diff --git a/.agents/docs/2026-10-24-implementation-checkpoints.md b/.agents/docs/2026-10-24-implementation-checkpoints.md
new file mode 100644
index 0000000..546da9c
--- /dev/null
+++ b/.agents/docs/2026-10-24-implementation-checkpoints.md
@@ -0,0 +1,45 @@
+# OpenCV mwrap implementation checkpoints
+
+## Source/interface separation checkpoint
+
+- Fork exists at mcpplibs/opencv-m; implementation branch retains commits.
+- Existing pinned upstream source moved to upstream/opencv without content changes.
+- Generated snapshots moved to generated; compatibility header moved to port/include/mwrap/opencv.
+- Root and submodule names changed to mcpplibs.mwrap.opencv; upstream cv API preserved.
+- Macro constants moved from cv into mcpplibs::mwrap::opencv::macros.
+- LLVM 23.1.3 baseline build passed (2747 units including the existing FFmpeg closure).
+- Existing test suite: six binaries passed; DNN/unifont gated cases require their feature runs separately.
+- Package revision 5.0.0.1 distinguishes this wrapper from the inherited v5.0.0 tag without changing upstream version.
+- Remaining: source/feature catalog split, additional modules, native GUI, ORT bridge, codecs/backends, full API audit, native CI and installed/template consumers.
+
+## Optional source catalog checkpoint
+
+- Generated per-platform source catalogs separate mandatory core, optional modules, codecs and video backends.
+- The root module aggregates only selected module interfaces; FFmpeg is a videoio-ffmpeg feature dependency.
+- Build-instance configuration and build information reflect the chosen JPEG/PNG features.
+- Linux LLVM 23.1.3 strict core-only and PNG/JPEG configurations passed all six test binaries. The image configuration executed both actual codec roundtrips; feature-disabled DNN/unifont binaries contain no cases and do not establish coverage for those capabilities.
+- CI now runs image codec features separately from core-only and DNN/unifont configurations.
+- mcpp engine is read-only. Its existing documentation/skill PR remains unmerged and is not a dependency of this work.
+- Native GUI, remaining main modules and ORT bridge remain implementation work; this checkpoint does not claim full support.
+
+## Aggregate module CI correction
+
+- Run 40010892459 exposed imports introduced through a header: GCC rejected them, while Windows built the library but consumers could not see the aggregate's core API.
+- The conventional src/opencv.cppm now directly re-exports core, macros and an internal selection module.
+- build.mcpp writes that selection module into its configuration-specific output and declares it with mcpp::generated before scanning. The generated file contains concrete imports for the selected features, with no header-induced or preprocessor-conditional imports.
+- Existing root-import API, header-mixing and codec tests exercise the aggregate from consumers; native Windows verification remains in CI.
+- This correction requires no mcpp engine changes.
+
+## Windows checkout newline correction
+
+- Reproduced the Windows selection problem locally by feeding CRLF versions of the tracked configuration files to the real build program: selected.cppm incorrectly contained no optional module imports.
+- Module and source catalog lines now strip CRLF carriage returns; cvconfig is normalized before optional codec definitions are disabled.
+- tools/test_build_config.py executes the compiled build program against LF and CRLF fixtures and verifies identical selected modules, source directives and codec configuration. It passed locally and is included in the Linux GCC CI job.
+- GCC 16 and musl static core-only tests passed, as did GCC 16 and LLVM 23 PNG/JPEG roundtrips after the aggregate correction. Windows core tests passed in run 40015097526; complete feature verification follows on the new CI head.
+
+## Executable quickstart and documentation checkpoint
+
+- tools/test_template.py invoked the actual mcpp installed-package template renderer, verified the qualified self.name/version dependency, then built and ran the generated candidate consumer under LLVM 23.1.3. It wrote a 64x64 out.png successfully. This is a staged-source template test, not a published archive installation test.
+- Added this actual template flow to the Linux LLVM CI leg.
+- English/Chinese README now describe current feature selection, module and macro names, verified coverage and unfinished native GUI/ORT/full-module work. Removed inherited full-featured claims and broken example links.
+- Package metadata now agrees with the existing Apache-2.0 root LICENSE, without replacing or relicensing the existing license file. The image example explicitly selects required PNG/JPEG features.
diff --git a/.agents/docs/2026-10-24-mwrap-repository-and-module-standard.md b/.agents/docs/2026-10-24-mwrap-repository-and-module-standard.md
new file mode 100644
index 0000000..0c906cb
--- /dev/null
+++ b/.agents/docs/2026-10-24-mwrap-repository-and-module-standard.md
@@ -0,0 +1,280 @@
+# mwrap 仓库、包与模块设计规范（评审稿）
+
+状态：Draft，等待用户 review。日期：2026-10-24。
+
+本轮只新增设计文档。组织 fork、创建仓库、改名、功能重构、发布和索引迁移均在评审后实施。
+配套方案：[OpenCV 与 ORT 实施设计](2026-10-24-opencv-5-full-and-onnxruntime-plan.md)。
+
+## 1. 定位与边界
+
+`mcpplibs` 顶层承载原生 C++ 模块项目；`mcpplibs.mwrap` 承载对已有 C/C++ 头文件库的模块化封装。
+`mwrap` = module wrapper，统一替代本类新项目的 `capi`、`cppapi` 分类。既有包按迁移计划逐个处理，不批量改写已发布版本。
+
+共同契约：保留上游公共实体、namespace、类型身份、调用方式与语义，增加命名模块入口。
+模块化无法原样携带的内容必须单独列出：宏、内部链接实体、依赖预处理配置的接口和 ABI 配置。
+不以“编译成功”代替公共 API 覆盖，也不将已声明的后端枚举当作可用实现。
+
+## 2. 命名规则
+
+| 层次 | 规则 | OpenCV | ONNX Runtime |
+|---|---|---|---|
+| Git 仓库 | `<upstream-name>-m` | `mcpplibs/opencv-m` | `mcpplibs/onnxruntime-m` |
+| package.namespace | `mcpplibs.mwrap` | 同左 | 同左 |
+| package.name | 单个原子名称，无 `-m` 后缀 | `opencv` | `onnxruntime` |
+| 完整包身份 | namespace + name | `mcpplibs.mwrap.opencv` | `mcpplibs.mwrap.onnxruntime` |
+| 根模块 | 同完整包身份 | `mcpplibs.mwrap.opencv` | `mcpplibs.mwrap.onnxruntime` |
+| 公共子模块 | 保留上游模块/头文件分组名称 | `mcpplibs.mwrap.opencv.core` | 有实际接口边界再增加 |
+| API namespace | 保留上游 | `cv::`、`cv::dnn::` | `Ort::`；C API 保持全局名称 |
+| 宏映射模块 | `<root>.macros` | `mcpplibs.mwrap.opencv.macros` | `mcpplibs.mwrap.onnxruntime.macros` |
+
+上游名称中不能用于模块标识符的字符使用稳定、可记录的规范化映射；不因仓库改名改变 API namespace。
+不创造 `mcpplibs::mwrap::opencv::Mat` 等替代 API，不主动将 C 全局函数搬入 namespace。
+不按 CUDA、GTK、ORT 等实现后端增加公共 API 模块，除非上游本身有可独立消费的接口。
+
+```toml
+[package]
+namespace = "mcpplibs.mwrap"
+name = "opencv"
+version = "5.0.0" # 与上游对齐；封装修订依次为 5.0.0.1、5.0.0.2
+
+[package.metadata.mwrap]
+upstream-version = "5.0.0"
+```
+
+```toml
+# 消费端
+[dependencies."mcpplibs.mwrap"]
+opencv = { version = "5.0.0", features = ["imgproc", "imgcodecs-png", "highgui-native", "dnn-onnxruntime"] }
+```
+
+以上 metadata 为本规范自定义记录，mcpp 不会替我们解释 `upstream-version`。
+namespace 是多段路径、name 是单段名称，遵守 mcpp 的包身份规则。
+
+## 3. 仓库范式：封装与上游分离
+
+```text
+<libname>-m/
+├── mcpp.toml                  # 封装包身份、features、依赖、targets
+├── build.mcpp                 # 按需生成配置、派生 TU 和资源
+├── .xlings.json               # 固定经过验证的最新稳定 mcpp
+├── upstream/
+│   ├── sources.lock.toml      # 来源、tag/commit、归档 SHA256、许可证
+│   ├── README.md              # 获取/导入/更新流程，裁剪规则
+│   └── <libname>/             # vendored 原始源码（仅需要时存在）
+├── patches/
+│   ├── series                 # 有序补丁；没有补丁也明确记录
+│   └── README.md              # 原因、影响、上游 issue、移除条件
+├── port/
+│   ├── include/               # 适配头、宏兼容头
+│   ├── src/                   # 必需的替换实现和平台适配
+│   └── config/                # 配置模板、模块与后端依赖清单
+├── src/
+│   ├── <libname>.cppm         # 公共根模块，满足 mcpp lib-root 约定
+│   ├── macros.cppm
+│   └── modules/               # 公共子模块与必要的内部 partition
+├── generated/                 # 可复现、确有必要提交的稳定生成物
+├── tools/                     # 同步、生成、公共 API 审计工具
+├── tests/
+│   ├── surface/               # 导出、类型身份、宏等价性
+│   ├── behavior/              # 真实功能
+│   └── consumers/             # 头文件混用、模块共存、安装后消费
+├── examples/
+├── docs/
+└── .agents/docs/
+```
+
+`tests/` 的子目录是本规范布局；须由测试 targets 或受控发现规则接入，不假定目录移动后 mcpp 自动执行全部测试。
+构建期、按 feature 变化的文件进入 mcpp 输出目录；不能写回共享 `generated/` 或修改 `upstream/`。
+公开头文件通过 include_dirs 暴露；上游内部头与生成配置保持私有，确有消费者需求的配置另行定义契约。
+
+参考 openkal-musl 的实质是三种内容分离：`musl/`（上游）、`port/`（适配）、`musl-generated/`（可复现生成物），
+以及修改/排除理由可追溯。这里统一到 `upstream/`，不照搬它的 libc 移植语义。
+
+## 4. 上游实现的三条接入路线
+
+| 路线 | 使用条件 | 要求 |
+|---|---|---|
+| `compat.<lib>` | 已有可复用的传统库包，配置和 ABI 足够 | 封装仅依赖它，不复制源码/二进制，不重复编译实现 |
+| vendor 到 `upstream/<lib>/` | 复杂配置、SIMD、生成代码、平台后端需要本仓库组织 | 固定来源和裁剪清单，源码与 port 分离，所有修改可审计 |
+| 预编译 SDK | 上游构建复杂且官方有合适 SDK，如首版 ORT | 平台/ABI/provider/运行库清单、hash 和许可明确；不承诺无产物目标可用 |
+
+`compat` 是传统实现供应者，`mwrap` 是模块接口供应者。一个程序中的同一实现必须只有一个所有者。
+不为了形式统一强制新增 `compat.opencv`；当前复杂的 OpenCV 构建可保留源码所有权。
+不将 build.mcpp 变成下载器，依赖获取由包/索引/provider 管理；源码预处理通过有输入输出的 action 表达。
+若依赖 CMake，在 CI 构建包时或明确声明的构建步骤中使用，必须说明与“消费端无需 CMake”的区别。
+
+## 5. 模块与导出契约
+
+1. 封装层优先使用上游实体的 `export using`；不复制公共类或重新定义同名类型。
+2. 每个实体有一个导出归属，根模块 `export import` 当前启用的公共模块。
+3. 子模块可单独 import，并能组合 import；不通过偶然的传递头文件获得未声明能力。
+4. root 与可选模块闭包由模块清单生成，打包后的公共模块集合与源码消费一致。
+5. `static inline` 等确需替换时，记录单独清单；验证语义、ADL、重载与头文件混用，不默默裁剪。
+6. 审计范围取上游公共 C/C++ 头文件，Python 绑定标记只能作为生成器输入之一。
+7. 内部实现使用 partition 或未公开模块；根模块不能意外把内部接口带入发布闭包。
+
+## 6. 宏的模块化映射
+
+`.macros` 是命名模块，不是预处理器宏的传输通道。
+推荐映射 namespace：`mcpplibs::mwrap::<libname>::macros`，保留宏的原始名称。
+宏映射是有意新增的 API 面，与保持上游 namespace 的普通实体分开管理。
+
+```cpp
+import mcpplibs.mwrap.opencv;
+import mcpplibs.mwrap.opencv.macros;
+namespace ocvm = mcpplibs::mwrap::opencv::macros;
+
+cv::Mat image(64, 64, ocvm::CV_8UC3);
+static_assert(ocvm::CV_MAKETYPE(ocvm::CV_8U, 3) == ocvm::CV_8UC3);
+```
+
+| 上游宏种类 | 映射方式 |
+|---|---|
+| 数值、字符串等对象式宏 | 类型明确的 inline constexpr；先在 GMF 中捕获值，再 undef，避免声明被展开 |
+| 可保持语义的计算宏 | constexpr 函数，记录整数提升、求值次数、返回类型等差异 |
+| `#if`、token 拼接、字符串化、注解/导出属性 | 兼容头文件保留原始宏 |
+| 断言/日志/控制流宏 | 默认保留宏；只有调用位置、求值和控制流契约可证明时才增加具名辅助函数 |
+
+不承诺所有宏都可映射；尤其普通函数不能自动保留 CV_Assert 的表达式字符串化与调用点信息。
+兼容头建议 `<mwrap/<libname>/macros.hpp>`，在 import 前包含。测试对象式宏存在时对 qualified 名字的展开冲突；
+不能认为加 namespace 就能规避预处理器。文档分别展示纯模块映射用法与原始宏用法，避免同一 TU 直接混用冲突名称。
+旧 `cv::CV_*` 常量属于已有封装扩展，迁入新包时转到 `.macros`；旧身份冻结兼容，不继续向上游 namespace 添加宏替身。
+
+## 7. feature、平台和运行时
+
+使用 mcpp 的 implies、forward、feature-deps、cfg(target) 和 build.mcpp action。
+feature 表达增加能力，依赖图同一包的请求取并集；不能设计靠依赖路径获得不同 ABI 的相反配置。
+仅需启用的外部库放 `[feature-deps.<feature>]`，链接参数由实现供应者携带。
+真正互斥的供应者通过明确变体/依赖图约束处理；capability 可以做选择，但不会移除其他已引入包的对象文件，
+也不会自动发现 SDK 或保证兼容。同名符号的两份运行库必须在进入最终链接图前避免同时引入。
+
+### 7.1 feature 命名规范
+
+feature 使用小写 kebab-case，优先复用上游模块、后端、依赖的正式名称。
+
+| 类别 | 规则 | 示例 |
+|---|---|---|
+| 上游模块 | `<module>` | dnn、highgui、videoio、stitching |
+| 模块的后端/可选依赖 | `<module>-<backend-or-library>` | highgui-gtk3、videoio-ffmpeg、dnn-onnxruntime |
+| 模块的图像格式 | `imgcodecs-<format>` | imgcodecs-jpeg、imgcodecs-tiff |
+| 跨模块加速依赖 | 使用正式名称 | opencl、tbb、ipp、lapack |
+| contrib 模块 | `contrib-<upstream-module>` | 以固定上游版本的实际模块名为准 |
+| 模块全集 | `all-modules` | 仅表达主仓库模块集合，不承诺所有后端/SDK |
+
+不在公共接口混用 gui/highgui、codec/imgcodecs、ort/onnxruntime；正式 feature 使用上游可识别名称。
+native 可作为有精确 target 映射表的便利开关，如 highgui-native；显式 backend 名仍保留。
+未支持的目标、缺失供应者和互斥后端组合在配置阶段给出明确错误，不静默忽略用户选择。
+default 的展开写入版本化清单；不把 desktop/full 等没有唯一含义的名称作为基础能力分类。
+已通过 E2E 126/127 核实：当前 pinned mcpp 支持依赖边的 default-features=false，显式 features 仍激活；
+不支持的是根项目 --no-default-features CLI。其他依赖边仍可请求默认项。最小默认集合是本规范的产品选择，不是客户端限制。
+OpenCV 新包建议 default=[]、core 为必需基础，其余模块与实现显式启用；常用体验由模板列出所需 features。
+同名 feature 不得在不同修订中无说明地改成其他执行后端。
+
+### 7.2 索引分类布局
+
+描述符统一置于 `mcpp-index/pkgs/mwrap/<full-package-name>.lua`，测试置于 `tests/mwrap/`。
+不再增加首字母子目录。Git 源码与发布归档保持同一布局，不生成到 pkgs/m 的转换副本。
+已核查 mcpp v2026.10.21.1：身份查找的 fallback 扫描 pkgs 下一级目录，子目录名不要求是单个字母；
+因此 pkgs/mwrap 是与现有扫描深度相容的分类，根目录 mwrap/o 则不在该查找路径内。
+发布脚本原本复制整个 pkgs，可直接保留新目录；lint、测试选择器、站点和 provider 仍须做集成验证。
+即使部分脚本的 pkgs/*/*.lua glob 已能覆盖，也要核查是否存在目录名必须单字母的额外假设。
+不因包装层分类而扩大客户端索引协议，也不为保持首字母分桶维护第二份 descriptor。
+
+### 7.3 测试责任
+
+Linux 优先本地执行，CI 重跑发布关键组合；Windows 与 macOS 由 CI 覆盖。
+CI 的编译、链接、功能执行和安装后消费分别报告；桌面/设备/GPU 不可用时明确未执行项。
+所有平台使用同一测试入口、feature 展开和固定工具版本，不能靠平台专属的临时脚本掩盖配方差异。
+设计文档检查与实现验证分别报告；本轮更新规范并不表示上述平台功能已通过运行验证。
+
+配置身份至少覆盖 target triple、工具链/stdlib、linkage、feature 闭包、上游版本和适配补丁。
+公共布局、异常/RTTI、运行时、CPU baseline 必须一致；SIMD 编译选项限定在实现 TU，不污染公共 BMI。
+宿主工具和目标库分开；不以构建宿主 OS 替代目标平台判断。
+预编译库需要测试动态加载的 provider、数据和插件；它们未必出现在普通链接依赖扫描结果中。
+
+### 7.4 每个 -m 库必须提供快捷模板
+
+每个以 -m 命名并发布的模块封装库至少提供一个可运行的默认 mcpp 项目模板，位于 templates/<name>/。
+模板通过完整包身份调用，例如 `mcpp new vision --template mcpplibs.mwrap.opencv@5.0.0`。
+多个模板使用 `:<template>` 选择，并通过 `mcpp new --list-templates <package>@<version>` 列出。
+模板保持纯数据，使用 mcpp 支持的 placeholder，不运行脚本或隐藏下载步骤。
+依赖版本取 self.version；当前 self.name 已是完整包选择器，使用带引号的单个 key，不再额外套 namespace 表；生成项目明确列出所需 features。
+默认模板不要求摄像头、GPU、桌面或用户另行下载模型；可选高级模板单独提供。
+模板必须经过真实 mcpp new、build、run/test 验证，发布归档必须包含 templates/；静态 placeholder 检查不代替运行。
+
+## 8. 版本和发布
+
+**用户已确认的规范：封装版本与上游版本对齐，最多追加一个数字修订尾号。**
+
+| 发布场景 | 上游版本 | mwrap 包版本 |
+|---|---|---|
+| 首次封装 | 5.0.0 | 5.0.0 |
+| 同一上游的第一次封装修订 | 5.0.0 | 5.0.0.1 |
+| 同一上游的后续封装修订 | 5.0.0 | 5.0.0.2、5.0.0.3…… |
+| 升级到下一个上游版本 | 5.0.1 | 5.0.1，修订计数重新开始 |
+
+不维护独立的 0.x 封装版本线；不使用 5.0.1 表示“仍为 5.0.0 的封装修复”。
+修订 N 从 1 开始，不发布 `.0`：mcpp 将缺失数字段当作零，5.0.0 与 5.0.0.0 会排序相等。
+同一个上游版本最多增加一个修订段，不能出现 5.0.0.1.1。
+不使用 `+build` 承担升级排序，也不把正式封装修订标成 `-mwrap.1` 预发布版本。
+metadata 与 sources.lock 仍明确固定上游版本、commit/hash；尾号仅表示封装/配方修订。
+对上游本身为多段数字的版本，同样只允许追加一个数字段；上游预发布或非数字版本须显式记录映射规则，不能改变上游版本含义。
+
+已核查 mcpp v2026.10.21.1 的 version_req 实现：支持任意长度数字段，逐段数值比较，
+故 5.0.0 < 5.0.0.1 < 5.0.0.2 < 5.0.1 可表达。发布验收还需覆盖 provider、索引、lockfile 与更新链路。
+该格式是 mwrap 的版本约定，不称为严格的三段 SemVer。
+消费端精确选择已发布字面版本；希望自动接受同一上游的修订时，显式使用 `>=5.0.0, <5.0.1`，
+不能把普通 `^5.0.0` 当成只允许封装修订（它可允许后续上游 5.x）。
+
+模块重命名、导出删除、宏映射迁移等破坏性变化必须发布说明和迁移表；尾号不是隐瞒破坏性变化的理由。
+本次包身份已切换到 mcpplibs.mwrap，原 opencv.opencv@5.0.0 保留不变；新身份可从 5.0.0 开始。
+
+上游源码、适配层和发布产物分别记录 hash。发布附模块/feature/平台/API 覆盖矩阵及第三方许可证。
+二进制包带接口源码和库，不分发依赖特定编译器构建的 BMI。
+
+## 9. 迁移原则
+
+新身份发布前先通过干净消费者验证。旧包/版本的地址与 hash 保持不可变。
+`opencv.opencv`、旧 `mcpplibs.capi.*` 可冻结留存并提示替代身份。
+如提供旧 import 转发，只做 export import，不重复实现；是否默认携带由兼容测试决定。
+同一程序同时引入旧、新实现供应者必须诊断或明确禁止，不能仅靠转发模块掩盖重复链接。
+
+## 10. 实施基线与参考
+
+2026-10-24 通过 GitHub Releases API 核实最新稳定 mcpp 为 `2026.10.21.1`。
+实施开始再次核实；若更新，统一变更 .xlings.json、CI、模板和文档并验证，提交中固定确切版本，不跟随浮动 latest。
+后续已按用户要求更新本地相关仓库到远端 main；提交、原目录保护与复核结果见配套实施方案 §1.2。
+其中 mcpp main 已标记 2026.10.22.1，发布 API 确认版本仍为 2026.10.21.1，两者不混为一谈。
+
+规范定稿后，正式维护位置为 mcpp-index/docs/mwrap.md；本文件保留为设计评审记录。
+同步更新索引的 add-mcpp-index-package skill 与 mcpp-usage skill，示例和模板链接正式规范。
+技能更新细项见配套方案 P7，规范确认前不提前改动其他仓库的指引。
+
+- [mcpp features / feature-deps](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/docs/06-features-and-capabilities.md)
+- [mcpp workspace](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/docs/07-workspace.md)
+- [mcpp 预编译库分发](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/docs/12-binary-distribution.md)
+- [mcpp 数字段版本比较](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/modules/versioning/src/version_req.cppm)
+- [mcpp build.mcpp](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/docs/30-build-mcpp.md)
+- [mcpp 描述符发现与 path 索引](https://github.com/mcpp-community/mcpp/blob/v2026.10.21.1/src/pm/package_fetcher.cppm)
+- [openkal-musl](https://github.com/mcpplibs/openkal-musl)：本地核查 musl/、port/、musl-generated/ 和补丁记录。
+- 当前仓库实际模块导出与宏实现：src/core.cppm、tools/gen_exports.py、include/mwrap/opencv/macros.hpp。
+
+## 11. 需要 review 的决策
+
+1. 接受完整公共前缀 `mcpplibs.mwrap.<libname>`，不把 `-m` 带入包名与模块名。
+2. 接受“compat 优先复用、复杂库 upstream/vendor、ORT 首版预编译 CPU”的实现分层。
+3. 接受宏映射独立 namespace 和原始宏兼容头双入口。
+4. 已确认：包版本与上游一致，最多追加一个从 1 开始的封装修订尾号；不发布 `.0`。
+5. 接受旧身份冻结、新身份切换，兼容入口不形成第二份实现。
+6. 索引使用 pkgs/mwrap 平铺描述符与 tests/mwrap 分类，无 staging 路径转换。
+7. feature 沿用上游模块/后端名称，Linux 本地验证，Windows/macOS CI 覆盖。
+
+## README 与本地验证资源补充规范
+
+所有 xxx-m 仓库的根 README 使用统一简洁风格，原则上每种语言不超过 100 行。
+保留一句定位、快捷模板、最小依赖/import 用法、关键平台边界与文档/许可入口；
+架构、完整矩阵、后端细节、排错和验证记录放到 docs/，不以超长行或删除必要前提凑行数。
+
+本地测试及依赖构建、编译器、代码生成和 AST 子进程的合计 CPU/内存占用不得超过
+本机有效资源的 80%，默认预留更多余量；限制总并发并监测资源，不停止用户的其他进程。
+正式中英文规范与 package-authoring skill 同步维护于 mcpp-index。
diff --git a/.agents/docs/2026-10-24-opencv-5-full-and-onnxruntime-plan.md b/.agents/docs/2026-10-24-opencv-5-full-and-onnxruntime-plan.md
new file mode 100644
index 0000000..47b0fc3
--- /dev/null
+++ b/.agents/docs/2026-10-24-opencv-5-full-and-onnxruntime-plan.md
@@ -0,0 +1,507 @@
+# OpenCV 5.0.0 全面支持、ORT 与 mwrap 索引迁移设计（实施基线）
+
+状态：Implementation，用户已授权实现、测试、每仓库一个 PR 与 checkpoint commits。日期：2026-10-24。
+规范：mcpp-index 的 `docs/zh/mwrap.md`，候选规范见 [索引 PR #564](https://github.com/mcpplibs/mcpp-index/pull/564)。
+实施进度、命令证据与剩余门槛见 [验收记录](2026-10-24-readiness-audit.md)。
+第 1 节保留设计评审时的历史基线；随后已获授权实施。mcpp 引擎源码只读，文档 PR #836 不合入，也不作为库项目的前置条件。
+已确认：版本跟随上游，最多追加一个数字封装修订尾号，例如 5.0.0 → 5.0.0.1。
+
+## 1. 本轮交付与后续实施边界
+
+本轮交付两份设计文档，不修改现有产品代码、工具版本、远端仓库或索引。
+评审后将 `Sunrisepeak/opencv-m` fork 到 `mcpplibs/opencv-m`，创建 `mcpplibs/onnxruntime-m`，
+并在 mcpp-index 新增独立 mwrap 描述符目录和测试目录。
+GitHub API 本轮对两个目标仓库返回 404；这仅表示当前查询不可见，不能据此断言组织权限或全局不存在。
+实施时检查目标存在性、权限和 fork 状态：存在则复用核验，不覆盖或误建第二个仓库。
+
+### 1.1 本地工作区优先
+
+用户已确认 mcpp、mcpp-index 与 mcpplibs 均有本地目录；实现与联调优先复用这些 checkout。
+
+| 对象 | 本轮实际检查的本地路径 |
+|---|---|
+| mcpp | /home/speak/workspace/github/mcpp-community/mcpp |
+| mcpp-index | /home/speak/workspace/github/mcpp-community/mcpp-index |
+| mcpplibs 工作区 | /home/speak/workspace/github/mcpplibs |
+| 分层参考 | /home/speak/workspace/github/mcpplibs/openkal-musl |
+| provider/loader 辅助检查 | /home/speak/workspace/github/openxlings/xlings、/home/speak/workspace/github/mcpplibs/libxpkg |
+
+本机另有 mcpplibs 下的 mcpp-index checkout 与多个工作树，实施前核对各自分支、未提交修改和目标远端，
+选定一个索引工作树实施，不在多个 checkout 间重复迁移。库目录本身不是一个统一 Git 仓库。
+源码、文档和调用链优先本地读取；仅在确认已发布版本、官方 SDK 或上游差异时查询远端。
+Linux 联调通过本地包依赖与本地索引完成，另做发布归档消费测试，不用远端现成包替代本地变更验收。
+用户随后明确要求切换 main 并更新远端，已执行 fetch 与 fast-forward；未修改这些仓库的产品代码。
+fork、创建组织仓库和功能重构仍属于设计评审后的实施阶段。
+
+### 1.2 更新远端 main 后的复核基线
+
+为避免功能分支或旧源码误导，以下基线均在 fetch origin main 后核查，HEAD 与 origin/main 一致：
+
+| 仓库 | 最新 main 提交 | 本次使用方式 |
+|---|---|---|
+| mcpp | 4c80028c147b6827d78a2fe9ca3e0e41faf1b721 | 原目录 main 快进；保留原有未跟踪文件 |
+| 选定的 mcpp-index | 18b7b056a4843da948b5fdd6ed3e04a91584dd00 | 原目录从功能分支切 main 并快进；原分支保留 |
+| openkal-musl | 7fe6d886643fa4634f0c55bedc415234e3150239 | 原目录 main，远端无新增 |
+| libxpkg | 5523780abfedf1e1e06d8b42a077fd76a70f284e | 原目录有未跟踪 lockfile，恢复原分支；在 /tmp/mwrap-design-review-20261024/libxpkg 的干净 main worktree 快进 |
+| xlings | 66c5cbf6 | 原目录有未提交改动，保持原状；在 /tmp/mwrap-design-review-20261024/xlings 的干净 main worktree 快进 |
+
+mcpp main 的版本字段已是 2026.10.22.1；本轮 GitHub Releases API latest 仍返回 v2026.10.21.1。
+源代码 main 与已确认发布的客户端分开记录：实现 pin 使用可获取、可验证的最新稳定发布，实施前再次查询。
+已比较 mcpp 发布 tag 与更新后的 main：描述符发现代码和 features 文档没有差异，本方案相关结论保持成立。
+更新后的 libxpkg 0.0.66 在 src/xpkg-loader-boundary.cpp 中仍枚举 pkgs 的一级分类目录，且显式处理包身份。
+未更新另一份 mcpplibs/mcpp-index 功能分支 checkout；本轮只选定一个索引工作树作为权威实现对象。
+
+## 2. 已核实的起点
+
+| 项目 | 当前事实 | 重构要求 |
+|---|---|---|
+| 包身份 | namespace=opencv，name=opencv，version=5.0.0 | 新包 `mcpplibs.mwrap.opencv` |
+| 模块 | opencv / opencv.cv / opencv.<mod> | 公共前缀统一为 mcpplibs.mwrap.opencv |
+| mcpp | .xlings.json 固定 2026.8.5.4 | 迁移到已核实最新稳定 2026.10.21.1；实施前复核 |
+| 源码 | 裁剪导入 8 个主模块 | 补齐主仓库 C++ 模块，单独导入 contrib |
+| GUI | config 中 backend=NONE | Win32 / Cocoa / GTK 原生窗口 |
+| DNN | 可选 dnn，含 ONNX 导入、ENGINE_ORT 导出 | ORT 未启用，必须接入真实运行库 |
+| 宏 | 部分常量被放入 cv::，另有宏兼容头 | 独立 .macros 模块与宏映射 namespace |
+| 导出生成 | Python 标记 + curated，跳过部分头/namespace | 完整 C++ API 清单审计，不能静默 prune 成“完整” |
+| 构建配置 | 固定 generated/<os> 快照，build.mcpp 注入部分文件 | 由 feature 与 target 生成配置，移除过时语法限制 workaround |
+| 索引 | pkgs/o/opencv.opencv.lua；tests/examples/opencv-module* | mwrap 分类与配套 CI/发布发现迁移 |
+
+已对照官方 5.0.0 tag 的 modules 目录；不能用 OpenCV 4 的 calib3d/features2d 等名称直接作为本次模块清单。
+
+## 3. “全面支持”的验收定义
+
+全面支持指：OpenCV 5.0.0 主仓库公共 C++ API、可选后端和模块依赖均有明确覆盖状态，
+支持项可以由 feature 选择并在声明的平台验证；不能将所有 SDK 和互斥后端强制放进一个构建。
+
+分别维护四张矩阵，避免以一个 full 开关掩盖缺失：
+
+1. **源码模块矩阵**：模块是否导入、可构建、可单独 import、根模块是否聚合。
+2. **API 矩阵**：公共实体、宏、内部链接适配、缺失项与原因。
+3. **运行能力矩阵**：窗口、编解码、视频、推理 provider、加速是否实际运行。
+4. **目标矩阵**：target triple、工具链、linkage、配置组合及验证状态。
+
+Python/Java/JS/ObjC 绑定、样例工具、ts 测试框架、world 聚合库不作为 mwrap C++ 首轮验收的必需产物。
+world 的使用体验由根模块聚合提供，不再重复构建第二套全部实现。
+contrib 是独立工作包，未验证前不能宣称 contrib 全支持。
+硬件/专有 SDK 项可以阶段性交付，但必须标为 planned / unavailable，而非笼统宣称已全功能。
+
+## 4. 仓库划分与布局
+
+### 4.1 mcpplibs/opencv-m
+
+```text
+opencv-m/
+├── mcpp.toml / build.mcpp / .xlings.json
+├── upstream/
+│   ├── sources.lock.toml
+│   ├── README.md
+│   ├── opencv/                 # 固定官方 5.0.0
+│   └── opencv_contrib/         # 后续导入匹配 tag/commit
+├── patches/                    # 最小、可重放补丁及原因
+├── port/
+│   ├── config/                # 模块图、后端配置模板、平台规则
+│   ├── include/mwrap/opencv/  # 原始宏兼容头
+│   └── src/                   # 必需的替换函数和平台适配
+├── src/
+│   ├── opencv.cppm            # export module mcpplibs.mwrap.opencv;
+│   ├── macros.cppm
+│   └── modules/<name>.cppm
+├── generated/                 # 稳定生成物；配置相关产物进构建输出目录
+├── tools/                     # import、config、exports、coverage
+├── tests/{surface,behavior,consumers}/
+└── examples/
+```
+
+OpenCV 适合保留 vendor 路线：SIMD dispatch、DNN、平台后端、contrib 与生成配置紧密关联。
+无需为了分层新增不可独立维护的 compat.opencv。
+FFmpeg、codec、TBB、ORT 等复用独立供应者，逐项核实 compat 包可用性。
+上游/适配/生成层分开；升级时重新导入上游再重放补丁，生成 diff 和 API 覆盖差异供 review。
+裁剪仅限非目标产物，并记录清单；不能在“源码裁剪”阶段删除后续 feature 所需代码。
+
+### 4.2 mcpplibs/onnxruntime-m
+
+独立提供 `mcpplibs.mwrap.onnxruntime`，保留 `Ort::` 和 C API。
+首版采用匹配版本的官方 CPU SDK，不将大二进制提交 Git；头文件与 SDK 必须同版本。
+包来源、产物地址、SHA256、ABI、最低系统要求、license 和 provider 清单进入供应者记录。
+
+优先评估创建/复用 `compat.onnxruntime` 作为传统 SDK 供应者：
+
+```text
+mcpplibs.mwrap.onnxruntime（模块接口）
+  └── compat.onnxruntime（头文件、import library、运行库）
+
+mcpplibs.mwrap.opencv --feature dnn-onnxruntime
+  └── mcpplibs.mwrap.onnxruntime
+       └── compat.onnxruntime
+```
+
+OpenCV 的 ORT 实现 TU 使用供应者的原始头与 C API 链接，无须在上游源码里 import 封装模块。
+实施时验证 mwrap 包能正确携带供应者所需的公开 include/link/runtime 信息。
+若需要 feature 依赖可见性调整，必须在消费者测试中确认，不能只测包内链接。
+若平台 SDK 不能以 compat 配方表达，保留独立 SDK 供应者实现，不把下载逻辑塞入模块文件。
+
+先覆盖 Linux x86_64 GNU、Windows x86_64 MSVC ABI、macOS arm64。
+musl、MinGW 和其他架构需要独立产物与 ABI 验证，不能复用 glibc/MSVC 产物后声称已支持。
+GPU/provider 第二阶段加入：记录 ORT、CUDA/cuDNN/TensorRT 等版本约束，防止 CPU/GPU 包携带两份同名运行库。
+ORT 有自己的 provider 支持，不等于 OpenCV 的 ORT wrapper 自动暴露了所有配置接口，两条路径分别验证。
+
+## 5. OpenCV 模块与 feature 设计
+
+根模块为 `mcpplibs.mwrap.opencv`，公共子模块遵循 `mcpplibs.mwrap.opencv.<upstream-module>`。
+宏映射入口为 `mcpplibs.mwrap.opencv.macros`。
+
+| 分组 | 上游模块 / feature | 当前状态与目标 |
+|---|---|---|
+| 基础 | core、imgproc、imgcodecs、flann、geometry | 已有基础，审计完整导出与依赖 |
+| 交互与视频 | highgui、videoio | 已有接口，补真实窗口/原生采集 |
+| 推理 | dnn | 已可选，补 ORT 和后端能力矩阵 |
+| 主模块补齐 | calib、features、objdetect、photo、ptcloud、stereo、stitching、video | 当前未导入，按实际依赖闭包补齐 |
+| 扩展 | contrib-<name> | 固定匹配来源，逐模块开放 |
+
+算法模块依赖从实际上游 CMake/公共头抽取成显式图，不凭印象手写并长期维护两套。
+模块图作为 sources、features、config、根模块和审计报告的共同输入。
+
+### 5.1 命名依据：上游模块、后端与格式
+
+feature 使用小写 kebab-case。模块名直接对应 OpenCV 5，后端/格式使用上游开发者熟悉的名字。
+上游 CMake 的 WITH_* / HAVE_* 与 mwrap feature 建立显式映射，但不把 HAVE_* 直接暴露成用户配置。
+
+| 层次 | feature 示例 | 语义与依赖 |
+|---|---|---|
+| 算法模块 | calib、features、objdetect、photo、ptcloud、stereo、stitching、video、dnn | 启用同名模块及其依赖闭包 |
+| GUI 模块 | highgui | 启用 highgui API；单独选择不承诺窗口后端 |
+| GUI 后端 | highgui-win32、highgui-cocoa、highgui-gtk3、highgui-qt6、highgui-wayland | implies highgui，启用明确的窗口实现及依赖 |
+| GUI 便利开关 | highgui-native | 按目标展开为 win32 / cocoa / gtk3，具体映射版本化 |
+| 图像格式 | imgcodecs-jpeg、imgcodecs-png、imgcodecs-tiff、imgcodecs-webp、imgcodecs-openexr、imgcodecs-jpeg2000、imgcodecs-avif、imgcodecs-jpegxl | implies imgcodecs，按图像格式组织；JPEG2000 首选 OpenJPEG 供应者 |
+| 视频模块 | videoio | 启用公共视频 I/O 接口及其基础实现，不等于已支持摄像头或所有容器 |
+| 视频后端 | videoio-ffmpeg、videoio-gstreamer、videoio-v4l2、videoio-msmf、videoio-dshow、videoio-avfoundation | implies videoio；名字对应上游后端 |
+| 原生采集便利开关 | videoio-native | Linux→v4l2，Windows→msmf，macOS→avfoundation；不暗示任意目标可用 |
+| DNN 引擎/后端 | dnn-onnxruntime、dnn-openvino、dnn-cuda | implies dnn，分别引入 SDK 和实现；执行引擎仍由上游运行 API 选择 |
+| 跨模块加速 | opencl、opengl、tbb、ipp、lapack、eigen | 开启相应构建能力；必须记录影响哪些模块，不能承诺其名称代表全部 API 均加速 |
+| 扩展模块 | contrib-<upstream-module> | 启用匹配版本的实际 contrib 模块与依赖 |
+| 字体 | unifont | 保留当前精确含义，Unicode 内嵌字体 |
+
+这些是统一命名表和待实施范围，未实现项不提前注册成空 feature，也不标成 supported。
+正式名采用 dnn-onnxruntime，文档可将 ONNX Runtime 简称 ORT；不再同时引入 dnn-ort、gui、codec-* 等同义新名称。
+当前尚未发布上述旧提案名称，不需要为它们建立永久别名。
+GTK 与 Qt 分别用 gtk3、qt6 标明首个支持的主版本；未来主版本变化增加独立名称并记录兼容性。
+
+highgui-native 的 native 表示本包的平台默认实现，不表示 GTK 属于 Linux 内核或所有桌面环境。
+它总是增加已记录的默认后端；显式选择 Qt 不会偷偷关掉默认后端。
+上游支持多个后端共存时，保留其上游选择机制；不支持共存的组合在配置时拒绝并给出冲突来源。
+不能仅凭注册表列出了 GTK/Qt/Win32 就认为当前构建方案支持多后端共存。
+
+### 5.2 默认集合、模块全集与能力边界
+
+不提供语义含混的 desktop/full feature。全面支持是交付目标，通过模块与后端的覆盖矩阵验收。
+提供以下可审计集合：
+
+- `default = []`：core 为必需基础，其他模块与外部后端均显式启用。
+  这是可预测、低依赖的产品默认选择。已运行 E2E 126/127 确认 pinned mcpp 支持依赖边 default-features=false，
+  与根项目没有 --no-default-features CLI 不同。
+  imgproc、imgcodecs、flann、geometry、videoio 等作为模块 feature，依赖闭包自动包含 core。
+  常用模板替用户列出 imgproc、imgcodecs-jpeg、imgcodecs-png；视频模板再增加 videoio-ffmpeg。
+  这是新包身份下有意的最小默认策略，与旧包的默认能力不同，需要迁移表。
+- `all-modules`：固定版本主仓库全部公共 C++ 算法/功能模块的集合，包括 dnn、highgui、videoio，排除语言绑定、ts、world。
+  它增加公共模块，不隐式增加所有 codec、GUI、GPU SDK 或 contrib。
+- 窗口使用显式选择 `highgui-native` 或对应 highgui 后端；根模块仅聚合已经启用的接口。
+- 特殊 codec、contrib、硬件后端独立选择，不用“自动全开、不可用就跳过”掩盖能力缺口。
+
+新身份的 default 不再聚合无实际窗口后端的 highgui，避免用户默认拿到 imshow 占位实现。
+仅启用 highgui 或 all-modules 而未选择窗口后端时，配置摘要明确输出“highgui API enabled; window backend: NONE”，
+文档不把该组合标为窗口支持；使用窗口的例子必须声明 highgui-native 或具体后端。
+
+用户组合示例（已实现并发布相关 feature 后可用）：
+
+```toml
+[dependencies."mcpplibs.mwrap"]
+opencv = { version = "5.0.0", features = ["imgproc", "imgcodecs-png", "highgui-native", "dnn-onnxruntime", "imgcodecs-tiff"] }
+```
+
+最小消费者不选择可选 feature；其他默认集合的包允许通过依赖边 default-features=false 关闭该边默认项。
+根项目不提供 --no-default-features CLI。发布案例逐项声明所需模块与后端，其他依赖边仍可要求默认项。
+多个依赖请求按 feature 并集合并，禁止基于调用依赖路径生成两套相同包身份的不同公共 ABI。
+未支持的目标、缺 SDK、缺 provider 产物、互斥后端在配置阶段明确报错，不静默降级。
+所有 feature 的展开清单与能力报告一起版本化，改动进入封装修订说明。
+
+### 5.2.1 ONNX Runtime 包的 feature
+
+onnxruntime-m 默认使用 CPU SDK，保留 CPU provider；首版不提供无实现的 GPU 开关。
+后续 provider 采用上游习惯名 cuda、tensorrt、coreml、directml、openvino，并维护平台/SDK/产物矩阵。
+启用 provider 需要匹配运行库和实际可用的 API；CPU/GPU 主库互斥变体由供应者处理，不能叠加两份 onnxruntime。
+OpenCV dnn-cuda 是 OpenCV 经典 CUDA 后端，与 ORT cuda provider 是两个能力，不能相互隐式启用。
+dnn-onnxruntime 首版只承诺 ORT CPU；以后若增加 provider 转发，必须先证明 OpenCV wrapper 暴露了对应选择能力。
+
+### 5.3 DNN 运行示例（目标接口）
+
+```cpp
+import mcpplibs.mwrap.opencv.dnn;
+auto net = cv::dnn::readNetFromONNX("model.onnx", cv::dnn::ENGINE_ORT);
+```
+
+必须真实验证 ORT 被调用：当前上游在未编入 ORT 时可能警告并回退 ENGINE_AUTO。
+包测试不能只断言 net 非空；需结合受控日志/测试观测点或 ORT 实际调用证据，区分回退。
+另有直接 import onnxruntime 并以 Ort::Session 推理的消费者测试，覆盖独立包价值。
+不假设 ENGINE_NEW 已支持 GPU；OpenCV 原生 DNN 与 ORT provider 的能力分别说明。
+
+## 6. 构建与 API 重构
+
+1. 使用最新固定 mcpp，先验证旧功能基线，再删除已无必要的 Windows TU stub 和旧语法 workaround。
+2. 生成 cfg 相关 include dirs / sources / flags；可声明的内容留 manifest，生成步骤用 build.mcpp action。
+3. 把 target、feature 闭包、ABI 与上游 pin 纳入生成输入和缓存身份，输出只写 mcpp 输出目录。
+4. 特别处理 Objective-C++ Cocoa 源码、CUDA、NASM、SIMD dispatch 与宿主代码生成工具。
+   标准中列为必验集成点，不假定最新 mcpp 已自动覆盖全部语言/规则。
+   若现有规则不足，先做最小验证，再选择声明的工具/rule package 或构建动作，并提出可复现的 mcpp 缺口。
+5. 生成 opencv_modules.hpp、cvconfig、highgui config、DNN 配置、dispatch TU 和聚合模块。
+6. 编译上游头文件消费者与 module 消费者的相同案例，验证类型/重载/运算符/常量/行为。
+7. 将现有自动 prune 流程改为生成显式缺失报告；缺失需理由与回归，不能以静默删除结束。
+8. 宏迁到 .macros；对现有 cv::CV_* 提供文档迁移映射，头文件混用测试覆盖 macro 展开冲突。
+
+上游公共 API 完整性与 ABI 保持是验收条件，不强制“零补丁”压倒正确性。
+确需补丁时应最小化并记录，与 wrapper 的替换实现分开。
+
+## 7. mcpp-index 的 mwrap 分类
+
+### 7.1 目标布局：Git 与发布保持一致
+
+```text
+mcpp-index/
+├── pkgs/
+│   ├── c/                         # 原有 compat 等包
+│   ├── ...
+│   └── mwrap/                     # 模块化封装的独立分类，描述符平铺
+│       ├── mcpplibs.mwrap.opencv.lua
+│       └── mcpplibs.mwrap.onnxruntime.lua
+├── tests/
+│   ├── examples/                  # 原有非 mwrap 消费者
+│   └── mwrap/
+│       ├── opencv-base/
+│       ├── opencv-highgui/
+│       ├── opencv-dnn-onnxruntime/
+│       ├── opencv-macros/
+│       ├── onnxruntime-cpu/
+│       └── legacy-migration/
+└── tools/
+```
+
+mwrap 独立分类放在 pkgs 下，与现有索引根和扫描深度一致；不再另加 o/ 等首字母层。
+分类约定写入 docs/mwrap.md；描述符目录保持纯包文件，避免 README 被旧 lint 当作描述符。
+包身份由 descriptor 声明，不从分类目录推断。compat.onnxruntime 仍归传统供应者，不进入 mwrap。
+
+### 7.2 已核查的发现路径与最小适配
+
+核查对象包括 mcpp v2026.10.21.1 的 src/pm/package_fetcher.cppm，以及本地 provider/libxpkg 加载路径。
+
+- mcpp 先尝试 pkgs/<首字母>/<候选文件名> 快速路径。
+- 未命中时按声明身份扫描 pkgs 根及其一级子目录。循环变量虽叫 letterDir，代码不要求目录名是一个字母。
+- 因此 pkgs/mwrap/<full-name>.lua 落在既有 fallback 范围内。
+- 根目录 mwrap/o/*.lua 不在该扫描范围；pkgs/mwrap/o/*.lua 也多了一层，不能假设递归支持。
+- 本地 libxpkg 的索引构建同样枚举 pkgs 下一级目录，目录名不强制首字母；具体 pinned provider 的实际组合仍需端到端验证。
+- mcpp-index 发布脚本复制完整 pkgs，因此新分类目录可原样发布，无需路径转换。
+
+**采用结论：取消 staging 路径转换，直接维护和发布 pkgs/mwrap。**
+这不要求先修改客户端索引协议；优先在 mcpp-index 内适配目录枚举、测试注册和 CI 选择。
+文件系统扫描 fallback 可能比首字母快速路径慢，先测实际规模；只有证据显示明显回归时再考虑通用查找优化。
+不为单个 mwrap 分类在 mcpp 引擎中增加硬编码 namespace 分支。
+
+实施前在 Linux 用精确固定的 mcpp/provider 做最小索引 fixture，验收 path、Git 和发布归档三种消费路径：
+精确身份解析、版本枚举、搜索、跨 namespace 依赖、lockfile、安装和最终链接均命中当前索引。
+旧版客户端的覆盖不是本轮目标；也不以本地源码可扫描代替上述最新版本的运行实测。
+
+### 7.3 必须同步修改的索引入口
+
+- 发布脚本的文件收集、内容 hash、镜像、manifest 与归档。
+- lint、包名与保留 namespace 检查、GLOBAL/CN URL 和 sha256 检查。
+- workspace members、新 tests/mwrap 项目注册和 index 重定向；适配 run_members.sh、plan_shards 和计时表中旧路径假设。
+- changed-files 到测试成员的映射、依赖影响传播、CI shards、耗时记录与缓存键。
+- 搜索/站点生成、清单生成和新增包模板。
+- 新旧身份迁移测试；旧版本 descriptor 不重新定向到不同内容的归档。
+
+本地索引文档记载过同一路径以多个 namespace 注册产生歧义的限制，需用最新 pinned 版本复核。
+测试必须确认 mwrap 与 compat 都来自当前索引的预期 revision；若仍受限制，分别验证配方并增加组合安装测试，
+不得用一次成功的远端解析冒充本地变更被验证。
+
+index.toml 的 latest_mcpp、CI 和模板使用统一 pin。min_mcpp 是消费者的兼容下限，
+仅在新目录/schema/语义确实要求时提高，不能因为测试使用最新版本就机械抬高全索引下限。
+
+## 8. 测试与发布验收
+
+| 维度 | 必须验证 |
+|---|---|
+| 基础 | 读写图、图像处理、各新增算法模块真实案例 |
+| API | 单模块/聚合/组合 import、模板和 ADL、头文件混用、宏映射等价 |
+| GUI | Linux Xvfb 等实际窗口环境、Windows/macOS 桌面 runner 创建窗口、imshow、事件循环与销毁 |
+| ORT | 直接 Ort::Session、OpenCV ENGINE_ORT、已知小 ONNX 模型数值结果、无回退证据 |
+| 视频/codec | 固定夹具 roundtrip，原生采集与设备相关项标明需设备 runner |
+| feature | core-only 默认配置、常用图像配置、all-modules、highgui-native、dnn-onnxruntime、关键 codec/后端组合及配置错误诊断 |
+| 二进制 | 干净机器运行、DLL/SO/dylib、动态加载 provider、资源、RPATH/install-name |
+| 索引 | path/Git/发布归档目录一致、解析身份与来源、搜索和版本枚举、sha256、旧身份仍可用 |
+| 工具链 | Linux GCC/LLVM，macOS arm64 LLVM，Windows MSVC ABI；额外目标按产物和验证开放 |
+
+首次重构保留当前已声明 Linux musl 基础能力；ORT 没有兼容产物时，dnn-onnxruntime 在该目标明确拒绝。
+组合空间不做无意义的全排列，采用依赖边覆盖、后端共存、公共 ABI 与跨平台关键组合。
+发布报告把 passed、build-only、requires-device、unsupported 分开；缺少硬件时不伪造运行通过。
+每项已启用依赖都有明确获取/链接/运行路径；关闭可选 feature 验证不引入其供应者。
+许可证、SDK 再分发条件和镜像范围以实际选中依赖为准，不把硬件驱动视为普通可随包复制的库。
+
+### 8.1 Linux 本地测试与其他平台 CI 分工
+
+Linux 本机作为主要迭代环境：先确认实际运行的 mcpp 及 provider 精确版本，再按同一入口执行以下验证。
+测试用临时目录/独立构建输出，不修改机器的全局索引或依赖配置来制造成功结果。
+
+| 验证项目 | Linux 本地 | Linux CI | Windows/macOS CI |
+|---|---|---|---|
+| 索引发现最小 fixture | 必须：pkgs/mwrap 的身份、版本、安装和链接 | 重跑 path/Git/归档 | 原生安装与消费者构建 |
+| core-only 与常用图像配置 | GCC/LLVM 编译及行为 | 发布前重跑 | 对应工具链构建及行为 |
+| GUI | GTK3 + Xvfb 创建/显示/事件循环/销毁 | 重跑 GTK3 | Win32 / Cocoa；runner 桌面能力需先探测 |
+| ORT | 直接 Session 与 OpenCV ORT CPU 数值测试 | 干净环境部署测试 | 各自 SDK 的直接/桥接推理与运行库加载 |
+| 模块与宏 | 单独/聚合 import、头文件混用和类型身份 | 完整回归 | 捕获编译器/stdlib 差异 |
+| native 摄像头/GPU | 有设备时运行 | 专用 runner | 专用或 self-hosted runner |
+
+Windows/macOS 的本地机器不可用不阻止 Linux 实施；其他平台结果以 CI 为准。
+CI 先发布测试产物和报告，失败要有可重现命令、工具版本和日志；修复后重跑相关任务。
+普通 hosted runner 无法执行真实摄像头、桌面或 GPU 时，明确标为未执行，并按需增加专用 runner；不能将 build-only 当运行验证。
+Linux 本地测试通过不等于其他平台通过；正式支持以该平台规定的验收结果为准。
+
+实现阶段测试入口需要支持上述子集，文档中的布局不是已经存在的新测试命令。
+本轮只做设计与源码核查，没有提前宣称这些 OpenCV/ORT 功能运行通过。
+
+## 9. 分阶段交付
+
+### P0：设计评审（当前）
+
+输出本规范和实施方案，确定包身份、宏映射、版本政策、feature 精确展开与 pkgs/mwrap 索引分类。
+
+### P1：组织与工具基线
+
+核验/创建组织 fork，保留 Git 历史；目标 remote 指向 mcpplibs，旧源保留追踪。
+新建 onnxruntime-m，应用统一布局；统一固定最新稳定 mcpp，旧功能在新工具下先通过。
+不移动旧 tag、不重写旧 release、不把新内容复用旧 hash。
+
+### P2：mwrap 模块和配置骨架
+
+改新身份与公共模块前缀，迁移宏模块和兼容头；源码移到 upstream，生成/适配层分离。
+完成配置输入图和 API 覆盖基线；验证消费者与打包模块闭包。
+
+### P3：原生 GUI 与 ORT CPU
+
+先完成每个平台窗口 TU/依赖/生成配置的最小验证，再接 highgui-native 与显式 highgui 后端 feature。
+发布可测试 ORT CPU 供应者和 wrapper，接入 OpenCV dnn-onnxruntime，完成两条推理路径。
+发布前验证运行时分发，不以链接成功结束。
+
+### P4：主模块、codec 和视频补齐
+
+导入剩余主模块并按依赖拓扑实现；补常用 codec 和原生采集，形成明确 default/all-modules 展开与后端能力矩阵。
+对每个新增模块做 API 差异审计与真实行为验证。
+
+### P5：contrib 与加速
+
+按明确需求依次引入 contrib、OpenCL、CUDA、OpenVINO、TBB/IPP 等。
+硬件、SDK、provider 和平台不支持项公开；达到矩阵条件后才标为 supported。
+
+### P6：索引迁移与正式发布
+
+收集/发布适配和测试选择器先支持新目录，再迁入新描述符及 tests/mwrap。
+包发布、SDK 供应者、镜像与索引 descriptor 按真实产物依次落地。
+对旧 capi 等封装采用逐包迁移，不把所有生态包改名绑在 OpenCV 重构里。
+
+### P7：规范定稿与 skill 同步（用户已要求）
+
+review 确定后，在 mcpp-index 的 docs/mwrap.md 发布正式 mwrap 规范，作为生态规范的唯一维护来源。
+本仓库 .agents/docs 保留设计决策与历史，README/贡献指南链接正式规范，不长期维护两份各自演进的规范正文。
+
+同步更新实际存在的技能入口：
+
+- mcpp-index/.agents/skills/add-mcpp-index-package/SKILL.md：增加 mwrap 包形态、pkgs/mwrap 与 tests/mwrap 分类，
+  修正“目录必须取完整包名首字母”的单一路径要求；补上 upstream[.N]、宏映射、feature 命名、SDK/runtime 和本地/CI 验收。
+- mcpp/.agents/skills/mcpp-usage/SKILL.md：补充 mwrap 依赖与导入示例，明确 API namespace 不随模块前缀变化、
+  feature 加法语义及默认项限制，链接索引正式规范，不复制完整配方说明。
+- 后续 opencv-m/onnxruntime-m 的贡献说明：链接统一规范，记录各自上游同步、补丁、导出审计和 feature 测试方式。
+
+只有实际需要新增通用封装技能时再创建，避免包索引技能、构建工具技能与库贡献说明职责重叠。
+修改 skill 时读取适用的 skill-creator 与目标技能说明，再核查正文、示例、索引模板和 lint 规则是否一致。
+技能中的迁移建议不能反过来重写已发布的旧包、URL 或 hash。
+这些步骤在规范 review 后实施，本轮未提前修改其他仓库的 skill。
+
+## 10. Review 决策表
+
+| 决策 | 建议 |
+|---|---|
+| 仓库 | fork opencv-m 到 mcpplibs，新建 onnxruntime-m；contrib 初期集成在 opencv-m |
+| 公共导入 | mcpplibs.mwrap.<libname>[.<upstream-module>] |
+| API | 保持 cv:: / Ort:: / C API；宏替身单列 .macros namespace |
+| 上游布局 | upstream 原始源码 + port 适配 + generated 稳定产物 |
+| ORT 所有权 | compat SDK 供应者 + onnxruntime-m 模块封装；CPU 优先 |
+| 封装版本 | 已确认：5.0.0、5.0.0.1……；升级上游后修订计数重置，不发布 .0 |
+| feature 集合 | default=[]、core 为基础；模块/后端显式启用；all-modules 只代表主模块全集 |
+| 索引 | pkgs/mwrap 平铺描述符，tests/mwrap 独立测试；源码与发布同布局，无路径转换 |
+| mcpp | 当前 2026.10.21.1，实施前复核并统一精确固定 |
+| 规范与技能 | 定稿后在 mcpp-index/docs/mwrap.md 维护正式规范，同步索引添加技能与 mcpp 使用技能 |
+
+## 11. 参考与证据
+
+- [OpenCV 5.0.0 modules](https://github.com/opencv/opencv/tree/5.0.0/modules)：官方 tag 清单经 API 核对。
+- [OpenCV 5 DNN engines](https://docs.opencv.org/5.0/main_modules/dnn_engine_selection.html)：ORT 与原生引擎的区别。
+- [ORT 官方构建](https://onnxruntime.ai/docs/build/inferencing.html)。
+- [ORT provider 动态加载](https://onnxruntime.ai/docs/build/eps.html)。
+- [mcpp 最新版本核对](https://api.github.com/repos/mcpp-community/mcpp/releases/latest)：本轮返回 v2026.10.21.1。
+- [mcpp 2026.10.21.1 文档](https://github.com/mcpp-community/mcpp/tree/v2026.10.21.1/docs)：features、workspace、pack、action。
+- 本地 mcpp-index：docs/repository-and-schema.md、tools/publish_mcpp_index.sh、.github/workflows/validate.yml、
+  pkgs/o/opencv.opencv.lua、pkgs/m/mcpplibs.capi.lua.lua、index.toml、mcpp.toml。
+- 本地 openkal-musl：musl/PATCHES.md、musl-generated/README.md、port/，用于分层参考。
+
+本地检查已按 §1.2 更新并固定到远端 main；实施 PR 前仍须重新 fetch，并记录新的基线，不假定远端保持不变。
+
+## 12. 多视角自我 review 与修正记录
+
+本节为同一作者从不同职责视角自查，不代表额外独立审查或已完成的运行测试。
+
+| 视角 | 找到的问题 | 本次修正 / 验收门槛 |
+|---|---|---|
+| 包管理维护者 | 根目录 mwrap/o 不在现有 mcpp 扫描范围，先前 staging 增加双布局成本 | 改 pkgs/mwrap 平铺；发布原样复制；不要求改客户端协议 |
+| 配方开发者 | 最新代码可走 fallback，不代表 path/Git/provider 搜索全部自动正确 | Linux 最小 fixture 覆盖解析、搜索、安装、lockfile 与链接；其他平台 CI |
+| 普通 OpenCV 用户 | gui、codec、ort 与上游名称不一致；full/desktop 无精确边界 | highgui-*、imgcodecs-*、videoio-*、dnn-onnxruntime；移除模糊聚合 |
+| 精简构建用户 | 旧 features 文档把根 CLI 与依赖边 opt-out 混淆 | 实现与 E2E 126/127 证明依赖 default-features=false 可用；core-only 保留为产品选择，模板显式列功能 |
+| GUI 使用者 | highgui API 或 all-modules 不等于存在实际窗口后端 | 分清模块/后端；摘要输出 NONE；窗口示例必须选具体后端或 highgui-native |
+| 后端集成者 | GTK/Qt 共存或 native 覆盖规则不能凭注册表推断 | native 只增加；按上游能力验证共存；冲突在配置阶段拒绝 |
+| 推理用户 | DNN 枚举可见、模型成功加载都不能证明用了 ORT | 直接 ORT 和 OpenCV bridge 分别执行，提供无回退证据 |
+| 链接/ABI 维护者 | capability 选择不自动从图中移除另一份同符号运行库 | SDK 供应者只能引入一个主库变体；图验证与最终符号/运行测试 |
+| 模块/API 维护者 | 使用 Python 标记生成导出并自动 prune 会遗漏 C++ API | 以公共 C++ 头为审计基准，缺失显式记录、禁止静默宣称完整 |
+| 宏与混用用户 | namespace 不阻止宏展开，函数替身不等价于任意断言宏 | .macros 与原始宏兼容头分开示例，测试冲突、求值与调用位置 |
+| 跨平台维护者 | Linux 通过无法证明 Cocoa TU、Windows DLL、各自 SDK 可用 | Linux 本地 + CI，Windows/macOS 原生 CI；桌面/GPU 缺项公开 |
+| 发布维护者 | 只查链接依赖可能漏掉 ORT 动态 provider；新目录可能漏 CI | 显式 runtime 清单、干净环境执行、目录选择器/镜像/站点覆盖 |
+| 版本维护者 | .0 与无尾号可能等序，+build 不能实现修订排序 | upstream[.N]、N>=1；不发布 .0；不可变旧版本与旧身份 |
+
+仍需实施实测的事项：最新 bundled provider 的实际目录发现/跨 namespace 组合、Cocoa 的构建动作、
+GTK/Qt 后端共存、ORT 的二进制与工具链兼容、根模块打包闭包。
+这些被列为先做最小验证的工作，不作为需要用户猜测技术答案的决策题。
+
+本轮 review 的产品决策主要是：接受 pkgs/mwrap 分类、上游风格 feature、最小默认 core-only、
+all-modules 的模块全集语义，以及 Linux 本地/其他平台 CI 的验证分工。
+
+## 13. 实施补充：模板与 checkpoint
+
+所有新建/重构的 -m 封装库必须提供快捷模板。OpenCV 默认模板使用自生成图像完成处理与写出；
+另提供窗口、视频、DNN/ORT 模板。ORT 默认模板内置小型、可再生成的 ONNX 模型并完成真实 CPU 推理。
+验证从 mcpp new 渲染到构建和执行的完整链路，不能只 lint 模板文本。
+各仓库使用一个功能分支和一个 PR，保留独立 checkpoint commits，不 squash 或 force-push 丢弃进度。
+每次 checkpoint 记录实际已验证范围；最终按计划要求逐项审计，并等待全部相关 CI 通过。
+远端权限不足期间继续本地实施，不能把仅本地完成当作 PR/CI 完成。
+
+## 14. Feature opt-out 证据修正
+
+mcpp parser 的 DependencySpec.defaultFeatures、prepare 图的 feature 合并，以及 E2E
+126_default_features_opt_out.sh / 127_transitive_default_features_optout.sh 在已发布 2026.10.21.1 上均验证通过。
+因此撤回先前“消费者不能关闭默认项”的判断；该判断来自过时且表述混淆的 features 文档。
+已在 mcpp PR #836 修正中英功能文档和使用技能，同时修正索引规范。
+
+组织权限已通过现有 Sunrisepeak 授权解决，mcpplibs/opencv-m fork 与 onnxruntime-m 仓库均已创建。
+使用单次命令的授权，不改变本机默认 GitHub account。
+
+## 15. mcpp 仓库边界（用户补充）
+
+mcpp 引擎代码只读。已有 PR #836 仅涉及文档与使用 skill，允许保留，但现在不合入。
+该 PR 的 review、CI 或合入状态不作为 opencv-m 实施与验证的前置条件。
+OpenCV 的模块、feature、平台后端、测试和模板继续在 opencv-m 内推进；
+索引分类及供应者适配在 mcpp-index 内处理。若遇到确切客户端缺口，保留最小复现并报告，
+不扩大 mcpp 修改范围，也不因此停止不受该缺口影响的 OpenCV 工作。
diff --git a/.agents/docs/2026-10-24-readiness-audit.md b/.agents/docs/2026-10-24-readiness-audit.md
new file mode 100644
index 0000000..c0b9c80
--- /dev/null
+++ b/.agents/docs/2026-10-24-readiness-audit.md
@@ -0,0 +1,900 @@
+# Implementation and release readiness ledger
+
+The full objective remains the OpenCV 5/main C++ API and backend plan, ORT wrapper, executable -m templates, one checkpoint PR per repository, green relevant CI and ecosystem review. Nothing is merged or released by these checkpoints. mcpp engine code stays read-only; its existing documentation-only PR is not a prerequisite.
+
+## Latest review state
+
+The six companion source PR heads were rechecked through GitHub: ORT 576c780b
+(4 checks), llama.cpp 5028a1aa (8), FFmpeg 1e8bce6e (2), gRPC 0d11b223 (6),
+ImGui ffebf83b (4) and Godot 40f72d55 (3) all have successful checks. Their
+independent draft PRs remain open, with executable templates included.
+
+OpenCV's 16baa03 native matrix passed all five jobs. Native run 40088385850
+on d1c3152 is running; the earlier eb1d34b Windows leg passed all-main-module
+tests, including the formerly crashing ArUCo constant case, before cancellation.
+The software SIMD checkpoint now passes all 28 programs on all three Linux
+compilers. Current Matx producer separation restores SDK template argument forms
+and passes independent three-compiler parity; its new 30-program combination
+and native matrix remain required. Index ee52fdb corrects the mixed-workspace
+ambiguity that persisted on 6ff350a; its site check passes, while workspace
+validation, updater and OpenKAL checks remain pending.
+The index still pins the independently verified 019eaadb OpenCV archive.
+Final source/archive alignment and all relevant exact-head checks remain
+required. API/header and backend classification is unfinished. No merge/release
+readiness is claimed.
+
+Sections below are chronological checkpoint evidence, not current PR status.
+
+## Historical verified checkpoints
+
+- OpenCV remote head 02fb836: native CI run 40026710108 passed all five jobs, including core, image codec behavior and the real default project template; Linux GCC additionally runs DNN/unifont. Root LICENSE/metadata/readme now consistently say Apache-2.0. The image example explicitly requests required features.
+- ORT head de3a0a9: native CI run 40022727603 passed Linux GCC/LLVM, macOS arm64 and Windows MSVC ABI. Each runs three module consumers plus the actual project template. LLVM audits the exact SDK declaration inventory. Supplemental official headers omitted from Windows SDK are source/hash pinned. The config-module internal-linkage adaptation and mixing limits are explicit.
+- SDK provider: isolated SDK install plus LLVM/GCC inference/header tests passed; no wrapper/source cache was preseeded in that SDK test.
+- ORT immutable archive: source de3a0a9da143f4ae52eb5e1a0302ba3fdf623b6d downloaded twice with SHA256 24d4bc26d2f426e3643f21d289d92e7a23b3ba54524a099a1079c1c490915251. Index consumers execute real inference and public helper/config APIs. The complete unchanged publication layout also passed in a fresh MCPP_HOME: actual archive/SDK/toolchain installation, mcpp new, strict build and unmodified template run.
+- ORT Linux distribution check: a release-mode consumer installed the actual immutable indexed archive and official SDK, then `mcpp pack --mode self-contained --format dir --toolchain llvm@23.1.3` succeeded. Its copied bundle passed Identity inference from `/` with a fresh HOME and MCPP_HOME/XLINGS_HOME/LD_LIBRARY_PATH/LD_PRELOAD absent. The bundled loader's `--list` resolved every file-backed ELF dependency inside the relocated bundle. This verifies Linux LLVM relocation, not Windows/macOS or GCC deployment. The initial license collector omitted ThirdPartyNotices.txt; index checkpoint 8d0f3cb now declares LICENSE and ThirdPartyNotices.txt deployment. A complete fresh-home archive/template/pack/relocation rerun passed and verified the bundled notices against the resolved SDK bytes. macOS deployment subsequently exposed a missing @loader_path rpath, corrected in index checkpoint 7d8b3ff and pending native CI revalidation.
+- Index PR #564 contains the ORT wrapper descriptor, SDK provider, mwrap specification/skill and category/test discovery changes. The full updater audit passed (85 automatic declarations, one manual immutable snapshot), and all 14 updater adapter tests passed. Namespace-filtered views are test-only byte copies; normal publication layout is tested separately and is never converted.
+- Llama PR #5 adds b10069.3 CPU template, keeping its legacy package/module identity. No-argument startup and a checksummed GGUF decode/sample passed through actual mcpp new consumers. Root LLVM build and all 116 existing unit/repository/build-helper checks passed. All eight checks on head 2de7714 passed, including Vulkan, Metal and Linux arm64. Its new archive/index descriptor and consumer were added in checkpoint 4018413; current native index validation remains required.
+
+## Native window checkpoint (new implementation)
+
+- Added highgui-native and explicit highgui-gtk3/highgui-win32/highgui-cocoa features, retaining API-only highgui and empty defaults. Target mismatches are errors. Current GTK SDK closure is Linux x86_64 glibc only; other Linux architectures and musl are refused.
+- GTK resolves declared xim SDKs through a scoped pkg-config view. It does not fall back to host headers/libraries. Only the GTK implementation TU uses the pthread compiler mode, keeping public BMIs consumable without that flag.
+- Bundled zlib uses upstream Z_PREFIX and Unix codec implementation symbols use hidden visibility, preventing their collision with shared GUI SDK dependencies.
+- Linux LLVM and GCC strict tests passed all seven binaries, including actual native window creation, image display, event processing, geometry checks and destruction, plus PNG/JPEG roundtrips. The actual named window template also passed strict LLVM build and timed smoke execution.
+- Cocoa passed its native CI job on head 2a74a82; Win32 validation is still running. These results must not be inferred from the earlier five green API/codec jobs. The template helper now restores package metadata reading and explicitly performs a strict build before running.
+
+## Sixteen main-module checkpoint
+
+- Added calib, features, objdetect, photo, ptcloud, stereo, stitching and video from the official pinned archive without changing upstream bytes. All sixteen modules are selectable and all-modules expands only their dependency closure; codecs/backends/SDKs stay explicit.
+- Every retained upstream file (2,305 files) passed direct byte comparison against the SHA256-verified archive. An isolated actual importer rerun reproduced the exact retained file set. The importer now targets upstream/opencv and verifies caller-supplied source trees, building a complete replacement before replacing an existing import.
+- Added behavior tests for SIFT, QR encoding, stereo block matching, camera intrinsic estimation from projected views, denoising, four-channel depth-to-point-cloud conversion, stitching's insufficient-input status, Kalman prediction and optical flow. Both direct submodule imports and the root aggregation are exercised.
+- Linux LLVM 23.1.3 and GCC 16.1.0 strict tests passed eight binaries, including all eight new module behavior cases. Added this same all-modules test gate to every native CI leg, including musl.
+- SIFT and pyramidal optical-flow dispatch currently use upstream baseline implementations; FAST additionally uses its x86 AVX2 TU. New-module OpenCL includes preserve upstream's macro definitions, but explicitly reject HAVE_OPENCL until real kernel integration exists.
+- Existing header-parser/curated exports still require a complete public C++ AST inventory and documented omissions review. Main-module build coverage does not prove complete public API coverage or hardware backend coverage.
+
+## ORT bridge and current-client checkpoint
+
+- The latest published stable mcpp changed during implementation: v2026.10.24.1 was published at 2026-10-23T22:02:51Z. Its Linux package checksum was verified. OpenCV, ORT, llama and index CI/tool pins now use 2026.10.24.1; no mcpp engine source was edited.
+- ORT head 2c3495f passed all four native jobs on the new client. Its source archive was downloaded twice with SHA256 26a89e349d3eb01e339d3c091ff0371ccc4401026f94698bef8e607ad27bc407. The index descriptor now points at that exact commit.
+- Llama head f5a046c passed all eight native checks on the new client. Local strict package build, all 116 unit/repository checks, and actual rendered GGUF decoding passed (sampled token 471). Its archive was downloaded twice with SHA256 543c19018aa05a7e6813f692a3535b6c5953842fdd70041e63266b5864435ddd. Index adds b10069.3 without changing any historical entries or the legacy ggml-org.llamacpp/import llamacpp identity.
+- The index's new llama CPU consumer executes real APIs from the archived candidate; a fresh complete-index template consumer also decoded the pinned GGUF. Its nonnumeric upstream release key is preserved. mcpp --strict treats the supported exact-key warning as an error, so that explicit legacy test exception accepts only that diagnostic and rejects other build warnings. Numeric ORT/OpenCV consumers retain --strict.
+- Added dnn-onnxruntime, implying dnn and the standalone ORT wrapper/official CPU SDK. Unsupported target/ABI combinations fail during configuration. The all-modules aggregate does not imply this external SDK feature.
+- A generated ONNX Add model runs through ENGINE_ORT. Tests require a real ORT JSON profile containing both model_run and CPUExecutionProvider; OpenCV's native-engine fallback cannot pass. LLVM and GCC strict tests passed all nine binaries on mcpp 2026.10.24.1. The actual named onnxruntime template also passed GCC and LLVM build/run; it imports both wrappers and checks output values.
+- Cross-package GCC testing exposed a default-versus-explicit BMI mapper root mismatch for the library's own aggregate. Re-exporting ORT from the feature-selected aggregate records the complete named-module dependency graph and fixed the test without changing mcpp, removing the interop test, or requiring private imports in user code.
+- Windows ORT profiling needs ORTCHAR_T/wchar_t rather than OpenCV's char string. A private generated implementation TU adapts that call through port/include/mwrap/opencv/ort_profile_path.hpp; the upstream file remains byte-identical. Native Windows validation remains required.
+- Full-module CI on f6b1e5e passed macOS, Linux LLVM and musl, but Windows found M_PI absent in tracker_vit.cpp. Added upstream's _USE_MATH_DEFINES and standard constant defines to the eight new modules' private flags. The next native matrix must validate this correction, Win32 windows and the ORT bridge.
+- Index checkpoint 4018413 adds archive/template checks for llama, notice deployment requirements in the shared specification/skill, new artifact pins and latest-client CI. All 14 updater adapter tests and the complete updater audit passed; every historical version/resource was preserved. Native CI for this new index head is pending.
+
+## Review decision
+
+| Repository | Merge readiness against the requested scope | Release readiness | Index readiness |
+|---|---|---|---|
+| opencv-m | Not ready: complete local main-module baseline, but API/backend scope and new native CI pending | Not ready for a full-support release | Final source archive descriptor and installed consumers absent |
+| onnxruntime-m | CPU-only candidate has four green native jobs; final API/distribution review pending | No release/tag created; Linux notices/relocation passed, platform deployment verification pending | SDK/wrapper descriptors and Linux real archive/template consumption implemented in index PR; final cross-platform validation/review pending |
+
+The public repository listing proves repository creation/forking, not merge or release readiness. Both source PRs and the index PR remain drafts. The latest index validation/platform workspace jobs passed, but its openkal-compat measurement job was still running at this audit; the whole PR cannot be described as green yet. ORT CPU acceptance is independent of OpenCV full support.
+
+## Live work and remaining gates
+
+- Monitor current index and llama PR heads, not the earlier failing runs. Index Windows UTF-8 decoding and current shared-image adapter metadata were corrected. Llama Vulkan CI pins the candidate index so it can validate those fixes before merge; native ARM verifies managed ELF runtime closure rather than assuming a static file label. No strict checks were disabled.
+- All 16 main modules are imported; all-modules strict tests pass on Linux LLVM/GCC. New native matrix results and full public API coverage remain required.
+- Finish native highgui Win32 validation, video native backends and Windows/macOS ONNX Runtime bridge validation with concrete features/templates/actual runtime tests. The highgui feature alone remains API-only; native backends require explicit selection. The new dedicated ORT test proves CPU execution through the session profile; the ordinary dnn test alone does not.
+- Complete public OpenCV API/macros inventory and consumer/mixing audit, platform/backend/codec matrices, and explicit unsupported hardware status remain required.
+- Add the finalized OpenCV archive descriptor and consumers to pkgs/mwrap/tests/mwrap only after source/features and archive bytes are validated.
+- Verify packaging/deployment/relocation and distribution runtime closure, including external SDKs, rather than relying solely on running inside an installed mcpp home.
+- Validate latest index archive/template checks on every declared platform and inspect all PR checks to green. Update stale architecture/contribution docs and re-review all source/feature/version/license/runtime boundaries.
+- Audit all local -m packages for runnable templates. ffmpeg-m/grpc-m/imgui-m already have templates; OpenCV and ORT are tested, llama fills the discovered missing template. Do not rewrite legacy published package identities as a shortcut.
+- Final PR descriptions, release ordering and requirement-by-requirement readiness audit remain mandatory. No merge, tag or release until user review.
+
+## PRs
+
+- https://github.com/mcpplibs/opencv-m/pull/1
+- https://github.com/mcpplibs/onnxruntime-m/pull/1
+- https://github.com/mcpplibs/mcpp-index/pull/564
+- https://github.com/mcpplibs/llama.cpp-m/pull/5
+
+## Native video and cross-platform text checkpoint
+
+- Added videoio-native with explicit videoio-msmf/videoio-avfoundation overrides. Linux uses the existing V4L2 catalog; Windows MSVC ABI uses Media Foundation; macOS uses the upstream macOS AVFoundation implementation. Target/backend mismatches fail during configuration.
+- Linux LLVM 23.1.3 strict testing with videoio-native,videoio-ffmpeg passed ten binaries. V4L2 registration/missing-device behavior passed, and FFmpeg encoded and decoded twelve generated frames with backend identity, dimensions and image error checks. This is not physical camera coverage.
+- Every native CI leg now runs this feature combination. Windows/macOS additionally exercise native H.264 MP4 encode/decode; those new checks remain pending. The named video template performs an FFmpeg roundtrip without camera hardware; its actual scaffold/build/run is being validated locally and in CI.
+- On c59b226, macOS, Linux LLVM and musl passed. Windows passed all sixteen module tests and the real Win32 window, then failed a generated ONNX header byte comparison due to checkout line ending conversion. Added LF attributes for wrapper text and disabled conversion for the pinned upstream tree/binary assets; the generated-model check passes locally. This does not yet prove Windows ORT execution.
+- Index f0f8e48 updates current llama CPU/Metal examples to b10069.3, which carries the portable LLVM 23 include fix. Historical descriptor versions remain unchanged. The replacement native runs are live; the prior b10069.2 failure is not waived.
+
+## OpenCV 5 typed macro checkpoint
+
+- Replaced the hand-maintained eight-depth subset with generated mappings from the pinned core HAL header: all thirteen scalar depths, all channel families/constants, HAL numeric constants and pure matrix type/layout helpers. Declaration and control-flow macros remain textual.
+- Added actual Mat allocation/layout checks for every depth and channels 1,2,3,4,7,128; verified unsigned/signed 64-bit, unsigned 32-bit and bool storage access; checked ROI/continuity against Mat methods. LLVM 23.1.3 and GCC 16.1.0 strict tests each passed eleven binaries, including all three new layout behavior cases. These tests do not claim every arithmetic algorithm supports every new depth.
+- OpenCV 5.0.0 CV_IS_SUBMAT uses an undefined CV_MAT_SUBMAT_FLAG. The typed mapping explicitly uses CV_SUBMAT_FLAG, tested against Mat::isSubmatrix; upstream source and the raw side-header macro remain unchanged. Both readmes document this adaptation.
+- CI checks generation consistency on every platform. Native macro validation remains pending; the prior Linux video template rendered, strictly built and decoded twelve frames successfully on the latest client.
+
+## C++ inventory and core surface restoration checkpoint
+
+- Added a streaming Clang AST inventory of facade-visible namespace/global types, aliases, enums/enumerators and overload signatures, with header ownership and internal-linkage flags. Class members ride with their owning class. ABI-versioned dnn namespace imports normalize to public cv::dnn names. Unloaded headers are reported separately; this is not a full-public-header completeness claim.
+- Corrected Clang JSON's stream-wide file-name elision, including locations in otherwise skipped function/class bodies. Three focused parser regressions cover streaming/truncation, cross-header ownership and namespace/overload/enum/linkage behavior. A real Clang nested-header experiment reproduced the ownership failure before the correction.
+- Restored public core Affine3/Quat/AutoBuffer and related types, fixed-width/global scalar aliases, 64-bit Vec aliases and the complete CPU enum surface without moving upstream declarations into new namespaces. Regeneration now supports explicit public global declarations. Affine's TU-local free operators use explicit adapters in the existing replacement namespace; upstream files remain unchanged.
+- New module-only tests exercise affine composition/inversion and Point3/Vec transforms, quaternion rotation, growing AutoBuffer, partition grouping, global aliases and new scalar types. LLVM 23.1.3 and GCC 16.1.0 strict core suites each passed twelve binaries. The LLVM sixteen-module strict suite also passed twelve binaries, including all eight main-module algorithm cases.
+- The corrected audit inventories 3,323 facade-visible namespace/global entities and reports 624 not present in export-using lists. Some have manual adapters, while others are real gaps; they are not silently pruned or declared complete. A separate root-import consumer successfully resolved all 2,700 listed export names. This validates name reachability, not every overload/template instantiation. CI now runs the inventory and publishes its evidence.
+- Latest index f0f8e48 native Windows/macOS workspaces and all four llama candidate checks passed; Linux workspace/measurement checks remain live. No source PR or index PR has been merged.
+
+## Public module closure and advanced stitching checkpoint
+
+- Actual direct stitching import exposed missing core name visibility. GMF reachability alone did not expose cv::Mat/Point/Rect names. Public optional modules now aggregate core, required modules and independent internal header-adapter modules under mcpplibs.mwrap.opencv.detail; C++ namespace/type identities and public import names remain unchanged.
+- Directly combining header GMFs and import core in one unit hit GCC 16's SVD duplicate defaults. Standard interface partitions subsequently hit a GCC merge ICE. Independent named adapter units passed; no compiler/engine patch or upstream-header edit was made. The source generator preserves adapter bodies and regenerates the public dependency aggregations and manifest source lists.
+- Restored 99 public stitching/detail exports and included the previously unloaded autocalib/timelapsers headers. Tests exercise actual two-tile CPU blending, camera intrinsics/plane projection and timelapser placement through the direct stitching import. Both LLVM 23.1.3 and GCC 16.1.0 strict all-modules suites passed thirteen binaries, including these three cases and all eight main-module behavior cases.
+- Added actual native ONNX Add execution to both ENGINE_CLASSIC and ENGINE_NEW, independent of ORT; both passed in the LLVM/GCC all-module suites. Added pixel-exact BMP/PPM and float-preserving PFM roundtrips, also passing both suites. PNG/JPEG remain separately gated codecs.
+- The updated Clang audit inventories 3,328 facade-visible namespace/global entities, 530 not in export-using lists; 132 of 274 retained header candidates remain outside the facade configuration and 14 are private. The separate consumers resolved all 2,799 listed root export names and all sixteen direct module surfaces, checking their own exports plus core type visibility. Template signatures now include the underlying function/alias declaration. Missing names/header profiles still require review; no completeness claim is inferred from these counts.
+- Replaced the text search over Ninja rules with a resolved compile-command guard. All 33 public/internal wrapper module interfaces passed the baseline ISA check. CI runs it on every platform and after all-modules, and publishes direct-import audit evidence.
+- Refreshed both architecture documents to describe the actual sixteen-module/provider/feature/adapter layout and remaining API/mixing boundaries.
+
+## Existing -m template ecosystem checkpoint
+
+- Found and corrected duplicated namespace rendering in ffmpeg-m, grpc-m and imgui-m templates: current self.name already contains the full qualified identity. Each repository has its own draft PR/checkpoint; published legacy package/module identities remain unchanged.
+- FFmpeg PR #8 / 5349a37 adds revision 8.1.2.1. Actual mcpp new, strict LLVM build and generated three-frame decoding passed locally; both native library and actual-template CI passed. Its full-commit archive was downloaded twice with matching SHA256 0c528d674aa99bf830fc61455cffdbf903e4c522c6da966b08274821acaa2d17. Installed-archive/index validation remains pending.
+- gRPC PR #8 / 56e6a2c adds revision 1.83.0.1 with runtime/plugin/rule version alignment, same-artifact plugin/rule path dependencies and current build-dependency declarations. Explicit and default greeter selectors both strictly built and executed successful/error RPC calls locally. Native/template CI is live on the latest checkpoint.
+- ImGui PR #13 / f3d9d16 adds revision 1.92.8.1. The prior 2dc0001 checkpoint passed all three native library jobs plus actual window/docking scaffolds rendering three frames each. The new default headless template strictly built and generated 168 draw vertices locally with DISPLAY/WAYLAND_DISPLAY unset; desktop templates stay explicit. New native/template CI is live; its three library jobs passed at this audit.
+- Local GUI validation initially exposed an incomplete warm graphics SDK cache: libllvm/libxshmfence payloads were absent and Mesa view links were stale. Official package-tool installation/activation of the declared SDKs restored normal mcpp strict build/run and three-frame rendering under Xvfb. A temporary isolated library-path experiment was diagnostic only, not acceptance proof; native CI independently passed without that override.
+- Index f0f8e48 passed every applicable check, including all platform workspaces, four llama candidates, graphics isolation and the 40m51s OpenKAL measurement. This is the checkpoint before adding finalized additional wrapper archives/consumers, so it is not the final index acceptance.
+- OpenCV 79a8b60 native CI passed macOS (including AVFoundation/FFmpeg file roundtrips, video template and ORT bridge/template) and musl (V4L2/FFmpeg). Windows and both glibc Linux jobs remain live. These results precede the new internal-adapter/direct-import checkpoint and do not validate that later source change.
+
+## User resource and README constraints
+
+- All -m root READMEs use the same concise entry structure and normally stay within 100 lines per language. Detailed usage moves to docs/; prerequisites, candidate status and critical scope limits remain visible. The index's bilingual mwrap spec and package-authoring skill record the rule.
+- Local tests and subprocesses collectively stay below 80% of effective CPU/memory. This host currently has 32 logical CPUs and about 62 GiB RAM. The task-specific mwrap-tests.slice has CPUQuota=400%, MemoryHigh=28G, MemoryMax=32G and TasksMax=512; future local heavy checks use that shared slice with the stricter four-core quota, MCPP_JOBS=1 and one heavy task at a time. These limits apply only to this task's processes, with unrelated user jobs untouched. Check current load/available memory before further heavy work.
+
+The current kernel cgroup limits are cpu.max=400000/100000, memory.high=28 GiB and memory.max=32 GiB. This user hierarchy does not delegate cpuset, so test commands additionally use taskset -c 0-3. Local heavy checks run as:
+
+```sh
+systemd-run --user --scope --slice=mwrap-tests.slice --quiet \
+  taskset -c 0-3 env MCPP_JOBS=1 <check-command>
+```
+
+README rewrites cover OpenCV (EN/ZH), ORT, llama.cpp, FFmpeg, gRPC (EN/ZH) and ImGui. Each entry is below 100 lines, with its detailed prior content retained in docs/usage*.md and local links checked.
+
+## FLANN and strict-consumer portability checkpoint
+
+- Restored the public cv::flann aliases/GenericIndex and 164 non-internal cvflann names without changing their namespaces. Two direct-import runtime tests perform nearest-neighbor searches through the high-level and low-level APIs and check distance functions. LLVM 23/GCC 16 strict FLANN suites passed; the LLVM all-module suite passed fourteen binaries. The combined GCC all-module strict recheck also passed fourteen binaries in 250 seconds (247 seconds build), including both FLANN cases, stitching, both native DNN engines and codec roundtrips.
+- The all-module Clang audit now inventories 3,328 facade-visible entities and resolves 2,983 listed exports through the root and all sixteen direct modules. It leaves 346 unlisted entities and 132 not-in-facade headers for review; these counts include internal declarations/manual adapters and cannot be called complete API coverage. Namespace const internal linkage now accounts for desugared types, pointer/reference constness and preceding external declarations; four parser regressions pass.
+- Repaired the optional raw CV_IS_SUBMAT compatibility macro to match the existing typed mapping and Mat::isSubmatrix, while preserving vendor bytes. Actual ROI checks passed on GCC/LLVM.
+- The previous remote GCC job failed during ORT tests because its BMI mapper mixed indirect adapter paths. Explicit aggregate imports of selected internal adapters fixed compilation. A retained candidate then passed fourteen strict binaries, including actual ONNX Add through ORT with CPUExecutionProvider profile evidence. Its first link attempt ran out of disk; the successful retry had sufficient free space and a 6 GiB cutoff guard.
+- On remote edadf5c, LLVM, musl and macOS passed. Windows passed all modules, actual Win32 GUI and both MSMF/FFmpeg twelve-frame file roundtrips, then failed the video template's strict build because Strawberry Perl's host NASM was selected. The wrapper now declares managed xim:nasm@3.02 for x86_64 Linux/Windows videoio-ffmpeg; ffmpeg-m declares the same tool for its x86 profile. This is a library dependency declaration, with no engine/PATH/strict-mode workaround. Native Windows verification is pending.
+- Latest README heads for ORT 576c780, llama.cpp 5028a1a, FFmpeg fa850f4 and ImGui ffebf83 passed all source checks. gRPC 839b61e has live native/template jobs. No PR has been merged or tagged.
+
+## Portable public C++ exports checkpoint
+
+Restored public error-code enums, Param/ParamType and Node, traits, sample helpers, logging, quaternion free functions, calibration fisheye flags, callback typedefs and geometry/point-cloud enums. The features surface now also exposes its C++ aliases and FlannBasedMatcher. DNN now exposes ActivationFunc, MatType, SoftNMSMethod and the documented dispatched activation lookup; removed the obsolete getActivationFunc prune entry after confirming its public all_layers.hpp declaration. Core explicitly loads logger.hpp instead of relying on another facade's transitive includes. Vendor source bytes and upstream namespaces remain unchanged.
+
+LLVM 23.1.3 and GCC 16.1.0 strict all-module suites each passed fourteen binaries (106.62 and 197.77 seconds). New runtime cases exercise throwing/catching upstream error codes, traits/ParamType, logging level restoration, free quaternion inverse/power and dispatched ReLU. All 3,119 listed exports resolve through the root and every direct module in the exact Clang all-module configuration. The inventory remains 3,328 entities, with 210 not in export lists. There are still 132 not-in-facade headers; many are legacy umbrellas, SIMD/device implementations or optional SDK interfaces, but portable public headers such as dualquaternion.hpp, async_promise.hpp, filesystem.hpp, parallel_backend.hpp and geometry/mst.hpp require further restoration and verification. No complete-API claim is made.
+
+A direct organization API audit found seven -m repositories, including godot-cpp-m previously omitted from the six-repository local inventory. Its latest main b19f824 targets godot-cpp 10.0.0-rc1 (Godot 4.6). It is now included in the template/concise-README work with its existing godotengine.godot-cpp-m and import godot_cpp identities preserved. The candidate wrapper revision is 10.0.0-rc1.1; local template validation is in progress, and it needs its own PR/index archive consumer.
+
+## Portable header and scalar semantic checkpoint
+
+The previous remote head e72c09b passed all five native jobs in run 40050010529: Linux GCC/LLVM/musl, macOS and Windows. In particular, Windows completed the actual ORT CPU profile/template plus Win32 and MSMF/FFmpeg/video-template checks. These results apply to that head; the following new changes need their own native matrix.
+
+Restored portable dual-quaternion, async-promise, filesystem, TLS, FP-control and caller-provided parallel backend headers, geometry MST, and CPU-build CUDA/OpenGL declaration surfaces. GPU declarations do not activate device backends. New behavior tests exercise translation, async Mat transfer, temporary filesystem operations, thread-local isolation, parallel_for_ dispatch through a supplied backend, both Prim/Kruskal MST and CPU-only CUDA detection. DISK is exported only with DNN, with an invalid-model test; trained-model inference is not claimed.
+
+An independent SDK oracle exposed three actual defects in the previous partial saturate_cast adapter: negative-to-unsigned wrap instead of saturation, ushort-to-uchar truncation, and double-to-uint64 truncation instead of rounding. The new generator preserves all thirteen pinned SDK source overloads and specializations; two ordinary private functions bridge TU-local cvRound. The test captures native function pointers before import and checks all 169 source/destination pairs, including rounding and boundary values. Generic cv::min/max now retain the actual standard-library entities, including first-reference ties, strings, comparators and initializer lists; dedicated Mat/UMat three-argument forwards preserve image overload selection. makePtr again rejects a custom DefaultDeleter as upstream requires. Utility alignment/division helpers retain upstream debug assertions.
+
+Latest strict all-module suites passed fifteen binaries with LLVM 23.1.3 (17.05 seconds after the DISK guard) and GCC 16.1.0 (28.88 seconds). The features-without-DNN LLVM suite passed fifteen binaries in 42.03 seconds, including the actual SIFT case. Positive and rejected makePtr probes passed on both compilers using their real compile commands; the GCC probe uses the recorded build directory for gcm.cache and explicitly includes the standard memory header needed by imported shared_ptr instantiation. CI runs the generated-conversion drift check and both compilation contracts; LLVM additionally tests the features-only configuration.
+
+The latest all-module Clang audit resolves 3,214 listed exports through the root and all sixteen direct modules. It inventories 3,382 entities, 169 not in export lists and 121 not-in-facade headers. These include manual adapters/private/device headers and genuine remaining portable helpers; no complete-API claim is made. The new docs/coverage.md keeps the four required matrices separate and lists remaining DNN shape/persistence convenience work and distribution gates explicitly.
+
+Godot PR #1 head 40f72d5 has all three native jobs green in run 40053798222, including its real standalone math template and exact Windows extension export check. The organization has seven -m repositories; all seven now have concise root READMEs and runnable default templates. Source/template CI does not alone prove index/release readiness.
+
+## DNN public shape-helper checkpoint
+
+Restored shape_utils.hpp, which had incorrectly been described as internal in the old prune list. _Range keeps its SDK class identity. A generated named-module adapter retains twenty upstream overload bodies for slicing, planes, shape construction, products/concatenation, axis/range normalization, all-one checks and generic formatting/printing. Calls between adapters are explicitly qualified so exported templates do not refer back to TU-local global-module functions; public cv::dnn names remain available alongside the pinned ABI namespace. The generator preserves the upstream license and is drift-checked in native CI. Vendor bytes are unchanged.
+
+LLVM 23.1.3 and GCC 16.1.0 strict all-module suites each passed sixteen binaries (13.71 and 30.37 seconds). The new direct-import tests check all four slicing overloads, shared tensor storage, Mat/UMat/array/integer shape overloads, valid/invalid axes and product ranges, generic vector formatting, print output and returned stream identity. The latest Clang audit resolves 3,215 export-list names through root/all sixteen direct modules and inventories 3,393 entities, 179 not in using lists, 120 not-in-facade headers and fourteen private implementation headers. Adapter names are not using-list completeness evidence and are tested separately. Persistence geometry conveniences and remaining portable headers still need explicit review before a complete-API claim.
+
+## Static-implementation notice deployment checkpoint
+
+The first immutable OpenCV archive 52f4c8f (SHA256 459e59767a7f75fa68abc15ee6f7ac031cdd98e59bb98665d7588e90e6ae22f9) passed an actual installed strict image/scalar consumer in 67.22 seconds, including exact grayscale pixels, PNG/JPEG roundtrips and the restored conversion/min-max/makePtr contracts. The actual default template installed in a fresh home also built strictly and wrote its 64x64 PNG. Its release/relocation audit is running separately.
+
+Review of the read-only mcpp packing implementation confirms automatic notice discovery walks shared-library locations, not vendored static implementation sources. The generated OpenCV manifest now explicitly deploys all fourteen retained wrapper/upstream license and copyright files with original relative paths; this avoids basename collisions and does not change the engine. The manifest generator is deterministic, every source exists and all destinations are unique. The index's actual archive/template deployment test checks all notice bytes and PNG dimensions after running the relocated executable. Final archive/native/deployment checks for this packaging checkpoint remain required.
+
+## Persistence, optimizer and SDK exception-runtime checkpoint
+
+Restored the FileStorage geometry/vector/enum/stream helpers previously listed as missing. The generator retains 65 pinned public inline bodies and the original license, adds typed forwards for the SDK's non-template priority cases and copies only private vector proxies into a module-private namespace. Internal calls use qualified adapter lookup; custom serializers alone fall back to ADL. SDK FileStorage, FileNode, iterator and external WriteStructContext keep their original identities. The enum constraint keeps the SDK's optional void* template argument, including explicit <Mode,nullptr> calls, without exposing a dependent enable_if pointer type that crashed LLVM23 module import. No upstream or engine source changes were made.
+
+Independent native-header and module executables now compare XML/YAML/JSON and all three Base64 forms byte-for-byte; ordinary cases are 432/638/643 bytes and Base64 cases are 722/982/890 bytes on the verified Linux compiler profiles. Tests cover scalar saturation, geometry, Matx, nested vectors, DMatch legacy priority, default/malformed nodes, iterators, enums and user-defined ADL serializers. GCC16 and LLVM23 comparisons pass. A direct geometry import also restores the public optimizer extension header; a user backend verifies the SDK's rejection and unsupported-geodesic report/dispatch contracts.
+
+Latest strict all-module suites passed nineteen binaries on LLVM23.1.3 (24.33 seconds) and GCC16.1.0 (38.36 seconds). Both compilers' positive/negative makePtr contracts pass; the baseline guard checks 33 interfaces. The Clang inventory resolves 3,217 listed exports through the root/all sixteen direct modules, with 3,395 entities, 179 not in using lists and 119 not-in-facade headers. Manual adapters are exercised separately and not inferred from list counts.
+
+Source CI on 5da7fc8 passed Windows/macOS/GCC/musl, but LLVM22 found uncaught cv::Exception only in the ORT process. A retained LLVM23 reproduction failed the typed error-catch test under the default static exception runtime. Changing only the Linux glibc target to cxx_runtime=toolchain-coupled made the same staged ORT project pass all sixteen binaries in 11.61 seconds. The source generator now declares that contract, matching the existing standalone ORT project and ORT template. The named template additionally checks a typed OpenCV exception after successful CPU Add inference; the actual rendered/strictly built template passed locally. The 3.8 GiB completed diagnostic project was removed after preserving logs, compile/link metadata and ELF evidence.
+
+The current native matrix and immutable archive/index gates must validate this new checkpoint; the 5da7fc8 results do not prove it. gRPC 0d11b22 now has all Linux/macOS native checks and its actual template CI green. Remaining portable-header/API classification and broader codec/backend acceptance remain visible in the coverage matrices; nothing is merged or released.
+
+The current coupled-runtime ORT candidate passed all nineteen strict test binaries with LLVM23 in 138.66 seconds (114.50 seconds build). Generated build inputs now preserve unchanged bytes and modification times: regeneration preserved 134 files, and the same GCC persistence check completed in 1.94 seconds after its prior 202.64-second rebuild. This avoids needless SDK recompilation and reduces local resource pressure.
+
+The resource ceiling remains mandatory for every local heavy check: the shared slice caps total task CPU at sixteen cores (50% of this 32-thread host), memory at 32 GiB (about 52% of 62 GiB), with a 28 GiB pressure threshold. CPU affinity is additionally enforced with taskset 0-15 because this user slice does not delegate cpuset. MCPP_JOBS=3, serial heavy checks and available-memory/disk monitoring reserve room for other user applications; unrelated processes are never stopped.
+
+Index updater run 40062594528 at 9f41559 completed all 28 candidate jobs successfully across the applicable Linux/GCC/LLVM, Windows and macOS combinations; scan passed and propose was intentionally skipped on the PR. This verifies that reapplying the candidate index after registry refresh fixes the actual published-index overwrite. The upcoming OpenCV source/archive checkpoint still needs its own checks.
+
+## Portable HAL, instrumentation and tracking checkpoint
+
+The exact 7e4fe39 immutable source archive (SHA256 1248a3fabfc7116941656c476389e86c7654b229570bc1d00ff4943b6eb1afbf) passed fresh index installation, strict actual default-template build, release packing, relocation and execution without the original home/runtime paths. All fourteen retained wrapper/upstream notices match byte-for-byte. Index fdac79a pins that source; current source/index native CI is still running.
+
+Further public-header review found four real portable omissions: core/imgproc HAL, the instrumentation external interface, and the documented tracking extension header. The adapters now expose 172 core HAL names, 34 imgproc HAL names, original instrumentation types/state functions and ten tracking classes/aliases. SDK @cond IGNORED compatibility helpers/private filter classes are not added. Instrumentation remains disabled in the current SDK configuration, and behavior checks require the original no-ops rather than inventing collection support. setFlags keeps both integer/enum calls by forwarding to the original external enum function; NodeData equality retains its SDK entity.
+
+New behavior checks exercise saturating HAL arithmetic, Hamming/L1 norms, exp and image color conversions; instrumentation construction/timing/copy/equality and disabled-state calls; downstream-derived tracking features dispatched through the original feature set, target-state accessors and sampling. The first sampler expectation was corrected after reading the pinned implementation: it always returns false even when samples are populated. The wrapper preserves that behavior and checks the generated samples independently.
+
+LLVM23.1.3 strict all-module validation passes twenty-two binaries in 19.01 seconds. Baseline ISA checks pass all 33 interfaces and both makePtr compilation contracts pass. The exact Clang audit resolves 3,454 listed names through root/all sixteen direct modules, inventories 3,645 entities with 202 not in using lists, 115 not-in-facade headers and fourteen private implementation headers. Unlisted counts include manually adapted and SDK-ignored compatibility entities; these counts do not prove full API behavior. GCC16.1.0 strict all-module validation also passes twenty-two binaries in 44.49 seconds. Remaining header classification, point-cloud detail helpers and the wider codec/backend acceptance matrix remain open.
+
+The first GCC attempt was terminated by the task guard when available filesystem space crossed its 6 GiB floor; it is not counted as a pass. Only task-owned generated outputs were removed after verifying no running process referenced them and no tracked files were involved: completed LLVM/stopped GCC test executables and completed Godot/llama/index build trees. Logs, source, compiler metadata and the model fixture were retained. The successful retry used three jobs to reduce simultaneous link temporary files, under the unchanged sixteen-core/32 GiB slice limits.
+
+## WebP codec integration checkpoint
+
+Reuses the existing compat.libwebp 1.5.0 source recipe rather than importing a second implementation. Index 7e5a54c adds independent demux/mux features and explicit COPYING/PATENTS/AUTHORS deployment; all historical platform resource blocks remain byte-identical. Strict isolated LLVM23 consumers pass a genuine two-frame lossless animation/EXIF container test plus the original encode/decode roundtrip. The unchanged-default variant passes independently, and its compilation database excludes mux/demux units.
+
+The OpenCV imgcodecs-webp feature implies imgcodecs and requests both provider features. HAVE_WEBP is private to imgcodecs implementation paths, including the retained Windows TU adapters; generated configuration/build information reflects selection. A generated-input consumer tests lossless transparent RGB preservation, alpha, exact animation pixels/timing/loop count and XMP metadata bytes. Focused strict runs pass LLVM23 (72.43 seconds) and GCC16 (134.31 seconds). LLVM22.1.8 with all-modules,imgcodecs-webp passes all twenty-three binaries in 252.78 seconds, including the persistence/SDK oracle, HAL, tracking and DNN cases.
+
+Source CI now pins the codec/ORT index fixture before codec tests and adds native WebP verification on all five target/toolchain jobs, with an explicit musl triple. Linux LLVM22 additionally checks codec-off behavior and the absence of the optional dependency from lock/compilation records. The candidate tool accepts a focused binary filter and explicit target to avoid creating unrelated executable copies for each backend check. The first disabled check passed actual codec behavior but exposed that mcpp emits no lock for an empty production graph; the helper now checks an optional lock plus actual compile units, instead of requiring a nonexistent file. The corrected strict rerun passed in 86.10 seconds and proved compat.libwebp absent from the production lock/actual compile-unit records.
+
+The latest stable mcpp was rechecked through the upstream release API and remains v2026.10.24.1 (published 2026-10-23T22:02:51Z). Tool pins remain current; engine source is read-only. Native CI, final immutable archive/consumer/deployment checks and the wider API/header/backend ledger still apply. No merge/tag/release is created.
+
+The continuing API audit identified concrete remaining static-inline conveniences beyond the count-based inventory: morphologyDefaultBorderValue, initWideAngleProjMap overloads, imwritemulti, raw array wrappers, alignment/norm/Jaccard helpers and several public scalar/constant aliases. These must be restored or individually justified; the old prune comments are not accepted as completeness evidence. Portable point-cloud detail rendering helpers and plugin descriptor types also remain under review. This WebP checkpoint does not close those API gates.
+
+## Portable inline and value-operator restoration checkpoint
+
+Restored fifteen pinned core helper bodies (six array norms, five alignment overloads, rectangle Jaccard distance and three raw-array wrappers), morphologyDefaultBorderValue, both enum/integer initWideAngleProjMap overloads, imwritemulti, original global cvTrunc/cvRound64, utils::getThreadID and the ArUco default threshold. Direct image tests exercise morphology defaults, wide-angle map equivalence, actual BMP file dispatch and threshold value/address/SDK detector initialization.
+
+An independent native-header executable exposed the upstream std::array rawInOut typo: its member lacks static, so the free SDK wrapper cannot call it without an instance. The adapter now delegates through an instance to the original member, retaining vector semantics and original array storage/type behavior; the reference consumer uses that same SDK member explicitly. No vendor or engine source is changed.
+
+The SDK oracle then reproduced a real old adapter defect: a legitimate rectangle near INT_MAX gave Jaccard distance 1 instead of the SDK's 0.875, because the handwritten intersection overflowed endpoint arithmetic. All 122 types.hpp free operators are now generated from the pinned source, retaining overloads, compound operations, scalar hypercomplex arithmetic and robust intersection. The before log is target/portable-rectangle-before.log; after restoration the independent helper/member/module outputs match at 222 bytes on LLVM23 and GCC16, including arithmetic, empty/wide unsigned norms, alignment, raw-vector/array identity, geometry/compound operators, soft-scalar rounding and thread identity.
+
+Strict all-module suites pass twenty-six binaries on LLVM23.1.3 (4.26 seconds after the final fixture correction) and GCC16.1.0 (66.06 seconds). Positive/rejected makePtr contracts and 33 baseline interface checks pass both. Clang verifies 3,457 listed names through root/all sixteen direct modules; it inventories 3,645 entities, 199 unlisted names, 115 not-in-facade headers and fourteen private implementation headers. Manual operators/helpers are tested separately from listed-name counts. LLVM22.1.8 also passes all twenty-six binaries in 242.28 seconds; its independent SDK/helper comparison matches the same 222 bytes and both compilation/baseline checks pass.
+
+The SDK's TU-local ArUco constant cannot be exported with a using declaration. Its module value keeps cv::aruco::DEFAULT_VALID_BIT_ID_THRESHOLD and matches the SDK detector. A captured compile probe confirms that including the original header and importing the module makes that same value name ambiguous; module-only value/address access passes LLVM/GCC. The existing full-core GCC header-mixing limitation remains separate.
+
+The old prune loop no longer rewrites API lists. It builds once or replays a log, returns failure and writes explicit JSON/log diagnostics. Every reviewed using exception requires a reason and the generated notes retain it. Replaying the actual ArUco export failure identifies its recorded declaration while preserving every curation/export file byte. Remaining public fast-math globals, matrix/vector overload completeness, portable point-cloud/plugin helpers, device declaration adapters and unloaded-header classification still need review; full-support/release readiness is not claimed.
+
+A separate staged LLVM22.1.8 dnn-onnxruntime build passed all thirteen CoreCppTypes cases, including typed OpenCV exception capture, in 188.10 seconds (165.76 seconds build). Log: target/portable-types-ort-llvm22.log. The previous remote source checkpoint 16baa03 currently has GCC, Windows, macOS and musl native jobs green; its LLVM22 ORT/template step is still live. These are separate from the upcoming helper/operator checkpoint.
+
+Final distribution review must also account for embedded legacy source/header licence preambles, beyond the fourteen named OpenCV notice files and selected provider notices already checked. COPYRIGHT alone does not contain those complete preambles; aggregate and verify them before claiming complete notice coverage. This remains a release gate rather than being hidden by the existing byte-identity notice checks.
+
+## Local resource guard clarification
+
+All local heavy checks share the existing capped slice and run serially with
+MCPP_JOBS=3. The local runner samples whole-host CPU and available memory every
+second: it refuses to start at 80% CPU or below 20% available memory and stops only
+its own test process group when those thresholds are reached during a run. The
+16-core quota and 32 GiB memory limit additionally cap this task's aggregate
+usage. Host sampling is reactive and cannot guarantee that unrelated processes
+never cause a brief whole-machine spike; unrelated processes are never stopped.
+
+## Embedded source notice deployment checkpoint
+
+Source CI at 16baa03 completed all five native jobs successfully, including the
+Linux LLVM22 ORT path. Later helper/operator changes still need their own CI.
+The distribution audit found that named license files alone omit complete older
+BSD preambles embedded in SDK headers. tools/generate_source_notices.py now
+preserves 542 distinct copyright/license comment blocks at 2,077 retained source
+locations in a deterministic 791,266-byte supplement. It skips quoted strings,
+retains original comment bytes and records source locations. Named notice files
+remain separate. All 15 OpenCV notice artifacts are declared by runtime.deploy;
+WebP consumers additionally receive the provider's three notices.
+
+The generator's drift check runs in every native CI leg. Local checks confirm
+complete base/types/matx/mat.inl BSD preambles, all 15 deployment inputs, and all
+2,305 retained SDK files matching the pinned upstream archive. Index relocation
+acceptance now explicitly requires the supplement byte for byte. Actual archive
+installation/relocation and native CI for this checkpoint remain pending.
+
+## Global fast-math API checkpoint
+
+The remaining public global fast-math overload sets cannot be exported with a
+single using declaration because they mix TU-local platform implementations and
+external SoftFloat functions. Twenty exact forwards now preserve the original
+cvRound/cvFloor/cvCeil, cvIsInf/cvIsNaN and CV_FOURCC names and signatures. Private
+bridges call original SDK overloads; constrained public templates also coexist
+with textual headers. Generator assertions pin all thirteen primitive overloads,
+six SoftFloat overloads and the original FOURCC declaration.
+
+All 26 strict all-module test programs passed with LLVM23 (21.52s), GCC16
+(62.59s) and LLVM22 (109.69s). Each compiler's independent header/module oracle
+matches exactly at 380 output bytes. The extended fixture checks negative/half
+rounding, SoftFloat agreement, integer limits, Inf/NaN, overload addresses and
+high-bit FOURCC bytes. The mixed-header test also passes on all three compilers.
+Logs: target/fast-math-oracle-llvm23.log and target/fast-math-all-compilers.log;
+complete compilation databases are saved under target/api-audit/fast-math-all-*.
+Only completed task-owned executables were removed between compiler legs;
+objects, BMIs and evidence remain. All heavy checks ran serially in the capped
+slice with three build jobs and the host pressure guard.
+
+The earlier 019eaadb immutable archive passed fresh-home WebP build/run,
+release packaging and relocation with eighteen byte-identical notices. Its
+source native matrix was still queued at the last authoritative poll; index
+2e54735 carries that verified archive. Final source/index alignment, native CI
+and the remaining portable-header/codec/backend inventory are still required
+before merge/release readiness can be claimed.
+
+## Preview plugin ABI and CPU point-cloud public API
+
+The facade now includes the original llapi/llapi.h preview ABI declarations and
+ptcloud/detail/kinfu_frame.hpp CPU rendering functions. Six original global
+ABI types/enumerators and two point-cloud functions are exported by using
+declarations; no copied ABI structures or backend implementations are created.
+The upstream preview/no-backward-compatibility status is retained. Consumer
+checks exercise typedef/tag identity, structure fields and size, enum values,
+colored/shaded rendering, invalid points and typed invalid-input exceptions.
+
+All 26 strict all-module programs pass LLVM23 (88.51s), GCC16 (72.49s) and LLVM22
+(26.66s). Independent SDK/module utility outputs match exactly at 400 bytes on
+all three. The compiler-derived audit resolves 3,465 listed root exports and all
+16 direct module surfaces; inventory is 3,653 entities, 199 absent from using
+lists (including adapters) and 113 headers not in facades, plus 14 implementation
+headers. Remaining headers require explicit classification; these counts are
+not a declaration of complete support. Logs: target/public-abi-rendering-all-compilers.log
+and target/public-abi-rendering-api-audit.log. The initial local curated-name
+spelling error was corrected; generation now rejects malformed C++ names early.
+The failed initial run is not acceptance evidence. The read-only export
+diagnostic regression still passes and no API was automatically pruned.
+
+## CPU-usable CUDA helpers, HAL and explicit header decisions
+
+Eight generated cuda.hpp helper overloads preserve original SDK bodies or exact
+external function forwards. They restore createContinuous/ensureSizeIsEnough
+for ordinary CPU Mat, GPU-returning overload signatures and header-only swaps.
+Ten Event::CreateFlags operators are generated from the pinned CV_ENUM_FLAGS
+macro definitions, preserving enum results and compound assignments. The SDK
+oracle checks non-contiguous CPU input, continuous reshape, storage reuse/growth,
+empty GPU header swaps, HostMem allocation mode swaps and every flag operation.
+No GPU allocation or device execution is claimed. Original cvhalKeyPoint and 26
+feature/imgproc HAL macro values are exported/mapped. Typed CV_FOURCC_MACRO
+preserves integer/unsigned expression types, checked in constant expressions.
+
+The initial all-module run was terminated by the host resource guard and is not
+a pass. Later runs reduce the shared slice to CPUQuota=800% (eight of 32 cores),
+CPU affinity 0-7 and MCPP_JOBS=2; memory high/max stay 28/32 GiB. The runner now
+records CPU, available-memory and disk metrics when a protection threshold fires.
+Only completed/stopped task-owned binaries are cleaned; user processes and
+original files are untouched. This stricter cap is the current local default.
+
+The capped rerun passed all 26 strict programs on LLVM23 (18.40s), GCC16 (80.77s)
+and LLVM22 (32.75s). Each independent SDK/module utility output matches exactly
+at 424 bytes. Log: target/cuda-hal-all-compilers-capped.log. Compiler-derived
+lookup resolves 3,466 listed root exports and sixteen direct module surfaces;
+inventory is 3,654 entities, 199 not in using lists and 112 headers not in
+facades, plus fourteen implementation headers. Log: target/cuda-hal-api-audit.log.
+
+The initial 113-header gap list is now explicitly reviewed in
+port/api/header-review.toml. A coverage checker is included in native inventory
+CI and does not edit exports or erase implementation gaps. Its full-support
+acceptance mode correctly refuses the 23 remaining public-gap records: universal
+intrinsics, public core dump utilities (not the ignored binding tests), and
+original legacy global enum spellings. SDK/platform and implementation headers
+have separate source-based reasons; classification does not make them supported.
+These remaining public APIs, final archive/index alignment and exact-head CI
+still prevent a complete-support/release-readiness claim.
+
+The minimal default-feature macro consumer also passed all four tests with LLVM23 (40.39s); no algorithm module was enabled to obtain the additional HAL values.
+
+## Windows notice ordering regression
+
+Native 27d0b50 Windows CI failed the embedded notice drift check before
+compilation. The repository already forces generated text to LF and preserves
+upstream bytes. The actual defect was WindowsPath case-insensitive ordering
+versus PosixPath ordering. Explicit case-sensitive relative path components now
+produce one order on both hosts without changing the existing notice artifact.
+A regression test emulates Windows path comparisons, preserves CRLF comment
+bytes and rejects apparent license comments inside ordinary/raw string literals.
+It reproduces the old failure in an isolated copy and passes with the fix.
+The original 791,266-byte notice supplement still passes its drift check.
+The new Windows native CI result remains required.
+
+## Public core diagnostics and original legacy enum checkpoint
+
+Twelve public static-inline dump functions now forward to the original SDK
+implementations through ordinary module-private functions, avoiding transcribed
+formatting logic. Eight external array/vector/cache diagnostic functions retain
+their original declarations. The explicitly ignored binding-test region is not
+exported. Tests compare scalar/string/geometry/criteria/range/vector formatting
+and all four array diagnostic variants between independent native-header and
+module consumers; the cache accessor signature is checked without touching user
+cache directories. The original InpaintingModes type and six photo/video global
+constants are exported unchanged, with tests against upstream C++ equivalents.
+
+All 26 strict programs pass LLVM23 (27.99s), GCC16 (80.25s) and LLVM22 (31.03s);
+each independent SDK/module utility output matches exactly at 1,302 bytes. Log:
+target/utils-legacy-all-compilers.log. Compiler-derived lookup resolves 3,481
+listed root exports and sixteen direct module surfaces. Inventory is 3,699
+entities, 229 not in using lists (including adapters/ignored SDK helpers), 109
+headers not in facades and fourteen implementation headers. Log:
+target/utils-legacy-api-audit.log. Header review now has twenty remaining
+public-gap records, all related to universal/architecture-specific intrinsics.
+An implemented header review also requires the compiler inventory to confirm
+that its facade actually loads that header. No review label hides these gaps.
+
+The Windows job for 11aa896 has passed Embedded upstream notices match retained
+sources and progressed through the WebP stage into image codec feature tests at
+the last authoritative poll. Its whole job and the new implementation head
+still need final native CI. The case-sensitive path ordering fix has therefore
+passed the real Windows notice gate, not just local emulation.
+
+For the next SIMD work, an isolated Clang module experiment disproved namespace
+using-directive-only exports: qualified calls remain invisible after import.
+Explicit using declarations for original v_float32x4/v_load/v_setall_f32/v_add/
+v_store pass the same import-only probe without copied SDK vector types or ISA
+flags. Logs: target/simd-namespace-probe.log (expected failed experiment) and
+target/simd-explicit-using-probe.log (successful explicit-name experiment). This
+is prototype evidence only; it does not certify the unimplemented SIMD family.
+
+The isolated SIMD prototype additionally passed actual managed mcpp strict
+build/run with LLVM23, GCC16 and LLVM22 (not only syntax checks). It uses the
+original SDK vector type/load/setall/add/store through explicit using
+ declarations; no copied vector type or private ISA flags are introduced. The
+first temporary manifest lacked an explicit binary entry and was corrected;
+only target/simd-native-probe-managed-final.log is runtime acceptance evidence.
+Prototype source/manifest path: /tmp/mwrap-simd-native-probe-0pbdluu1. The twenty
+SIMD family records remain public gaps until the full surface and target matrix
+are implemented and tested.
+
+## Native 128-bit SIMD module checkpoint
+
+The optional simd feature adds core.simd plus a separate detail.simd SDK adapter
+and selected root re-export. Original SDK vector types and 220 enabled names
+are available. The frozen SDK declaration inventory drives reviewed generation;
+SSE-specific and FP16 names keep their target guards. Fifteen typed SIMD
+capability macros describe the compiled library baseline. Target validation
+rejects unsupported architectures; no empty emulator or wider-ISA feature is
+registered. READMEs stay at 51 lines per language; detailed usage is docs/simd.md.
+
+An initial combined-GMF/import form reproduced GCC's SVD default-argument
+conflict; separate header adapter/public aggregation resolves it without SDK
+patches. A deliberately unaligned input then exposed GCC importing an intrinsic
+inline body with incorrect alignment behavior: native SDK passed, module code
+segfaulted at _mm_loadu_ps. Ordinary producer-compiled forwards for the memory
+entry overloads preserve original SDK operations and pass unaligned load/store.
+One uint/unsigned-int forward redeclaration is normalized as the same overload.
+No API was removed based on compiler failure; vector classes are not copied.
+Logs: target/simd-gcc-backtrace.log, target/simd-module-gcc-memory-dedup.log.
+
+Final native SDK/module outputs match exactly at 495 bytes on LLVM23/GCC16/LLVM22;
+220 names resolve through direct and aggregate imports on each compiler. Log:
+target/simd-native-oracles-verified.log. Full all-modules,simd composition passed
+28 programs on LLVM23 (319.17s), GCC16 (587.71s) and LLVM22 (354.02s), with SIMD
+and utility SDK outputs matching 495/1302 bytes, 35 baseline interfaces and
+makePtr positive/negative checks. Only completed own binaries were cleaned
+between compiler legs. Log: target/simd-all-modules-composition.log. GCC release
+parity and surface checks pass (94.26s), including deliberately unaligned memory;
+log: target/simd-release-gcc.log. All heavy checks were serial under the shared
+eight-core/32 GiB slice, two build jobs and whole-host pressure guard.
+
+The compiler inventory now includes enabled optional facades and transitive
+namespace imports. A regression checks nested hal_baseline/simd128_cpp lookup.
+All five inventory unit tests pass. With SIMD selected, import-only probes
+resolve 3701 root names plus sixteen direct algorithm modules, while the SIMD
+checker separately covers direct/root SIMD imports. The inventory has 3948
+entities, 255 not in using lists, 102 not-in-facade and fourteen implementation
+headers. Log: target/simd-composition-api-audit.log. Counts are not overload
+behavior proof. Header review retains eight partially accepted native records
+and twelve unimplemented mode/ISA records; full-support mode refuses both.
+
+Windows 6d60a93 failed image_helpers compilation in Clang23 MSVC ABI while
+resolving the ArUco threshold constant (all other 25 programs passed). A generated
+explicit float token now replaces the imported deduced-auto/private initializer
+chain, retaining the exact pinned SDK value and qualified name. The four image
+helper contracts pass LLVM23/GCC16/LLVM22 after this change (4.71s/8.67s/4.91s).
+Log: target/aruco-explicit-float-three-compilers.log. Actual Windows confirmation
+is still required; no test or export was disabled. Native CI and final source/
+archive/index alignment remain open; no merge/tag/release readiness is claimed.
+
+## Software SIMD implementation checkpoint
+
+`simd-emulated` implies `simd` and selects the original SDK's
+CV_FORCE_SIMD128_CPP implementation in the public SIMD/macros adapters only.
+The package feature union selects one vector implementation; algorithm kernel
+ISA/dispatch settings are unchanged. Original v_reg<T,N> definitions and SDK
+function bodies are retained. After including ordinary core declarations, the
+adapter temporarily maps CV_INLINE to inline for namespace function templates
+and restores the macro. Software GCC memory templates are exported directly,
+without the native memory-call adapters.
+
+Independent original-header and import-only consumers produce identical
+644-byte results on LLVM23, GCC16 and LLVM22. Generic eight-lane arithmetic,
+bitwise operations, double conversion halves, reductions and rounding shifts
+supplement the native fixture. All 223 enabled names resolve through direct and
+aggregate imports. GCC release parity also passes (90.89s); the three debug
+checks took 2.35s after initial compilation, 73.94s and 47.65s. Switching back
+to native mode passes LLVM23 (40.76s) and GCC16 (72.39s), preserving the original
+495-byte output and 220 names. Logs: /tmp/mwrap-simd-emulated-llvm23.log and
+/tmp/mwrap-simd-emulated-matrix.log.
+
+The generic SDK v_reinterpret_as_uint refers to a missing trait member.
+Both independent original-header and import probes fail with reinterpret_uint,
+while its declaration remains exported. This is a recorded upstream behavior,
+not a deleted export or a claimed successful instantiation. Header review keeps
+one software record partial, eight native-family records partial and eleven
+other ISA/legacy headers open; full-support acceptance still rejects twenty
+unfinished records. Three-compiler all-main-module composition is running at
+/tmp/mwrap-simd-emulated-composition.log. LLVM23 has passed all 28 programs
+(314.59s), 644-byte SIMD/1302-byte utility parity, 35 interface argument guards,
+makePtr positive/negative contracts and 223 direct/root SIMD names. GCC16 and
+LLVM22 composition results remain pending. Native CI now includes software SDK
+parity on every leg and optimized software parity on Linux GCC. Those new gates
+require their own actual results before acceptance.
+
+Index checkpoint 6ff350a registers namespace-only view preparation in workspace
+CI, removes stale complete-index categories and adds a repeated rebuild
+regression. A fresh-home immutable ORT consumer passed strict inference/public
+API tests (103.25s). Index publication bytes/layout are unchanged. The index PR
+and source PR descriptions now distinguish current source work from the older
+verified immutable OpenCV archive. mcpp engine sources remain read-only.
+
+## Exact Matx/Vec template API restoration
+
+The SDK accepts determinant<float,3>(Matx33f); the former whole-operand wrapper
+rejects it with too many template arguments. Eight adaptations lost original
+argument forms: determinant, matrix/vector comma initialization, mixed-type
+matrix/vector += and -=, and matrix multiplication. Directly restoring their
+parameter patterns inside the original header producer reproduces a Clang22
+frontend crash in api_surface_test. A separate import-only prototype passes,
+so core now aggregates detail.core (original SDK facade/general adapters) and
+detail.matx (exact Matx/Vec templates over already imported original classes).
+No upstream file, engine or vector/matrix class definition is changed. Matx
+arithmetic bodies retain their prior SDK accumulator/saturation behavior.
+
+The independent original-header/import fixture exercises every argument prefix
+of those eight families, explicit second-argument conversion for initializers,
+function-pointer selection, saturation, derived-class determinant and matrix/
+vector base deduction with exact SDK reference-return types. All three compilers
+match 342 output bytes: LLVM22 2.45s, GCC16 73.41s, LLVM23 41.83s. Each also checks
+SDK/import rejection of wrong determinant/product dimensions and const left
+augmentation, rejecting compiler crashes as acceptance. Existing LLVM22 API/
+Matx behavior passes after the producer split. Logs:
+/tmp/mwrap-matx-template-matrix.log and /tmp/mwrap-matx-split-llvm22.log.
+The failing direct-definition reproduction is retained at
+/tmp/mwrap-matx-original-shapes-llvm22.log.
+
+The preceding d1c3152 software SIMD full compositions completed successfully on
+LLVM23 (314.59s), GCC16 (593.65s) and LLVM22 (357.54s): 28 programs each, 644-byte
+SIMD/1302-byte utility parity, baseline interface arguments, makePtr contracts
+and 223 SIMD names. After the Matx split, a new three-compiler all-modules,
+simd-emulated run checks 30 programs and an additional 342-byte Matx oracle at
+/tmp/mwrap-matx-split-composition.log. Native SDK/compiler/platform acceptance
+still needs the exact new source head, and final immutable archive/index pins
+are not yet aligned. No release/merge readiness is inferred from focused tests.
+
+The new composition has passed all 30 programs on LLVM23 (69.62s) and GCC16
+(156.35s), with all three output pairs identical, 37 interface argument checks,
+makePtr contracts and 223 SIMD name lookups. LLVM22 is running on the same
+source. The temporary detached worktree used to prepare the failed direct-shape
+candidate is task-owned and can be removed after this checkpoint; its failure
+and successful imported-type reproductions remain in the logs above.
+
+## Explicit SIMD compatibility operators
+
+With simd enabled, core.simd.legacy explicitly imports the compatibility header's
+21 original cv::hal operator templates. Base/root imports keep those operators
+out of their visible API; the test checks that boundary. The wrapper does not
+copy operator bodies or add another implementation owner/feature. Its generator
+extracts the exact operator list from the pinned original header.
+
+Independent SDK/import fixtures match 976 output bytes in native and software
+modes on GCC16, LLVM22 and LLVM23; software GCC release also passes. The fixture
+covers all 21 names, normal syntax, explicit function-pointer selection,
+compound reference identity and byte saturation. Native mode checks floating
+complement; the original software SDK declares v_not<float,N> without a body,
+so its floating complement and the unchanged module operator both fail to link.
+That original failure is retained at /tmp/mwrap-simd-legacy-sdk-float-not.log;
+software positive tests exercise integer complement. No broken export is pruned.
+Focused logs: /tmp/mwrap-simd-legacy-llvm23.log and
+/tmp/mwrap-simd-legacy-matrix.log.
+
+Full all-modules,simd-emulated composition has passed all 32 programs on LLVM23
+(297.73s), including SIMD 644, utility 1302, Matx 342 and legacy 976 byte-pairs,
+39 interface argument guards, makePtr contracts and 223 SIMD name lookups.
+GCC16/LLVM22 are running at /tmp/mwrap-legacy-simd-composition.log. Native CI
+and exact final archive/index alignment remain acceptance gates.
+
+The inventory selector now uses the active root's feature flags, ignoring stale
+optional source entries retained in a CDB. Active SIMD requires both actual
+adapter commands and includes the explicit legacy facade in its inventory.
+Seven parser/profile regressions pass. Header review retains legacy as partial,
+with eight native-family partial records, two software/legacy partial records
+and ten other ISA records open. This is not full-support acceptance.
+
+Further unlisted-entity review has identified explicit follow-ups for FP state
+controls, videoio opaque forward declarations and generic SIMD broadcast
+helpers. Source evidence and names are recorded in
+ target/api-audit/unlisted-next-review.json. Existing aliases or using-list
+counts do not prove those original qualified APIs are visible or callable.
+
+## Qualified FP, opaque videoio and generic broadcast APIs
+
+Restored six original cv::details FP state/function/RAII names and the original
+IVideoCapture/IVideoWriter forward declarations. They use export-using with no
+new implementation or class copy. The SDK/import oracle checks exact signatures,
+64-byte state layout, direct save/set/restore, both RAII constructors, NOOP scope
+and per-thread restoration. Opaque pointers remain incomplete as in the public
+SDK header. All three compilers match 21 bytes (LLVM23 5.46s, GCC16 9.70s,
+LLVM22 5.61s); this does not claim GPU/device implementation behavior.
+
+Type2Vec128_Traits, v_setall and vx_setall now retain the original SDK type
+mapping and ten scalar specializations. The static-inline broadcasts call
+producer-compiled exact SDK specializations; unsupported plain-char traits are
+rejected in both SDK/import probes. All three compilers match native 1311-byte
+and software 1460-byte SIMD oracles; GCC software release passes too. Generic
+broadcast function-pointer checks also run in the full composition. Call-boundary
+performance parity is unmeasured. Legacy operator output remains 976 bytes.
+
+Before the iterator-scope correction below, all 34 programs and five independent
+SDK pairs passed on LLVM23 (75.31s), GCC16 (167.16s), LLVM22 (81.14s), alongside
+39 interface guards, makePtr contracts and 226 software SIMD names.
+Logs: /tmp/mwrap-fp-state-llvm23.log, /tmp/mwrap-fp-state-matrix.log,
+/tmp/mwrap-broadcast-matrix.log, /tmp/mwrap-qualified-api-composition.log.
+
+Native fb27853 Windows job 120871685646 then found two legacy fixture failures
+(30 other programs passed). A broad using namespace cv::hal made the SDK's
+unconstrained operator!= intercept MSVC array iterator comparison through its
+base class. The fixture now imports only operator+, qualifies the other operators
+and tests a derived/base equality iterator, reproducing the issue on Linux too.
+A raw SDK Linux probe fails with the broad namespace and passes with the scoped
+operator import: /tmp/mwrap-legacy-derived-iterator-repro.log. No SDK/operator
+body was changed or test removed. Actual Windows confirmation remains required.
+
+The corrected 34-program composition passes LLVM23 (24.13s). The following GCC
+segment was stopped by the whole-host guard at 83.14% CPU, with 76.10% available
+memory and 13.95 GiB free disk; it is not counted as a pass. Metrics are retained
+in /tmp/mwrap-qualified-api-final-composition.log.resources.json. Once host CPU
+returned to 4%, only GCC16/LLVM22 were restarted under a four-core quota and one
+build job at /tmp/mwrap-qualified-api-retry.log. Other processes were untouched.
+
+The first reduced-concurrency retry then found two zero-byte, non-executable
+link outputs left by the interrupted linker. They were task-owned bin artifacts;
+that run executed fourteen programs, left twenty unrun and is not accepted as
+complete. Before relinking, host disk fell to 7.8 GiB and preflight correctly
+refused further heavy work. Only the stopped task's GCC bin directory was
+removed (9.5 GiB); object files, BMI caches, source and logs were retained.
+The GCC verification now runs the same all-modules,simd-emulated configuration
+one binary at a time and discards each executable only after a successful run.
+All 34 unique filters and all five SDK output pairs are still required. This
+bounds executable storage rather than narrowing test scope; progress and final
+per-program results are recorded at /tmp/mwrap-qualified-batched-gcc.log and
+/tmp/mwrap-qualified-batched-results.json. LLVM22 remains a separate required
+post-correction run. Index 0861946's updater, OpenKAL and site checks pass;
+its complete workspace validation remains pending.
+
+GCC's bounded-storage run has now passed all 34 unique binaries (196.50s), with
+all five SDK pairs identical (1460/1302/342/21/976 bytes), 39 interface checks,
+makePtr contracts and 226 SIMD name probes. Its JSON result lists every program.
+Only completed executables were discarded; features and test contents stayed
+unchanged. LLVM22's final post-correction composition/inventory is running at
+/tmp/mwrap-qualified-llvm22-final.log. Latest source/index native CI and final
+immutable-archive alignment are still required before readiness.
+
+LLVM22's corrected final run passed all 34 programs (30.20s), all five byte pairs,
+39 interface guards, makePtr contracts and 226 SIMD names. The corresponding
+fresh audit resolves 3715 root names and sixteen direct modules; it inventories
+3953 entities, 247 not in using lists, 103 headers outside the active facade and
+fourteen private headers. The new qualified/broadcast names are now accounted
+for. Twenty partial/other-ISA header records and remaining entity classification
+stay open; these counts are not a full-support claim. This local checkpoint is
+ready for native CI, including the actual Windows fixture confirmation.
+
+## Indexed becda22 archive and original-name audit
+
+Index checkpoint 0d7f3d1 pins becda22229cb5ed43d7ce098291cf7a4e5f7d15b,
+SHA256 67fdaec136e4acb4b0aa9d6a37c1c7952fa278180d82d6eab77dcac4211404ce,
+on all three descriptor platforms. A fresh home resolves that exact payload,
+renders the unmodified default template and passes strict build/run (4m31s),
+release packing (4m38s), isolated relocated execution, ELF closure and fifteen
+byte-identical wrapper/upstream notices. Log:
+/tmp/mwrap-becda22-template-deployment.log. A second fresh home passes the
+indexed image consumer and restored qualified FP signature/state checks
+(301.68s): /tmp/mwrap-becda22-indexed-cpu.log. These certify that source archive,
+not later uncommitted API changes. No release/tag/merge was performed.
+
+Before the Mat assignment changes below, an import-only Clang22 consumer probes
+all 247 original names absent from the using lists, with only the root module
+and explicit optional legacy SIMD module imported. After mapping diagnostics,
+the 135 successful names are recompiled together without the 112 rejected names.
+Report: target/api-audit/unlisted-import-probe/report.json; raw attempt logs are
+retained there. Name visibility does not certify overloads, signatures or runtime
+behavior. The rejected list includes SDK-ignored compatibility and private/helper
+entities, binding tests, plus real public omissions; it is not an assertion of
+112 missing public APIs. Mat augmented assignments and DNN Arg equality/backend
+utility declarations require follow-up. Other-ISA header review remains open.
+
+## Mat augmented-assignment restoration
+
+The name probe demonstrates that cv::operator^= is unavailable through the
+previous module surface. The SDK operations.hpp defines 49 augmented-assignment
+macro invocations, each with mutable and const left operands. A generator now
+expands those exact bodies/signatures in detail.matx, where original SDK types
+are imported rather than textually redeclared. Scalar/Mat/Mat_/Matx operands,
+original template order and return-reference identity are retained. Non-template
+SDK forms use the existing constrained dummy-template adaptation; class bodies
+and retained upstream files are unchanged. CI checks reproducible generation
+and compares independent SDK/module consumers.
+
+The shared behavioral fixture runs all 49 operand families with both left-operand
+qualifiers, then checks explicit typed/fixed-size signatures and selected function
+pointers. SDK/module output is identical (1049 bytes) on LLVM23 (5.86s), GCC16
+(12.84s) and LLVM22 (6.14s). Logs: /tmp/mwrap-mat-aug-llvm23.log and
+/tmp/mwrap-mat-aug-matrix.log. The complete 36-program all-modules,simd-emulated
+composition and all six SDK oracle pairs are now running under the shared
+four-core/one-build-job resource limits at /tmp/mwrap-mat-aug-composition.log;
+GCC retains bounded executable storage. Current source CI and final archive
+alignment remain required after this restoration.
+
+The complete restoration run now passes all 36 programs on LLVM23 (49.04s),
+LLVM22 (59.80s) and GCC16 (254.96s, executable storage bounded). Each matches all
+six independent SDK pairs: SIMD 1460, utilities 1302, Matx 342, FP state 21,
+Mat assignments 1049 and legacy SIMD 976 bytes. All retain 39 interface guards,
+makePtr positive/negative contracts, 226 software SIMD names and the original
+negative trait/SDK probes. GCC per-program results:
+/tmp/mwrap-mat-aug-batched-results.json. Generator check mode and byte/mtime
+idempotence pass; no retained SDK source is modified.
+
+The reusable tools/probe_unlisted_api.py verifies consumer/inventory feature
+profile equality and uses BMI mappings only from that same profile. It is now
+part of the Clang inventory CI step. Against the unchanged pinned-header
+inventory and the new Clang22 BMIs, the report has 136 visible and 111 rejected
+original names: operator^= is now visible. Output:
+target/api-audit/mat-aug-unlisted-import/report.json;
+/tmp/mwrap-mat-aug-unlisted-probe.log. This diagnostic does not turn unclassified
+rejections into accepted exclusions. DNN equality/legacy backend utility names,
+remaining entity classification, current native CI and final source/archive
+alignment still require work before the requested final readiness report.
+
+## Original DNN names and source-reviewed rejection inventory
+
+Restored the original Arg equality function in both cv::dnn and its original
+ABI namespace, plus six original Inference Engine utility declarations. No SDK
+class or implementation body is copied. An independent SDK/module fixture checks
+all six exact function signatures, equality/function-pointer identity, four
+StsNotImplemented results and two original no-op cleanup contracts. Explicit
+ABI-namespace lookup found that exporting only the public spelling was
+insufficient; both spellings now designate the same original function.
+The original incomplete cudev::GpuMat_ declaration is also exported and checked
+as an opaque pointer, without enabling a CUDA backend.
+
+With those changes, all 38 programs pass on LLVM23 (52.38s), LLVM22 (62.77s)
+and GCC16 (272.28s, bounded executable storage), matching seven SDK pairs:
+1460/1302/342/21/1049/92/976 bytes. Logs:
+/tmp/mwrap-dnn-qualified-composition.log and
+/tmp/mwrap-dnn-qualified-batched-results.json. The run retains 39 interface
+guards, makePtr contracts and the existing negative SIMD/trait probes.
+
+A final source review identified two software SIMD width enums as public,
+rather than private helper names. Their exact SDK entities are now exported in
+both public and original mode namespaces; selected-mode tests check values and
+enum type identity. The subsequent four-program SIMD/legacy suites pass on
+LLVM23 (8.29s), GCC16 (21.43s), LLVM22 (8.69s), with unchanged 1460/976-byte
+oracles and 230 enabled name spellings (two enum entities, four spellings added).
+Log: /tmp/mwrap-dnn-width-final.log. The 38-program timings above precede this
+two-enum extension; final exact-head native CI remains required.
+
+The final fresh Clang22 inventory resolves 3726 listed root names and sixteen
+direct modules. Of 3953 entities, 238 lack using-list entries: 137 resolve from
+imports, and 101 have exact source-reviewed exclusions (83 implementation/SDK
+compatibility helpers and 18 language-binding tests). Each entry in
+port/api/entity-review.toml has exact names, a reason, source SHA256 and literal
+source evidence. The validator rejects new unreviewed names, stale exclusions,
+changed source hashes and profile mismatches. Software-only helper entries are
+conditional on simd-emulated. No blanket namespace exclusion is introduced.
+Seven existing audit regression tests pass. This is review coverage, not a proof
+of all visible overloads or runtime backends.
+
+An additional independent ordinary-consumer probe then found a real overload
+problem: SDK Mat_<float> + Mat_<float> compiles, but module-only lookup fails
+because current Mat/MatExpr forwards constrain operands to exact base types.
+Raw SDK/module logs are retained in target/api-audit/typed-mat-lookup/; the
+observational probe reports sdk exit 0 and module exit 1. This is not counted as
+a passing acceptance test. Original parameter shapes/conversions and MatExpr
+assignment families require repair before full-support/merge/release readiness.
+Other-ISA header acceptance and exact final archive/index alignment remain open.
+
+## Mat expression parameter and conversion restoration
+
+The SDK/module ordinary-consumer probe above is now positive on both sides.
+All 64 Mat/MatExpr/MatShape forwards retain their original SDK parameter types,
+with the existing constrained dummy-template adaptation for non-template SDK
+functions. This restores ordinary overload ranking, derived Mat_ operands and
+implicit numeric/user conversions; exact-base-type constraints no longer reject
+valid SDK expressions. Each forward still invokes the captured exact original
+SDK function. Sixteen original MatExpr augmented-assignment bodies and the
+original deprecated Mat_ comma initializer are generated from mat.inl.hpp in
+the imported-type producer. No SDK class/body or retained source file is changed.
+
+The expanded independent oracle covers 114 assignment cases, exact signatures
+and returned references, thirteen ordinary conversion cases and comma
+initialization. SDK/module output matches 1574 bytes; the typed-Mat probe changes
+from SDK 0/module 1 to SDK 0/module 0. The initial Clang22 focused test passes
+without the earlier exact-Matx serialization crash.
+
+The first full composition attempt is not accepted: the resource guard stopped
+it when free disk reached 5.47 GiB (host CPU 7.54%, available memory 81.31%).
+No external processes were stopped. Only task-owned untracked executable bins
+were removed, after checking no live references; objects, BMIs, sources and logs
+were retained. Disk free recovered from 5.3 GiB to 16.93 GiB. Every compiler now
+uses one binary at a time, removing it only after its successful run.
+
+The complete unchanged all-modules,simd-emulated test set passes all 38 unique
+programs on LLVM23 (120.87s), GCC16 (270.10s) and LLVM22 (146.14s). Every compiler
+matches all seven SDK pairs: 1460/1302/342/21/1574/92/976 bytes. All retain
+39 interface guards, makePtr contracts, 230 enabled SIMD name spellings and
+negative SDK/trait checks. Fresh Clang audit/probes still resolve 3726 listed
+names, sixteen direct modules, 137 manual names and 101 exact source-reviewed
+rejections; seven audit regression tests pass. Logs and per-program results:
+/tmp/mwrap-mat-conversion-bounded-all.log and
+/tmp/mwrap-mat-conversion-bounded-results.json. The stopped run is retained at
+/tmp/mwrap-mat-conversion-composition.log with resource metrics beside it.
+
+Index consumption is being extended with typed-Mat addition, exact MatExpr
+assignment pointers and affine-expression values, so an older cached candidate
+cannot stand in for this restoration. Final immutable archive alignment,
+independent-home template/API/deployment tests, explicit optional capability
+matrices and exact-head native CI remain required. On 2026-10-25, the latest
+published mcpp is still v2026.10.24.1, matching all project/CI pins. No merge,
+tag or release has been performed; mcpp engine source remains unchanged.
+
+## Native SSE review profile correction
+
+Exact-head c052ccf native CI job 120910535637 fails at the strict declaration
+review gate, after compilation/behavior checks, because the software-profile
+catalog does not include 23 additional native SSE implementation helpers.
+The actual CI artifact (12565369629) has all-modules,simd without simd-emulated:
+3969 entities, 258 outside using lists, 137 visible manual names and 121 rejected
+names. The failure is not counted as success or hidden by relaxing the gate.
+
+Two exact groups now review twenty underscore-prefixed __m128i SSE emulation
+shims in intrin_sse_em.hpp and three palignr/reinterpret helpers in the explicit
+hal_sse_internal namespace in intrin_sse.hpp. Each retains source SHA256 and
+literal evidence. Groups require simd, exclude simd-emulated and apply only when
+the corresponding header is loaded. Unknown names, changed sources and stale
+exclusions still fail; the preserved software report passes and both injected
+unreviewed/stale faults are rejected. Raw probe source/logs are now included
+in the native inventory CI artifact.
+
+The actual local native SDK/module run passes all four programs (648.92s,
+one build job), matching 1311-byte SIMD and 976-byte legacy outputs. A fresh
+native audit resolves 3719 listed names and sixteen direct modules; all 121
+rejections are covered (103 implementation helpers, 18 binding tests). The
+preserved software audit still covers 101 (83 implementation, 18 binding).
+Log: /tmp/mwrap-native-entity-review.log. No library/module implementation,
+upstream source, template or build recipe is changed by this correction.
+The final source/index CI still requires the corrected HEAD.
+
+The preceding c052ccf source archive has now also passed the final actual WebP
+alpha/animation/XMP behavior, release pack, relocated execution and eighteen
+byte-identical selected notices. Log: /tmp/mwrap-c052ccf-webp-deployment.log.
+Normal template/indexed API deployment passed separately with fifteen notices.
+The corrected archive must be re-pinned and its implementation equivalence
+verified rather than silently claiming c052ccf's failing audit scripts pass.
+
+
+## Root aggregate imports in the GCC ORT configuration (2026-10-25)
+
+Source 71d0967 CI job 120923103789 passed the native all-module and SDK
+contracts, then failed the staged dnn-onnxruntime configuration: reading core
+from the root fell back to bare detail.core/detail.matx BMI filenames. The
+selected aggregate already imported these producers, but root's earlier core
+import still reached the broken indirect mapping. A fresh temporary copy with
+one actual ORT test reproduces the same two diagnostics.
+
+The root now directly imports both internal producers before public core.
+Their existing public re-exports and SDK entities are unchanged. The retained
+project passed actual CPUExecutionProvider/profile inference (131.98s).
+A second A/B replay restores the original root against the SAME warmed graph:
+it fails with both missing-BMI diagnostics again. Restoring exact formal root
+bytes passes actual CPU/profile inference (6.41s), excluding cache warmth as
+the explanation. Logs: /tmp/mwrap-gcc-ort-root-repro.log,
+/tmp/mwrap-gcc-root-import-negative.log, /tmp/mwrap-gcc-root-import-ab.log.
+
+All 38 programs pass on LLVM23 (128.68s), GCC16 (238.24s) and LLVM22 (790.55s,
+including its cold configuration rebuild). Seven SDK/module outputs remain
+1460/1302/342/21/1574/92/976 bytes. The interface, makePtr positive/negative,
+230 SIMD name and preserved SDK-negative guards pass; the fresh software
+inventory and all 101 exact rejection decisions pass. Results and log:
+/tmp/mwrap-root-import-bounded-results.json and
+/tmp/mwrap-root-import-bounded-all.log. New CDB snapshots use the
+root-import-bounded prefix; prior checkpoint evidence is retained separately.
+
+Only the root import graph changes; retained SDK bytes, implementation bodies,
+provider recipes and notices are unchanged. This source still requires a new
+immutable archive/index pin and all final native/source/index CI. The preceding
+71d0967 archive's successful deployments cannot substitute for that gate.
diff --git a/.agents/docs/2026-10-25-unified-mwrap-checkpoint.md b/.agents/docs/2026-10-25-unified-mwrap-checkpoint.md
new file mode 100644
index 0000000..fb4d838
--- /dev/null
+++ b/.agents/docs/2026-10-25-unified-mwrap-checkpoint.md
@@ -0,0 +1,8 @@
+# Unified mwrap first release
+
+Package/module: `mcpplibs.mwrap.opencv`; upstream version: `5.0.0`.
+
+This checkpoint migrates wrapper identity while retaining upstream API names and SDK sources.
+Default README is English with a mandatory Chinese counterpart; original section order is preserved.
+Validation and release evidence are recorded in the PR and the index ecosystem ledger.
+No old release tag or source resource is rewritten.
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..c91eb55
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,9 @@
+# Generated text must compare byte-for-byte on Windows as well as Unix.
+* text=auto eol=lf
+# Retain the pinned archive's original bytes, including third-party assets.
+upstream/** -text -whitespace
+*.onnx -text
+*.png -text
+*.jpg -text
+*.jpeg -text
+*.ttf -text
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a2a5133..7e69be2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,14 +15,9 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  # 0.0.102 (mcpp#258): OS-conditional [target.'cfg(os)'.build].flags, which
-  # this manifest uses to keep -msse3 on the library TUs but off the module
-  # interfaces. 0.0.101 rejects `flags` under a cfg section. (0.0.102 also
-  # carries #261 — the windows scan-deps command-line fix.) The pin tracks
-  # the latest release; 0.0.103 adds the mcpplibs index org migration +
-  # per-repo artifact adoption (mcpp#267/#269) — no manifest-grammar change,
-  # the package floor stays 0.0.102.
-  MCPP_VERSION: "2026.8.5.4"
+  # Latest stable release verified on 2026-10-24; keep this pin and
+  # .xlings.json/release.yml aligned. Engine sources stay unchanged.
+  MCPP_VERSION: "2026.10.24.1"
 
 jobs:
   # ── Platform × toolchain matrix ─────────────────────────────────────────
@@ -36,7 +31,7 @@ jobs:
   #                 signature); merged as e83ed49, green since.
   #   windows     — per-glob flags live in [target.'cfg(windows)'.build.flags]
   #                 (mcpp#258, landed in 0.0.102), still keyed on the
-  #                 gen/windows/tu/w*/ stub paths; removing the stub layer
+  #                 generated/windows/tu/w*/ stub paths; removing the stub layer
   #                 itself is tracked in #17.
   test:
     name: ${{ matrix.name }}
@@ -48,6 +43,7 @@ jobs:
       matrix:
         include:
           - name: linux-gcc
+            ort_toolchain: gcc@16.1.0
             os: ubuntu-latest
             suffix: linux-x86_64
             ext: tar.gz
@@ -59,6 +55,7 @@ jobs:
             features: true
             examples: true
           - name: linux-llvm-22
+            ort_toolchain: llvm@22.1.8
             os: ubuntu-latest
             suffix: linux-x86_64
             ext: tar.gz
@@ -87,6 +84,7 @@ jobs:
             features: false
             examples: false
           - name: macos-llvm
+            ort_toolchain: llvm@23.1.3
             os: macos-15
             suffix: macosx-arm64
             ext: tar.gz
@@ -96,6 +94,7 @@ jobs:
             features: false
             examples: false
           - name: windows-llvm
+            ort_toolchain: llvm@23.1.3
             os: windows-latest
             suffix: windows-x86_64
             ext: zip
@@ -108,6 +107,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Mwrap identity and bilingual README contract
+        run: python3 tools/check_mwrap_release.py
+
       - name: Restore mcpp registry cache
         uses: actions/cache@v4
         with:
@@ -173,10 +175,49 @@ jobs:
           done < <(find templates -name '*.cpp.in' -o -name '*.cc.in' -o -name '*.cpp' -o -name '*.cc')
           exit $fail
 
+      - name: Generated macro mappings match pinned headers
+        shell: bash
+        run: python3 tools/generate_macros.py --check
+
+      - name: Embedded upstream notices match retained sources
+        shell: bash
+        run: |
+          python3 tools/test_source_notices.py
+          python3 tools/generate_source_notices.py --check
+
+      - name: Generated scalar conversions match the pinned SDK
+        shell: bash
+        run: python3 tools/generate_saturate.py --check
+
+      - name: Generated DNN shape helpers match the pinned SDK
+        shell: bash
+        run: python3 tools/generate_dnn_shapes.py --check
+
+      - name: Generated persistence helpers match the pinned SDK
+        shell: bash
+        run: python3 tools/generate_persistence.py --check
+
+      - name: Generated portable helpers and value operators match the pinned SDK
+        shell: bash
+        run: |
+          python3 tools/generate_inline_helpers.py --check
+          python3 tools/generate_cuda_helpers.py --check
+          python3 tools/generate_simd.py --check
+          python3 tools/generate_simd_legacy.py --check
+          python3 tools/generate_objdetect_constants.py --check
+          python3 tools/generate_type_ops.py --check
+          python3 tools/generate_mat_aug_ops.py --check
+          python3 tools/test_export_diagnostics.py
+
       - name: Build
         shell: bash
         run: mcpp build
 
+      - name: Build configuration newline regression
+        if: matrix.name == 'linux-gcc'
+        shell: bash
+        run: python3 tools/test_build_config.py target/.build-mcpp/build.mcpp.bin
+
       # Guard the module-interface BMIs against non-baseline target features.
       # A src/*.cppm compiled with -msse3/-mavx/-march=… bakes that feature
       # into opencv.<mod>.pcm; a consumer TU compiled at plain baseline then
@@ -185,31 +226,155 @@ jobs:
       # (OpenCV's x86_64 baseline), so it is applied per-glob to the library
       # TUs only — this asserts it never leaked back onto an interface unit.
       - name: Module-interface baseline guard
-        if: matrix.features
         shell: bash
-        run: |
-          ninja=$(find target -name build.ninja | head -1)
-          [ -n "$ninja" ] || { echo "no build.ninja found"; exit 1; }
-          bad=0
-          for m in opencv cv core imgproc imgcodecs videoio highgui flann geometry; do
-            hits=$(grep -E "[ =/]src/${m}\.cppm" "$ninja" | grep -oE '\-m(sse[0-9._]*|avx[0-9_]*|arch=[^ ]+)' | sort -u || true)
-            if [ -n "$hits" ]; then
-              echo "::error::src/${m}.cppm carries non-baseline target feature(s): $hits — its BMI will be unloadable by baseline consumers"
-              bad=1
-            fi
-          done
-          [ $bad -eq 0 ] && echo "module interfaces are baseline (no target-feature flags)."
-          exit $bad
+        run: python3 tools/check_interface_flags.py
 
       - name: Test
         shell: bash
         run: mcpp test
 
+      - name: Candidate codec and ORT index
+        uses: actions/checkout@v4
+        with:
+          repository: mcpplibs/mcpp-index
+          ref: 7e5a54ccee615e2f8b1a32b34dd9cd7d5c2c55cb
+          path: .candidate-index
+
+      - name: WebP lossless alpha, animation and metadata
+        shell: bash
+        run: |
+          if [[ "${{ matrix.name }}" == "linux-musl-static" ]]; then
+            python3 tools/test_candidate.py --index .candidate-index --toolchain gcc@16.1.0 --target x86_64-linux-musl --features imgcodecs-webp --filter webp_codec
+          else
+            python3 tools/test_candidate.py --index .candidate-index --toolchain "${{ matrix.ort_toolchain }}" --features imgcodecs-webp --filter webp_codec
+          fi
+
+      - name: WebP disabled dependency boundary
+        if: matrix.name == 'linux-llvm-22'
+        shell: bash
+        run: python3 tools/test_candidate.py --index .candidate-index --toolchain llvm@22.1.8 --features imgcodecs --filter webp_codec --absent-dependency compat.libwebp
+
+      - name: Image codec feature tests
+        shell: bash
+        run: mcpp test --features imgcodecs-png,imgcodecs-jpeg
+
+      - name: All main modules and generated-input algorithm behavior
+        shell: bash
+        run: |
+          mcpp test --features all-modules,simd --strict --timeout 120
+          python3 tools/check_interface_flags.py
+          python3 tools/check_cpp_contracts.py
+
+      - name: C++ declaration and header coverage inventory
+        if: matrix.name == 'linux-llvm-22'
+        shell: bash
+        run: |
+          python3 tools/test_audit_api.py
+          python3 tools/check_interface_flags.py
+          python3 tools/audit_api.py --verify-exports
+          python3 tools/probe_unlisted_api.py
+          python3 tools/check_entity_review.py --require-complete
+          python3 tools/check_header_review.py
+
+      - name: Preserve C++ inventory for review
+        if: matrix.name == 'linux-llvm-22' && always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: opencv-cpp-inventory
+          path: |
+            target/api-audit/inventory.json
+            target/api-audit/includes.log
+            target/api-audit/export-consumer.log
+            target/api-audit/unlisted-import-probe/
+          if-no-files-found: error
+
+      - name: Actual default project template
+        if: matrix.name == 'linux-llvm-22'
+        shell: bash
+        run: python3 tools/test_template.py --toolchain llvm@22.1.8
+
+      - name: Native SDK versus module persistence formats
+        shell: bash
+        run: python3 tools/check_persistence_format.py
+
+      - name: Native SDK versus module portable helper behavior
+        shell: bash
+        run: python3 tools/check_utility_helpers.py
+
+      - name: Original SDK versus module Matx and Vec template contracts
+        shell: bash
+        run: python3 tools/check_matx_templates.py
+
+      - name: Original SDK versus qualified FP state and opaque videoio APIs
+        shell: bash
+        run: python3 tools/check_fp_state.py
+
+      - name: Original SDK versus Mat augmented assignment signatures and behavior
+        shell: bash
+        run: python3 tools/check_mat_aug.py
+
+      - name: Original SDK versus DNN equality and unavailable backend contracts
+        shell: bash
+        run: python3 tools/check_dnn_compat.py
+
+      - name: Native SDK versus module baseline SIMD behavior
+        shell: bash
+        run: |
+          python3 tools/check_simd.py
+          python3 tools/check_interface_flags.py
+
+      - name: Original SDK versus module software SIMD behavior
+        shell: bash
+        run: |
+          python3 tools/check_simd.py --emulated
+          python3 tools/check_interface_flags.py
+
+      - name: Optimized software SIMD behavior
+        if: matrix.name == 'linux-gcc'
+        shell: bash
+        run: python3 tools/check_simd.py --emulated --profile release
+
+      - name: Features without the optional DNN surface
+        if: matrix.name == 'linux-llvm-22'
+        shell: bash
+        run: mcpp test --features features --strict --timeout 120
+
       - name: Feature tests (dnn + unifont module interfaces)
         if: matrix.features
         shell: bash
         run: mcpp test --features dnn,unifont
 
+      - name: Linux native GTK3 window and actual window template
+        if: matrix.name == 'linux-llvm-22'
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xvfb pkg-config
+          xvfb-run -a mcpp test --features highgui-native --timeout 60
+          xvfb-run -a python3 tools/test_template.py --toolchain llvm@22.1.8 --template window --run-arg=--smoke-test
+
+      - name: Native Win32 or Cocoa window
+        if: runner.os == 'Windows' || runner.os == 'macOS'
+        shell: bash
+        run: mcpp test --features highgui-native --timeout 60
+
+      - name: Native video backend and FFmpeg file roundtrips
+        shell: bash
+        run: mcpp test --features videoio-native,videoio-ffmpeg --strict --timeout 120
+
+      - name: Actual video project template
+        if: matrix.ort_toolchain
+        shell: bash
+        run: python3 tools/test_template.py --toolchain "${{ matrix.ort_toolchain }}" --template video
+
+      - name: OpenCV ONNX Runtime CPU execution proof and actual project template
+        if: matrix.ort_toolchain
+        shell: bash
+        run: |
+          python3 tools/generate_ort_model.py --check
+          python3 tools/test_candidate.py --index .candidate-index --toolchain "${{ matrix.ort_toolchain }}"
+          python3 tools/test_template.py --index .candidate-index --template onnxruntime --toolchain "${{ matrix.ort_toolchain }}"
+
       # NOTE examples are exercised locally, not here: each one is a path-dep
       # consumer that cold-rebuilds the whole vendored OpenCV (+ffmpeg) in its
       # own target/ (~40 min per example on a 4-core runner) while adding
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 5130c4a..f0c6447 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,68 +1,49 @@
 name: Release
-
 on:
   push:
-    tags: ["v*"]
-
+    tags: ["mwrap-*"]
 permissions:
-  contents: write
-
-env:
-  # Keep in lockstep with ci.yml: the manifest needs >= 0.0.102
-  # ([target.'cfg(...)'.build.flags], mcpp#258). The previous `xlings install`
-  # path delivered whatever mcpp xlings shipped (0.0.101 at the time), which
-  # rejects cfg-section flag tables — the v0.0.9 and v0.0.10 release runs both
-  # failed on exactly that skew, while the 5-leg CI (pinned) was green.
-  MCPP_VERSION: "2026.8.5.4"
-
+  contents: read
 jobs:
-  verify-and-release:
-    name: verify (linux) + GitHub Release
+  publish:
     runs-on: ubuntu-latest
-    # Cold source-build of the vendored OpenCV + transitive compat.ffmpeg (see ci.yml).
-    timeout-minutes: 90
+    timeout-minutes: 30
+    permissions:
+      contents: write
+      actions: read
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      # Same pinned install as ci.yml: the release tarball seeds
-      # ~/.mcpp/registry (nasm included), no xlings needed.
-      - name: Download mcpp
-        shell: bash
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Check tag, upstream version and bilingual entry pages
+        run: python3 tools/check_mwrap_release.py --tag "$GITHUB_REF_NAME"
+      - name: Require successful source CI at this exact commit
         env:
-          MCPP_ARCHIVE: mcpp-${{ env.MCPP_VERSION }}-linux-x86_64.tar.gz
-          MCPP_ROOT: mcpp-${{ env.MCPP_VERSION }}-linux-x86_64
-        run: |
-          curl -L -fsS -o "$MCPP_ARCHIVE" \
-            "https://github.com/mcpp-community/mcpp/releases/download/v${MCPP_VERSION}/${MCPP_ARCHIVE}"
-          tar -xzf "$MCPP_ARCHIVE"
-          root="$PWD/$MCPP_ROOT"
-          mkdir -p "$HOME/.mcpp/registry"
-          cp -a "$root/registry/." "$HOME/.mcpp/registry/"
-          echo "$root/bin" >> "$GITHUB_PATH"
-
-      - name: Set default toolchain
-        run: |
-          mcpp toolchain install gcc 16.1.0
-          mcpp toolchain default gcc@16.1.0
-          mcpp --version
-
-      - name: Build + test at the tagged revision
-        run: |
-          mcpp build
-          mcpp test
-
-      - name: Verify tag matches package version
+          GH_TOKEN: ${{ github.token }}
+        shell: bash
         run: |
-          pkg_ver="$(sed -n 's/^version *= *"\(.*\)"/\1/p' mcpp.toml | head -1)"
-          tag="${GITHUB_REF_NAME#v}"
-          test "$pkg_ver" = "$tag" || { echo "tag $GITHUB_REF_NAME != package version $pkg_ver"; exit 1; }
-
-      - name: Create GitHub Release
+          set -euo pipefail
+          result=$(gh run list --repo "$GITHUB_REPOSITORY" --workflow ci.yml --commit "$GITHUB_SHA" --limit 1 --json status,conclusion --jq '.[0] | .status == "completed" and .conclusion == "success"')
+          test "$result" = true || { echo 'No successful source CI at the tag commit'; exit 1; }
+      - name: Build immutable source asset and publish
         env:
           GH_TOKEN: ${{ github.token }}
+        shell: bash
         run: |
-          gh release create "$GITHUB_REF_NAME" \
-            --title "opencv-m $GITHUB_REF_NAME" \
-            --generate-notes \
-            --verify-tag
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#mwrap-}"
+          repo="${GITHUB_REPOSITORY#*/}"
+          asset="${repo}-${version}.tar.gz"
+          git archive --format=tar.gz --prefix="${repo}-${version}/" "$GITHUB_SHA" > "$RUNNER_TEMP/$asset"
+          (cd "$RUNNER_TEMP" && sha256sum "$asset" > "$asset.sha256")
+          if gh release view "$GITHUB_REF_NAME" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            echo 'Release already exists; refusing to change immutable assets'; exit 1
+          fi
+          extra=()
+          if [[ "$version" == *-rc* ]]; then extra+=(--prerelease); fi
+          gh release create "$GITHUB_REF_NAME" "$RUNNER_TEMP/$asset" "$RUNNER_TEMP/$asset.sha256" \
+            --repo "$GITHUB_REPOSITORY" --verify-tag --title "$repo $version" \
+            --notes "Module wrapper for upstream $version. New mwrap package identities become installable after mcpp-index publication; see the bilingual README for the tested support scope." "${extra[@]}"
diff --git a/.gitignore b/.gitignore
index ef09318..3531aa6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -73,6 +73,7 @@ target/
 mcpp.lock
 .mcpp/
 .xlings/
+.candidate-index/
 
 # python bytecode (tools import hdr_parser from third_party)
 __pycache__/
diff --git a/.xlings.json b/.xlings.json
index da059b5..4dcdd6b 100644
--- a/.xlings.json
+++ b/.xlings.json
@@ -1,5 +1,5 @@
 {
-    "workspace": {
-        "xim:mcpp": "2026.8.5.4"
-    }
+  "workspace": {
+    "xim:mcpp": "2026.10.24.1"
+  }
 }
diff --git a/LICENSE b/LICENSE
index 261eeb9..d645695 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..4133401
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,8 @@
+opencv-m: C++ module wrapper
+Copyright (c) 2026 mcpp-community contributors
+
+The wrapper contributions are licensed under the Apache License, Version 2.0.
+Upstream code, copied interfaces, generated bindings and dependencies retain
+their original licenses and copyright notices. Original upstream README and
+license documents are retained in upstream/opencv/; provenance and checksums
+are recorded in upstream/documents.json.
diff --git a/README.md b/README.md
index 5eb5039..2c747b1 100644
--- a/README.md
+++ b/README.md
@@ -1,140 +1,77 @@
 # opencv
 
-> A C++23 module wrapper over OpenCV 5. `import opencv.cv;` replaces header inclusion while the
-> API spelling remains unchanged; the build is fully featured on three platforms, with dnn and
-> unifont available as opt-in features.
+> OpenCV 5.0.0 through C++23 modules; the upstream cv:: API is preserved.
 
-**English** · [中文](README.zh.md)
+**English** · [简体中文](README.zh.md) · [Upstream](https://github.com/opencv/opencv) · [Releases](https://github.com/mcpplibs/opencv-m/releases) · [mcpp](https://github.com/mcpp-community/mcpp) · [Index](https://github.com/mcpplibs/mcpp-index)
 
-[![Release](https://img.shields.io/github/v/release/Sunrisepeak/opencv-m)](https://github.com/Sunrisepeak/opencv-m/releases)
 [![C++23](https://img.shields.io/badge/C%2B%2B-23-blue.svg)](https://en.cppreference.com/w/cpp/23)
-[![Module](https://img.shields.io/badge/module-ok-green.svg)](https://en.cppreference.com/w/cpp/language/modules)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-
-| [mcpp build tool](https://github.com/mcpp-community/mcpp) · [package index](https://github.com/mcpp-community/mcpp-index) · [OpenCV upstream](https://github.com/opencv/opencv) · [Architecture](docs/architecture.en.md) · [Issues](https://github.com/Sunrisepeak/opencv-m/issues) · [Releases](https://github.com/Sunrisepeak/opencv-m/releases) |
-|:---:|
-| [![CI](https://github.com/Sunrisepeak/opencv-m/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Sunrisepeak/opencv-m/actions/workflows/ci.yml) |
-
-## Characteristics
-
-- **Module-based import.** Consumer code obtains the OpenCV interface through
-  `import opencv.cv;` without header inclusion, while the API and its usage remain those of
-  upstream OpenCV.
-- **Built from source, with no CMake on the consumer side.** The OpenCV 5.0.0 sources are
-  vendored under `third_party/`, the configure-time artefacts are committed as real generated
-  files under `gen/`, and mcpp compiles the whole of OpenCV — NASM SIMD included, with runtime
-  dispatch preserved — from this repository's `mcpp.toml`. The FFmpeg backend of videoio is
-  supplied by `compat.ffmpeg`. A single repository carries both the module layer and the
-  complete build.
-- **Equivalent functionality on three platforms.** Linux, macOS and Windows are each verified in
-  CI and each provide imgcodecs (PNG and JPEG), videoio (FFmpeg `cap_ffmpeg`) and optional dnn.
-  The gemm backend of dnn is selected per platform (x86 mlas/AVX, arm mlas/NEON, built-in
-  fast_gemm on Windows).
-- **Opt-in features.** `dnn` enables the `import opencv.dnn;` deep-learning module; `unifont`
-  enables `putText` rendering for Unicode and CJK text.
+[![License](https://img.shields.io/badge/license-Apache-2.0-blue.svg)](LICENSE)
+[![mcpp-community](https://img.shields.io/badge/mcpp--community-mwrap-blue)](https://github.com/mcpp-community)
+[![CI](https://github.com/mcpplibs/opencv-m/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mcpplibs/opencv-m/actions/workflows/ci.yml)
+
+Sixteen main modules, optional native windows, codecs, video and ORT CPU; pinned upstream sources are separate from adapters.
+
+## Modules
+
+Optional modules require their corresponding mcpp features.
+
+- `import mcpplibs.mwrap.opencv;`: Enabled module aggregate
+- `import mcpplibs.mwrap.opencv.core;`: Mat, types and basic operations
+- `import mcpplibs.mwrap.opencv.imgproc;`: Image processing and drawing
+- `import mcpplibs.mwrap.opencv.imgcodecs;`: Image loading and saving
+- `import mcpplibs.mwrap.opencv.highgui;`: Window API; select a backend feature
+- `import mcpplibs.mwrap.opencv.videoio;`: Video input/output
+- `import mcpplibs.mwrap.opencv.dnn;`: Neural network inference
+
+> More Modules API -> [Usage and API](docs/usage.md)
 
 ## Getting started
 
-```bash
-mcpp new myvision --template opencv && cd myvision && mcpp run -- input.png    # grayscale pipeline skeleton
+```sh
+mcpp new vision --template mcpplibs.mwrap.opencv@5.0.0
+cd vision
+mcpp run
 ```
 
-Or declare the dependency in an existing project:
-
 ```toml
-[dependencies.opencv]
-opencv = "5.0.0"
+[dependencies]
+mcpplibs.mwrap.opencv = { version = "5.0.0", features = ["imgproc", "imgcodecs-png"] }
 ```
 
 ```cpp
-import opencv.cv;   // or per module: import opencv.core; import opencv.imgproc; …
-
-int main() {
-    cv::Mat img = cv::imread("in.png", cv::IMREAD_COLOR);
-    cv::Mat gray;
-    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
-    cv::imwrite("out.png", gray);
-    return 0;
-}
+import mcpplibs.mwrap.opencv;
+namespace macros = mcpplibs::mwrap::opencv::macros;
+int main() { return cv::Mat(8, 8, macros::CV_8UC3).empty(); }
 ```
 
-## Modules
-
-| Module | Description |
-|---|---|
-| `opencv.cv` | aggregate entry point, recommended by default |
-| `opencv.core` | core: `Mat`, types, arithmetic and the operator replacement surface |
-| `opencv.imgproc` | image processing: filtering, geometric transforms, colour spaces, drawing |
-| `opencv.imgcodecs` | image reading and writing (PNG and JPEG) |
-| `opencv.videoio` | video I/O (V4L2 and FFmpeg backends, all three platforms) |
-| `opencv.highgui` | high-level GUI (headless) |
-| `opencv.flann` / `opencv.geometry` | dependency-closure modules |
-| `opencv.dnn` | deep learning (requires the `dnn` feature) |
-
-Each `opencv.<mod>` is a self-contained global module fragment that exports only its own surface;
-the modules do not import one another, and `opencv.cv` aggregates them through `export import`.
-Object-like constant macros (`CV_8UC3`, `CV_PI`, `CV_MAKETYPE`, …) are exported as `cv::`
-constexpr entities retaining the original spelling. A translation unit that needs the original
-spelling of a function-like macro (`CV_Assert`, the version macros) should include
-`<opencv-m/macros.hpp>` before the import.
-
 ## Features
 
-| Feature | Description |
-|---|---|
-| `dnn` | adds the `import opencv.dnn;` interface (`Net`, `blobFromImage`, `readNet`, …) and builds the underlying dnn together with the vendored protobuf. Available on all three platforms (per-OS features, mcpp#253): Linux and macOS use mlas (x86 AVX/AVX2/AVX512, arm NEON), while Windows uses OpenCV's built-in `fast_gemm` — upstream mlas x86 assembly is GAS/ELF syntax from which clang-cl cannot emit COFF, so the upstream path of falling back to fast_gemm in the absence of assembly is followed |
-| `unifont` | embeds the WenQuanYi Micro Hei font, enabling `putText` for Unicode and CJK text through `FontFace("uni")` |
+Core is mandatory; `default=[]`. Select capabilities explicitly.
 
-```toml
-[dependencies.opencv]
-opencv = { version = "5.0.0", features = ["dnn"] }
-```
+| Feature | Purpose |
+|---|---|
+| `all-modules` | Sixteen main modules; backends stay explicit |
+| `highgui-native` | GTK3 / Win32 / Cocoa windows |
+| `imgcodecs-png`, `imgcodecs-jpeg`, `imgcodecs-webp` | Selected image formats |
+| `videoio-native`, `videoio-ffmpeg` | Native platform / FFmpeg video |
+| `dnn-onnxruntime` | ORT CPU inference |
+| `simd`, `simd-emulated` | Native baseline / software vectors |
 
-The dnn layer adds over 300 translation units, is built only for consumers that enable it
-explicitly, and does not enter the `opencv.cv` aggregate by default. mcpp ≥ 0.0.102 is
-required: the per-OS feature semantics (mcpp#253) and the OS-conditional per-glob
-compile options (`[target.'cfg(...)'.build.flags]`, mcpp#258).
+Macro mappings use `.macros`; include `<mwrap/opencv/macros.hpp>` before imports for preprocessing macros.
 
 ## Examples
 
-| Example | Contents |
-|---|---|
-| [`examples/probe`](examples/probe) | version and build information (no input required) |
-| [`examples/gray_pipeline`](examples/gray_pipeline) | a minimal read, grayscale and write pipeline |
-| [`examples/workspace`](examples/workspace) | a multi-member workspace |
-
-```bash
-cd examples/gray_pipeline && mcpp run -- input.png
-```
+The default template generates its own image. Named templates: `:window`, `:video`, `:onnxruntime`.
+[Examples](examples) · [Usage](docs/usage.md)
 
 ## Build and toolchains
 
-The package does not pin a toolchain; mcpp resolves the environment default. CI covers five
-combinations: Linux/gcc 16, Linux/llvm 22, Linux/gcc `--target x86_64-linux-musl` (statically
-linked), macOS/llvm (arm64) and Windows/llvm.
-
-The upstream OpenCV 5.0.0 sources are vendored under `third_party/opencv-5.0.0/` as a pruned
-import of the official tag tarball, pinned by sha256 and free of patches; the process is
-reproducible through `tools/vendor/import_opencv.sh`. The platform-dependent configure-time
-snapshots live in `gen/` and were ported once from the retired compat.opencv descriptor by
-`tools/vendor/port_descriptor.py`. On the package-index side only a thin `opencv.lua` pointing at
-this repository's releases remains.
-
-Operators and a number of named free functions are defined `static inline` upstream. Such
-entities have internal linkage and cannot be re-exported through `export using` — clang rejects
-this outright, gcc merely tolerates it. This repository replaces that surface with equivalent
-external-linkage definitions across `src/core_ops.inc` (saturate_cast, Point/Size/Rect/Range/
-Scalar, Mat/MatExpr), `src/matx_ops.inc` (Matx/Vec algebra) and `src/core_fns.inc` (named free
-functions). This is the reason `import opencv.cv;` compiles under both clang and gcc.
-
-The overall structure, the responsibility of each layer and the reasoning behind the design are
-documented in the [architecture description](docs/architecture.en.md).
-
-> [!NOTE]
-> The project is at an early stage and its interface may change. Questions and suggestions are
-> welcome as [issues](https://github.com/Sunrisepeak/opencv-m/issues).
+Tested with Linux GCC/LLVM, Windows LLVM and macOS ARM64 LLVM. Window templates need a desktop session.
+Physical cameras require devices; GPU/contrib and nonbaseline ISA are outside this release.
+[Architecture](docs/architecture.en.md) · [Coverage and compiler limits](docs/coverage.md)
 
 ## License
 
-The wrapper code is MIT-licensed. The vendored OpenCV itself (`third_party/opencv-5.0.0/`) is
-Apache-2.0, with each third-party component retaining its own original license.
+[Apache-2.0](LICENSE); upstream and selected dependencies retain their notices.
+
+Wrapper: Apache-2.0, mcpp-community. [Original upstream README and licenses](upstream/opencv/). Upstream licenses remain unchanged.
diff --git a/README.zh.md b/README.zh.md
index 93ac7b8..6bcdc73 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -1,127 +1,77 @@
 # opencv
 
-> OpenCV 5 的 C++23 模块化封装。以 `import opencv.cv;` 取代头文件包含,API 拼写保持不变;
-> 三平台全功能构建,dnn 与 unifont 以特性形式按需启用。
+> 以 C++23 模块使用 OpenCV 5.0.0，保留上游 cv:: API。
 
-[English](README.md) · **中文**
+[English](README.md) · **简体中文** · [Upstream](https://github.com/opencv/opencv) · [Releases](https://github.com/mcpplibs/opencv-m/releases) · [mcpp](https://github.com/mcpp-community/mcpp) · [Index](https://github.com/mcpplibs/mcpp-index)
 
-[![Release](https://img.shields.io/github/v/release/Sunrisepeak/opencv-m)](https://github.com/Sunrisepeak/opencv-m/releases)
 [![C++23](https://img.shields.io/badge/C%2B%2B-23-blue.svg)](https://en.cppreference.com/w/cpp/23)
-[![Module](https://img.shields.io/badge/module-ok-green.svg)](https://en.cppreference.com/w/cpp/language/modules)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-
-| [mcpp 构建工具](https://github.com/mcpp-community/mcpp) · [包索引 mcpp-index](https://github.com/mcpp-community/mcpp-index) · [OpenCV 上游](https://github.com/opencv/opencv) · [架构设计](docs/architecture.md) · [Issues](https://github.com/Sunrisepeak/opencv-m/issues) · [Releases](https://github.com/Sunrisepeak/opencv-m/releases) |
-|:---:|
-| [![CI](https://github.com/Sunrisepeak/opencv-m/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Sunrisepeak/opencv-m/actions/workflows/ci.yml) |
-
-## 特性
-
-- **模块化导入**。消费者代码通过 `import opencv.cv;` 获得 OpenCV 接口,不需要头文件包含,
-  而所用 API 与调用习惯与上游一致。
-- **源码构建,消费端不执行 CMake**。OpenCV 5.0.0 源码内置于 `third_party/`,构建期配置以
-  已生成的真实文件形式提交在 `gen/`,mcpp 依据本仓库 `mcpp.toml` 直接编译整套 OpenCV
-  (含 NASM SIMD,运行时 dispatch 保留);videoio 的 FFmpeg 后端由 `compat.ffmpeg` 提供。
-  模块层与完整构建由单一仓库承载。
-- **三平台等价功能**。Linux、macOS、Windows 三平台均通过 CI 验证,各自具备 imgcodecs
-  (PNG 与 JPEG)、videoio(FFmpeg `cap_ffmpeg`)与可选的 dnn;dnn 按平台选择 gemm 后端
-  (x86 mlas/AVX、arm mlas/NEON、Windows 内置 fast_gemm)。
-- **特性可选**。`dnn` 启用 `import opencv.dnn;` 深度学习模块,`unifont` 启用 Unicode 与
-  中日韩字符的 `putText` 渲染。
+[![License](https://img.shields.io/badge/license-Apache-2.0-blue.svg)](LICENSE)
+[![mcpp-community](https://img.shields.io/badge/mcpp--community-mwrap-blue)](https://github.com/mcpp-community)
+[![CI](https://github.com/mcpplibs/opencv-m/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mcpplibs/opencv-m/actions/workflows/ci.yml)
+
+十六个主模块；原生窗口、编解码、视频和 ORT CPU 按需启用，上游源码与适配分层。
+
+## 模块
+
+可选模块需启用对应的 mcpp feature。
+
+- `import mcpplibs.mwrap.opencv;`: 已启用模块聚合
+- `import mcpplibs.mwrap.opencv.core;`: Mat、类型与基础运算
+- `import mcpplibs.mwrap.opencv.imgproc;`: 图像处理与绘制
+- `import mcpplibs.mwrap.opencv.imgcodecs;`: 图像读写
+- `import mcpplibs.mwrap.opencv.highgui;`: 窗口 API，需选择后端 feature
+- `import mcpplibs.mwrap.opencv.videoio;`: 视频输入输出
+- `import mcpplibs.mwrap.opencv.dnn;`: 神经网络推理
+
+> More Modules API -> [模块与 API](docs/usage.zh.md)
 
 ## 快速开始
 
-```bash
-mcpp new myvision --template opencv && cd myvision && mcpp run -- input.png    # 灰度管线骨架
+```sh
+mcpp new vision --template mcpplibs.mwrap.opencv@5.0.0
+cd vision
+mcpp run
 ```
 
-或在既有项目中声明依赖:
-
 ```toml
-[dependencies.opencv]
-opencv = "5.0.0"
+[dependencies]
+mcpplibs.mwrap.opencv = { version = "5.0.0", features = ["imgproc", "imgcodecs-png"] }
 ```
 
 ```cpp
-import opencv.cv;   // 或按模块:import opencv.core; import opencv.imgproc; …
-
-int main() {
-    cv::Mat img = cv::imread("in.png", cv::IMREAD_COLOR);
-    cv::Mat gray;
-    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
-    cv::imwrite("out.png", gray);
-    return 0;
-}
+import mcpplibs.mwrap.opencv;
+namespace macros = mcpplibs::mwrap::opencv::macros;
+int main() { return cv::Mat(8, 8, macros::CV_8UC3).empty(); }
 ```
 
-## 模块
-
-| 模块 | 说明 |
-|---|---|
-| `opencv.cv` | 聚合入口,推荐默认使用 |
-| `opencv.core` | 核心:`Mat`、类型、算术与运算符替换面 |
-| `opencv.imgproc` | 图像处理:滤波、几何变换、颜色空间、绘制 |
-| `opencv.imgcodecs` | 图像读写(PNG 与 JPEG) |
-| `opencv.videoio` | 视频 I/O(V4L2 与 FFmpeg 后端,三平台) |
-| `opencv.highgui` | 高层 GUI(headless) |
-| `opencv.flann` / `opencv.geometry` | 依赖闭包模块 |
-| `opencv.dnn` | 深度学习(需启用 `dnn` 特性) |
-
-每个 `opencv.<mod>` 是自包含的全局模块片段,仅导出自身表面,模块之间不互相导入;
-`opencv.cv` 通过 `export import` 聚合。对象式常量宏(`CV_8UC3`、`CV_PI`、`CV_MAKETYPE` 等)
-以保持原拼写的 `cv::` constexpr 形式导出;需要函数式宏(`CV_Assert`、版本宏)原始拼写的
-翻译单元,应在 import 之前包含 `<opencv-m/macros.hpp>`。
-
 ## 特性开关
 
-| 特性 | 说明 |
-|---|---|
-| `dnn` | 追加 `import opencv.dnn;` 接口(`Net`、`blobFromImage`、`readNet` 等)并构建底层 dnn 与内置 protobuf。三平台可用(per-OS 特性,mcpp#253):Linux 与 macOS 使用 mlas(x86 AVX/AVX2/AVX512,arm NEON);Windows 使用 OpenCV 内置 `fast_gemm` —— 上游 mlas 的 x86 汇编为 GAS/ELF 语法,clang-cl 无法产出 COFF,故沿用上游"无汇编即回退 fast_gemm"的路径 |
-| `unifont` | 内嵌 WenQuanYi Micro Hei 字体,经 `FontFace("uni")` 支持 Unicode 与中日韩字符的 `putText` |
+core 必需，`default=[]`；按需叠加以下能力。
 
-```toml
-[dependencies.opencv]
-opencv = { version = "5.0.0", features = ["dnn"] }
-```
+| Feature | 用途 |
+|---|---|
+| `all-modules` | 十六个主模块，后端仍显式选择 |
+| `highgui-native` | GTK3 / Win32 / Cocoa 窗口 |
+| `imgcodecs-png`, `imgcodecs-jpeg`, `imgcodecs-webp` | 按格式选择图像编解码 |
+| `videoio-native`, `videoio-ffmpeg` | 平台原生 / FFmpeg 视频 |
+| `dnn-onnxruntime` | ORT CPU 推理 |
+| `simd`, `simd-emulated` | 原生基线 / 软件向量 |
 
-dnn 底层多出 300 余个翻译单元,仅对显式启用者构建,且默认不进入 `opencv.cv` 聚合模块。
-要求 mcpp ≥ 0.0.102:per-OS 特性语义(mcpp#253)与按 OS 条件化的逐 glob 编译选项
-(`[target.'cfg(...)'.build.flags]`,mcpp#258)。
+宏映射位于 `.macros`；文本宏在 import 前包含 `<mwrap/opencv/macros.hpp>`。
 
 ## 示例
 
-| 示例 | 内容 |
-|---|---|
-| [`examples/probe`](examples/probe) | 版本与构建信息(无需输入) |
-| [`examples/gray_pipeline`](examples/gray_pipeline) | 读图、灰度化、写图的最小管线 |
-| [`examples/workspace`](examples/workspace) | 多成员 workspace 示例 |
-
-```bash
-cd examples/gray_pipeline && mcpp run -- input.png
-```
+默认模板自行生成图像；另有 `:window`、`:video`、`:onnxruntime` 模板。
+[示例](examples) · [使用说明](docs/usage.zh.md)
 
 ## 构建与工具链
 
-本包不固定工具链,由 mcpp 解析环境默认值。CI 覆盖五种组合:Linux/gcc 16、Linux/llvm 22、
-Linux/gcc `--target x86_64-linux-musl`(静态链接)、macOS/llvm(arm64)、Windows/llvm。
-
-上游 OpenCV 5.0.0 源码内置于 `third_party/opencv-5.0.0/`,来自官方 tag tarball 的裁剪导入,
-sha256 锁定且不含补丁,`tools/vendor/import_opencv.sh` 可复现该过程。平台相关的构建期配置
-快照位于 `gen/`,由 `tools/vendor/port_descriptor.py` 一次性移植自已退役的 compat.opencv
-描述符。包索引侧仅保留指向本仓库 Release 的薄 `opencv.lua`。
-
-运算符与部分命名自由函数在上游以 `static inline` 定义,属内部链接,无法经 `export using`
-重新导出(clang 直接拒绝,gcc 宽容)。本仓库以外部链接的等价定义替换该表面,分布于
-`src/core_ops.inc`(saturate_cast,Point/Size/Rect/Range/Scalar,Mat/MatExpr)、
-`src/matx_ops.inc`(Matx/Vec 代数)与 `src/core_fns.inc`(命名自由函数)。这是
-`import opencv.cv;` 能在 clang 与 gcc 上同时编译的原因。
-
-整体结构、各层职责与设计依据详见[架构设计说明](docs/architecture.md)。
+已验证 Linux GCC/LLVM、Windows LLVM、macOS ARM64 LLVM；窗口需要桌面会话。
+真实摄像头需要设备；GPU/contrib 与非基线 ISA 不在本次发布范围。
+[架构](docs/architecture.en.md) · [覆盖与编译器限制](docs/coverage.md)
 
-> [!NOTE]
-> 本项目处于早期阶段,接口可能调整。问题与建议欢迎提交
-> [issue](https://github.com/Sunrisepeak/opencv-m/issues)。
+## 许可证
 
-## 许可
+[Apache-2.0](LICENSE)；保留上游及选中依赖的通知。
 
-封装代码采用 MIT 许可。内置的 OpenCV 本体(`third_party/opencv-5.0.0/`)采用 Apache-2.0 许可,
-其中各第三方组件保留各自原始许可。
+封装：Apache-2.0，mcpp-community。[上游原始 README 与许可证](upstream/opencv/)，上游许可保持原样。
diff --git a/build.mcpp b/build.mcpp
index 7b079aa..ffc8d3b 100644
--- a/build.mcpp
+++ b/build.mcpp
@@ -1,39 +1,15 @@
-// build.mcpp — opencv-m single-repo build glue. Covers exactly what the
-// mcpp.toml manifest grammar cannot express (v0.0.101), nothing more:
-//
-//   1. per-OS generated-config include dirs: the frozen config snapshots live
-//      in gen/<os>/ (cvconfig.h, cv_cpu_config.h, per-ISA dispatch TU headers)
-//      + gen/common/ overlaps; the manifest has no [target.'cfg(os)']
-//      include_dirs key, so the per-OS -I list is read from
-//      gen/<os>/INCLUDE_DIRS.txt (written by tools/vendor/port_descriptor.py)
-//      and emitted as PRIVATE include dirs — consumers only ever need
-//      gen/common (opencv2/opencv_modules.hpp), which is declarative in
-//      [build].include_dirs.
-//   2. per-OS dnn sources (feature-gated): [features.dnn] carries only the
-//      OS-neutral subset (no per-OS features in the manifest grammar); the
-//      per-OS remainder — ISA dispatch TUs, mlas, feature stubs — is listed
-//      in gen/<os>/DNN_SOURCES.txt and injected here.
-//   3. unifont: when the `unifont` feature is on, hex-embed the vendored
-//      assets/WenQuanYiMicroHei.ttf.gz into $MCPP_OUT_DIR/builtin_font_uni.h
-//      (symbol OcvBuiltinFontUni; byte-faithful port of cmake ocv_blob2hdr —
-//      the COMPRESSED bytes are embedded, OpenCV inflates at runtime).
-//
-// Style: modules-first per docs/07 — directives and the env contract go
-// through `import mcpp;` (the module is bundled in the mcpp binary, so it
-// always matches the protocol). `import std;` is NOT available in the
-// build.mcpp compile context — empirically verified 2026-07-21: only the
-// bundled `mcpp` module is wired up there (regular project TUs can import
-// std, this special TU cannot). Textual std includes remain for the file
-// I/O this program does itself, and MUST precede the import. Diagnostics go to stdout as
-// non-directive lines (never stderr: it can interleave into the buffered
-// directive stream).
+// OpenCV target configuration and selected source catalogs. The upstream
+// implementation stays unchanged; outputs are private to this build instance.
 #include <algorithm>
+#include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <sstream>
+#include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
 import mcpp;
@@ -121,16 +97,278 @@ static std::vector<std::string> expand_glob_line(const fs::path& man, const std:
     return files;
 }
 
-int main() {
+static std::string c_string(const std::string& value) {
+    std::string result = "\"";
+    for (char c : value) {
+        if (c == '\\' || c == '\"') result += '\\';
+        if (c == '\n') result += "\\n";
+        else if (c == '\r') result += "\\r";
+        else result += c;
+    }
+    return result + "\"";
+}
+
+static void inject_catalog(const fs::path& man, const std::string& os,
+                           const std::string& feature) {
+    std::string relative = "port/config/sources/" + os + "/" + feature + ".txt";
+    std::ifstream input(man / relative);
+    if (!input) return;
+    std::string line;
+    while (std::getline(input, line)) {
+        while (!line.empty() && (line.back() == '\r' || line.back() == ' ')) line.pop_back();
+        if (line.empty() || line[0] == '#') continue;
+        for (const auto& source : expand_glob_line(man, line)) mcpp::source(source.c_str());
+    }
+    mcpp::rerun_if_changed(relative.c_str());
+}
+
+static std::string shell_quote(const std::string& value) {
+    std::string result = "'";
+    for (char c : value) result += c == '\'' ? "'\\''" : std::string(1, c);
+    return result + "'";
+}
+
+static std::vector<std::string> flag_words(const std::string& value) {
+    std::vector<std::string> words;
+    std::string word;
+    char quote = 0;
+    bool escape = false;
+    for (char c : value) {
+        if (escape) { word += c; escape = false; }
+        else if (c == '\\' && quote != '\'') escape = true;
+        else if (quote) { if (c == quote) quote = 0; else word += c; }
+        else if (c == '\'' || c == '"') quote = c;
+        else if (std::isspace(static_cast<unsigned char>(c))) {
+            if (!word.empty()) { words.push_back(word); word.clear(); }
+        } else word += c;
+    }
+    if (quote || escape) throw std::runtime_error("malformed GTK pkg-config flags");
+    if (!word.empty()) words.push_back(word);
+    return words;
+}
+
+static std::string configure_highgui(const fs::path& out, const std::string& os) {
+    const bool native = mcpp::has_feature("highgui-native");
+    const bool gtk = mcpp::has_feature("highgui-gtk3") || (native && os == "linux");
+    const bool win32 = mcpp::has_feature("highgui-win32") || (native && os == "windows");
+    const bool cocoa = mcpp::has_feature("highgui-cocoa") || (native && os == "macosx");
+    if (native && os != "linux" && os != "windows" && os != "macosx")
+        throw std::runtime_error("highgui-native supports Linux, Windows and macOS desktop targets");
+    if ((gtk && os != "linux") || (win32 && os != "windows") || (cocoa && os != "macosx"))
+        throw std::runtime_error("selected highgui backend does not support this target OS");
+    std::string backend = "NONE";
+    if (gtk) {
+        if (std::string(mcpp::target_arch()) != "x86_64")
+            throw std::runtime_error("the current GTK3 SDK closure is supported on Linux x86_64 only");
+        if (std::string(mcpp::target_libc()) == "musl")
+            throw std::runtime_error("highgui-gtk3 requires the glibc GTK SDK; musl is not supported");
+        const std::string sdk = mcpp::xpkg_dir("xim", "gtk3");
+        const std::string pc = mcpp::pkg_config_libdir();
+        if (sdk.empty() || pc.empty())
+            throw std::runtime_error("highgui-gtk3 requires the declared xim:gtk3@3.24.43 SDK");
+        const fs::path xtst = mcpp::xpkg_dir("xim", "libXtst");
+        if (xtst.empty() || !fs::exists(xtst / "lib/libXtst.so"))
+            throw std::runtime_error("highgui-gtk3 requires the declared xim:libXtst@1.2.5 SDK");
+        // The Xtst payload exports its libraries/headers but not an xtst.pc
+        // asset. Supply that metadata from its exact declared payload, never
+        // from the host pkg-config database.
+        const auto pc_extra = out / "gtk-pkgconfig";
+        spew(pc_extra / "xtst.pc", "prefix=" + xtst.string() +
+             "\nlibdir=${prefix}/lib\nincludedir=${prefix}/include\n"
+             "Name: Xtst\nDescription: Declared XTest SDK\nVersion: 1.2.5\n"
+             "Requires: x11 xext xi\nLibs: -L${libdir} -lXtst\nCflags: -I${includedir}\n");
+        const auto flags = out / "gtk3-flags.txt";
+        const std::string command = "PKG_CONFIG_PATH= PKG_CONFIG_LIBDIR=" + shell_quote(pc_extra.string() + ":" + pc)
+            + " pkg-config --cflags --libs gtk+-3.0 > " + shell_quote(flags.string());
+        if (std::system(command.c_str()))
+            throw std::runtime_error("pkg-config could not resolve the declared GTK3 SDK");
+        for (const auto& flag : flag_words(slurp(flags))) {
+            if (flag.starts_with("-I")) mcpp::include_dir(flag.substr(2).c_str());
+            else if (flag.starts_with("-L")) {
+                mcpp::link_search(flag.substr(2).c_str());
+                mcpp::runtime_search_dir(flag.substr(2).c_str());
+            } else if (flag.starts_with("-l")) mcpp::link_lib(flag.substr(2).c_str());
+            else if (flag == "-pthread") mcpp::link_flag(flag.c_str());
+            else { mcpp::cxxflag(flag.c_str()); mcpp::link_flag(flag.c_str()); }
+        }
+        mcpp::runtime_search_dir((fs::path(sdk) / "lib").string().c_str());
+        mcpp::define("HAVE_GTK");
+        mcpp::define("HAVE_GTK3");
+        mcpp::source("upstream/opencv/modules/highgui/src/window_gtk.cpp");
+        backend = "GTK3";
+    } else if (win32) {
+        mcpp::define("HAVE_WIN32UI");
+        mcpp::source("upstream/opencv/modules/highgui/src/window_w32.cpp");
+        for (const char* lib : {"user32", "gdi32", "comdlg32", "advapi32"}) mcpp::link_lib(lib);
+        backend = "WIN32UI";
+    } else if (cocoa) {
+        mcpp::define("HAVE_COCOA");
+        mcpp::source("upstream/opencv/modules/highgui/src/window_cocoa.mm");
+        mcpp::link_flag("-framework");
+        mcpp::link_flag("Cocoa");
+        backend = "COCOA";
+    }
+    spew(out / "opencv_highgui_config.hpp",
+         "#pragma once\n#define OPENCV_HIGHGUI_BUILTIN_BACKEND_STR \"" + backend + "\"\n"
+         + (backend == "NONE" ? "#define OPENCV_HIGHGUI_WITHOUT_BUILTIN_BACKEND 1\n" : ""));
+    return backend;
+}
+
+static std::string configure_videoio(const fs::path& man, const std::string& os) {
+    const bool native = mcpp::has_feature("videoio-native");
+    const bool v4l = mcpp::has_feature("videoio-v4l2") || (native && os == "linux");
+    const bool msmf = mcpp::has_feature("videoio-msmf") || (native && os == "windows");
+    const bool avf = mcpp::has_feature("videoio-avfoundation") || (native && os == "macosx");
+    if ((native && os != "linux" && os != "windows" && os != "macosx") ||
+        (v4l && os != "linux") || (msmf && os != "windows") || (avf && os != "macosx"))
+        throw std::runtime_error("selected native videoio backend does not support this target OS");
+    if (v4l) {
+        mcpp::define("HAVE_CAMV4L2");
+        if (!mcpp::has_feature("videoio-v4l2")) inject_catalog(man, os, "videoio-v4l2");
+        return "V4L2";
+    }
+    if (msmf) {
+        if (std::string(mcpp::target_env()) != "msvc")
+            throw std::runtime_error("videoio-msmf is supported with the Windows MSVC ABI SDK only");
+        mcpp::define("HAVE_MSMF");
+        mcpp::source("upstream/opencv/modules/videoio/src/cap_msmf.cpp");
+        for (const char* lib : {"mfplat", "mf", "mfuuid", "mfreadwrite", "strmiids", "dxgi",
+                                "shlwapi", "ole32", "oleaut32", "uuid", "comsuppw"})
+            mcpp::link_lib(lib);
+        return "MSMF";
+    }
+    if (avf) {
+        mcpp::define("HAVE_AVFOUNDATION");
+        mcpp::source("upstream/opencv/modules/videoio/src/cap_avfoundation_mac.mm");
+        for (const char* framework : {"Cocoa", "Accelerate", "AVFoundation", "CoreGraphics",
+                                     "CoreMedia", "CoreVideo", "QuartzCore"}) {
+            mcpp::link_flag("-framework");
+            mcpp::link_flag(framework);
+        }
+        return "AVFOUNDATION";
+    }
+    return "NONE";
+}
+
+int main() try {
     fs::path man = mcpp::manifest_dir()[0] ? mcpp::manifest_dir() : ".";
 
     // 1. per-OS include dirs
     std::string os = mcpp::target_os()[0] ? mcpp::target_os() : "linux";
-    if (os == "macos") os = "macosx";  // gen/ keeps the descriptor-era dir name
-    // windows compiles through the gen/windows/tu/w*/ stub namespace (see
+    if (mcpp::has_feature("simd") && !mcpp::has_feature("simd-emulated")) {
+        const std::string arch = mcpp::target_arch();
+        if (arch != "x86_64" && arch != "aarch64") {
+            std::printf("opencv-m: simd currently supports x86_64 SSE2 and aarch64 NEON baselines\n");
+            return 1;
+        }
+    }
+    if (os == "macos") os = "macosx";  // generated/ keeps the descriptor-era dir name
+    if (!mcpp::out_dir()[0]) {
+        std::printf("opencv-m: MCPP_OUT_DIR is required\n");
+        return 1;
+    }
+    if (mcpp::has_feature("videoio-v4l2") && os != "linux") {
+        std::printf("opencv-m: videoio-v4l2 requires a Linux target\n");
+        return 1;
+    }
+    fs::path out = mcpp::out_dir();
+    mcpp::include_dir(out.string().c_str());
+    const std::string gui = configure_highgui(out, os);
+    const std::string native_video = configure_videoio(man, os);
+    if (mcpp::has_feature("dnn-onnxruntime")) {
+        const std::string arch = mcpp::target_arch();
+        const std::string env = mcpp::target_env();
+        if (!((os == "linux" && arch == "x86_64" && env == "gnu") ||
+              (os == "windows" && arch == "x86_64" && env == "msvc") ||
+              (os == "macosx" && arch == "aarch64")))
+            throw std::runtime_error("dnn-onnxruntime supplies CPU SDKs for Linux x86_64 glibc, Windows x86_64 MSVC ABI and macOS arm64 only");
+    }
+    // Newly integrated modules use the upstream baseline dispatch path.
+    // Their optional OpenCL backends remain unavailable until actual kernel
+    // embeddings and runtime validation are provided; never fake that flag.
+    for (const char* name : {"features", "objdetect", "photo", "ptcloud", "stereo", "stitching", "video"}) {
+        spew(out / (std::string("opencl_kernels_") + name + ".hpp"),
+             "#pragma once\n#include <opencv2/core/ocl.hpp>\n"
+             "#include <opencv2/core/ocl_genbase.hpp>\n#include <opencv2/core/opencl/ocl_defs.hpp>\n"
+             "#ifdef HAVE_OPENCL\n#error OpenCL kernels for this module are not integrated\n#endif\n");
+    }
+    for (const char* name : {"sift", "lkpyramid"})
+        spew(out / (std::string(name) + ".simd_declarations.hpp"),
+             "#define CV_CPU_DISPATCH_MODES_ALL BASELINE\n");
+    inject_catalog(man, os, "core");
+    std::vector<std::string> modules;
+    std::istringstream module_list(slurp(man / "port/config/modules.txt"));
+    std::string module;
+    while (std::getline(module_list, module)) {
+        while (!module.empty() && (module.back() == '\r' || module.back() == ' ')) module.pop_back();
+        if (module.empty() || (module != "core" && !mcpp::has_feature(module.c_str()))) continue;
+        modules.push_back(module);
+        if (module != "core" && module != "dnn") inject_catalog(man, os, module);
+    }
+    mcpp::rerun_if_changed("port/config/modules.txt");
+    for (const char* feature : {"imgcodecs-jpeg", "imgcodecs-png", "videoio-ffmpeg", "videoio-v4l2"})
+        if (mcpp::has_feature(feature)) inject_catalog(man, os, feature);
+    // Imports must be direct module declarations (GCC rejects them inside
+    // included headers). Generate the complete selected interface before
+    // mcpp scans it; there are no conditional imports for its scanner to guess.
+    std::ostringstream imports;
+    if (mcpp::has_feature("dnn-onnxruntime"))
+        imports << "export import mcpplibs.mwrap.onnxruntime;\n";
+    // Keep every adapter in the aggregate's direct dependency graph too.
+    // GCC's mapper for cross-package self-tests otherwise mixes default and
+    // explicit BMI paths for indirect internal imports (notably with ORT).
+    imports << "export import mcpplibs.mwrap.opencv.detail.core;\n"
+               "export import mcpplibs.mwrap.opencv.detail.matx;\n"
+               "export import mcpplibs.mwrap.opencv.core;\n";
+    if (mcpp::has_feature("simd"))
+        imports << "export import mcpplibs.mwrap.opencv.detail.simd;\n"
+                   "export import mcpplibs.mwrap.opencv.core.simd;\n";
+    for (const auto& name : modules)
+        if (name != "core") imports << "export import mcpplibs.mwrap.opencv.detail." << name << ";\n";
+    for (const auto& name : modules)
+        if (name != "core") imports << "export import mcpplibs.mwrap.opencv." << name << ";\n";
+    std::string aggregate = slurp(man / "src/selected.cppm.in");
+    const std::string marker = "@MCPP_OPENCV_IMPORTS@";
+    auto marker_at = aggregate.find(marker);
+    if (marker_at == std::string::npos) {
+        std::printf("opencv-m: src/selected.cppm.in has no import marker\n");
+        return 1;
+    }
+    aggregate.replace(marker_at, marker.size(), imports.str());
+    const auto aggregate_path = out / "selected.cppm";
+    spew(aggregate_path, aggregate);
+    mcpp::generated(aggregate_path.string().c_str());
+    mcpp::rerun_if_changed("src/selected.cppm.in");
+
+    std::string config = slurp(man / ("generated/" + os + "/cvconfig.h"));
+    config.erase(std::remove(config.begin(), config.end(), '\r'), config.end());
+    for (const auto& entry : {std::pair{"HAVE_JPEG", "imgcodecs-jpeg"},
+                              std::pair{"HAVE_PNG", "imgcodecs-png"}}) {
+        if (!mcpp::has_feature(entry.second)) {
+            const std::string definition = std::string("#define ") + entry.first;
+            auto at = config.find(definition + "\n");
+            if (at != std::string::npos) config.replace(at, definition.size(), std::string("/* #undef ") + entry.first + " */");
+        }
+    }
+    if (mcpp::has_feature("imgcodecs-webp")) config += "\n#define HAVE_WEBP 1\n";
+    spew(out / "cvconfig.h", config);
+    spew(out / "opencv2/cvconfig.h", config);
+    std::ostringstream report;
+    report << "OpenCV 5.0.0 (mcpplibs.mwrap.opencv 5.0.0)\nTarget: " << os << "\nModules:";
+    for (const auto& name : modules) report << ' ' << name;
+    report << "\nJPEG: " << (mcpp::has_feature("imgcodecs-jpeg") ? "YES" : "NO")
+           << "\nPNG: " << (mcpp::has_feature("imgcodecs-png") ? "YES" : "NO")
+           << "\nWEBP: " << (mcpp::has_feature("imgcodecs-webp") ? "YES" : "NO")
+           << "\nFFmpeg: " << (mcpp::has_feature("videoio-ffmpeg") ? "YES" : "NO") << "\n";
+    report << "Window backend: " << gui << "\n";
+    report << "Native video backend: " << native_video << "\n";
+    report << "DNN ONNX Runtime: " << (mcpp::has_feature("dnn-onnxruntime") ? "CPU (1.25.1)" : "NO") << "\n";
+    spew(out / "version_string.inc", c_string(report.str()) + "\n");
+
+    // windows compiles through the generated/windows/tu/w*/ stub namespace (see
     // mcpp.toml header comment; workaround for mcpp-community/mcpp#258) —
     // same INCLUDE_DIRS/DNN_SOURCES machinery as the other OSes from here on.
-    std::string listrel = "gen/" + os + "/INCLUDE_DIRS.txt";
+    std::string listrel = "generated/" + os + "/INCLUDE_DIRS.txt";
     std::ifstream list(man / listrel);
     if (!list) {
         std::printf("opencv-m build.mcpp: %s missing — no frozen snapshot for target OS '%s'\n",
@@ -148,7 +386,24 @@ int main() {
 
     // 2. per-OS dnn sources (feature-gated)
     if (mcpp::has_feature("dnn")) {
-        std::string dnnrel = "gen/" + os + "/DNN_SOURCES.txt";
+        fs::path ort_backend;
+        if (os == "windows" && mcpp::has_feature("dnn-onnxruntime")) {
+            // Keep the vendor byte-faithful. ORT expects a native wide path
+            // on Windows; upstream's model path handles this but its profile
+            // call currently passes char*. Generate a private adapted TU.
+            const auto original = "upstream/opencv/modules/dnn/src/net_impl_backend.cpp";
+            std::string text = slurp(man / original);
+            const std::string call = "opts.EnableProfiling(ort_profile_path_prefix.c_str());";
+            const auto at = text.find(call);
+            if (at == std::string::npos || text.find(call, at + 1) != std::string::npos)
+                throw std::runtime_error("upstream ORT profiling call changed; review the Windows path adapter");
+            text.replace(at, call.size(), "opts.EnableProfiling(mwrap_opencv_port::ort_profile_path(ort_profile_path_prefix).c_str());");
+            ort_backend = out / "port/modules/dnn/src/net_impl_backend.cpp";
+            spew(ort_backend, "#include <mwrap/opencv/ort_profile_path.hpp>\n" + text);
+            mcpp::include_dir("upstream/opencv/modules/dnn/src");
+            mcpp::rerun_if_changed(original);
+        }
+        std::string dnnrel = "generated/" + os + "/DNN_SOURCES.txt";
         std::ifstream dl(man / dnnrel);
         if (dl) {
             int injected = 0;
@@ -157,7 +412,9 @@ int main() {
                 while (!dline.empty() && (dline.back() == '\r' || dline.back() == ' ')) dline.pop_back();
                 if (dline.empty() || dline[0] == '#') continue;
                 for (const std::string& one : expand_glob_line(man, dline)) {
-                    mcpp::source(one.c_str());
+                    if (!ort_backend.empty() && one.ends_with("net_impl_backend.cpp"))
+                        mcpp::source(ort_backend.string().c_str());
+                    else mcpp::source(one.c_str());
                     injected++;
                 }
             }
@@ -179,4 +436,7 @@ int main() {
     std::printf("opencv-m build.mcpp: include dirs for '%s' emitted\n", os.c_str());
     std::fflush(stdout);
     return 0;
+} catch (const std::exception& error) {
+    std::fprintf(stderr, "opencv-m: %s\n", error.what());
+    return 1;
 }
diff --git a/docs/architecture.en.md b/docs/architecture.en.md
index 56e8a7e..5222a2d 100644
--- a/docs/architecture.en.md
+++ b/docs/architecture.en.md
@@ -1,236 +1,167 @@
-# opencv-m Architecture
-
-[中文](architecture.md) · **English**
-
-This document describes the structure of opencv-m, the responsibility of each layer, and the
-reasoning behind the principal design decisions. It is addressed to developers who intend to
-modify this repository, or who need to understand the general problem of wrapping a large
-header-based C++ library in C++23 modules.
-
----
-
-## 1. Objectives and constraints
-
-opencv-m must satisfy three requirements simultaneously; in existing approaches these conflict:
-
-1. **Module-based consumption**: `import opencv.cv;` replaces `#include <opencv2/opencv.hpp>`
-   while the API spelling remains unchanged (`cv::Mat`, `cv::cvtColor`).
-2. **No OpenCV installation and no CMake on the consumer side**: once the dependency is
-   declared, mcpp performs the entire build.
-3. **No reduction in functionality**: imgcodecs (PNG/JPEG), videoio (FFmpeg backend) and dnn
-   are available on Linux, macOS and Windows alike, with runtime SIMD dispatch preserved.
-
-Two constraints govern the design. First, OpenCV's build configuration is produced by CMake:
-`cvconfig.h`, `cv_cpu_config.h` and the per-module SIMD dispatch translation units are all
-configure-time artefacts, which a consumer cannot obtain without running CMake. Second, the
-export semantics of C++ modules are stricter than those of headers: macros do not cross a module
-boundary, and entities with internal linkage (`static inline`) cannot be re-exported through
-`export using` — clang rejects this outright, gcc merely tolerates it.
-
-The architecture of this repository is a systematic response to those two constraints.
-
-## 2. Layering
-
-```
-consumer project
-  └─ import opencv.cv;                     ← module interface layer
-        └─ src/*.cppm  +  src/*.inc        ← export surface (generated + hand-written replacements)
-              └─ third_party/opencv-5.0.0  ← vendored upstream source (patch-free)
-                   +  gen/                 ← frozen configuration snapshots (CMake substitute)
-                   +  mcpp.toml / build.mcpp ← build description (CMakeLists substitute)
-                   +  compat.ffmpeg        ← the single external dependency (videoio backend)
-```
-
-### 2.1 Vendored upstream source — `third_party/opencv-5.0.0/`
-
-A pruned import of the official OpenCV 5.0.0 tag tarball, pinned by sha256 and carrying **no
-patches**. Eight modules are retained (core, imgproc, imgcodecs, highgui, videoio, dnn, flann,
-geometry) together with seven third-party components (libjpeg-turbo, libpng, zlib, protobuf,
-mlas, flatbuffers, dlpack). The test and perf trees and the language-binding directories are
-removed, with the exception of `modules/python/src2`, whose `hdr_parser.py` is an input to the
-export-surface generator. The result is 1969 files, 48 MB.
-
-The patch-free property is a deliberate constraint: on an upstream version bump,
-`tools/vendor/import_opencv.sh` re-imports the tree and no patch set has to be replayed. All
-platform differences are pushed outward into `gen/` and `mcpp.toml`.
-
-### 2.2 Frozen configuration snapshots — `gen/`
-
-The headers and derived translation units that CMake emits at configure time are committed here
-as **real, already-generated files**:
-
-| Directory | Contents | Size |
-|---|---|---|
-| `gen/common/` | artefacts byte-identical across all three platforms (SIMD dispatch wrapper TUs, `opencv_modules.hpp`, …) plus `gen/common/synth/` (fonts, OpenCL kernels) | 257 files |
-| `gen/linux/`, `gen/macosx/`, `gen/windows/` | platform-dependent `cvconfig.h`, `cv_cpu_config.h`, …, each with `INCLUDE_DIRS.txt` and `DNN_SOURCES.txt` | 43–45 files each |
-
-The snapshots were ported once from the retired `compat.opencv` descriptor by
-`tools/vendor/port_descriptor.py`, a process that included cross-platform de-duplication,
-conflict detection and byte-level verification. Committing generated artefacts rather than
-running CMake at build time is what makes "no CMake on the consumer side" attainable; the cost
-is that an upstream bump requires the port to be re-run.
-
-### 2.3 Build description — `mcpp.toml` and `build.mcpp`
-
-`mcpp.toml` (about 1500 lines) carries everything that can be declared: source globs, public
-include directories, 51 per-glob compile-option groups assigned to their OS under
-`[target.'cfg(...)'.build.flags]`, platform-conditional source sets under
-`[target.'cfg(os)'.build]`, the `[features]` definitions, and the single external dependency
-`compat.ffmpeg`.
-
-`build.mcpp` covers only the three things the manifest grammar **cannot** express, and nothing
-further:
-
-1. reading `gen/<os>/INCLUDE_DIRS.txt` for the target platform and emitting private include
-   directories (the manifest has no platform-conditional `include_dirs` key);
-2. injecting the platform-dependent sources listed in `gen/<os>/DNN_SOURCES.txt` when the `dnn`
-   feature is active (the manifest has no platform × feature cross dimension);
-3. embedding `assets/WenQuanYiMicroHei.ttf.gz` as a hex header when the `unifont` feature is
-   active (equivalent to CMake's `ocv_blob2hdr`).
-
-The file is written modules-first and uses the typed API via `import mcpp;`. Note that
-`import std;` is not available in the build.mcpp compilation context — only the bundled `mcpp`
-module is wired up there — so textual std includes remain, and must precede the import.
-
-### 2.4 Module interface layer — `src/`
-
-Each `opencv.<mod>` is self-contained: the corresponding upstream headers are included in the
-global module fragment, and names are exported individually in the purview via
-`export using cv::name;`. The modules do not import one another; `opencv.cv` is the sole
-aggregate entry point and `export import`s the submodules.
-
-The export surface is composed of two parts:
-
-- **Generated** — `src/gen_exports/*.inc` (2267 lines). `tools/gen_exports.py` invokes upstream
-  `hdr_parser.py` to enumerate the `CV_EXPORTS_W` surface, then overlays the manually curated
-  names in `tools/curated/<mod>.txt` — entities the wrapper generator cannot see, such as the
-  template typedef families (`Point2i`, `Vec3b`, `Matx33f`), the `InputArray` family and the
-  traits. Names are de-duplicated across modules, so each entity has exactly one home module.
-- **Hand-written replacements** — `src/*_ops.inc` and `src/core_fns.inc`; see §3.1.
-
-`tools/prune_loop.py` closes the loop around the generator: on a failed build it parses the
-errors that point into `gen_exports/*.inc`, appends the offending names together with their
-reason to `tools/curated/<mod>.prune.txt`, regenerates and retries until the build is green.
-431 lines have been pruned to date.
-
-## 3. Principal design decisions
-
-### 3.1 Replacement layer for internally-linked entities
-
-OpenCV defines its operators and a number of named free functions as `static inline` in headers.
-Such entities have internal linkage and cannot be re-exported through `export using`. This
-repository replaces that surface with equivalent `inline` (external linkage) definitions, in
-three files:
-
-| File | Coverage |
-|---|---|
-| `src/core_ops.inc` | `saturate_cast`, Point/Size/Rect/Range/Scalar, Mat/MatExpr operators |
-| `src/matx_ops.inc` | Matx/Vec algebra |
-| `src/core_fns.inc` | named free functions (`cv::format`, `cv::print`, … re-implemented to upstream semantics) |
-
-This layer is the direct reason `import opencv.cv;` compiles under clang (macOS/Windows) and gcc
-alike. In mixed translation units — those that both include headers and import modules — the
-upstream exact-match `static inline` overloads remain more specialised, so semantics are
-unchanged.
-
-### 3.2 Deduction form of template parameters (a clang BMI constraint)
-
-An empirically established constraint applies on clang 20 and 22: a function or operator template
-whose parameters are not fully bound by its **first argument**, once serialised into a module BMI,
-crashes the frontend of any importer that uses that name. clang 18 is unaffected, making this an
-18→20 regression. The affected shapes include the four-`int` `Matx × Matx` multiplication,
-`determinant` over `Matx<_Tp,m,m>`, the two-typename `+=`/`-=`, and the comma-initialiser `<<`.
-
-`src/matx_ops.inc` therefore uses **whole-type deduction**: the templates are declared as
-`template<typename _MA, typename _MB>` and re-bound by self-checking constraints such as
-`__is_same(_MA, typename _MA::mat_type)`, so that every template parameter is determined by the
-argument types themselves. The form is semantically equivalent under gcc and has been
-regression-verified. A minimal reproducer and the analysis are recorded in mcpp#256.
-
-### 3.3 Treatment of macros
-
-A module cannot export a macro. Object-like constant macros (`CV_8U`, `CV_PI`, `CV_MAKETYPE`, …)
-are exported as `cv::` constexpr values or functions retaining the original spelling.
-Function-like macros (`CV_Assert`, `CV_Error`, the version macros) cannot be handled this way;
-a translation unit that needs the original spelling should `#include <opencv-m/macros.hpp>`
-before the import.
-
-### 3.4 Platform-conditional compilation and the Windows stub layer
-
-Since mcpp 0.0.102 the per-glob flag tables can be made platform-conditional
-(`[target.'cfg(...)'.build.flags]`, mcpp#258), and the descriptor is partitioned accordingly:
-the entries byte-identical between the Linux and macOS snapshots live in `cfg(unix)`, the
-x86_64 dispatch TUs and nasm `.asm` in `cfg(linux)`, the neon TUs in `cfg(macos)`, and the
-Windows tables in `cfg(windows)`. An entry whose predicate does not match the resolved target
-never enters the glob table, so no platform's build sees another platform's globs — and the
-structural dead-glob warnings (about 26 per build before the migration) are gone on every
-platform.
-
-The Windows/unix difference comprises both **additions and removals** — the zlib group, for
-instance, defines `HAVE_UNISTD_H=1` on unix and must leave it undefined on Windows. Conditional
-entries are appended after the base and take effect under GNU last-wins, so removals are now
-expressible; the Windows TUs are still carried by the **stub-namespace** arrangement — every
-Windows translation unit is a one-line `#include` stub under `gen/windows/tu/w*/` (703 stubs in
-total), giving each TU a stable path identity of its own. Removing the stub layer altogether
-(compiling `third_party/**` directly on Windows and undoing the unix defines per cfg) is no
-longer blocked by the manifest grammar and remains a separate, later clean-up.
-
-### 3.5 Feature partitioning
-
-| Feature | Contents | Rationale |
-|---|---|---|
-| `dnn` | adds the `import opencv.dnn;` interface and the underlying dnn sources (including vendored protobuf) | over 300 additional translation units, built only for consumers that opt in; the `opencv.cv` umbrella does not include dnn by default |
-| `unifont` | embeds the WenQuanYi Micro Hei font, enabling Unicode/CJK `putText` through `FontFace("uni")` | the font payload and the rendering path are only meaningful to consumers that need them |
-
-The gemm backend of `dnn` is selected per platform: Linux and macOS use mlas (x86 AVX/AVX2/AVX512,
-arm NEON), while Windows uses OpenCV's built-in `fast_gemm`. Upstream mlas x86 assembly is written
-in GAS/ELF syntax and clang-cl cannot emit COFF from it, so the upstream path of "fall back to
-fast_gemm when no assembly is available" is followed. This platform distinction relies on the
-per-OS feature semantics introduced by mcpp#253, hence the requirement of mcpp ≥ 0.0.101.
-
-### 3.6 Dependency boundary
-
-There is exactly one external dependency: `compat.ffmpeg`, which provides the implementation
-behind the videoio FFmpeg backend (`cap_ffmpeg`). Everything else is contained in this
-repository. On the package-index side only a thin `opencv.lua` pointing at this repository's
-releases remains; upstream opencv.org distributions are no longer referenced directly.
-
-## 4. Verification strategy
-
-CI is a platform × toolchain matrix; all five legs are required:
-
-| Leg | Platform and toolchain |
-|---|---|
-| linux-gcc | Ubuntu / gcc 16.1.0 (additionally builds the `dnn,unifont` features and lints template placeholders) |
-| linux-llvm-22 | Ubuntu / llvm 22.1.8 |
-| linux-musl-static | Ubuntu / gcc 16.1.0 `--target x86_64-linux-musl`, statically linked |
-| macos-llvm | macOS 15 / llvm (arm64) |
-| windows-llvm | Windows / llvm |
-
-Each leg cold-builds roughly 2700 object files; the `~/.mcpp/registry` cache carries toolchains
-and the built `compat.ffmpeg` across runs. The test suite comprises six executables covering
-export-surface completeness (`api_surface_test`), read/write round-trips including FFmpeg mp4
-(`roundtrip_test`), mixed module/header translation units (`full_mix_test`, `macros_mix_test`),
-and the two feature interfaces (`dnn_module_test`, `unifont_module_test`).
-
-The example projects are not executed in CI: each is a path-dependency consumer that cold-builds
-the entire library in its own `target/` (about 40 minutes on a four-core runner), and its
-coverage is already contained in `mcpp test`.
-
-## 5. Upstream upgrade procedure
-
-1. Import the new tarball with `tools/vendor/import_opencv.sh` (the script downloads and verifies
-   it itself and does not depend on the host environment).
-2. Regenerate the `gen/` snapshots and re-check the cross-platform differences and conflicts.
-3. Regenerate the export surface with `python3 tools/gen_exports.py`, then converge to a green
-   build with `python3 tools/prune_loop.py`.
-4. Publish a release once all five CI legs are green, and update the version pointer in the thin
-   `opencv.lua` on the index side.
-
-## 6. Known temporary structures
-
-| Item | Removal condition |
-|---|---|
-| the 703 stubs under `gen/windows/tu/w*/` and the corresponding `cfg(windows)` glob entries | no longer grammar-blocked since mcpp#258; removing the stub layer (compiling `third_party/**` directly on Windows, undoing the unix defines per cfg) is a separate, later clean-up — see [#17](https://github.com/Sunrisepeak/opencv-m/issues/17) |
-| the llvm CI leg installing gcc first | mcpp#259 (`toolchain install llvm` does not pull its glibc runtime) is fixed |
-| the whole-type deduction form in `src/matx_ops.inc` | may be reconsidered once the clang BMI regression is fixed, though the present form is harmless in itself |
+# opencv-m architecture
+
+[中文](architecture.md)
+
+The package `mcpplibs.mwrap.opencv` wraps OpenCV 5.0.0 for C++23 modules.
+The wrapper revision is 5.0.0. Upstream `cv::` names and type identities remain
+unchanged; package/module identity identifies the adaptation layer. This
+checkpoint does not claim complete public API or hardware coverage.
+
+## Source ownership
+
+- `upstream/opencv`: retained official source and headers, byte-identical to the
+  SHA256-pinned archive in `upstream/sources.lock.toml`. All sixteen main C++
+  modules are imported. Bindings, test frameworks and contrib are separate scope.
+- `port`: configuration inputs, source catalogs and compatibility headers.
+- `generated`: stable configuration/dispatch/resources committed for reproducible
+  builds. Feature-specific files belong to the build output directory.
+- `src`: public interfaces and explicit adapters for internal-linkage entities.
+- `templates`, `tests`, `tools`: executable consumers, behavior checks, import,
+  generation and coverage audits.
+
+OpenCV implementation objects have one owner. FFmpeg and ORT come from declared
+providers; an additional compat.opencv implementation must not be linked beside
+the vendored implementation. Wrapper/SDK layers do not fetch dependencies while
+compiling module interfaces.
+
+## Public interfaces and internal adapter units
+
+`src/core.cppm` aggregates `detail.core` and `detail.matx`. The first owns the
+SDK header facade and general internal-linkage helpers. The second imports
+those original class declarations before defining Matx/Vec adapters with the
+SDK's exact template parameters. Defining these patterns beside the textual
+class declarations crashed Clang22 importers; changing them to whole-operand
+templates lost explicit template arguments and derived-to-base deduction.
+The separate producer preserves the original argument forms and avoids that
+serialization failure. Values and pure
+macro calculations live in `mcpplibs.mwrap.opencv.macros`; raw preprocessing
+macros remain available through `<mwrap/opencv/macros.hpp>` before imports.
+
+Each other public module is a generated aggregation unit. For example,
+`mcpplibs.mwrap.opencv.stitching` re-exports core, its required module dependencies
+and the independent `mcpplibs.mwrap.opencv.detail.stitching` adapter. The internal
+unit's GMF includes upstream headers and its export-using list. The `detail`
+module family is an implementation detail; upstream `cv::detail` stitching APIs
+remain public C++ APIs and retain that namespace.
+
+Keeping textual GMFs and dependency imports in separate units avoids GCC 16's
+SVD default-argument conflict when core.hpp and import core meet in one unit.
+Interface partitions also triggered a GCC 16 merge ICE in this graph; independent
+named adapter units passed the direct-import behavior tests. No compiler/engine
+source patch or upstream-header modification is required for this layout.
+
+The root interface exports core/macros and a configuration-specific selection
+module. That selection has direct imports, including ORT when requested, so
+module scanning and GCC BMI mapper paths see the complete dependency graph.
+A module's source existing on disk does not activate its feature.
+
+## Build generation and feature graph
+
+`tools/generate_build.py` derives required module relationships from the pinned
+CMake module definitions, generates public aggregation interfaces, the manifest
+and per-platform implementation catalogs. Adapter units are maintained separately
+and the generator preserves their content. `build.mcpp` selects catalogs and
+writes private configuration into its output directory; consumers run no CMake.
+
+Defaults are empty; core is mandatory. `all-modules` selects the sixteen main
+module implementations, while codecs, native windows/video and external DNN
+SDKs stay explicit. `highgui-native` selects GTK3/Win32/Cocoa; `videoio-native`
+selects V4L2/MSMF/AVFoundation. Explicit backend names reject mismatched targets.
+`dnn-onnxruntime` implies dnn and the standalone ORT wrapper/official CPU SDK.
+
+The generated manifest declares runtime deployment of fourteen named retained
+wrapper/upstream notices plus the embedded-source notice supplement, preserving their source paths.
+Static implementation objects cannot rely on a shared-library notice scan.
+
+Private ISA and pthread flags belong only to implementation TUs. Public and
+internal wrapper BMIs must remain consumable by baseline consumers. The CI guard
+reads resolved compile commands for every interface, including internal units.
+Bundled zlib uses its upstream prefix; private codec symbols use hidden Unix
+visibility to avoid interposition with the GTK SDK's codecs.
+
+The opt-in `simd` utility exposes native 128-bit intrinsics through
+`mcpplibs.mwrap.opencv.core.simd`; [its contract](simd.md) separates the compiled
+library baseline from per-TU ISA selection. Vector types remain original SDK
+entities. GCC memory-entry forwards preserve unaligned semantics that its
+imported inline intrinsic body miscompiled. Native/platform acceptance and the
+software-mode and other ISA acceptance stay explicit in the coverage review.
+
+## API verification and known boundaries
+
+The Python binding parser plus curated export lists are generation inputs, not
+an API completeness proof. `tools/audit_api.py --verify-exports` inventories
+facade-visible namespace/global declarations, overload signatures (including
+function templates), internal linkage and retained-header coverage using the
+resolved all-modules Clang configuration. It compiles a root-import consumer and
+one consumer for each public module. CI uploads the report and consumer log.
+
+Unloaded headers, unlisted entities, static-inline adaptations, SDK-dependent
+surfaces and template/overload behavior remain separately reviewed.
+The scalar conversion adapter is generated from the pinned saturate.hpp, keeping
+all thirteen input overloads and their upstream specializations; a private
+ordinary module function bridges TU-local cvRound. Independent SDK function
+pointers captured before imports check all 169 source/destination type pairs.
+The makePtr custom-deleter rejection is checked with both successful and rejected
+consumer compilations. Generic cv::min/max use the original std entities, with
+explicit image overloads to preserve overload selection. Exporting a
+class makes its definition reachable but does not prove every method works in
+every backend configuration. Module-only use and textual-header mixing have
+separate tests; full core.hpp mixing on GCC still has its upstream-declaration
+merge limitation. No full-support release can be inferred from source counts.
+
+Runtime tests use generated images/models/videos. ORT checks its actual CPU
+session profile to exclude native fallback. GUI tests create/display/destroy a
+real window; Linux camera checks do not claim physical device capture. Release
+acceptance also requires immutable archive consumers, SDK notices and relocated
+application runtime checks, independent of package-internal tests.
+
+## Upgrades
+
+1. Import a pinned official archive with `tools/vendor/import_opencv.sh`.
+2. Verify retained bytes with `tools/check_upstream.py`.
+3. Regenerate build metadata, exports and macro mappings; review every diff.
+4. Re-run AST/direct-import, behavior, backend, archive and native CI gates.
+5. Use the upstream version, optionally followed by one numeric wrapper revision.
+
+Persistence adapters preserve all 65 pinned SDK inline bodies, with qualified
+internal calls and module-private vector proxies. Existing primitive functions
+remain original SDK calls; custom serializers retain ADL. The enum adapter keeps
+the SDK's optional void-pointer template argument without exporting a dependent
+enable_if type that crashes Clang. Separate textual-header and module consumers
+verify identical XML/YAML/JSON and Base64 output on every native CI platform.
+
+Linux glibc project targets explicitly use the toolchain-coupled C++ runtime,
+matching the ORT template. The actual SDK process must preserve typed OpenCV
+exception catches as well as successful inference. The template tests both.
+
+The readiness ledger under `.agents/docs` records checkpoint evidence and open
+gates. mcpp engine source stays read-only; its documentation PR is independent.
+
+[Coverage matrices / 覆盖矩阵](coverage.md)
+
+The core/imgproc HAL exports their public function/class declarations, preserving
+upstream `cv::hal` names and runtime dispatch. SDK `@cond IGNORED` compatibility
+aliases and private filter implementations are excluded. Instrumentation exports
+the external interface and original node types; collection remains disabled as
+in the selected SDK configuration. Its integer setFlags overload forwards to the
+original enum function. The video adapter additionally includes the documented
+tracking extension interfaces, tested with a user-derived feature and original
+SDK feature-set dispatch.
+
+All 122 free value operators from the pinned types.hpp now use generated SDK
+bodies, replacing the old partial handwritten implementations. This preserves
+overload coverage and the SDK's overflow-safe rectangle intersection, including
+Jaccard distances near INT_MAX. Fifteen core helpers and image conveniences
+retain their upstream bodies with module-safe lookup. rawInOut calls the SDK
+member through an instance: OpenCV 5 omitted static on its std::array overload,
+making the original free wrapper uncompilable for that argument. Vector behavior
+is unchanged. Independent header/member and module consumers compare results.
+
+The ArUco default threshold is captured by value because its SDK declaration has
+internal linkage. Module-only access retains its qualified name/value and address
+use; naming that value after including the original ArUco header and importing
+the module is ambiguous. This limitation is verified separately from API behavior.
+
+Every using-declaration exception requires an explicit reason. The historical
+tools/prune_loop.py now builds once and emits a JSON/log report without changing
+curated lists or exports; it cannot shrink the API until compilation turns green.
diff --git a/docs/architecture.md b/docs/architecture.md
index 22e3ddc..497ff37 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,202 +1,121 @@
-# opencv-m 架构设计说明
+# opencv-m 架构
 
-**中文** · [English](architecture.en.md)
+[English](architecture.en.md)
 
-本文说明 opencv-m 的整体结构、各层职责与关键设计决策的依据。阅读对象是需要修改本仓库、
-或需要理解"C++23 模块封装一个大型 C++ 头文件库"这一问题的开发者。
+`mcpplibs.mwrap.opencv` 为 OpenCV 5.0.0 提供 C++23 模块入口，封装修订为 5.0.0。
+上游 `cv::` 名称与类型身份保持一致；包名和模块名表达封装层归属。当前 checkpoint
+仍在补齐公共 API 与后端覆盖，不能据此宣称完整支持。
 
----
+## 源码归属
 
-## 1. 设计目标与约束
+- `upstream/opencv`：与 `upstream/sources.lock.toml` 中 SHA256 固定的官方归档逐字节一致。
+  已导入全部 16 个主仓库 C++ 模块；语言绑定、测试框架与 contrib 单独界定范围。
+- `port`：配置输入、源码清单与兼容头。
+- `generated`：提交的稳定配置、dispatch 与资源；feature 相关产物进入构建输出目录。
+- `src`：公共接口，以及内部链接实体必须使用的显式适配。
+- `templates`、`tests`、`tools`：可运行消费者、行为验证、导入、生成与覆盖审计。
 
-opencv-m 要同时满足三项要求,而这三项在既有方案中相互冲突:
+OpenCV 实现对象只有一个所有者，不能再链接另一份 compat.opencv。FFmpeg 与 ORT
+来自声明的供应者依赖；模块接口编译时不执行隐藏下载。
 
-1. **消费端以模块方式使用 OpenCV**:`import opencv.cv;` 取代 `#include <opencv2/opencv.hpp>`,
-   同时 API 拼写保持不变(仍是 `cv::Mat`、`cv::cvtColor`)。
-2. **消费端不需要安装 OpenCV,也不需要执行 CMake**:依赖声明后由 mcpp 完成全部构建。
-3. **功能不缩水**:imgcodecs(PNG/JPEG)、videoio(FFmpeg 后端)、dnn 在 Linux、macOS、
-   Windows 三平台均可用,且保留运行时 SIMD dispatch。
+## 公共接口与内部适配单元
 
-约束条件有二。其一,OpenCV 的构建配置由 CMake 生成:`cvconfig.h`、`cv_cpu_config.h`、
-各模块的 SIMD dispatch 派生 TU 均是构建期产物,消费端不可能在没有 CMake 的前提下得到它们。
-其二,C++ 模块的导出语义比头文件严格:宏无法跨模块边界,`static inline`(内部链接)实体
-无法被 `export using` 重新导出——clang 直接拒绝,gcc 只是宽容。
+`src/core.cppm` 聚合 `detail.core` 与 `detail.matx`。前者维护 SDK 头文件 facade 与
+通用内部链接函数适配；后者先导入原始类声明，再定义保留上游模板参数的 Matx/Vec 适配。
+在文本类声明所在单元直接定义这些模板会使 Clang22 消费者崩溃，旧的整体操作数模板
+则丢失显式模板参数和派生类到基类的推导。分开模板 producer 后能保留原调用形式，
+避免该序列化问题。值常量与纯计算宏位于 `mcpplibs.mwrap.opencv.macros`；原始预处理宏
+通过 import 前包含 `<mwrap/opencv/macros.hpp>` 使用。
 
-本仓库的架构即是对这两项约束的系统性回应。
+其余公共模块由生成的聚合单元提供。例如 `mcpplibs.mwrap.opencv.stitching`
+转导出 core、必需模块依赖与独立的 `mcpplibs.mwrap.opencv.detail.stitching` 适配单元。
+内部单元在 GMF 包含上游头文件并使用 export using 导出实体。模块名中的 detail 是
+封装实现细节；上游 `cv::detail` 下的拼接 API 则是公共 C++ API，保留原 namespace。
 
-## 2. 分层结构
+将文本 GMF 与依赖 import 放在不同单元，避免 GCC 16 在 core.hpp 与 import core
+位于同一单元时对 SVD 默认参数报冲突。本图使用接口分区还触发了 GCC 16 的合并 ICE；
+独立命名的适配单元已通过直接导入行为测试，无需修改编译器、mcpp 或上游头文件。
 
-```
-消费者项目
-  └─ import opencv.cv;                     ← 模块接口层
-        └─ src/*.cppm  +  src/*.inc        ← 导出面(生成 + 手写替换层)
-              └─ third_party/opencv-5.0.0  ← vendored 上游源码(零补丁)
-                   +  gen/                 ← 冻结的构建配置快照(替代 CMake)
-                   +  mcpp.toml / build.mcpp ← 构建描述(替代 CMakeLists)
-                   +  compat.ffmpeg        ← 唯一外部依赖(videoio 后端)
-```
+根接口导出 core、macros 与配置相关的选择模块。选择模块写入直接 import，启用 ORT 时
+也记录其模块依赖，保持扫描结果及 GCC BMI mapper 路径一致。源码文件存在不等于 feature 已启用。
 
-各层职责如下。
+## 构建生成与 feature
 
-### 2.1 vendored 上游源码 —— `third_party/opencv-5.0.0/`
+`tools/generate_build.py` 从固定版本的 CMake 模块声明推导必需依赖，生成公共聚合接口、
+manifest 与平台源码清单。内部适配单元单独维护，重新生成时保留内容。
+`build.mcpp` 选择清单并在自身输出目录生成私有配置；消费者不运行 CMake。
 
-OpenCV 5.0.0 官方 tag tarball 的裁剪导入,sha256 锁定,**不含任何补丁**。保留 8 个模块
-(core、imgproc、imgcodecs、highgui、videoio、dnn、flann、geometry)与 7 个第三方组件
-(libjpeg-turbo、libpng、zlib、protobuf、mlas、flatbuffers、dlpack);test/perf 树与语言绑定
-目录被裁除,但 `modules/python/src2` 予以保留,因为其中的 `hdr_parser.py` 是导出面生成器的输入。
-裁剪后为 1969 个文件、48 MB。
+默认 feature 为空，core 始终存在。all-modules 选择 16 个主模块实现，编解码、原生窗口、
+视频后端与外部推理 SDK 分别显式选择。highgui-native 按目标选择 GTK3/Win32/Cocoa，
+videoio-native 选择 V4L2/MSMF/AVFoundation。显式后端在目标不匹配时报错。
+dnn-onnxruntime 包含 dnn，并通过独立 ORT 封装引入官方 CPU SDK。
 
-零补丁是刻意的约束:上游版本升级时,`tools/vendor/import_opencv.sh` 重新导入即可,
-无需重放补丁集合。所有平台差异都被推到 `gen/` 与 `mcpp.toml` 中表达。
+ISA 与 pthread 编译模式只用于实现 TU。公共及内部模块 BMI 保持基线可消费，CI 从实际
+compile_commands 检查全部接口。内置 zlib 使用上游符号前缀，Unix 下私有 codec 符号
+隐藏，避免与 GTK SDK 的共享 codec 发生符号抢占。
 
-### 2.2 冻结配置快照 —— `gen/`
+## 验证与边界
 
-CMake 在配置阶段生成的头文件与派生 TU,在本仓库中以**已生成的真实文件**形式提交:
+Python 绑定解析器与 curated 列表是生成输入，不是完整 C++ API 的证明。
+`tools/audit_api.py --verify-exports` 使用实际 all-modules Clang 配置记录 namespace/global
+声明、含模板的重载签名、内部链接与头文件加载覆盖，并编译根模块及每个公共子模块的独立消费者。
+CI 保存报告和消费者日志。
 
-| 目录 | 内容 | 规模 |
-|---|---|---|
-| `gen/common/` | 三平台逐字节相同的产物(SIMD dispatch 包装 TU、`opencv_modules.hpp` 等)与 `gen/common/synth/`(字体、OpenCL kernel 等合成资源) | 257 文件 |
-| `gen/linux/`、`gen/macosx/`、`gen/windows/` | 平台相关的 `cvconfig.h`、`cv_cpu_config.h` 等,附 `INCLUDE_DIRS.txt` 与 `DNN_SOURCES.txt` | 各 43–45 文件 |
+未加载的头、未列入导出列表的实体、内部链接适配、SDK 相关接口与模板/重载行为分别审阅。
+类定义可达不代表每个方法都在每种后端配置下运行。纯 import 与文本头混用分别测试；
+GCC 上完整 core.hpp 混用仍有声明合并限制。源码模块数量不能代替完整支持验收。
 
-这些快照由 `tools/vendor/port_descriptor.py` 一次性移植自已退役的 `compat.opencv` 描述符,
-移植过程包含跨平台去重、冲突检测与逐字节校验。提交生成物而非在构建期运行 CMake,是使
-"消费端不跑 CMake"成为可能的前提;代价是上游升级时需要重新执行一次移植流程。
+运行测试使用生成的图像、模型与视频。ORT 检查实际 CPU session profile，避免原生回退
+冒充通过。GUI 测试实际创建、显示、销毁窗口；Linux 相机测试不声称验证实体设备采集。
+发布门槛还包括真实不可变归档消费、SDK 许可通知与程序搬迁后的运行验证。
 
-### 2.3 构建描述 —— `mcpp.toml` 与 `build.mcpp`
+## 升级步骤
 
-`mcpp.toml`(约 1500 行)承载可声明的部分:源文件 glob、公共 include 目录、51 组按 OS 归属的
-`[target.'cfg(...)'.build.flags]` 逐 glob 编译选项、`[target.'cfg(os)'.build]` 的平台条件源集合、
-`[features]` 定义、以及唯一的外部依赖 `compat.ffmpeg`。
+1. 使用 `tools/vendor/import_opencv.sh` 导入固定官方归档。
+2. 使用 `tools/check_upstream.py` 验证保留文件的字节。
+3. 重新生成构建元数据、导出与宏映射，审阅全部 diff。
+4. 重跑 AST/直接导入、行为、后端、归档与原生 CI 门槛。
+5. 版本沿用上游，必要时追加一个数字封装修订段。
 
-`build.mcpp` 只承担清单语法**无法表达**的三件事,不多做:
+`.agents/docs` 的验收记录保存 checkpoint 证据与剩余门槛。mcpp 引擎源码只读，
+其文档 PR 独立于本库进度。
 
-1. 按目标平台读取 `gen/<os>/INCLUDE_DIRS.txt`,发出私有 include 目录(清单没有平台条件的
-   `include_dirs` 键);
-2. `dnn` 特性开启时,注入 `gen/<os>/DNN_SOURCES.txt` 列出的平台相关源文件(清单没有
-   "平台 × 特性"的交叉维度);
-3. `unifont` 特性开启时,将 `assets/WenQuanYiMicroHei.ttf.gz` 以十六进制嵌入生成头文件
-   (等价于 CMake 的 `ocv_blob2hdr`)。
+## 标量适配的语义验证
 
-该文件采用 modules-first 风格,通过 `import mcpp;` 使用类型化 API。需要注意:`import std;`
-在 build.mcpp 的编译上下文中不可用(经验证仅 `mcpp` 模块被接入),因此文本 include 保留,
-且必须位于 `import` 之前。
+`saturate_cast` 适配从固定版本 `saturate.hpp` 生成，保留十三种输入重载及上游特化；私有普通模块函数桥接 TU-local `cvRound`。测试在 import 前捕获原始 SDK 函数指针，对 169 组输入/输出类型独立比较，覆盖饱和边界和舍入。`makePtr` 保留上游自定义 deleter 禁用规则，通过正反编译用例验证。泛型 `cv::min/max` 使用上游导入的标准库实体，并保留图像三参数重载的选择行为。
 
-### 2.4 模块接口层 —— `src/`
+[Coverage matrices / 覆盖矩阵](coverage.md)
 
-每个 `opencv.<mod>` 是一个自包含模块:在全局模块片段(GMF)中 `#include` 对应上游头文件,
-在 purview 中通过 `export using cv::name;` 逐名导出。模块之间不互相 `import`,`opencv.cv`
-是唯一的聚合入口(`export import` 各子模块)。
+## 分发文件
 
-导出面由两部分合成:
+生成清单通过 `runtime.deploy` 显式保留十四份独立 wrapper/上游通知与源码许可补充文件，并保持来源路径，避免组件同名 LICENSE 覆盖。静态实现不依赖共享库扫描发现通知。索引中的实际模板打包测试逐字节检查这些文件，并从独立目录运行搬迁后的程序。
 
-- **生成部分** `src/gen_exports/*.inc`(2267 行):`tools/gen_exports.py` 调用上游
-  `hdr_parser.py` 枚举 `CV_EXPORTS_W` 表面,叠加 `tools/curated/<mod>.txt` 中人工补充的名字
-  (生成器看不见的模板 typedef 家族 `Point2i`/`Vec3b`/`Matx33f`、`InputArray` 家族、traits 等)。
-  名字跨模块去重,每个实体只由一个归属模块导出。
-- **人工替换部分** `src/*_ops.inc` / `src/core_fns.inc`:见 §3.1。
+可选 `simd` 提供原生 128 位 intrinsics，入口为 `mcpplibs.mwrap.opencv.core.simd`。
+[接口约定](simd.md) 区分库编译基线和每个使用方 TU 的 ISA 配置；向量类型仍是上游实体。
+GCC 的内存入口通过普通函数转发，保留导入 inline intrinsic 时曾被错误编译的非对齐读写。
+原生 CI 与剩余的软件模拟、其他 ISA 家族仍是独立验收项。
 
-`tools/prune_loop.py` 构成生成器的闭环:编译失败时解析指向 `gen_exports/*.inc` 的错误,
-将不可导出的名字连同原因追加到 `tools/curated/<mod>.prune.txt`,重新生成并重试,直至构建通过。
-当前累计裁剪 431 行。
+## FileStorage 与共享运行时
 
-## 3. 关键设计决策
+序列化适配保留固定 SDK 的 65 份 inline 函数体，内部调用显式限定到适配层，向量代理放入模块私有 namespace。基础函数仍调用原始 SDK，用户自定义序列化仍支持 ADL。枚举保留可选 void* 模板参数，同时避免向模块导出会触发 Clang 崩溃的 dependent enable_if 类型。独立的原始头文件程序和模块程序逐字节比较 XML/YAML/JSON 及 Base64 六种输出。
 
-### 3.1 内部链接实体的替换层
+Linux glibc 项目目标显式选择 toolchain-coupled C++ 运行时，与 ORT 模板一致。实际复现显示加载 SDK 时嵌入另一份静态异常运行时会导致 cv::Exception 捕获终止；改为共享运行时后，同一组测试通过。ORT 模板同时验证推理和异常捕获。
 
-OpenCV 的运算符与部分命名自由函数以 `static inline` 定义在头文件中,属内部链接,无法被
-`export using` 重导出。本仓库以等价的 `inline`(外部链接)定义替换该表面,分三个文件:
+core/imgproc HAL 的公共函数与类型保持 `cv::hal` 名称及上游运行时派发；
+`@cond IGNORED` 的旧兼容别名和私有滤波类不加入该接口。instrumentation 导出
+原始节点类型与外部接口，保持当前 SDK 未启用采集时的 no-op 行为；整数 setFlags
+转发给原始枚举函数。video 补上文档公开的 tracking 扩展接口，并以用户派生特征
+类验证上游 TrackerFeatureSet 的真实派发。
 
-| 文件 | 覆盖范围 |
-|---|---|
-| `src/core_ops.inc` | `saturate_cast`、Point/Size/Rect/Range/Scalar、Mat/MatExpr 运算符 |
-| `src/matx_ops.inc` | Matx/Vec 代数 |
-| `src/core_fns.inc` | 命名自由函数(`cv::format`、`cv::print` 等按上游语义重实现) |
+types.hpp 的 122 个自由值类型运算符改由固定 SDK 生成，替换旧的部分手写实现，
+保留完整重载及矩形求交的防溢出处理；INT_MAX 附近的 Jaccard 距离已通过独立
+头文件/module 对照。十五个 core 辅助函数及图像便利接口保留 SDK 函数体并调整
+模块查找。rawInOut 通过对象调用原始 SDK 成员：5.0.0 的 std::array 成员遗漏了
+static，使原始自由包装函数无法编译该参数；vector 行为保持一致。
 
-替换层是 `import opencv.cv;` 能在 clang(macOS/Windows)与 gcc 上同时编译的直接原因。
-混合 TU(既 include 头文件又 import 模块)中,上游的精确匹配 `static inline` 版本重载
-更特化,因此语义不变。
+ArUco 默认阈值在 SDK 中具有内部链接，封装按值捕获并保留限定名、值及地址访问。
+同时包含原始 ArUco 头并导入模块后再引用该同名常量会有歧义；该值应采用纯模块
+访问。此边界已单独编译验证，不用正常接口测试掩盖。
 
-### 3.2 模板参数的推导形式(clang BMI 约束)
-
-在 clang 20 与 22 上存在一项实测约束:模板参数未被**第一个实参**完全绑定的函数/运算符模板,
-经模块 BMI 序列化后,导入方一旦使用该名字即触发前端崩溃(clang 18 无此问题,属 18→20 回归)。
-受影响的形态包括 4 个 int 参数的 `Matx × Matx` 乘法、`Matx<_Tp,m,m>` 的 `determinant`、
-双 typename 的 `+=`/`-=`、以及逗号初始化 `<<`。
-
-`src/matx_ops.inc` 因此改用**整类型推导**:以 `template<typename _MA, typename _MB>` 声明,
-再用 `__is_same(_MA, typename _MA::mat_type)` 之类的自校验约束回绑,使全部模板参数由实参类型
-本身确定。该形式在 gcc 上语义等价并已回归验证。相关最小复现与分析见 mcpp#256。
-
-### 3.3 宏的处理
-
-模块不能导出宏。对象式常量宏(`CV_8U`、`CV_PI`、`CV_MAKETYPE` 等)以保持原拼写的
-`cv::` constexpr 值/函数形式导出;函数式宏(`CV_Assert`、`CV_Error`、版本宏)无法如此处理,
-需要原始拼写的 TU 应在 `import` 之前 `#include <opencv-m/macros.hpp>`。
-
-### 3.4 平台条件编译与 Windows 的桩层
-
-mcpp 0.0.102 起,逐 glob 的 flag 表可按平台条件化(`[target.'cfg(...)'.build.flags]`,
-mcpp#258)。描述符据此按归属拆分:Linux 与 macOS 快照中逐字节一致的条目在 `cfg(unix)`,
-x86_64 dispatch TU 与 nasm `.asm` 在 `cfg(linux)`,neon TU 在 `cfg(macos)`,Windows 的表在
-`cfg(windows)`。谓词不匹配当前目标的条目根本不进 glob 表,因此任一平台的构建都看不到
-其它平台的 glob,也不再产生结构性 dead-glob 警告(迁移前每次构建约 26 条)。
-
-Windows 与 unix 的差异同时包含**增加与删除**(例如 zlib 组在 unix 下定义
-`HAVE_UNISTD_H=1`,Windows 必须不定义)。条件条目追加在 base 之后、按 GNU last-wins
-生效,删除因此可表达;当前仍沿用**桩命名空间**承载 Windows TU:每个 Windows TU 对应
-`gen/windows/tu/w*/` 下的一行 `#include` 桩文件(共 703 个),为每个 TU 提供稳定的
-独立路径身份。桩层的整体移除(让 Windows 直接编译 `third_party/**` 并按 cfg 撤销 unix
-定义)不再受清单语法阻塞,是一项独立的后续清理。
-
-### 3.5 特性划分
-
-| 特性 | 内容 | 理由 |
-|---|---|---|
-| `dnn` | 追加 `import opencv.dnn;` 接口与底层 dnn 源(含 vendored protobuf) | 底层多出 300 余个 TU,仅对显式开启者构建;`opencv.cv` umbrella 默认不含 dnn |
-| `unifont` | 内嵌 WenQuanYi Micro Hei 字体,支持 `FontFace("uni")` 的 Unicode/CJK `putText` | 字体资源体积与渲染路径仅对需要者有意义 |
-
-`dnn` 的 gemm 后端按平台选择:Linux 与 macOS 使用 mlas(x86 AVX/AVX2/AVX512、arm NEON);
-Windows 使用 OpenCV 内置的 `fast_gemm`——上游 mlas 的 x86 汇编为 GAS/ELF 语法,clang-cl
-无法产出 COFF,故沿用上游"无 ASM 即回退 fast_gemm"的既定路径。此平台差异依赖 mcpp#253
-引入的 per-OS 特性语义,故要求 mcpp ≥ 0.0.101。
-
-### 3.6 依赖边界
-
-外部依赖只有一个:`compat.ffmpeg`,为 videoio 的 FFmpeg 后端(`cap_ffmpeg`)提供实现。
-其余全部内联于本仓库。包索引侧仅保留一个指向本仓库 Release 的薄 `opencv.lua`,不再直连
-上游 opencv.org 的分发物。
-
-## 4. 验证策略
-
-CI 为平台 × 工具链矩阵,五条腿全部为必需:
-
-| 腿 | 平台与工具链 |
-|---|---|
-| linux-gcc | Ubuntu / gcc 16.1.0(附加 `dnn,unifont` 特性构建与模板占位符检查) |
-| linux-llvm-22 | Ubuntu / llvm 22.1.8 |
-| linux-musl-static | Ubuntu / gcc 16.1.0 `--target x86_64-linux-musl`,静态链接 |
-| macos-llvm | macOS 15 / llvm(arm64) |
-| windows-llvm | Windows / llvm |
-
-每条腿冷构建约 2700 个目标文件;`~/.mcpp/registry` 缓存跨运行保留工具链与已构建的
-`compat.ffmpeg`。测试为 6 个可执行文件,覆盖导出面完整性(`api_surface_test`)、
-读写往返含 FFmpeg mp4(`roundtrip_test`)、模块与头文件混合 TU(`full_mix_test`、
-`macros_mix_test`)、以及两项特性接口(`dnn_module_test`、`unifont_module_test`)。
-
-示例工程不在 CI 中执行:每个示例是 path 依赖消费者,会在自身 `target/` 中冷构建整套库
-(4 核 runner 约 40 分钟),而其覆盖面已被 `mcpp test` 包含。
-
-## 5. 上游升级流程
-
-1. `tools/vendor/import_opencv.sh` 导入新版本 tarball(脚本自行下载并校验,不依赖宿主机环境)。
-2. 重新生成 `gen/` 快照,核对跨平台差异与冲突。
-3. `python3 tools/gen_exports.py` 重生成导出面,`python3 tools/prune_loop.py` 收敛至构建通过。
-4. 五条 CI 腿全绿后发布 Release;包索引侧的薄 `opencv.lua` 更新版本指向。
-
-## 6. 已知的临时结构
-
-| 项 | 移除条件 |
-|---|---|
-| `gen/windows/tu/w*/` 的 703 个桩文件与 `cfg(windows)` 的对应 glob 条目 | 语法阻塞已随 mcpp#258 解除;移除桩层是独立的后续清理(Windows 直接编译 `third_party/**` 并按 cfg 撤销 unix 定义),见 [#17](https://github.com/Sunrisepeak/opencv-m/issues/17) |
-| llvm CI 腿先安装 gcc 的变通 | mcpp#259(`toolchain install llvm` 未拉取其 glibc 运行时)修复 |
-| `src/matx_ops.inc` 的整类型推导写法 | clang BMI 回归修复后可考虑回退,但当前形式本身无害 |
+每项 using 导出例外必须有明确理由。历史 tools/prune_loop.py 现只构建一次并输出
+JSON/日志诊断，不再修改 curated/export 文件，不通过自动删接口获得绿色构建。
diff --git a/docs/coverage.md b/docs/coverage.md
new file mode 100644
index 0000000..8034200
--- /dev/null
+++ b/docs/coverage.md
@@ -0,0 +1,139 @@
+# OpenCV 5.0.0 coverage
+
+These matrices describe verified scope, not a complete-support release. The
+[readiness ledger](../.agents/docs/2026-10-24-readiness-audit.md) records exact
+commits, CI runs and remaining acceptance gates. Vendor bytes are pinned in
+upstream/sources.lock.toml; native CI for e72c09b passed all five jobs. Later
+public-API restorations are locally verified and require their own native CI.
+
+## Source modules
+
+All interfaces use `mcpplibs.mwrap.opencv.<module>` and preserve upstream API
+namespaces. Core is always present. `all-modules` selects the other fifteen
+features and their required dependency closure. Every module also depends on core.
+
+| Module / feature | Other required modules | Source and import coverage |
+|---|---|---|
+| `calib` | `flann`, `geometry`, `imgproc`, `objdetect`, `stereo` | retained / builds / direct import / aggregate |
+| `core` | mandatory | retained / builds / direct import / aggregate |
+| `dnn` | `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `features` | `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `flann` | core only | retained / builds / direct import / aggregate |
+| `geometry` | `flann` | retained / builds / direct import / aggregate |
+| `highgui` | `imgproc` | retained / builds / direct import / aggregate |
+| `imgcodecs` | `imgproc` | retained / builds / direct import / aggregate |
+| `imgproc` | `geometry` | retained / builds / direct import / aggregate |
+| `objdetect` | `features`, `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `photo` | `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `ptcloud` | `flann`, `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `stereo` | `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `stitching` | `features`, `flann`, `geometry`, `imgproc` | retained / builds / direct import / aggregate |
+| `video` | `imgproc` | retained / builds / direct import / aggregate |
+| `videoio` | `imgcodecs`, `imgproc` | retained / builds / direct import / aggregate |
+
+## C++ API and macros
+
+| Surface | Evidence | Remaining boundary |
+|---|---|---|
+| Root and sixteen direct modules | 3,726 listed names compile in the latest local all-module Clang audit | Name lookup does not prove every overload/template/backend |
+| Public core types, filesystem, TLS, parallel backend, dual quaternions, async promise | Actual behavior tests; LLVM/GCC strict suites | Full core.hpp mixing on GCC has a declaration-merge limitation |
+| Scalar conversion adapters | Independent pinned SDK oracle, 169 type pairs; saturation/rounding boundaries | Platform rounding bridge needs current native matrix |
+| Generic min/max and makePtr | Reference/tie and image behavior; positive/negative custom-deleter compilation | GCC shared_ptr probes include the standard memory header |
+| FLANN and stitching detail | Direct-import algorithm and factory consumers | Other portable helper headers still require inventory review |
+| Macro constants and pure calculations | Generated `.macros` mapping and optional textual macro header; ROI behavior | Preprocessor flow controls remain textual; no fake exported preprocessor state |
+| DNN-dependent DISK | Conditional export and missing-model rejection; features-only build without DNN | Trained DISK inference is not verified |
+| Remaining API/header inventory | 3,953 facade-visible entities with software SIMD selected; 238 not in export lists; 103 not-in-facade headers | 137 unlisted names resolve through imports; the other 101 have exact source-reviewed internal/binding decisions. Typed Mat expressions and user conversions now have SDK parity; current native CI and other-ISA coverage remain separate gates |
+| DNN equality and legacy backend utilities | Original Arg equality in public and ABI-version namespaces, six original utilities and SDK failure/no-op behavior; all three compilers match a 92-byte oracle | This exports SDK contracts; Inference Engine/OpenVINO runtime support remains unavailable |
+| DNN shape helpers | Twenty generated overloads retain pinned bodies; direct-import tensor/axis/formatting behavior passes LLVM/GCC | Static-inline bodies use a constrained named-module adapter |
+| Persistence helpers | 65 pinned SDK bodies plus typed forwards; native header/module XML/YAML/JSON and Base64 bytes match on GCC/LLVM | Private vector proxies stay internal; original FileStorage/WriteStructContext types retain their SDK identity |
+| Geometry optimizer extension | Public LevMarqBase/Backend imported; callback rejection/geodesic report contracts execute original SDK code | Device acceleration is separate |
+| Value operators and portable helpers | 122 pinned types.hpp operator bodies, fifteen core helper bodies and image conveniences; independent SDK/module results match on LLVM/GCC | rawInOut(std::array) uses the original non-static SDK member through an instance to repair the broken free-wrapper call |
+| Matx/Vec template signatures | Original template order, every explicit argument prefix in eight adapted families, function pointers and derived-to-base deduction; independent 342-byte SDK/module oracle passes GCC16/LLVM22/LLVM23 | Separate imported-type producer avoids the Clang22 GMF serialization crash; current all-module/native matrix still required |
+| Mat augmented assignments | 49 SDK macro families plus sixteen MatExpr overloads give 114 mutable/const assignments; 1574-byte SDK/module oracle, return identity, original parameter conversions, function pointers and deprecated comma initialization pass GCC16/LLVM22/LLVM23 | All-module composition and current native CI remain required; generated bodies retain original SDK operations |
+| Preview plugin ABI and point-cloud rendering | Original CvResult/OpenCV_API_Header entities and two CPU rendering functions; three-compiler SDK/module and rendering checks pass | Preview ABI follows upstream compatibility limits; declaration availability does not enable a plugin backend |
+| CPU-usable CUDA helpers and feature HAL | Eight helper overloads plus ten SDK Event flag operators; CPU Mat reuse/reshape and 424-byte SDK/module oracle pass on GCC16/LLVM22/LLVM23; original cvhalKeyPoint is exported | No CUDA device backend or GPU allocation is certified; 26 extra HAL macro values and typed FOURCC mapping are tested separately |
+| Public core diagnostics and legacy enums | Twelve SDK dump forwards, eight original external utility declarations, and original photo/video global enum spellings; three-compiler SDK/module oracle matches 1302 bytes | Ignored language-binding tests remain outside the exported public surface; cache accessor signature is checked without changing user cache state |
+| Qualified FP controls and videoio opaque types | Six original cv::details state/functions/RAII declarations, plus IVideoCapture/IVideoWriter and cudev::GpuMat_ forwards; independent SDK/module state restoration and exact signature checks pass GCC16/LLVM22/LLVM23 | Per-thread state is restored; unsupported architectures retain SDK no-op behavior. Opaque declarations do not provide backend implementations |
+| Global fast math | Twenty exact SDK forwards cover cvRound/cvFloor/cvCeil, cvIsInf/cvIsNaN and CV_FOURCC; SDK/module output matches on GCC16 and LLVM22/23, including mixed-header checks | Platform rounding follows the SDK; native CI on the current checkpoint remains required |
+| Public scalar/constant aliases | Original cvTrunc/cvRound64 and utils::getThreadID; ArUco threshold matches the SDK detector and supports address access | Naming the ArUco threshold after both its original header and module import is ambiguous; use module-only access for that value |
+| Core/imgproc HAL | 172 core and 34 imgproc public names; saturating arithmetic/norms/exp and color conversions execute the SDK | SDK IGNORED legacy aliases and private filter classes stay outside this surface; ISA intrinsics remain separate |
+| Instrumentation external interface | Original NodeData/InstrNode types and SDK state functions; both setFlags overloads and NodeData equality | Instrumentation collection is disabled in the current build; tests verify original no-op behavior |
+| Tracking extension interfaces | Ten documented SDK classes/aliases; a user feature runs through TrackerFeatureSet, plus target-state and sampling behavior | Pinned sampler returns false while producing samples; the wrapper preserves this upstream behavior |
+
+## Runtime capabilities
+
+| Feature / capability | Verified behavior | Conditions / limits |
+|---|---|---|
+| `highgui` | API can be imported | No window backend by itself |
+| `highgui-native` | GTK3 / Win32 / Cocoa create, display, process events and destroy | GTK SDK is Linux x86_64 glibc only; Linux uses Xvfb in CI |
+| `videoio-native` | V4L2 registration/error path; MSMF/AVFoundation file tests | No physical-camera claim |
+| `videoio-ffmpeg` | Generated file encode/decode and actual video template | Declared FFmpeg SDK; managed NASM on x86_64 Linux/Windows |
+| Base image codecs | BMP/PPM exact roundtrips; PFM float roundtrip | Other compiled base formats are not individually certified |
+| `imgcodecs-png`, `imgcodecs-jpeg` | Generated image roundtrips | Separate explicit features |
+| `imgcodecs-webp` | Lossless transparent RGB/alpha, animation frames/timing/loop count and exact XMP bytes | libwebp 1.5.0 with mux/demux; Linux GCC16, LLVM22/23 local checks pass; native/archive gates pending |
+| `dnn` | Generated ONNX Add through native classic/new engines | No external accelerator implied |
+| `dnn-onnxruntime` | Generated ONNX Add; actual CPUExecutionProvider session profile and template | Official ORT 1.25.1 CPU SDK, supported targets only |
+| CUDA, OpenCL, OpenVINO, other SDK backends | Planned/unavailable | Declaration exports do not enable a device implementation |
+| Contrib | Not imported | Separate matching upstream version and per-module verification required |
+
+The following design names are planned/unavailable in this candidate, rather
+than registered empty features. Retained upstream source files alone do not
+enable their codec or backend implementations.
+
+| Planned names / scope | Current boundary |
+|---|---|
+| `imgcodecs-tiff`, `imgcodecs-openexr`, `imgcodecs-jpeg2000`, `imgcodecs-avif`, `imgcodecs-jpegxl` | No integrated provider/configuration or certified roundtrip |
+| `highgui-qt6`, `highgui-wayland` | No selected implementation/SDK; native GTK3/Win32/Cocoa are the implemented choices |
+| `videoio-gstreamer`, `videoio-dshow` | No integrated backend; native V4L2/MSMF/AVFoundation and FFmpeg are separately verified |
+| `opencl`, `opengl`, `tbb`, `ipp`, `lapack`, `eigen` | No feature integration or acceleration claim from declaration availability |
+| `dnn-openvino`, `dnn-cuda`, ORT GPU providers | CPU inference is the declared scope; runtime/SDK/device integration remains separate |
+| `contrib-*` | Matching contrib sources are not imported; no contrib module is certified |
+| AVX/AVX512, VSX, MSA, LSX/LASX, RVV and WASM universal-intrinsic families | No public module/target certification beyond the declared baseline/native and software modes |
+
+## Targets and configuration
+
+| Target | Toolchain / linkage | Verified scope at e72c09b |
+|---|---|---|
+| Linux x86_64 glibc | GCC 16.1.0; LLVM 22.1.8 CI / 23.1.3 local; archive implementation | All modules, codecs, native video/FFmpeg; GTK window on LLVM; ORT CPU |
+| Linux x86_64 musl | GCC 16.1.0; static profile | All modules, codecs, native video/FFmpeg; declared GTK/ORT SDKs unavailable |
+| macOS arm64 | LLVM 23.1.3; native frameworks | All modules, codecs, Cocoa, AVFoundation/FFmpeg, ORT CPU |
+| Windows x86_64 MSVC ABI | LLVM 23.1.3 | All modules, codecs, Win32, MSMF/FFmpeg, ORT CPU |
+| Other triples / ABI / shared-library configurations | Not certified | No inference from the target rows above |
+
+The Linux x86_64 glibc source project and the ORT template explicitly select
+`cxx_runtime = "toolchain-coupled"`. A verified negative test showed that embedding
+a static exception runtime while loading the SDK could terminate typed catches;
+the shared-runtime configuration passed the same tests.
+
+Installed immutable OpenCV archives, relocated deployment/runtime closure and
+all final source/index CI heads remain release gates. Main-module CI does not
+establish those distribution properties. No tag, release or merge is created.
+
+## Reviewed header decisions
+
+`port/api/header-review.toml` records every header from the initial 113-header
+facade gap list with an explicit reason. It distinguishes compatibility
+forwarders, SDK/platform code, upstream internals, textual macros and actual
+public gaps. HAL record/value, public core dump utilities and legacy enum coverage have since been implemented.
+`tools/check_header_review.py` checks review coverage against the compiler
+inventory; `--require-complete` additionally rejects the 20 remaining public-gap
+records (universal intrinsics and their architecture implementations). Review coverage does not mean these APIs are implemented.
+
+## Native SIMD checkpoint
+
+The opt-in `simd` feature exposes `mcpplibs.mwrap.opencv.core.simd`, plus the
+selected root import, with 220 enabled baseline names on Linux x86_64. Original
+SDK vector types are retained. GCC uses producer-compiled memory forwards to
+preserve unaligned input/output semantics; Clang re-exports SDK inline entities.
+The 495-byte native SDK/module oracle passes GCC16, LLVM22 and LLVM23, alongside
+all 28 programs with `all-modules,simd`, 35 baseline interface checks and makePtr
+positive/negative contracts. GCC release-mode parity and export visibility pass.
+See [SIMD configuration](simd.md). Native ARM64/Windows CI remains required.
+
+Header review keeps eight native-family records and two software/legacy records
+partially accepted, with ten other mode/ISA records unimplemented.
+Full-support acceptance fails for all unfinished categories. The opt-in
+`simd-emulated` mode preserves generic SDK vector templates and has independent
+software SDK parity/lookup checks. The explicitly imported `core.simd.legacy`
+re-exports the 21 original operators; both vector modes have SDK parity and
+base/root visibility-boundary checks. Non-baseline ISA families remain uncertified.
diff --git a/docs/simd.md b/docs/simd.md
new file mode 100644
index 0000000..9a2dd33
--- /dev/null
+++ b/docs/simd.md
@@ -0,0 +1,98 @@
+# Universal intrinsics
+
+Enable `simd` to import OpenCV's native 128-bit CPU intrinsics with their
+original `cv::` vector types and function names:
+
+```toml
+[dependencies]
+"mcpplibs.mwrap.opencv" = { version = "5.0.0", features = ["simd"] }
+```
+
+```cpp
+import mcpplibs.mwrap.opencv.core.simd;
+int main() {
+    float input[4]{1, 2, 3, 4}, output[4]{};
+    auto sum = cv::v_add(cv::v_load(input), cv::v_setall_f32(2));
+    cv::v_store(output, sum);
+    return output[0] != 3;
+}
+```
+
+The root `mcpplibs.mwrap.opencv` import also exposes this surface when `simd`
+is selected. It is separate from `all-modules`, which selects sixteen main
+algorithm modules. No external SDK, GPU backend or additional ISA flag is added.
+
+The implementation selects the library's compiled baseline: x86_64 SSE2 or
+ARM64 NEON, with sixteen-byte vector storage. The imported macros module maps
+`CV_SIMD_WIDTH`, `CV_SIMD128`, `CV_SIMD_64F` and related values under
+`mcpplibs::mwrap::opencv::macros`. These describe the library module; they do
+not change with an importing translation unit's flags. Per-translation-unit
+CPU dispatch, AVX2/AVX512 variants and other native architectures still need
+separate integration and verification. No empty features
+are registered for those implementations.
+
+`simd-emulated` implies `simd` and selects the SDK's software implementation
+(`CV_FORCE_SIMD128_CPP`) for this package's public intrinsics. It uses the same
+module and `cv::` names, including original `v_reg<T, N>` generic templates.
+The package feature union selects one implementation for all consumers; it
+does not provide two interchangeable vector ABIs. Textual comparisons must use
+the same upstream force macro. The compiled algorithm kernels keep their own
+native dispatch configuration.
+
+The emulator adapter includes ordinary core declarations first, then temporarily
+maps `CV_INLINE` to `inline` while including the original intrinsics header.
+This changes the linkage of namespace function templates needed by module
+exports; vector class definitions and implementation bodies remain unchanged.
+The original macro is restored afterward. Its SDK reference test uses unmodified
+headers without this linkage adaptation. Software mode exports generic memory
+templates directly, including on GCC; it does not use native memory forwards.
+The pinned SDK's generic `v_reinterpret_as_uint` references a missing
+`V_TypeTraits<T>::reinterpret_uint`. Its name remains exported; matching negative
+SDK/import probes record the original instantiation failure. Concrete
+`v_reinterpret_as_u32` and the other width-specific SDK operations remain usable.
+
+Vector classes and ordinary inline functions refer to original SDK entities.
+The original `Type2Vec128_Traits<T>`, `v_setall<T>` and `vx_setall<T>` are also
+available. The ten SDK scalar specializations use producer-compiled forwards
+to the original static-inline broadcasts, preserving the SDK vector types,
+argument deduction and function-pointer signatures. Unsupported traits such as
+plain `char` remain rejected. These forwards add a call boundary; performance
+parity has not been measured.
+GCC memory-entry adapters call ordinary producer-compiled forwards: GCC 16
+miscompiled an unaligned load through the imported inline intrinsic body.
+The adapter retains unaligned input/output support. This introduces a call
+boundary for those GCC entries; performance parity has not been measured.
+`vx_store` and `vx_store_aligned` keep their compatibility spellings through
+explicit forwards. Public aggregation is separate from the header adapter to
+avoid GCC's full-header/default-argument merge issue. Full textual SDK header
+mixing follows the restrictions in [architecture](architecture.en.md).
+
+For the operators removed from the ordinary intrinsics header in OpenCV 4.11,
+explicitly import `mcpplibs.mwrap.opencv.core.simd.legacy` with `simd` enabled.
+It corresponds to manually including the original `intrin_legacy_ops.h` after
+the intrinsics header. All 21 original operator templates stay in `cv::hal`;
+use its operators as with the SDK, for example `using cv::hal::operator+;`.
+Keep these declarations scoped to vector expressions. The SDK's unconstrained
+comparison templates can override a derived iterator's base-class comparison,
+as observed with MSVC's std::array iterators when importing all of cv::hal.
+The base SIMD and root imports deliberately do not introduce these overloads.
+No additional feature or implementation library is required. The opt-in
+interface is built with the same native/software vector configuration.
+
+The SDK software implementation declares `v_not<float,N>` without defining it:
+floating legacy `operator~` therefore fails to link in both SDK and module
+consumers. Integer complement is tested in software mode; native mode also
+checks floating complement. The adapter re-exports the SDK templates and does
+not manufacture a replacement definition for the broken specialization.
+
+`tools/check_simd.py` compares independent original-header/import-only
+consumers. It exercises unaligned memory, saturating/wrapping arithmetic,
+packing/widening, lane ordering, masks, dot products, rounding, doubles and
+interleaved RGB. It also checks every enabled name through direct/root imports.
+Pass `--emulated` to check software mode, including eight-lane generic arithmetic,
+bitwise operations, double conversion, reductions and rounding shifts.
+Both modes compare the 21 legacy operators against independent SDK consumers,
+including compound reference identity, function-pointer selection and byte
+saturation, and verify that base/root imports keep those operators opt-in.
+Native CI covers the declared platforms; pending results remain acceptance
+gates. See [coverage](coverage.md) for the current verified scope.
diff --git a/docs/usage.md b/docs/usage.md
new file mode 100644
index 0000000..99c21f9
--- /dev/null
+++ b/docs/usage.md
@@ -0,0 +1,208 @@
+Detailed usage and background. See the [README](../README.md) for the current candidate quickstart and support boundary.
+
+# opencv-m
+
+OpenCV 5.0.0 C++ APIs through `mcpplibs.mwrap.opencv`, preserving `cv::` names.
+The candidate package is **5.0.0**: upstream 5.0.0 plus wrapper revision 1.
+
+**English** · [中文](../README.zh.md)
+
+This is an unpublished candidate with all sixteen main modules, explicit native
+window/video backends, PNG/JPEG/WebP and the ORT CPU bridge. Module availability,
+API coverage, runtime backends and target certification are separate questions.
+See the [coverage matrices](coverage.md) and [readiness ledger](../.agents/docs/2026-10-24-readiness-audit.md)
+for exact evidence and outstanding gates. Current source/index CI and final
+archive installation/deployment must pass before release.
+
+## Build the checkout
+
+Use mcpp **2026.10.24.1**, pinned in .xlings.json and CI:
+
+```sh
+mcpp test
+mcpp test --features imgcodecs-png,imgcodecs-jpeg
+mcpp test --features all-modules --strict
+mcpp test --features dnn,unifont
+python3 tools/test_template.py
+```
+
+Linux GCC/LLVM, Linux musl static, macOS arm64 and Windows MSVC-ABI builds are
+covered in CI. Core and PNG/JPEG behavior run on all five legs; the DNN/unifont
+combination currently runs on Linux GCC. Hardware capabilities require their
+own runtime evidence.
+
+## Project template
+
+The default template generates its own image, converts it to grayscale and
+writes out.png. Its actual mcpp renderer, generated manifest, build and execution
+are tested. No input image is required.
+
+After this candidate is published and indexed:
+
+```sh
+mcpp new myvision --template mcpplibs.mwrap.opencv@5.0.0
+cd myvision
+mcpp run
+```
+
+The named `window` template displays a generated image and processes window events:
+
+```sh
+mcpp new mywindow --template mcpplibs.mwrap.opencv@5.0.0:window
+cd mywindow
+mcpp run
+```
+
+Linux requires a graphical session and the `pkg-config` executable. The GTK3
+headers and libraries come from declared SDK dependencies. Headless CI uses Xvfb
+and `mcpp run -- --smoke-test` to close the window automatically.
+
+The named `onnxruntime` template runs a generated ONNX Add model through
+OpenCV's ENGINE_ORT and also imports the standalone ORT module:
+
+```sh
+mcpp new inference --template mcpplibs.mwrap.opencv@5.0.0:onnxruntime
+cd inference
+mcpp run
+```
+
+It declares the Linux toolchain-coupled C++ runtime needed by the shared SDK.
+The bridge's tests require ORT's real CPU session profile, so a native-engine
+fallback cannot satisfy them. Enabling dnn-onnxruntime also re-exports the ORT
+module through the selected aggregate, keeping cross-package BMI paths consistent
+for GCC. `cv::` and `Ort::` retain their upstream names.
+
+Local-source template tests and actual immutable-archive installation tests are
+separate. The index acceptance uses a fresh private home, runs the unmodified
+template and indexed API consumer, then packs and relocates the application.
+A successful older archive does not certify a later source checkpoint.
+
+## Dependencies and features
+
+```toml
+[dependencies."mcpplibs.mwrap"]
+opencv = { version = "5.0.0", features = ["imgcodecs-png", "imgcodecs-jpeg"] }
+```
+
+`default = []`; core is mandatory. Optional modules add their upstream dependency
+closure. Consumers can disable a dependency's defaults with `default-features = false`.
+
+| Feature | Current behavior |
+|---|---|
+| imgproc, flann, geometry | Selected algorithm modules |
+| calib, features, objdetect, photo, ptcloud, stereo, stitching, video | Remaining upstream main C++ modules |
+| all-modules | All sixteen main modules; external codecs, GUI backends and SDKs stay explicit |
+| imgcodecs | Image codec API and common source set |
+| imgcodecs-png, imgcodecs-jpeg | Enable the corresponding codec and imply imgcodecs |
+| imgcodecs-webp | Adds libwebp encode/decode, mux and demux for lossless/alpha images, animation and metadata |
+| videoio | Video I/O API |
+| videoio-ffmpeg | Adds the FFmpeg implementation and compat.ffmpeg dependency |
+| videoio-v4l2 | Adds V4L2 on Linux; other targets are refused |
+| videoio-native | Select V4L2 on Linux, Media Foundation on Windows, or AVFoundation on macOS |
+| videoio-msmf / videoio-avfoundation | Explicit Windows MSVC ABI / macOS native video backends; mismatched targets are refused |
+| highgui | GUI API only; current window backend is NONE |
+| highgui-native | Select GTK3 on Linux x86_64 glibc, Win32 on Windows, or Cocoa on macOS |
+| highgui-gtk3, highgui-win32, highgui-cocoa | Explicit native backend; mismatched targets are refused |
+| dnn | OpenCV's native DNN implementation; does not enable ORT |
+| dnn-onnxruntime | Adds dnn and the official ORT 1.25.1 CPU SDK through mcpplibs.mwrap.onnxruntime |
+| unifont | Unicode/CJK font rendering, implying imgproc |
+
+The all-modules feature selects sixteen implementations; it does not select
+external SDKs or every runtime backend. GTK3, Win32 and Cocoa window behavior
+and ORT CPU inference have native evidence in the coverage/readiness records;
+each new source checkpoint still requires its own platform CI. Physical camera
+capture and GPU/provider execution require applicable device runners.
+Calling imshow with API-only highgui still reports a missing window backend;
+enable highgui-native or a supported explicit backend. Planned/unavailable codec,
+GUI, video and accelerator names are listed in the coverage matrix and are not
+registered as empty features.
+
+## Modules, API and macros
+
+```cpp
+import mcpplibs.mwrap.opencv;
+// Or import the selected module directly:
+// import mcpplibs.mwrap.opencv.imgproc;
+```
+
+The root re-exports core, macros and the selected optional modules. Each public
+submodule also re-exports core and its required module dependencies, with its
+header adapter in a separate internal unit. The aggregate
+selection module is generated into the configuration-specific build directory
+before scanning, with direct imports. Optional modules are not exposed merely
+because their source exists in the checkout.
+
+`cv::Mat`, `cv::cvtColor` and other upstream APIs keep their spelling. Typed macro
+mappings use a separate namespace:
+
+```cpp
+namespace macros = mcpplibs::mwrap::opencv::macros;
+cv::Mat image(64, 64, macros::CV_8UC3, cv::Scalar(20, 80, 160));
+```
+
+Migration from the legacy wrapper uses these explicit replacements:
+
+| Legacy form | New candidate form |
+|---|---|
+| `opencv.opencv@5.0.0` | `mcpplibs.mwrap.opencv@5.0.0`; core-only default, with other features requested explicitly |
+| `import opencv;` / `import opencv.cv;` | `import mcpplibs.mwrap.opencv;` |
+| `import opencv.<module>;` | `import mcpplibs.mwrap.opencv.<module>;` with its module feature enabled |
+| Wrapper constant `cv::CV_8UC3` | `macros::CV_8UC3` with the namespace alias above |
+| Ordinary upstream `cv::Mat`, `cv::cvtColor`, etc. | Keep the original spelling |
+
+Historical package identities and resource bytes remain available unchanged;
+the new package does not add permanent aliases for the legacy module names.
+
+For preprocessing macros such as CV_Assert, include
+`<mwrap/opencv/macros.hpp>` **before** importing. Raw macros still expand inside
+qualified names: use raw macro and typed-mapping forms in separate contexts.
+
+
+The typed mappings include all 13 OpenCV 5 scalar depths, channel families
+(`CV_16BFC(n)`, `CV_BoolC(n)`, `CV_64UC(n)`, etc.), HAL value constants and
+matrix type/layout helpers. Regenerate them with `python3 tools/generate_macros.py`;
+`--check` verifies the committed result. Annotation and control-flow macros remain
+in the textual side header. The typed `CV_IS_SUBMAT` mapping repairs OpenCV 5.0.0's
+undefined `CV_MAT_SUBMAT_FLAG` reference by using the actual `CV_SUBMAT_FLAG`;
+the optional raw side header applies the same repair while the vendor file
+stays unchanged. Tests compare these helpers to real Mat
+allocations and ROI flags.
+
+For a facade-visible C++ inventory, first run `mcpp test --features all-modules
+--toolchain llvm@23.1.3 --strict`, then `python3 tools/audit_api.py --verify-exports`.
+The report separates declaration signatures, header ownership, internal linkage
+and listed exports, and compiles a separate import-only name-lookup consumer.
+Unloaded public headers and unlisted declarations remain review work; successful
+name lookup alone does not prove overload or algorithm coverage. CI publishes
+the inventory and consumer log for review.
+
+## Repository structure and upgrades
+
+- upstream/opencv contains the pinned source; upstream/sources.lock.toml records provenance and archive SHA256.
+- port contains configuration inputs and compatibility headers.
+- src contains wrapper interfaces and adapters; generated contains stable snapshots.
+- build.mcpp writes feature-specific configuration into its own output directory.
+- tools/generate_build.py regenerates the manifest, dependency map and source catalogs.
+- tools/check_upstream.py verifies retained file bytes against the pinned upstream archive.
+- templates and tests contain executable consumer examples and behavior checks.
+
+The import includes all sixteen main C++ modules. Newly integrated SIFT and
+pyramidal optical-flow dispatch use baseline implementations; FAST retains its
+x86 AVX2 TU. OpenCL kernels for the eight new modules are not integrated and
+configuration explicitly refuses enabling them. API completeness, additional
+backends and installed archives remain release gates. Design and
+implementation evidence live under .agents/docs; the common mwrap contract is
+maintained in mcpp-index/docs/mwrap.md.
+
+## License
+
+The root LICENSE is Apache-2.0 and the package metadata follows it. The vendored
+OpenCV sources are Apache-2.0; third-party components retain their own licenses.
+
+The named `video` template encodes and decodes 12 generated frames through FFmpeg and lists native camera backends without requiring a camera. Linux V4L2 tests cover registration and the missing-device path; physical camera capture remains unverified.
+
+```sh
+mcpp new video-demo --template mcpplibs.mwrap.opencv@5.0.0:video
+cd video-demo
+mcpp run
+```
diff --git a/docs/usage.zh.md b/docs/usage.zh.md
new file mode 100644
index 0000000..f897488
--- /dev/null
+++ b/docs/usage.zh.md
@@ -0,0 +1,184 @@
+详细使用与背景说明；当前候选版本的快捷入口与支持边界见 [README](../README.zh.md)。
+
+# opencv-m
+
+通过 `mcpplibs.mwrap.opencv` 使用 OpenCV 5.0.0 C++ API，保留 `cv::` 名称。
+候选包版本为 **5.0.0**：上游 5.0.0，加封装修订 1。
+
+[English](../README.md) · **中文**
+
+这是尚未发布的候选版本，已接入全部十六个主模块、显式原生窗口/视频后端、PNG/JPEG/WebP 和 ORT CPU 桥接。
+模块可用、API 覆盖、运行后端与目标认证分别验收；具体证据和剩余门槛见
+[覆盖矩阵](coverage.md) 与 [验收记录](../.agents/docs/2026-10-24-readiness-audit.md)。
+发布前仍须通过当前源码/索引提交的 CI，以及最终归档的实际安装和搬迁部署验收。
+
+## 构建本地 checkout
+
+使用 .xlings.json 和 CI 固定的 mcpp **2026.10.24.1**：
+
+```sh
+mcpp test
+mcpp test --features imgcodecs-png,imgcodecs-jpeg
+mcpp test --features all-modules --strict
+mcpp test --features dnn,unifont
+python3 tools/test_template.py
+```
+
+CI 覆盖 Linux GCC/LLVM、Linux musl 静态、macOS arm64 和 Windows MSVC ABI。
+五项均执行 core 与 PNG/JPEG 行为测试；DNN/unifont 组合当前由 Linux GCC 执行。
+硬件能力需要各自的运行证据。
+
+## 快捷模板
+
+默认模板自行生成图像、转为灰度并写出 out.png，不需要输入图片。
+开发验证会实际执行 mcpp 渲染、检查生成清单，再构建和运行工程。
+
+候选版本发布并加入索引后：
+
+```sh
+mcpp new myvision --template mcpplibs.mwrap.opencv@5.0.0
+cd myvision
+mcpp run
+```
+
+命名模板 `window` 会显示生成的图像并处理窗口事件：
+
+```sh
+mcpp new mywindow --template mcpplibs.mwrap.opencv@5.0.0:window
+cd mywindow
+mcpp run
+```
+
+Linux 需要图形会话与 `pkg-config` 命令；GTK3 头文件与库由声明的 SDK 依赖提供。
+无桌面的 CI 使用 Xvfb，并通过 `mcpp run -- --smoke-test` 自动关闭窗口。
+
+命名模板 `onnxruntime` 通过 OpenCV 的 ENGINE_ORT 运行生成的 ONNX Add 模型，
+并同时导入独立 ORT 模块：
+
+```sh
+mcpp new inference --template mcpplibs.mwrap.opencv@5.0.0:onnxruntime
+cd inference
+mcpp run
+```
+
+模板显式声明 Linux 共享 SDK 所需的 toolchain-coupled C++ runtime。
+桥接测试必须读到 ORT 实际生成的 CPU session profile，原生引擎回退不能通过验收。
+启用 dnn-onnxruntime 后，选择聚合模块也会转导出 ORT 模块，使 GCC 的跨包 BMI 路径保持一致；
+`cv::` 与 `Ort::` 名称不变。
+
+本地源码模板测试与真实不可变归档安装分别验收。索引验收使用独立测试 home，先运行未修改的模板，
+再运行索引 API 消费者并打包搬迁。旧归档通过不能证明后续源码 checkpoint 已通过。
+
+## 依赖与 feature
+
+```toml
+[dependencies."mcpplibs.mwrap"]
+opencv = { version = "5.0.0", features = ["imgcodecs-png", "imgcodecs-jpeg"] }
+```
+
+`default = []`，core 始终存在。可选模块按上游依赖关系展开。
+依赖边支持通过 `default-features = false` 关闭该边的默认请求。
+
+| Feature | 当前行为 |
+|---|---|
+| imgproc、flann、geometry | 按需启用对应算法模块 |
+| calib、features、objdetect、photo、ptcloud、stereo、stitching、video | 其余上游主仓库 C++ 模块 |
+| all-modules | 全部十六个主模块；外部 codec、窗口后端和 SDK 仍显式选择 |
+| imgcodecs | 图像 codec API 与通用源码 |
+| imgcodecs-png、imgcodecs-jpeg | 启用对应格式，并包含 imgcodecs |
+| imgcodecs-webp | 增加 libwebp 编解码、mux/demux，支持无损/透明图、动画与元数据 |
+| videoio | 视频 I/O API |
+| videoio-ffmpeg | 增加 FFmpeg 实现和 compat.ffmpeg 依赖 |
+| videoio-v4l2 | Linux V4L2，其他目标明确拒绝 |
+| videoio-native | 按目标选择 Linux V4L2、Windows Media Foundation 或 macOS AVFoundation |
+| videoio-msmf / videoio-avfoundation | 显式选择 Windows MSVC ABI / macOS 原生视频后端，拒绝目标不匹配 |
+| highgui | 只有 GUI API，当前窗口后端为 NONE |
+| highgui-native | Linux x86_64 glibc 选择 GTK3，Windows 选择 Win32，macOS 选择 Cocoa |
+| highgui-gtk3、highgui-win32、highgui-cocoa | 显式选择原生后端，目标不匹配时拒绝构建 |
+| dnn | OpenCV 原生 DNN 实现，不代表启用 ORT |
+| dnn-onnxruntime | 启用 dnn，并通过 mcpplibs.mwrap.onnxruntime 引入官方 ORT 1.25.1 CPU SDK |
+| unifont | Unicode/CJK 字体渲染，包含 imgproc |
+
+all-modules 选择十六个实现，不隐式选择外部 SDK 或全部后端。GTK3、Win32、Cocoa 窗口行为及 ORT CPU
+推理的原生证据见覆盖矩阵与验收记录；每个新源码 checkpoint 仍须通过对应平台 CI。
+真实摄像头采集与 GPU/provider 执行需要具备设备的 runner。
+仅选择 highgui API 时，imshow 仍会报告缺少窗口后端；请启用 highgui-native 或明确支持的后端。
+尚未接入的 codec、GUI、视频和加速能力列在覆盖矩阵中，不注册无实现的空 feature。
+
+## 模块、API 与宏
+
+```cpp
+import mcpplibs.mwrap.opencv;
+// 也可以直接导入已启用的模块：
+// import mcpplibs.mwrap.opencv.imgproc;
+```
+
+根模块聚合 core、macros 和已选择的模块。构建程序在配置独立的输出目录中生成聚合选择模块，
+以直接 import 交给扫描器；源码存在不代表消费者已启用该模块。
+
+上游的 `cv::Mat`、`cv::cvtColor` 等名称不变。宏的类型化映射单独放置：
+
+```cpp
+namespace macros = mcpplibs::mwrap::opencv::macros;
+cv::Mat image(64, 64, macros::CV_8UC3, cv::Scalar(20, 80, 160));
+```
+
+从旧封装迁移时，使用以下明确对照：
+
+| 旧形式 | 新候选形式 |
+|---|---|
+| `opencv.opencv@5.0.0` | `mcpplibs.mwrap.opencv@5.0.0`；默认仅 core，其他 feature 显式选择 |
+| `import opencv;` / `import opencv.cv;` | `import mcpplibs.mwrap.opencv;` |
+| `import opencv.<module>;` | `import mcpplibs.mwrap.opencv.<module>;`，并启用对应模块 feature |
+| 封装常量 `cv::CV_8UC3` | 使用上文 namespace 别名的 `macros::CV_8UC3` |
+| 普通上游 `cv::Mat`、`cv::cvtColor` 等 | 保持原名称 |
+
+旧包身份及其历史资源字节继续保留；新包不为旧模块名增加永久别名。
+
+需要 CV_Assert 等预处理宏时，在 import **之前**包含 `<mwrap/opencv/macros.hpp>`。
+原始宏仍会在限定名称中展开，因此宏形式与类型化映射应在不同使用上下文中选择。
+
+
+类型化映射包含 OpenCV 5 的全部 13 种标量深度、通道类型族
+（如 `CV_16BFC(n)`、`CV_BoolC(n)`、`CV_64UC(n)`）、HAL 值常量和矩阵布局函数。
+运行 `python3 tools/generate_macros.py` 重新生成，`--check` 检查生成结果。
+声明标记和控制流宏仍通过文本兼容头提供。类型化 `CV_IS_SUBMAT` 使用实际存在的
+`CV_SUBMAT_FLAG`，修复上游 5.0.0 对未定义 `CV_MAT_SUBMAT_FLAG` 的引用；可选文本兼容头也应用同一修复，上游文件保持不变。
+测试通过实际 Mat 分配、读写与 ROI 标记验证布局。
+
+需要审计当前封装头可见的 C++ API 时，先运行
+`mcpp test --features all-modules --toolchain llvm@23.1.3 --strict`，再运行
+`python3 tools/audit_api.py --verify-exports`。报告分别记录签名、所属头、内部链接与导出列表，
+并编译独立的纯 import 消费者检查名称查找。未加载的公共头和未列出的声明仍需审阅；
+名称可见不等于全部重载或算法行为已覆盖。CI 保存报告与消费者日志供 review。
+
+## 仓库布局与升级
+
+- upstream/opencv 保存固定上游源码，upstream/sources.lock.toml 记录来源与归档 SHA256。
+- port 保存配置输入与兼容头。
+- src 保存模块接口和适配，generated 保存稳定生成物。
+- build.mcpp 将 feature 相关配置写入自身输出目录。
+- tools/generate_build.py 生成 manifest、依赖图与源码清单。
+- tools/check_upstream.py 对照 SHA256 固定的上游归档验证保留文件字节。
+- templates 与 tests 保存可执行消费者和行为验证。
+
+当前已导入全部十六个主仓库 C++ 模块。新增 SIFT 与金字塔光流使用 baseline dispatch，
+FAST 保留 x86 AVX2 实现。八个新增模块的 OpenCL 内核尚未接入，配置会明确拒绝启用，
+不会把占位头视为 OpenCL 支持。API 完整性、新后端和安装归档仍是后续发布门槛。
+设计与实施证据位于 .agents/docs；共同 mwrap 规范维护在 mcpp-index/docs/mwrap.md。
+
+## 许可证
+
+根 LICENSE 为 Apache-2.0，包元数据与之保持一致。
+内置 OpenCV 为 Apache-2.0，各第三方组件保留其自身许可证。
+
+命名模板 `video` 使用 FFmpeg 编码并解码 12 帧生成图像，列出原生相机后端；不需要相机硬件。Linux V4L2 测试只验证注册和缺失设备路径，不能证明实体相机采集。
+
+```sh
+mcpp new video-demo --template mcpplibs.mwrap.opencv@5.0.0:video
+cd video-demo
+mcpp run
+```
+
+公共子模块也转导出 core 与必需模块依赖，头文件适配保存在独立内部模块单元。
+该布局及生成、验证流程见 [架构说明](../docs/architecture.md)。
diff --git a/examples/gray_pipeline/mcpp.toml b/examples/gray_pipeline/mcpp.toml
index 8c821ae..048d906 100644
--- a/examples/gray_pipeline/mcpp.toml
+++ b/examples/gray_pipeline/mcpp.toml
@@ -1,11 +1,11 @@
 [package]
 name        = "opencv-gray-pipeline"
 version     = "0.1.0"
-description = "imread → resize → grayscale → imwrite, all through import opencv.cv"
+description = "imread → resize → grayscale → imwrite, all through import mcpplibs.mwrap.opencv"
 license     = "Apache-2.0"
 
 [dependencies]
-opencv = { path = "../.." }
+opencv = { path = "../..", features = ["imgcodecs-png", "imgcodecs-jpeg"] }
 
 [targets.opencv-gray-pipeline]
 kind = "bin"
diff --git a/examples/gray_pipeline/src/main.cpp b/examples/gray_pipeline/src/main.cpp
index 9a53043..3a823bc 100644
--- a/examples/gray_pipeline/src/main.cpp
+++ b/examples/gray_pipeline/src/main.cpp
@@ -2,7 +2,7 @@
 // resize, grayscale, write a PNG next to it.
 #include <cstdio>
 import std;
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 int main(int argc, char** argv) {
     cv::Mat img;
diff --git a/examples/probe/mcpp.toml b/examples/probe/mcpp.toml
index 49e4982..9dd5fa7 100644
--- a/examples/probe/mcpp.toml
+++ b/examples/probe/mcpp.toml
@@ -1,7 +1,7 @@
 [package]
 name        = "opencv-probe"
 version     = "0.1.0"
-description = "Show the OpenCV build surface through import opencv.cv"
+description = "Show the OpenCV build surface through import mcpplibs.mwrap.opencv"
 license     = "Apache-2.0"
 
 [dependencies]
diff --git a/examples/probe/src/main.cpp b/examples/probe/src/main.cpp
index d1aae82..7558436 100644
--- a/examples/probe/src/main.cpp
+++ b/examples/probe/src/main.cpp
@@ -1,6 +1,6 @@
 // Show what the source-built OpenCV exposes — version, build info, backends.
 import std;
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 int main() {
     std::println("OpenCV {}", cv::getVersionString());
diff --git a/gen/common/opencv2/opencv_modules.hpp b/gen/common/opencv2/opencv_modules.hpp
deleted file mode 100644
index c71a384..0000000
--- a/gen/common/opencv2/opencv_modules.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- *      ** File generated automatically, do not modify **
- *
- * This file defines the list of modules available in current build configuration
- *
- *
-*/
-
-// This definition means that OpenCV is built with enabled non-free code.
-// For example, patented algorithms for non-profit/non-commercial use only.
-/* #undef OPENCV_ENABLE_NONFREE */
-
-#define HAVE_OPENCV_CORE
-#define HAVE_OPENCV_FLANN
-#define HAVE_OPENCV_GEOMETRY
-#define HAVE_OPENCV_HIGHGUI
-#define HAVE_OPENCV_IMGCODECS
-#define HAVE_OPENCV_IMGPROC
-#define HAVE_OPENCV_VIDEOIO
-
-
diff --git a/gen/linux/DNN_SOURCES.txt b/gen/linux/DNN_SOURCES.txt
deleted file mode 100644
index 2dd5ba5..0000000
--- a/gen/linux/DNN_SOURCES.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-third_party/opencv-5.0.0/3rdparty/mlas/lib/*.cpp
-third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/*.S
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/*.cc
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/*.cc
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/*.cc
-third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.cc
-third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.cc
-third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/*.cc
-third_party/opencv-5.0.0/modules/dnn/src/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.cpp
-third_party/opencv-5.0.0/modules/dnn/src/int8layers/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/layers/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/onnx/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tensorflow/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tflite/tflite_importer.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tokenizer/*.cpp
-gen/common/modules/dnn/int8layers/{conv2_int8_kernels.avx2,layers_common.avx2,layers_common.avx512_skx}.cpp
-gen/common/modules/dnn/layers/{layers_common.avx,layers_common.avx2,layers_common.avx512_skx}.cpp
-gen/common/modules/dnn/layers/cpu_kernels/{activation_kernels.avx,activation_kernels.avx2,conv2_depthwise.avx,conv2_depthwise.avx2,conv2_kernels.avx,conv2_kernels.avx2,conv_block.avx,conv_block.avx2,conv_depthwise.avx,conv_depthwise.avx2,conv_winograd_f63.avx,conv_winograd_f63.avx2,fast_gemm_kernels.avx,fast_gemm_kernels.avx2,gridsample_kernels.avx,gridsample_kernels.avx2,nary_eltwise_kernels.avx,nary_eltwise_kernels.avx2,reduce2_kernels.avx,reduce2_kernels.avx2,transpose_kernels.avx,transpose_kernels.avx2}.cpp
-gen/common/mlas_hgemm_stub.cpp
-gen/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/gen/linux/INCLUDE_DIRS.txt b/gen/linux/INCLUDE_DIRS.txt
deleted file mode 100644
index cb97ffb..0000000
--- a/gen/linux/INCLUDE_DIRS.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-gen/linux
-gen/common
-gen/linux/3rdparty/libjpeg-turbo
-gen/common/3rdparty/libjpeg-turbo
-gen/common/3rdparty/zlib
-gen/linux/modules/core
-gen/common/modules/core
-gen/linux/modules/imgproc
-gen/common/modules/imgproc
-gen/linux/modules/dnn
-gen/common/modules/dnn
-gen/common/modules/highgui
-gen/common/synth
diff --git a/gen/macosx/DNN_SOURCES.txt b/gen/macosx/DNN_SOURCES.txt
deleted file mode 100644
index ab498c9..0000000
--- a/gen/macosx/DNN_SOURCES.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-third_party/opencv-5.0.0/3rdparty/mlas/lib/*.cpp
-third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/*.S
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/*.cc
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/*.cc
-third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/*.cc
-third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.cc
-third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.cc
-third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/*.cc
-third_party/opencv-5.0.0/modules/dnn/src/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.cpp
-third_party/opencv-5.0.0/modules/dnn/src/int8layers/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/layers/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/onnx/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tensorflow/*.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tflite/tflite_importer.cpp
-third_party/opencv-5.0.0/modules/dnn/src/tokenizer/*.cpp
-gen/common/modules/dnn/int8layers/layers_common.neon.cpp
-gen/common/modules/dnn/layers/layers_common.neon.cpp
-gen/common/modules/dnn/layers/cpu_kernels/{activation_kernels.neon,conv2_depthwise.neon,conv2_kernels.neon,conv_block.neon,conv_block.neon_fp16,conv_winograd_f63.neon,fast_gemm_kernels.neon,gridsample_kernels.neon,nary_eltwise_kernels.neon,reduce2_kernels.neon,transpose_kernels.neon}.cpp
-gen/common/mlas_hgemm_stub.cpp
-gen/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/gen/macosx/INCLUDE_DIRS.txt b/gen/macosx/INCLUDE_DIRS.txt
deleted file mode 100644
index f5c80b5..0000000
--- a/gen/macosx/INCLUDE_DIRS.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-gen/macosx
-gen/common
-gen/macosx/3rdparty/libjpeg-turbo
-gen/common/3rdparty/libjpeg-turbo
-gen/macosx/3rdparty/libjpeg-turbo/simd/arm
-gen/common/3rdparty/zlib
-gen/macosx/modules/core
-gen/common/modules/core
-gen/macosx/modules/imgproc
-gen/common/modules/imgproc
-gen/macosx/modules/dnn
-gen/common/modules/dnn
-gen/common/modules/highgui
-gen/common/synth
diff --git a/gen/windows/DNN_SOURCES.txt b/gen/windows/DNN_SOURCES.txt
deleted file mode 100644
index 6d1fd25..0000000
--- a/gen/windows/DNN_SOURCES.txt
+++ /dev/null
@@ -1,277 +0,0 @@
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc
-gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp
-gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp
-gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp
diff --git a/gen/windows/INCLUDE_DIRS.txt b/gen/windows/INCLUDE_DIRS.txt
deleted file mode 100644
index b18efd5..0000000
--- a/gen/windows/INCLUDE_DIRS.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-gen/windows
-gen/common
-gen/windows/3rdparty/libjpeg-turbo
-gen/common/3rdparty/libjpeg-turbo
-gen/common/3rdparty/zlib
-gen/windows/modules/core
-gen/common/modules/core
-gen/windows/modules/imgproc
-gen/common/modules/imgproc
-gen/windows/modules/dnn
-gen/common/modules/dnn
-gen/common/modules/highgui
-gen/common/synth
diff --git a/gen/common/3rdparty/libjpeg-turbo/jversion.h b/generated/common/3rdparty/libjpeg-turbo/jversion.h
similarity index 100%
rename from gen/common/3rdparty/libjpeg-turbo/jversion.h
rename to generated/common/3rdparty/libjpeg-turbo/jversion.h
diff --git a/gen/common/3rdparty/zlib/zconf.h b/generated/common/3rdparty/zlib/zconf.h
similarity index 100%
rename from gen/common/3rdparty/zlib/zconf.h
rename to generated/common/3rdparty/zlib/zconf.h
diff --git a/gen/common/custom_hal.hpp b/generated/common/custom_hal.hpp
similarity index 100%
rename from gen/common/custom_hal.hpp
rename to generated/common/custom_hal.hpp
diff --git a/gen/common/mlas_hgemm_stub.cpp b/generated/common/mlas_hgemm_stub.cpp
similarity index 100%
rename from gen/common/mlas_hgemm_stub.cpp
rename to generated/common/mlas_hgemm_stub.cpp
diff --git a/gen/common/modules/core/arithm.avx2.cpp b/generated/common/modules/core/arithm.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/arithm.avx2.cpp
rename to generated/common/modules/core/arithm.avx2.cpp
diff --git a/gen/common/modules/core/arithm.lasx.cpp b/generated/common/modules/core/arithm.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/arithm.lasx.cpp
rename to generated/common/modules/core/arithm.lasx.cpp
diff --git a/gen/common/modules/core/arithm.sse2.cpp b/generated/common/modules/core/arithm.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/arithm.sse2.cpp
rename to generated/common/modules/core/arithm.sse2.cpp
diff --git a/gen/common/modules/core/arithm.sse4_1.cpp b/generated/common/modules/core/arithm.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/core/arithm.sse4_1.cpp
rename to generated/common/modules/core/arithm.sse4_1.cpp
diff --git a/gen/common/modules/core/arithm.vsx3.cpp b/generated/common/modules/core/arithm.vsx3.cpp
similarity index 100%
rename from gen/common/modules/core/arithm.vsx3.cpp
rename to generated/common/modules/core/arithm.vsx3.cpp
diff --git a/gen/common/modules/core/convert.avx2.cpp b/generated/common/modules/core/convert.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/convert.avx2.cpp
rename to generated/common/modules/core/convert.avx2.cpp
diff --git a/gen/common/modules/core/convert.lasx.cpp b/generated/common/modules/core/convert.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/convert.lasx.cpp
rename to generated/common/modules/core/convert.lasx.cpp
diff --git a/gen/common/modules/core/convert.sse2.cpp b/generated/common/modules/core/convert.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/convert.sse2.cpp
rename to generated/common/modules/core/convert.sse2.cpp
diff --git a/gen/common/modules/core/convert.vsx3.cpp b/generated/common/modules/core/convert.vsx3.cpp
similarity index 100%
rename from gen/common/modules/core/convert.vsx3.cpp
rename to generated/common/modules/core/convert.vsx3.cpp
diff --git a/gen/common/modules/core/convert_scale.avx2.cpp b/generated/common/modules/core/convert_scale.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/convert_scale.avx2.cpp
rename to generated/common/modules/core/convert_scale.avx2.cpp
diff --git a/gen/common/modules/core/convert_scale.lasx.cpp b/generated/common/modules/core/convert_scale.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/convert_scale.lasx.cpp
rename to generated/common/modules/core/convert_scale.lasx.cpp
diff --git a/gen/common/modules/core/convert_scale.sse2.cpp b/generated/common/modules/core/convert_scale.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/convert_scale.sse2.cpp
rename to generated/common/modules/core/convert_scale.sse2.cpp
diff --git a/gen/common/modules/core/count_non_zero.avx2.cpp b/generated/common/modules/core/count_non_zero.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/count_non_zero.avx2.cpp
rename to generated/common/modules/core/count_non_zero.avx2.cpp
diff --git a/gen/common/modules/core/count_non_zero.lasx.cpp b/generated/common/modules/core/count_non_zero.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/count_non_zero.lasx.cpp
rename to generated/common/modules/core/count_non_zero.lasx.cpp
diff --git a/gen/common/modules/core/count_non_zero.sse2.cpp b/generated/common/modules/core/count_non_zero.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/count_non_zero.sse2.cpp
rename to generated/common/modules/core/count_non_zero.sse2.cpp
diff --git a/gen/common/modules/core/has_non_zero.avx2.cpp b/generated/common/modules/core/has_non_zero.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/has_non_zero.avx2.cpp
rename to generated/common/modules/core/has_non_zero.avx2.cpp
diff --git a/gen/common/modules/core/has_non_zero.lasx.cpp b/generated/common/modules/core/has_non_zero.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/has_non_zero.lasx.cpp
rename to generated/common/modules/core/has_non_zero.lasx.cpp
diff --git a/gen/common/modules/core/has_non_zero.sse2.cpp b/generated/common/modules/core/has_non_zero.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/has_non_zero.sse2.cpp
rename to generated/common/modules/core/has_non_zero.sse2.cpp
diff --git a/gen/common/modules/core/mathfuncs_core.avx.cpp b/generated/common/modules/core/mathfuncs_core.avx.cpp
similarity index 100%
rename from gen/common/modules/core/mathfuncs_core.avx.cpp
rename to generated/common/modules/core/mathfuncs_core.avx.cpp
diff --git a/gen/common/modules/core/mathfuncs_core.avx2.cpp b/generated/common/modules/core/mathfuncs_core.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/mathfuncs_core.avx2.cpp
rename to generated/common/modules/core/mathfuncs_core.avx2.cpp
diff --git a/gen/common/modules/core/mathfuncs_core.lasx.cpp b/generated/common/modules/core/mathfuncs_core.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/mathfuncs_core.lasx.cpp
rename to generated/common/modules/core/mathfuncs_core.lasx.cpp
diff --git a/gen/common/modules/core/mathfuncs_core.sse2.cpp b/generated/common/modules/core/mathfuncs_core.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/mathfuncs_core.sse2.cpp
rename to generated/common/modules/core/mathfuncs_core.sse2.cpp
diff --git a/gen/common/modules/core/matmul.avx2.cpp b/generated/common/modules/core/matmul.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.avx2.cpp
rename to generated/common/modules/core/matmul.avx2.cpp
diff --git a/gen/common/modules/core/matmul.avx512_skx.cpp b/generated/common/modules/core/matmul.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.avx512_skx.cpp
rename to generated/common/modules/core/matmul.avx512_skx.cpp
diff --git a/gen/common/modules/core/matmul.lasx.cpp b/generated/common/modules/core/matmul.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.lasx.cpp
rename to generated/common/modules/core/matmul.lasx.cpp
diff --git a/gen/common/modules/core/matmul.neon_dotprod.cpp b/generated/common/modules/core/matmul.neon_dotprod.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.neon_dotprod.cpp
rename to generated/common/modules/core/matmul.neon_dotprod.cpp
diff --git a/gen/common/modules/core/matmul.sse2.cpp b/generated/common/modules/core/matmul.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.sse2.cpp
rename to generated/common/modules/core/matmul.sse2.cpp
diff --git a/gen/common/modules/core/matmul.sse4_1.cpp b/generated/common/modules/core/matmul.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/core/matmul.sse4_1.cpp
rename to generated/common/modules/core/matmul.sse4_1.cpp
diff --git a/gen/common/modules/core/mean.avx2.cpp b/generated/common/modules/core/mean.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/mean.avx2.cpp
rename to generated/common/modules/core/mean.avx2.cpp
diff --git a/gen/common/modules/core/mean.lasx.cpp b/generated/common/modules/core/mean.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/mean.lasx.cpp
rename to generated/common/modules/core/mean.lasx.cpp
diff --git a/gen/common/modules/core/mean.sse2.cpp b/generated/common/modules/core/mean.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/mean.sse2.cpp
rename to generated/common/modules/core/mean.sse2.cpp
diff --git a/gen/common/modules/core/merge.avx2.cpp b/generated/common/modules/core/merge.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/merge.avx2.cpp
rename to generated/common/modules/core/merge.avx2.cpp
diff --git a/gen/common/modules/core/merge.lasx.cpp b/generated/common/modules/core/merge.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/merge.lasx.cpp
rename to generated/common/modules/core/merge.lasx.cpp
diff --git a/gen/common/modules/core/merge.sse2.cpp b/generated/common/modules/core/merge.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/merge.sse2.cpp
rename to generated/common/modules/core/merge.sse2.cpp
diff --git a/gen/common/modules/core/minmax.avx2.cpp b/generated/common/modules/core/minmax.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/minmax.avx2.cpp
rename to generated/common/modules/core/minmax.avx2.cpp
diff --git a/gen/common/modules/core/minmax.lasx.cpp b/generated/common/modules/core/minmax.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/minmax.lasx.cpp
rename to generated/common/modules/core/minmax.lasx.cpp
diff --git a/gen/common/modules/core/minmax.sse2.cpp b/generated/common/modules/core/minmax.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/minmax.sse2.cpp
rename to generated/common/modules/core/minmax.sse2.cpp
diff --git a/gen/common/modules/core/minmax.sse4_1.cpp b/generated/common/modules/core/minmax.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/core/minmax.sse4_1.cpp
rename to generated/common/modules/core/minmax.sse4_1.cpp
diff --git a/gen/common/modules/core/minmax.vsx3.cpp b/generated/common/modules/core/minmax.vsx3.cpp
similarity index 100%
rename from gen/common/modules/core/minmax.vsx3.cpp
rename to generated/common/modules/core/minmax.vsx3.cpp
diff --git a/gen/common/modules/core/nan_mask.avx2.cpp b/generated/common/modules/core/nan_mask.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/nan_mask.avx2.cpp
rename to generated/common/modules/core/nan_mask.avx2.cpp
diff --git a/gen/common/modules/core/nan_mask.lasx.cpp b/generated/common/modules/core/nan_mask.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/nan_mask.lasx.cpp
rename to generated/common/modules/core/nan_mask.lasx.cpp
diff --git a/gen/common/modules/core/nan_mask.sse2.cpp b/generated/common/modules/core/nan_mask.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/nan_mask.sse2.cpp
rename to generated/common/modules/core/nan_mask.sse2.cpp
diff --git a/gen/common/modules/core/norm.avx.cpp b/generated/common/modules/core/norm.avx.cpp
similarity index 100%
rename from gen/common/modules/core/norm.avx.cpp
rename to generated/common/modules/core/norm.avx.cpp
diff --git a/gen/common/modules/core/norm.avx2.cpp b/generated/common/modules/core/norm.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/norm.avx2.cpp
rename to generated/common/modules/core/norm.avx2.cpp
diff --git a/gen/common/modules/core/norm.lasx.cpp b/generated/common/modules/core/norm.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/norm.lasx.cpp
rename to generated/common/modules/core/norm.lasx.cpp
diff --git a/gen/common/modules/core/norm.neon_dotprod.cpp b/generated/common/modules/core/norm.neon_dotprod.cpp
similarity index 100%
rename from gen/common/modules/core/norm.neon_dotprod.cpp
rename to generated/common/modules/core/norm.neon_dotprod.cpp
diff --git a/gen/common/modules/core/norm.sse2.cpp b/generated/common/modules/core/norm.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/norm.sse2.cpp
rename to generated/common/modules/core/norm.sse2.cpp
diff --git a/gen/common/modules/core/norm.sse4_1.cpp b/generated/common/modules/core/norm.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/core/norm.sse4_1.cpp
rename to generated/common/modules/core/norm.sse4_1.cpp
diff --git a/gen/common/modules/core/reduce.avx2.cpp b/generated/common/modules/core/reduce.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/reduce.avx2.cpp
rename to generated/common/modules/core/reduce.avx2.cpp
diff --git a/gen/common/modules/core/reduce.neon_dotprod.cpp b/generated/common/modules/core/reduce.neon_dotprod.cpp
similarity index 100%
rename from gen/common/modules/core/reduce.neon_dotprod.cpp
rename to generated/common/modules/core/reduce.neon_dotprod.cpp
diff --git a/gen/common/modules/core/reduce.sse2.cpp b/generated/common/modules/core/reduce.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/reduce.sse2.cpp
rename to generated/common/modules/core/reduce.sse2.cpp
diff --git a/gen/common/modules/core/reduce.ssse3.cpp b/generated/common/modules/core/reduce.ssse3.cpp
similarity index 100%
rename from gen/common/modules/core/reduce.ssse3.cpp
rename to generated/common/modules/core/reduce.ssse3.cpp
diff --git a/gen/common/modules/core/split.avx2.cpp b/generated/common/modules/core/split.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/split.avx2.cpp
rename to generated/common/modules/core/split.avx2.cpp
diff --git a/gen/common/modules/core/split.lasx.cpp b/generated/common/modules/core/split.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/split.lasx.cpp
rename to generated/common/modules/core/split.lasx.cpp
diff --git a/gen/common/modules/core/split.sse2.cpp b/generated/common/modules/core/split.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/split.sse2.cpp
rename to generated/common/modules/core/split.sse2.cpp
diff --git a/gen/common/modules/core/stat.avx2.cpp b/generated/common/modules/core/stat.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/stat.avx2.cpp
rename to generated/common/modules/core/stat.avx2.cpp
diff --git a/gen/common/modules/core/stat.lasx.cpp b/generated/common/modules/core/stat.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/stat.lasx.cpp
rename to generated/common/modules/core/stat.lasx.cpp
diff --git a/gen/common/modules/core/stat.sse4_2.cpp b/generated/common/modules/core/stat.sse4_2.cpp
similarity index 100%
rename from gen/common/modules/core/stat.sse4_2.cpp
rename to generated/common/modules/core/stat.sse4_2.cpp
diff --git a/gen/common/modules/core/sum.avx2.cpp b/generated/common/modules/core/sum.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/sum.avx2.cpp
rename to generated/common/modules/core/sum.avx2.cpp
diff --git a/gen/common/modules/core/sum.lasx.cpp b/generated/common/modules/core/sum.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/sum.lasx.cpp
rename to generated/common/modules/core/sum.lasx.cpp
diff --git a/gen/common/modules/core/sum.sse2.cpp b/generated/common/modules/core/sum.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/sum.sse2.cpp
rename to generated/common/modules/core/sum.sse2.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.avx.cpp b/generated/common/modules/core/test/test_intrin128.avx.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.avx.cpp
rename to generated/common/modules/core/test/test_intrin128.avx.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.avx2.cpp b/generated/common/modules/core/test/test_intrin128.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.avx2.cpp
rename to generated/common/modules/core/test/test_intrin128.avx2.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.avx512_skx.cpp b/generated/common/modules/core/test/test_intrin128.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.avx512_skx.cpp
rename to generated/common/modules/core/test/test_intrin128.avx512_skx.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.fp16.cpp b/generated/common/modules/core/test/test_intrin128.fp16.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.fp16.cpp
rename to generated/common/modules/core/test/test_intrin128.fp16.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.simd_declarations.hpp b/generated/common/modules/core/test/test_intrin128.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.simd_declarations.hpp
rename to generated/common/modules/core/test/test_intrin128.simd_declarations.hpp
diff --git a/gen/common/modules/core/test/test_intrin128.sse2.cpp b/generated/common/modules/core/test/test_intrin128.sse2.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.sse2.cpp
rename to generated/common/modules/core/test/test_intrin128.sse2.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.sse3.cpp b/generated/common/modules/core/test/test_intrin128.sse3.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.sse3.cpp
rename to generated/common/modules/core/test/test_intrin128.sse3.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.sse4_1.cpp b/generated/common/modules/core/test/test_intrin128.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.sse4_1.cpp
rename to generated/common/modules/core/test/test_intrin128.sse4_1.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.sse4_2.cpp b/generated/common/modules/core/test/test_intrin128.sse4_2.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.sse4_2.cpp
rename to generated/common/modules/core/test/test_intrin128.sse4_2.cpp
diff --git a/gen/common/modules/core/test/test_intrin128.ssse3.cpp b/generated/common/modules/core/test/test_intrin128.ssse3.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin128.ssse3.cpp
rename to generated/common/modules/core/test/test_intrin128.ssse3.cpp
diff --git a/gen/common/modules/core/test/test_intrin256.avx2.cpp b/generated/common/modules/core/test/test_intrin256.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin256.avx2.cpp
rename to generated/common/modules/core/test/test_intrin256.avx2.cpp
diff --git a/gen/common/modules/core/test/test_intrin256.avx512_skx.cpp b/generated/common/modules/core/test/test_intrin256.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin256.avx512_skx.cpp
rename to generated/common/modules/core/test/test_intrin256.avx512_skx.cpp
diff --git a/gen/common/modules/core/test/test_intrin256.lasx.cpp b/generated/common/modules/core/test/test_intrin256.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin256.lasx.cpp
rename to generated/common/modules/core/test/test_intrin256.lasx.cpp
diff --git a/gen/common/modules/core/test/test_intrin256.simd_declarations.hpp b/generated/common/modules/core/test/test_intrin256.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin256.simd_declarations.hpp
rename to generated/common/modules/core/test/test_intrin256.simd_declarations.hpp
diff --git a/gen/common/modules/core/test/test_intrin512.avx512_skx.cpp b/generated/common/modules/core/test/test_intrin512.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin512.avx512_skx.cpp
rename to generated/common/modules/core/test/test_intrin512.avx512_skx.cpp
diff --git a/gen/common/modules/core/test/test_intrin512.simd_declarations.hpp b/generated/common/modules/core/test/test_intrin512.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/core/test/test_intrin512.simd_declarations.hpp
rename to generated/common/modules/core/test/test_intrin512.simd_declarations.hpp
diff --git a/gen/common/modules/core/transpose.avx.cpp b/generated/common/modules/core/transpose.avx.cpp
similarity index 100%
rename from gen/common/modules/core/transpose.avx.cpp
rename to generated/common/modules/core/transpose.avx.cpp
diff --git a/gen/common/modules/core/transpose.avx2.cpp b/generated/common/modules/core/transpose.avx2.cpp
similarity index 100%
rename from gen/common/modules/core/transpose.avx2.cpp
rename to generated/common/modules/core/transpose.avx2.cpp
diff --git a/gen/common/modules/core/transpose.lasx.cpp b/generated/common/modules/core/transpose.lasx.cpp
similarity index 100%
rename from gen/common/modules/core/transpose.lasx.cpp
rename to generated/common/modules/core/transpose.lasx.cpp
diff --git a/gen/common/modules/core/transpose.neon.cpp b/generated/common/modules/core/transpose.neon.cpp
similarity index 100%
rename from gen/common/modules/core/transpose.neon.cpp
rename to generated/common/modules/core/transpose.neon.cpp
diff --git a/gen/common/modules/core/transpose.rvv.cpp b/generated/common/modules/core/transpose.rvv.cpp
similarity index 100%
rename from gen/common/modules/core/transpose.rvv.cpp
rename to generated/common/modules/core/transpose.rvv.cpp
diff --git a/gen/common/modules/dnn/int8layers/conv2_int8_kernels.avx2.cpp b/generated/common/modules/dnn/int8layers/conv2_int8_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/conv2_int8_kernels.avx2.cpp
rename to generated/common/modules/dnn/int8layers/conv2_int8_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/int8layers/conv2_int8_kernels.simd_declarations.hpp b/generated/common/modules/dnn/int8layers/conv2_int8_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/conv2_int8_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/int8layers/conv2_int8_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.avx2.cpp b/generated/common/modules/dnn/int8layers/layers_common.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.avx2.cpp
rename to generated/common/modules/dnn/int8layers/layers_common.avx2.cpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.avx512_skx.cpp b/generated/common/modules/dnn/int8layers/layers_common.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.avx512_skx.cpp
rename to generated/common/modules/dnn/int8layers/layers_common.avx512_skx.cpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.lasx.cpp b/generated/common/modules/dnn/int8layers/layers_common.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.lasx.cpp
rename to generated/common/modules/dnn/int8layers/layers_common.lasx.cpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.neon.cpp b/generated/common/modules/dnn/int8layers/layers_common.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.neon.cpp
rename to generated/common/modules/dnn/int8layers/layers_common.neon.cpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.rvv.cpp b/generated/common/modules/dnn/int8layers/layers_common.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.rvv.cpp
rename to generated/common/modules/dnn/int8layers/layers_common.rvv.cpp
diff --git a/gen/common/modules/dnn/int8layers/layers_common.simd_declarations.hpp b/generated/common/modules/dnn/int8layers/layers_common.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/int8layers/layers_common.simd_declarations.hpp
rename to generated/common/modules/dnn/int8layers/layers_common.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon_fp16.cpp b/generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon_fp16.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon_fp16.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon_fp16.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon_fp16.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon_fp16.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon_fp16.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon_fp16.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon_fp16.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_block.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_block.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_block.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_block.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_block.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_block.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_block.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_block.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_block.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_block.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_block.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_block.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.rvv.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.rvv.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_depthwise.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_depthwise.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon_fp16.cpp b/generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon_fp16.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon_fp16.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.rvv.cpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.rvv.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.rvv.cpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.rvv.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.rvv.cpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.rvv.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx2.cpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx2.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.lasx.cpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.lasx.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.rvv.cpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.rvv.cpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.simd_declarations.hpp b/generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/layers_common.avx.cpp b/generated/common/modules/dnn/layers/layers_common.avx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.avx.cpp
rename to generated/common/modules/dnn/layers/layers_common.avx.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.avx2.cpp b/generated/common/modules/dnn/layers/layers_common.avx2.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.avx2.cpp
rename to generated/common/modules/dnn/layers/layers_common.avx2.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.avx512_skx.cpp b/generated/common/modules/dnn/layers/layers_common.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.avx512_skx.cpp
rename to generated/common/modules/dnn/layers/layers_common.avx512_skx.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.lasx.cpp b/generated/common/modules/dnn/layers/layers_common.lasx.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.lasx.cpp
rename to generated/common/modules/dnn/layers/layers_common.lasx.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.neon.cpp b/generated/common/modules/dnn/layers/layers_common.neon.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.neon.cpp
rename to generated/common/modules/dnn/layers/layers_common.neon.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.rvv.cpp b/generated/common/modules/dnn/layers/layers_common.rvv.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.rvv.cpp
rename to generated/common/modules/dnn/layers/layers_common.rvv.cpp
diff --git a/gen/common/modules/dnn/layers/layers_common.simd_declarations.hpp b/generated/common/modules/dnn/layers/layers_common.simd_declarations.hpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.simd_declarations.hpp
rename to generated/common/modules/dnn/layers/layers_common.simd_declarations.hpp
diff --git a/gen/common/modules/dnn/layers/layers_common.sve.cpp b/generated/common/modules/dnn/layers/layers_common.sve.cpp
similarity index 100%
rename from gen/common/modules/dnn/layers/layers_common.sve.cpp
rename to generated/common/modules/dnn/layers/layers_common.sve.cpp
diff --git a/gen/common/modules/highgui/opencv_highgui_config.hpp b/generated/common/modules/highgui/opencv_highgui_config.hpp
similarity index 100%
rename from gen/common/modules/highgui/opencv_highgui_config.hpp
rename to generated/common/modules/highgui/opencv_highgui_config.hpp
diff --git a/gen/common/modules/imgproc/accum.avx.cpp b/generated/common/modules/imgproc/accum.avx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/accum.avx.cpp
rename to generated/common/modules/imgproc/accum.avx.cpp
diff --git a/gen/common/modules/imgproc/accum.avx2.cpp b/generated/common/modules/imgproc/accum.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/accum.avx2.cpp
rename to generated/common/modules/imgproc/accum.avx2.cpp
diff --git a/gen/common/modules/imgproc/accum.sse4_1.cpp b/generated/common/modules/imgproc/accum.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/accum.sse4_1.cpp
rename to generated/common/modules/imgproc/accum.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/bilateral_filter.avx2.cpp b/generated/common/modules/imgproc/bilateral_filter.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/bilateral_filter.avx2.cpp
rename to generated/common/modules/imgproc/bilateral_filter.avx2.cpp
diff --git a/gen/common/modules/imgproc/bilateral_filter.avx512_icl.cpp b/generated/common/modules/imgproc/bilateral_filter.avx512_icl.cpp
similarity index 100%
rename from gen/common/modules/imgproc/bilateral_filter.avx512_icl.cpp
rename to generated/common/modules/imgproc/bilateral_filter.avx512_icl.cpp
diff --git a/gen/common/modules/imgproc/bilateral_filter.avx512_skx.cpp b/generated/common/modules/imgproc/bilateral_filter.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/bilateral_filter.avx512_skx.cpp
rename to generated/common/modules/imgproc/bilateral_filter.avx512_skx.cpp
diff --git a/gen/common/modules/imgproc/bilateral_filter.sse2.cpp b/generated/common/modules/imgproc/bilateral_filter.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/bilateral_filter.sse2.cpp
rename to generated/common/modules/imgproc/bilateral_filter.sse2.cpp
diff --git a/gen/common/modules/imgproc/box_filter.avx2.cpp b/generated/common/modules/imgproc/box_filter.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/box_filter.avx2.cpp
rename to generated/common/modules/imgproc/box_filter.avx2.cpp
diff --git a/gen/common/modules/imgproc/box_filter.avx512_skx.cpp b/generated/common/modules/imgproc/box_filter.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/box_filter.avx512_skx.cpp
rename to generated/common/modules/imgproc/box_filter.avx512_skx.cpp
diff --git a/gen/common/modules/imgproc/box_filter.sse2.cpp b/generated/common/modules/imgproc/box_filter.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/box_filter.sse2.cpp
rename to generated/common/modules/imgproc/box_filter.sse2.cpp
diff --git a/gen/common/modules/imgproc/box_filter.sse4_1.cpp b/generated/common/modules/imgproc/box_filter.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/box_filter.sse4_1.cpp
rename to generated/common/modules/imgproc/box_filter.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/color_hsv.avx2.cpp b/generated/common/modules/imgproc/color_hsv.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_hsv.avx2.cpp
rename to generated/common/modules/imgproc/color_hsv.avx2.cpp
diff --git a/gen/common/modules/imgproc/color_hsv.sse2.cpp b/generated/common/modules/imgproc/color_hsv.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_hsv.sse2.cpp
rename to generated/common/modules/imgproc/color_hsv.sse2.cpp
diff --git a/gen/common/modules/imgproc/color_hsv.sse4_1.cpp b/generated/common/modules/imgproc/color_hsv.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_hsv.sse4_1.cpp
rename to generated/common/modules/imgproc/color_hsv.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/color_rgb.avx2.cpp b/generated/common/modules/imgproc/color_rgb.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_rgb.avx2.cpp
rename to generated/common/modules/imgproc/color_rgb.avx2.cpp
diff --git a/gen/common/modules/imgproc/color_rgb.sse2.cpp b/generated/common/modules/imgproc/color_rgb.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_rgb.sse2.cpp
rename to generated/common/modules/imgproc/color_rgb.sse2.cpp
diff --git a/gen/common/modules/imgproc/color_rgb.sse4_1.cpp b/generated/common/modules/imgproc/color_rgb.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_rgb.sse4_1.cpp
rename to generated/common/modules/imgproc/color_rgb.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/color_yuv.avx2.cpp b/generated/common/modules/imgproc/color_yuv.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_yuv.avx2.cpp
rename to generated/common/modules/imgproc/color_yuv.avx2.cpp
diff --git a/gen/common/modules/imgproc/color_yuv.sse2.cpp b/generated/common/modules/imgproc/color_yuv.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_yuv.sse2.cpp
rename to generated/common/modules/imgproc/color_yuv.sse2.cpp
diff --git a/gen/common/modules/imgproc/color_yuv.sse4_1.cpp b/generated/common/modules/imgproc/color_yuv.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/color_yuv.sse4_1.cpp
rename to generated/common/modules/imgproc/color_yuv.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/filter.avx2.cpp b/generated/common/modules/imgproc/filter.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/filter.avx2.cpp
rename to generated/common/modules/imgproc/filter.avx2.cpp
diff --git a/gen/common/modules/imgproc/filter.sse2.cpp b/generated/common/modules/imgproc/filter.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/filter.sse2.cpp
rename to generated/common/modules/imgproc/filter.sse2.cpp
diff --git a/gen/common/modules/imgproc/filter.sse4_1.cpp b/generated/common/modules/imgproc/filter.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/filter.sse4_1.cpp
rename to generated/common/modules/imgproc/filter.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/median_blur.avx2.cpp b/generated/common/modules/imgproc/median_blur.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/median_blur.avx2.cpp
rename to generated/common/modules/imgproc/median_blur.avx2.cpp
diff --git a/gen/common/modules/imgproc/median_blur.avx512_icl.cpp b/generated/common/modules/imgproc/median_blur.avx512_icl.cpp
similarity index 100%
rename from gen/common/modules/imgproc/median_blur.avx512_icl.cpp
rename to generated/common/modules/imgproc/median_blur.avx512_icl.cpp
diff --git a/gen/common/modules/imgproc/median_blur.avx512_skx.cpp b/generated/common/modules/imgproc/median_blur.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/median_blur.avx512_skx.cpp
rename to generated/common/modules/imgproc/median_blur.avx512_skx.cpp
diff --git a/gen/common/modules/imgproc/median_blur.sse2.cpp b/generated/common/modules/imgproc/median_blur.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/median_blur.sse2.cpp
rename to generated/common/modules/imgproc/median_blur.sse2.cpp
diff --git a/gen/common/modules/imgproc/median_blur.sse4_1.cpp b/generated/common/modules/imgproc/median_blur.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/median_blur.sse4_1.cpp
rename to generated/common/modules/imgproc/median_blur.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/morph.avx2.cpp b/generated/common/modules/imgproc/morph.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/morph.avx2.cpp
rename to generated/common/modules/imgproc/morph.avx2.cpp
diff --git a/gen/common/modules/imgproc/morph.sse2.cpp b/generated/common/modules/imgproc/morph.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/morph.sse2.cpp
rename to generated/common/modules/imgproc/morph.sse2.cpp
diff --git a/gen/common/modules/imgproc/morph.sse4_1.cpp b/generated/common/modules/imgproc/morph.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/morph.sse4_1.cpp
rename to generated/common/modules/imgproc/morph.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/smooth.avx2.cpp b/generated/common/modules/imgproc/smooth.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/smooth.avx2.cpp
rename to generated/common/modules/imgproc/smooth.avx2.cpp
diff --git a/gen/common/modules/imgproc/smooth.avx512_icl.cpp b/generated/common/modules/imgproc/smooth.avx512_icl.cpp
similarity index 100%
rename from gen/common/modules/imgproc/smooth.avx512_icl.cpp
rename to generated/common/modules/imgproc/smooth.avx512_icl.cpp
diff --git a/gen/common/modules/imgproc/smooth.sse2.cpp b/generated/common/modules/imgproc/smooth.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/smooth.sse2.cpp
rename to generated/common/modules/imgproc/smooth.sse2.cpp
diff --git a/gen/common/modules/imgproc/smooth.sse4_1.cpp b/generated/common/modules/imgproc/smooth.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/smooth.sse4_1.cpp
rename to generated/common/modules/imgproc/smooth.sse4_1.cpp
diff --git a/gen/common/modules/imgproc/sumpixels.avx2.cpp b/generated/common/modules/imgproc/sumpixels.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/sumpixels.avx2.cpp
rename to generated/common/modules/imgproc/sumpixels.avx2.cpp
diff --git a/gen/common/modules/imgproc/sumpixels.avx512_skx.cpp b/generated/common/modules/imgproc/sumpixels.avx512_skx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/sumpixels.avx512_skx.cpp
rename to generated/common/modules/imgproc/sumpixels.avx512_skx.cpp
diff --git a/gen/common/modules/imgproc/sumpixels.sse2.cpp b/generated/common/modules/imgproc/sumpixels.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/sumpixels.sse2.cpp
rename to generated/common/modules/imgproc/sumpixels.sse2.cpp
diff --git a/gen/common/modules/imgproc/undistort.avx2.cpp b/generated/common/modules/imgproc/undistort.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/undistort.avx2.cpp
rename to generated/common/modules/imgproc/undistort.avx2.cpp
diff --git a/gen/common/modules/imgproc/undistort.sse2.cpp b/generated/common/modules/imgproc/undistort.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/undistort.sse2.cpp
rename to generated/common/modules/imgproc/undistort.sse2.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.avx2.cpp b/generated/common/modules/imgproc/warp_kernels.avx2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.avx2.cpp
rename to generated/common/modules/imgproc/warp_kernels.avx2.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.lasx.cpp b/generated/common/modules/imgproc/warp_kernels.lasx.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.lasx.cpp
rename to generated/common/modules/imgproc/warp_kernels.lasx.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.neon.cpp b/generated/common/modules/imgproc/warp_kernels.neon.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.neon.cpp
rename to generated/common/modules/imgproc/warp_kernels.neon.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.neon_fp16.cpp b/generated/common/modules/imgproc/warp_kernels.neon_fp16.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.neon_fp16.cpp
rename to generated/common/modules/imgproc/warp_kernels.neon_fp16.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.rvv.cpp b/generated/common/modules/imgproc/warp_kernels.rvv.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.rvv.cpp
rename to generated/common/modules/imgproc/warp_kernels.rvv.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.sse2.cpp b/generated/common/modules/imgproc/warp_kernels.sse2.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.sse2.cpp
rename to generated/common/modules/imgproc/warp_kernels.sse2.cpp
diff --git a/gen/common/modules/imgproc/warp_kernels.sse4_1.cpp b/generated/common/modules/imgproc/warp_kernels.sse4_1.cpp
similarity index 100%
rename from gen/common/modules/imgproc/warp_kernels.sse4_1.cpp
rename to generated/common/modules/imgproc/warp_kernels.sse4_1.cpp
diff --git a/generated/common/opencv2/opencv_modules.hpp b/generated/common/opencv2/opencv_modules.hpp
new file mode 100644
index 0000000..b3fcc1a
--- /dev/null
+++ b/generated/common/opencv2/opencv_modules.hpp
@@ -0,0 +1,2 @@
+#pragma once
+#define HAVE_OPENCV_CORE
diff --git a/gen/common/synth/builtin_font_italic.h b/generated/common/synth/builtin_font_italic.h
similarity index 100%
rename from gen/common/synth/builtin_font_italic.h
rename to generated/common/synth/builtin_font_italic.h
diff --git a/gen/common/synth/builtin_font_sans.h b/generated/common/synth/builtin_font_sans.h
similarity index 100%
rename from gen/common/synth/builtin_font_sans.h
rename to generated/common/synth/builtin_font_sans.h
diff --git a/gen/common/synth/clsrc/opencl_kernels_core.cpp b/generated/common/synth/clsrc/opencl_kernels_core.cpp
similarity index 100%
rename from gen/common/synth/clsrc/opencl_kernels_core.cpp
rename to generated/common/synth/clsrc/opencl_kernels_core.cpp
diff --git a/gen/common/synth/clsrc/opencl_kernels_geometry.cpp b/generated/common/synth/clsrc/opencl_kernels_geometry.cpp
similarity index 100%
rename from gen/common/synth/clsrc/opencl_kernels_geometry.cpp
rename to generated/common/synth/clsrc/opencl_kernels_geometry.cpp
diff --git a/gen/common/synth/clsrc/opencl_kernels_imgproc.cpp b/generated/common/synth/clsrc/opencl_kernels_imgproc.cpp
similarity index 100%
rename from gen/common/synth/clsrc/opencl_kernels_imgproc.cpp
rename to generated/common/synth/clsrc/opencl_kernels_imgproc.cpp
diff --git a/gen/common/synth/opencl_kernels_core.hpp b/generated/common/synth/opencl_kernels_core.hpp
similarity index 100%
rename from gen/common/synth/opencl_kernels_core.hpp
rename to generated/common/synth/opencl_kernels_core.hpp
diff --git a/gen/common/synth/opencl_kernels_geometry.hpp b/generated/common/synth/opencl_kernels_geometry.hpp
similarity index 100%
rename from gen/common/synth/opencl_kernels_geometry.hpp
rename to generated/common/synth/opencl_kernels_geometry.hpp
diff --git a/gen/common/synth/opencl_kernels_imgproc.hpp b/generated/common/synth/opencl_kernels_imgproc.hpp
similarity index 100%
rename from gen/common/synth/opencl_kernels_imgproc.hpp
rename to generated/common/synth/opencl_kernels_imgproc.hpp
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
diff --git a/gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c b/generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
similarity index 100%
rename from gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
rename to generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
diff --git a/gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c b/generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
similarity index 100%
rename from gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
rename to generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/gen/linux/3rdparty/libjpeg-turbo/jconfig.h b/generated/linux/3rdparty/libjpeg-turbo/jconfig.h
similarity index 100%
rename from gen/linux/3rdparty/libjpeg-turbo/jconfig.h
rename to generated/linux/3rdparty/libjpeg-turbo/jconfig.h
diff --git a/gen/linux/3rdparty/libjpeg-turbo/jconfigint.h b/generated/linux/3rdparty/libjpeg-turbo/jconfigint.h
similarity index 100%
rename from gen/linux/3rdparty/libjpeg-turbo/jconfigint.h
rename to generated/linux/3rdparty/libjpeg-turbo/jconfigint.h
diff --git a/generated/linux/DNN_SOURCES.txt b/generated/linux/DNN_SOURCES.txt
new file mode 100644
index 0000000..43c7e66
--- /dev/null
+++ b/generated/linux/DNN_SOURCES.txt
@@ -0,0 +1,22 @@
+upstream/opencv/3rdparty/mlas/lib/*.cpp
+upstream/opencv/3rdparty/mlas/lib/x86_64/*.S
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/*.cc
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/*.cc
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/*.cc
+upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.cc
+upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.cc
+upstream/opencv/modules/dnn/misc/tensorflow/*.cc
+upstream/opencv/modules/dnn/src/*.cpp
+upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp
+upstream/opencv/modules/dnn/src/int8layers/*.cpp
+upstream/opencv/modules/dnn/src/layers/*.cpp
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/*.cpp
+upstream/opencv/modules/dnn/src/onnx/*.cpp
+upstream/opencv/modules/dnn/src/tensorflow/*.cpp
+upstream/opencv/modules/dnn/src/tflite/tflite_importer.cpp
+upstream/opencv/modules/dnn/src/tokenizer/*.cpp
+generated/common/modules/dnn/int8layers/{conv2_int8_kernels.avx2,layers_common.avx2,layers_common.avx512_skx}.cpp
+generated/common/modules/dnn/layers/{layers_common.avx,layers_common.avx2,layers_common.avx512_skx}.cpp
+generated/common/modules/dnn/layers/cpu_kernels/{activation_kernels.avx,activation_kernels.avx2,conv2_depthwise.avx,conv2_depthwise.avx2,conv2_kernels.avx,conv2_kernels.avx2,conv_block.avx,conv_block.avx2,conv_depthwise.avx,conv_depthwise.avx2,conv_winograd_f63.avx,conv_winograd_f63.avx2,fast_gemm_kernels.avx,fast_gemm_kernels.avx2,gridsample_kernels.avx,gridsample_kernels.avx2,nary_eltwise_kernels.avx,nary_eltwise_kernels.avx2,reduce2_kernels.avx,reduce2_kernels.avx2,transpose_kernels.avx,transpose_kernels.avx2}.cpp
+generated/common/mlas_hgemm_stub.cpp
+generated/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/generated/linux/INCLUDE_DIRS.txt b/generated/linux/INCLUDE_DIRS.txt
new file mode 100644
index 0000000..f4138f5
--- /dev/null
+++ b/generated/linux/INCLUDE_DIRS.txt
@@ -0,0 +1,13 @@
+generated/linux
+generated/common
+generated/linux/3rdparty/libjpeg-turbo
+generated/common/3rdparty/libjpeg-turbo
+generated/common/3rdparty/zlib
+generated/linux/modules/core
+generated/common/modules/core
+generated/linux/modules/imgproc
+generated/common/modules/imgproc
+generated/linux/modules/dnn
+generated/common/modules/dnn
+generated/common/modules/highgui
+generated/common/synth
diff --git a/gen/linux/cv_cpu_config.h b/generated/linux/cv_cpu_config.h
similarity index 100%
rename from gen/linux/cv_cpu_config.h
rename to generated/linux/cv_cpu_config.h
diff --git a/gen/linux/cvconfig.h b/generated/linux/cvconfig.h
similarity index 100%
rename from gen/linux/cvconfig.h
rename to generated/linux/cvconfig.h
diff --git a/gen/linux/modules/core/arithm.simd_declarations.hpp b/generated/linux/modules/core/arithm.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/arithm.simd_declarations.hpp
rename to generated/linux/modules/core/arithm.simd_declarations.hpp
diff --git a/gen/linux/modules/core/convert.simd_declarations.hpp b/generated/linux/modules/core/convert.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/convert.simd_declarations.hpp
rename to generated/linux/modules/core/convert.simd_declarations.hpp
diff --git a/gen/linux/modules/core/convert_scale.simd_declarations.hpp b/generated/linux/modules/core/convert_scale.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/convert_scale.simd_declarations.hpp
rename to generated/linux/modules/core/convert_scale.simd_declarations.hpp
diff --git a/gen/linux/modules/core/count_non_zero.simd_declarations.hpp b/generated/linux/modules/core/count_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/count_non_zero.simd_declarations.hpp
rename to generated/linux/modules/core/count_non_zero.simd_declarations.hpp
diff --git a/gen/linux/modules/core/has_non_zero.simd_declarations.hpp b/generated/linux/modules/core/has_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/has_non_zero.simd_declarations.hpp
rename to generated/linux/modules/core/has_non_zero.simd_declarations.hpp
diff --git a/gen/linux/modules/core/mathfuncs_core.simd_declarations.hpp b/generated/linux/modules/core/mathfuncs_core.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/mathfuncs_core.simd_declarations.hpp
rename to generated/linux/modules/core/mathfuncs_core.simd_declarations.hpp
diff --git a/gen/linux/modules/core/matmul.simd_declarations.hpp b/generated/linux/modules/core/matmul.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/matmul.simd_declarations.hpp
rename to generated/linux/modules/core/matmul.simd_declarations.hpp
diff --git a/gen/linux/modules/core/mean.simd_declarations.hpp b/generated/linux/modules/core/mean.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/mean.simd_declarations.hpp
rename to generated/linux/modules/core/mean.simd_declarations.hpp
diff --git a/gen/linux/modules/core/merge.simd_declarations.hpp b/generated/linux/modules/core/merge.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/merge.simd_declarations.hpp
rename to generated/linux/modules/core/merge.simd_declarations.hpp
diff --git a/gen/linux/modules/core/minmax.simd_declarations.hpp b/generated/linux/modules/core/minmax.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/minmax.simd_declarations.hpp
rename to generated/linux/modules/core/minmax.simd_declarations.hpp
diff --git a/gen/linux/modules/core/nan_mask.simd_declarations.hpp b/generated/linux/modules/core/nan_mask.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/nan_mask.simd_declarations.hpp
rename to generated/linux/modules/core/nan_mask.simd_declarations.hpp
diff --git a/gen/linux/modules/core/norm.simd_declarations.hpp b/generated/linux/modules/core/norm.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/norm.simd_declarations.hpp
rename to generated/linux/modules/core/norm.simd_declarations.hpp
diff --git a/gen/linux/modules/core/reduce.simd_declarations.hpp b/generated/linux/modules/core/reduce.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/reduce.simd_declarations.hpp
rename to generated/linux/modules/core/reduce.simd_declarations.hpp
diff --git a/gen/linux/modules/core/split.simd_declarations.hpp b/generated/linux/modules/core/split.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/split.simd_declarations.hpp
rename to generated/linux/modules/core/split.simd_declarations.hpp
diff --git a/gen/linux/modules/core/stat.simd_declarations.hpp b/generated/linux/modules/core/stat.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/stat.simd_declarations.hpp
rename to generated/linux/modules/core/stat.simd_declarations.hpp
diff --git a/gen/linux/modules/core/sum.simd_declarations.hpp b/generated/linux/modules/core/sum.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/sum.simd_declarations.hpp
rename to generated/linux/modules/core/sum.simd_declarations.hpp
diff --git a/gen/linux/modules/core/transpose.simd_declarations.hpp b/generated/linux/modules/core/transpose.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/core/transpose.simd_declarations.hpp
rename to generated/linux/modules/core/transpose.simd_declarations.hpp
diff --git a/gen/linux/modules/core/version_string.inc b/generated/linux/modules/core/version_string.inc
similarity index 100%
rename from gen/linux/modules/core/version_string.inc
rename to generated/linux/modules/core/version_string.inc
diff --git a/gen/linux/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp b/generated/linux/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
rename to generated/linux/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
diff --git a/gen/linux/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp b/generated/linux/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
rename to generated/linux/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
diff --git a/gen/linux/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp b/generated/linux/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
rename to generated/linux/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
diff --git a/gen/linux/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp b/generated/linux/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
rename to generated/linux/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/accum.simd_declarations.hpp b/generated/linux/modules/imgproc/accum.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/accum.simd_declarations.hpp
rename to generated/linux/modules/imgproc/accum.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/bilateral_filter.simd_declarations.hpp b/generated/linux/modules/imgproc/bilateral_filter.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/bilateral_filter.simd_declarations.hpp
rename to generated/linux/modules/imgproc/bilateral_filter.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/box_filter.simd_declarations.hpp b/generated/linux/modules/imgproc/box_filter.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/box_filter.simd_declarations.hpp
rename to generated/linux/modules/imgproc/box_filter.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/color_hsv.simd_declarations.hpp b/generated/linux/modules/imgproc/color_hsv.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/color_hsv.simd_declarations.hpp
rename to generated/linux/modules/imgproc/color_hsv.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/color_rgb.simd_declarations.hpp b/generated/linux/modules/imgproc/color_rgb.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/color_rgb.simd_declarations.hpp
rename to generated/linux/modules/imgproc/color_rgb.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/color_yuv.simd_declarations.hpp b/generated/linux/modules/imgproc/color_yuv.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/color_yuv.simd_declarations.hpp
rename to generated/linux/modules/imgproc/color_yuv.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/filter.simd_declarations.hpp b/generated/linux/modules/imgproc/filter.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/filter.simd_declarations.hpp
rename to generated/linux/modules/imgproc/filter.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/median_blur.simd_declarations.hpp b/generated/linux/modules/imgproc/median_blur.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/median_blur.simd_declarations.hpp
rename to generated/linux/modules/imgproc/median_blur.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/morph.simd_declarations.hpp b/generated/linux/modules/imgproc/morph.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/morph.simd_declarations.hpp
rename to generated/linux/modules/imgproc/morph.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/smooth.simd_declarations.hpp b/generated/linux/modules/imgproc/smooth.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/smooth.simd_declarations.hpp
rename to generated/linux/modules/imgproc/smooth.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/sumpixels.simd_declarations.hpp b/generated/linux/modules/imgproc/sumpixels.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/sumpixels.simd_declarations.hpp
rename to generated/linux/modules/imgproc/sumpixels.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/undistort.simd_declarations.hpp b/generated/linux/modules/imgproc/undistort.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/undistort.simd_declarations.hpp
rename to generated/linux/modules/imgproc/undistort.simd_declarations.hpp
diff --git a/gen/linux/modules/imgproc/warp_kernels.simd_declarations.hpp b/generated/linux/modules/imgproc/warp_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/linux/modules/imgproc/warp_kernels.simd_declarations.hpp
rename to generated/linux/modules/imgproc/warp_kernels.simd_declarations.hpp
diff --git a/gen/linux/opencv2/cvconfig.h b/generated/linux/opencv2/cvconfig.h
similarity index 100%
rename from gen/linux/opencv2/cvconfig.h
rename to generated/linux/opencv2/cvconfig.h
diff --git a/gen/linux/opencv_data_config.hpp b/generated/linux/opencv_data_config.hpp
similarity index 100%
rename from gen/linux/opencv_data_config.hpp
rename to generated/linux/opencv_data_config.hpp
diff --git a/gen/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp b/generated/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
similarity index 100%
rename from gen/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
rename to generated/linux/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/gen/macosx/3rdparty/libjpeg-turbo/jconfig.h b/generated/macosx/3rdparty/libjpeg-turbo/jconfig.h
similarity index 100%
rename from gen/macosx/3rdparty/libjpeg-turbo/jconfig.h
rename to generated/macosx/3rdparty/libjpeg-turbo/jconfig.h
diff --git a/gen/macosx/3rdparty/libjpeg-turbo/jconfigint.h b/generated/macosx/3rdparty/libjpeg-turbo/jconfigint.h
similarity index 100%
rename from gen/macosx/3rdparty/libjpeg-turbo/jconfigint.h
rename to generated/macosx/3rdparty/libjpeg-turbo/jconfigint.h
diff --git a/gen/macosx/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h b/generated/macosx/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h
similarity index 100%
rename from gen/macosx/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h
rename to generated/macosx/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h
diff --git a/generated/macosx/DNN_SOURCES.txt b/generated/macosx/DNN_SOURCES.txt
new file mode 100644
index 0000000..1ad20c5
--- /dev/null
+++ b/generated/macosx/DNN_SOURCES.txt
@@ -0,0 +1,22 @@
+upstream/opencv/3rdparty/mlas/lib/*.cpp
+upstream/opencv/3rdparty/mlas/lib/aarch64/*.S
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/*.cc
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/*.cc
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/*.cc
+upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.cc
+upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.cc
+upstream/opencv/modules/dnn/misc/tensorflow/*.cc
+upstream/opencv/modules/dnn/src/*.cpp
+upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp
+upstream/opencv/modules/dnn/src/int8layers/*.cpp
+upstream/opencv/modules/dnn/src/layers/*.cpp
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/*.cpp
+upstream/opencv/modules/dnn/src/onnx/*.cpp
+upstream/opencv/modules/dnn/src/tensorflow/*.cpp
+upstream/opencv/modules/dnn/src/tflite/tflite_importer.cpp
+upstream/opencv/modules/dnn/src/tokenizer/*.cpp
+generated/common/modules/dnn/int8layers/layers_common.neon.cpp
+generated/common/modules/dnn/layers/layers_common.neon.cpp
+generated/common/modules/dnn/layers/cpu_kernels/{activation_kernels.neon,conv2_depthwise.neon,conv2_kernels.neon,conv_block.neon,conv_block.neon_fp16,conv_winograd_f63.neon,fast_gemm_kernels.neon,gridsample_kernels.neon,nary_eltwise_kernels.neon,reduce2_kernels.neon,transpose_kernels.neon}.cpp
+generated/common/mlas_hgemm_stub.cpp
+generated/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/generated/macosx/INCLUDE_DIRS.txt b/generated/macosx/INCLUDE_DIRS.txt
new file mode 100644
index 0000000..c5b6425
--- /dev/null
+++ b/generated/macosx/INCLUDE_DIRS.txt
@@ -0,0 +1,14 @@
+generated/macosx
+generated/common
+generated/macosx/3rdparty/libjpeg-turbo
+generated/common/3rdparty/libjpeg-turbo
+generated/macosx/3rdparty/libjpeg-turbo/simd/arm
+generated/common/3rdparty/zlib
+generated/macosx/modules/core
+generated/common/modules/core
+generated/macosx/modules/imgproc
+generated/common/modules/imgproc
+generated/macosx/modules/dnn
+generated/common/modules/dnn
+generated/common/modules/highgui
+generated/common/synth
diff --git a/gen/macosx/cv_cpu_config.h b/generated/macosx/cv_cpu_config.h
similarity index 100%
rename from gen/macosx/cv_cpu_config.h
rename to generated/macosx/cv_cpu_config.h
diff --git a/gen/macosx/cvconfig.h b/generated/macosx/cvconfig.h
similarity index 100%
rename from gen/macosx/cvconfig.h
rename to generated/macosx/cvconfig.h
diff --git a/gen/macosx/modules/core/arithm.simd_declarations.hpp b/generated/macosx/modules/core/arithm.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/arithm.simd_declarations.hpp
rename to generated/macosx/modules/core/arithm.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/convert.simd_declarations.hpp b/generated/macosx/modules/core/convert.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/convert.simd_declarations.hpp
rename to generated/macosx/modules/core/convert.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/convert_scale.simd_declarations.hpp b/generated/macosx/modules/core/convert_scale.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/convert_scale.simd_declarations.hpp
rename to generated/macosx/modules/core/convert_scale.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/count_non_zero.simd_declarations.hpp b/generated/macosx/modules/core/count_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/count_non_zero.simd_declarations.hpp
rename to generated/macosx/modules/core/count_non_zero.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/has_non_zero.simd_declarations.hpp b/generated/macosx/modules/core/has_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/has_non_zero.simd_declarations.hpp
rename to generated/macosx/modules/core/has_non_zero.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/mathfuncs_core.simd_declarations.hpp b/generated/macosx/modules/core/mathfuncs_core.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/mathfuncs_core.simd_declarations.hpp
rename to generated/macosx/modules/core/mathfuncs_core.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/matmul.simd_declarations.hpp b/generated/macosx/modules/core/matmul.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/matmul.simd_declarations.hpp
rename to generated/macosx/modules/core/matmul.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/mean.simd_declarations.hpp b/generated/macosx/modules/core/mean.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/mean.simd_declarations.hpp
rename to generated/macosx/modules/core/mean.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/merge.simd_declarations.hpp b/generated/macosx/modules/core/merge.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/merge.simd_declarations.hpp
rename to generated/macosx/modules/core/merge.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/minmax.simd_declarations.hpp b/generated/macosx/modules/core/minmax.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/minmax.simd_declarations.hpp
rename to generated/macosx/modules/core/minmax.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/nan_mask.simd_declarations.hpp b/generated/macosx/modules/core/nan_mask.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/nan_mask.simd_declarations.hpp
rename to generated/macosx/modules/core/nan_mask.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/norm.simd_declarations.hpp b/generated/macosx/modules/core/norm.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/norm.simd_declarations.hpp
rename to generated/macosx/modules/core/norm.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/reduce.simd_declarations.hpp b/generated/macosx/modules/core/reduce.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/reduce.simd_declarations.hpp
rename to generated/macosx/modules/core/reduce.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/split.simd_declarations.hpp b/generated/macosx/modules/core/split.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/split.simd_declarations.hpp
rename to generated/macosx/modules/core/split.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/stat.simd_declarations.hpp b/generated/macosx/modules/core/stat.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/stat.simd_declarations.hpp
rename to generated/macosx/modules/core/stat.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/sum.simd_declarations.hpp b/generated/macosx/modules/core/sum.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/sum.simd_declarations.hpp
rename to generated/macosx/modules/core/sum.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/transpose.simd_declarations.hpp b/generated/macosx/modules/core/transpose.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/core/transpose.simd_declarations.hpp
rename to generated/macosx/modules/core/transpose.simd_declarations.hpp
diff --git a/gen/macosx/modules/core/version_string.inc b/generated/macosx/modules/core/version_string.inc
similarity index 100%
rename from gen/macosx/modules/core/version_string.inc
rename to generated/macosx/modules/core/version_string.inc
diff --git a/gen/macosx/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp b/generated/macosx/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
rename to generated/macosx/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
diff --git a/gen/macosx/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp b/generated/macosx/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
rename to generated/macosx/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
diff --git a/gen/macosx/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp b/generated/macosx/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
rename to generated/macosx/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
diff --git a/gen/macosx/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp b/generated/macosx/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
rename to generated/macosx/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/accum.simd_declarations.hpp b/generated/macosx/modules/imgproc/accum.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/accum.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/accum.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/bilateral_filter.simd_declarations.hpp b/generated/macosx/modules/imgproc/bilateral_filter.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/bilateral_filter.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/bilateral_filter.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/box_filter.simd_declarations.hpp b/generated/macosx/modules/imgproc/box_filter.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/box_filter.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/box_filter.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/color_hsv.simd_declarations.hpp b/generated/macosx/modules/imgproc/color_hsv.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/color_hsv.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/color_hsv.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/color_rgb.simd_declarations.hpp b/generated/macosx/modules/imgproc/color_rgb.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/color_rgb.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/color_rgb.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/color_yuv.simd_declarations.hpp b/generated/macosx/modules/imgproc/color_yuv.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/color_yuv.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/color_yuv.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/filter.simd_declarations.hpp b/generated/macosx/modules/imgproc/filter.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/filter.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/filter.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/median_blur.simd_declarations.hpp b/generated/macosx/modules/imgproc/median_blur.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/median_blur.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/median_blur.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/morph.simd_declarations.hpp b/generated/macosx/modules/imgproc/morph.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/morph.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/morph.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/smooth.simd_declarations.hpp b/generated/macosx/modules/imgproc/smooth.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/smooth.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/smooth.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/sumpixels.simd_declarations.hpp b/generated/macosx/modules/imgproc/sumpixels.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/sumpixels.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/sumpixels.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/undistort.simd_declarations.hpp b/generated/macosx/modules/imgproc/undistort.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/undistort.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/undistort.simd_declarations.hpp
diff --git a/gen/macosx/modules/imgproc/warp_kernels.simd_declarations.hpp b/generated/macosx/modules/imgproc/warp_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/macosx/modules/imgproc/warp_kernels.simd_declarations.hpp
rename to generated/macosx/modules/imgproc/warp_kernels.simd_declarations.hpp
diff --git a/gen/macosx/opencv2/cvconfig.h b/generated/macosx/opencv2/cvconfig.h
similarity index 100%
rename from gen/macosx/opencv2/cvconfig.h
rename to generated/macosx/opencv2/cvconfig.h
diff --git a/gen/macosx/opencv_data_config.hpp b/generated/macosx/opencv_data_config.hpp
similarity index 100%
rename from gen/macosx/opencv_data_config.hpp
rename to generated/macosx/opencv_data_config.hpp
diff --git a/gen/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp b/generated/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
similarity index 100%
rename from gen/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
rename to generated/macosx/tu/mlasgemm/mlasgemm_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/gen/windows/3rdparty/libjpeg-turbo/jconfig.h b/generated/windows/3rdparty/libjpeg-turbo/jconfig.h
similarity index 100%
rename from gen/windows/3rdparty/libjpeg-turbo/jconfig.h
rename to generated/windows/3rdparty/libjpeg-turbo/jconfig.h
diff --git a/gen/windows/3rdparty/libjpeg-turbo/jconfigint.h b/generated/windows/3rdparty/libjpeg-turbo/jconfigint.h
similarity index 100%
rename from gen/windows/3rdparty/libjpeg-turbo/jconfigint.h
rename to generated/windows/3rdparty/libjpeg-turbo/jconfigint.h
diff --git a/generated/windows/DNN_SOURCES.txt b/generated/windows/DNN_SOURCES.txt
new file mode 100644
index 0000000..5ce9b55
--- /dev/null
+++ b/generated/windows/DNN_SOURCES.txt
@@ -0,0 +1,277 @@
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc
+generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp
+generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp
+generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp
diff --git a/generated/windows/INCLUDE_DIRS.txt b/generated/windows/INCLUDE_DIRS.txt
new file mode 100644
index 0000000..a991141
--- /dev/null
+++ b/generated/windows/INCLUDE_DIRS.txt
@@ -0,0 +1,13 @@
+generated/windows
+generated/common
+generated/windows/3rdparty/libjpeg-turbo
+generated/common/3rdparty/libjpeg-turbo
+generated/common/3rdparty/zlib
+generated/windows/modules/core
+generated/common/modules/core
+generated/windows/modules/imgproc
+generated/common/modules/imgproc
+generated/windows/modules/dnn
+generated/common/modules/dnn
+generated/common/modules/highgui
+generated/common/synth
diff --git a/gen/windows/cv_cpu_config.h b/generated/windows/cv_cpu_config.h
similarity index 100%
rename from gen/windows/cv_cpu_config.h
rename to generated/windows/cv_cpu_config.h
diff --git a/gen/windows/cvconfig.h b/generated/windows/cvconfig.h
similarity index 100%
rename from gen/windows/cvconfig.h
rename to generated/windows/cvconfig.h
diff --git a/gen/windows/modules/core/arithm.simd_declarations.hpp b/generated/windows/modules/core/arithm.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/arithm.simd_declarations.hpp
rename to generated/windows/modules/core/arithm.simd_declarations.hpp
diff --git a/gen/windows/modules/core/convert.simd_declarations.hpp b/generated/windows/modules/core/convert.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/convert.simd_declarations.hpp
rename to generated/windows/modules/core/convert.simd_declarations.hpp
diff --git a/gen/windows/modules/core/convert_scale.simd_declarations.hpp b/generated/windows/modules/core/convert_scale.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/convert_scale.simd_declarations.hpp
rename to generated/windows/modules/core/convert_scale.simd_declarations.hpp
diff --git a/gen/windows/modules/core/count_non_zero.simd_declarations.hpp b/generated/windows/modules/core/count_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/count_non_zero.simd_declarations.hpp
rename to generated/windows/modules/core/count_non_zero.simd_declarations.hpp
diff --git a/gen/windows/modules/core/has_non_zero.simd_declarations.hpp b/generated/windows/modules/core/has_non_zero.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/has_non_zero.simd_declarations.hpp
rename to generated/windows/modules/core/has_non_zero.simd_declarations.hpp
diff --git a/gen/windows/modules/core/mathfuncs_core.simd_declarations.hpp b/generated/windows/modules/core/mathfuncs_core.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/mathfuncs_core.simd_declarations.hpp
rename to generated/windows/modules/core/mathfuncs_core.simd_declarations.hpp
diff --git a/gen/windows/modules/core/matmul.simd_declarations.hpp b/generated/windows/modules/core/matmul.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/matmul.simd_declarations.hpp
rename to generated/windows/modules/core/matmul.simd_declarations.hpp
diff --git a/gen/windows/modules/core/mean.simd_declarations.hpp b/generated/windows/modules/core/mean.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/mean.simd_declarations.hpp
rename to generated/windows/modules/core/mean.simd_declarations.hpp
diff --git a/gen/windows/modules/core/merge.simd_declarations.hpp b/generated/windows/modules/core/merge.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/merge.simd_declarations.hpp
rename to generated/windows/modules/core/merge.simd_declarations.hpp
diff --git a/gen/windows/modules/core/minmax.simd_declarations.hpp b/generated/windows/modules/core/minmax.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/minmax.simd_declarations.hpp
rename to generated/windows/modules/core/minmax.simd_declarations.hpp
diff --git a/gen/windows/modules/core/nan_mask.simd_declarations.hpp b/generated/windows/modules/core/nan_mask.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/nan_mask.simd_declarations.hpp
rename to generated/windows/modules/core/nan_mask.simd_declarations.hpp
diff --git a/gen/windows/modules/core/norm.simd_declarations.hpp b/generated/windows/modules/core/norm.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/norm.simd_declarations.hpp
rename to generated/windows/modules/core/norm.simd_declarations.hpp
diff --git a/gen/windows/modules/core/reduce.simd_declarations.hpp b/generated/windows/modules/core/reduce.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/reduce.simd_declarations.hpp
rename to generated/windows/modules/core/reduce.simd_declarations.hpp
diff --git a/gen/windows/modules/core/split.simd_declarations.hpp b/generated/windows/modules/core/split.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/split.simd_declarations.hpp
rename to generated/windows/modules/core/split.simd_declarations.hpp
diff --git a/gen/windows/modules/core/stat.simd_declarations.hpp b/generated/windows/modules/core/stat.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/stat.simd_declarations.hpp
rename to generated/windows/modules/core/stat.simd_declarations.hpp
diff --git a/gen/windows/modules/core/sum.simd_declarations.hpp b/generated/windows/modules/core/sum.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/sum.simd_declarations.hpp
rename to generated/windows/modules/core/sum.simd_declarations.hpp
diff --git a/gen/windows/modules/core/transpose.simd_declarations.hpp b/generated/windows/modules/core/transpose.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/core/transpose.simd_declarations.hpp
rename to generated/windows/modules/core/transpose.simd_declarations.hpp
diff --git a/gen/windows/modules/core/version_string.inc b/generated/windows/modules/core/version_string.inc
similarity index 100%
rename from gen/windows/modules/core/version_string.inc
rename to generated/windows/modules/core/version_string.inc
diff --git a/gen/windows/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp b/generated/windows/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
rename to generated/windows/modules/dnn/layers/cpu_kernels/activation_kernels.simd_declarations.hpp
diff --git a/gen/windows/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp b/generated/windows/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
rename to generated/windows/modules/dnn/layers/cpu_kernels/conv2_depthwise.simd_declarations.hpp
diff --git a/gen/windows/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp b/generated/windows/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
rename to generated/windows/modules/dnn/layers/cpu_kernels/conv2_kernels.simd_declarations.hpp
diff --git a/gen/windows/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp b/generated/windows/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
rename to generated/windows/modules/dnn/layers/cpu_kernels/conv_winograd_f63.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/accum.simd_declarations.hpp b/generated/windows/modules/imgproc/accum.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/accum.simd_declarations.hpp
rename to generated/windows/modules/imgproc/accum.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/bilateral_filter.simd_declarations.hpp b/generated/windows/modules/imgproc/bilateral_filter.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/bilateral_filter.simd_declarations.hpp
rename to generated/windows/modules/imgproc/bilateral_filter.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/box_filter.simd_declarations.hpp b/generated/windows/modules/imgproc/box_filter.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/box_filter.simd_declarations.hpp
rename to generated/windows/modules/imgproc/box_filter.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/color_hsv.simd_declarations.hpp b/generated/windows/modules/imgproc/color_hsv.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/color_hsv.simd_declarations.hpp
rename to generated/windows/modules/imgproc/color_hsv.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/color_rgb.simd_declarations.hpp b/generated/windows/modules/imgproc/color_rgb.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/color_rgb.simd_declarations.hpp
rename to generated/windows/modules/imgproc/color_rgb.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/color_yuv.simd_declarations.hpp b/generated/windows/modules/imgproc/color_yuv.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/color_yuv.simd_declarations.hpp
rename to generated/windows/modules/imgproc/color_yuv.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/filter.simd_declarations.hpp b/generated/windows/modules/imgproc/filter.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/filter.simd_declarations.hpp
rename to generated/windows/modules/imgproc/filter.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/median_blur.simd_declarations.hpp b/generated/windows/modules/imgproc/median_blur.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/median_blur.simd_declarations.hpp
rename to generated/windows/modules/imgproc/median_blur.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/morph.simd_declarations.hpp b/generated/windows/modules/imgproc/morph.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/morph.simd_declarations.hpp
rename to generated/windows/modules/imgproc/morph.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/smooth.simd_declarations.hpp b/generated/windows/modules/imgproc/smooth.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/smooth.simd_declarations.hpp
rename to generated/windows/modules/imgproc/smooth.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/sumpixels.simd_declarations.hpp b/generated/windows/modules/imgproc/sumpixels.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/sumpixels.simd_declarations.hpp
rename to generated/windows/modules/imgproc/sumpixels.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/undistort.simd_declarations.hpp b/generated/windows/modules/imgproc/undistort.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/undistort.simd_declarations.hpp
rename to generated/windows/modules/imgproc/undistort.simd_declarations.hpp
diff --git a/gen/windows/modules/imgproc/warp_kernels.simd_declarations.hpp b/generated/windows/modules/imgproc/warp_kernels.simd_declarations.hpp
similarity index 100%
rename from gen/windows/modules/imgproc/warp_kernels.simd_declarations.hpp
rename to generated/windows/modules/imgproc/warp_kernels.simd_declarations.hpp
diff --git a/gen/windows/opencv2/cvconfig.h b/generated/windows/opencv2/cvconfig.h
similarity index 100%
rename from gen/windows/opencv2/cvconfig.h
rename to generated/windows/opencv2/cvconfig.h
diff --git a/gen/windows/opencv_data_config.hpp b/generated/windows/opencv_data_config.hpp
similarity index 100%
rename from gen/windows/opencv_data_config.hpp
rename to generated/windows/opencv_data_config.hpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_arithm.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_arithm.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_arithm.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_arithm.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_arithm.sse4_1.cpp b/generated/windows/tu/w/core/gen_common_modules_core_arithm.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_arithm.sse4_1.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_arithm.sse4_1.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_convert.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_convert.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_convert.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_convert.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_convert_scale.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_convert_scale.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_convert_scale.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_convert_scale.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_count_non_zero.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_count_non_zero.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_count_non_zero.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_count_non_zero.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_has_non_zero.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_has_non_zero.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_has_non_zero.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_has_non_zero.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx.cpp b/generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_matmul.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_matmul.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_matmul.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_matmul.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_matmul.avx512_skx.cpp b/generated/windows/tu/w/core/gen_common_modules_core_matmul.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_matmul.avx512_skx.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_matmul.avx512_skx.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_matmul.sse4_1.cpp b/generated/windows/tu/w/core/gen_common_modules_core_matmul.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_matmul.sse4_1.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_matmul.sse4_1.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_mean.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_mean.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_mean.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_mean.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_merge.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_merge.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_merge.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_merge.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_minmax.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_minmax.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_minmax.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_minmax.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_minmax.sse4_1.cpp b/generated/windows/tu/w/core/gen_common_modules_core_minmax.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_minmax.sse4_1.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_minmax.sse4_1.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_nan_mask.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_nan_mask.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_nan_mask.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_nan_mask.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_norm.avx.cpp b/generated/windows/tu/w/core/gen_common_modules_core_norm.avx.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_norm.avx.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_norm.avx.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_norm.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_norm.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_norm.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_norm.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_norm.sse4_1.cpp b/generated/windows/tu/w/core/gen_common_modules_core_norm.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_norm.sse4_1.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_norm.sse4_1.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_reduce.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_reduce.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_reduce.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_reduce.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_split.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_split.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_split.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_split.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_stat.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_stat.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_stat.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_stat.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_stat.sse4_2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_stat.sse4_2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_stat.sse4_2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_stat.sse4_2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_sum.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_sum.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_sum.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_sum.avx2.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_transpose.avx.cpp b/generated/windows/tu/w/core/gen_common_modules_core_transpose.avx.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_transpose.avx.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_transpose.avx.cpp
diff --git a/gen/windows/tu/w/core/gen_common_modules_core_transpose.avx2.cpp b/generated/windows/tu/w/core/gen_common_modules_core_transpose.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/core/gen_common_modules_core_transpose.avx2.cpp
rename to generated/windows/tu/w/core/gen_common_modules_core_transpose.avx2.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_algorithm.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_algorithm.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_algorithm.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_algorithm.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_async.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_async.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_async.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_async.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_batch_distance.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_batch_distance.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_batch_distance.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_batch_distance.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_bindings_utils.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_bindings_utils.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_bindings_utils.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_bindings_utils.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_buffer_area.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_buffer_area.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_buffer_area.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_buffer_area.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_channels.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_channels.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_channels.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_channels.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_check.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_check.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_check.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_check.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_command_line_parser.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_command_line_parser.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_command_line_parser.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_command_line_parser.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_conjugate_gradient.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_conjugate_gradient.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_conjugate_gradient.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_conjugate_gradient.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert_scale.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert_scale.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert_scale.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert_scale.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_copy.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_copy.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_copy.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_copy.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_count_non_zero.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_count_non_zero.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_count_non_zero.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_count_non_zero.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat_nd.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat_nd.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat_nd.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat_nd.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_host_mem.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_host_mem.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_host_mem.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_host_mem.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_info.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_info.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_info.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_info.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_stream.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_stream.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_stream.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_stream.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_directx.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_directx.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_directx.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_directx.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_downhill_simplex.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_downhill_simplex.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_downhill_simplex.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_downhill_simplex.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_dxt.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_dxt.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_dxt.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_dxt.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_gl_core_3_1.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_gl_core_3_1.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_gl_core_3_1.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_gl_core_3_1.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_glob.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_glob.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_glob.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_glob.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_hal_internal.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_hal_internal.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_hal_internal.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_hal_internal.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_has_non_zero.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_has_non_zero.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_has_non_zero.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_has_non_zero.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_kmeans.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_kmeans.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_kmeans.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_kmeans.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lapack.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lapack.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lapack.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lapack.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lda.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lda.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lda.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lda.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_logger.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_logger.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_logger.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_logger.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lpsolver.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lpsolver.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lpsolver.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lpsolver.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lut.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lut.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lut.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lut.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs_core.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs_core.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs_core.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs_core.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matmul.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matmul.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matmul.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matmul.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_decomp.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_decomp.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_decomp.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_decomp.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_expressions.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_expressions.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_expressions.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_expressions.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_iterator.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_iterator.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_iterator.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_iterator.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_operations.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_operations.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_operations.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_operations.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_sparse.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_sparse.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_sparse.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_sparse.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_transform.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_transform.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_transform.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_transform.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_wrap.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_wrap.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_wrap.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_wrap.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mean.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mean.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mean.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mean.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_merge.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_merge.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_merge.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_merge.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_minmax.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_minmax.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_minmax.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_minmax.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_nan_mask.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_nan_mask.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_nan_mask.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_nan_mask.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_norm.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_norm.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_norm.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_norm.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_ocl.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_ocl.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_ocl.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_ocl.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clblas.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clblas.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clblas.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clblas.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clfft.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clfft.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clfft.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clfft.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_core.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_core.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_core.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_core.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opengl.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opengl.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opengl.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opengl.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_out.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_out.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_out.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_out.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_impl.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_impl.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_impl.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_impl.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_openmp.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_openmp.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_openmp.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_openmp.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_tbb.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_tbb.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_tbb.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_tbb.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_pca.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_pca.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_pca.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_pca.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_base64_encoding.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_base64_encoding.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_base64_encoding.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_base64_encoding.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_json.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_json.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_json.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_json.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_types.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_types.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_types.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_types.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_xml.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_xml.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_xml.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_xml.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_yml.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_yml.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_yml.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_yml.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_rand.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_rand.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_rand.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_rand.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_reduce.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_reduce.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_reduce.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_reduce.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_softfloat.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_softfloat.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_softfloat.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_softfloat.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_split.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_split.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_split.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_split.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stat.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stat.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stat.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stat.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stl.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stl.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stl.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stl.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_sum.dispatch.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_sum.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_sum.dispatch.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_sum.dispatch.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_system.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_system.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_system.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_system.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_tables.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_tables.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_tables.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_tables.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_trace.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_trace.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_trace.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_trace.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_types.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_types.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_types.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_types.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_umatrix.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_umatrix.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_umatrix.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_umatrix.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_datafile.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_datafile.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_datafile.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_datafile.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_filesystem.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_filesystem.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_filesystem.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_filesystem.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagconfigparser.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagconfigparser.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagconfigparser.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagconfigparser.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagmanager.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagmanager.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagmanager.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagmanager.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_samples.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_samples.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_samples.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_samples.cpp
diff --git a/gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_va_intel.cpp b/generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_va_intel.cpp
similarity index 100%
rename from gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_va_intel.cpp
rename to generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_va_intel.cpp
diff --git a/gen/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_flann.cpp b/generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_flann.cpp
similarity index 100%
rename from gen/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_flann.cpp
rename to generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_flann.cpp
diff --git a/gen/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_miniflann.cpp b/generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_miniflann.cpp
similarity index 100%
rename from gen/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_miniflann.cpp
rename to generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_miniflann.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ap3p.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ap3p.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ap3p.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ap3p.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_approx.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_approx.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_approx.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_approx.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_calibration_base.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_calibration_base.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_calibration_base.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_calibration_base.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_convhull.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_convhull.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_convhull.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_convhull.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_epnp.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_epnp.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_epnp.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_epnp.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fisheye.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fisheye.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fisheye.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fisheye.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_five-point.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_five-point.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_five-point.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_five-point.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fundam.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fundam.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fundam.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fundam.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_geometry.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_geometry.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_geometry.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_geometry.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_homography_decomp.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_homography_decomp.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_homography_decomp.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_homography_decomp.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_intersection.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_intersection.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_intersection.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_intersection.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ippe.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ippe.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ippe.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ippe.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_levmarq.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_levmarq.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_levmarq.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_levmarq.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_linefit.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_linefit.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_linefit.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_linefit.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_main.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_main.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_main.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_main.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_matchcontours.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_matchcontours.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_matchcontours.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_matchcontours.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_convex_polygon.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_convex_polygon.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_convex_polygon.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_convex_polygon.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_triangle.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_triangle.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_triangle.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_triangle.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_moments.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_moments.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_moments.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_moments.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_mst.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_mst.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_mst.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_mst.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_p3p.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_p3p.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_p3p.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_p3p.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_pinhole.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_pinhole.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_pinhole.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_pinhole.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_polynom_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_polynom_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_polynom_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_polynom_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_normal_estimation.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_normal_estimation.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_normal_estimation.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_normal_estimation.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_ptcloud_utils.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_ptcloud_utils.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_ptcloud_utils.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_ptcloud_utils.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_region_growing_3d.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_region_growing_3d.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_region_growing_3d.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_region_growing_3d.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sac_segmentation.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sac_segmentation.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sac_segmentation.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sac_segmentation.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sampling.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sampling.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sampling.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sampling.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptsetreg.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptsetreg.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptsetreg.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptsetreg.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rho.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rho.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rho.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rho.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rotcalipers.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rotcalipers.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rotcalipers.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rotcalipers.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_shapedescr.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_shapedescr.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_shapedescr.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_shapedescr.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_solvepnp.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_solvepnp.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_solvepnp.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_solvepnp.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_sqpnp.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_sqpnp.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_sqpnp.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_sqpnp.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_subdivision2d.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_subdivision2d.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_subdivision2d.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_subdivision2d.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_triangulate.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_triangulate.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_triangulate.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_triangulate.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_bundle.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_bundle.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_bundle.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_bundle.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_degeneracy.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_degeneracy.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_degeneracy.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_degeneracy.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_dls_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_dls_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_dls_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_dls_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_essential_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_essential_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_essential_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_essential_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_estimator.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_estimator.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_estimator.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_estimator.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_fundamental_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_fundamental_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_fundamental_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_fundamental_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_gamma_values.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_gamma_values.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_gamma_values.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_gamma_values.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_homography_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_homography_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_homography_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_homography_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_local_optimization.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_local_optimization.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_local_optimization.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_local_optimization.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_plane_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_plane_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_plane_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_plane_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_pnp_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_pnp_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_pnp_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_pnp_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_quality.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_quality.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_quality.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_quality.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_ransac_solvers.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_ransac_solvers.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_ransac_solvers.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_ransac_solvers.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sampler.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sampler.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sampler.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sampler.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sphere_solver.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sphere_solver.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sphere_solver.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sphere_solver.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_termination.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_termination.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_termination.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_termination.cpp
diff --git a/gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_utils.cpp b/generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_utils.cpp
similarity index 100%
rename from gen/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_utils.cpp
rename to generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_utils.cpp
diff --git a/gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_backend.cpp b/generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_backend.cpp
similarity index 100%
rename from gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_backend.cpp
rename to generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_backend.cpp
diff --git a/gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_roiSelector.cpp b/generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_roiSelector.cpp
similarity index 100%
rename from gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_roiSelector.cpp
rename to generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_roiSelector.cpp
diff --git a/gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_window.cpp b/generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_window.cpp
similarity index 100%
rename from gen/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_window.cpp
rename to generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_window.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_bitstrm.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_bitstrm.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_bitstrm.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_bitstrm.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_exif.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_exif.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_exif.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_exif.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_avif.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_avif.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_avif.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_avif.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_base.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_base.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_base.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_base.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_bmp.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_bmp.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_bmp.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_bmp.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_exr.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_exr.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_exr.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_exr.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdal.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdal.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdal.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdal.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdcm.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdcm.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdcm.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdcm.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gif.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gif.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gif.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gif.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_hdr.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_hdr.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_hdr.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_hdr.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000_openjpeg.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000_openjpeg.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000_openjpeg.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000_openjpeg.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpegxl.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpegxl.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpegxl.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpegxl.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pam.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pam.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pam.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pam.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pfm.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pfm.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pfm.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pfm.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_png.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_png.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_png.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_png.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pxm.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pxm.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pxm.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pxm.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_spng.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_spng.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_spng.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_spng.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_sunras.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_sunras.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_sunras.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_sunras.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_tiff.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_tiff.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_tiff.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_tiff.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_webp.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_webp.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_webp.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_webp.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_loadsave.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_loadsave.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_loadsave.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_loadsave.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_rgbe.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_rgbe.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_rgbe.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_rgbe.cpp
diff --git a/gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_utils.cpp b/generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_utils.cpp
similarity index 100%
rename from gen/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_utils.cpp
rename to generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_utils.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx512_skx.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx512_skx.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx512_skx.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx512_skx.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx512_skx.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx512_skx.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx512_skx.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx512_skx.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx512_skx.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx512_skx.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx512_skx.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx512_skx.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_undistort.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_undistort.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_undistort.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_undistort.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.avx2.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.avx2.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.sse4_1.cpp b/generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_bilateral_filter.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_bilateral_filter.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_bilateral_filter.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_bilateral_filter.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_blend.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_blend.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_blend.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_blend.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_box_filter.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_box_filter.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_box_filter.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_box_filter.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_canny.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_canny.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_canny.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_canny.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_clahe.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_clahe.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_clahe.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_clahe.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_hsv.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_hsv.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_hsv.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_hsv.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_lab.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_lab.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_lab.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_lab.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_rgb.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_rgb.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_rgb.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_rgb.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_yuv.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_yuv.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_yuv.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_yuv.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_colormap.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_colormap.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_colormap.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_colormap.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_connectedcomponents.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_connectedcomponents.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_connectedcomponents.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_connectedcomponents.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_approx.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_approx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_approx.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_approx.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_common.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_common.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_common.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_common.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_link.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_link.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_link.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_link.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_new.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_new.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_new.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_new.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_truco.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_truco.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_truco.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_truco.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.avx.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.avx.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.avx.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.avx.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_cornersubpix.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_cornersubpix.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_cornersubpix.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_cornersubpix.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_demosaicing.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_demosaicing.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_demosaicing.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_demosaicing.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_deriv.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_deriv.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_deriv.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_deriv.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_distransform.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_distransform.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_distransform.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_distransform.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing_text.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing_text.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing_text.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing_text.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_emd_new.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_emd_new.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_emd_new.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_emd_new.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_filter.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_filter.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_filter.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_filter.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_fisheye.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_fisheye.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_fisheye.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_fisheye.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_floodfill.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_floodfill.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_floodfill.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_floodfill.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_gabor.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_gabor.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_gabor.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_gabor.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_generalized_hough.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_generalized_hough.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_generalized_hough.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_generalized_hough.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_grabcut.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_grabcut.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_grabcut.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_grabcut.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_histogram.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_histogram.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_histogram.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_histogram.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_hough.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_hough.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_hough.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_hough.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.avx2.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.avx2.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.sse4_1.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_lsd.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_lsd.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_lsd.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_lsd.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_main.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_main.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_main.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_main.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_median_blur.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_median_blur.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_median_blur.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_median_blur.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_morph.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_morph.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_morph.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_morph.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr_iterative.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr_iterative.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr_iterative.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr_iterative.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_pyramids.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_pyramids.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_pyramids.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_pyramids.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.avx2.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.avx2.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.avx2.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.avx2.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.sse4_1.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.sse4_1.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.sse4_1.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.sse4_1.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_samplers.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_samplers.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_samplers.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_samplers.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_segmentation.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_segmentation.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_segmentation.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_segmentation.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_smooth.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_smooth.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_smooth.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_smooth.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_spatialgradient.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_spatialgradient.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_spatialgradient.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_spatialgradient.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stackblur.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stackblur.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stackblur.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stackblur.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stb_truetype.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stb_truetype.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stb_truetype.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stb_truetype.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_sumpixels.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_sumpixels.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_sumpixels.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_sumpixels.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_tables.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_tables.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_tables.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_tables.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_templmatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_templmatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_templmatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_templmatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_thresh.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_thresh.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_thresh.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_thresh.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_undistort.dispatch.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_undistort.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_undistort.dispatch.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_undistort.dispatch.cpp
diff --git a/gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_utils.cpp b/generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_utils.cpp
similarity index 100%
rename from gen/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_utils.cpp
rename to generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_utils.cpp
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
diff --git a/gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jutils.c b/generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
similarity index 100%
rename from gen/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
rename to generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
diff --git a/gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jutils.c b/generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
similarity index 100%
rename from gen/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
rename to generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jaricom.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jaricom.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jaricom.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jaricom.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapimin.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapimin.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapimin.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapimin.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapistd.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapistd.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapistd.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapistd.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcarith.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcarith.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcarith.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcarith.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccoefct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccoefct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccoefct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccoefct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccolor.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccolor.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccolor.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccolor.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdctmgr.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdctmgr.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdctmgr.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdctmgr.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdiffct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdiffct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdiffct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdiffct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jchuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jchuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jchuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jchuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcicc.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcicc.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcicc.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcicc.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcinit.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcinit.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcinit.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcinit.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclhuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclhuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclhuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclhuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclossls.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclossls.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclossls.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclossls.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmainct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmainct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmainct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmainct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmarker.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmarker.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmarker.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmarker.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmaster.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmaster.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmaster.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmaster.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcomapi.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcomapi.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcomapi.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcomapi.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcparam.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcparam.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcparam.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcparam.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcphuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcphuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcphuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcphuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcprepct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcprepct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcprepct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcprepct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcsample.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcsample.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcsample.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcsample.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jctrans.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jctrans.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jctrans.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jctrans.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapimin.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapimin.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapimin.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapimin.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapistd.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapistd.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapistd.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapistd.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdarith.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdarith.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdarith.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdarith.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatadst.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatadst.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatadst.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatadst.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatasrc.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatasrc.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatasrc.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatasrc.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcoefct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcoefct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcoefct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcoefct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcolor.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcolor.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcolor.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcolor.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddctmgr.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddctmgr.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddctmgr.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddctmgr.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddiffct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddiffct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddiffct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddiffct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdhuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdhuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdhuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdhuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdicc.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdicc.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdicc.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdicc.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdinput.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdinput.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdinput.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdinput.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlhuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlhuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlhuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlhuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlossls.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlossls.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlossls.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlossls.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmainct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmainct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmainct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmainct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmarker.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmarker.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmarker.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmarker.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmaster.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmaster.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmaster.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmaster.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmerge.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmerge.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmerge.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmerge.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdphuff.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdphuff.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdphuff.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdphuff.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdpostct.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdpostct.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdpostct.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdpostct.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdsample.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdsample.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdsample.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdsample.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdtrans.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdtrans.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdtrans.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdtrans.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jerror.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jerror.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jerror.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jerror.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctflt.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctflt.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctflt.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctflt.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctfst.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctfst.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctfst.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctfst.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctint.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctint.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctint.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctint.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctflt.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctflt.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctflt.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctflt.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctfst.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctfst.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctfst.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctfst.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctint.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctint.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctint.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctint.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctred.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctred.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctred.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctred.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemmgr.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemmgr.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemmgr.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemmgr.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemnobs.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemnobs.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemnobs.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemnobs.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jpeg_nbits.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jpeg_nbits.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jpeg_nbits.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jpeg_nbits.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant1.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant1.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant1.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant1.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant2.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant2.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant2.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant2.c
diff --git a/gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jutils.c b/generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jutils.c
similarity index 100%
rename from gen/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jutils.c
rename to generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_filter_sse2_intrinsics.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_filter_sse2_intrinsics.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_filter_sse2_intrinsics.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_filter_sse2_intrinsics.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_intel_init.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_intel_init.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_intel_init.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_intel_init.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_png.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_png.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_png.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_png.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngerror.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngerror.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngerror.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngerror.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngget.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngget.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngget.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngget.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngmem.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngmem.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngmem.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngmem.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngpread.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngpread.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngpread.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngpread.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngread.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngread.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngread.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngread.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrio.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrio.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrio.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrio.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrtran.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrtran.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrtran.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrtran.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrutil.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrutil.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrutil.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrutil.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngset.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngset.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngset.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngset.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngtrans.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngtrans.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngtrans.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngtrans.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwio.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwio.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwio.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwio.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwrite.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwrite.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwrite.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwrite.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwtran.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwtran.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwtran.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwtran.c
diff --git a/gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwutil.c b/generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwutil.c
similarity index 100%
rename from gen/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwutil.c
rename to generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwutil.c
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_static.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_static.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_static.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_static.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_ffmpeg.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_ffmpeg.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_ffmpeg.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_ffmpeg.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_images.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_images.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_images.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_images.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_decoder.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_decoder.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_decoder.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_decoder.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_encoder.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_encoder.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_encoder.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_encoder.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_container_avi.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_container_avi.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_container_avi.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_container_avi.cpp
diff --git a/gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_videoio_registry.cpp b/generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_videoio_registry.cpp
similarity index 100%
rename from gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_videoio_registry.cpp
rename to generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_videoio_registry.cpp
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_adler32.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_adler32.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_adler32.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_adler32.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_compress.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_compress.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_compress.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_compress.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_crc32.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_crc32.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_crc32.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_crc32.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_deflate.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_deflate.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_deflate.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_deflate.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzclose.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzclose.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzclose.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzclose.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzlib.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzlib.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzlib.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzlib.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzread.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzread.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzread.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzread.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzwrite.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzwrite.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzwrite.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzwrite.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_infback.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_infback.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_infback.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_infback.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inffast.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inffast.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inffast.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inffast.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inflate.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inflate.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inflate.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inflate.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inftrees.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inftrees.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inftrees.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inftrees.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_trees.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_trees.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_trees.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_trees.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_uncompr.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_uncompr.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_uncompr.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_uncompr.c
diff --git a/gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_zutil.c b/generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_zutil.c
similarity index 100%
rename from gen/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_zutil.c
rename to generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_zutil.c
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_conv2_int8_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_int8layers_layers_common.avx512_skx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_activation_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_depthwise.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv2_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_block.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_depthwise.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_conv_winograd_f63.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_fast_gemm_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_gridsample_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_nary_eltwise_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_reduce2_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_cpu_kernels_transpose_kernels.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp b/generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp
rename to generated/windows/tu/wdnn/dnn/gen_common_modules_dnn_layers_layers_common.avx512_skx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_caffe_opencv-caffe.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_onnx_opencv-onnx.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_attr_value.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_function.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_graph.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_op_def.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_tensor_shape.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_types.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_misc_tensorflow_versions.pb.cc
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_caffe_caffe_io.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_debug_utils.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_params.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_read.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_dnn_utils.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_block_layout.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_buffer_allocator.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_args.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_const_fold.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_attention.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_basic.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_matmul_to_gemm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_qdq.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_reshape_transpose.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_scale_softmax.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_shared_gemm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_fusion_transpose_matmul.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_graph_simplifier.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_ie_ngraph.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_init.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_batch_norm_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_conv2_int8_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_convolution_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_elementwise_layers.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise2_int8_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_eltwise_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_fully_connected_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_layers_rvp052.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_matmul_int8_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pool2_int8_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_pooling_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_quantization_utils.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_scale_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_int8layers_softmax_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_kv_cache_manager.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layer_factory.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_accum_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_affinegrid_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_arg_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_attention_onnxai_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_avgpool_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_batch_norm_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_bitshift_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_blank_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cast_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_centercroppad_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_clip_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_concat_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_const_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_constantofshape_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_common.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_conv2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convolution_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_convtranspose_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_correlation_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_activation_kernels.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_deconv.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_depthwise.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv2_kernels.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_depthwise.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_conv_winograd_f63.dispatch.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_convolution.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_attn.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_gemm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_fast_norm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_gemm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_mlas_threading.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cpu_kernels_softmax.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_crop_and_resize_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_cumsum_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_deconvolution_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_depth_space_ops_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dequantizelinear_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_det_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_detection_output_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_dft_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_einsum_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_elementwise_layers.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eltwise_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_expand_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_eyelike_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flatten_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_flow_warp_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_fully_connected_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gatherND.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_elements_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gather_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gemm_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gridsample_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_group_norm_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_gru_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_hardmax.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_if_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_instance_norm_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_inf_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_is_nan_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layer_norm2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_layers_common.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_loop_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_lrn_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_matmul_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_max_unpooling_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_maxpool_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_mvn_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nary_eltwise_layers.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nll_loss_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonmaxsuppression_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_nonzero_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_normalize_bbox_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_implemented_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_not_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_onehot_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pad2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_padding_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_permute_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_pooling_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_prior_box_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_proposal_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_quantlizelinear_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_randomnormallike_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_range_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent2_layers.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_recurrent_layers.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reduce_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_region_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reorg_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_reshape_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_resize_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rms_norm.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_roialign_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_rotary_embedding_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scale_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatterND_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_scatter_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_sdpa_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shape_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_shuffle_channel_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_size_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_slice_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_cross_entropy_loss_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_softmax_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_split_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_squeeze_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_tile_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk2_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_topk_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transform_layout_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_transpose_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_trilu_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unique_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_unsqueeze_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_layers_windows_layer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_legacy_backend.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_model.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_cann.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_backend.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_impl_fuse.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_net_openvino.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_nms.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_graph_simplifier.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_onnx_onnx_importer2.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cann.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_cuda.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_inf_engine.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_timvx.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_vkcom.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_op_webnn.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_registry.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_graph_simplifier.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_importer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tensorflow_tf_io.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tflite_tflite_importer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_core_bpe.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_tokenizer.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode-data.cpp
diff --git a/gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp b/generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp
similarity index 100%
rename from gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp
rename to generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_tokenizer_unicode.cpp
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_any_lite.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arena.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_arenastring.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor.pb.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_descriptor_database.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_dynamic_message.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_extension_set_heavy.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_enum_util.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_reflection.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_generated_message_util.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_implicit_weak_message.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_coded_stream.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_io_win32.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_strtod.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_tokenizer.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_io_zero_copy_stream_impl_lite.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_map_field.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_message_lite.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_parse_context.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_reflection_ops.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_field.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_repeated_ptr_field.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_bytestream.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_common.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_int128.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_status.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringpiece.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_stringprintf.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_structurally_valid.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_strutil.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_stubs_substitute.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_text_format.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_unknown_field_set.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format.cc
diff --git a/gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc b/generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc
similarity index 100%
rename from gen/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc
rename to generated/windows/tu/wdnn/protobuf/third_party_opencv-5.0.0_3rdparty_protobuf_src_google_protobuf_wire_format_lite.cc
diff --git a/include/opencv-m/macros.hpp b/include/opencv-m/macros.hpp
deleted file mode 100644
index 684f406..0000000
--- a/include/opencv-m/macros.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-// opencv-m/macros.hpp — optional side header for OpenCV's macro surface.
-//
-// Modules cannot export macros. Everything with linkage is re-exported by the
-// opencv.* modules; this textual header covers the rest: CV_Assert / CV_Error
-// / CV_DbgAssert, the CV_8UC(n)-style *function-like* type macros, version
-// macros, and the global-namespace inline helpers (cvRound, cvFloor, …).
-//
-// IMPORTANT: include this header BEFORE any `import opencv.*;` in the same
-// translation unit (include-after-import is ill-formed for headers that also
-// declare entities attached to the global module — same rule as ffmpeg-m's
-// macros.h).
-#pragma once
-
-#include <opencv2/core/base.hpp>
-#include <opencv2/core/check.hpp>
-#include <opencv2/core/cvdef.h>
-#include <opencv2/core/version.hpp>
diff --git a/mcpp.toml b/mcpp.toml
index cc04b05..5bd56c8 100644
--- a/mcpp.toml
+++ b/mcpp.toml
@@ -1,1502 +1,773 @@
-# The namespace names whose library this is, not who packaged it; the version
-# says which upstream you are getting. `mcpplibs` is mcpp's DEFAULT namespace
-# (kDefaultNamespace), not an answer to "whose library" — OpenCV is opencv's,
-# and this repository adds the C++23 module layer plus the vendored build. And
-# `0.0.10` said nothing about the OpenCV inside; the description right below has
-# been carrying that answer all along.
-#
-# Rule and full migration table: mcpp-index#163.
+# Generated by tools/generate_build.py; edit port/config inputs.
+
 [package]
-namespace   = "opencv"
-name        = "opencv"
-version     = "5.0.0"
-description = "OpenCV 5.0.0 vendored + C++23 module layer — import opencv.cv; (API and habits unchanged, just no headers). Single repo: full source build carried by this manifest, frozen per-OS config snapshots in gen/, no compat.opencv dependency."
-license     = "MIT"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Single-repo build (ported from mcpp-index pkgs/c/compat.opencv.lua @8692bb26,
-# see .agents/docs/2026-07-21-vendor-single-repo-plan.md):
-#   third_party/opencv-5.0.0/  pinned upstream source (zero patches)
-#   gen/common, gen/<os>/      frozen config snapshots as real files
-#   build.mcpp                 per-OS include dirs + per-OS dnn sources
-#                              (gen/<os>/DNN_SOURCES.txt) + unifont embed
-# The per-glob flag tables scope __OPENCV_BUILD-family flags to third_party/**
-# and gen/** TUs — src/*.cppm module-layer TUs never see them.
-#
-# Since mcpp 0.0.102 the per-glob tables are OS-conditional
-# ([target.'cfg(...)'.build.flags], mcpp-community/mcpp#258): entries shared
-# by the linux+macosx snapshots live in cfg(unix), x86_64 dispatch + .asm in
-# cfg(linux), the neon TUs in cfg(macos), and the windows stub-path tables in
-# cfg(windows). An entry whose predicate does not match the resolved target
-# never enters the glob table, so no OS sees another OS's globs and no build
-# emits structural dead-glob warnings. The windows TUs remain one-line
-# include stubs under gen/windows/tu/w*/ (stable per-TU path identity);
-# dropping the stub layer entirely is a separate, larger change.
-# ─────────────────────────────────────────────────────────────────────────────
+namespace = "mcpplibs.mwrap"
+name = "opencv"
+version = "5.0.0"
+description = "OpenCV 5.0.0 public C++ APIs through optional mwrap modules"
+license = "Apache-2.0"
+authors = ["mcpp-community"]
+repo = "https://github.com/mcpplibs/opencv-m"
+
+[package.metadata]
+
+[package.metadata.mwrap]
+upstream-version = "5.0.0"
+wrapper-revision = 0
 
 [build]
-# Module-layer surface (opencv.cv umbrella + per-module interfaces). dnn.cppm
-# is NOT listed here on purpose: it needs <opencv2/dnn.hpp> compiled in, so the
-# dnn feature adds it and import opencv.dnn; fails (correctly) without it.
-# The OpenCV library TUs are per-OS -> [target.'cfg(<os>)'.build].sources.
-sources = [
-    "src/opencv.cppm",
-    "src/cv.cppm",
-    "src/core.cppm",
-    "src/imgproc.cppm",
-    "src/imgcodecs.cppm",
-    "src/videoio.cppm",
-    "src/highgui.cppm",
-    "src/flann.cppm",
-    "src/geometry.cppm",
-]
-# Public include dirs (propagate to consumers): the module layer's include/,
-# gen/common (opencv2/opencv_modules.hpp — the ONE consumer-visible generated
-# header) and the vendored OpenCV trees. The per-OS gen/<os> snapshot dirs are
-# PRIVATE and emitted by build.mcpp (gen/<os>/INCLUDE_DIRS.txt).
-include_dirs = [
-        "include",
-        "gen/common",
-        "third_party/opencv-5.0.0",
-        "third_party/opencv-5.0.0/3rdparty/dlpack/include",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64",
-        "third_party/opencv-5.0.0/3rdparty/zlib",
-        "third_party/opencv-5.0.0/modules/core/include",
-        "third_party/opencv-5.0.0/modules/flann/include",
-        "third_party/opencv-5.0.0/modules/geometry/include",
-        "third_party/opencv-5.0.0/modules/imgproc/include",
-        "third_party/opencv-5.0.0/3rdparty/mlas/inc",
-        "third_party/opencv-5.0.0/3rdparty/mlas/lib",
-        "third_party/opencv-5.0.0/modules/dnn/include",
-        "third_party/opencv-5.0.0/modules/dnn/misc/caffe",
-        "third_party/opencv-5.0.0/modules/dnn/misc/tensorflow",
-        "third_party/opencv-5.0.0/modules/dnn/misc/onnx",
-        "third_party/opencv-5.0.0/modules/dnn/misc/tflite",
-        "third_party/opencv-5.0.0/3rdparty/flatbuffers/include",
-        "third_party/opencv-5.0.0/3rdparty/protobuf/src",
-        "third_party/opencv-5.0.0/3rdparty/libpng",
-        "third_party/opencv-5.0.0/modules/imgcodecs/include",
-        "third_party/opencv-5.0.0/modules/videoio/include",
-        "third_party/opencv-5.0.0/modules/highgui/include",
-    ]
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Per-glob flag tables, one cfg section per OS (mcpp#258, needs mcpp >= 0.0.102).
-# An entry whose predicate does not match the resolved target never enters the
-# glob table, so no OS sees another OS's globs — zero structural dead-glob
-# warnings on any platform.
-#
-# cfg(unix) = the entries identical in the linux+macosx snapshots (grep-verified
-# per-name; HAVE_GETAUXVAL is read only under __ppc64__, dead on both targets).
-# ─────────────────────────────────────────────────────────────────────────────
-
-[[target.'cfg(unix)'.build.flags]]
+jobs = 6
+sources = ["src/opencv.cppm", "src/core.cppm", "src/detail/core.cppm", "src/detail/matx.cppm", "src/macros.cppm"]
+include_dirs = ["port/include", "generated/common", "upstream/opencv", "upstream/opencv/3rdparty/dlpack/include", "upstream/opencv/3rdparty/libjpeg-turbo/src", "upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm", "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64", "upstream/opencv/3rdparty/zlib", "upstream/opencv/modules/core/include", "upstream/opencv/modules/flann/include", "upstream/opencv/modules/geometry/include", "upstream/opencv/modules/imgproc/include", "upstream/opencv/3rdparty/mlas/inc", "upstream/opencv/3rdparty/mlas/lib", "upstream/opencv/modules/dnn/include", "upstream/opencv/modules/dnn/misc/caffe", "upstream/opencv/modules/dnn/misc/tensorflow", "upstream/opencv/modules/dnn/misc/onnx", "upstream/opencv/modules/dnn/misc/tflite", "upstream/opencv/3rdparty/flatbuffers/include", "upstream/opencv/3rdparty/protobuf/src", "upstream/opencv/3rdparty/libpng", "upstream/opencv/modules/imgcodecs/include", "upstream/opencv/modules/videoio/include", "upstream/opencv/modules/highgui/include", "upstream/opencv/modules/calib/include", "upstream/opencv/modules/features/include", "upstream/opencv/modules/objdetect/include", "upstream/opencv/modules/photo/include", "upstream/opencv/modules/ptcloud/include", "upstream/opencv/modules/stereo/include", "upstream/opencv/modules/stitching/include", "upstream/opencv/modules/video/include"]
+defines = ["Z_PREFIX"]
+
+[target]
+
+[target."cfg(unix)"]
+
+[target."cfg(unix)".build]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/core/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "HAVE_UNISTD_H=1",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["HAVE_STDARG_H=1", "HAVE_UNISTD_H=1", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/flann/**"
-defines = [
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/geometry/**"
-defines = [
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/highgui/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["ENABLE_PLUGINS", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/imgcodecs/**"
-defines = [
-    "HAVE_IMGCODEC_HDR",
-    "HAVE_IMGCODEC_PFM",
-    "HAVE_IMGCODEC_PXM",
-    "HAVE_IMGCODEC_SUNRASTER",
-    "HAVE_STDARG_H=1",
-    "HAVE_UNISTD_H=1",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["HAVE_IMGCODEC_HDR", "HAVE_IMGCODEC_PFM", "HAVE_IMGCODEC_PXM", "HAVE_IMGCODEC_SUNRASTER", "HAVE_STDARG_H=1", "HAVE_UNISTD_H=1", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/imgproc/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "HAVE_UNISTD_H=1",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["HAVE_STDARG_H=1", "HAVE_UNISTD_H=1", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/3rdparty/libjpeg-turbo/**"
-defines = [
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-]
+defines = ["NDEBUG", "NO_GETENV", "NO_PUTENV"]
 
-[[target.'cfg(unix)'.build.flags]]
+[[target."cfg(unix)".build.flags]]
 glob = "**/tu/jpeg12/**"
-defines = [
-    "BITS_IN_JSAMPLE=12",
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["BITS_IN_JSAMPLE=12", "NDEBUG", "NO_GETENV", "NO_PUTENV"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/tu/jpeg16/**"
-defines = [
-    "BITS_IN_JSAMPLE=16",
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["BITS_IN_JSAMPLE=16", "NDEBUG", "NO_GETENV", "NO_PUTENV"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/3rdparty/libpng/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "HAVE_UNISTD_H=1",
-    "NDEBUG",
-]
+defines = ["HAVE_STDARG_H=1", "HAVE_UNISTD_H=1", "NDEBUG"]
 
-[[target.'cfg(unix)'.build.flags]]
+[[target."cfg(unix)".build.flags]]
 glob = "**/modules/videoio/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "HAVE_FFMPEG",
-    "HAVE_FFMPEG_LIBAVDEVICE",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(unix)'.build.flags]]
+defines = ["ENABLE_PLUGINS", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/3rdparty/zlib/**"
+defines = ["HAVE_STDARG_H=1", "HAVE_UNISTD_H=1", "NDEBUG"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "upstream/opencv/modules/core/src/alloc.cpp"
+defines = ["HAVE_POSIX_MEMALIGN=1"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "upstream/opencv/modules/core/src/parallel/parallel.cpp"
+defines = ["PARALLEL_ENABLE_PLUGINS=1"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "upstream/opencv/modules/core/src/system.cpp"
+defines = ["HAVE_GETAUXVAL=1"]
+
+[[target."cfg(unix)".build.flags]]
 glob = "**/3rdparty/zlib/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "HAVE_UNISTD_H=1",
-    "NDEBUG",
-]
-
-[[target.'cfg(unix)'.build.flags]]
-glob = "third_party/opencv-5.0.0/modules/core/src/alloc.cpp"
-defines = [
-    "HAVE_POSIX_MEMALIGN=1",
-]
-
-[[target.'cfg(unix)'.build.flags]]
-glob = "third_party/opencv-5.0.0/modules/core/src/parallel/parallel.cpp"
-defines = [
-    "PARALLEL_ENABLE_PLUGINS=1",
-]
-
-[[target.'cfg(unix)'.build.flags]]
-glob = "third_party/opencv-5.0.0/modules/core/src/system.cpp"
-defines = [
-    "HAVE_GETAUXVAL=1",
-]
-
-[target.'cfg(linux)'.build]
-# -msse3 is intentionally NOT here: it is OpenCV's x86_64 baseline and the
-# library TUs need it, but as a non-default target feature it would tag every
-# module-interface BMI (src/*.cppm) and make opencv.*.pcm unloadable by a
-# baseline consumer TU (clang -Wmodule-file-config-mismatch). It is applied to
-# the library TUs only via the per-glob `flags` below, keeping the BMIs at
-# baseline. (linux CI uses gcc, which does not enforce this, but a linux/clang
-# consumer would hit it exactly as windows/clang did.)
-cflags   = [
-    "-w",
-    "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
-    "-DPNG_INTEL_SSE_OPT=1",
-    "-DHAVE_CAMV4L2",
-    "-DHAVE_MALLOC_H=1",
-    "-DHAVE_MEMALIGN=1",
-    "-DHAVE_FLATBUFFERS=1",
-]
-cxxflags = [
-    "-w",
-    "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
-    "-DPNG_INTEL_SSE_OPT=1",
-    "-DHAVE_CAMV4L2",
-    "-DHAVE_MALLOC_H=1",
-    "-DHAVE_MEMALIGN=1",
-    "-DHAVE_FLATBUFFERS=1",
-]
-ldflags  = [
-    "-lpthread",
-    "-ldl",
-]
-sources  = [
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/{jaricom,jcapimin,jcapistd,jcarith,jccoefct,jccolor,jcdctmgr,jcdiffct,jchuff,jcicc,jcinit,jclhuff,jclossls,jcmainct,jcmarker,jcmaster,jcomapi,jcparam,jcphuff,jcprepct,jcsample,jctrans,jdapimin,jdapistd,jdarith,jdatadst,jdatasrc,jdcoefct,jdcolor,jddctmgr,jddiffct,jdhuff,jdicc,jdinput,jdlhuff,jdlossls,jdmainct,jdmarker,jdmaster,jdmerge,jdphuff,jdpostct,jdsample,jdtrans,jerror,jfdctflt,jfdctfst,jfdctint,jidctflt,jidctfst,jidctint,jidctred,jmemmgr,jmemnobs,jpeg_nbits,jquant1,jquant2,jutils}.c",
-        "third_party/opencv-5.0.0/3rdparty/libpng/*.c",
-        "third_party/opencv-5.0.0/3rdparty/libpng/intel/*.c",
-        "third_party/opencv-5.0.0/3rdparty/zlib/*.c",
-        "third_party/opencv-5.0.0/modules/core/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/opencl/runtime/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/parallel/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/utils/*.cpp",
-        "third_party/opencv-5.0.0/modules/flann/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/ptcloud/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/usac/*.cpp",
-        "third_party/opencv-5.0.0/modules/highgui/src/{backend,roiSelector,window}.cpp",
-        "third_party/opencv-5.0.0/modules/imgcodecs/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/imgproc/src/{accum,accum.dispatch,bilateral_filter.dispatch,blend,box_filter.dispatch,canny,clahe,color,color_hsv.dispatch,color_lab,color_rgb.dispatch,color_yuv.dispatch,colormap,connectedcomponents,contours_approx,contours_common,contours_link,contours_new,contours_truco,corner,corner.avx,cornersubpix,demosaicing,deriv,distransform,drawing,drawing_text,emd_new,filter.dispatch,fisheye,floodfill,gabor,generalized_hough,grabcut,histogram,hough,imgwarp,imgwarp.avx2,imgwarp.sse4_1,lsd,main,median_blur.dispatch,morph.dispatch,phasecorr,phasecorr_iterative,pyramids,resize,resize.avx2,resize.sse4_1,samplers,segmentation,smooth.dispatch,spatialgradient,stackblur,stb_truetype,sumpixels.dispatch,tables,templmatch,thresh,undistort.dispatch,utils}.cpp",
-        "third_party/opencv-5.0.0/modules/videoio/src/{backend_plugin,backend_static,cap,cap_ffmpeg,cap_images,cap_mjpeg_decoder,cap_mjpeg_encoder,cap_v4l,container_avi,videoio_registry}.cpp",
-        "gen/common/modules/core/{arithm.avx2,arithm.sse4_1,convert.avx2,convert_scale.avx2,count_non_zero.avx2,has_non_zero.avx2,mathfuncs_core.avx,mathfuncs_core.avx2,matmul.avx2,matmul.avx512_skx,matmul.sse4_1,mean.avx2,merge.avx2,minmax.avx2,minmax.sse4_1,nan_mask.avx2,norm.avx,norm.avx2,norm.sse4_1,reduce.avx2,split.avx2,stat.avx2,stat.sse4_2,sum.avx2,transpose.avx,transpose.avx2}.cpp",
-        "gen/common/modules/imgproc/{accum.avx,accum.avx2,accum.sse4_1,bilateral_filter.avx2,bilateral_filter.avx512_skx,box_filter.avx2,box_filter.avx512_skx,box_filter.sse4_1,color_hsv.avx2,color_hsv.sse4_1,color_rgb.avx2,color_rgb.sse4_1,color_yuv.avx2,color_yuv.sse4_1,filter.avx2,filter.sse4_1,median_blur.avx2,median_blur.avx512_skx,median_blur.sse4_1,morph.avx2,morph.sse4_1,smooth.avx2,smooth.sse4_1,sumpixels.avx2,sumpixels.avx512_skx,undistort.avx2,warp_kernels.avx2,warp_kernels.sse4_1}.cpp",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c",
-    ]
-# x86_64 dispatch TUs + nasm .asm — linux is the only x86_64 leg; the macosx
-# snapshot is arm64 (neon TUs below) and windows keys these on stub paths.
-
-[[target.'cfg(linux)'.build.flags]]
-glob = "third_party/opencv-5.0.0/**/*.asm"
-defines = [
-    "ELF",
-    "NO_GETENV",
-    "NO_PUTENV",
-    "PIC",
-    "__CET__",
-    "__x86_64__",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cflags = ["-fvisibility=hidden"]
+cxxflags = ["-fvisibility=hidden"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/3rdparty/libpng/**"
+cflags = ["-fvisibility=hidden"]
+cxxflags = ["-fvisibility=hidden"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/3rdparty/libjpeg-turbo/**"
+cflags = ["-fvisibility=hidden"]
+cxxflags = ["-fvisibility=hidden"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/tu/jpeg12/**"
+cflags = ["-fvisibility=hidden"]
+cxxflags = ["-fvisibility=hidden"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/tu/jpeg16/**"
+cflags = ["-fvisibility=hidden"]
+cxxflags = ["-fvisibility=hidden"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/calib/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/features/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/objdetect/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/photo/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/ptcloud/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/stereo/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/stitching/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(unix)".build.flags]]
+glob = "**/modules/video/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[target."cfg(linux)"]
+
+[target."cfg(linux)".build]
+cflags = ["-w", "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long", "-DPNG_INTEL_SSE_OPT=1", "-DHAVE_MALLOC_H=1", "-DHAVE_MEMALIGN=1", "-DHAVE_FLATBUFFERS=1"]
+cxxflags = ["-w", "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long", "-DPNG_INTEL_SSE_OPT=1", "-DHAVE_MALLOC_H=1", "-DHAVE_MEMALIGN=1", "-DHAVE_FLATBUFFERS=1"]
+ldflags = ["-lpthread", "-ldl"]
+
+[[target."cfg(linux)".build.flags]]
+glob = "upstream/opencv/**/*.asm"
+defines = ["ELF", "NO_GETENV", "NO_PUTENV", "PIC", "__CET__", "__x86_64__"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/core/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/core/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/core/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/core/**/*.sse4_1.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-]
-defines = [
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_1",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1"]
+defines = ["CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_1"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/core/**/*.sse4_2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-]
-defines = [
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_2",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2"]
+defines = ["CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_2"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/imgproc/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/imgproc/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/imgproc/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
-
-[[target.'cfg(linux)'.build.flags]]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
+
+[[target."cfg(linux)".build.flags]]
 glob = "**/modules/imgproc/**/*.sse4_1.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-]
-defines = [
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_1",
-]
-
-# SSE3 baseline for the library TUs only (see the cflags note above): the
-# vendored OpenCV/3rdparty sources and the gen/ per-module + libjpeg TUs, never
-# the src/*.cppm module interfaces — so opencv.*.pcm stays baseline-loadable.
-[[target.'cfg(linux)'.build.flags]]
-glob = "third_party/opencv-5.0.0/**"
+cxxflags = ["-mssse3", "-msse4.1"]
+defines = ["CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_1"]
+
+[[target."cfg(linux)".build.flags]]
+glob = "upstream/opencv/**"
 cflags = ["-msse3"]
 cxxflags = ["-msse3"]
 
-[[target.'cfg(linux)'.build.flags]]
-glob = "gen/**"
+[[target."cfg(linux)".build.flags]]
+glob = "generated/**"
 cflags = ["-msse3"]
 cxxflags = ["-msse3"]
 
-[target.'cfg(macos)'.build]
-cflags   = [
-    "-w",
-    "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int",
-    "-DHAVE_STDARG_H=1",
-    "-DHAVE_UNISTD_H=1",
-    "-DNEON_INTRINSICS",
-    "-DPNG_ARM_NEON_OPT=2",
-]
-cxxflags = [
-    "-w",
-    "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int",
-    "-DHAVE_STDARG_H=1",
-    "-DHAVE_UNISTD_H=1",
-    "-DNEON_INTRINSICS",
-    "-DPNG_ARM_NEON_OPT=2",
-]
-ldflags  = [
-    "-lpthread",
-    "-ldl",
-]
-sources  = [
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/{jccolor-neon,jcgray-neon,jcphuff-neon,jcsample-neon,jdcolor-neon,jdmerge-neon,jdsample-neon,jfdctfst-neon,jfdctint-neon,jidctfst-neon,jidctint-neon,jidctred-neon,jquanti-neon}.c",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/{jchuff-neon,jsimd}.c",
-        "third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/{jaricom,jcapimin,jcapistd,jcarith,jccoefct,jccolor,jcdctmgr,jcdiffct,jchuff,jcicc,jcinit,jclhuff,jclossls,jcmainct,jcmarker,jcmaster,jcomapi,jcparam,jcphuff,jcprepct,jcsample,jctrans,jdapimin,jdapistd,jdarith,jdatadst,jdatasrc,jdcoefct,jdcolor,jddctmgr,jddiffct,jdhuff,jdicc,jdinput,jdlhuff,jdlossls,jdmainct,jdmarker,jdmaster,jdmerge,jdphuff,jdpostct,jdsample,jdtrans,jerror,jfdctflt,jfdctfst,jfdctint,jidctflt,jidctfst,jidctint,jidctred,jmemmgr,jmemnobs,jpeg_nbits,jquant1,jquant2,jutils}.c",
-        "third_party/opencv-5.0.0/3rdparty/libpng/*.c",
-        "third_party/opencv-5.0.0/3rdparty/libpng/arm/filter_neon.S",
-        "third_party/opencv-5.0.0/3rdparty/libpng/arm/*.c",
-        "third_party/opencv-5.0.0/3rdparty/zlib/*.c",
-        "third_party/opencv-5.0.0/modules/core/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/opencl/runtime/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/parallel/*.cpp",
-        "third_party/opencv-5.0.0/modules/core/src/utils/*.cpp",
-        "third_party/opencv-5.0.0/modules/flann/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/ptcloud/*.cpp",
-        "third_party/opencv-5.0.0/modules/geometry/src/usac/*.cpp",
-        "third_party/opencv-5.0.0/modules/highgui/src/{backend,roiSelector,window}.cpp",
-        "third_party/opencv-5.0.0/modules/imgcodecs/src/*.cpp",
-        "third_party/opencv-5.0.0/modules/imgproc/src/{accum,accum.dispatch,bilateral_filter.dispatch,blend,box_filter.dispatch,canny,clahe,color,color_hsv.dispatch,color_lab,color_rgb.dispatch,color_yuv.dispatch,colormap,connectedcomponents,contours_approx,contours_common,contours_link,contours_new,contours_truco,corner,cornersubpix,demosaicing,deriv,distransform,drawing,drawing_text,emd_new,filter.dispatch,fisheye,floodfill,gabor,generalized_hough,grabcut,histogram,hough,imgwarp,lsd,main,median_blur.dispatch,morph.dispatch,phasecorr,phasecorr_iterative,pyramids,resize,samplers,segmentation,smooth.dispatch,spatialgradient,stackblur,stb_truetype,sumpixels.dispatch,tables,templmatch,thresh,undistort.dispatch,utils}.cpp",
-        "third_party/opencv-5.0.0/modules/videoio/src/{backend_plugin,backend_static,cap,cap_ffmpeg,cap_images,cap_mjpeg_decoder,cap_mjpeg_encoder,container_avi,videoio_registry}.cpp",
-        "gen/common/modules/core/transpose.neon.cpp",
-        "gen/common/modules/imgproc/warp_kernels.neon.cpp",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c",
-        "gen/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c",
-        "gen/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c",
-    ]
-
-[[target.'cfg(macos)'.build.flags]]
-glob = "gen/common/modules/core/transpose.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
-
-[[target.'cfg(macos)'.build.flags]]
-glob = "gen/common/modules/imgproc/warp_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
-
-[target.'cfg(windows)'.build]
-cflags   = [
-    "-w",
-]
-cxxflags = [
-    "-w",
-]
-ldflags  = [
-    "-lole32",
-]
-sources  = [
-        "gen/windows/tu/w/**/*.{c,cc,cpp,asm}",
-    ]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "NDEBUG",
-    "OPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/flann/**"
-defines = [
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/geometry/**"
-defines = [
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/highgui/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgcodecs/**"
-defines = [
-    "HAVE_IMGCODEC_HDR",
-    "HAVE_IMGCODEC_PFM",
-    "HAVE_IMGCODEC_PXM",
-    "HAVE_IMGCODEC_SUNRASTER",
-    "HAVE_STDARG_H=1",
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgproc/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/libjpeg-turbo/**"
-defines = [
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/jpeg12/**"
-defines = [
-    "BITS_IN_JSAMPLE=12",
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/jpeg16/**"
-defines = [
-    "BITS_IN_JSAMPLE=16",
-    "NDEBUG",
-    "NO_GETENV",
-    "NO_PUTENV",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/libpng/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "NDEBUG",
-    "PNG_INTEL_SSE_OPT=1",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/videoio/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "HAVE_FFMPEG",
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/zlib/**"
-defines = [
-    "HAVE_STDARG_H=1",
-    "NDEBUG",
-    "NO_FSEEKO",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**/*.sse4_1.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-]
-defines = [
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_1",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/**/*.sse4_2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-]
-defines = [
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_2",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgproc/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgproc/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgproc/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/imgproc/**/*.sse4_1.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-]
-defines = [
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=SSE4_1",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp"
-defines = [
-    "HAVE_MALLOC_H=1",
-    "HAVE_WIN32_ALIGNED_MALLOC=1",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp"
-defines = [
-    "DEBUG_POSTFIX=d",
-    "PARALLEL_ENABLE_PLUGINS=1",
-]
-
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp"
-defines = [
-    "DEBUG_POSTFIX=d",
-]
-
-# -msse3 is OpenCV's x86_64 baseline and the library TUs need it, but it must
-# NOT reach the module-interface units (src/*.cppm). A BMI compiled with a
-# non-default target feature cannot be loaded by an importer that lacks it
-# (clang -Wmodule-file-config-mismatch), and a consumer compiles its importing
-# TU at plain baseline — so a +sse3 opencv.cv.pcm is unloadable downstream even
-# though the package's own tests (which also carry -msse3) accept it. Keying
-# -msse3 to the library TUs only (gen/windows/tu/** covers the w/ and dnn wdnn/
-# stub namespaces) keeps opencv.*.pcm at baseline — loadable by any importer —
-# while the .cpp still get SSE3 codegen.
-[[target.'cfg(windows)'.build.flags]]
-glob = "gen/windows/tu/**"
+[[target."cfg(linux)".build.flags]]
+glob = "**/features/src/fast.avx2.cpp"
+cxxflags = ["-mavx2"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[target."cfg(macos)"]
+
+[target."cfg(macos)".build]
+cflags = ["-w", "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int", "-DHAVE_STDARG_H=1", "-DHAVE_UNISTD_H=1", "-DNEON_INTRINSICS", "-DPNG_ARM_NEON_OPT=2"]
+cxxflags = ["-w", "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int", "-DHAVE_STDARG_H=1", "-DHAVE_UNISTD_H=1", "-DNEON_INTRINSICS", "-DPNG_ARM_NEON_OPT=2"]
+ldflags = ["-lpthread", "-ldl"]
+
+[[target."cfg(macos)".build.flags]]
+glob = "generated/common/modules/core/transpose.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
+
+[[target."cfg(macos)".build.flags]]
+glob = "generated/common/modules/imgproc/warp_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
+
+[target."cfg(windows)"]
+
+[target."cfg(windows)".build]
+cflags = ["-w"]
+cxxflags = ["-w"]
+ldflags = ["-lole32"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**"
+defines = ["HAVE_STDARG_H=1", "NDEBUG", "OPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/flann/**"
+defines = ["NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/geometry/**"
+defines = ["NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/highgui/**"
+defines = ["ENABLE_PLUGINS", "NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgcodecs/**"
+defines = ["HAVE_IMGCODEC_HDR", "HAVE_IMGCODEC_PFM", "HAVE_IMGCODEC_PXM", "HAVE_IMGCODEC_SUNRASTER", "HAVE_STDARG_H=1", "NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgproc/**"
+defines = ["HAVE_STDARG_H=1", "NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/libjpeg-turbo/**"
+defines = ["NDEBUG", "NO_GETENV", "NO_PUTENV", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/jpeg12/**"
+defines = ["BITS_IN_JSAMPLE=12", "NDEBUG", "NO_GETENV", "NO_PUTENV", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/jpeg16/**"
+defines = ["BITS_IN_JSAMPLE=16", "NDEBUG", "NO_GETENV", "NO_PUTENV", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/libpng/**"
+defines = ["HAVE_STDARG_H=1", "NDEBUG", "PNG_INTEL_SSE_OPT=1", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/videoio/**"
+defines = ["ENABLE_PLUGINS", "NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/zlib/**"
+defines = ["HAVE_STDARG_H=1", "NDEBUG", "NO_FSEEKO", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**/*.avx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**/*.avx2.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**/*.avx512_skx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**/*.sse4_1.cpp"
+cxxflags = ["-mssse3", "-msse4.1"]
+defines = ["CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_1"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/**/*.sse4_2.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2"]
+defines = ["CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_2"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgproc/**/*.avx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgproc/**/*.avx2.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgproc/**/*.avx512_skx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/imgproc/**/*.sse4_1.cpp"
+cxxflags = ["-mssse3", "-msse4.1"]
+defines = ["CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=SSE4_1"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp"
+defines = ["HAVE_MALLOC_H=1", "HAVE_WIN32_ALIGNED_MALLOC=1"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp"
+defines = ["DEBUG_POSTFIX=d", "PARALLEL_ENABLE_PLUGINS=1"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp"
+defines = ["DEBUG_POSTFIX=d"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "generated/windows/tu/**"
 cflags = ["-msse3"]
 cxxflags = ["-msse3"]
 
+[[target."cfg(windows)".build.flags]]
+glob = "**/features/src/fast.avx2.cpp"
+cxxflags = ["-mavx2"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_DISPATCH_MODE=AVX2"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/calib/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/features/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/objdetect/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/photo/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/ptcloud/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/stereo/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/stitching/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[[target."cfg(windows)".build.flags]]
+glob = "**/modules/video/**"
+defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+
+[target.x86_64-linux-musl]
+linkage = "static"
+
+[target."cfg(all(os = \"linux\", env = \"gnu\", arch = \"x86_64\"))"]
+
+[target."cfg(all(os = \"linux\", env = \"gnu\", arch = \"x86_64\"))".feature-xlings]
+
+[target."cfg(all(os = \"linux\", env = \"gnu\", arch = \"x86_64\"))".feature-xlings.highgui-native]
+"xim:gtk3" = "3.24.43"
+"xim:libXtst" = "1.2.5"
+
+[target."cfg(all(os = \"linux\", env = \"gnu\", arch = \"x86_64\"))".feature-xlings.highgui-gtk3]
+"xim:gtk3" = "3.24.43"
+"xim:libXtst" = "1.2.5"
+
+[target."cfg(all(arch = \"x86_64\", any(os = \"linux\", os = \"windows\")))"]
+
+[target."cfg(all(arch = \"x86_64\", any(os = \"linux\", os = \"windows\")))".feature-xlings]
+
+[target."cfg(all(arch = \"x86_64\", any(os = \"linux\", os = \"windows\")))".feature-xlings.videoio-ffmpeg]
+"xim:nasm" = "3.02"
+
+[target.x86_64-linux-gnu]
+cxx_runtime = "toolchain-coupled"
+
+[runtime]
+
+[[runtime.deploy]]
+from = "LICENSE"
+to = "licenses/opencv"
+
+[[runtime.deploy]]
+from = "NOTICE"
+to = "licenses/opencv"
+
+[[runtime.deploy]]
+from = "upstream/opencv/README.md"
+to = "licenses/opencv/upstream/opencv"
+
+[[runtime.deploy]]
+from = "port/licenses/UPSTREAM_SOURCE_NOTICES.txt"
+to = "licenses/opencv/port/licenses"
 
-[dependencies]
-# FFmpeg videoio backend — stays a compat package (separate unification
-# decision). Source-built by mcpp for whatever target/toolchain is active.
-compat.ffmpeg = "8.1.2"
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/dlpack/LICENSE"
+to = "licenses/opencv/upstream/opencv/3rdparty/dlpack"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/flatbuffers/LICENSE.txt"
+to = "licenses/opencv/upstream/opencv/3rdparty/flatbuffers"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/libjpeg-turbo/LICENSE.md"
+to = "licenses/opencv/upstream/opencv/3rdparty/libjpeg-turbo"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/libpng/LICENSE"
+to = "licenses/opencv/upstream/opencv/3rdparty/libpng"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/mlas/LICENSE"
+to = "licenses/opencv/upstream/opencv/3rdparty/mlas"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/protobuf/LICENSE"
+to = "licenses/opencv/upstream/opencv/3rdparty/protobuf"
+
+[[runtime.deploy]]
+from = "upstream/opencv/3rdparty/zlib/LICENSE"
+to = "licenses/opencv/upstream/opencv/3rdparty/zlib"
+
+[[runtime.deploy]]
+from = "upstream/opencv/COPYRIGHT"
+to = "licenses/opencv/upstream/opencv"
+
+[[runtime.deploy]]
+from = "upstream/opencv/LICENSE"
+to = "licenses/opencv/upstream/opencv"
+
+[[runtime.deploy]]
+from = "upstream/opencv/modules/core/3rdparty/SoftFloat/COPYING.txt"
+to = "licenses/opencv/upstream/opencv/modules/core/3rdparty/SoftFloat"
+
+[[runtime.deploy]]
+from = "upstream/opencv/modules/features/3rdparty/annoy/LICENSE"
+to = "licenses/opencv/upstream/opencv/modules/features/3rdparty/annoy"
+
+[[runtime.deploy]]
+from = "upstream/opencv/modules/features/3rdparty/mscr/chi_table_LICENSE.txt"
+to = "licenses/opencv/upstream/opencv/modules/features/3rdparty/mscr"
+
+[[runtime.deploy]]
+from = "upstream/opencv/modules/highgui/src/files_Qt/Material/LICENSE"
+to = "licenses/opencv/upstream/opencv/modules/highgui/src/files_Qt/Material"
 
 [dev-dependencies]
-compat.gtest = "1.15.2"
+
+[dev-dependencies.compat]
+gtest = "1.15.2"
 
 [features]
-unifont = { defines = ["HAVE_UNIFONT"] }
+default = []
+
+[features.calib]
+implies = ["flann", "geometry", "imgproc", "objdetect", "stereo"]
+sources = ["src/calib.cppm", "src/detail/calib.cppm"]
+defines = ["HAVE_OPENCV_CALIB"]
 
 [features.dnn]
-defines = [
-    "HAVE_OPENCV_DNN",
-]
-# The dnn LIBRARY sources are per-OS by construction (windows compiles
-# them through its tu/w/ stub namespace so its per-glob flags can key on
-# the paths) -> ALL of them are injected by build.mcpp from
-# gen/<os>/DNN_SOURCES.txt; only the module interface lives here.
-sources = [
-        "src/dnn.cppm",
-    ]
+implies = ["geometry", "imgproc"]
+sources = ["src/dnn.cppm", "src/detail/dnn.cppm"]
+defines = ["HAVE_OPENCV_DNN"]
 
 [[features.dnn.flags]]
 glob = "**/modules/dnn/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "HAVE_MLAS=1",
-    "HAVE_PROTOBUF=1",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
+defines = ["ENABLE_PLUGINS", "HAVE_MLAS=1", "HAVE_PROTOBUF=1", "NDEBUG", "_USE_MATH_DEFINES", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
 
 [[features.dnn.flags]]
 glob = "**/3rdparty/mlas/**"
-defines = [
-    "BUILD_MLAS_NO_ONNXRUNTIME=1",
-    "MLAS_GEMM_ONLY=1",
-    "MLAS_OPENCV_THREADING=1",
-    "NDEBUG",
-    "_GNU_SOURCE=1",
-    "_USE_MATH_DEFINES",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
+defines = ["BUILD_MLAS_NO_ONNXRUNTIME=1", "MLAS_GEMM_ONLY=1", "MLAS_OPENCV_THREADING=1", "NDEBUG", "_GNU_SOURCE=1", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
 
 [[features.dnn.flags]]
 glob = "**/tu/mlasgemm/**"
-defines = [
-    "BUILD_MLAS_NO_ONNXRUNTIME=1",
-    "MLAS_GEMM_ONLY=1",
-    "MLAS_OPENCV_THREADING=1",
-    "NDEBUG",
-    "_USE_MATH_DEFINES",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
+defines = ["BUILD_MLAS_NO_ONNXRUNTIME=1", "MLAS_GEMM_ONLY=1", "MLAS_OPENCV_THREADING=1", "NDEBUG", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
 
 [[features.dnn.flags]]
 glob = "**/3rdparty/protobuf/**"
-defines = [
-    "HAVE_PTHREAD=1",
-    "NDEBUG",
-]
+defines = ["HAVE_PTHREAD=1", "NDEBUG"]
 
 [[features.dnn.flags]]
 glob = "**/modules/dnn/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
 
 [[features.dnn.flags]]
 glob = "**/modules/dnn/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
 
 [[features.dnn.flags]]
 glob = "**/modules/dnn/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
 
 [[features.dnn.flags]]
-glob = "third_party/opencv-5.0.0/3rdparty/mlas/lib/platform.cpp"
-cxxflags = [
-    "-include",
-    "unistd.h",
-]
+glob = "upstream/opencv/3rdparty/mlas/lib/platform.cpp"
+cxxflags = ["-include", "unistd.h"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/int8layers/layers_common.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/int8layers/layers_common.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON_FP16",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON_FP16"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/common/modules/dnn/layers/layers_common.neon.cpp"
-defines = [
-    "CV_CPU_DISPATCH_MODE=NEON",
-]
+glob = "generated/common/modules/dnn/layers/layers_common.neon.cpp"
+defines = ["CV_CPU_DISPATCH_MODE=NEON"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/dnn/**"
-defines = [
-    "ENABLE_PLUGINS",
-    "HAVE_PROTOBUF=1",
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_CRT_SECURE_NO_WARNINGS=1",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_USE_MATH_DEFINES",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-    "__OPENCV_BUILD=1",
-    "__STDC_CONSTANT_MACROS",
-    "__STDC_FORMAT_MACROS",
-    "__STDC_LIMIT_MACROS",
-]
+glob = "generated/windows/tu/wdnn/dnn/**"
+defines = ["ENABLE_PLUGINS", "HAVE_PROTOBUF=1", "NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_CRT_SECURE_NO_WARNINGS=1", "_SCL_SECURE_NO_WARNINGS", "_USE_MATH_DEFINES", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS", "__OPENCV_BUILD=1", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/protobuf/**"
-defines = [
-    "NDEBUG",
-    "WIN32",
-    "_CRT_NONSTDC_NO_DEPRECATE",
-    "_CRT_SECURE_NO_DEPRECATE",
-    "_CRT_SECURE_NO_WARNINGS=1",
-    "_SCL_SECURE_NO_WARNINGS",
-    "_VARIADIC_MAX=10",
-    "_WIN32_WINNT=0x0601",
-    "_WINDOWS",
-]
+glob = "generated/windows/tu/wdnn/protobuf/**"
+defines = ["NDEBUG", "WIN32", "_CRT_NONSTDC_NO_DEPRECATE", "_CRT_SECURE_NO_DEPRECATE", "_CRT_SECURE_NO_WARNINGS=1", "_SCL_SECURE_NO_WARNINGS", "_VARIADIC_MAX=10", "_WIN32_WINNT=0x0601", "_WINDOWS"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/dnn/**/*.avx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX",
-]
+glob = "generated/windows/tu/wdnn/dnn/**/*.avx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx"]
+defines = ["CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/dnn/**/*.avx2.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX2",
-]
+glob = "generated/windows/tu/wdnn/dnn/**/*.avx2.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX2"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/dnn/**/*.avx512_skx.cpp"
-cxxflags = [
-    "-mssse3",
-    "-msse4.1",
-    "-mpopcnt",
-    "-msse4.2",
-    "-mavx",
-    "-mf16c",
-    "-mavx2",
-    "-mfma",
-    "-mavx512f",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512f",
-    "-mavx512cd",
-    "-mavx512vl",
-    "-mavx512bw",
-    "-mavx512dq",
-]
-defines = [
-    "CV_CPU_COMPILE_AVX2=1",
-    "CV_CPU_COMPILE_AVX512_COMMON=1",
-    "CV_CPU_COMPILE_AVX512_SKX=1",
-    "CV_CPU_COMPILE_AVX=1",
-    "CV_CPU_COMPILE_AVX_512F=1",
-    "CV_CPU_COMPILE_FMA3=1",
-    "CV_CPU_COMPILE_FP16=1",
-    "CV_CPU_COMPILE_POPCNT=1",
-    "CV_CPU_COMPILE_SSE4_1=1",
-    "CV_CPU_COMPILE_SSE4_2=1",
-    "CV_CPU_COMPILE_SSSE3=1",
-    "CV_CPU_DISPATCH_MODE=AVX512_SKX",
-]
+glob = "generated/windows/tu/wdnn/dnn/**/*.avx512_skx.cpp"
+cxxflags = ["-mssse3", "-msse4.1", "-mpopcnt", "-msse4.2", "-mavx", "-mf16c", "-mavx2", "-mfma", "-mavx512f", "-mavx512f", "-mavx512cd", "-mavx512f", "-mavx512cd", "-mavx512vl", "-mavx512bw", "-mavx512dq"]
+defines = ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_COMPILE_AVX512_COMMON=1", "CV_CPU_COMPILE_AVX512_SKX=1", "CV_CPU_COMPILE_AVX=1", "CV_CPU_COMPILE_AVX_512F=1", "CV_CPU_COMPILE_FMA3=1", "CV_CPU_COMPILE_FP16=1", "CV_CPU_COMPILE_POPCNT=1", "CV_CPU_COMPILE_SSE4_1=1", "CV_CPU_COMPILE_SSE4_2=1", "CV_CPU_COMPILE_SSSE3=1", "CV_CPU_DISPATCH_MODE=AVX512_SKX"]
 
 [[features.dnn.flags]]
-glob = "gen/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp"
-defines = [
-    "DEBUG_POSTFIX=d",
-]
+glob = "generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp"
+defines = ["DEBUG_POSTFIX=d"]
+
+[features.features]
+implies = ["geometry", "imgproc"]
+sources = ["src/features.cppm", "src/detail/features.cppm"]
+defines = ["HAVE_OPENCV_FEATURES"]
+
+[features.flann]
+implies = []
+sources = ["src/flann.cppm", "src/detail/flann.cppm"]
+defines = ["HAVE_OPENCV_FLANN"]
+
+[features.geometry]
+implies = ["flann"]
+sources = ["src/geometry.cppm", "src/detail/geometry.cppm"]
+defines = ["HAVE_OPENCV_GEOMETRY"]
+
+[features.highgui]
+implies = ["imgproc"]
+sources = ["src/highgui.cppm", "src/detail/highgui.cppm"]
+defines = ["HAVE_OPENCV_HIGHGUI"]
+
+[features.imgcodecs]
+implies = ["imgproc"]
+sources = ["src/imgcodecs.cppm", "src/detail/imgcodecs.cppm"]
+defines = ["HAVE_OPENCV_IMGCODECS"]
+
+[features.imgproc]
+implies = ["geometry"]
+sources = ["src/imgproc.cppm", "src/detail/imgproc.cppm"]
+defines = ["HAVE_OPENCV_IMGPROC"]
+
+[features.objdetect]
+implies = ["features", "geometry", "imgproc"]
+sources = ["src/objdetect.cppm", "src/detail/objdetect.cppm"]
+defines = ["HAVE_OPENCV_OBJDETECT"]
+
+[features.photo]
+implies = ["geometry", "imgproc"]
+sources = ["src/photo.cppm", "src/detail/photo.cppm"]
+defines = ["HAVE_OPENCV_PHOTO"]
+
+[features.ptcloud]
+implies = ["flann", "geometry", "imgproc"]
+sources = ["src/ptcloud.cppm", "src/detail/ptcloud.cppm"]
+defines = ["HAVE_OPENCV_PTCLOUD"]
+
+[features.stereo]
+implies = ["geometry", "imgproc"]
+sources = ["src/stereo.cppm", "src/detail/stereo.cppm"]
+defines = ["HAVE_OPENCV_STEREO"]
+
+[features.stitching]
+implies = ["features", "flann", "geometry", "imgproc"]
+sources = ["src/stitching.cppm", "src/detail/stitching.cppm"]
+defines = ["HAVE_OPENCV_STITCHING"]
+
+[features.video]
+implies = ["imgproc"]
+sources = ["src/video.cppm", "src/detail/video.cppm"]
+defines = ["HAVE_OPENCV_VIDEO"]
+
+[features.videoio]
+implies = ["imgcodecs", "imgproc"]
+sources = ["src/videoio.cppm", "src/detail/videoio.cppm"]
+defines = ["HAVE_OPENCV_VIDEOIO"]
+
+[[features.videoio.flags]]
+glob = "**/modules/videoio/**"
+defines = ["ENABLE_PLUGINS", "NDEBUG", "__OPENCV_BUILD=1", "_USE_MATH_DEFINES", "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
 
-# musl leg: mcpp build --target x86_64-linux-musl (toolchain resolved from the
-# installed gcc-musl pair; static is the supported linkage for this target).
-[target.x86_64-linux-musl]
-linkage = "static"
+[features.all-modules]
+implies = ["calib", "dnn", "features", "flann", "geometry", "highgui", "imgcodecs", "imgproc", "objdetect", "photo", "ptcloud", "stereo", "stitching", "video", "videoio"]
+
+[features.simd]
+sources = ["src/core_simd.cppm", "src/detail/simd.cppm", "src/core_simd_legacy.cppm", "src/detail/simd_legacy.cppm"]
+
+[features.simd-emulated]
+implies = ["simd"]
+
+[features.imgcodecs-jpeg]
+implies = ["imgcodecs"]
+
+[features.imgcodecs-png]
+implies = ["imgcodecs"]
+
+[features.imgcodecs-webp]
+implies = ["imgcodecs"]
+
+[[features.imgcodecs-webp.flags]]
+glob = "**/imgcodecs/**"
+defines = ["HAVE_WEBP=1"]
+
+[features.videoio-ffmpeg]
+implies = ["videoio"]
+defines = ["HAVE_FFMPEG", "HAVE_FFMPEG_LIBAVDEVICE"]
+
+[features.videoio-v4l2]
+implies = ["videoio"]
+defines = ["HAVE_CAMV4L2"]
+
+[features.videoio-native]
+implies = ["videoio"]
+
+[features.videoio-msmf]
+implies = ["videoio"]
+
+[features.videoio-avfoundation]
+implies = ["videoio"]
+
+[features.unifont]
+implies = ["imgproc"]
+defines = ["HAVE_UNIFONT"]
+
+[features.highgui-native]
+implies = ["highgui", "imgcodecs"]
+
+[[features.highgui-native.flags]]
+glob = "**/highgui/src/window_gtk.cpp"
+cxxflags = ["-pthread"]
+
+[features.highgui-gtk3]
+implies = ["highgui", "imgcodecs"]
+
+[[features.highgui-gtk3.flags]]
+glob = "**/highgui/src/window_gtk.cpp"
+cxxflags = ["-pthread"]
+
+[features.highgui-win32]
+implies = ["highgui"]
+
+[features.highgui-cocoa]
+implies = ["highgui"]
+
+[features.dnn-onnxruntime]
+implies = ["dnn"]
+defines = ["HAVE_ONNXRUNTIME=1"]
+
+[feature-deps]
+
+[feature-deps.videoio-ffmpeg]
+
+[feature-deps.videoio-ffmpeg.compat]
+ffmpeg = "8.1.2"
+
+[feature-deps.imgcodecs-webp]
+
+[feature-deps.imgcodecs-webp.compat]
+
+[feature-deps.imgcodecs-webp.compat.libwebp]
+version = "1.5.0"
+features = ["demux", "mux"]
+
+[feature-deps.dnn-onnxruntime]
+
+[feature-deps.dnn-onnxruntime."mcpplibs.mwrap"]
+onnxruntime = "1.25.1"
+
+[targets]
 
 [targets.opencv]
 kind = "lib"
diff --git a/port/api/entity-review.toml b/port/api/entity-review.toml
new file mode 100644
index 0000000..0530e8b
--- /dev/null
+++ b/port/api/entity-review.toml
@@ -0,0 +1,359 @@
+schema = 1
+upstream-version = "5.0.0"
+# Exact reviewed rejections from import-only lookup, not a blanket namespace exclusion.
+
+[[groups]]
+source = "modules/core/include/opencv2/core/base.hpp"
+source-sha256 = "9e2623e6114b66874e31d45acc6f58c313c45fab38dc9538ebaca435d5a8ebb8"
+decision = "upstream-internal"
+reason = "SDK-ignored OpenCV 3 compatibility aliases guarded by DISABLE_OPENCV_3_COMPATIBILITY; current useIPP_NotExact/setUseIPP_NotExact remain exported."
+evidence = ["@cond IGNORED", "DISABLE_OPENCV_3_COMPATIBILITY", "static inline bool useIPP_NE"]
+names = [
+  "cv::ipp::setUseIPP_NE",
+  "cv::ipp::useIPP_NE",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/bindings_utils.hpp"
+source-sha256 = "7438b1e6e13b0cdf73e4792fa1f7b5c2de6f0db621552c7b9dd13c538549f264"
+decision = "binding-only"
+reason = "These exact names lie in the SDK-ignored language-binding test region; ordinary public dump helpers before that region are separately restored and tested."
+evidence = ["@cond IGNORED", "testReservedKeywordConversion", "@endcond IGNORED"]
+names = [
+  "cv::utils::ClassWithKeywordProperties",
+  "cv::utils::FunctionParams",
+  "cv::utils::copyMatAndDumpNamedArguments",
+  "cv::utils::dumpVec2i",
+  "cv::utils::generateVectorOfInt",
+  "cv::utils::generateVectorOfMat",
+  "cv::utils::generateVectorOfRect",
+  "cv::utils::nested::OriginalClassName",
+  "cv::utils::nested::OriginalClassName_Params",
+  "cv::utils::nested::testEchoBooleanFunction",
+  "cv::utils::testAsyncArray",
+  "cv::utils::testAsyncException",
+  "cv::utils::testOverloadResolution",
+  "cv::utils::testOverwriteNativeMethod",
+  "cv::utils::testRaiseGeneralException",
+  "cv::utils::testReservedKeywordConversion",
+  "cv::utils::testRotatedRect",
+  "cv::utils::testRotatedRectVector",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/check.hpp"
+source-sha256 = "dd9eb5c2d14202e432a2455a5851721cbe70eeb176411bd07fd20ee034f4eaf3"
+decision = "upstream-internal"
+reason = "SDK-ignored check-context, operation enums and error-formatting dispatch used by textual CV_Check macros; public depthToString/typeToString remain exported."
+evidence = ["@cond IGNORED", "struct CheckContext", "enum TestOp"]
+names = [
+  "cv::detail::CV__LAST_TEST_OP",
+  "cv::detail::CheckContext",
+  "cv::detail::TEST_CUSTOM",
+  "cv::detail::TEST_EQ",
+  "cv::detail::TEST_GE",
+  "cv::detail::TEST_GT",
+  "cv::detail::TEST_LE",
+  "cv::detail::TEST_LT",
+  "cv::detail::TEST_NE",
+  "cv::detail::TestOp",
+  "cv::detail::check_failed_MatChannels",
+  "cv::detail::check_failed_MatDepth",
+  "cv::detail::check_failed_MatType",
+  "cv::detail::check_failed_auto",
+  "cv::detail::check_failed_false",
+  "cv::detail::check_failed_true",
+  "cv::detail::depthToString_",
+  "cv::detail::typeToString_",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/cvstd.hpp"
+source-sha256 = "96a1ddefb0539061389be0704b554e5ab30f20132944485f4c70644ceeb4a0d2"
+decision = "upstream-internal"
+reason = "Character-conversion implementation helpers behind exported toLowerCase/toUpperCase, not independent string APIs."
+evidence = ["namespace details", "char_tolower", "char_toupper"]
+names = [
+  "cv::details::char_tolower",
+  "cv::details::char_toupper",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/cvstd_wrapper.hpp"
+source-sha256 = "9f25758221966c94a202f173fe86c73abbdd9610be3708e820f71d91c7c9b653"
+decision = "upstream-internal"
+reason = "SFINAE detection implementation used by has_custom_delete/Ptr; public pointer construction and custom-deleter rejection have independent tests."
+evidence = ["namespace sfinae", "has_parenthesis_operator", "struct has_custom_delete"]
+names = [
+  "cv::sfinae::has_parenthesis_operator",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/dualquaternion.inl.hpp"
+source-sha256 = "1b6b478123cd15b7f24f2f3399d5c9199f7af979d9b57f0b0265a02cd4279484"
+decision = "upstream-internal"
+reason = "Private Jacobian helper inside the implementation header, called by original DualQuat exp/log member implementations; not a documented public extension interface."
+evidence = ["//Implementation", "namespace detail", "detail::jacob_exp(real)"]
+names = [
+  "cv::detail::jacob_exp",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/hal/hal.hpp"
+source-sha256 = "02698c7584bb7dbb0083c117c373f76482ea96483c4385c3013e432ef3ab67ce"
+decision = "upstream-internal"
+reason = "SDK-ignored binary-compatibility aliases for OpenCV 3.0; the current typed HAL entry points are exported and behavior-tested."
+evidence = ["for binary compatibility with 3.0", "@cond IGNORED", "CV_EXPORTS void invSqrt"]
+names = [
+  "cv::hal::Cholesky",
+  "cv::hal::LU",
+  "cv::hal::exp",
+  "cv::hal::fastAtan2",
+  "cv::hal::invSqrt",
+  "cv::hal::log",
+  "cv::hal::magnitude",
+  "cv::hal::sqrt",
+]
+
+[[groups]]
+features = ["simd-emulated"]
+source = "modules/core/include/opencv2/core/hal/intrin_cpp.hpp"
+source-sha256 = "570828789b15e0c51ca34134b38769e045ff56bb0f94530a2642144c155359be"
+decision = "upstream-internal"
+reason = "SDK-ignored _absdiff/_pack_b implementation helpers and the TU-local popcount lookup table; public vector functions and width enums are separately exported and tested."
+evidence = ["_absdiff", "_pack_b", "static const unsigned char popCountTable"]
+names = [
+  "cv::hal_EMULATOR_CPP::_absdiff",
+  "cv::hal_EMULATOR_CPP::_pack_b",
+  "cv::hal_EMULATOR_CPP::popCountTable",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/mat.inl.hpp"
+source-sha256 = "5307377114f21cf4a884ad26ae203ae695546e3411d5954dafcabe201a8c2d3c"
+decision = "upstream-internal"
+reason = "SDK-ignored raw element-type calculation used internally by raw InputArray constructors; public rawIn/rawOut/rawInOut adapters are tested separately."
+evidence = ["@cond IGNORED", "int rawType()", "_InputArray::FIXED_TYPE"]
+names = [
+  "cv::rawType",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/matx.inl.hpp"
+source-sha256 = "d0c6a03dd02395c20d3982cffd74e63f0188beebf7de04b1019c7c0bb5055c1a"
+decision = "upstream-internal"
+reason = "Internal determinant/conjugation implementation under cv::internal; public Matx/Vec reductions and operators are tested through the original public spellings."
+evidence = ["namespace internal", "Matx_DetOp", "conjugate"]
+names = [
+  "cv::internal::Matx_DetOp",
+  "cv::internal::conjugate",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/operations.hpp"
+source-sha256 = "43b94b3cfd74d1e3a38b8daa4b9f99ec6476b1e0420bfd33b74f3ce60c73b849"
+decision = "upstream-internal"
+reason = "Internal Matx inversion/solve dispatch functors; original public Matx::inv/solve members remain the SDK implementation."
+evidence = ["namespace internal", "Matx_FastInvOp", "Matx_FastSolveOp"]
+names = [
+  "cv::internal::Matx_FastInvOp",
+  "cv::internal::Matx_FastSolveOp",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/persistence.hpp"
+source-sha256 = "4416e51a1f49c85490a5633e3e1b0bd5aa726680594dcfa9c10819053ebc7b0b"
+decision = "upstream-internal"
+reason = "Private persistence reader/writer proxies and internal write-context helper; public FileStorage and generated read/write contracts are separately tested."
+evidence = ["namespace internal", "VecReaderProxy", "VecWriterProxy", "WriteStructContext"]
+names = [
+  "cv::internal::VecReaderProxy",
+  "cv::internal::VecWriterProxy",
+  "cv::internal::WriteStructContext",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/quaternion.inl.hpp"
+source-sha256 = "dff743f883e47035d84e52058cb9bca9fbf5d615e35bf3923097164263d6a164"
+decision = "upstream-internal"
+reason = "SDK-hidden Euler-angle implementation helpers used by original Quat member bodies; the public quaternion API remains exported."
+evidence = ["@cond IGNORE", "namespace detail", "detail::createFromAxisRot"]
+names = [
+  "cv::detail::createFromAxisRot",
+  "cv::detail::isIntAngleType",
+  "cv::detail::isTaitBryan",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/traits.hpp"
+source-sha256 = "73fdb2ffa02e290007c1235f8aecfbfba9559abf2f3d04c3e09bed67e481ffc5"
+decision = "upstream-internal"
+reason = "Macro-generated member-detection implementation in traits::internal; public Depth/Type trait declarations remain exported."
+evidence = ["namespace internal", "CV_CREATE_MEMBER_CHECK(fmt)", "CV_CREATE_MEMBER_CHECK(type)"]
+names = [
+  "cv::traits::internal::CheckMember_fmt",
+  "cv::traits::internal::CheckMember_type",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/utils/logger.hpp"
+source-sha256 = "de05bb88ce641de6e1fb8b21b61cc5c4e5f3652937273a9b4697878f10ad5827"
+decision = "upstream-internal"
+reason = "Logger dispatch callbacks and hook replacement machinery in the explicit internal namespace; public logging state/functions remain exported."
+evidence = ["namespace internal", "replaceWriteLogMessage", "WriteLogMessageFuncType"]
+names = [
+  "cv::utils::logging::internal::WriteLogMessageExFuncType",
+  "cv::utils::logging::internal::WriteLogMessageFuncType",
+  "cv::utils::logging::internal::getGlobalLogTag",
+  "cv::utils::logging::internal::replaceWriteLogMessage",
+  "cv::utils::logging::internal::replaceWriteLogMessageEx",
+  "cv::utils::logging::internal::writeLogMessage",
+  "cv::utils::logging::internal::writeLogMessageEx",
+]
+
+[[groups]]
+source = "modules/core/include/opencv2/core/utils/tls.hpp"
+source-sha256 = "3b3261c3900c2d1ab82496b6722979996cb899f3110492d7177651790b6f9aef"
+decision = "upstream-internal"
+reason = "Incomplete friend storage implementation owned by core/src/system.cpp, not the documented TLSData/TLSDataAccumulator interfaces."
+evidence = ["namespace details { class TlsStorage; }", "friend class cv::details::TlsStorage"]
+names = [
+  "cv::details::TlsStorage",
+]
+
+[[groups]]
+source = "modules/dnn/include/opencv2/dnn/dnn.hpp"
+source-sha256 = "30b8090f9dd644c9b737b8626b83b5cc8d370bdd80534a0a0f5bedbc5cb4e3cd"
+decision = "upstream-internal"
+reason = "Incomplete private friend accessor for Net implementation storage, distinct from the public Arg equality and legacy backend utilities now restored."
+evidence = ["namespace accessor", "DnnNetAccessor"]
+names = [
+  "cv::dnn::accessor::DnnNetAccessor",
+]
+
+[[groups]]
+source = "modules/flann/include/opencv2/flann/allocator.h"
+source-sha256 = "df11437b7c656f2b0d653eac5c49233ef5dd6a416086ba3896ac070be3994b46"
+decision = "upstream-internal"
+reason = "SDK-ignored raw FLANN allocator tuning constants used by PooledAllocator; auxiliary cvflann exports are not a promise to expose every raw implementation detail."
+evidence = ["@cond IGNORED", "WORDSIZE=16", "BLOCKSIZE=8192"]
+names = [
+  "cvflann::BLOCKSIZE",
+  "cvflann::WORDSIZE",
+]
+
+[[groups]]
+source = "modules/flann/include/opencv2/flann/any.h"
+source-sha256 = "3b15f77754d790637d2ee5efd5ead1de2671717b87ce8d9852b1d40529040e4a"
+decision = "upstream-internal"
+reason = "SDK-ignored raw FLANN type-erasure policies and stream helpers, not OpenCV flann public index/search interfaces. Existing exported aliases retain original SDK identities."
+evidence = ["@cond IGNORED", "namespace anyimpl", "base_any_policy"]
+names = [
+  "cvflann::anyimpl::SinglePolicy",
+  "cvflann::anyimpl::any",
+  "cvflann::anyimpl::bad_any_cast",
+  "cvflann::anyimpl::base_any_policy",
+  "cvflann::anyimpl::big_any_policy",
+  "cvflann::anyimpl::choose_policy",
+  "cvflann::anyimpl::empty_any",
+  "cvflann::anyimpl::operator<<",
+  "cvflann::anyimpl::small_any_policy",
+  "cvflann::anyimpl::typed_base_any_policy",
+  "cvflann::operator<<",
+]
+
+[[groups]]
+source = "modules/flann/include/opencv2/flann/lsh_table.h"
+source-sha256 = "a64c3744103ba09251d7198e0743a6a2d10abaaae895c2b24b4f5000a0354c96"
+decision = "upstream-internal"
+reason = "SDK-ignored raw FLANN LSH bucket/table implementation; OpenCV public LSH index parameters and searches remain separately exported."
+evidence = ["@cond IGNORED", "namespace lsh", "LshTable"]
+names = [
+  "cvflann::lsh::Bucket",
+  "cvflann::lsh::BucketKey",
+  "cvflann::lsh::FeatureIndex",
+  "cvflann::lsh::LshStats",
+  "cvflann::lsh::LshTable",
+  "cvflann::lsh::operator<<",
+]
+
+[[groups]]
+source = "modules/imgproc/include/opencv2/imgproc/hal/hal.hpp"
+source-sha256 = "efecd002537f5d66489e05401dadca222785c8bd4c69d7d70e1e131fd69a0097"
+decision = "upstream-internal"
+reason = "Deprecated SDK-ignored HAL filter implementation classes; the current public filter2D/sepFilter2D/morph entry points retain their SDK entities."
+evidence = ["@cond IGNORED", "CV_DEPRECATED", "struct CV_EXPORTS Morph"]
+names = [
+  "cv::hal::Filter2D",
+  "cv::hal::Morph",
+  "cv::hal::SepFilter2D",
+]
+
+[[groups]]
+source = "modules/stitching/include/opencv2/stitching/detail/util_inl.hpp"
+source-sha256 = "75ad5d758c607f78151db4e9485791d8ef5dda0d5e2b9e2b11d9675b81e97559"
+decision = "upstream-internal"
+reason = "SDK-ignored stitching auxiliary math behind Graph and algorithm implementations; public stitching classes/functions are separately exported."
+evidence = ["@cond IGNORED", "Some auxiliary math functions", "static inline int sqr"]
+names = [
+  "cv::detail::normL2",
+  "cv::detail::normL2sq",
+  "cv::detail::sqr",
+]
+
+[[groups]]
+source = "modules/videoio/include/opencv2/videoio.hpp"
+source-sha256 = "85c1224ce4beaf522e5c7dc0ebc12554f34d34d28a50e28c7a84144a494e03e4"
+decision = "upstream-internal"
+reason = "Incomplete private friend accessor for VideoCapture implementation storage, not a capture backend interface."
+evidence = ["namespace internal", "VideoCapturePrivateAccessor"]
+names = [
+  "cv::internal::VideoCapturePrivateAccessor",
+]
+
+[[groups]]
+features = ["simd"]
+without-features = ["simd-emulated"]
+when-header-loaded = true
+source = "modules/core/include/opencv2/core/hal/intrin_sse.hpp"
+source-sha256 = "9af7b4fdd7b587f2379b1bab854e596eef336b7f342568bd4ebda12d7a9d9396"
+decision = "upstream-internal"
+reason = "Implementation-only palignr and reinterpret templates inside the explicit hal_sse_internal namespace; public vector entry points retain the original SDK code."
+evidence = ["namespace hal_sse_internal", "v_sse_palignr_u8", "v_sse_reinterpret_as"]
+names = [
+  "cv::hal_baseline::hal_sse_internal::v_sse_palignr_u8",
+  "cv::hal_baseline::hal_sse_internal::v_sse_palignr_u8_class",
+  "cv::hal_baseline::hal_sse_internal::v_sse_reinterpret_as",
+]
+
+[[groups]]
+features = ["simd"]
+without-features = ["simd-emulated"]
+when-header-loaded = true
+source = "modules/core/include/opencv2/core/hal/intrin_sse_em.hpp"
+source-sha256 = "9a8369d287ff500756fae5577f528c360f011e04e5a4a44f5af1d697b1d1442a"
+decision = "upstream-internal"
+reason = "Private x86 SSE compatibility shims over __m128i used by the public universal intrinsics; underscore-prefixed helper names emulate newer instructions on the SSE2 baseline."
+evidence = ["#if !CV_SSE4_1", "_v128_blendv_epi8", "_v128_cvtepi8_epi32"]
+names = [
+  "cv::hal_baseline::_v128_blendv_epi8",
+  "cv::hal_baseline::_v128_comgt_epu32",
+  "cv::hal_baseline::_v128_cvtepi16_epi32",
+  "cv::hal_baseline::_v128_cvtepi16_epi32_high",
+  "cv::hal_baseline::_v128_cvtepi32_epi64",
+  "cv::hal_baseline::_v128_cvtepi32_epi64_high",
+  "cv::hal_baseline::_v128_cvtepi8_epi16",
+  "cv::hal_baseline::_v128_cvtepi8_epi16_high",
+  "cv::hal_baseline::_v128_cvtepi8_epi32",
+  "cv::hal_baseline::_v128_cvtepu16_epi32",
+  "cv::hal_baseline::_v128_cvtepu16_epi32_high",
+  "cv::hal_baseline::_v128_cvtepu32_epi64",
+  "cv::hal_baseline::_v128_cvtepu32_epi64_high",
+  "cv::hal_baseline::_v128_cvtepu8_epi16",
+  "cv::hal_baseline::_v128_cvtepu8_epi16_high",
+  "cv::hal_baseline::_v128_cvtepu8_epi32",
+  "cv::hal_baseline::_v128_extract_epi64",
+  "cv::hal_baseline::_v128_min_epu32",
+  "cv::hal_baseline::_v128_mullo_epi32",
+  "cv::hal_baseline::_v128_packs_epu32",
+]
diff --git a/port/api/header-review.toml b/port/api/header-review.toml
new file mode 100644
index 0000000..d2337f7
--- /dev/null
+++ b/port/api/header-review.toml
@@ -0,0 +1,248 @@
+schema = 1
+upstream-version = "5.0.0"
+# Pinned-header review, not a claim of complete API support. public-gap stays open.
+
+[[groups]]
+decision = "cuda-sdk"
+reason = "CUDA device templates and stream accessors require CUDA SDK types/compiler. No device module is implemented or certified."
+headers = [
+  "modules/core/include/opencv2/core/cuda/block.hpp",
+  "modules/core/include/opencv2/core/cuda/border_interpolate.hpp",
+  "modules/core/include/opencv2/core/cuda/color.hpp",
+  "modules/core/include/opencv2/core/cuda/common.hpp",
+  "modules/core/include/opencv2/core/cuda/cuda_compat.hpp",
+  "modules/core/include/opencv2/core/cuda/datamov_utils.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/color_detail.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/reduce.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp",
+  "modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp",
+  "modules/core/include/opencv2/core/cuda/dynamic_smem.hpp",
+  "modules/core/include/opencv2/core/cuda/emulation.hpp",
+  "modules/core/include/opencv2/core/cuda/filters.hpp",
+  "modules/core/include/opencv2/core/cuda/funcattrib.hpp",
+  "modules/core/include/opencv2/core/cuda/functional.hpp",
+  "modules/core/include/opencv2/core/cuda/limits.hpp",
+  "modules/core/include/opencv2/core/cuda/reduce.hpp",
+  "modules/core/include/opencv2/core/cuda/saturate_cast.hpp",
+  "modules/core/include/opencv2/core/cuda/scan.hpp",
+  "modules/core/include/opencv2/core/cuda/simd_functions.hpp",
+  "modules/core/include/opencv2/core/cuda/transform.hpp",
+  "modules/core/include/opencv2/core/cuda/type_traits.hpp",
+  "modules/core/include/opencv2/core/cuda/utility.hpp",
+  "modules/core/include/opencv2/core/cuda/vec_distance.hpp",
+  "modules/core/include/opencv2/core/cuda/vec_math.hpp",
+  "modules/core/include/opencv2/core/cuda/vec_traits.hpp",
+  "modules/core/include/opencv2/core/cuda/warp.hpp",
+  "modules/core/include/opencv2/core/cuda/warp_reduce.hpp",
+  "modules/core/include/opencv2/core/cuda/warp_shuffle.hpp",
+  "modules/core/include/opencv2/core/cuda_stream_accessor.hpp",
+]
+
+[[groups]]
+decision = "partial-native"
+reason = "The optional core.simd surface implements native 128-bit APIs with original types. Linux GCC16/LLVM22/LLVM23 SDK parity, all-main-module composition and GCC release tests pass. ARM64/Windows native CI and complete mode coverage remain required; this is not a completed family-wide acceptance record."
+headers = [
+  "modules/core/include/opencv2/core/hal/intrin.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_forward.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_math.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_neon.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_sse.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_sse_em.hpp",
+  "modules/core/include/opencv2/core/hal/simd_utils.impl.hpp",
+  "modules/core/include/opencv2/core/simd_intrinsics.hpp",
+]
+
+[[groups]]
+decision = "partial"
+reason = "The optional simd-emulated mode imports original generic SDK templates with scoped namespace-function linkage adaptation. SDK/module parity and direct/root lookup pass on Linux GCC16/LLVM22/LLVM23. Current native CI and all-main-module composition remain required; the original reinterpret_uint instantiation failure is independently preserved."
+headers = [
+  "modules/core/include/opencv2/core/hal/intrin_cpp.hpp",
+]
+
+[[groups]]
+decision = "partial"
+reason = "The explicit core.simd.legacy module re-exports all 21 original cv::hal operator templates. Native/software SDK parity, reference identity, saturation and root/base opt-in boundaries pass GCC16/LLVM22/LLVM23; GCC release software parity passes too. Native platform CI and full composition remain required. The original software floating v_not link failure is preserved."
+headers = [
+  "modules/core/include/opencv2/core/hal/intrin_legacy_ops.h",
+]
+
+[[groups]]
+decision = "public-gap"
+reason = "Other architecture/ISA implementations still need explicit module integration and applicable verification. Native 128-bit, software mode and legacy operator support do not certify these modes."
+headers = [
+  "modules/core/include/opencv2/core/hal/intrin_avx.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_avx512.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_lasx.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_lsx.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_msa.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_rvv071.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_vsx.hpp",
+  "modules/core/include/opencv2/core/hal/intrin_wasm.hpp",
+  "modules/core/include/opencv2/core/hal/msa_macros.h",
+]
+
+[[groups]]
+decision = "runtime-internal"
+reason = "OpenCL runtime loaders/wrappers, build configuration macros and anonymous-namespace information dumping support the implementation. Public cv::ocl declarations are provided by core/ocl.hpp."
+headers = [
+  "modules/core/include/opencv2/core/ocl_genbase.hpp",
+  "modules/core/include/opencv2/core/opencl/ocl_defs.hpp",
+  "modules/core/include/opencv2/core/opencl/opencl_info.hpp",
+  "modules/core/include/opencv2/core/opencl/opencl_svm.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core_wrappers.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl_wrappers.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp",
+  "modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp",
+]
+
+[[groups]]
+decision = "forwarder"
+reason = "Only include guards/build-use checks and includes remain after comments: these compatibility paths introduce no additional declarations. Current module imports provide the included modern APIs."
+headers = [
+  "modules/calib/include/opencv2/calib3d.hpp",
+  "modules/calib/include/opencv2/calib3d/calib3d.hpp",
+  "modules/core/include/opencv2/core/core.hpp",
+  "modules/features/include/opencv2/features/features.hpp",
+  "modules/features/include/opencv2/features2d.hpp",
+  "modules/flann/include/opencv2/flann/flann.hpp",
+  "modules/highgui/include/opencv2/highgui/highgui.hpp",
+  "modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp",
+  "modules/imgproc/include/opencv2/imgproc/imgproc.hpp",
+  "modules/objdetect/include/opencv2/objdetect/objdetect.hpp",
+  "modules/photo/include/opencv2/photo/photo.hpp",
+  "modules/video/include/opencv2/video/video.hpp",
+  "modules/videoio/include/opencv2/videoio/videoio.hpp",
+]
+
+[[groups]]
+decision = "platform-sdk"
+reason = "Public SDK/platform-specific interoperation is not implemented: DirectX, Eigen, VA-API, WinRT/C++-CX or Objective-C Apple/UIKit types and execution environments must be integrated and tested explicitly."
+headers = [
+  "modules/core/include/opencv2/core/directx.hpp",
+  "modules/core/include/opencv2/core/eigen.hpp",
+  "modules/core/include/opencv2/core/va_intel.hpp",
+  "modules/highgui/include/opencv2/highgui/highgui_winrt.hpp",
+  "modules/imgcodecs/include/opencv2/imgcodecs/ios.h",
+  "modules/imgcodecs/include/opencv2/imgcodecs/macosx.h",
+  "modules/videoio/include/opencv2/videoio/cap_ios.h",
+  "modules/videoio/include/opencv2/videoio/cap_winrt.hpp",
+]
+
+[[groups]]
+decision = "parallel-sdk"
+reason = "Optional custom parallel backend implementations need OpenMP compiler/runtime or TBB SDK. The existing public ParallelForAPI interface is exported; these concrete backends are not enabled."
+headers = [
+  "modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp",
+  "modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp",
+]
+
+[[groups]]
+decision = "upstream-internal"
+reason = "Pinned headers mark their bodies @cond IGNORED: dispatch helper implementation, retired dummy, FLANN factory/simplex helpers and GCGraph implementation."
+headers = [
+  "modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp",
+  "modules/flann/include/opencv2/flann/dummy.h",
+  "modules/flann/include/opencv2/flann/object_factory.h",
+  "modules/flann/include/opencv2/flann/simplex_downhill.h",
+  "modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp",
+]
+
+[[groups]]
+decision = "upstream-internal"
+reason = "Upstream explicitly says skipModelImport is internal and not intended for users."
+headers = [
+  "modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp",
+]
+
+[[groups]]
+decision = "upstream-internal"
+reason = "PoseGraph explicitly says it is used internally in Large KinFu. Submap/SubmapManager are its scene-management implementation types; public point-cloud factories and rendering functions are separate exports."
+headers = [
+  "modules/ptcloud/include/opencv2/ptcloud/detail/pose_graph.hpp",
+  "modules/ptcloud/include/opencv2/ptcloud/detail/submap.hpp",
+]
+
+[[groups]]
+decision = "implementation"
+reason = "Concrete allocator counter implementation depends on build-specific counter configuration. The public AllocatorStatisticsInterface and accessor functions are exported from allocator_stats.hpp."
+headers = [
+  "modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp",
+]
+
+[[groups]]
+decision = "textual-only"
+reason = "Build CPU dispatch selection macros have no standalone public declarations to import."
+headers = [
+  "modules/core/include/opencv2/core/cv_cpu_helper.h",
+]
+
+[[groups]]
+decision = "textual-only"
+reason = "Public trace region/argument macros are control-flow instrumentation. Supporting details are explicitly @cond IGNORED; callers need the textual trace header before imports."
+headers = [
+  "modules/core/include/opencv2/core/utils/trace.hpp",
+]
+
+[[groups]]
+decision = "textual-only"
+reason = "Layer registration declaration macros construct private registrars; callers can use the exported LayerFactory C++ API. Macro-based declarations require the upstream textual header and supported mixing order."
+headers = [
+  "modules/dnn/include/opencv2/dnn/layer.details.hpp",
+]
+
+[[groups]]
+decision = "binding-only"
+reason = "Header explicitly says functions are for bindings only and directs C++ callers to HoughLines/HoughCircles, which are exported."
+headers = [
+  "modules/imgproc/include/opencv2/imgproc/bindings.hpp",
+]
+
+[[groups]]
+decision = "implemented"
+reason = "Twelve public dump helpers use exact SDK forwards; eight external array/vector/cache helpers retain original declarations. Independent native/module consumers cover formatting and array diagnostics on all three Linux compilers. The ignored binding-test region is not exported."
+headers = [
+  "modules/core/include/opencv2/core/bindings_utils.hpp",
+]
+
+[[groups]]
+decision = "implemented"
+reason = "The original global InpaintingModes type and six global legacy constants are exported from photo/video with using declarations. Direct module tests compare their original values and modern C++ equivalents."
+headers = [
+  "modules/photo/include/opencv2/photo/legacy/constants_c.h",
+  "modules/video/include/opencv2/video/legacy/constants_c.h",
+]
+
+[[groups]]
+decision = "implemented"
+reason = "Original cvhalKeyPoint is included and re-exported from the features facade. HAL values are mapped in the macros module; native consumer coverage is required on the new checkpoint."
+headers = [
+  "modules/features/include/opencv2/features/hal/interface.h",
+]
+
+[[groups]]
+decision = "typed-mapped"
+reason = "Header contains pure CV_HAL_* macro constants only. The macros module and optional textual bridge include this header and map each value without enabling an image-processing backend."
+headers = [
+  "modules/imgproc/include/opencv2/imgproc/hal/interface.h",
+]
+
+[[groups]]
+decision = "documentation"
+reason = "Hardware-acceleration documentation contains documentation content, not an API header."
+headers = [
+  "modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp",
+]
diff --git a/port/api/simd-surface.json b/port/api/simd-surface.json
new file mode 100644
index 0000000..fbe9396
--- /dev/null
+++ b/port/api/simd-surface.json
@@ -0,0 +1,554 @@
+{
+  "upstream-version": "5.0.0",
+  "source": "Clang pinned SDK inventories for native x86_64 and CV_FORCE_SIMD128_CPP; preserve original entities. No failure-driven pruning.",
+  "common": [
+    "Type2Vec128_Traits",
+    "VTraits",
+    "V_RegTraits",
+    "V_TypeTraits",
+    "v_abs",
+    "v_absdiff",
+    "v_absdiffs",
+    "v_add",
+    "v_add_wrap",
+    "v_and",
+    "v_broadcast_element",
+    "v_broadcast_highest",
+    "v_ceil",
+    "v_check_all",
+    "v_check_any",
+    "v_cleanup",
+    "v_combine_high",
+    "v_combine_low",
+    "v_cos",
+    "v_cos_default_16f",
+    "v_cos_default_32f",
+    "v_cos_default_64f",
+    "v_cvt_f32",
+    "v_cvt_f64",
+    "v_cvt_f64_high",
+    "v_div",
+    "v_dotprod",
+    "v_dotprod_expand",
+    "v_dotprod_expand_fast",
+    "v_dotprod_fast",
+    "v_eq",
+    "v_erf",
+    "v_erf_default_32f",
+    "v_exp",
+    "v_exp_default_16f",
+    "v_exp_default_32f",
+    "v_exp_default_64f",
+    "v_expand",
+    "v_expand_high",
+    "v_expand_low",
+    "v_extract",
+    "v_extract_highest",
+    "v_extract_n",
+    "v_float32",
+    "v_float32x4",
+    "v_float64",
+    "v_float64x2",
+    "v_floor",
+    "v_fma",
+    "v_ge",
+    "v_get0",
+    "v_gt",
+    "v_int16",
+    "v_int16x8",
+    "v_int32",
+    "v_int32x4",
+    "v_int64",
+    "v_int64x2",
+    "v_int8",
+    "v_int8x16",
+    "v_interleave_pairs",
+    "v_interleave_quads",
+    "v_invsqrt",
+    "v_le",
+    "v_load",
+    "v_load_aligned",
+    "v_load_deinterleave",
+    "v_load_expand",
+    "v_load_expand_q",
+    "v_load_halves",
+    "v_load_low",
+    "v_log",
+    "v_log_default_16f",
+    "v_log_default_32f",
+    "v_log_default_64f",
+    "v_lt",
+    "v_lut",
+    "v_lut_deinterleave",
+    "v_lut_pairs",
+    "v_lut_quads",
+    "v_magnitude",
+    "v_matmul",
+    "v_matmuladd",
+    "v_max",
+    "v_min",
+    "v_mul",
+    "v_mul_expand",
+    "v_mul_hi",
+    "v_mul_wrap",
+    "v_muladd",
+    "v_ne",
+    "v_not",
+    "v_not_nan",
+    "v_or",
+    "v_pack",
+    "v_pack_b",
+    "v_pack_store",
+    "v_pack_triplets",
+    "v_pack_u",
+    "v_pack_u_store",
+    "v_popcount",
+    "v_recombine",
+    "v_reduce_max",
+    "v_reduce_min",
+    "v_reduce_sad",
+    "v_reduce_sum",
+    "v_reduce_sum4",
+    "v_reinterpret_as_f32",
+    "v_reinterpret_as_f64",
+    "v_reinterpret_as_s16",
+    "v_reinterpret_as_s32",
+    "v_reinterpret_as_s64",
+    "v_reinterpret_as_s8",
+    "v_reinterpret_as_u16",
+    "v_reinterpret_as_u32",
+    "v_reinterpret_as_u64",
+    "v_reinterpret_as_u8",
+    "v_reverse",
+    "v_rotate_left",
+    "v_rotate_right",
+    "v_round",
+    "v_rshr_pack",
+    "v_rshr_pack_store",
+    "v_rshr_pack_u",
+    "v_rshr_pack_u_store",
+    "v_scan_forward",
+    "v_select",
+    "v_setall_",
+    "v_setall_f32",
+    "v_setall_f64",
+    "v_setall_s16",
+    "v_setall_s32",
+    "v_setall_s64",
+    "v_setall_s8",
+    "v_setall_u16",
+    "v_setall_u32",
+    "v_setall_u64",
+    "v_setall_u8",
+    "v_setzero_",
+    "v_setzero_f32",
+    "v_setzero_f64",
+    "v_setzero_s16",
+    "v_setzero_s32",
+    "v_setzero_s64",
+    "v_setzero_s8",
+    "v_setzero_u16",
+    "v_setzero_u32",
+    "v_setzero_u64",
+    "v_setzero_u8",
+    "v_shl",
+    "v_shr",
+    "v_signmask",
+    "v_sin",
+    "v_sin_default_16f",
+    "v_sin_default_32f",
+    "v_sin_default_64f",
+    "v_sincos",
+    "v_sincos_default_16f",
+    "v_sincos_default_32f",
+    "v_sincos_default_64f",
+    "v_sqr_magnitude",
+    "v_sqrt",
+    "v_store",
+    "v_store_aligned",
+    "v_store_aligned_nocache",
+    "v_store_high",
+    "v_store_interleave",
+    "v_store_low",
+    "v_sub",
+    "v_sub_wrap",
+    "v_transpose4x4",
+    "v_trunc",
+    "v_uint16",
+    "v_uint16x8",
+    "v_uint32",
+    "v_uint32x4",
+    "v_uint64",
+    "v_uint64x2",
+    "v_uint8",
+    "v_uint8x16",
+    "v_xor",
+    "v_zip",
+    "vx_cleanup",
+    "vx_load",
+    "vx_load_aligned",
+    "vx_load_expand",
+    "vx_load_expand_q",
+    "vx_load_halves",
+    "vx_load_low",
+    "vx_lut",
+    "vx_lut_pairs",
+    "vx_lut_quads",
+    "vx_setall_f32",
+    "vx_setall_f64",
+    "vx_setall_s16",
+    "vx_setall_s32",
+    "vx_setall_s64",
+    "vx_setall_s8",
+    "vx_setall_u16",
+    "vx_setall_u32",
+    "vx_setall_u64",
+    "vx_setall_u8",
+    "vx_setzero_f32",
+    "vx_setzero_f64",
+    "vx_setzero_s16",
+    "vx_setzero_s32",
+    "vx_setzero_s64",
+    "vx_setzero_s8",
+    "vx_setzero_u16",
+    "vx_setzero_u32",
+    "vx_setzero_u64",
+    "vx_setzero_u8"
+  ],
+  "sse2": [
+    "v_select_si128",
+    "v_sign_epi64",
+    "v_srai_epi64"
+  ],
+  "fp16": [
+    "v_float16",
+    "v_float16x8",
+    "v_reinterpret_as_f16",
+    "v_setzero_f16",
+    "v_setall_f16",
+    "vx_setzero_f16",
+    "vx_setall_f16",
+    "v_cvt_f16"
+  ],
+  "legacy-adapters": [
+    "vx_store",
+    "vx_store_aligned"
+  ],
+  "gcc-memory-bridges": {
+    "v_load": [
+      "v_float32x4 (const float *)",
+      "v_float64x2 (const double *)",
+      "v_int16x8 (const short *)",
+      "v_int32x4 (const int *)",
+      "v_int64x2 (const int64 *)",
+      "v_int8x16 (const schar *)",
+      "v_uint16x8 (const ushort *)",
+      "v_uint32x4 (const unsigned int *)",
+      "v_uint64x2 (const uint64 *)",
+      "v_uint8x16 (const uchar *)"
+    ],
+    "v_load_aligned": [
+      "v_float32x4 (const float *)",
+      "v_float64x2 (const double *)",
+      "v_int16x8 (const short *)",
+      "v_int32x4 (const int *)",
+      "v_int64x2 (const int64 *)",
+      "v_int8x16 (const schar *)",
+      "v_uint16x8 (const ushort *)",
+      "v_uint32x4 (const unsigned int *)",
+      "v_uint64x2 (const uint64 *)",
+      "v_uint8x16 (const uchar *)"
+    ],
+    "v_load_deinterleave": [
+      "void (const double *, v_float64x2 &, v_float64x2 &)",
+      "void (const double *, v_float64x2 &, v_float64x2 &, v_float64x2 &)",
+      "void (const double *, v_float64x2 &, v_float64x2 &, v_float64x2 &, v_float64x2 &)",
+      "void (const float *, v_float32x4 &, v_float32x4 &)",
+      "void (const float *, v_float32x4 &, v_float32x4 &, v_float32x4 &)",
+      "void (const float *, v_float32x4 &, v_float32x4 &, v_float32x4 &, v_float32x4 &)",
+      "void (const int *, v_int32x4 &, v_int32x4 &)",
+      "void (const int *, v_int32x4 &, v_int32x4 &, v_int32x4 &)",
+      "void (const int *, v_int32x4 &, v_int32x4 &, v_int32x4 &, v_int32x4 &)",
+      "void (const int64 *, v_int64x2 &, v_int64x2 &)",
+      "void (const int64 *, v_int64x2 &, v_int64x2 &, v_int64x2 &)",
+      "void (const int64 *, v_int64x2 &, v_int64x2 &, v_int64x2 &, v_int64x2 &)",
+      "void (const schar *, v_int8x16 &, v_int8x16 &)",
+      "void (const schar *, v_int8x16 &, v_int8x16 &, v_int8x16 &)",
+      "void (const schar *, v_int8x16 &, v_int8x16 &, v_int8x16 &, v_int8x16 &)",
+      "void (const short *, v_int16x8 &, v_int16x8 &)",
+      "void (const short *, v_int16x8 &, v_int16x8 &, v_int16x8 &)",
+      "void (const short *, v_int16x8 &, v_int16x8 &, v_int16x8 &, v_int16x8 &)",
+      "void (const uchar *, v_uint8x16 &, v_uint8x16 &)",
+      "void (const uchar *, v_uint8x16 &, v_uint8x16 &, v_uint8x16 &)",
+      "void (const uchar *, v_uint8x16 &, v_uint8x16 &, v_uint8x16 &, v_uint8x16 &)",
+      "void (const uint64 *, v_uint64x2 &, v_uint64x2 &)",
+      "void (const uint64 *, v_uint64x2 &, v_uint64x2 &, v_uint64x2 &)",
+      "void (const uint64 *, v_uint64x2 &, v_uint64x2 &, v_uint64x2 &, v_uint64x2 &)",
+      "void (const unsigned int *, v_uint32x4 &, v_uint32x4 &)",
+      "void (const unsigned int *, v_uint32x4 &, v_uint32x4 &, v_uint32x4 &)",
+      "void (const unsigned int *, v_uint32x4 &, v_uint32x4 &, v_uint32x4 &, v_uint32x4 &)",
+      "void (const ushort *, v_uint16x8 &, v_uint16x8 &)",
+      "void (const ushort *, v_uint16x8 &, v_uint16x8 &, v_uint16x8 &)",
+      "void (const ushort *, v_uint16x8 &, v_uint16x8 &, v_uint16x8 &, v_uint16x8 &)"
+    ],
+    "v_load_expand": [
+      "v_float32x4 (const hfloat *)",
+      "v_int16x8 (const schar *)",
+      "v_int32x4 (const short *)",
+      "v_int64x2 (const int *)",
+      "v_uint16x8 (const uchar *)",
+      "v_uint32x4 (const ushort *)",
+      "v_uint64x2 (const uint *)",
+      "v_uint64x2 (const unsigned int *)"
+    ],
+    "v_load_expand_q": [
+      "v_int32x4 (const schar *)",
+      "v_uint32x4 (const uchar *)"
+    ],
+    "v_load_halves": [
+      "v_float32x4 (const float *, const float *)",
+      "v_float64x2 (const double *, const double *)",
+      "v_int16x8 (const short *, const short *)",
+      "v_int32x4 (const int *, const int *)",
+      "v_int64x2 (const int64 *, const int64 *)",
+      "v_int8x16 (const schar *, const schar *)",
+      "v_uint16x8 (const ushort *, const ushort *)",
+      "v_uint32x4 (const unsigned int *, const unsigned int *)",
+      "v_uint64x2 (const uint64 *, const uint64 *)",
+      "v_uint8x16 (const uchar *, const uchar *)"
+    ],
+    "v_load_low": [
+      "v_float32x4 (const float *)",
+      "v_float64x2 (const double *)",
+      "v_int16x8 (const short *)",
+      "v_int32x4 (const int *)",
+      "v_int64x2 (const int64 *)",
+      "v_int8x16 (const schar *)",
+      "v_uint16x8 (const ushort *)",
+      "v_uint32x4 (const unsigned int *)",
+      "v_uint64x2 (const uint64 *)",
+      "v_uint8x16 (const uchar *)"
+    ],
+    "v_lut": [
+      "v_float32x4 (const float *, const int *)",
+      "v_float32x4 (const float *, const v_int32x4 &)",
+      "v_float64x2 (const double *, const int *)",
+      "v_float64x2 (const double *, const v_int32x4 &)",
+      "v_int16x8 (const short *, const int *)",
+      "v_int32x4 (const int *, const int *)",
+      "v_int32x4 (const int *, const v_int32x4 &)",
+      "v_int64x2 (const int64_t *, const int *)",
+      "v_int8x16 (const schar *, const int *)",
+      "v_uint16x8 (const ushort *, const int *)",
+      "v_uint32x4 (const unsigned int *, const int *)",
+      "v_uint32x4 (const unsigned int *, const v_int32x4 &)",
+      "v_uint64x2 (const uint64_t *, const int *)",
+      "v_uint8x16 (const uchar *, const int *)"
+    ],
+    "v_lut_deinterleave": [
+      "void (const double *, const v_int32x4 &, v_float64x2 &, v_float64x2 &)",
+      "void (const float *, const v_int32x4 &, v_float32x4 &, v_float32x4 &)"
+    ],
+    "v_lut_pairs": [
+      "v_float32x4 (const float *, const int *)",
+      "v_float64x2 (const double *, const int *)",
+      "v_int16x8 (const short *, const int *)",
+      "v_int32x4 (const int *, const int *)",
+      "v_int64x2 (const int64_t *, const int *)",
+      "v_int8x16 (const schar *, const int *)",
+      "v_uint16x8 (const ushort *, const int *)",
+      "v_uint32x4 (const unsigned int *, const int *)",
+      "v_uint64x2 (const uint64_t *, const int *)",
+      "v_uint8x16 (const uchar *, const int *)"
+    ],
+    "v_lut_quads": [
+      "v_float32x4 (const float *, const int *)",
+      "v_int16x8 (const short *, const int *)",
+      "v_int32x4 (const int *, const int *)",
+      "v_int8x16 (const schar *, const int *)",
+      "v_uint16x8 (const ushort *, const int *)",
+      "v_uint32x4 (const unsigned int *, const int *)",
+      "v_uint8x16 (const uchar *, const int *)"
+    ],
+    "v_store": [
+      "void (double *, const v_float64x2 &)",
+      "void (double *, const v_float64x2 &, hal::StoreMode)",
+      "void (float *, const v_float32x4 &)",
+      "void (float *, const v_float32x4 &, hal::StoreMode)",
+      "void (int *, const v_int32x4 &)",
+      "void (int *, const v_int32x4 &, hal::StoreMode)",
+      "void (int64 *, const v_int64x2 &)",
+      "void (int64 *, const v_int64x2 &, hal::StoreMode)",
+      "void (schar *, const v_int8x16 &)",
+      "void (schar *, const v_int8x16 &, hal::StoreMode)",
+      "void (short *, const v_int16x8 &)",
+      "void (short *, const v_int16x8 &, hal::StoreMode)",
+      "void (uchar *, const v_uint8x16 &)",
+      "void (uchar *, const v_uint8x16 &, hal::StoreMode)",
+      "void (uint64 *, const v_uint64x2 &)",
+      "void (uint64 *, const v_uint64x2 &, hal::StoreMode)",
+      "void (unsigned int *, const v_uint32x4 &)",
+      "void (unsigned int *, const v_uint32x4 &, hal::StoreMode)",
+      "void (ushort *, const v_uint16x8 &)",
+      "void (ushort *, const v_uint16x8 &, hal::StoreMode)"
+    ],
+    "v_store_aligned": [
+      "void (double *, const v_float64x2 &)",
+      "void (float *, const v_float32x4 &)",
+      "void (int *, const v_int32x4 &)",
+      "void (int64 *, const v_int64x2 &)",
+      "void (schar *, const v_int8x16 &)",
+      "void (short *, const v_int16x8 &)",
+      "void (uchar *, const v_uint8x16 &)",
+      "void (uint64 *, const v_uint64x2 &)",
+      "void (unsigned int *, const v_uint32x4 &)",
+      "void (ushort *, const v_uint16x8 &)"
+    ],
+    "v_store_aligned_nocache": [
+      "void (double *, const v_float64x2 &)",
+      "void (float *, const v_float32x4 &)",
+      "void (int *, const v_int32x4 &)",
+      "void (int64 *, const v_int64x2 &)",
+      "void (schar *, const v_int8x16 &)",
+      "void (short *, const v_int16x8 &)",
+      "void (uchar *, const v_uint8x16 &)",
+      "void (uint64 *, const v_uint64x2 &)",
+      "void (unsigned int *, const v_uint32x4 &)",
+      "void (ushort *, const v_uint16x8 &)"
+    ],
+    "v_store_high": [
+      "void (double *, const v_float64x2 &)",
+      "void (float *, const v_float32x4 &)",
+      "void (int *, const v_int32x4 &)",
+      "void (int64 *, const v_int64x2 &)",
+      "void (schar *, const v_int8x16 &)",
+      "void (short *, const v_int16x8 &)",
+      "void (uchar *, const v_uint8x16 &)",
+      "void (uint64 *, const v_uint64x2 &)",
+      "void (unsigned int *, const v_uint32x4 &)",
+      "void (ushort *, const v_uint16x8 &)"
+    ],
+    "v_store_interleave": [
+      "void (double *, const v_float64x2 &, const v_float64x2 &, const v_float64x2 &, const v_float64x2 &, hal::StoreMode)",
+      "void (double *, const v_float64x2 &, const v_float64x2 &, const v_float64x2 &, hal::StoreMode)",
+      "void (double *, const v_float64x2 &, const v_float64x2 &, hal::StoreMode)",
+      "void (float *, const v_float32x4 &, const v_float32x4 &, const v_float32x4 &, const v_float32x4 &, hal::StoreMode)",
+      "void (float *, const v_float32x4 &, const v_float32x4 &, const v_float32x4 &, hal::StoreMode)",
+      "void (float *, const v_float32x4 &, const v_float32x4 &, hal::StoreMode)",
+      "void (int *, const v_int32x4 &, const v_int32x4 &, const v_int32x4 &, const v_int32x4 &, hal::StoreMode)",
+      "void (int *, const v_int32x4 &, const v_int32x4 &, const v_int32x4 &, hal::StoreMode)",
+      "void (int *, const v_int32x4 &, const v_int32x4 &, hal::StoreMode)",
+      "void (int64 *, const v_int64x2 &, const v_int64x2 &, const v_int64x2 &, const v_int64x2 &, hal::StoreMode)",
+      "void (int64 *, const v_int64x2 &, const v_int64x2 &, const v_int64x2 &, hal::StoreMode)",
+      "void (int64 *, const v_int64x2 &, const v_int64x2 &, hal::StoreMode)",
+      "void (schar *, const v_int8x16 &, const v_int8x16 &, const v_int8x16 &, const v_int8x16 &, hal::StoreMode)",
+      "void (schar *, const v_int8x16 &, const v_int8x16 &, const v_int8x16 &, hal::StoreMode)",
+      "void (schar *, const v_int8x16 &, const v_int8x16 &, hal::StoreMode)",
+      "void (short *, const v_int16x8 &, const v_int16x8 &, const v_int16x8 &, const v_int16x8 &, hal::StoreMode)",
+      "void (short *, const v_int16x8 &, const v_int16x8 &, const v_int16x8 &, hal::StoreMode)",
+      "void (short *, const v_int16x8 &, const v_int16x8 &, hal::StoreMode)",
+      "void (uchar *, const v_uint8x16 &, const v_uint8x16 &, const v_uint8x16 &, const v_uint8x16 &, hal::StoreMode)",
+      "void (uchar *, const v_uint8x16 &, const v_uint8x16 &, const v_uint8x16 &, hal::StoreMode)",
+      "void (uchar *, const v_uint8x16 &, const v_uint8x16 &, hal::StoreMode)",
+      "void (uint64 *, const v_uint64x2 &, const v_uint64x2 &, const v_uint64x2 &, const v_uint64x2 &, hal::StoreMode)",
+      "void (uint64 *, const v_uint64x2 &, const v_uint64x2 &, const v_uint64x2 &, hal::StoreMode)",
+      "void (uint64 *, const v_uint64x2 &, const v_uint64x2 &, hal::StoreMode)",
+      "void (unsigned int *, const v_uint32x4 &, const v_uint32x4 &, const v_uint32x4 &, const v_uint32x4 &, hal::StoreMode)",
+      "void (unsigned int *, const v_uint32x4 &, const v_uint32x4 &, const v_uint32x4 &, hal::StoreMode)",
+      "void (unsigned int *, const v_uint32x4 &, const v_uint32x4 &, hal::StoreMode)",
+      "void (ushort *, const v_uint16x8 &, const v_uint16x8 &, const v_uint16x8 &, const v_uint16x8 &, hal::StoreMode)",
+      "void (ushort *, const v_uint16x8 &, const v_uint16x8 &, const v_uint16x8 &, hal::StoreMode)",
+      "void (ushort *, const v_uint16x8 &, const v_uint16x8 &, hal::StoreMode)"
+    ],
+    "v_store_low": [
+      "void (double *, const v_float64x2 &)",
+      "void (float *, const v_float32x4 &)",
+      "void (int *, const v_int32x4 &)",
+      "void (int64 *, const v_int64x2 &)",
+      "void (schar *, const v_int8x16 &)",
+      "void (short *, const v_int16x8 &)",
+      "void (uchar *, const v_uint8x16 &)",
+      "void (uint64 *, const v_uint64x2 &)",
+      "void (unsigned int *, const v_uint32x4 &)",
+      "void (ushort *, const v_uint16x8 &)"
+    ],
+    "vx_load": [
+      "v_float32 (const float *)",
+      "v_float64 (const double *)",
+      "v_int16 (const short *)",
+      "v_int32 (const int *)",
+      "v_int64 (const int64 *)",
+      "v_int8 (const schar *)",
+      "v_uint16 (const ushort *)",
+      "v_uint32 (const unsigned int *)",
+      "v_uint64 (const uint64 *)",
+      "v_uint8 (const uchar *)"
+    ],
+    "vx_load_aligned": [
+      "v_float32 (const float *)",
+      "v_float64 (const double *)",
+      "v_int16 (const short *)",
+      "v_int32 (const int *)",
+      "v_int64 (const int64 *)",
+      "v_int8 (const schar *)",
+      "v_uint16 (const ushort *)",
+      "v_uint32 (const unsigned int *)",
+      "v_uint64 (const uint64 *)",
+      "v_uint8 (const uchar *)"
+    ],
+    "vx_load_expand": [
+      "v_float32 (const bfloat *)",
+      "v_float32 (const hfloat *)",
+      "v_int16 (const schar *)",
+      "v_int32 (const short *)",
+      "v_int64 (const int *)",
+      "v_uint16 (const uchar *)",
+      "v_uint32 (const ushort *)",
+      "v_uint64 (const unsigned int *)"
+    ],
+    "vx_load_expand_q": [
+      "v_int32 (const schar *)",
+      "v_uint32 (const uchar *)"
+    ],
+    "vx_load_halves": [
+      "v_float32 (const float *, const float *)",
+      "v_float64 (const double *, const double *)",
+      "v_int16 (const short *, const short *)",
+      "v_int32 (const int *, const int *)",
+      "v_int64 (const int64 *, const int64 *)",
+      "v_int8 (const schar *, const schar *)",
+      "v_uint16 (const ushort *, const ushort *)",
+      "v_uint32 (const unsigned int *, const unsigned int *)",
+      "v_uint64 (const uint64 *, const uint64 *)",
+      "v_uint8 (const uchar *, const uchar *)"
+    ],
+    "vx_load_low": [
+      "v_float32 (const float *)",
+      "v_float64 (const double *)",
+      "v_int16 (const short *)",
+      "v_int32 (const int *)",
+      "v_int64 (const int64 *)",
+      "v_int8 (const schar *)",
+      "v_uint16 (const ushort *)",
+      "v_uint32 (const unsigned int *)",
+      "v_uint64 (const uint64 *)",
+      "v_uint8 (const uchar *)"
+    ]
+  },
+  "emulated": [
+    "v_hsum",
+    "v_minmax",
+    "v_reg",
+    "v_reinterpret_as_int",
+    "v_reinterpret_as_uint",
+    "v_rshr"
+  ],
+  "broadcast-adapters": [
+    "v_setall",
+    "vx_setall"
+  ],
+  "emulated-enums": [
+    "simd128_width",
+    "simdmax_width"
+  ]
+}
diff --git a/port/config/module-dependencies.json b/port/config/module-dependencies.json
new file mode 100644
index 0000000..8c6f7cc
--- /dev/null
+++ b/port/config/module-dependencies.json
@@ -0,0 +1,62 @@
+{
+  "calib": [
+    "flann",
+    "geometry",
+    "imgproc",
+    "objdetect",
+    "stereo"
+  ],
+  "core": [],
+  "dnn": [
+    "geometry",
+    "imgproc"
+  ],
+  "features": [
+    "geometry",
+    "imgproc"
+  ],
+  "flann": [],
+  "geometry": [
+    "flann"
+  ],
+  "highgui": [
+    "imgproc"
+  ],
+  "imgcodecs": [
+    "imgproc"
+  ],
+  "imgproc": [
+    "geometry"
+  ],
+  "objdetect": [
+    "features",
+    "geometry",
+    "imgproc"
+  ],
+  "photo": [
+    "geometry",
+    "imgproc"
+  ],
+  "ptcloud": [
+    "flann",
+    "geometry",
+    "imgproc"
+  ],
+  "stereo": [
+    "geometry",
+    "imgproc"
+  ],
+  "stitching": [
+    "features",
+    "flann",
+    "geometry",
+    "imgproc"
+  ],
+  "video": [
+    "imgproc"
+  ],
+  "videoio": [
+    "imgcodecs",
+    "imgproc"
+  ]
+}
diff --git a/port/config/modules.txt b/port/config/modules.txt
new file mode 100644
index 0000000..bc73448
--- /dev/null
+++ b/port/config/modules.txt
@@ -0,0 +1,16 @@
+calib
+core
+dnn
+features
+flann
+geometry
+highgui
+imgcodecs
+imgproc
+objdetect
+photo
+ptcloud
+stereo
+stitching
+video
+videoio
diff --git a/port/config/platforms.json b/port/config/platforms.json
new file mode 100644
index 0000000..2ad66f5
--- /dev/null
+++ b/port/config/platforms.json
@@ -0,0 +1,1445 @@
+{
+  "build": {
+    "jobs": 6,
+    "sources": [
+      "src/opencv.cppm",
+      "src/macros.cppm",
+      "src/cv.cppm",
+      "src/core.cppm",
+      "src/imgproc.cppm",
+      "src/imgcodecs.cppm",
+      "src/videoio.cppm",
+      "src/highgui.cppm",
+      "src/flann.cppm",
+      "src/geometry.cppm"
+    ],
+    "include_dirs": [
+      "port/include",
+      "generated/common",
+      "upstream/opencv",
+      "upstream/opencv/3rdparty/dlpack/include",
+      "upstream/opencv/3rdparty/libjpeg-turbo/src",
+      "upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm",
+      "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64",
+      "upstream/opencv/3rdparty/zlib",
+      "upstream/opencv/modules/core/include",
+      "upstream/opencv/modules/flann/include",
+      "upstream/opencv/modules/geometry/include",
+      "upstream/opencv/modules/imgproc/include",
+      "upstream/opencv/3rdparty/mlas/inc",
+      "upstream/opencv/3rdparty/mlas/lib",
+      "upstream/opencv/modules/dnn/include",
+      "upstream/opencv/modules/dnn/misc/caffe",
+      "upstream/opencv/modules/dnn/misc/tensorflow",
+      "upstream/opencv/modules/dnn/misc/onnx",
+      "upstream/opencv/modules/dnn/misc/tflite",
+      "upstream/opencv/3rdparty/flatbuffers/include",
+      "upstream/opencv/3rdparty/protobuf/src",
+      "upstream/opencv/3rdparty/libpng",
+      "upstream/opencv/modules/imgcodecs/include",
+      "upstream/opencv/modules/videoio/include",
+      "upstream/opencv/modules/highgui/include"
+    ]
+  },
+  "target": {
+    "cfg(unix)": {
+      "build": {
+        "flags": [
+          {
+            "glob": "**/modules/core/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "HAVE_UNISTD_H=1",
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/modules/flann/**",
+            "defines": [
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/modules/geometry/**",
+            "defines": [
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/modules/highgui/**",
+            "defines": [
+              "ENABLE_PLUGINS",
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/modules/imgcodecs/**",
+            "defines": [
+              "HAVE_IMGCODEC_HDR",
+              "HAVE_IMGCODEC_PFM",
+              "HAVE_IMGCODEC_PXM",
+              "HAVE_IMGCODEC_SUNRASTER",
+              "HAVE_STDARG_H=1",
+              "HAVE_UNISTD_H=1",
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/modules/imgproc/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "HAVE_UNISTD_H=1",
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/3rdparty/libjpeg-turbo/**",
+            "defines": [
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV"
+            ]
+          },
+          {
+            "glob": "**/tu/jpeg12/**",
+            "defines": [
+              "BITS_IN_JSAMPLE=12",
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV"
+            ]
+          },
+          {
+            "glob": "**/tu/jpeg16/**",
+            "defines": [
+              "BITS_IN_JSAMPLE=16",
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV"
+            ]
+          },
+          {
+            "glob": "**/3rdparty/libpng/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "HAVE_UNISTD_H=1",
+              "NDEBUG"
+            ]
+          },
+          {
+            "glob": "**/modules/videoio/**",
+            "defines": [
+              "ENABLE_PLUGINS",
+              "HAVE_FFMPEG",
+              "HAVE_FFMPEG_LIBAVDEVICE",
+              "NDEBUG",
+              "_USE_MATH_DEFINES",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "**/3rdparty/zlib/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "HAVE_UNISTD_H=1",
+              "NDEBUG"
+            ]
+          },
+          {
+            "glob": "upstream/opencv/modules/core/src/alloc.cpp",
+            "defines": [
+              "HAVE_POSIX_MEMALIGN=1"
+            ]
+          },
+          {
+            "glob": "upstream/opencv/modules/core/src/parallel/parallel.cpp",
+            "defines": [
+              "PARALLEL_ENABLE_PLUGINS=1"
+            ]
+          },
+          {
+            "glob": "upstream/opencv/modules/core/src/system.cpp",
+            "defines": [
+              "HAVE_GETAUXVAL=1"
+            ]
+          }
+        ]
+      }
+    },
+    "cfg(linux)": {
+      "build": {
+        "cflags": [
+          "-w",
+          "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
+          "-DPNG_INTEL_SSE_OPT=1",
+          "-DHAVE_CAMV4L2",
+          "-DHAVE_MALLOC_H=1",
+          "-DHAVE_MEMALIGN=1",
+          "-DHAVE_FLATBUFFERS=1"
+        ],
+        "cxxflags": [
+          "-w",
+          "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
+          "-DPNG_INTEL_SSE_OPT=1",
+          "-DHAVE_CAMV4L2",
+          "-DHAVE_MALLOC_H=1",
+          "-DHAVE_MEMALIGN=1",
+          "-DHAVE_FLATBUFFERS=1"
+        ],
+        "ldflags": [
+          "-lpthread",
+          "-ldl"
+        ],
+        "sources": [
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c",
+          "upstream/opencv/3rdparty/libjpeg-turbo/src/{jaricom,jcapimin,jcapistd,jcarith,jccoefct,jccolor,jcdctmgr,jcdiffct,jchuff,jcicc,jcinit,jclhuff,jclossls,jcmainct,jcmarker,jcmaster,jcomapi,jcparam,jcphuff,jcprepct,jcsample,jctrans,jdapimin,jdapistd,jdarith,jdatadst,jdatasrc,jdcoefct,jdcolor,jddctmgr,jddiffct,jdhuff,jdicc,jdinput,jdlhuff,jdlossls,jdmainct,jdmarker,jdmaster,jdmerge,jdphuff,jdpostct,jdsample,jdtrans,jerror,jfdctflt,jfdctfst,jfdctint,jidctflt,jidctfst,jidctint,jidctred,jmemmgr,jmemnobs,jpeg_nbits,jquant1,jquant2,jutils}.c",
+          "upstream/opencv/3rdparty/libpng/*.c",
+          "upstream/opencv/3rdparty/libpng/intel/*.c",
+          "upstream/opencv/3rdparty/zlib/*.c",
+          "upstream/opencv/modules/core/src/*.cpp",
+          "upstream/opencv/modules/core/src/opencl/runtime/*.cpp",
+          "upstream/opencv/modules/core/src/parallel/*.cpp",
+          "upstream/opencv/modules/core/src/utils/*.cpp",
+          "upstream/opencv/modules/flann/src/*.cpp",
+          "upstream/opencv/modules/geometry/src/*.cpp",
+          "upstream/opencv/modules/geometry/src/ptcloud/*.cpp",
+          "upstream/opencv/modules/geometry/src/usac/*.cpp",
+          "upstream/opencv/modules/highgui/src/{backend,roiSelector,window}.cpp",
+          "upstream/opencv/modules/imgcodecs/src/*.cpp",
+          "upstream/opencv/modules/imgproc/src/{accum,accum.dispatch,bilateral_filter.dispatch,blend,box_filter.dispatch,canny,clahe,color,color_hsv.dispatch,color_lab,color_rgb.dispatch,color_yuv.dispatch,colormap,connectedcomponents,contours_approx,contours_common,contours_link,contours_new,contours_truco,corner,corner.avx,cornersubpix,demosaicing,deriv,distransform,drawing,drawing_text,emd_new,filter.dispatch,fisheye,floodfill,gabor,generalized_hough,grabcut,histogram,hough,imgwarp,imgwarp.avx2,imgwarp.sse4_1,lsd,main,median_blur.dispatch,morph.dispatch,phasecorr,phasecorr_iterative,pyramids,resize,resize.avx2,resize.sse4_1,samplers,segmentation,smooth.dispatch,spatialgradient,stackblur,stb_truetype,sumpixels.dispatch,tables,templmatch,thresh,undistort.dispatch,utils}.cpp",
+          "upstream/opencv/modules/videoio/src/{backend_plugin,backend_static,cap,cap_ffmpeg,cap_images,cap_mjpeg_decoder,cap_mjpeg_encoder,cap_v4l,container_avi,videoio_registry}.cpp",
+          "generated/common/modules/core/{arithm.avx2,arithm.sse4_1,convert.avx2,convert_scale.avx2,count_non_zero.avx2,has_non_zero.avx2,mathfuncs_core.avx,mathfuncs_core.avx2,matmul.avx2,matmul.avx512_skx,matmul.sse4_1,mean.avx2,merge.avx2,minmax.avx2,minmax.sse4_1,nan_mask.avx2,norm.avx,norm.avx2,norm.sse4_1,reduce.avx2,split.avx2,stat.avx2,stat.sse4_2,sum.avx2,transpose.avx,transpose.avx2}.cpp",
+          "generated/common/modules/imgproc/{accum.avx,accum.avx2,accum.sse4_1,bilateral_filter.avx2,bilateral_filter.avx512_skx,box_filter.avx2,box_filter.avx512_skx,box_filter.sse4_1,color_hsv.avx2,color_hsv.sse4_1,color_rgb.avx2,color_rgb.sse4_1,color_yuv.avx2,color_yuv.sse4_1,filter.avx2,filter.sse4_1,median_blur.avx2,median_blur.avx512_skx,median_blur.sse4_1,morph.avx2,morph.sse4_1,smooth.avx2,smooth.sse4_1,sumpixels.avx2,sumpixels.avx512_skx,undistort.avx2,warp_kernels.avx2,warp_kernels.sse4_1}.cpp",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c"
+        ],
+        "flags": [
+          {
+            "glob": "upstream/opencv/**/*.asm",
+            "defines": [
+              "ELF",
+              "NO_GETENV",
+              "NO_PUTENV",
+              "PIC",
+              "__CET__",
+              "__x86_64__"
+            ]
+          },
+          {
+            "glob": "**/modules/core/**/*.avx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX"
+            ]
+          },
+          {
+            "glob": "**/modules/core/**/*.avx2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX2"
+            ]
+          },
+          {
+            "glob": "**/modules/core/**/*.avx512_skx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma",
+              "-mavx512f",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512vl",
+              "-mavx512bw",
+              "-mavx512dq"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX512_COMMON=1",
+              "CV_CPU_COMPILE_AVX512_SKX=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_AVX_512F=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+            ]
+          },
+          {
+            "glob": "**/modules/core/**/*.sse4_1.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_1"
+            ]
+          },
+          {
+            "glob": "**/modules/core/**/*.sse4_2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_2"
+            ]
+          },
+          {
+            "glob": "**/modules/imgproc/**/*.avx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX"
+            ]
+          },
+          {
+            "glob": "**/modules/imgproc/**/*.avx2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX2"
+            ]
+          },
+          {
+            "glob": "**/modules/imgproc/**/*.avx512_skx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma",
+              "-mavx512f",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512vl",
+              "-mavx512bw",
+              "-mavx512dq"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX512_COMMON=1",
+              "CV_CPU_COMPILE_AVX512_SKX=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_AVX_512F=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+            ]
+          },
+          {
+            "glob": "**/modules/imgproc/**/*.sse4_1.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_1"
+            ]
+          },
+          {
+            "glob": "upstream/opencv/**",
+            "cflags": [
+              "-msse3"
+            ],
+            "cxxflags": [
+              "-msse3"
+            ]
+          },
+          {
+            "glob": "generated/**",
+            "cflags": [
+              "-msse3"
+            ],
+            "cxxflags": [
+              "-msse3"
+            ]
+          }
+        ]
+      }
+    },
+    "cfg(macos)": {
+      "build": {
+        "cflags": [
+          "-w",
+          "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int",
+          "-DHAVE_STDARG_H=1",
+          "-DHAVE_UNISTD_H=1",
+          "-DNEON_INTRINSICS",
+          "-DPNG_ARM_NEON_OPT=2"
+        ],
+        "cxxflags": [
+          "-w",
+          "-DOPENCV_ALLOCATOR_STATS_COUNTER_TYPE=int",
+          "-DHAVE_STDARG_H=1",
+          "-DHAVE_UNISTD_H=1",
+          "-DNEON_INTRINSICS",
+          "-DPNG_ARM_NEON_OPT=2"
+        ],
+        "ldflags": [
+          "-lpthread",
+          "-ldl"
+        ],
+        "sources": [
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/{jccolor-neon,jcgray-neon,jcphuff-neon,jcsample-neon,jdcolor-neon,jdmerge-neon,jdsample-neon,jfdctfst-neon,jfdctint-neon,jidctfst-neon,jidctint-neon,jidctred-neon,jquanti-neon}.c",
+          "upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/{jchuff-neon,jsimd}.c",
+          "upstream/opencv/3rdparty/libjpeg-turbo/src/{jaricom,jcapimin,jcapistd,jcarith,jccoefct,jccolor,jcdctmgr,jcdiffct,jchuff,jcicc,jcinit,jclhuff,jclossls,jcmainct,jcmarker,jcmaster,jcomapi,jcparam,jcphuff,jcprepct,jcsample,jctrans,jdapimin,jdapistd,jdarith,jdatadst,jdatasrc,jdcoefct,jdcolor,jddctmgr,jddiffct,jdhuff,jdicc,jdinput,jdlhuff,jdlossls,jdmainct,jdmarker,jdmaster,jdmerge,jdphuff,jdpostct,jdsample,jdtrans,jerror,jfdctflt,jfdctfst,jfdctint,jidctflt,jidctfst,jidctint,jidctred,jmemmgr,jmemnobs,jpeg_nbits,jquant1,jquant2,jutils}.c",
+          "upstream/opencv/3rdparty/libpng/*.c",
+          "upstream/opencv/3rdparty/libpng/arm/filter_neon.S",
+          "upstream/opencv/3rdparty/libpng/arm/*.c",
+          "upstream/opencv/3rdparty/zlib/*.c",
+          "upstream/opencv/modules/core/src/*.cpp",
+          "upstream/opencv/modules/core/src/opencl/runtime/*.cpp",
+          "upstream/opencv/modules/core/src/parallel/*.cpp",
+          "upstream/opencv/modules/core/src/utils/*.cpp",
+          "upstream/opencv/modules/flann/src/*.cpp",
+          "upstream/opencv/modules/geometry/src/*.cpp",
+          "upstream/opencv/modules/geometry/src/ptcloud/*.cpp",
+          "upstream/opencv/modules/geometry/src/usac/*.cpp",
+          "upstream/opencv/modules/highgui/src/{backend,roiSelector,window}.cpp",
+          "upstream/opencv/modules/imgcodecs/src/*.cpp",
+          "upstream/opencv/modules/imgproc/src/{accum,accum.dispatch,bilateral_filter.dispatch,blend,box_filter.dispatch,canny,clahe,color,color_hsv.dispatch,color_lab,color_rgb.dispatch,color_yuv.dispatch,colormap,connectedcomponents,contours_approx,contours_common,contours_link,contours_new,contours_truco,corner,cornersubpix,demosaicing,deriv,distransform,drawing,drawing_text,emd_new,filter.dispatch,fisheye,floodfill,gabor,generalized_hough,grabcut,histogram,hough,imgwarp,lsd,main,median_blur.dispatch,morph.dispatch,phasecorr,phasecorr_iterative,pyramids,resize,samplers,segmentation,smooth.dispatch,spatialgradient,stackblur,stb_truetype,sumpixels.dispatch,tables,templmatch,thresh,undistort.dispatch,utils}.cpp",
+          "upstream/opencv/modules/videoio/src/{backend_plugin,backend_static,cap,cap_ffmpeg,cap_images,cap_mjpeg_decoder,cap_mjpeg_encoder,container_avi,videoio_registry}.cpp",
+          "generated/common/modules/core/transpose.neon.cpp",
+          "generated/common/modules/imgproc/warp_kernels.neon.cpp",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c",
+          "generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c",
+          "generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c"
+        ],
+        "flags": [
+          {
+            "glob": "generated/common/modules/core/transpose.neon.cpp",
+            "defines": [
+              "CV_CPU_DISPATCH_MODE=NEON"
+            ]
+          },
+          {
+            "glob": "generated/common/modules/imgproc/warp_kernels.neon.cpp",
+            "defines": [
+              "CV_CPU_DISPATCH_MODE=NEON"
+            ]
+          }
+        ]
+      }
+    },
+    "cfg(windows)": {
+      "build": {
+        "cflags": [
+          "-w"
+        ],
+        "cxxflags": [
+          "-w"
+        ],
+        "ldflags": [
+          "-lole32"
+        ],
+        "sources": [
+          "generated/windows/tu/w/**/*.{c,cc,cpp,asm}"
+        ],
+        "flags": [
+          {
+            "glob": "generated/windows/tu/w/core/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "NDEBUG",
+              "OPENCV_ALLOCATOR_STATS_COUNTER_TYPE=long long",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/flann/**",
+            "defines": [
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/geometry/**",
+            "defines": [
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/highgui/**",
+            "defines": [
+              "ENABLE_PLUGINS",
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgcodecs/**",
+            "defines": [
+              "HAVE_IMGCODEC_HDR",
+              "HAVE_IMGCODEC_PFM",
+              "HAVE_IMGCODEC_PXM",
+              "HAVE_IMGCODEC_SUNRASTER",
+              "HAVE_STDARG_H=1",
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgproc/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/libjpeg-turbo/**",
+            "defines": [
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/jpeg12/**",
+            "defines": [
+              "BITS_IN_JSAMPLE=12",
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/jpeg16/**",
+            "defines": [
+              "BITS_IN_JSAMPLE=16",
+              "NDEBUG",
+              "NO_GETENV",
+              "NO_PUTENV",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/libpng/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "NDEBUG",
+              "PNG_INTEL_SSE_OPT=1",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/videoio/**",
+            "defines": [
+              "ENABLE_PLUGINS",
+              "HAVE_FFMPEG",
+              "NDEBUG",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_USE_MATH_DEFINES",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS",
+              "__OPENCV_BUILD=1",
+              "__STDC_CONSTANT_MACROS",
+              "__STDC_FORMAT_MACROS",
+              "__STDC_LIMIT_MACROS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/zlib/**",
+            "defines": [
+              "HAVE_STDARG_H=1",
+              "NDEBUG",
+              "NO_FSEEKO",
+              "WIN32",
+              "_CRT_NONSTDC_NO_DEPRECATE",
+              "_CRT_SECURE_NO_DEPRECATE",
+              "_SCL_SECURE_NO_WARNINGS",
+              "_VARIADIC_MAX=10",
+              "_WIN32_WINNT=0x0601",
+              "_WINDOWS"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/**/*.avx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/**/*.avx2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX2"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/**/*.avx512_skx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma",
+              "-mavx512f",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512vl",
+              "-mavx512bw",
+              "-mavx512dq"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX512_COMMON=1",
+              "CV_CPU_COMPILE_AVX512_SKX=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_AVX_512F=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/**/*.sse4_1.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_1"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/**/*.sse4_2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_2"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgproc/**/*.avx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgproc/**/*.avx2.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX2"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgproc/**/*.avx512_skx.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1",
+              "-mpopcnt",
+              "-msse4.2",
+              "-mavx",
+              "-mf16c",
+              "-mavx2",
+              "-mfma",
+              "-mavx512f",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512f",
+              "-mavx512cd",
+              "-mavx512vl",
+              "-mavx512bw",
+              "-mavx512dq"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_AVX2=1",
+              "CV_CPU_COMPILE_AVX512_COMMON=1",
+              "CV_CPU_COMPILE_AVX512_SKX=1",
+              "CV_CPU_COMPILE_AVX=1",
+              "CV_CPU_COMPILE_AVX_512F=1",
+              "CV_CPU_COMPILE_FMA3=1",
+              "CV_CPU_COMPILE_FP16=1",
+              "CV_CPU_COMPILE_POPCNT=1",
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSE4_2=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/imgproc/**/*.sse4_1.cpp",
+            "cxxflags": [
+              "-mssse3",
+              "-msse4.1"
+            ],
+            "defines": [
+              "CV_CPU_COMPILE_SSE4_1=1",
+              "CV_CPU_COMPILE_SSSE3=1",
+              "CV_CPU_DISPATCH_MODE=SSE4_1"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp",
+            "defines": [
+              "HAVE_MALLOC_H=1",
+              "HAVE_WIN32_ALIGNED_MALLOC=1"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp",
+            "defines": [
+              "DEBUG_POSTFIX=d",
+              "PARALLEL_ENABLE_PLUGINS=1"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp",
+            "defines": [
+              "DEBUG_POSTFIX=d"
+            ]
+          },
+          {
+            "glob": "generated/windows/tu/**",
+            "cflags": [
+              "-msse3"
+            ],
+            "cxxflags": [
+              "-msse3"
+            ]
+          }
+        ]
+      }
+    },
+    "x86_64-linux-musl": {
+      "linkage": "static"
+    }
+  },
+  "dnn": {
+    "defines": [
+      "HAVE_OPENCV_DNN"
+    ],
+    "sources": [
+      "src/dnn.cppm"
+    ],
+    "flags": [
+      {
+        "glob": "**/modules/dnn/**",
+        "defines": [
+          "ENABLE_PLUGINS",
+          "HAVE_MLAS=1",
+          "HAVE_PROTOBUF=1",
+          "NDEBUG",
+          "_USE_MATH_DEFINES",
+          "__OPENCV_BUILD=1",
+          "__STDC_CONSTANT_MACROS",
+          "__STDC_FORMAT_MACROS",
+          "__STDC_LIMIT_MACROS"
+        ]
+      },
+      {
+        "glob": "**/3rdparty/mlas/**",
+        "defines": [
+          "BUILD_MLAS_NO_ONNXRUNTIME=1",
+          "MLAS_GEMM_ONLY=1",
+          "MLAS_OPENCV_THREADING=1",
+          "NDEBUG",
+          "_GNU_SOURCE=1",
+          "_USE_MATH_DEFINES",
+          "__STDC_CONSTANT_MACROS",
+          "__STDC_FORMAT_MACROS",
+          "__STDC_LIMIT_MACROS"
+        ]
+      },
+      {
+        "glob": "**/tu/mlasgemm/**",
+        "defines": [
+          "BUILD_MLAS_NO_ONNXRUNTIME=1",
+          "MLAS_GEMM_ONLY=1",
+          "MLAS_OPENCV_THREADING=1",
+          "NDEBUG",
+          "_USE_MATH_DEFINES",
+          "__STDC_CONSTANT_MACROS",
+          "__STDC_FORMAT_MACROS",
+          "__STDC_LIMIT_MACROS"
+        ]
+      },
+      {
+        "glob": "**/3rdparty/protobuf/**",
+        "defines": [
+          "HAVE_PTHREAD=1",
+          "NDEBUG"
+        ]
+      },
+      {
+        "glob": "**/modules/dnn/**/*.avx.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX"
+        ]
+      },
+      {
+        "glob": "**/modules/dnn/**/*.avx2.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx",
+          "-mf16c",
+          "-mavx2",
+          "-mfma"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX2=1",
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_FMA3=1",
+          "CV_CPU_COMPILE_FP16=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX2"
+        ]
+      },
+      {
+        "glob": "**/modules/dnn/**/*.avx512_skx.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx",
+          "-mf16c",
+          "-mavx2",
+          "-mfma",
+          "-mavx512f",
+          "-mavx512f",
+          "-mavx512cd",
+          "-mavx512f",
+          "-mavx512cd",
+          "-mavx512vl",
+          "-mavx512bw",
+          "-mavx512dq"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX2=1",
+          "CV_CPU_COMPILE_AVX512_COMMON=1",
+          "CV_CPU_COMPILE_AVX512_SKX=1",
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_AVX_512F=1",
+          "CV_CPU_COMPILE_FMA3=1",
+          "CV_CPU_COMPILE_FP16=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+        ]
+      },
+      {
+        "glob": "upstream/opencv/3rdparty/mlas/lib/platform.cpp",
+        "cxxflags": [
+          "-include",
+          "unistd.h"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/int8layers/layers_common.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/activation_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/conv2_depthwise.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/conv2_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/conv_block.neon_fp16.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON_FP16"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/conv_winograd_f63.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/fast_gemm_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/gridsample_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/nary_eltwise_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/reduce2_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/cpu_kernels/transpose_kernels.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/common/modules/dnn/layers/layers_common.neon.cpp",
+        "defines": [
+          "CV_CPU_DISPATCH_MODE=NEON"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/dnn/**",
+        "defines": [
+          "ENABLE_PLUGINS",
+          "HAVE_PROTOBUF=1",
+          "NDEBUG",
+          "WIN32",
+          "_CRT_NONSTDC_NO_DEPRECATE",
+          "_CRT_SECURE_NO_DEPRECATE",
+          "_CRT_SECURE_NO_WARNINGS=1",
+          "_SCL_SECURE_NO_WARNINGS",
+          "_USE_MATH_DEFINES",
+          "_VARIADIC_MAX=10",
+          "_WIN32_WINNT=0x0601",
+          "_WINDOWS",
+          "__OPENCV_BUILD=1",
+          "__STDC_CONSTANT_MACROS",
+          "__STDC_FORMAT_MACROS",
+          "__STDC_LIMIT_MACROS"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/protobuf/**",
+        "defines": [
+          "NDEBUG",
+          "WIN32",
+          "_CRT_NONSTDC_NO_DEPRECATE",
+          "_CRT_SECURE_NO_DEPRECATE",
+          "_CRT_SECURE_NO_WARNINGS=1",
+          "_SCL_SECURE_NO_WARNINGS",
+          "_VARIADIC_MAX=10",
+          "_WIN32_WINNT=0x0601",
+          "_WINDOWS"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/dnn/**/*.avx.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/dnn/**/*.avx2.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx",
+          "-mf16c",
+          "-mavx2",
+          "-mfma"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX2=1",
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_FMA3=1",
+          "CV_CPU_COMPILE_FP16=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX2"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/dnn/**/*.avx512_skx.cpp",
+        "cxxflags": [
+          "-mssse3",
+          "-msse4.1",
+          "-mpopcnt",
+          "-msse4.2",
+          "-mavx",
+          "-mf16c",
+          "-mavx2",
+          "-mfma",
+          "-mavx512f",
+          "-mavx512f",
+          "-mavx512cd",
+          "-mavx512f",
+          "-mavx512cd",
+          "-mavx512vl",
+          "-mavx512bw",
+          "-mavx512dq"
+        ],
+        "defines": [
+          "CV_CPU_COMPILE_AVX2=1",
+          "CV_CPU_COMPILE_AVX512_COMMON=1",
+          "CV_CPU_COMPILE_AVX512_SKX=1",
+          "CV_CPU_COMPILE_AVX=1",
+          "CV_CPU_COMPILE_AVX_512F=1",
+          "CV_CPU_COMPILE_FMA3=1",
+          "CV_CPU_COMPILE_FP16=1",
+          "CV_CPU_COMPILE_POPCNT=1",
+          "CV_CPU_COMPILE_SSE4_1=1",
+          "CV_CPU_COMPILE_SSE4_2=1",
+          "CV_CPU_COMPILE_SSSE3=1",
+          "CV_CPU_DISPATCH_MODE=AVX512_SKX"
+        ]
+      },
+      {
+        "glob": "generated/windows/tu/wdnn/dnn/third_party_opencv-5.0.0_modules_dnn_src_backend.cpp",
+        "defines": [
+          "DEBUG_POSTFIX=d"
+        ]
+      }
+    ]
+  }
+}
diff --git a/port/config/sources/linux/calib.txt b/port/config/sources/linux/calib.txt
new file mode 100644
index 0000000..b19b73a
--- /dev/null
+++ b/port/config/sources/linux/calib.txt
@@ -0,0 +1,5 @@
+upstream/opencv/modules/calib/src/calibration.cpp
+upstream/opencv/modules/calib/src/calibration_handeye.cpp
+upstream/opencv/modules/calib/src/fisheye.cpp
+upstream/opencv/modules/calib/src/main.cpp
+upstream/opencv/modules/calib/src/multiview_calibration.cpp
diff --git a/port/config/sources/linux/core.txt b/port/config/sources/linux/core.txt
new file mode 100644
index 0000000..8b7b321
--- /dev/null
+++ b/port/config/sources/linux/core.txt
@@ -0,0 +1,127 @@
+generated/common/modules/core/arithm.avx2.cpp
+generated/common/modules/core/arithm.sse4_1.cpp
+generated/common/modules/core/convert.avx2.cpp
+generated/common/modules/core/convert_scale.avx2.cpp
+generated/common/modules/core/count_non_zero.avx2.cpp
+generated/common/modules/core/has_non_zero.avx2.cpp
+generated/common/modules/core/mathfuncs_core.avx.cpp
+generated/common/modules/core/mathfuncs_core.avx2.cpp
+generated/common/modules/core/matmul.avx2.cpp
+generated/common/modules/core/matmul.avx512_skx.cpp
+generated/common/modules/core/matmul.sse4_1.cpp
+generated/common/modules/core/mean.avx2.cpp
+generated/common/modules/core/merge.avx2.cpp
+generated/common/modules/core/minmax.avx2.cpp
+generated/common/modules/core/minmax.sse4_1.cpp
+generated/common/modules/core/nan_mask.avx2.cpp
+generated/common/modules/core/norm.avx.cpp
+generated/common/modules/core/norm.avx2.cpp
+generated/common/modules/core/norm.sse4_1.cpp
+generated/common/modules/core/reduce.avx2.cpp
+generated/common/modules/core/split.avx2.cpp
+generated/common/modules/core/stat.avx2.cpp
+generated/common/modules/core/stat.sse4_2.cpp
+generated/common/modules/core/sum.avx2.cpp
+generated/common/modules/core/transpose.avx.cpp
+generated/common/modules/core/transpose.avx2.cpp
+upstream/opencv/3rdparty/zlib/adler32.c
+upstream/opencv/3rdparty/zlib/compress.c
+upstream/opencv/3rdparty/zlib/crc32.c
+upstream/opencv/3rdparty/zlib/deflate.c
+upstream/opencv/3rdparty/zlib/gzclose.c
+upstream/opencv/3rdparty/zlib/gzlib.c
+upstream/opencv/3rdparty/zlib/gzread.c
+upstream/opencv/3rdparty/zlib/gzwrite.c
+upstream/opencv/3rdparty/zlib/infback.c
+upstream/opencv/3rdparty/zlib/inffast.c
+upstream/opencv/3rdparty/zlib/inflate.c
+upstream/opencv/3rdparty/zlib/inftrees.c
+upstream/opencv/3rdparty/zlib/trees.c
+upstream/opencv/3rdparty/zlib/uncompr.c
+upstream/opencv/3rdparty/zlib/zutil.c
+upstream/opencv/modules/core/src/algorithm.cpp
+upstream/opencv/modules/core/src/alloc.cpp
+upstream/opencv/modules/core/src/arithm.cpp
+upstream/opencv/modules/core/src/arithm.dispatch.cpp
+upstream/opencv/modules/core/src/async.cpp
+upstream/opencv/modules/core/src/batch_distance.cpp
+upstream/opencv/modules/core/src/bindings_utils.cpp
+upstream/opencv/modules/core/src/buffer_area.cpp
+upstream/opencv/modules/core/src/channels.cpp
+upstream/opencv/modules/core/src/check.cpp
+upstream/opencv/modules/core/src/command_line_parser.cpp
+upstream/opencv/modules/core/src/conjugate_gradient.cpp
+upstream/opencv/modules/core/src/convert.dispatch.cpp
+upstream/opencv/modules/core/src/convert_scale.dispatch.cpp
+upstream/opencv/modules/core/src/copy.cpp
+upstream/opencv/modules/core/src/count_non_zero.dispatch.cpp
+upstream/opencv/modules/core/src/cuda_gpu_mat.cpp
+upstream/opencv/modules/core/src/cuda_gpu_mat_nd.cpp
+upstream/opencv/modules/core/src/cuda_host_mem.cpp
+upstream/opencv/modules/core/src/cuda_info.cpp
+upstream/opencv/modules/core/src/cuda_stream.cpp
+upstream/opencv/modules/core/src/directx.cpp
+upstream/opencv/modules/core/src/downhill_simplex.cpp
+upstream/opencv/modules/core/src/dxt.cpp
+upstream/opencv/modules/core/src/gl_core_3_1.cpp
+upstream/opencv/modules/core/src/glob.cpp
+upstream/opencv/modules/core/src/hal_internal.cpp
+upstream/opencv/modules/core/src/has_non_zero.dispatch.cpp
+upstream/opencv/modules/core/src/kmeans.cpp
+upstream/opencv/modules/core/src/lapack.cpp
+upstream/opencv/modules/core/src/lda.cpp
+upstream/opencv/modules/core/src/logger.cpp
+upstream/opencv/modules/core/src/lpsolver.cpp
+upstream/opencv/modules/core/src/lut.cpp
+upstream/opencv/modules/core/src/mathfuncs.cpp
+upstream/opencv/modules/core/src/mathfuncs_core.dispatch.cpp
+upstream/opencv/modules/core/src/matmul.dispatch.cpp
+upstream/opencv/modules/core/src/matrix.cpp
+upstream/opencv/modules/core/src/matrix_decomp.cpp
+upstream/opencv/modules/core/src/matrix_expressions.cpp
+upstream/opencv/modules/core/src/matrix_iterator.cpp
+upstream/opencv/modules/core/src/matrix_operations.cpp
+upstream/opencv/modules/core/src/matrix_sparse.cpp
+upstream/opencv/modules/core/src/matrix_transform.cpp
+upstream/opencv/modules/core/src/matrix_wrap.cpp
+upstream/opencv/modules/core/src/mean.dispatch.cpp
+upstream/opencv/modules/core/src/merge.dispatch.cpp
+upstream/opencv/modules/core/src/minmax.dispatch.cpp
+upstream/opencv/modules/core/src/nan_mask.dispatch.cpp
+upstream/opencv/modules/core/src/norm.dispatch.cpp
+upstream/opencv/modules/core/src/ocl.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clblas.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clfft.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_core.cpp
+upstream/opencv/modules/core/src/opengl.cpp
+upstream/opencv/modules/core/src/out.cpp
+upstream/opencv/modules/core/src/parallel.cpp
+upstream/opencv/modules/core/src/parallel/parallel.cpp
+upstream/opencv/modules/core/src/parallel/parallel_openmp.cpp
+upstream/opencv/modules/core/src/parallel/parallel_tbb.cpp
+upstream/opencv/modules/core/src/parallel_impl.cpp
+upstream/opencv/modules/core/src/pca.cpp
+upstream/opencv/modules/core/src/persistence.cpp
+upstream/opencv/modules/core/src/persistence_base64_encoding.cpp
+upstream/opencv/modules/core/src/persistence_json.cpp
+upstream/opencv/modules/core/src/persistence_types.cpp
+upstream/opencv/modules/core/src/persistence_xml.cpp
+upstream/opencv/modules/core/src/persistence_yml.cpp
+upstream/opencv/modules/core/src/rand.cpp
+upstream/opencv/modules/core/src/reduce.dispatch.cpp
+upstream/opencv/modules/core/src/softfloat.cpp
+upstream/opencv/modules/core/src/split.dispatch.cpp
+upstream/opencv/modules/core/src/stat.dispatch.cpp
+upstream/opencv/modules/core/src/stl.cpp
+upstream/opencv/modules/core/src/sum.dispatch.cpp
+upstream/opencv/modules/core/src/system.cpp
+upstream/opencv/modules/core/src/tables.cpp
+upstream/opencv/modules/core/src/trace.cpp
+upstream/opencv/modules/core/src/types.cpp
+upstream/opencv/modules/core/src/umatrix.cpp
+upstream/opencv/modules/core/src/utils/datafile.cpp
+upstream/opencv/modules/core/src/utils/filesystem.cpp
+upstream/opencv/modules/core/src/utils/logtagconfigparser.cpp
+upstream/opencv/modules/core/src/utils/logtagmanager.cpp
+upstream/opencv/modules/core/src/utils/samples.cpp
+upstream/opencv/modules/core/src/va_intel.cpp
diff --git a/port/config/sources/linux/features.txt b/port/config/sources/linux/features.txt
new file mode 100644
index 0000000..600cae4
--- /dev/null
+++ b/port/config/sources/linux/features.txt
@@ -0,0 +1,21 @@
+upstream/opencv/modules/features/src/affine_feature.cpp
+upstream/opencv/modules/features/src/annoy.cpp
+upstream/opencv/modules/features/src/blobdetector.cpp
+upstream/opencv/modules/features/src/disk.cpp
+upstream/opencv/modules/features/src/draw.cpp
+upstream/opencv/modules/features/src/dynamic.cpp
+upstream/opencv/modules/features/src/evaluation.cpp
+upstream/opencv/modules/features/src/fast.avx2.cpp
+upstream/opencv/modules/features/src/fast.cpp
+upstream/opencv/modules/features/src/fast_score.cpp
+upstream/opencv/modules/features/src/feature2d.cpp
+upstream/opencv/modules/features/src/feature2d_aliked.cpp
+upstream/opencv/modules/features/src/featureselect.cpp
+upstream/opencv/modules/features/src/gftt.cpp
+upstream/opencv/modules/features/src/keypoint.cpp
+upstream/opencv/modules/features/src/main.cpp
+upstream/opencv/modules/features/src/matchers.cpp
+upstream/opencv/modules/features/src/matchers_lightglue.cpp
+upstream/opencv/modules/features/src/mser.cpp
+upstream/opencv/modules/features/src/orb.cpp
+upstream/opencv/modules/features/src/sift.dispatch.cpp
diff --git a/port/config/sources/linux/flann.txt b/port/config/sources/linux/flann.txt
new file mode 100644
index 0000000..fc24a96
--- /dev/null
+++ b/port/config/sources/linux/flann.txt
@@ -0,0 +1,2 @@
+upstream/opencv/modules/flann/src/flann.cpp
+upstream/opencv/modules/flann/src/miniflann.cpp
diff --git a/port/config/sources/linux/geometry.txt b/port/config/sources/linux/geometry.txt
new file mode 100644
index 0000000..da23498
--- /dev/null
+++ b/port/config/sources/linux/geometry.txt
@@ -0,0 +1,53 @@
+upstream/opencv/modules/geometry/src/ap3p.cpp
+upstream/opencv/modules/geometry/src/approx.cpp
+upstream/opencv/modules/geometry/src/calibration_base.cpp
+upstream/opencv/modules/geometry/src/convhull.cpp
+upstream/opencv/modules/geometry/src/epnp.cpp
+upstream/opencv/modules/geometry/src/fisheye.cpp
+upstream/opencv/modules/geometry/src/five-point.cpp
+upstream/opencv/modules/geometry/src/fundam.cpp
+upstream/opencv/modules/geometry/src/geometry.cpp
+upstream/opencv/modules/geometry/src/homography_decomp.cpp
+upstream/opencv/modules/geometry/src/intersection.cpp
+upstream/opencv/modules/geometry/src/ippe.cpp
+upstream/opencv/modules/geometry/src/levmarq.cpp
+upstream/opencv/modules/geometry/src/linefit.cpp
+upstream/opencv/modules/geometry/src/main.cpp
+upstream/opencv/modules/geometry/src/matchcontours.cpp
+upstream/opencv/modules/geometry/src/min_enclosing_convex_polygon.cpp
+upstream/opencv/modules/geometry/src/min_enclosing_triangle.cpp
+upstream/opencv/modules/geometry/src/moments.cpp
+upstream/opencv/modules/geometry/src/mst.cpp
+upstream/opencv/modules/geometry/src/p3p.cpp
+upstream/opencv/modules/geometry/src/pinhole.cpp
+upstream/opencv/modules/geometry/src/polynom_solver.cpp
+upstream/opencv/modules/geometry/src/ptcloud/normal_estimation.cpp
+upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.cpp
+upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.cpp
+upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.cpp
+upstream/opencv/modules/geometry/src/ptcloud/sampling.cpp
+upstream/opencv/modules/geometry/src/ptsetreg.cpp
+upstream/opencv/modules/geometry/src/rho.cpp
+upstream/opencv/modules/geometry/src/rotcalipers.cpp
+upstream/opencv/modules/geometry/src/shapedescr.cpp
+upstream/opencv/modules/geometry/src/solvepnp.cpp
+upstream/opencv/modules/geometry/src/sqpnp.cpp
+upstream/opencv/modules/geometry/src/subdivision2d.cpp
+upstream/opencv/modules/geometry/src/triangulate.cpp
+upstream/opencv/modules/geometry/src/usac/bundle.cpp
+upstream/opencv/modules/geometry/src/usac/degeneracy.cpp
+upstream/opencv/modules/geometry/src/usac/dls_solver.cpp
+upstream/opencv/modules/geometry/src/usac/essential_solver.cpp
+upstream/opencv/modules/geometry/src/usac/estimator.cpp
+upstream/opencv/modules/geometry/src/usac/fundamental_solver.cpp
+upstream/opencv/modules/geometry/src/usac/gamma_values.cpp
+upstream/opencv/modules/geometry/src/usac/homography_solver.cpp
+upstream/opencv/modules/geometry/src/usac/local_optimization.cpp
+upstream/opencv/modules/geometry/src/usac/plane_solver.cpp
+upstream/opencv/modules/geometry/src/usac/pnp_solver.cpp
+upstream/opencv/modules/geometry/src/usac/quality.cpp
+upstream/opencv/modules/geometry/src/usac/ransac_solvers.cpp
+upstream/opencv/modules/geometry/src/usac/sampler.cpp
+upstream/opencv/modules/geometry/src/usac/sphere_solver.cpp
+upstream/opencv/modules/geometry/src/usac/termination.cpp
+upstream/opencv/modules/geometry/src/usac/utils.cpp
diff --git a/port/config/sources/linux/highgui.txt b/port/config/sources/linux/highgui.txt
new file mode 100644
index 0000000..98479bb
--- /dev/null
+++ b/port/config/sources/linux/highgui.txt
@@ -0,0 +1,3 @@
+upstream/opencv/modules/highgui/src/backend.cpp
+upstream/opencv/modules/highgui/src/roiSelector.cpp
+upstream/opencv/modules/highgui/src/window.cpp
diff --git a/port/config/sources/linux/imgcodecs-jpeg.txt b/port/config/sources/linux/imgcodecs-jpeg.txt
new file mode 100644
index 0000000..37a3bff
--- /dev/null
+++ b/port/config/sources/linux/imgcodecs-jpeg.txt
@@ -0,0 +1,129 @@
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm
+upstream/opencv/3rdparty/libjpeg-turbo/src/jaricom.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapimin.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapistd.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcarith.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccoefct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccolor.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdctmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdiffct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcicc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcinit.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclossls.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmainct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmarker.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcomapi.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcparam.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcprepct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcsample.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jctrans.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapimin.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapistd.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdarith.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolor.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddctmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddiffct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdicc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdinput.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlossls.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmarker.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdphuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdpostct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdtrans.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctflt.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctfst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctint.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctflt.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctfst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctint.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctred.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemnobs.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant1.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant2.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jutils.c
diff --git a/port/config/sources/linux/imgcodecs-png.txt b/port/config/sources/linux/imgcodecs-png.txt
new file mode 100644
index 0000000..cf1ff3e
--- /dev/null
+++ b/port/config/sources/linux/imgcodecs-png.txt
@@ -0,0 +1,17 @@
+upstream/opencv/3rdparty/libpng/intel/filter_sse2_intrinsics.c
+upstream/opencv/3rdparty/libpng/intel/intel_init.c
+upstream/opencv/3rdparty/libpng/png.c
+upstream/opencv/3rdparty/libpng/pngerror.c
+upstream/opencv/3rdparty/libpng/pngget.c
+upstream/opencv/3rdparty/libpng/pngmem.c
+upstream/opencv/3rdparty/libpng/pngpread.c
+upstream/opencv/3rdparty/libpng/pngread.c
+upstream/opencv/3rdparty/libpng/pngrio.c
+upstream/opencv/3rdparty/libpng/pngrtran.c
+upstream/opencv/3rdparty/libpng/pngrutil.c
+upstream/opencv/3rdparty/libpng/pngset.c
+upstream/opencv/3rdparty/libpng/pngtrans.c
+upstream/opencv/3rdparty/libpng/pngwio.c
+upstream/opencv/3rdparty/libpng/pngwrite.c
+upstream/opencv/3rdparty/libpng/pngwtran.c
+upstream/opencv/3rdparty/libpng/pngwutil.c
diff --git a/port/config/sources/linux/imgcodecs.txt b/port/config/sources/linux/imgcodecs.txt
new file mode 100644
index 0000000..a085b19
--- /dev/null
+++ b/port/config/sources/linux/imgcodecs.txt
@@ -0,0 +1,25 @@
+upstream/opencv/modules/imgcodecs/src/bitstrm.cpp
+upstream/opencv/modules/imgcodecs/src/exif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_avif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_base.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_bmp.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_exr.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gdal.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_hdr.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pam.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pfm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pxm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_sunras.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_webp.cpp
+upstream/opencv/modules/imgcodecs/src/loadsave.cpp
+upstream/opencv/modules/imgcodecs/src/rgbe.cpp
+upstream/opencv/modules/imgcodecs/src/utils.cpp
diff --git a/port/config/sources/linux/imgproc.txt b/port/config/sources/linux/imgproc.txt
new file mode 100644
index 0000000..b889799
--- /dev/null
+++ b/port/config/sources/linux/imgproc.txt
@@ -0,0 +1,89 @@
+generated/common/modules/imgproc/accum.avx.cpp
+generated/common/modules/imgproc/accum.avx2.cpp
+generated/common/modules/imgproc/accum.sse4_1.cpp
+generated/common/modules/imgproc/bilateral_filter.avx2.cpp
+generated/common/modules/imgproc/bilateral_filter.avx512_skx.cpp
+generated/common/modules/imgproc/box_filter.avx2.cpp
+generated/common/modules/imgproc/box_filter.avx512_skx.cpp
+generated/common/modules/imgproc/box_filter.sse4_1.cpp
+generated/common/modules/imgproc/color_hsv.avx2.cpp
+generated/common/modules/imgproc/color_hsv.sse4_1.cpp
+generated/common/modules/imgproc/color_rgb.avx2.cpp
+generated/common/modules/imgproc/color_rgb.sse4_1.cpp
+generated/common/modules/imgproc/color_yuv.avx2.cpp
+generated/common/modules/imgproc/color_yuv.sse4_1.cpp
+generated/common/modules/imgproc/filter.avx2.cpp
+generated/common/modules/imgproc/filter.sse4_1.cpp
+generated/common/modules/imgproc/median_blur.avx2.cpp
+generated/common/modules/imgproc/median_blur.avx512_skx.cpp
+generated/common/modules/imgproc/median_blur.sse4_1.cpp
+generated/common/modules/imgproc/morph.avx2.cpp
+generated/common/modules/imgproc/morph.sse4_1.cpp
+generated/common/modules/imgproc/smooth.avx2.cpp
+generated/common/modules/imgproc/smooth.sse4_1.cpp
+generated/common/modules/imgproc/sumpixels.avx2.cpp
+generated/common/modules/imgproc/sumpixels.avx512_skx.cpp
+generated/common/modules/imgproc/undistort.avx2.cpp
+generated/common/modules/imgproc/warp_kernels.avx2.cpp
+generated/common/modules/imgproc/warp_kernels.sse4_1.cpp
+upstream/opencv/modules/imgproc/src/accum.cpp
+upstream/opencv/modules/imgproc/src/accum.dispatch.cpp
+upstream/opencv/modules/imgproc/src/bilateral_filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/blend.cpp
+upstream/opencv/modules/imgproc/src/box_filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/canny.cpp
+upstream/opencv/modules/imgproc/src/clahe.cpp
+upstream/opencv/modules/imgproc/src/color.cpp
+upstream/opencv/modules/imgproc/src/color_hsv.dispatch.cpp
+upstream/opencv/modules/imgproc/src/color_lab.cpp
+upstream/opencv/modules/imgproc/src/color_rgb.dispatch.cpp
+upstream/opencv/modules/imgproc/src/color_yuv.dispatch.cpp
+upstream/opencv/modules/imgproc/src/colormap.cpp
+upstream/opencv/modules/imgproc/src/connectedcomponents.cpp
+upstream/opencv/modules/imgproc/src/contours_approx.cpp
+upstream/opencv/modules/imgproc/src/contours_common.cpp
+upstream/opencv/modules/imgproc/src/contours_link.cpp
+upstream/opencv/modules/imgproc/src/contours_new.cpp
+upstream/opencv/modules/imgproc/src/contours_truco.cpp
+upstream/opencv/modules/imgproc/src/corner.avx.cpp
+upstream/opencv/modules/imgproc/src/corner.cpp
+upstream/opencv/modules/imgproc/src/cornersubpix.cpp
+upstream/opencv/modules/imgproc/src/demosaicing.cpp
+upstream/opencv/modules/imgproc/src/deriv.cpp
+upstream/opencv/modules/imgproc/src/distransform.cpp
+upstream/opencv/modules/imgproc/src/drawing.cpp
+upstream/opencv/modules/imgproc/src/drawing_text.cpp
+upstream/opencv/modules/imgproc/src/emd_new.cpp
+upstream/opencv/modules/imgproc/src/filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/fisheye.cpp
+upstream/opencv/modules/imgproc/src/floodfill.cpp
+upstream/opencv/modules/imgproc/src/gabor.cpp
+upstream/opencv/modules/imgproc/src/generalized_hough.cpp
+upstream/opencv/modules/imgproc/src/grabcut.cpp
+upstream/opencv/modules/imgproc/src/histogram.cpp
+upstream/opencv/modules/imgproc/src/hough.cpp
+upstream/opencv/modules/imgproc/src/imgwarp.avx2.cpp
+upstream/opencv/modules/imgproc/src/imgwarp.cpp
+upstream/opencv/modules/imgproc/src/imgwarp.sse4_1.cpp
+upstream/opencv/modules/imgproc/src/lsd.cpp
+upstream/opencv/modules/imgproc/src/main.cpp
+upstream/opencv/modules/imgproc/src/median_blur.dispatch.cpp
+upstream/opencv/modules/imgproc/src/morph.dispatch.cpp
+upstream/opencv/modules/imgproc/src/phasecorr.cpp
+upstream/opencv/modules/imgproc/src/phasecorr_iterative.cpp
+upstream/opencv/modules/imgproc/src/pyramids.cpp
+upstream/opencv/modules/imgproc/src/resize.avx2.cpp
+upstream/opencv/modules/imgproc/src/resize.cpp
+upstream/opencv/modules/imgproc/src/resize.sse4_1.cpp
+upstream/opencv/modules/imgproc/src/samplers.cpp
+upstream/opencv/modules/imgproc/src/segmentation.cpp
+upstream/opencv/modules/imgproc/src/smooth.dispatch.cpp
+upstream/opencv/modules/imgproc/src/spatialgradient.cpp
+upstream/opencv/modules/imgproc/src/stackblur.cpp
+upstream/opencv/modules/imgproc/src/stb_truetype.cpp
+upstream/opencv/modules/imgproc/src/sumpixels.dispatch.cpp
+upstream/opencv/modules/imgproc/src/tables.cpp
+upstream/opencv/modules/imgproc/src/templmatch.cpp
+upstream/opencv/modules/imgproc/src/thresh.cpp
+upstream/opencv/modules/imgproc/src/undistort.dispatch.cpp
+upstream/opencv/modules/imgproc/src/utils.cpp
diff --git a/port/config/sources/linux/objdetect.txt b/port/config/sources/linux/objdetect.txt
new file mode 100644
index 0000000..8e771a7
--- /dev/null
+++ b/port/config/sources/linux/objdetect.txt
@@ -0,0 +1,35 @@
+upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp
+upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp
+upstream/opencv/modules/objdetect/src/barcode.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp
+upstream/opencv/modules/objdetect/src/calibinit.cpp
+upstream/opencv/modules/objdetect/src/checkchessboard.cpp
+upstream/opencv/modules/objdetect/src/chessboard.cpp
+upstream/opencv/modules/objdetect/src/circlesgrid.cpp
+upstream/opencv/modules/objdetect/src/face_detect.cpp
+upstream/opencv/modules/objdetect/src/face_recognize.cpp
+upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp
+upstream/opencv/modules/objdetect/src/main.cpp
+upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp
+upstream/opencv/modules/objdetect/src/mcc/charts.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp
+upstream/opencv/modules/objdetect/src/mcc/common.cpp
+upstream/opencv/modules/objdetect/src/mcc/debug.cpp
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp
+upstream/opencv/modules/objdetect/src/qrcode.cpp
+upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp
+upstream/opencv/modules/objdetect/src/quadsubpix.cpp
diff --git a/port/config/sources/linux/photo.txt b/port/config/sources/linux/photo.txt
new file mode 100644
index 0000000..9019a3c
--- /dev/null
+++ b/port/config/sources/linux/photo.txt
@@ -0,0 +1,23 @@
+upstream/opencv/modules/photo/src/align.cpp
+upstream/opencv/modules/photo/src/calibrate.cpp
+upstream/opencv/modules/photo/src/ccm/ccm.cpp
+upstream/opencv/modules/photo/src/ccm/color.cpp
+upstream/opencv/modules/photo/src/ccm/colorspace.cpp
+upstream/opencv/modules/photo/src/ccm/distance.cpp
+upstream/opencv/modules/photo/src/ccm/illumobserver.cpp
+upstream/opencv/modules/photo/src/ccm/linearize.cpp
+upstream/opencv/modules/photo/src/ccm/operations.cpp
+upstream/opencv/modules/photo/src/ccm/utils.cpp
+upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp
+upstream/opencv/modules/photo/src/contrast_preserve.cpp
+upstream/opencv/modules/photo/src/denoise_tvl1.cpp
+upstream/opencv/modules/photo/src/denoising.cpp
+upstream/opencv/modules/photo/src/denoising.cuda.cpp
+upstream/opencv/modules/photo/src/hdr_common.cpp
+upstream/opencv/modules/photo/src/inpaint.cpp
+upstream/opencv/modules/photo/src/intelligent_scissors.cpp
+upstream/opencv/modules/photo/src/merge.cpp
+upstream/opencv/modules/photo/src/npr.cpp
+upstream/opencv/modules/photo/src/seamless_cloning.cpp
+upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp
+upstream/opencv/modules/photo/src/tonemap.cpp
diff --git a/port/config/sources/linux/ptcloud.txt b/port/config/sources/linux/ptcloud.txt
new file mode 100644
index 0000000..41a3b82
--- /dev/null
+++ b/port/config/sources/linux/ptcloud.txt
@@ -0,0 +1,22 @@
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/depth_registration.cpp
+upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/io_base.cpp
+upstream/opencv/modules/ptcloud/src/io_obj.cpp
+upstream/opencv/modules/ptcloud/src/io_ply.cpp
+upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp
+upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp
+upstream/opencv/modules/ptcloud/src/normal.cpp
+upstream/opencv/modules/ptcloud/src/octree.cpp
+upstream/opencv/modules/ptcloud/src/odometry.cpp
+upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp
+upstream/opencv/modules/ptcloud/src/odometry_functions.cpp
+upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp
+upstream/opencv/modules/ptcloud/src/plane.cpp
+upstream/opencv/modules/ptcloud/src/pose_graph.cpp
+upstream/opencv/modules/ptcloud/src/rendering.cpp
+upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/utils.cpp
+upstream/opencv/modules/ptcloud/src/volume_impl.cpp
+upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp
diff --git a/port/config/sources/linux/stereo.txt b/port/config/sources/linux/stereo.txt
new file mode 100644
index 0000000..e8d3307
--- /dev/null
+++ b/port/config/sources/linux/stereo.txt
@@ -0,0 +1,4 @@
+upstream/opencv/modules/stereo/src/main.cpp
+upstream/opencv/modules/stereo/src/stereo_geom.cpp
+upstream/opencv/modules/stereo/src/stereobm.cpp
+upstream/opencv/modules/stereo/src/stereosgbm.cpp
diff --git a/port/config/sources/linux/stitching.txt b/port/config/sources/linux/stitching.txt
new file mode 100644
index 0000000..ccb02d9
--- /dev/null
+++ b/port/config/sources/linux/stitching.txt
@@ -0,0 +1,12 @@
+upstream/opencv/modules/stitching/src/autocalib.cpp
+upstream/opencv/modules/stitching/src/blenders.cpp
+upstream/opencv/modules/stitching/src/camera.cpp
+upstream/opencv/modules/stitching/src/exposure_compensate.cpp
+upstream/opencv/modules/stitching/src/matchers.cpp
+upstream/opencv/modules/stitching/src/motion_estimators.cpp
+upstream/opencv/modules/stitching/src/seam_finders.cpp
+upstream/opencv/modules/stitching/src/stitcher.cpp
+upstream/opencv/modules/stitching/src/timelapsers.cpp
+upstream/opencv/modules/stitching/src/util.cpp
+upstream/opencv/modules/stitching/src/warpers.cpp
+upstream/opencv/modules/stitching/src/warpers_cuda.cpp
diff --git a/port/config/sources/linux/video.txt b/port/config/sources/linux/video.txt
new file mode 100644
index 0000000..838a00c
--- /dev/null
+++ b/port/config/sources/linux/video.txt
@@ -0,0 +1,27 @@
+upstream/opencv/modules/video/src/bgfg_KNN.cpp
+upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp
+upstream/opencv/modules/video/src/camshift.cpp
+upstream/opencv/modules/video/src/dis_flow.cpp
+upstream/opencv/modules/video/src/ecc.cpp
+upstream/opencv/modules/video/src/eccms.cpp
+upstream/opencv/modules/video/src/kalman.cpp
+upstream/opencv/modules/video/src/lkpyramid.cpp
+upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp
+upstream/opencv/modules/video/src/optflowgf.cpp
+upstream/opencv/modules/video/src/optical_flow_io.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker.cpp
+upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp
+upstream/opencv/modules/video/src/tracking/tracker_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker_nano.cpp
+upstream/opencv/modules/video/src/tracking/tracker_vit.cpp
+upstream/opencv/modules/video/src/variational_refinement.cpp
diff --git a/port/config/sources/linux/videoio-ffmpeg.txt b/port/config/sources/linux/videoio-ffmpeg.txt
new file mode 100644
index 0000000..51be8b5
--- /dev/null
+++ b/port/config/sources/linux/videoio-ffmpeg.txt
@@ -0,0 +1 @@
+upstream/opencv/modules/videoio/src/cap_ffmpeg.cpp
diff --git a/port/config/sources/linux/videoio-v4l2.txt b/port/config/sources/linux/videoio-v4l2.txt
new file mode 100644
index 0000000..1da0af6
--- /dev/null
+++ b/port/config/sources/linux/videoio-v4l2.txt
@@ -0,0 +1 @@
+upstream/opencv/modules/videoio/src/cap_v4l.cpp
diff --git a/port/config/sources/linux/videoio.txt b/port/config/sources/linux/videoio.txt
new file mode 100644
index 0000000..8745897
--- /dev/null
+++ b/port/config/sources/linux/videoio.txt
@@ -0,0 +1,8 @@
+upstream/opencv/modules/videoio/src/backend_plugin.cpp
+upstream/opencv/modules/videoio/src/backend_static.cpp
+upstream/opencv/modules/videoio/src/cap.cpp
+upstream/opencv/modules/videoio/src/cap_images.cpp
+upstream/opencv/modules/videoio/src/cap_mjpeg_decoder.cpp
+upstream/opencv/modules/videoio/src/cap_mjpeg_encoder.cpp
+upstream/opencv/modules/videoio/src/container_avi.cpp
+upstream/opencv/modules/videoio/src/videoio_registry.cpp
diff --git a/port/config/sources/macosx/calib.txt b/port/config/sources/macosx/calib.txt
new file mode 100644
index 0000000..b19b73a
--- /dev/null
+++ b/port/config/sources/macosx/calib.txt
@@ -0,0 +1,5 @@
+upstream/opencv/modules/calib/src/calibration.cpp
+upstream/opencv/modules/calib/src/calibration_handeye.cpp
+upstream/opencv/modules/calib/src/fisheye.cpp
+upstream/opencv/modules/calib/src/main.cpp
+upstream/opencv/modules/calib/src/multiview_calibration.cpp
diff --git a/port/config/sources/macosx/core.txt b/port/config/sources/macosx/core.txt
new file mode 100644
index 0000000..4ad9712
--- /dev/null
+++ b/port/config/sources/macosx/core.txt
@@ -0,0 +1,102 @@
+generated/common/modules/core/transpose.neon.cpp
+upstream/opencv/3rdparty/zlib/adler32.c
+upstream/opencv/3rdparty/zlib/compress.c
+upstream/opencv/3rdparty/zlib/crc32.c
+upstream/opencv/3rdparty/zlib/deflate.c
+upstream/opencv/3rdparty/zlib/gzclose.c
+upstream/opencv/3rdparty/zlib/gzlib.c
+upstream/opencv/3rdparty/zlib/gzread.c
+upstream/opencv/3rdparty/zlib/gzwrite.c
+upstream/opencv/3rdparty/zlib/infback.c
+upstream/opencv/3rdparty/zlib/inffast.c
+upstream/opencv/3rdparty/zlib/inflate.c
+upstream/opencv/3rdparty/zlib/inftrees.c
+upstream/opencv/3rdparty/zlib/trees.c
+upstream/opencv/3rdparty/zlib/uncompr.c
+upstream/opencv/3rdparty/zlib/zutil.c
+upstream/opencv/modules/core/src/algorithm.cpp
+upstream/opencv/modules/core/src/alloc.cpp
+upstream/opencv/modules/core/src/arithm.cpp
+upstream/opencv/modules/core/src/arithm.dispatch.cpp
+upstream/opencv/modules/core/src/async.cpp
+upstream/opencv/modules/core/src/batch_distance.cpp
+upstream/opencv/modules/core/src/bindings_utils.cpp
+upstream/opencv/modules/core/src/buffer_area.cpp
+upstream/opencv/modules/core/src/channels.cpp
+upstream/opencv/modules/core/src/check.cpp
+upstream/opencv/modules/core/src/command_line_parser.cpp
+upstream/opencv/modules/core/src/conjugate_gradient.cpp
+upstream/opencv/modules/core/src/convert.dispatch.cpp
+upstream/opencv/modules/core/src/convert_scale.dispatch.cpp
+upstream/opencv/modules/core/src/copy.cpp
+upstream/opencv/modules/core/src/count_non_zero.dispatch.cpp
+upstream/opencv/modules/core/src/cuda_gpu_mat.cpp
+upstream/opencv/modules/core/src/cuda_gpu_mat_nd.cpp
+upstream/opencv/modules/core/src/cuda_host_mem.cpp
+upstream/opencv/modules/core/src/cuda_info.cpp
+upstream/opencv/modules/core/src/cuda_stream.cpp
+upstream/opencv/modules/core/src/directx.cpp
+upstream/opencv/modules/core/src/downhill_simplex.cpp
+upstream/opencv/modules/core/src/dxt.cpp
+upstream/opencv/modules/core/src/gl_core_3_1.cpp
+upstream/opencv/modules/core/src/glob.cpp
+upstream/opencv/modules/core/src/hal_internal.cpp
+upstream/opencv/modules/core/src/has_non_zero.dispatch.cpp
+upstream/opencv/modules/core/src/kmeans.cpp
+upstream/opencv/modules/core/src/lapack.cpp
+upstream/opencv/modules/core/src/lda.cpp
+upstream/opencv/modules/core/src/logger.cpp
+upstream/opencv/modules/core/src/lpsolver.cpp
+upstream/opencv/modules/core/src/lut.cpp
+upstream/opencv/modules/core/src/mathfuncs.cpp
+upstream/opencv/modules/core/src/mathfuncs_core.dispatch.cpp
+upstream/opencv/modules/core/src/matmul.dispatch.cpp
+upstream/opencv/modules/core/src/matrix.cpp
+upstream/opencv/modules/core/src/matrix_decomp.cpp
+upstream/opencv/modules/core/src/matrix_expressions.cpp
+upstream/opencv/modules/core/src/matrix_iterator.cpp
+upstream/opencv/modules/core/src/matrix_operations.cpp
+upstream/opencv/modules/core/src/matrix_sparse.cpp
+upstream/opencv/modules/core/src/matrix_transform.cpp
+upstream/opencv/modules/core/src/matrix_wrap.cpp
+upstream/opencv/modules/core/src/mean.dispatch.cpp
+upstream/opencv/modules/core/src/merge.dispatch.cpp
+upstream/opencv/modules/core/src/minmax.dispatch.cpp
+upstream/opencv/modules/core/src/nan_mask.dispatch.cpp
+upstream/opencv/modules/core/src/norm.dispatch.cpp
+upstream/opencv/modules/core/src/ocl.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clblas.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clfft.cpp
+upstream/opencv/modules/core/src/opencl/runtime/opencl_core.cpp
+upstream/opencv/modules/core/src/opengl.cpp
+upstream/opencv/modules/core/src/out.cpp
+upstream/opencv/modules/core/src/parallel.cpp
+upstream/opencv/modules/core/src/parallel/parallel.cpp
+upstream/opencv/modules/core/src/parallel/parallel_openmp.cpp
+upstream/opencv/modules/core/src/parallel/parallel_tbb.cpp
+upstream/opencv/modules/core/src/parallel_impl.cpp
+upstream/opencv/modules/core/src/pca.cpp
+upstream/opencv/modules/core/src/persistence.cpp
+upstream/opencv/modules/core/src/persistence_base64_encoding.cpp
+upstream/opencv/modules/core/src/persistence_json.cpp
+upstream/opencv/modules/core/src/persistence_types.cpp
+upstream/opencv/modules/core/src/persistence_xml.cpp
+upstream/opencv/modules/core/src/persistence_yml.cpp
+upstream/opencv/modules/core/src/rand.cpp
+upstream/opencv/modules/core/src/reduce.dispatch.cpp
+upstream/opencv/modules/core/src/softfloat.cpp
+upstream/opencv/modules/core/src/split.dispatch.cpp
+upstream/opencv/modules/core/src/stat.dispatch.cpp
+upstream/opencv/modules/core/src/stl.cpp
+upstream/opencv/modules/core/src/sum.dispatch.cpp
+upstream/opencv/modules/core/src/system.cpp
+upstream/opencv/modules/core/src/tables.cpp
+upstream/opencv/modules/core/src/trace.cpp
+upstream/opencv/modules/core/src/types.cpp
+upstream/opencv/modules/core/src/umatrix.cpp
+upstream/opencv/modules/core/src/utils/datafile.cpp
+upstream/opencv/modules/core/src/utils/filesystem.cpp
+upstream/opencv/modules/core/src/utils/logtagconfigparser.cpp
+upstream/opencv/modules/core/src/utils/logtagmanager.cpp
+upstream/opencv/modules/core/src/utils/samples.cpp
+upstream/opencv/modules/core/src/va_intel.cpp
diff --git a/port/config/sources/macosx/features.txt b/port/config/sources/macosx/features.txt
new file mode 100644
index 0000000..6bd5d17
--- /dev/null
+++ b/port/config/sources/macosx/features.txt
@@ -0,0 +1,20 @@
+upstream/opencv/modules/features/src/affine_feature.cpp
+upstream/opencv/modules/features/src/annoy.cpp
+upstream/opencv/modules/features/src/blobdetector.cpp
+upstream/opencv/modules/features/src/disk.cpp
+upstream/opencv/modules/features/src/draw.cpp
+upstream/opencv/modules/features/src/dynamic.cpp
+upstream/opencv/modules/features/src/evaluation.cpp
+upstream/opencv/modules/features/src/fast.cpp
+upstream/opencv/modules/features/src/fast_score.cpp
+upstream/opencv/modules/features/src/feature2d.cpp
+upstream/opencv/modules/features/src/feature2d_aliked.cpp
+upstream/opencv/modules/features/src/featureselect.cpp
+upstream/opencv/modules/features/src/gftt.cpp
+upstream/opencv/modules/features/src/keypoint.cpp
+upstream/opencv/modules/features/src/main.cpp
+upstream/opencv/modules/features/src/matchers.cpp
+upstream/opencv/modules/features/src/matchers_lightglue.cpp
+upstream/opencv/modules/features/src/mser.cpp
+upstream/opencv/modules/features/src/orb.cpp
+upstream/opencv/modules/features/src/sift.dispatch.cpp
diff --git a/port/config/sources/macosx/flann.txt b/port/config/sources/macosx/flann.txt
new file mode 100644
index 0000000..fc24a96
--- /dev/null
+++ b/port/config/sources/macosx/flann.txt
@@ -0,0 +1,2 @@
+upstream/opencv/modules/flann/src/flann.cpp
+upstream/opencv/modules/flann/src/miniflann.cpp
diff --git a/port/config/sources/macosx/geometry.txt b/port/config/sources/macosx/geometry.txt
new file mode 100644
index 0000000..da23498
--- /dev/null
+++ b/port/config/sources/macosx/geometry.txt
@@ -0,0 +1,53 @@
+upstream/opencv/modules/geometry/src/ap3p.cpp
+upstream/opencv/modules/geometry/src/approx.cpp
+upstream/opencv/modules/geometry/src/calibration_base.cpp
+upstream/opencv/modules/geometry/src/convhull.cpp
+upstream/opencv/modules/geometry/src/epnp.cpp
+upstream/opencv/modules/geometry/src/fisheye.cpp
+upstream/opencv/modules/geometry/src/five-point.cpp
+upstream/opencv/modules/geometry/src/fundam.cpp
+upstream/opencv/modules/geometry/src/geometry.cpp
+upstream/opencv/modules/geometry/src/homography_decomp.cpp
+upstream/opencv/modules/geometry/src/intersection.cpp
+upstream/opencv/modules/geometry/src/ippe.cpp
+upstream/opencv/modules/geometry/src/levmarq.cpp
+upstream/opencv/modules/geometry/src/linefit.cpp
+upstream/opencv/modules/geometry/src/main.cpp
+upstream/opencv/modules/geometry/src/matchcontours.cpp
+upstream/opencv/modules/geometry/src/min_enclosing_convex_polygon.cpp
+upstream/opencv/modules/geometry/src/min_enclosing_triangle.cpp
+upstream/opencv/modules/geometry/src/moments.cpp
+upstream/opencv/modules/geometry/src/mst.cpp
+upstream/opencv/modules/geometry/src/p3p.cpp
+upstream/opencv/modules/geometry/src/pinhole.cpp
+upstream/opencv/modules/geometry/src/polynom_solver.cpp
+upstream/opencv/modules/geometry/src/ptcloud/normal_estimation.cpp
+upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.cpp
+upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.cpp
+upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.cpp
+upstream/opencv/modules/geometry/src/ptcloud/sampling.cpp
+upstream/opencv/modules/geometry/src/ptsetreg.cpp
+upstream/opencv/modules/geometry/src/rho.cpp
+upstream/opencv/modules/geometry/src/rotcalipers.cpp
+upstream/opencv/modules/geometry/src/shapedescr.cpp
+upstream/opencv/modules/geometry/src/solvepnp.cpp
+upstream/opencv/modules/geometry/src/sqpnp.cpp
+upstream/opencv/modules/geometry/src/subdivision2d.cpp
+upstream/opencv/modules/geometry/src/triangulate.cpp
+upstream/opencv/modules/geometry/src/usac/bundle.cpp
+upstream/opencv/modules/geometry/src/usac/degeneracy.cpp
+upstream/opencv/modules/geometry/src/usac/dls_solver.cpp
+upstream/opencv/modules/geometry/src/usac/essential_solver.cpp
+upstream/opencv/modules/geometry/src/usac/estimator.cpp
+upstream/opencv/modules/geometry/src/usac/fundamental_solver.cpp
+upstream/opencv/modules/geometry/src/usac/gamma_values.cpp
+upstream/opencv/modules/geometry/src/usac/homography_solver.cpp
+upstream/opencv/modules/geometry/src/usac/local_optimization.cpp
+upstream/opencv/modules/geometry/src/usac/plane_solver.cpp
+upstream/opencv/modules/geometry/src/usac/pnp_solver.cpp
+upstream/opencv/modules/geometry/src/usac/quality.cpp
+upstream/opencv/modules/geometry/src/usac/ransac_solvers.cpp
+upstream/opencv/modules/geometry/src/usac/sampler.cpp
+upstream/opencv/modules/geometry/src/usac/sphere_solver.cpp
+upstream/opencv/modules/geometry/src/usac/termination.cpp
+upstream/opencv/modules/geometry/src/usac/utils.cpp
diff --git a/port/config/sources/macosx/highgui.txt b/port/config/sources/macosx/highgui.txt
new file mode 100644
index 0000000..98479bb
--- /dev/null
+++ b/port/config/sources/macosx/highgui.txt
@@ -0,0 +1,3 @@
+upstream/opencv/modules/highgui/src/backend.cpp
+upstream/opencv/modules/highgui/src/roiSelector.cpp
+upstream/opencv/modules/highgui/src/window.cpp
diff --git a/port/config/sources/macosx/imgcodecs-jpeg.txt b/port/config/sources/macosx/imgcodecs-jpeg.txt
new file mode 100644
index 0000000..fe4fd8e
--- /dev/null
+++ b/port/config/sources/macosx/imgcodecs-jpeg.txt
@@ -0,0 +1,116 @@
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
+generated/common/tu/jpeg12/jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/common/tu/jpeg16/jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jaricom.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapimin.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapistd.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcarith.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccoefct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccolor.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdctmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdiffct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcicc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcinit.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclossls.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmainct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmarker.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcomapi.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcparam.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcprepct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcsample.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jctrans.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapimin.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapistd.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdarith.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolor.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddctmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddiffct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdicc.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdinput.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlhuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlossls.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmarker.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdphuff.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdpostct.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdtrans.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctflt.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctfst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctint.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctflt.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctfst.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctint.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctred.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemmgr.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemnobs.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant1.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant2.c
+upstream/opencv/3rdparty/libjpeg-turbo/src/jutils.c
diff --git a/port/config/sources/macosx/imgcodecs-png.txt b/port/config/sources/macosx/imgcodecs-png.txt
new file mode 100644
index 0000000..80df703
--- /dev/null
+++ b/port/config/sources/macosx/imgcodecs-png.txt
@@ -0,0 +1,19 @@
+upstream/opencv/3rdparty/libpng/arm/arm_init.c
+upstream/opencv/3rdparty/libpng/arm/filter_neon.S
+upstream/opencv/3rdparty/libpng/arm/filter_neon_intrinsics.c
+upstream/opencv/3rdparty/libpng/arm/palette_neon_intrinsics.c
+upstream/opencv/3rdparty/libpng/png.c
+upstream/opencv/3rdparty/libpng/pngerror.c
+upstream/opencv/3rdparty/libpng/pngget.c
+upstream/opencv/3rdparty/libpng/pngmem.c
+upstream/opencv/3rdparty/libpng/pngpread.c
+upstream/opencv/3rdparty/libpng/pngread.c
+upstream/opencv/3rdparty/libpng/pngrio.c
+upstream/opencv/3rdparty/libpng/pngrtran.c
+upstream/opencv/3rdparty/libpng/pngrutil.c
+upstream/opencv/3rdparty/libpng/pngset.c
+upstream/opencv/3rdparty/libpng/pngtrans.c
+upstream/opencv/3rdparty/libpng/pngwio.c
+upstream/opencv/3rdparty/libpng/pngwrite.c
+upstream/opencv/3rdparty/libpng/pngwtran.c
+upstream/opencv/3rdparty/libpng/pngwutil.c
diff --git a/port/config/sources/macosx/imgcodecs.txt b/port/config/sources/macosx/imgcodecs.txt
new file mode 100644
index 0000000..a085b19
--- /dev/null
+++ b/port/config/sources/macosx/imgcodecs.txt
@@ -0,0 +1,25 @@
+upstream/opencv/modules/imgcodecs/src/bitstrm.cpp
+upstream/opencv/modules/imgcodecs/src/exif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_avif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_base.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_bmp.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_exr.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gdal.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_gif.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_hdr.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pam.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pfm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_pxm.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_sunras.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp
+upstream/opencv/modules/imgcodecs/src/grfmt_webp.cpp
+upstream/opencv/modules/imgcodecs/src/loadsave.cpp
+upstream/opencv/modules/imgcodecs/src/rgbe.cpp
+upstream/opencv/modules/imgcodecs/src/utils.cpp
diff --git a/port/config/sources/macosx/imgproc.txt b/port/config/sources/macosx/imgproc.txt
new file mode 100644
index 0000000..026d66a
--- /dev/null
+++ b/port/config/sources/macosx/imgproc.txt
@@ -0,0 +1,57 @@
+generated/common/modules/imgproc/warp_kernels.neon.cpp
+upstream/opencv/modules/imgproc/src/accum.cpp
+upstream/opencv/modules/imgproc/src/accum.dispatch.cpp
+upstream/opencv/modules/imgproc/src/bilateral_filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/blend.cpp
+upstream/opencv/modules/imgproc/src/box_filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/canny.cpp
+upstream/opencv/modules/imgproc/src/clahe.cpp
+upstream/opencv/modules/imgproc/src/color.cpp
+upstream/opencv/modules/imgproc/src/color_hsv.dispatch.cpp
+upstream/opencv/modules/imgproc/src/color_lab.cpp
+upstream/opencv/modules/imgproc/src/color_rgb.dispatch.cpp
+upstream/opencv/modules/imgproc/src/color_yuv.dispatch.cpp
+upstream/opencv/modules/imgproc/src/colormap.cpp
+upstream/opencv/modules/imgproc/src/connectedcomponents.cpp
+upstream/opencv/modules/imgproc/src/contours_approx.cpp
+upstream/opencv/modules/imgproc/src/contours_common.cpp
+upstream/opencv/modules/imgproc/src/contours_link.cpp
+upstream/opencv/modules/imgproc/src/contours_new.cpp
+upstream/opencv/modules/imgproc/src/contours_truco.cpp
+upstream/opencv/modules/imgproc/src/corner.cpp
+upstream/opencv/modules/imgproc/src/cornersubpix.cpp
+upstream/opencv/modules/imgproc/src/demosaicing.cpp
+upstream/opencv/modules/imgproc/src/deriv.cpp
+upstream/opencv/modules/imgproc/src/distransform.cpp
+upstream/opencv/modules/imgproc/src/drawing.cpp
+upstream/opencv/modules/imgproc/src/drawing_text.cpp
+upstream/opencv/modules/imgproc/src/emd_new.cpp
+upstream/opencv/modules/imgproc/src/filter.dispatch.cpp
+upstream/opencv/modules/imgproc/src/fisheye.cpp
+upstream/opencv/modules/imgproc/src/floodfill.cpp
+upstream/opencv/modules/imgproc/src/gabor.cpp
+upstream/opencv/modules/imgproc/src/generalized_hough.cpp
+upstream/opencv/modules/imgproc/src/grabcut.cpp
+upstream/opencv/modules/imgproc/src/histogram.cpp
+upstream/opencv/modules/imgproc/src/hough.cpp
+upstream/opencv/modules/imgproc/src/imgwarp.cpp
+upstream/opencv/modules/imgproc/src/lsd.cpp
+upstream/opencv/modules/imgproc/src/main.cpp
+upstream/opencv/modules/imgproc/src/median_blur.dispatch.cpp
+upstream/opencv/modules/imgproc/src/morph.dispatch.cpp
+upstream/opencv/modules/imgproc/src/phasecorr.cpp
+upstream/opencv/modules/imgproc/src/phasecorr_iterative.cpp
+upstream/opencv/modules/imgproc/src/pyramids.cpp
+upstream/opencv/modules/imgproc/src/resize.cpp
+upstream/opencv/modules/imgproc/src/samplers.cpp
+upstream/opencv/modules/imgproc/src/segmentation.cpp
+upstream/opencv/modules/imgproc/src/smooth.dispatch.cpp
+upstream/opencv/modules/imgproc/src/spatialgradient.cpp
+upstream/opencv/modules/imgproc/src/stackblur.cpp
+upstream/opencv/modules/imgproc/src/stb_truetype.cpp
+upstream/opencv/modules/imgproc/src/sumpixels.dispatch.cpp
+upstream/opencv/modules/imgproc/src/tables.cpp
+upstream/opencv/modules/imgproc/src/templmatch.cpp
+upstream/opencv/modules/imgproc/src/thresh.cpp
+upstream/opencv/modules/imgproc/src/undistort.dispatch.cpp
+upstream/opencv/modules/imgproc/src/utils.cpp
diff --git a/port/config/sources/macosx/objdetect.txt b/port/config/sources/macosx/objdetect.txt
new file mode 100644
index 0000000..8e771a7
--- /dev/null
+++ b/port/config/sources/macosx/objdetect.txt
@@ -0,0 +1,35 @@
+upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp
+upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp
+upstream/opencv/modules/objdetect/src/barcode.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp
+upstream/opencv/modules/objdetect/src/calibinit.cpp
+upstream/opencv/modules/objdetect/src/checkchessboard.cpp
+upstream/opencv/modules/objdetect/src/chessboard.cpp
+upstream/opencv/modules/objdetect/src/circlesgrid.cpp
+upstream/opencv/modules/objdetect/src/face_detect.cpp
+upstream/opencv/modules/objdetect/src/face_recognize.cpp
+upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp
+upstream/opencv/modules/objdetect/src/main.cpp
+upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp
+upstream/opencv/modules/objdetect/src/mcc/charts.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp
+upstream/opencv/modules/objdetect/src/mcc/common.cpp
+upstream/opencv/modules/objdetect/src/mcc/debug.cpp
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp
+upstream/opencv/modules/objdetect/src/qrcode.cpp
+upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp
+upstream/opencv/modules/objdetect/src/quadsubpix.cpp
diff --git a/port/config/sources/macosx/photo.txt b/port/config/sources/macosx/photo.txt
new file mode 100644
index 0000000..9019a3c
--- /dev/null
+++ b/port/config/sources/macosx/photo.txt
@@ -0,0 +1,23 @@
+upstream/opencv/modules/photo/src/align.cpp
+upstream/opencv/modules/photo/src/calibrate.cpp
+upstream/opencv/modules/photo/src/ccm/ccm.cpp
+upstream/opencv/modules/photo/src/ccm/color.cpp
+upstream/opencv/modules/photo/src/ccm/colorspace.cpp
+upstream/opencv/modules/photo/src/ccm/distance.cpp
+upstream/opencv/modules/photo/src/ccm/illumobserver.cpp
+upstream/opencv/modules/photo/src/ccm/linearize.cpp
+upstream/opencv/modules/photo/src/ccm/operations.cpp
+upstream/opencv/modules/photo/src/ccm/utils.cpp
+upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp
+upstream/opencv/modules/photo/src/contrast_preserve.cpp
+upstream/opencv/modules/photo/src/denoise_tvl1.cpp
+upstream/opencv/modules/photo/src/denoising.cpp
+upstream/opencv/modules/photo/src/denoising.cuda.cpp
+upstream/opencv/modules/photo/src/hdr_common.cpp
+upstream/opencv/modules/photo/src/inpaint.cpp
+upstream/opencv/modules/photo/src/intelligent_scissors.cpp
+upstream/opencv/modules/photo/src/merge.cpp
+upstream/opencv/modules/photo/src/npr.cpp
+upstream/opencv/modules/photo/src/seamless_cloning.cpp
+upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp
+upstream/opencv/modules/photo/src/tonemap.cpp
diff --git a/port/config/sources/macosx/ptcloud.txt b/port/config/sources/macosx/ptcloud.txt
new file mode 100644
index 0000000..41a3b82
--- /dev/null
+++ b/port/config/sources/macosx/ptcloud.txt
@@ -0,0 +1,22 @@
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/depth_registration.cpp
+upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/io_base.cpp
+upstream/opencv/modules/ptcloud/src/io_obj.cpp
+upstream/opencv/modules/ptcloud/src/io_ply.cpp
+upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp
+upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp
+upstream/opencv/modules/ptcloud/src/normal.cpp
+upstream/opencv/modules/ptcloud/src/octree.cpp
+upstream/opencv/modules/ptcloud/src/odometry.cpp
+upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp
+upstream/opencv/modules/ptcloud/src/odometry_functions.cpp
+upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp
+upstream/opencv/modules/ptcloud/src/plane.cpp
+upstream/opencv/modules/ptcloud/src/pose_graph.cpp
+upstream/opencv/modules/ptcloud/src/rendering.cpp
+upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/utils.cpp
+upstream/opencv/modules/ptcloud/src/volume_impl.cpp
+upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp
diff --git a/port/config/sources/macosx/stereo.txt b/port/config/sources/macosx/stereo.txt
new file mode 100644
index 0000000..e8d3307
--- /dev/null
+++ b/port/config/sources/macosx/stereo.txt
@@ -0,0 +1,4 @@
+upstream/opencv/modules/stereo/src/main.cpp
+upstream/opencv/modules/stereo/src/stereo_geom.cpp
+upstream/opencv/modules/stereo/src/stereobm.cpp
+upstream/opencv/modules/stereo/src/stereosgbm.cpp
diff --git a/port/config/sources/macosx/stitching.txt b/port/config/sources/macosx/stitching.txt
new file mode 100644
index 0000000..ccb02d9
--- /dev/null
+++ b/port/config/sources/macosx/stitching.txt
@@ -0,0 +1,12 @@
+upstream/opencv/modules/stitching/src/autocalib.cpp
+upstream/opencv/modules/stitching/src/blenders.cpp
+upstream/opencv/modules/stitching/src/camera.cpp
+upstream/opencv/modules/stitching/src/exposure_compensate.cpp
+upstream/opencv/modules/stitching/src/matchers.cpp
+upstream/opencv/modules/stitching/src/motion_estimators.cpp
+upstream/opencv/modules/stitching/src/seam_finders.cpp
+upstream/opencv/modules/stitching/src/stitcher.cpp
+upstream/opencv/modules/stitching/src/timelapsers.cpp
+upstream/opencv/modules/stitching/src/util.cpp
+upstream/opencv/modules/stitching/src/warpers.cpp
+upstream/opencv/modules/stitching/src/warpers_cuda.cpp
diff --git a/port/config/sources/macosx/video.txt b/port/config/sources/macosx/video.txt
new file mode 100644
index 0000000..838a00c
--- /dev/null
+++ b/port/config/sources/macosx/video.txt
@@ -0,0 +1,27 @@
+upstream/opencv/modules/video/src/bgfg_KNN.cpp
+upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp
+upstream/opencv/modules/video/src/camshift.cpp
+upstream/opencv/modules/video/src/dis_flow.cpp
+upstream/opencv/modules/video/src/ecc.cpp
+upstream/opencv/modules/video/src/eccms.cpp
+upstream/opencv/modules/video/src/kalman.cpp
+upstream/opencv/modules/video/src/lkpyramid.cpp
+upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp
+upstream/opencv/modules/video/src/optflowgf.cpp
+upstream/opencv/modules/video/src/optical_flow_io.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker.cpp
+upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp
+upstream/opencv/modules/video/src/tracking/tracker_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker_nano.cpp
+upstream/opencv/modules/video/src/tracking/tracker_vit.cpp
+upstream/opencv/modules/video/src/variational_refinement.cpp
diff --git a/port/config/sources/macosx/videoio-ffmpeg.txt b/port/config/sources/macosx/videoio-ffmpeg.txt
new file mode 100644
index 0000000..51be8b5
--- /dev/null
+++ b/port/config/sources/macosx/videoio-ffmpeg.txt
@@ -0,0 +1 @@
+upstream/opencv/modules/videoio/src/cap_ffmpeg.cpp
diff --git a/port/config/sources/macosx/videoio.txt b/port/config/sources/macosx/videoio.txt
new file mode 100644
index 0000000..8745897
--- /dev/null
+++ b/port/config/sources/macosx/videoio.txt
@@ -0,0 +1,8 @@
+upstream/opencv/modules/videoio/src/backend_plugin.cpp
+upstream/opencv/modules/videoio/src/backend_static.cpp
+upstream/opencv/modules/videoio/src/cap.cpp
+upstream/opencv/modules/videoio/src/cap_images.cpp
+upstream/opencv/modules/videoio/src/cap_mjpeg_decoder.cpp
+upstream/opencv/modules/videoio/src/cap_mjpeg_encoder.cpp
+upstream/opencv/modules/videoio/src/container_avi.cpp
+upstream/opencv/modules/videoio/src/videoio_registry.cpp
diff --git a/port/config/sources/windows/calib.txt b/port/config/sources/windows/calib.txt
new file mode 100644
index 0000000..b19b73a
--- /dev/null
+++ b/port/config/sources/windows/calib.txt
@@ -0,0 +1,5 @@
+upstream/opencv/modules/calib/src/calibration.cpp
+upstream/opencv/modules/calib/src/calibration_handeye.cpp
+upstream/opencv/modules/calib/src/fisheye.cpp
+upstream/opencv/modules/calib/src/main.cpp
+upstream/opencv/modules/calib/src/multiview_calibration.cpp
diff --git a/port/config/sources/windows/core.txt b/port/config/sources/windows/core.txt
new file mode 100644
index 0000000..98ec78f
--- /dev/null
+++ b/port/config/sources/windows/core.txt
@@ -0,0 +1,127 @@
+generated/windows/tu/w/core/gen_common_modules_core_arithm.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_arithm.sse4_1.cpp
+generated/windows/tu/w/core/gen_common_modules_core_convert.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_convert_scale.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_count_non_zero.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_has_non_zero.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx.cpp
+generated/windows/tu/w/core/gen_common_modules_core_mathfuncs_core.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_matmul.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_matmul.avx512_skx.cpp
+generated/windows/tu/w/core/gen_common_modules_core_matmul.sse4_1.cpp
+generated/windows/tu/w/core/gen_common_modules_core_mean.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_merge.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_minmax.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_minmax.sse4_1.cpp
+generated/windows/tu/w/core/gen_common_modules_core_nan_mask.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_norm.avx.cpp
+generated/windows/tu/w/core/gen_common_modules_core_norm.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_norm.sse4_1.cpp
+generated/windows/tu/w/core/gen_common_modules_core_reduce.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_split.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_stat.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_stat.sse4_2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_sum.avx2.cpp
+generated/windows/tu/w/core/gen_common_modules_core_transpose.avx.cpp
+generated/windows/tu/w/core/gen_common_modules_core_transpose.avx2.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_algorithm.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_alloc.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_arithm.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_async.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_batch_distance.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_bindings_utils.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_buffer_area.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_channels.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_check.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_command_line_parser.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_conjugate_gradient.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_convert_scale.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_copy.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_count_non_zero.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_gpu_mat_nd.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_host_mem.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_info.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_cuda_stream.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_directx.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_downhill_simplex.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_dxt.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_gl_core_3_1.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_glob.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_hal_internal.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_has_non_zero.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_kmeans.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lapack.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lda.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_logger.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lpsolver.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_lut.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mathfuncs_core.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matmul.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_decomp.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_expressions.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_iterator.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_operations.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_sparse.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_transform.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_matrix_wrap.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_mean.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_merge.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_minmax.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_nan_mask.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_norm.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_ocl.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clblas.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_clfft.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opencl_runtime_opencl_core.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_opengl.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_out.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_impl.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_openmp.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_parallel_parallel_tbb.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_pca.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_base64_encoding.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_json.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_types.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_xml.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_persistence_yml.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_rand.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_reduce.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_softfloat.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_split.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stat.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_stl.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_sum.dispatch.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_system.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_tables.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_trace.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_types.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_umatrix.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_datafile.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_filesystem.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagconfigparser.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_logtagmanager.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_utils_samples.cpp
+generated/windows/tu/w/core/third_party_opencv-5.0.0_modules_core_src_va_intel.cpp
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_adler32.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_compress.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_crc32.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_deflate.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzclose.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzlib.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzread.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_gzwrite.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_infback.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inffast.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inflate.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_inftrees.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_trees.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_uncompr.c
+generated/windows/tu/w/zlib/third_party_opencv-5.0.0_3rdparty_zlib_zutil.c
diff --git a/port/config/sources/windows/features.txt b/port/config/sources/windows/features.txt
new file mode 100644
index 0000000..600cae4
--- /dev/null
+++ b/port/config/sources/windows/features.txt
@@ -0,0 +1,21 @@
+upstream/opencv/modules/features/src/affine_feature.cpp
+upstream/opencv/modules/features/src/annoy.cpp
+upstream/opencv/modules/features/src/blobdetector.cpp
+upstream/opencv/modules/features/src/disk.cpp
+upstream/opencv/modules/features/src/draw.cpp
+upstream/opencv/modules/features/src/dynamic.cpp
+upstream/opencv/modules/features/src/evaluation.cpp
+upstream/opencv/modules/features/src/fast.avx2.cpp
+upstream/opencv/modules/features/src/fast.cpp
+upstream/opencv/modules/features/src/fast_score.cpp
+upstream/opencv/modules/features/src/feature2d.cpp
+upstream/opencv/modules/features/src/feature2d_aliked.cpp
+upstream/opencv/modules/features/src/featureselect.cpp
+upstream/opencv/modules/features/src/gftt.cpp
+upstream/opencv/modules/features/src/keypoint.cpp
+upstream/opencv/modules/features/src/main.cpp
+upstream/opencv/modules/features/src/matchers.cpp
+upstream/opencv/modules/features/src/matchers_lightglue.cpp
+upstream/opencv/modules/features/src/mser.cpp
+upstream/opencv/modules/features/src/orb.cpp
+upstream/opencv/modules/features/src/sift.dispatch.cpp
diff --git a/port/config/sources/windows/flann.txt b/port/config/sources/windows/flann.txt
new file mode 100644
index 0000000..0d6eeba
--- /dev/null
+++ b/port/config/sources/windows/flann.txt
@@ -0,0 +1,2 @@
+generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_flann.cpp
+generated/windows/tu/w/flann/third_party_opencv-5.0.0_modules_flann_src_miniflann.cpp
diff --git a/port/config/sources/windows/geometry.txt b/port/config/sources/windows/geometry.txt
new file mode 100644
index 0000000..95efa7b
--- /dev/null
+++ b/port/config/sources/windows/geometry.txt
@@ -0,0 +1,53 @@
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ap3p.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_approx.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_calibration_base.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_convhull.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_epnp.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fisheye.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_five-point.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_fundam.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_geometry.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_homography_decomp.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_intersection.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ippe.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_levmarq.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_linefit.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_main.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_matchcontours.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_convex_polygon.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_min_enclosing_triangle.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_moments.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_mst.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_p3p.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_pinhole.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_polynom_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_normal_estimation.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_ptcloud_utils.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_region_growing_3d.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sac_segmentation.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptcloud_sampling.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_ptsetreg.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rho.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_rotcalipers.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_shapedescr.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_solvepnp.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_sqpnp.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_subdivision2d.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_triangulate.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_bundle.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_degeneracy.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_dls_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_essential_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_estimator.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_fundamental_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_gamma_values.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_homography_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_local_optimization.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_plane_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_pnp_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_quality.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_ransac_solvers.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sampler.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_sphere_solver.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_termination.cpp
+generated/windows/tu/w/geometry/third_party_opencv-5.0.0_modules_geometry_src_usac_utils.cpp
diff --git a/port/config/sources/windows/highgui.txt b/port/config/sources/windows/highgui.txt
new file mode 100644
index 0000000..d1940c1
--- /dev/null
+++ b/port/config/sources/windows/highgui.txt
@@ -0,0 +1,3 @@
+generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_backend.cpp
+generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_roiSelector.cpp
+generated/windows/tu/w/highgui/third_party_opencv-5.0.0_modules_highgui_src_window.cpp
diff --git a/port/config/sources/windows/imgcodecs-jpeg.txt b/port/config/sources/windows/imgcodecs-jpeg.txt
new file mode 100644
index 0000000..ac88b0e
--- /dev/null
+++ b/port/config/sources/windows/imgcodecs-jpeg.txt
@@ -0,0 +1,101 @@
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccoefct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdctmgr.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcoefct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddctmgr.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdmerge.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctfst.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jfdctint.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctflt.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctfst.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctint.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jidctred.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant1.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jquant2.c
+generated/windows/tu/w/jpeg12/gen_common_tu_jpeg12_jpeg12_3rdparty_libjpeg-turbo_src_jutils.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/windows/tu/w/jpeg16/gen_common_tu_jpeg16_jpeg16_3rdparty_libjpeg-turbo_src_jutils.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jaricom.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapimin.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcapistd.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcarith.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccoefct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jccolor.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdctmgr.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcdiffct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jchuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcicc.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcinit.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclhuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jclossls.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmainct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmarker.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcmaster.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcomapi.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcparam.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcphuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcprepct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jcsample.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jctrans.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapimin.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdapistd.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdarith.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatadst.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdatasrc.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcoefct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdcolor.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddctmgr.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jddiffct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdhuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdicc.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdinput.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlhuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdlossls.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmainct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmarker.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmaster.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdmerge.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdphuff.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdpostct.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdsample.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jdtrans.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jerror.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctflt.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctfst.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jfdctint.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctflt.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctfst.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctint.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jidctred.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemmgr.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jmemnobs.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jpeg_nbits.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant1.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jquant2.c
+generated/windows/tu/w/libjpeg-turbo/third_party_opencv-5.0.0_3rdparty_libjpeg-turbo_src_jutils.c
diff --git a/port/config/sources/windows/imgcodecs-png.txt b/port/config/sources/windows/imgcodecs-png.txt
new file mode 100644
index 0000000..fd47636
--- /dev/null
+++ b/port/config/sources/windows/imgcodecs-png.txt
@@ -0,0 +1,17 @@
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_filter_sse2_intrinsics.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_intel_intel_init.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_png.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngerror.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngget.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngmem.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngpread.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngread.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrio.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrtran.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngrutil.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngset.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngtrans.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwio.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwrite.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwtran.c
+generated/windows/tu/w/libpng/third_party_opencv-5.0.0_3rdparty_libpng_pngwutil.c
diff --git a/port/config/sources/windows/imgcodecs.txt b/port/config/sources/windows/imgcodecs.txt
new file mode 100644
index 0000000..7896cfc
--- /dev/null
+++ b/port/config/sources/windows/imgcodecs.txt
@@ -0,0 +1,25 @@
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_bitstrm.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_exif.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_avif.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_base.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_bmp.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_exr.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdal.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gdcm.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_gif.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_hdr.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpeg2000_openjpeg.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_jpegxl.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pam.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pfm.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_png.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_pxm.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_spng.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_sunras.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_tiff.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_grfmt_webp.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_loadsave.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_rgbe.cpp
+generated/windows/tu/w/imgcodecs/third_party_opencv-5.0.0_modules_imgcodecs_src_utils.cpp
diff --git a/port/config/sources/windows/imgproc.txt b/port/config/sources/windows/imgproc.txt
new file mode 100644
index 0000000..56b424c
--- /dev/null
+++ b/port/config/sources/windows/imgproc.txt
@@ -0,0 +1,89 @@
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_accum.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_bilateral_filter.avx512_skx.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.avx512_skx.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_box_filter.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_hsv.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_rgb.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_color_yuv.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_filter.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.avx512_skx.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_median_blur.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_morph.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_smooth.sse4_1.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_sumpixels.avx512_skx.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_undistort.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.avx2.cpp
+generated/windows/tu/w/imgproc/gen_common_modules_imgproc_warp_kernels.sse4_1.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_accum.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_bilateral_filter.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_blend.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_box_filter.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_canny.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_clahe.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_hsv.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_lab.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_rgb.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_color_yuv.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_colormap.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_connectedcomponents.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_approx.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_common.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_link.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_new.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_contours_truco.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.avx.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_corner.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_cornersubpix.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_demosaicing.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_deriv.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_distransform.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_drawing_text.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_emd_new.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_filter.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_fisheye.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_floodfill.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_gabor.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_generalized_hough.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_grabcut.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_histogram.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_hough.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.avx2.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_imgwarp.sse4_1.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_lsd.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_main.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_median_blur.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_morph.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_phasecorr_iterative.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_pyramids.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.avx2.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_resize.sse4_1.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_samplers.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_segmentation.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_smooth.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_spatialgradient.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stackblur.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_stb_truetype.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_sumpixels.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_tables.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_templmatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_thresh.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_undistort.dispatch.cpp
+generated/windows/tu/w/imgproc/third_party_opencv-5.0.0_modules_imgproc_src_utils.cpp
diff --git a/port/config/sources/windows/objdetect.txt b/port/config/sources/windows/objdetect.txt
new file mode 100644
index 0000000..8e771a7
--- /dev/null
+++ b/port/config/sources/windows/objdetect.txt
@@ -0,0 +1,35 @@
+upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp
+upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp
+upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp
+upstream/opencv/modules/objdetect/src/barcode.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
+upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp
+upstream/opencv/modules/objdetect/src/calibinit.cpp
+upstream/opencv/modules/objdetect/src/checkchessboard.cpp
+upstream/opencv/modules/objdetect/src/chessboard.cpp
+upstream/opencv/modules/objdetect/src/circlesgrid.cpp
+upstream/opencv/modules/objdetect/src/face_detect.cpp
+upstream/opencv/modules/objdetect/src/face_recognize.cpp
+upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp
+upstream/opencv/modules/objdetect/src/main.cpp
+upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp
+upstream/opencv/modules/objdetect/src/mcc/charts.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp
+upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp
+upstream/opencv/modules/objdetect/src/mcc/common.cpp
+upstream/opencv/modules/objdetect/src/mcc/debug.cpp
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp
+upstream/opencv/modules/objdetect/src/qrcode.cpp
+upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp
+upstream/opencv/modules/objdetect/src/quadsubpix.cpp
diff --git a/port/config/sources/windows/photo.txt b/port/config/sources/windows/photo.txt
new file mode 100644
index 0000000..9019a3c
--- /dev/null
+++ b/port/config/sources/windows/photo.txt
@@ -0,0 +1,23 @@
+upstream/opencv/modules/photo/src/align.cpp
+upstream/opencv/modules/photo/src/calibrate.cpp
+upstream/opencv/modules/photo/src/ccm/ccm.cpp
+upstream/opencv/modules/photo/src/ccm/color.cpp
+upstream/opencv/modules/photo/src/ccm/colorspace.cpp
+upstream/opencv/modules/photo/src/ccm/distance.cpp
+upstream/opencv/modules/photo/src/ccm/illumobserver.cpp
+upstream/opencv/modules/photo/src/ccm/linearize.cpp
+upstream/opencv/modules/photo/src/ccm/operations.cpp
+upstream/opencv/modules/photo/src/ccm/utils.cpp
+upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp
+upstream/opencv/modules/photo/src/contrast_preserve.cpp
+upstream/opencv/modules/photo/src/denoise_tvl1.cpp
+upstream/opencv/modules/photo/src/denoising.cpp
+upstream/opencv/modules/photo/src/denoising.cuda.cpp
+upstream/opencv/modules/photo/src/hdr_common.cpp
+upstream/opencv/modules/photo/src/inpaint.cpp
+upstream/opencv/modules/photo/src/intelligent_scissors.cpp
+upstream/opencv/modules/photo/src/merge.cpp
+upstream/opencv/modules/photo/src/npr.cpp
+upstream/opencv/modules/photo/src/seamless_cloning.cpp
+upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp
+upstream/opencv/modules/photo/src/tonemap.cpp
diff --git a/port/config/sources/windows/ptcloud.txt b/port/config/sources/windows/ptcloud.txt
new file mode 100644
index 0000000..41a3b82
--- /dev/null
+++ b/port/config/sources/windows/ptcloud.txt
@@ -0,0 +1,22 @@
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/depth_registration.cpp
+upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/io_base.cpp
+upstream/opencv/modules/ptcloud/src/io_obj.cpp
+upstream/opencv/modules/ptcloud/src/io_ply.cpp
+upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp
+upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp
+upstream/opencv/modules/ptcloud/src/normal.cpp
+upstream/opencv/modules/ptcloud/src/octree.cpp
+upstream/opencv/modules/ptcloud/src/odometry.cpp
+upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp
+upstream/opencv/modules/ptcloud/src/odometry_functions.cpp
+upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp
+upstream/opencv/modules/ptcloud/src/plane.cpp
+upstream/opencv/modules/ptcloud/src/pose_graph.cpp
+upstream/opencv/modules/ptcloud/src/rendering.cpp
+upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp
+upstream/opencv/modules/ptcloud/src/utils.cpp
+upstream/opencv/modules/ptcloud/src/volume_impl.cpp
+upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp
diff --git a/port/config/sources/windows/stereo.txt b/port/config/sources/windows/stereo.txt
new file mode 100644
index 0000000..e8d3307
--- /dev/null
+++ b/port/config/sources/windows/stereo.txt
@@ -0,0 +1,4 @@
+upstream/opencv/modules/stereo/src/main.cpp
+upstream/opencv/modules/stereo/src/stereo_geom.cpp
+upstream/opencv/modules/stereo/src/stereobm.cpp
+upstream/opencv/modules/stereo/src/stereosgbm.cpp
diff --git a/port/config/sources/windows/stitching.txt b/port/config/sources/windows/stitching.txt
new file mode 100644
index 0000000..ccb02d9
--- /dev/null
+++ b/port/config/sources/windows/stitching.txt
@@ -0,0 +1,12 @@
+upstream/opencv/modules/stitching/src/autocalib.cpp
+upstream/opencv/modules/stitching/src/blenders.cpp
+upstream/opencv/modules/stitching/src/camera.cpp
+upstream/opencv/modules/stitching/src/exposure_compensate.cpp
+upstream/opencv/modules/stitching/src/matchers.cpp
+upstream/opencv/modules/stitching/src/motion_estimators.cpp
+upstream/opencv/modules/stitching/src/seam_finders.cpp
+upstream/opencv/modules/stitching/src/stitcher.cpp
+upstream/opencv/modules/stitching/src/timelapsers.cpp
+upstream/opencv/modules/stitching/src/util.cpp
+upstream/opencv/modules/stitching/src/warpers.cpp
+upstream/opencv/modules/stitching/src/warpers_cuda.cpp
diff --git a/port/config/sources/windows/video.txt b/port/config/sources/windows/video.txt
new file mode 100644
index 0000000..838a00c
--- /dev/null
+++ b/port/config/sources/windows/video.txt
@@ -0,0 +1,27 @@
+upstream/opencv/modules/video/src/bgfg_KNN.cpp
+upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp
+upstream/opencv/modules/video/src/camshift.cpp
+upstream/opencv/modules/video/src/dis_flow.cpp
+upstream/opencv/modules/video/src/ecc.cpp
+upstream/opencv/modules/video/src/eccms.cpp
+upstream/opencv/modules/video/src/kalman.cpp
+upstream/opencv/modules/video/src/lkpyramid.cpp
+upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp
+upstream/opencv/modules/video/src/optflowgf.cpp
+upstream/opencv/modules/video/src/optical_flow_io.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp
+upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker.cpp
+upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp
+upstream/opencv/modules/video/src/tracking/tracker_mil.cpp
+upstream/opencv/modules/video/src/tracking/tracker_nano.cpp
+upstream/opencv/modules/video/src/tracking/tracker_vit.cpp
+upstream/opencv/modules/video/src/variational_refinement.cpp
diff --git a/port/config/sources/windows/videoio-ffmpeg.txt b/port/config/sources/windows/videoio-ffmpeg.txt
new file mode 100644
index 0000000..61f55fa
--- /dev/null
+++ b/port/config/sources/windows/videoio-ffmpeg.txt
@@ -0,0 +1 @@
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_ffmpeg.cpp
diff --git a/port/config/sources/windows/videoio.txt b/port/config/sources/windows/videoio.txt
new file mode 100644
index 0000000..a54ea57
--- /dev/null
+++ b/port/config/sources/windows/videoio.txt
@@ -0,0 +1,8 @@
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_plugin.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_backend_static.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_images.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_decoder.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_cap_mjpeg_encoder.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_container_avi.cpp
+generated/windows/tu/w/videoio/third_party_opencv-5.0.0_modules_videoio_src_videoio_registry.cpp
diff --git a/port/include/mwrap/opencv/macros.hpp b/port/include/mwrap/opencv/macros.hpp
new file mode 100644
index 0000000..d1576ef
--- /dev/null
+++ b/port/include/mwrap/opencv/macros.hpp
@@ -0,0 +1,27 @@
+// mwrap/opencv/macros.hpp — optional side header for OpenCV's macro surface.
+//
+// Modules cannot export macros. Everything with linkage is re-exported by the
+// opencv.* modules; this textual header covers the rest: CV_Assert / CV_Error
+// / CV_DbgAssert, the CV_8UC(n)-style *function-like* type macros, version
+// macros, and the global-namespace inline helpers (cvRound, cvFloor, …).
+//
+// IMPORTANT: include this header BEFORE any `import mcpplibs.mwrap.opencv.*;` in the same
+// translation unit (include-after-import is ill-formed for headers that also
+// declare entities attached to the global module — same rule as ffmpeg-m's
+// macros.h).
+#pragma once
+
+#include <opencv2/core/base.hpp>
+#include <opencv2/core/check.hpp>
+#include <opencv2/core/cvdef.h>
+#include <opencv2/core/version.hpp>
+#include <opencv2/features/hal/interface.h>
+#include <opencv2/imgproc/hal/interface.h>
+
+// OpenCV 5.0.0 spells the flag CV_MAT_SUBMAT_FLAG in this macro, but only
+// CV_SUBMAT_FLAG exists. Keep the vendor file intact and repair the optional
+// compatibility surface, matching Mat::isSubmatrix and the typed mapping.
+#if CV_VERSION_MAJOR == 5 && CV_VERSION_MINOR == 0 && CV_VERSION_REVISION == 0
+#undef CV_IS_SUBMAT
+#define CV_IS_SUBMAT(flags) ((flags) & CV_SUBMAT_FLAG)
+#endif
diff --git a/port/include/mwrap/opencv/ort_profile_path.hpp b/port/include/mwrap/opencv/ort_profile_path.hpp
new file mode 100644
index 0000000..36d880e
--- /dev/null
+++ b/port/include/mwrap/opencv/ort_profile_path.hpp
@@ -0,0 +1,11 @@
+#pragma once
+#include <filesystem>
+#include <string>
+
+// ORT's profiling path is wchar_t on Windows, while OpenCV stores the
+// temporary filename as std::string. Adapt only the implementation call.
+namespace mwrap_opencv_port {
+inline auto ort_profile_path(const std::string& value) {
+    return std::filesystem::path(value).native();
+}
+}
diff --git a/port/include/mwrap/opencv/simd.hpp b/port/include/mwrap/opencv/simd.hpp
new file mode 100644
index 0000000..a05d169
--- /dev/null
+++ b/port/include/mwrap/opencv/simd.hpp
@@ -0,0 +1,16 @@
+#pragma once
+// Freeze ordinary SDK declarations before adjusting namespace-function linkage.
+#include <opencv2/core.hpp>
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+#define CV_FORCE_SIMD128_CPP 1
+// The emulator uses CV_INLINE only on namespace function templates. Give those
+// original templates external linkage so named modules can re-export them.
+// Vector class definitions and all implementation bodies remain SDK originals.
+#pragma push_macro("CV_INLINE")
+#undef CV_INLINE
+#define CV_INLINE inline
+#endif
+#include <opencv2/core/simd_intrinsics.hpp>
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+#pragma pop_macro("CV_INLINE")
+#endif
diff --git a/port/licenses/UPSTREAM_SOURCE_NOTICES.txt b/port/licenses/UPSTREAM_SOURCE_NOTICES.txt
new file mode 100644
index 0000000..bcb969a
--- /dev/null
+++ b/port/licenses/UPSTREAM_SOURCE_NOTICES.txt
@@ -0,0 +1,17374 @@
+Generated by tools/generate_source_notices.py from retained OpenCV 5.0.0 sources.
+Embedded copyright and license comments; original comment bytes preserved.
+Named license files are distributed alongside this supplement.
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/dlpack/LICENSE:3
+upstream/opencv/3rdparty/flatbuffers/LICENSE.txt:4
+upstream/opencv/LICENSE:4
+upstream/opencv/modules/highgui/src/files_Qt/Material/LICENSE:3
+
+//www.apache.org/licenses/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/dlpack/LICENSE:195
+upstream/opencv/3rdparty/flatbuffers/LICENSE.txt:196
+upstream/opencv/LICENSE:196
+upstream/opencv/modules/features/3rdparty/annoy/LICENSE:7
+upstream/opencv/modules/highgui/src/files_Qt/Material/LICENSE:195
+
+//www.apache.org/licenses/LICENSE-2.0
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/dlpack/include/dlpack/dlpack.h:1
+
+/*!
+ *  Copyright (c) 2017 by Contributors
+ * \file dlpack.h
+ * \brief The common header of DLPack.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/allocator.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/array.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer_ref.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/default_allocator.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/detached_buffer.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/string.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/struct.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/table.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector_downward.h:1
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/verifier.h:1
+
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h:1
+
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/stl_emulation.h:1
+
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/LICENSE.md:12
+
+//opensource.org/licenses/Zlib), but in the context of
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/jversion.h.in:1
+
+/*
+ * jversion.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2012-2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains software version identification.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jccolext-neon.c:1
+
+/*
+ * Colorspace conversion (32-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jchuff-neon.c:1
+
+/*
+ * Huffman entropy encoding (32-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2019, Google LLC.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 32-bit Arm architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd_neon.S:1
+
+/*
+ * Armv7 Neon optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2009-2011, Nokia Corporation and/or its subsidiary(-ies).
+ *                          All Rights Reserved.
+ * Author:  Siarhei Siamashka <siarhei.siamashka@nokia.com>
+ * Copyright (C) 2014, Siarhei Siamashka.  All Rights Reserved.
+ * Copyright (C) 2014, Linaro Limited.  All Rights Reserved.
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jccolext-neon.c:1
+
+/*
+ * Colorspace conversion (64-bit Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c:1
+
+/*
+ * Huffman entropy encoding (64-bit Arm Neon)
+ *
+ * Copyright (C) 2020-2021, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2022, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, 2020, 2022, 2024,
+ *           D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit Arm architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd_neon.S:1
+
+/*
+ * Armv8 Neon optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2009-2011, Nokia Corporation and/or its subsidiary(-ies).
+ *                          All Rights Reserved.
+ * Author:  Siarhei Siamashka <siarhei.siamashka@nokia.com>
+ * Copyright (C) 2013-2014, Linaro Limited.  All Rights Reserved.
+ * Author:  Ragesh Radhakrishnan <ragesh.r@linaro.org>
+ * Copyright (C) 2014-2016, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2015-2016, 2018, Matthieu Darbois.  All Rights Reserved.
+ * Copyright (C) 2016, Siarhei Siamashka.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/align.h:1
+
+/*
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c:1
+
+/*
+ * Colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2024-2025, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c:1
+
+/*
+ * Grayscale colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgryext-neon.c:1
+
+/*
+ * Grayscale colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jchuff.h:1
+
+/*
+ * jchuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2018, 2021, 2025, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2020-2021, Arm Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c:1
+
+/*
+ * Prepare data for progressive Huffman encoding (Arm Neon)
+ *
+ * Copyright (C) 2020-2021, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2022, Matthieu Darbois.  All Rights Reserved.
+ * Copyright (C) 2022, 2024-2025, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c:1
+
+/*
+ * Downsampling (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024-2025, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolext-neon.c:1
+
+/*
+ * Colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c:1
+
+/*
+ * Colorspace conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c:1
+
+/*
+ * Merged upsampling/color conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmrgext-neon.c:1
+
+/*
+ * Merged upsampling/color conversion (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c:1
+
+/*
+ * Upsampling (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c:1
+
+/*
+ * Fast integer FDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c:1
+
+/*
+ * Accurate integer FDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c:1
+
+/*
+ * Fast integer IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c:1
+
+/*
+ * Accurate integer IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c:1
+
+/*
+ * Reduced-size IDCT (Arm Neon)
+ *
+ * Copyright (C) 2020, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2020, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c:1
+
+/*
+ * Sample data conversion and quantization (Arm Neon)
+ *
+ * Copyright (C) 2020-2021, Arm Limited.  All Rights Reserved.
+ * Copyright (C) 2024-2025, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h.in:1
+
+/*
+ * Copyright (C) 2020, 2024, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2020-2021, Arm Limited.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2013-2014, 2016, 2018, 2022-2024, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 32-bit x86 architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/jsimd.h:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014-2016, 2018, 2020, 2022, D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2014, Linaro Limited.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, 2020, 2022, 2024,
+ *           D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * MIPS architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2.S:1
+
+/*
+ * MIPS DSPr2 optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ *                          All Rights Reserved.
+ * Authors:  Teodora Novkovic <teodora.novkovic@imgtec.com>
+ *           Darko Laus       <darko.laus@imgtec.com>
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2_asm.h:1
+
+/*
+ * MIPS DSPr2 optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2013, MIPS Technologies, Inc., California.
+ * Copyright (C) 2018, Matthieu Darbois.
+ * All Rights Reserved.
+ * Authors:  Teodora Novkovic (teodora.novkovic@imgtec.com)
+ *           Darko Laus       (darko.laus@imgtec.com)
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolext-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014-2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           ZhangLixia  <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolor-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2014, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgray-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2014, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgryext-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014-2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample.h:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample.h:1
+
+/*
+ * jcsample.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolext-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolor-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmerge-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2011, 2015, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmrgext-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2015, 2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhangLixia <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdsample-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           ZhangLixia  <zhanglixia-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctfst-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  LiuQingfa <liuqingfa-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctint-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2018, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctfst-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2018-2019, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  LiuQingfa <liuqingfa-hf@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctint-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2018, 2020, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jquanti-mmi.c:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2017, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ * Copyright (C) 2018-2019, D. R. Commander.  All Rights Reserved.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit MIPS architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd_mmi.h:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Authors:  ZhuChen     <zhuchen@loongson.cn>
+ *           CaiWanwei   <caiwanwei@loongson.cn>
+ *           SunZhangzhi <sunzhangzhi-cq@loongson.cn>
+ *           QingfaLiu   <liuqingfa-hf@loongson.cn>
+ * Copyright (C) 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/loongson-mmintrin.h:1
+
+/*
+ * Loongson MMI optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
+ *                          All Rights Reserved.
+ * Copyright (C) 2019, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolext-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgryext-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2024, D. R. Commander.  All Rights Reserved.
+ * Copyright (C) 2014, Jay Foad.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolor-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgray-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctfst-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolext-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmrgext-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdsample-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolor-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmerge-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2015, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctint-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014, 2020, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctfst-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jquanti-altivec.c:1
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd_altivec.h:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctint-altivec.c:1
+
+/*
+ * AltiVec optimizations for libjpeg-turbo
+ *
+ * Copyright (C) 2014-2015, 2020, 2024, D. R. Commander.  All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014-2016, 2018, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * PowerPC architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c:1
+
+/*
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2011, 2014, 2016, 2018, 2022-2024, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ * This file contains the interface between the "normal" portions
+ * of the library and the SIMD implementations when running on a
+ * 64-bit x86 architecture.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jaricom.c:1
+
+/*
+ * jaricom.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2018, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains probability estimation tables for common use in
+ * arithmetic entropy encoding and decoding routines.
+ *
+ * This data represents Table D.2 in
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994 and Table 24 in
+ * Recommendation ITU-T T.82 (1993) | ISO/IEC 11544:1993.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapimin.c:1
+
+/*
+ * jcapimin.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c.  But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcapistd.c:1
+
+/*
+ * jcapistd.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-compression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_compress, it will end up linking in the entire compressor.
+ * We thus must separate this file from jcapimin.c to avoid linking the
+ * whole compression library into a transcoder.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcarith.c:1
+
+/*
+ * jcarith.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2018, 2021-2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains portable arithmetic entropy encoding routines for JPEG
+ * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ *
+ * Both sequential and progressive modes are supported in this single module.
+ *
+ * Suspension is not currently supported in this module.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccoefct.c:1
+
+/*
+ * jccoefct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the lossy JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccolext.c:1
+
+/*
+ * jccolext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2012, 2015, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jccolor.c:1
+
+/*
+ * jccolor.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009-2012, 2015, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdctmgr.c:1
+
+/*
+ * jcdctmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014-2015, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcdiffct.c:1
+
+/*
+ * jcdiffct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the difference buffer controller for compression.
+ * This controller is the top level of the lossless JPEG compressor proper.
+ * The difference buffer lies between the prediction/differencing and entropy
+ * encoding steps.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c:1
+
+/*
+ * jchuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2014-2016, 2018-2025, D. R. Commander.
+ * Copyright (C) 2015, Matthieu Darbois.
+ * Copyright (C) 2018, Matthias Räncker.
+ * Copyright (C) 2020, Arm Limited.
+ * Copyright (C) 2022, Felix Hanau.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c:580
+
+/* This is a well-known technique for obtaining the absolute value without a
+   * branch.  It is derived from an assembly language technique presented in
+   * "How to Optimize for the Pentium Processors", Copyright (c) 1996, 1997 by
+   * Agner Fog.  This code assumes we are on a two's complement machine.
+   */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.h:1
+
+/*
+ * jchuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c).  No other modules need to see these.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcicc.c:1
+
+/*
+ * jcicc.c
+ *
+ * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
+ * Copyright (C) 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides code to write International Color Consortium (ICC) device
+ * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
+ * for including such data in JPEG "APP2" markers.  The code given here does
+ * not know anything about the internal structure of the ICC profile data; it
+ * just knows how to embed the profile data in a JPEG file while writing it.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcinit.c:1
+
+/*
+ * jcinit.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c.  It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclhuff.c:1
+
+/*
+ * jclhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy encoding routines for lossless JPEG.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jclossls.c:1
+
+/*
+ * jclossls.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1998, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains prediction, sample differencing, and point transform
+ * routines for the lossless JPEG compressor.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmainct.c:1
+
+/*
+ * jcmainct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmarker.c:1
+
+/*
+ * jcmarker.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.c:1
+
+/*
+ * jcmaster.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2003-2010 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, 2018, 2022-2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work
+ * to be done in each pass).
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.h:1
+
+/*
+ * jcmaster.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2016, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains master control structure for the JPEG compressor.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcomapi.c:1
+
+/*
+ * jcomapi.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcparam.c:1
+
+/*
+ * jcparam.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2003-2008 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2018, 2023-2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c:1
+
+/*
+ * jcphuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2015, 2018, 2021-2022, 2024, D. R. Commander.
+ * Copyright (C) 2016, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ * Copyright (C) 2021, Alex Richardson.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c:496
+
+/* This is a well-known technique for obtaining the absolute value without
+     * a branch.  It is derived from an assembly language technique presented
+     * in "How to Optimize for the Pentium Processors", Copyright (c) 1996,
+     * 1997 by Agner Fog.
+     */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcprepct.c:1
+
+/*
+ * jcprepct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler.  See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcsample.c:1
+
+/*
+ * jcsample.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, 2019, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups".  A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally.  The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup.  In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel.  The hi-falutin sampling literature
+ * refers to this as a "box filter".  In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad.  If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided.  This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol).  When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jcstest.c:1
+
+/*
+ * Copyright (C)2011 D. R. Commander.  All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ * - Neither the name of the libjpeg-turbo Project nor the names of its
+ *   contributors may be used to endorse or promote products derived from this
+ *   software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jctrans.c:1
+
+/*
+ * jctrans.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1998, Thomas G. Lane.
+ * Modified 2000-2009 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapimin.c:1
+
+/*
+ * jdapimin.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2016, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdapistd.c:1
+
+/*
+ * jdapistd.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2015-2020, 2022-2025, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-decompression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdarith.c:1
+
+/*
+ * jdarith.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Developed 1997-2015 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains portable arithmetic entropy encoding routines for JPEG
+ * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1).
+ *
+ * Both sequential and progressive modes are supported in this single module.
+ *
+ * Suspension is not currently supported in this module.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst-tj.c:1
+
+/*
+ * jdatadst-tj.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2012 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2014, 2016, 2019, 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to memory or to a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst.c:1
+
+/*
+ * jdatadst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2012 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, 2016, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to memory or to a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc-tj.c:1
+
+/*
+ * jdatasrc-tj.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2016, 2019, 2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from memory or from a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc.c:1
+
+/*
+ * jdatasrc.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2009-2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, 2016, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from memory or from a file (or any stdio stream).
+ * While these routines are sufficient for most applications,
+ * some will want to use a different source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.c:1
+
+/*
+ * jdcoefct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015-2016, 2019-2020, 2022-2024, D. R. Commander.
+ * Copyright (C) 2015, 2020, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the lossy JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.h:1
+
+/*
+ * jdcoefct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2020, Google, Inc.
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcol565.c:1
+
+/*
+ * jdcol565.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modifications:
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2014-2015, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolext.c:1
+
+/*
+ * jdcolext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2011, 2015, 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolor.c:1
+
+/*
+ * jdcolor.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2011 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009, 2011-2012, 2014-2015, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdct.h:1
+
+/*
+ * jdct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddctmgr.c:1
+
+/*
+ * jddctmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2002-2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015, 2022, D. R. Commander.
+ * Copyright (C) 2013, MIPS Technologies, Inc., California.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores.  No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper.  This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jddiffct.c:1
+
+/*
+ * jddiffct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the [un]difference buffer controller for decompression.
+ * This controller is the top level of the lossless JPEG decompressor proper.
+ * The difference buffer lies between the entropy decoding and
+ * prediction/undifferencing steps.  The undifference buffer lies between the
+ * prediction/undifferencing and scaling steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.c:1
+
+/*
+ * jdhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2016, 2018-2019, 2022, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.h:1
+
+/*
+ * jdhuff.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010-2011, 2015-2016, 2021, D. R. Commander.
+ * Copyright (C) 2018, Matthias Räncker.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c), the progressive
+ * decoder (jdphuff.c), and the lossless decoder (jdlhuff.c).  No other modules
+ * need to see these.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdicc.c:1
+
+/*
+ * jdicc.c
+ *
+ * Copyright (C) 1997-1998, Thomas G. Lane, Todd Newman.
+ * Copyright (C) 2017, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides code to read International Color Consortium (ICC) device
+ * profiles embedded in JFIF JPEG image files.  The ICC has defined a standard
+ * for including such data in JPEG "APP2" markers.  The code given here does
+ * not know anything about the internal structure of the ICC profile data; it
+ * just knows how to get the profile data from a JPEG file while reading it.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdinput.c:1
+
+/*
+ * jdinput.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, 2018, 2022, 2024, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient/difference decoding).
+ * The actual input reading is done in jdmarker.c, jdhuff.c, jdphuff.c,
+ * and jdlhuff.c.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlhuff.c:1
+
+/*
+ * jdlhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy decoding routines for lossless JPEG.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdlossls.c:1
+
+/*
+ * jdlossls.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1998, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains prediction, sample undifferencing, point transform, and
+ * sample scaling routines for the lossless JPEG decompressor.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.c:1
+
+/*
+ * jdmainct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2010, 2016, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.h:1
+
+/*
+ * jdmainct.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmarker.c:1
+
+/*
+ * jdmarker.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2012, 2015, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application.  On resumption, we reprocess
+ * the marker.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.c:1
+
+/*
+ * jdmaster.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 2002-2009 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2016, 2019, 2022-2024, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.h:1
+
+/*
+ * jdmaster.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the master control structure for the JPEG decompressor.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.c:1
+
+/*
+ * jdmerge.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2009, 2011, 2014-2015, 2020, 2022, D. R. Commander.
+ * Copyright (C) 2013, Linaro Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ *
+ * This file combines functions from jdsample.c and jdcolor.c;
+ * read those files first to understand what's going on.
+ *
+ * When the chroma components are to be upsampled by simple replication
+ * (ie, box filtering), we can save some work in color conversion by
+ * calculating all the output pixels corresponding to a pair of chroma
+ * samples at one time.  In the conversion equations
+ *      R = Y           + K1 * Cr
+ *      G = Y + K2 * Cb + K3 * Cr
+ *      B = Y + K4 * Cb
+ * only the Y term varies among the group of pixels corresponding to a pair
+ * of chroma samples, so the rest of the terms can be calculated just once.
+ * At typical sampling ratios, this eliminates half or three-quarters of the
+ * multiplications needed for color conversion.
+ *
+ * This file currently provides implementations for the following cases:
+ *      YCbCr => RGB color conversion only.
+ *      Sampling ratios of 2h1v or 2h2v.
+ *      No scaling needed at upsample time.
+ *      Corner-aligned (non-CCIR601) sampling alignment.
+ * Other special cases could be added, but in most applications these are
+ * the only common cases.  (For uncommon cases we fall back on the more
+ * general code in jdsample.c and jdcolor.c.)
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.h:1
+
+/*
+ * jdmerge.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrg565.c:1
+
+/*
+ * jdmrg565.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, Linaro Limited.
+ * Copyright (C) 2014-2015, 2018, 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrgext.c:1
+
+/*
+ * jdmrgext.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2011, 2015, 2020, 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdphuff.c:1
+
+/*
+ * jdphuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2016, 2018-2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains Huffman entropy decoding routines for progressive JPEG.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ *
+ * NOTE: All referenced figures are from
+ * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdpostct.c:1
+
+/*
+ * jdpostct.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022-2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.c:1
+
+/*
+ * jdsample.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2010, 2015-2016, 2022, 2024-2025, D. R. Commander.
+ * Copyright (C) 2014, MIPS Technologies, Inc., California.
+ * Copyright (C) 2015, Google, Inc.
+ * Copyright (C) 2019-2020, Arm Limited.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.h:1
+
+/*
+ * jdsample.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jdtrans.c:1
+
+/*
+ * jdtrans.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.c:1
+
+/*
+ * jerror.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do.  Many applications will want to replace
+ * some or all of these routines.
+ *
+ * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
+ * you get a Windows-specific hack to display error messages in a dialog box.
+ * It ain't much, but it beats dropping error messages into the bit bucket,
+ * which is what happens to output to stderr under most Windows C compilers.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.h:1
+
+/*
+ * jerror.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2014, 2017, 2021-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too.  Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctflt.c:1
+
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctfst.c:1
+
+/*
+ * jfdctfst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values.  The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctint.c:1
+
+/*
+ * jfdctint.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a slower but more accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctflt.c:1
+
+/*
+ * jidctflt.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * Modified 2010 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2014, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctfst.c:1
+
+/*
+ * jidctfst.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README.ijg).  The following
+ * code is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values.  The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctint.c:1
+
+/*
+ * jidctint.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modification developed 2002-2018 by Guido Vollbeding.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains a slower but more accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ *
+ * We also provide IDCT routines with various output sample block sizes for
+ * direct resolution reduction or enlargement without additional resampling:
+ * NxN (N=1...16) pixels for one 8x8 input DCT block.
+ *
+ * For N<8 we simply take the corresponding low-frequency coefficients of
+ * the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
+ * to yield the downscaled outputs.
+ * This can be seen as direct low-pass downsampling from the DCT domain
+ * point of view rather than the usual spatial domain point of view,
+ * yielding significant computational savings and results at least
+ * as good as common bilinear (averaging) spatial downsampling.
+ *
+ * For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
+ * lower frequencies and higher frequencies assumed to be zero.
+ * It turns out that the computational effort is similar to the 8x8 IDCT
+ * regarding the output size.
+ * Furthermore, the scaling and descaling is the same for all IDCT sizes.
+ *
+ * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
+ * since there would be too many additional constants to pre-calculate.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jidctred.c:1
+
+/*
+ * jidctred.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains inverse-DCT routines that produce reduced-size output:
+ * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
+ *
+ * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M)
+ * algorithm used in jidctint.c.  We simply replace each 8-to-8 1-D IDCT step
+ * with an 8-to-4 step that produces the four averages of two adjacent outputs
+ * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
+ * These steps were derived by computing the corresponding values at the end
+ * of the normal LL&M code, then simplifying as much as possible.
+ *
+ * 1x1 is trivial: just take the DC coefficient divided by 8.
+ *
+ * See jidctint.c for additional comments.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jinclude.h:1
+
+/*
+ * jinclude.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files.  (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library.  Most applications need only include jpeglib.h.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jlossls.h:1
+
+/*
+ * jlossls.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1998, Thomas G. Lane.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This include file contains common declarations for the lossless JPEG
+ * codec modules.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemmgr.c:1
+
+/*
+ * jmemmgr.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2016, 2021-2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains the JPEG system-independent memory management
+ * routines.  This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ *   * pool-based allocation and freeing of memory;
+ *   * policy decisions about how to divide available memory among the
+ *     virtual arrays;
+ *   * control logic for swapping virtual arrays between main memory and
+ *     backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems.  For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed.  (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemnobs.c:1
+
+/*
+ * jmemnobs.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1992-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2017-2018, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager.  This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmemsys.h:1
+
+/*
+ * jmemsys.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1992-1997, Thomas G. Lane.
+ * It was modified by The libjpeg-turbo Project to include only code and
+ * information relevant to libjpeg-turbo.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager.  No other
+ * modules need include it.  (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution.  You may need to modify it if you write a
+ * custom memory manager.  If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jmorecfg.h:1
+
+/*
+ * jmorecfg.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2011, 2014-2015, 2018, 2020, 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.c:1
+
+/*
+ * Copyright (C) 2024-2025, D. R. Commander.
+ *
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.h:1
+
+/*
+ * Copyright (C) 2014, 2021, 2024-2025, D. R. Commander.
+ * Copyright (C) 2014, Olle Liljenzin.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpegapicomp.h:1
+
+/*
+ * jpegapicomp.h
+ *
+ * Copyright (C) 2010, 2020, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * JPEG compatibility macros
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpegint.h:1
+
+/*
+ * jpegint.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2009 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015-2017, 2019, 2021-2022, 2024, D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * Copyright (C) 2021, Alex Richardson.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jpeglib.h:1
+
+/*
+ * jpeglib.h
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * Modified 2002-2009 by Guido Vollbeding.
+ * Lossless JPEG Modifications:
+ * Copyright (C) 1999, Ken Murchison.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009-2011, 2013-2014, 2016-2017, 2020, 2022-2024,
+             D. R. Commander.
+ * Copyright (C) 2015, Google, Inc.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant1.c:1
+
+/*
+ * jquant1.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2015, 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains 1-pass color quantization (color mapping) routines.
+ * These routines provide mapping to a fixed color map using equally spaced
+ * color values.  Optional Floyd-Steinberg or ordered dithering is available.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jquant2.c:1
+
+/*
+ * jquant2.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2009, 2014-2015, 2020, 2022-2023, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains 2-pass color quantization (color mapping) routines.
+ * These routines provide selection of a custom color map for an image,
+ * followed by mapping of the image to that color map, with optional
+ * Floyd-Steinberg dithering.
+ * It is also possible to use just the second pass to map to an arbitrary
+ * externally-given color map.
+ *
+ * Note: ordered dithering is not supported, since there isn't any fast
+ * way to compute intercolor distances; it's unclear that ordered dither's
+ * fundamental assumptions even hold with an irregularly spaced color map.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jsamplecomp.h:1
+
+/*
+ * jsamplecomp.h
+ *
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jsimd.h:1
+
+/*
+ * jsimd.h
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright (C) 2011, 2014, 2022, D. R. Commander.
+ * Copyright (C) 2015-2016, 2018, 2022, Matthieu Darbois.
+ * Copyright (C) 2020, Arm Limited.
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jsimddct.h:1
+
+/*
+ * jsimddct.h
+ *
+ * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ *
+ * Based on the x86 SIMD extension for IJG JPEG library,
+ * Copyright (C) 1999-2006, MIYASAKA Masaru.
+ * For conditions of distribution and use, see copyright notice in jsimdext.inc
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jstdhuff.c:1
+
+/*
+ * jstdhuff.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2013, 2022, 2024, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains routines to set the default Huffman tables, if they are
+ * not already set.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libjpeg-turbo/src/jutils.c:1
+
+/*
+ * jutils.c
+ *
+ * This file was part of the Independent JPEG Group's software:
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2022, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
+ *
+ * This file contains tables and miscellaneous utility routines needed
+ * for both compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/CHANGES:562
+
+/*.c
+  Updated scripts/makevms.com and added makevms.com to contrib/gregbook
+    and contrib/pngminus (Martin Zinser)
+
+Version 1.0.5c [November 26, 1999]
+  Moved png_get_header_version from png.h to png.c, to accommodate ansi2knr.
+  Removed all global arrays (according to PNG_NO_GLOBAL_ARRAYS macro), to
+    accommodate making DLL's: Moved usr_png_ver from global variable to function
+    png_get_header_ver() in png.c.  Moved png_sig to png_sig_bytes in png.c and
+    eliminated use of png_sig in pngwutil.c.  Moved the various png_CHNK arrays
+    into pngtypes.h.  Eliminated use of global png_pass arrays.  Declared the
+    png_CHNK and png_pass arrays to be "const".  Made the global arrays
+    available to applications (although none are used in libpng itself) when
+    PNG_NO_GLOBAL_ARRAYS is not defined or when PNG_GLOBAL_ARRAYS is defined.
+  Removed some extraneous "-I" from contrib/pngminus/makefile.std
+  Changed the PNG_sRGB_INTENT macros in png.h to be consistent with PNG-1.2.
+  Change PNG_SRGB_INTENT to PNG_sRGB_INTENT in libpng.txt and libpng.3
+
+Version 1.0.5d [November 29, 1999]
+  Add type cast (png_const_charp) two places in png.c
+  Eliminated pngtypes.h; use macros instead to declare PNG_CHNK arrays.
+  Renamed "PNG_GLOBAL_ARRAYS" to "PNG_USE_GLOBAL_ARRAYS" and made available
+    to applications a macro "PNG_USE_LOCAL_ARRAYS".
+  comment out (with #ifdef) all the new declarations when
+    PNG_USE_GLOBAL_ARRAYS is defined.
+  Added PNG_EXPORT_VAR macro to accommodate making DLL's.
+
+Version 1.0.5e [November 30, 1999]
+  Added iCCP, iTXt, and sPLT support; added "lang" member to the png_text
+    structure; refactored the inflate/deflate support to make adding new chunks
+    with trailing compressed parts easier in the future, and added new functions
+    png_free_iCCP, png_free_pCAL, png_free_sPLT, png_free_text, png_get_iCCP,
+    png_get_spalettes, png_set_iCCP, png_set_spalettes (Eric S. Raymond).
+    NOTE: Applications that write text chunks MUST define png_text->lang
+    before calling png_set_text(). It must be set to NULL if you want to
+    write tEXt or zTXt chunks.  If you want your application to be able to
+    run with older versions of libpng, use
+
+      #ifdef PNG_iTXt_SUPPORTED
+         png_text[i].lang = NULL;
+      #endif
+
+  Changed png_get_oFFs() and png_set_oFFs() to use signed rather than unsigned
+    offsets (Eric S. Raymond).
+  Combined PNG_READ_cHNK_SUPPORTED and PNG_WRITE_cHNK_SUPPORTED macros into
+    PNG_cHNK_SUPPORTED and combined the three types of PNG_text_SUPPORTED
+    macros, leaving the separate macros also available.
+  Removed comments on #endifs at the end of many short, non-nested #if-blocks.
+
+Version 1.0.5f [December 6, 1999]
+  Changed makefile.solaris to issue a warning about potential problems when
+    the ucb "ld" is in the path ahead of the ccs "ld".
+  Removed "- [date]" from the "synopsis" line in libpng.3 and libpngpf.3.
+  Added sCAL chunk support (Eric S. Raymond).
+
+Version 1.0.5g [December 7, 1999]
+  Fixed "png_free_spallettes" typo in png.h
+  Added code to handle new chunks in pngpread.c
+  Moved PNG_CHNK string macro definitions outside of PNG_NO_EXTERN block
+  Added "translated_key" to png_text structure and png_write_iTXt().
+  Added code in pngwrite.c to work around a newly discovered zlib bug.
+
+Version 1.0.5h [December 10, 1999]
+  NOTE: regarding the note for version 1.0.5e, the following must also
+    be included in your code:
+        png_text[i].translated_key = NULL;
+  Unknown chunk handling is now supported.
+  Option to eliminate all floating point support was added.  Some new
+    fixed-point functions such as png_set_gAMA_fixed() were added.
+  Expanded tabs and removed trailing blanks in source files.
+
+Version 1.0.5i [December 13, 1999]
+  Added some type casts to silence compiler warnings.
+  Renamed "png_free_spalette" to "png_free_spalettes" for consistency.
+  Removed leading blanks from a #define in pngvcrd.c
+  Added some parameters to the new png_set_keep_unknown_chunks() function.
+  Added a test for up->location != 0 in the first instance of writing
+    unknown chunks in pngwrite.c
+  Changed "num" to "i" in png_free_spalettes() and png_free_unknowns() to
+    prevent recursion.
+  Added png_free_hIST() function.
+  Various patches to fix bugs in the sCAL and integer cHRM processing,
+    and to add some convenience macros for use with sCAL.
+
+Version 1.0.5j [December 21, 1999]
+  Changed "unit" parameter of png_write_sCAL from png_byte to int, to work
+    around buggy compilers.
+  Added new type "png_fixed_point" for integers that hold float*100000 values
+  Restored backward compatibility of tEXt/zTXt chunk processing:
+    Restored the first four members of png_text to the same order as v.1.0.5d.
+    Added members "lang_key" and "itxt_length" to png_text struct.  Set
+    text_length=0 when "text" contains iTXt data.  Use the "compression"
+    member to distinguish among tEXt/zTXt/iTXt types.  Added
+    PNG_ITXT_COMPRESSION_NONE (1) and PNG_ITXT_COMPRESSION_zTXt(2) macros.
+    The "Note" above, about backward incompatibility of libpng-1.0.5e, no
+    longer applies.
+  Fixed png_read|write_iTXt() to read|write parameters in the right order,
+    and to write the iTXt chunk after IDAT if it appears in the end_ptr.
+  Added pnggccrd.c, version of pngvcrd.c Intel assembler for gcc (Greg Roelofs)
+  Reversed the order of trying to write floating-point and fixed-point gAMA.
+
+Version 1.0.5k [December 27, 1999]
+  Added many parentheses, e.g., "if (a && b & c)" becomes "if (a && (b & c))"
+  Added png_handle_as_unknown() function (Glenn)
+  Added png_free_chunk_list() function and chunk_list and num_chunk_list members
+    of png_ptr.
+  Eliminated erroneous warnings about multiple sPLT chunks and sPLT-after-PLTE.
+  Fixed a libpng-1.0.5h bug in pngrutil.c that was issuing erroneous warnings
+    about ignoring incorrect gAMA with sRGB (gAMA was in fact not ignored)
+  Added png_free_tRNS(); png_set_tRNS() now malloc's its own trans array (ESR).
+  Define png_get_int_32 when oFFs chunk is supported as well as when pCAL is.
+  Changed type of proflen from png_int_32 to png_uint_32 in png_get_iCCP().
+
+Version 1.0.5l [January 1, 2000]
+  Added functions png_set_read_user_chunk_fn() and png_get_user_chunk_ptr()
+    for setting a callback function to handle unknown chunks and for
+    retrieving the associated user pointer (Glenn).
+
+Version 1.0.5m [January 7, 2000]
+  Added high-level functions png_read_png(), png_write_png(), png_free_pixels().
+
+Version 1.0.5n [January 9, 2000]
+  Added png_free_PLTE() function, and modified png_set_PLTE() to malloc its
+    own memory for info_ptr->palette.  This makes it safe for the calling
+    application to free its copy of the palette any time after it calls
+    png_set_PLTE().
+
+Version 1.0.5o [January 20, 2000]
+  Cosmetic changes only (removed some trailing blanks and TABs)
+
+Version 1.0.5p [January 31, 2000]
+  Renamed pngdll.mak to makefile.bd32
+  Cosmetic changes in pngtest.c
+
+Version 1.0.5q [February 5, 2000]
+  Relocated the makefile.solaris warning about PATH problems.
+  Fixed pngvcrd.c bug by pushing/popping registers in mmxsupport (Bruce Oberg)
+  Revised makefile.gcmmx
+  Added PNG_SETJMP_SUPPORTED, PNG_SETJMP_NOT_SUPPORTED, and PNG_ABORT() macros
+
+Version 1.0.5r [February 7, 2000]
+  Removed superfluous prototype for png_get_itxt from png.h
+  Fixed a bug in pngrtran.c that improperly expanded the background color.
+  Return *num_text=0 from png_get_text() when appropriate, and fix documentation
+    of png_get_text() in libpng.txt/libpng.3.
+
+Version 1.0.5s [February 18, 2000]
+  Added "png_jmp_env()" macro to pngconf.h, to help people migrate to the
+    new error handler that's planned for the next libpng release, and changed
+    example.c, pngtest.c, and contrib programs to use this macro.
+  Revised some of the DLL-export macros in pngconf.h (Greg Roelofs)
+  Fixed a bug in png_read_png() that caused it to fail to expand some images
+    that it should have expanded.
+  Fixed some mistakes in the unused and undocumented INCH_CONVERSIONS functions
+    in pngget.c
+  Changed the allocation of palette, history, and trans arrays back to
+    the version 1.0.5 method (linking instead of copying) which restores
+    backward compatibility with version 1.0.5.  Added some remarks about
+    that in example.c.  Added "free_me" member to info_ptr and png_ptr
+    and added png_free_data() function.
+  Updated makefile.linux and makefile.gccmmx to make directories conditionally.
+  Made cosmetic changes to pngasmrd.h
+  Added png_set_rows() and png_get_rows(), for use with png_read|write_png().
+  Modified png_read_png() to allocate info_ptr->row_pointers only if it
+    hasn't already been allocated.
+
+Version 1.0.5t [March 4, 2000]
+  Changed png_jmp_env() migration aiding macro to png_jmpbuf().
+  Fixed "interlace" typo (should be "interlaced") in contrib/gregbook/read2-x.c
+  Fixed bug with use of PNG_BEFORE_IHDR bit in png_ptr->mode, introduced when
+    PNG_FLAG_HAVE_CHUNK_HEADER was moved into png_ptr->mode in version 1.0.5b
+  Files in contrib/gregbook were revised to use png_jmpbuf() and to select
+    a 24-bit visual if one is available, and to allow abbreviated options.
+  Files in contrib/pngminus were revised to use the png_jmpbuf() macro.
+  Removed spaces in makefile.linux and makefile.gcmmx, introduced in 1.0.5s
+
+Version 1.0.5u [March 5, 2000]
+  Simplified the code that detects old png.h in png.c and pngtest.c
+  Renamed png_spalette (_p, _pp) to png_sPLT_t (_tp, _tpp)
+  Increased precision of rgb_to_gray calculations from 8 to 15 bits and
+    added png_set_rgb_to_gray_fixed() function.
+  Added makefile.bc32 (32-bit Borland C++, C mode)
+
+Version 1.0.5v [March 11, 2000]
+  Added some parentheses to the png_jmpbuf macro definition.
+  Updated references to the zlib home page, which has moved to freesoftware.com.
+  Corrected bugs in documentation regarding png_read_row() and png_write_row().
+  Updated documentation of png_rgb_to_gray calculations in libpng.3/libpng.txt.
+  Renamed makefile.borland,turboc3 back to makefile.bor,tc3 as in version 1.0.3,
+    revised borland makefiles; added makefile.ibmvac3 and makefile.gcc (Cosmin)
+
+Version 1.0.6 [March 20, 2000]
+  Minor revisions of makefile.bor, libpng.txt, and gregbook/rpng2-win.c
+  Added makefile.sggcc (SGI IRIX with gcc)
+
+Version 1.0.6d [April 7, 2000]
+  Changed sprintf() to strcpy() in png_write_sCAL_s() to work without STDIO
+  Added data_length parameter to png_decompress_chunk() function
+  Revised documentation to remove reference to abandoned png_free_chnk functions
+  Fixed an error in png_rgb_to_gray_fixed()
+  Revised example.c, usage of png_destroy_write_struct().
+  Renamed makefile.ibmvac3 to makefile.ibmc, added libpng.icc IBM project file
+  Added a check for info_ptr->free_me&PNG_FREE_TEXT when freeing text in png.c
+  Simplify png_sig_bytes() function to remove use of non-ISO-C strdup().
+
+Version 1.0.6e [April 9, 2000]
+  Added png_data_freer() function.
+  In the code that checks for over-length tRNS chunks, added check of
+    info_ptr->num_trans as well as png_ptr->num_trans (Matthias Benckmann)
+  Minor revisions of libpng.txt/libpng.3.
+  Check for existing data and free it if the free_me flag is set, in png_set_*()
+    and png_handle_*().
+  Only define PNG_WEIGHTED_FILTERS_SUPPORTED when PNG_FLOATING_POINT_SUPPORTED
+    is defined.
+  Changed several instances of PNG_NO_CONSOLE_ID to PNG_NO_STDIO in pngrutil.c
+    and mentioned the purposes of the two macros in libpng.txt/libpng.3.
+
+Version 1.0.6f [April 14, 2000]
+  Revised png_set_iCCP() and png_set_rows() to avoid prematurely freeing data.
+  Add checks in png_set_text() for NULL members of the input text structure.
+  Revised libpng.txt/libpng.3.
+  Removed superfluous prototype for png_set_iTXt from png.h
+  Removed "else" from pngread.c, after png_error(), and changed "0" to "length".
+  Changed several png_errors about malformed ancillary chunks to png_warnings.
+
+Version 1.0.6g [April 24, 2000]
+  Added png_pass-* arrays to pnggccrd.c when PNG_USE_LOCAL_ARRAYS is defined.
+  Relocated paragraph about png_set_background() in libpng.3/libpng.txt
+    and other revisions (Matthias Benckmann)
+  Relocated info_ptr->free_me, png_ptr->free_me, and other info_ptr and
+    png_ptr members to restore binary compatibility with libpng-1.0.5
+    (breaks compatibility with libpng-1.0.6).
+
+Version 1.0.6h [April 24, 2000]
+  Changed shared library so-number pattern from 2.x.y.z to xy.z (this builds
+    libpng.so.10 & libpng.so.10.6h instead of libpng.so.2 & libpng.so.2.1.0.6h)
+    This is a temporary change for test purposes.
+
+Version 1.0.6i [May 2, 2000]
+  Rearranged some members at the end of png_info and png_struct, to put
+    unknown_chunks_num and free_me within the original size of the png_structs
+    and free_me, png_read_user_fn, and png_free_fn within the original png_info,
+    because some old applications allocate the structs directly instead of
+    using png_create_*().
+  Added documentation of user memory functions in libpng.txt/libpng.3
+  Modified png_read_png so that it will use user_allocated row_pointers
+    if present, unless free_me directs that it be freed, and added description
+    of the use of png_set_rows() and png_get_rows() in libpng.txt/libpng.3.
+  Added PNG_LEGACY_SUPPORTED macro, and #ifdef out all new (since version
+    1.00) members of png_struct and png_info, to regain binary compatibility
+    when you define this macro.  Capabilities lost in this event
+    are user transforms (new in version 1.0.0),the user transform pointer
+    (new in version 1.0.2), rgb_to_gray (new in 1.0.5), iCCP, sCAL, sPLT,
+    the high-level interface, and unknown chunks support (all new in 1.0.6).
+    This was necessary because of old applications that allocate the structs
+    directly as authors were instructed to do in libpng-0.88 and earlier,
+    instead of using png_create_*().
+  Added modes PNG_CREATED_READ_STRUCT and PNG_CREATED_WRITE_STRUCT which
+    can be used to detect codes that directly allocate the structs, and
+    code to check these modes in png_read_init() and png_write_init() and
+    generate a libpng error if the modes aren't set and PNG_LEGACY_SUPPORTED
+    was not defined.
+  Added makefile.intel and updated makefile.watcom (Pawel Mrochen)
+
+Version 1.0.6j [May 3, 2000]
+  Overloaded png_read_init() and png_write_init() with macros that convert
+    calls to png_read_init_2() or png_write_init_2() that check the version
+    and structure sizes.
+
+Version 1.0.7beta11 [May 7, 2000]
+  Removed the new PNG_CREATED_READ_STRUCT and PNG_CREATED_WRITE_STRUCT modes
+    which are no longer used.
+  Eliminated the three new members of png_text when PNG_LEGACY_SUPPORTED is
+    defined or when neither PNG_READ_iTXt_SUPPORTED nor PNG_WRITE_iTXt_SUPPORTED
+    is defined.
+  Made PNG_NO_READ|WRITE_iTXt the default setting, to avoid memory
+    overrun when old applications fill the info_ptr->text structure directly.
+  Added PNGAPI macro, and added it to the definitions of all exported functions.
+  Relocated version macro definitions ahead of the includes of zlib.h and
+    pngconf.h in png.h.
+
+Version 1.0.7beta12 [May 12, 2000]
+  Revised pngset.c to avoid a problem with expanding the png_debug macro.
+  Deleted some extraneous defines from pngconf.h
+  Made PNG_NO_CONSOLE_IO the default condition when PNG_BUILD_DLL is defined.
+  Use MSC _RPTn debugging instead of fprintf if _MSC_VER is defined.
+  Added png_access_version_number() function.
+  Check for mask&PNG_FREE_CHNK (for TEXT, SCAL, PCAL) in png_free_data().
+  Expanded libpng.3/libpng.txt information about png_data_freer().
+
+Version 1.0.7beta14 [May 17, 2000] (beta13 was not published)
+  Changed pnggccrd.c and pngvcrd.c to handle bad adaptive filter types as
+    warnings instead of errors, as pngrutil.c does.
+  Set the PNG_INFO_IDAT valid flag in png_set_rows() so png_write_png()
+    will actually write IDATs.
+  Made the default PNG_USE_LOCAL_ARRAYS depend on PNG_DLL instead of WIN32.
+  Make png_free_data() ignore its final parameter except when freeing data
+    that can have multiple instances (text, sPLT, unknowns).
+  Fixed a new bug in png_set_rows().
+  Removed info_ptr->valid tests from png_free_data(), as in version 1.0.5.
+  Added png_set_invalid() function.
+  Fixed incorrect illustrations of png_destroy_write_struct() in example.c.
+
+Version 1.0.7beta15 [May 30, 2000]
+  Revised the deliberately erroneous Linux setjmp code in pngconf.h to produce
+    fewer error messages.
+  Rearranged checks for Z_OK to check the most likely path first in pngpread.c
+    and pngwutil.c.
+  Added checks in pngtest.c for png_create_*() returning NULL, and mentioned
+    in libpng.txt/libpng.3 the need for applications to check this.
+  Changed names of png_default_*() functions in pngtest to pngtest_*().
+  Changed return type of png_get_x|y_offset_*() from png_uint_32 to png_int_32.
+  Fixed some bugs in the unused PNG_INCH_CONVERSIONS functions in pngget.c
+  Set each pointer to NULL after freeing it in png_free_data().
+  Worked around a problem in pngconf.h; AIX's strings.h defines an "index"
+    macro that conflicts with libpng's png_color_16.index. (Dimitri
+    Papadapoulos)
+  Added "msvc" directory with MSVC++ project files (Simon-Pierre Cadieux).
+
+Version 1.0.7beta16 [June 4, 2000]
+  Revised the workaround of AIX string.h "index" bug.
+  Added a check for overlength PLTE chunk in pngrutil.c.
+  Added PNG_NO_POINTER_INDEXING macro to use array-indexing instead of pointer
+    indexing in pngrutil.c and pngwutil.c to accommodate a buggy compiler.
+  Added a warning in png_decompress_chunk() when it runs out of data, e.g.
+    when it tries to read an erroneous PhotoShop iCCP chunk.
+  Added PNG_USE_DLL macro.
+  Revised the copyright/disclaimer/license notice.
+  Added contrib/msvctest directory
+
+Version 1.0.7rc1 [June 9, 2000]
+  Corrected the definition of PNG_TRANSFORM_INVERT_ALPHA  (0x0400 not 0x0200)
+  Added contrib/visupng directory (Willem van Schaik)
+
+Version 1.0.7beta18 [June 23, 2000]
+  Revised PNGAPI definition, and pngvcrd.c to work with __GCC__
+    and do not redefine PNGAPI if it is passed in via a compiler directive.
+  Revised visupng/PngFile.c to remove returns from within the Try block.
+  Removed leading underscores from "_PNG_H" and "_PNG_SAVE_BSD_SOURCE" macros.
+  Updated contrib/visupng/cexcept.h to version 1.0.0.
+  Fixed bugs in pngwrite.c and pngwutil.c that prevented writing iCCP chunks.
+
+Version 1.0.7rc2 [June 28, 2000]
+  Updated license to include disclaimers required by UCITA.
+  Fixed "DJBPP" typo in pnggccrd.c introduced in beta18.
+
+Version 1.0.7 [July 1, 2000]
+  Revised the definition of "trans_values" in libpng.3/libpng.txt
+
+Version 1.0.8beta1 [July 8, 2000]
+  Added png_free(png_ptr, key) two places in pngpread.c to stop memory leaks.
+  Changed PNG_NO_STDIO to PNG_NO_CONSOLE_IO, several places in pngrutil.c and
+    pngwutil.c.
+  Changed PNG_EXPORT_VAR to use PNG_IMPEXP, in pngconf.h.
+  Removed unused "#include <assert.h>" from png.c
+  Added WindowsCE support.
+  Revised pnggccrd.c to work with gcc-2.95.2 and in the Cygwin environment.
+
+Version 1.0.8beta2 [July 10, 2000]
+  Added project files to the wince directory and made further revisions
+    of pngtest.c, pngrio.c, and pngwio.c in support of WindowsCE.
+
+Version 1.0.8beta3 [July 11, 2000]
+  Only set the PNG_FLAG_FREE_TRNS or PNG_FREE_TRNS flag in png_handle_tRNS()
+    for indexed-color input files to avoid potential double-freeing trans array
+    under some unusual conditions; problem was introduced in version 1.0.6f.
+  Further revisions to pngtest.c and files in the wince subdirectory.
+
+Version 1.0.8beta4 [July 14, 2000]
+  Added the files pngbar.png and pngbar.jpg to the distribution.
+  Added makefile.cygwin, and cygwin support in pngconf.h
+  Added PNG_NO_ZALLOC_ZERO macro (makes png_zalloc skip zeroing memory)
+
+Version 1.0.8rc1 [July 16, 2000]
+  Revised png_debug() macros and statements to eliminate compiler warnings.
+
+Version 1.0.8 [July 24, 2000]
+  Added png_flush() in pngwrite.c, after png_write_IEND().
+  Updated makefile.hpux to build a shared library.
+
+Version 1.0.9beta1 [November 10, 2000]
+  Fixed typo in scripts/makefile.hpux
+  Updated makevms.com in scripts and contrib/* and contrib/* (Martin Zinser)
+  Fixed sequence-point bug in contrib/pngminus/png2pnm (Martin Zinser)
+  Changed "cdrom.com" in documentation to "libpng.org"
+  Revised pnggccrd.c to get it all working, and updated makefile.gcmmx (Greg).
+  Changed type of "params" from voidp to png_voidp in png_read|write_png().
+  Make sure PNGAPI and PNG_IMPEXP are defined in pngconf.h.
+  Revised the 3 instances of WRITEFILE in pngtest.c.
+  Relocated "msvc" and "wince" project subdirectories into "dll" subdirectory.
+  Updated png.rc in dll/msvc project
+  Revised makefile.dec to define and use LIBPATH and INCPATH
+  Increased size of global png_libpng_ver[] array from 12 to 18 chars.
+  Made global png_libpng_ver[], png_sig[] and png_pass_*[] arrays const.
+  Removed duplicate png_crc_finish() from png_handle_bKGD() function.
+  Added a warning when application calls png_read_update_info() multiple times.
+  Revised makefile.cygwin
+  Fixed bugs in iCCP support in pngrutil.c and pngwutil.c.
+  Replaced png_set_empty_plte_permitted() with png_permit_mng_features().
+
+Version 1.0.9beta2 [November 19, 2000]
+  Renamed the "dll" subdirectory "projects".
+  Added borland project files to "projects" subdirectory.
+  Set VS_FF_PRERELEASE and VS_FF_PATCHED flags in msvc/png.rc when appropriate.
+  Add error message in png_set_compression_buffer_size() when malloc fails.
+
+Version 1.0.9beta3 [November 23, 2000]
+  Revised PNG_LIBPNG_BUILD_TYPE macro in png.h, used in the msvc project.
+  Removed the png_flush() in pngwrite.c that crashes some applications
+    that don't set png_output_flush_fn.
+  Added makefile.macosx and makefile.aix to scripts directory.
+
+Version 1.0.9beta4 [December 1, 2000]
+  Change png_chunk_warning to png_warning in png_check_keyword().
+  Increased the first part of msg buffer from 16 to 18 in png_chunk_error().
+
+Version 1.0.9beta5 [December 15, 2000]
+  Added support for filter method 64 (for PNG datastreams embedded in MNG).
+
+Version 1.0.9beta6 [December 18, 2000]
+  Revised png_set_filter() to accept filter method 64 when appropriate.
+  Added new PNG_HAVE_PNG_SIGNATURE bit to png_ptr->mode and use it to
+    help prevent applications from using MNG features in PNG datastreams.
+  Added png_permit_mng_features() function.
+  Revised libpng.3/libpng.txt.  Changed "filter type" to "filter method".
+
+Version 1.0.9rc1 [December 23, 2000]
+  Revised test for PNG_HAVE_PNG_SIGNATURE in pngrutil.c
+  Fixed error handling of unknown compression type in png_decompress_chunk().
+  In pngconf.h, define __cdecl when _MSC_VER is defined.
+
+Version 1.0.9beta7 [December 28, 2000]
+  Changed PNG_TEXT_COMPRESSION_zTXt to PNG_COMPRESSION_TYPE_BASE several places.
+  Revised memory management in png_set_hIST and png_handle_hIST in a backward
+    compatible manner.  PLTE and tRNS were revised similarly.
+  Revised the iCCP chunk reader to ignore trailing garbage.
+
+Version 1.0.9beta8 [January 12, 2001]
+  Moved pngasmrd.h into pngconf.h.
+  Improved handling of out-of-spec garbage iCCP chunks generated by PhotoShop.
+
+Version 1.0.9beta9 [January 15, 2001]
+  Added png_set_invalid, png_permit_mng_features, and png_mmx_supported to
+    wince and msvc project module definition files.
+  Minor revision of makefile.cygwin.
+  Fixed bug with progressive reading of narrow interlaced images in pngpread.c
+
+Version 1.0.9beta10 [January 16, 2001]
+  Do not typedef png_FILE_p in pngconf.h when PNG_NO_STDIO is defined.
+  Fixed "png_mmx_supported" typo in project definition files.
+
+Version 1.0.9beta11 [January 19, 2001]
+  Updated makefile.sgi to make shared library.
+  Removed png_mmx_support() function and disabled PNG_MNG_FEATURES_SUPPORTED
+    by default, for the benefit of DLL forward compatibility.  These will
+    be re-enabled in version 1.2.0.
+
+Version 1.0.9rc2 [January 22, 2001]
+  Revised cygwin support.
+
+Version 1.0.9 [January 31, 2001]
+  Added check of cygwin's ALL_STATIC in pngconf.h
+  Added "-nommx" parameter to contrib/gregbook/rpng2-win and rpng2-x demos.
+
+Version 1.0.10beta1 [March 14, 2001]
+  Revised makefile.dec, makefile.sgi, and makefile.sggcc; added makefile.hpgcc.
+  Reformatted libpng.3 to eliminate bad line breaks.
+  Added checks for _mmx_supported in the read_filter_row function of pnggccrd.c
+  Added prototype for png_mmx_support() near the top of pnggccrd.c
+  Moved some error checking from png_handle_IHDR to png_set_IHDR.
+  Added PNG_NO_READ_SUPPORTED and PNG_NO_WRITE_SUPPORTED macros.
+  Revised png_mmx_support() function in pnggccrd.c
+  Restored version 1.0.8 PNG_WRITE_EMPTY_PLTE_SUPPORTED behavior in pngwutil.c
+  Fixed memory leak in contrib/visupng/PngFile.c
+  Fixed bugs in png_combine_row() in pnggccrd.c and pngvcrd.c (C version)
+  Added warnings when retrieving or setting gamma=0.
+  Increased the first part of msg buffer from 16 to 18 in png_chunk_warning().
+
+Version 1.0.10rc1 [March 23, 2001]
+  Changed all instances of memcpy, strcpy, and strlen to png_memcpy, png_strcpy,
+    and png_strlen.
+  Revised png_mmx_supported() function in pnggccrd.c to return proper value.
+  Fixed bug in progressive reading (pngpread.c) with small images (height < 8).
+
+Version 1.0.10 [March 30, 2001]
+  Deleted extraneous space (introduced in 1.0.9) from line 42 of makefile.cygwin
+  Added beos project files (Chris Herborth)
+
+Version 1.0.11beta1 [April 3, 2001]
+  Added type casts on several png_malloc() calls (Dimitri Papadapoulos).
+  Removed a no-longer needed AIX work-around from pngconf.h
+  Changed several "//" single-line comments to C-style in pnggccrd.c
+
+Version 1.0.11beta2 [April 11, 2001]
+  Removed PNGAPI from several functions whose prototypes did not have PNGAPI.
+  Updated scripts/pngos2.def
+
+Version 1.0.11beta3 [April 14, 2001]
+  Added checking the results of many instances of png_malloc() for NULL
+
+Version 1.0.11beta4 [April 20, 2001]
+  Undid the changes from version 1.0.11beta3.  Added a check for NULL return
+    from user's malloc_fn().
+  Removed some useless type casts of the NULL pointer.
+  Added makefile.netbsd
+
+Version 1.0.11 [April 27, 2001]
+  Revised makefile.netbsd
+
+Version 1.0.12beta1 [May 14, 2001]
+  Test for Windows platform in pngconf.h when including malloc.h (Emmanuel Blot)
+  Updated makefile.cygwin and handling of Cygwin's ALL_STATIC in pngconf.h
+  Added some never-to-be-executed code in pnggccrd.c to quiet compiler warnings.
+  Eliminated the png_error about apps using png_read|write_init().  Instead,
+    libpng will reallocate the png_struct and info_struct if they are too small.
+    This retains future binary compatibility for old applications written for
+    libpng-0.88 and earlier.
+
+Version 1.2.0beta1 [May 6, 2001]
+  Bumped DLLNUM to 2.
+  Re-enabled PNG_MNG_FEATURES_SUPPORTED and enabled PNG_ASSEMBLER_CODE_SUPPORTED
+    by default.
+  Added runtime selection of MMX features.
+  Added png_set_strip_error_numbers function and related macros.
+
+Version 1.2.0beta2 [May 7, 2001]
+  Finished merging 1.2.0beta1 with version 1.0.11
+  Added a check for attempts to read or write PLTE in grayscale PNG datastreams.
+
+Version 1.2.0beta3 [May 17, 2001]
+  Enabled user memory function by default.
+  Modified png_create_struct so it passes user mem_ptr to user memory allocator.
+  Increased png_mng_features flag from png_byte to png_uint_32.
+  Bumped shared-library (so-number) and dll-number to 3.
+
+Version 1.2.0beta4 [June 23, 2001]
+  Check for missing profile length field in iCCP chunk and free chunk_data
+    in case of truncated iCCP chunk.
+  Bumped shared-library number to 3 in makefile.sgi and makefile.sggcc
+  Bumped dll-number from 2 to 3 in makefile.cygwin
+  Revised contrib/gregbook/rpng*-x.c to avoid a memory leak and to exit cleanly
+    if user attempts to run it on an 8-bit display.
+  Updated contrib/gregbook
+  Use png_malloc instead of png_zalloc to allocate palette in pngset.c
+  Updated makefile.ibmc
+  Added some typecasts to eliminate gcc 3.0 warnings.  Changed prototypes
+    of png_write_oFFS width and height from png_uint_32 to png_int_32.
+  Updated example.c
+  Revised prototypes for png_debug_malloc and png_debug_free in pngtest.c
+
+Version 1.2.0beta5 [August 8, 2001]
+  Revised contrib/gregbook
+  Revised makefile.gcmmx
+  Revised pnggccrd.c to conditionally compile some thread-unsafe code only
+    when PNG_THREAD_UNSAFE_OK is defined.
+  Added tests to prevent pngwutil.c from writing a bKGD or tRNS chunk with
+    value exceeding 2^bit_depth-1
+  Revised makefile.sgi and makefile.sggcc
+  Replaced calls to fprintf(stderr,...) with png_warning() in pnggccrd.c
+  Removed restriction that do_invert_mono only operate on 1-bit opaque files
+
+Version 1.2.0 [September 1, 2001]
+  Changed a png_warning() to png_debug() in pnggccrd.c
+  Fixed contrib/gregbook/rpng-x.c, rpng2-x.c to avoid crash with XFreeGC().
+
+Version 1.2.1beta1 [October 19, 2001]
+  Revised makefile.std in contrib/pngminus
+  Include background_1 in png_struct regardless of gamma support.
+  Revised makefile.netbsd and makefile.macosx, added makefile.darwin.
+  Revised example.c to provide more details about using row_callback().
+
+Version 1.2.1beta2 [October 25, 2001]
+  Added type cast to each NULL appearing in a function call, except for
+    WINCE functions.
+  Added makefile.so9.
+
+Version 1.2.1beta3 [October 27, 2001]
+  Removed type casts from all NULLs.
+  Simplified png_create_struct_2().
+
+Version 1.2.1beta4 [November 7, 2001]
+  Revised png_create_info_struct() and png_creat_struct_2().
+  Added error message if png_write_info() was omitted.
+  Type cast NULLs appearing in function calls when _NO_PROTO or
+    PNG_TYPECAST_NULL is defined.
+
+Version 1.2.1rc1 [November 24, 2001]
+  Type cast NULLs appearing in function calls except when PNG_NO_TYPECAST_NULL
+    is defined.
+  Changed typecast of "size" argument to png_size_t in pngmem.c calls to
+    the user malloc_fn, to agree with the prototype in png.h
+  Added a pop/push operation to pnggccrd.c, to preserve Eflag (Maxim Sobolev)
+  Updated makefile.sgi to recognize LIBPATH and INCPATH.
+  Updated various makefiles so "make clean" does not remove previous major
+    version of the shared library.
+
+Version 1.2.1rc2 [December 4, 2001]
+  Always allocate 256-entry internal palette, hist, and trans arrays, to
+    avoid out-of-bounds memory reference caused by invalid PNG datastreams.
+  Added a check for prefix_length > data_length in iCCP chunk handler.
+
+Version 1.2.1 [December 7, 2001]
+  None.
+
+Version 1.2.2beta1 [February 22, 2002]
+  Fixed a bug with reading the length of iCCP profiles (Larry Reeves).
+  Revised makefile.linux, makefile.gcmmx, and makefile.sgi to generate
+    libpng.a, libpng12.so (not libpng.so.3), and libpng12/png.h
+  Revised makefile.darwin to remove "-undefined suppress" option.
+  Added checks for gamma and chromaticity values over 21474.83, which exceed
+    the limit for PNG unsigned 32-bit integers when encoded.
+  Revised calls to png_create_read_struct() and png_create_write_struct()
+    for simpler debugging.
+  Revised png_zalloc() so zlib handles errors (uses PNG_FLAG_MALLOC_NULL_MEM_OK)
+
+Version 1.2.2beta2 [February 23, 2002]
+  Check chunk_length and idat_size for invalid (over PNG_MAX_UINT) lengths.
+  Check for invalid image dimensions in png_get_IHDR.
+  Added missing "fi;" in the install target of the SGI makefiles.
+  Added install-static to all makefiles that make shared libraries.
+  Always do gamma compensation when image is partially transparent.
+
+Version 1.2.2beta3 [March 7, 2002]
+  Compute background.gray and background_1.gray even when color_type is RGB
+    in case image gets reduced to gray later.
+  Modified shared-library makefiles to install pkgconfig/libpngNN.pc.
+  Export (with PNGAPI) png_zalloc, png_zfree, and png_handle_as_unknown
+  Removed unused png_write_destroy_info prototype from png.h
+  Eliminated incorrect use of width_mmx from pnggccrd.c in pixel_bytes == 8 case
+  Added install-shared target to all makefiles that make shared libraries.
+  Stopped a double free of palette, hist, and trans when not using free_me.
+  Added makefile.32sunu for Sun Ultra 32 and makefile.64sunu for Sun Ultra 64.
+
+Version 1.2.2beta4 [March 8, 2002]
+  Compute background.gray and background_1.gray even when color_type is RGB
+    in case image gets reduced to gray later (Jason Summers).
+  Relocated a misplaced /bin/rm in the "install-shared" makefile targets
+  Added PNG_1_0_X macro which can be used to build a 1.0.x-compatible library.
+
+Version 1.2.2beta5 [March 26, 2002]
+  Added missing PNGAPI to several function definitions.
+  Check for invalid bit_depth or color_type in png_get_IHDR(), and
+    check for missing PLTE or IHDR in png_push_read_chunk() (Matthias Clasen).
+  Revised iTXt support to accept NULL for lang and lang_key.
+  Compute gamma for color components of background even when color_type is gray.
+  Changed "()" to "{}" in scripts/libpng.pc.in.
+  Revised makefiles to put png.h and pngconf.h only in $prefix/include/libpngNN
+  Revised makefiles to make symlink to libpng.so.NN in addition to libpngNN.so
+
+Version 1.2.2beta6 [March 31, 2002]
+
+Version 1.0.13beta1 [March 31, 2002]
+  Prevent png_zalloc() from trying to memset memory that it failed to acquire.
+  Add typecasts of PNG_MAX_UINT in pngset_cHRM_fixed() (Matt Holgate).
+  Ensure that the right function (user or default) is used to free the
+    png_struct after an error in png_create_read_struct_2().
+
+Version 1.2.2rc1 [April 7, 2002]
+
+Version 1.0.13rc1 [April 7, 2002]
+  Save the ebx register in pnggccrd.c (Sami Farin)
+  Add "mem_ptr = png_ptr->mem_ptr" in png_destroy_write_struct() (Paul Gardner).
+  Updated makefiles to put headers in include/libpng and remove old include/*.h.
+
+Version 1.2.2 [April 15, 2002]
+
+Version 1.0.13 [April 15, 2002]
+  Revised description of png_set_filter() in libpng.3/libpng.txt.
+  Revised makefile.netbsd and added makefile.neNNbsd and makefile.freebsd
+
+Version 1.0.13patch01 [April 17, 2002]
+
+Version 1.2.2patch01 [April 17, 2002]
+  Changed ${PNGMAJ}.${PNGVER} bug to ${PNGVER} in makefile.sgi and
+    makefile.sggcc
+  Fixed VER -> PNGVER typo in makefile.macosx and added install-static to
+    install
+  Added install: target to makefile.32sunu and makefile.64sunu
+
+Version 1.0.13patch03 [April 18, 2002]
+
+Version 1.2.2patch03 [April 18, 2002]
+  Revised 15 makefiles to link libpng.a to libpngNN.a and the include libpng
+  subdirectory to libpngNN subdirectory without the full pathname.
+  Moved generation of libpng.pc from "install" to "all" in 15 makefiles.
+
+Version 1.2.3rc1 [April 28, 2002]
+  Added install-man target to 15 makefiles (Dimitri Papadopolous-Orfanos).
+  Added $(DESTDIR) feature to 24 makefiles (Tim Mooney)
+  Fixed bug with $prefix, should be $(prefix) in makefile.hpux.
+  Updated cygwin-specific portion of pngconf.h and revised makefile.cygwin
+  Added a link from libpngNN.pc to libpng.pc in 15 makefiles.
+  Added links from include/libpngNN/*.h to include/*.h in 24 makefiles.
+  Revised makefile.darwin to make relative links without full pathname.
+  Added setjmp() at the end of png_create_*_struct_2() in case user forgets
+    to put one in their application.
+  Restored png_zalloc() and png_zfree() prototypes to version 1.2.1 and
+    removed them from module definition files.
+
+Version 1.2.3rc2 [May 1, 2002]
+  Fixed bug in reporting number of channels in pngget.c and pngset.c,
+    that was introduced in version 1.2.2beta5.
+  Exported png_zalloc(), png_zfree(), png_default_read(), png_default_write(),
+    png_default_flush(), and png_push_fill_buffer() and included them in
+    module definition files.
+  Added "libpng.pc" dependency to the "install-shared" target in 15 makefiles.
+
+Version 1.2.3rc3 [May 1, 2002]
+  Revised prototype for png_default_flush()
+  Remove old libpng.pc and libpngNN.pc before installing new ones.
+
+Version 1.2.3rc4 [May 2, 2002]
+  Typos in *.def files (png_default_read|write -> png_default_read|write_data)
+  In makefiles, changed rm libpng.NN.pc to rm libpngNN.pc
+  Added libpng-config and libpngNN-config and modified makefiles to install
+    them.
+  Changed $(MANPATH) to $(DESTDIR)$(MANPATH) in makefiles
+  Added "Win32 DLL VB" configuration to projects/msvc/libpng.dsp
+
+Version 1.2.3rc5 [May 11, 2002]
+  Changed "error" and "message" in prototypes to "error_message" and
+    "warning_message" to avoid namespace conflict.
+  Revised 15 makefiles to build libpng-config from libpng-config-*.in
+  Once more restored png_zalloc and png_zfree to regular nonexported form.
+  Restored png_default_read|write_data, png_default_flush, png_read_fill_buffer
+    to nonexported form, but with PNGAPI, and removed them from module def
+    files.
+
+Version 1.2.3rc6 [May 14, 2002]
+  Removed "PNGAPI" from png_zalloc() and png_zfree() in png.c
+  Changed "Gz" to "Gd" in projects/msvc/libpng.dsp and zlib.dsp.
+  Removed leftover libpng-config "sed" script from four makefiles.
+  Revised libpng-config creating script in 16 makefiles.
+
+Version 1.2.3 [May 22, 2002]
+  Revised libpng-config target in makefile.cygwin.
+  Removed description of png_set_mem_fn() from documentation.
+  Revised makefile.freebsd.
+  Minor cosmetic changes to 15 makefiles, e.g., $(DI) = $(DESTDIR)/$(INCDIR).
+  Revised projects/msvc/README.txt
+  Changed -lpng to -lpngNN in LDFLAGS in several makefiles.
+
+Version 1.2.4beta1 [May 24, 2002]
+  Added libpng.pc and libpng-config to "all:" target in 16 makefiles.
+  Fixed bug in 16 makefiles: $(DESTDIR)/$(LIBPATH) to $(DESTDIR)$(LIBPATH)
+  Added missing "\" before closing double quote in makefile.gcmmx.
+  Plugged various memory leaks; added png_malloc_warn() and png_set_text_2()
+    functions.
+
+Version 1.2.4beta2 [June 25, 2002]
+  Plugged memory leak of png_ptr->current_text (Matt Holgate).
+  Check for buffer overflow before reading CRC in pngpread.c (Warwick Allison)
+  Added -soname to the loader flags in makefile.dec, makefile.sgi, and
+    makefile.sggcc.
+  Added "test-installed" target to makefile.linux, makefile.gcmmx,
+    makefile.sgi, and makefile.sggcc.
+
+Version 1.2.4beta3 [June 28, 2002]
+  Plugged memory leak of row_buf in pngtest.c when there is a png_error().
+  Detect buffer overflow in pngpread.c when IDAT is corrupted with extra data.
+  Added "test-installed" target to makefile.32sunu, makefile.64sunu,
+    makefile.beos, makefile.darwin, makefile.dec, makefile.macosx,
+    makefile.solaris, makefile.hpux, makefile.hpgcc, and makefile.so9.
+
+Version 1.2.4rc1 and 1.0.14rc1 [July 2, 2002]
+  Added "test-installed" target to makefile.cygwin and makefile.sco.
+  Revised pnggccrd.c to be able to back out version 1.0.x via PNG_1_0_X macro.
+
+Version 1.2.4 and 1.0.14 [July 8, 2002]
+  Changed png_warning() to png_error() when width is too large to process.
+
+Version 1.2.4patch01 [July 20, 2002]
+  Revised makefile.cygwin to use DLL number 12 instead of 13.
+
+Version 1.2.5beta1 [August 6, 2002]
+  Added code to contrib/gregbook/readpng2.c to ignore unused chunks.
+  Replaced toucan.png in contrib/gregbook (it has been corrupt since 1.0.11)
+  Removed some stray *.o files from contrib/gregbook.
+  Changed png_error() to png_warning() about "Too much data" in pngpread.c
+    and about "Extra compressed data" in pngrutil.c.
+  Prevent png_ptr->pass from exceeding 7 in png_push_finish_row().
+  Updated makefile.hpgcc
+  Updated png.c and pnggccrd.c handling of return from png_mmx_support()
+
+Version 1.2.5beta2 [August 15, 2002]
+  Only issue png_warning() about "Too much data" in pngpread.c when avail_in
+    is nonzero.
+  Updated makefiles to install a separate libpng.so.3 with its own rpath.
+
+Version 1.2.5rc1 and 1.0.15rc1 [August 24, 2002]
+  Revised makefiles to not remove previous minor versions of shared libraries.
+
+Version 1.2.5rc2 and 1.0.15rc2 [September 16, 2002]
+  Revised 13 makefiles to remove "-lz" and "-L$(ZLIBLIB)", etc., from shared
+    library loader directive.
+  Added missing "$OBJSDLL" line to makefile.gcmmx.
+  Added missing "; fi" to makefile.32sunu.
+
+Version 1.2.5rc3 and 1.0.15rc3 [September 18, 2002]
+  Revised libpng-config script.
+
+Version 1.2.5 and 1.0.15 [October 3, 2002]
+  Revised makefile.macosx, makefile.darwin, makefile.hpgcc, and makefile.hpux,
+    and makefile.aix.
+  Relocated two misplaced PNGAPI lines in pngtest.c
+
+Version 1.2.6beta1 [October 22, 2002]
+  Commented out warning about uninitialized mmx_support in pnggccrd.c.
+  Changed "IBMCPP__" flag to "__IBMCPP__" in pngconf.h.
+  Relocated two more misplaced PNGAPI lines in pngtest.c
+  Fixed memory overrun bug in png_do_read_filler() with 16-bit datastreams,
+    introduced in version 1.0.2.
+  Revised makefile.macosx, makefile.dec, makefile.aix, and makefile.32sunu.
+
+Version 1.2.6beta2 [November 1, 2002]
+  Added libpng-config "--ldopts" output.
+  Added "AR=ar" and "ARFLAGS=rc" and changed "ar rc" to "$(AR) $(ARFLAGS)"
+    in makefiles.
+
+Version 1.2.6beta3 [July 18, 2004]
+  Reverted makefile changes from version 1.2.6beta2 and some of the changes
+    from version 1.2.6beta1; these will be postponed until version 1.2.7.
+    Version 1.2.6 is going to be a simple bugfix release.
+  Changed the one instance of "ln -sf" to "ln -f -s" in each Sun makefile.
+  Fixed potential overrun in pngerror.c by using strncpy instead of memcpy.
+  Added "#!/bin/sh" at the top of configure, for recognition of the
+    'x' flag under Cygwin (Cosmin).
+  Optimized vacuous tests that silence compiler warnings, in png.c (Cosmin).
+  Added support for PNG_USER_CONFIG, in pngconf.h (Cosmin).
+  Fixed the special memory handler for Borland C under DOS, in pngmem.c
+    (Cosmin).
+  Removed some spurious assignments in pngrutil.c (Cosmin).
+  Replaced 65536 with 65536L, and 0xffff with 0xffffL, to silence warnings
+    on 16-bit platforms (Cosmin).
+  Enclosed shift op expressions in parentheses, to silence warnings (Cosmin).
+  Used proper type png_fixed_point, to avoid problems on 16-bit platforms,
+    in png_handle_sRGB() (Cosmin).
+  Added compression_type to png_struct, and optimized the window size
+    inside the deflate stream (Cosmin).
+  Fixed definition of isnonalpha(), in pngerror.c and pngrutil.c (Cosmin).
+  Fixed handling of unknown chunks that come after IDAT (Cosmin).
+  Allowed png_error() and png_warning() to work even if png_ptr == NULL
+    (Cosmin).
+  Replaced row_info->rowbytes with row_bytes in png_write_find_filter()
+    (Cosmin).
+  Fixed definition of PNG_LIBPNG_VER_DLLNUM (Simon-Pierre).
+  Used PNG_LIBPNG_VER and PNG_LIBPNG_VER_STRING instead of the hardcoded
+    values in png.c (Simon-Pierre, Cosmin).
+  Initialized png_libpng_ver[] with PNG_LIBPNG_VER_STRING (Simon-Pierre).
+  Replaced PNG_LIBPNG_VER_MAJOR with PNG_LIBPNG_VER_DLLNUM in png.rc
+    (Simon-Pierre).
+  Moved the definition of PNG_HEADER_VERSION_STRING near the definitions
+    of the other PNG_LIBPNG_VER_... symbols in png.h (Cosmin).
+  Relocated #ifndef PNGAPI guards in pngconf.h (Simon-Pierre, Cosmin).
+  Updated scripts/makefile.vc(a)win32 (Cosmin).
+  Updated the MSVC project (Simon-Pierre, Cosmin).
+  Updated the Borland C++ Builder project (Cosmin).
+  Avoided access to asm_flags in pngvcrd.c, if PNG_1_0_X is defined (Cosmin).
+  Commented out warning about uninitialized mmx_support in pngvcrd.c (Cosmin).
+  Removed scripts/makefile.bd32 and scripts/pngdef.pas (Cosmin).
+  Added extra guard around inclusion of Turbo C memory headers, in pngconf.h
+    (Cosmin).
+  Renamed projects/msvc/ to projects/visualc6/, and projects/borland/ to
+    projects/cbuilder5/ (Cosmin).
+  Moved projects/visualc6/png32ms.def to scripts/pngw32.def,
+    and projects/visualc6/png.rc to scripts/pngw32.rc (Cosmin).
+  Added projects/visualc6/pngtest.dsp; removed contrib/msvctest/ (Cosmin).
+  Changed line endings to DOS style in cbuilder5 and visualc6 files, even
+    in the tar.* distributions (Cosmin).
+  Updated contrib/visupng/VisualPng.dsp (Cosmin).
+  Updated contrib/visupng/cexcept.h to version 2.0.0 (Cosmin).
+  Added a separate distribution with "configure" and supporting files (Junichi).
+
+Version 1.2.6beta4 [July 28, 2004]
+  Added user ability to change png_size_t via a PNG_SIZE_T macro.
+  Added png_sizeof() and png_convert_size() functions.
+  Added PNG_SIZE_MAX (maximum value of a png_size_t variable.
+  Added check in png_malloc_default() for (size_t)size != (png_uint_32)size
+    which would indicate an overflow.
+  Changed sPLT failure action from png_error to png_warning and abandon chunk.
+  Changed sCAL and iCCP failures from png_error to png_warning and abandon.
+  Added png_get_uint_31(png_ptr, buf) function.
+  Added PNG_UINT_32_MAX macro.
+  Renamed PNG_MAX_UINT to PNG_UINT_31_MAX.
+  Made png_zalloc() issue a png_warning and return NULL on potential
+    overflow.
+  Turn on PNG_NO_ZALLOC_ZERO by default in version 1.2.x
+  Revised "clobber list" in pnggccrd.c so it will compile under gcc-3.4.
+  Revised Borland portion of png_malloc() to return NULL or issue
+    png_error() according to setting of PNG_FLAG_MALLOC_NULL_MEM_OK.
+  Added PNG_NO_SEQUENTIAL_READ_SUPPORTED macro to conditionally remove
+    sequential read support.
+  Added some "#if PNG_WRITE_SUPPORTED" blocks.
+  Added #ifdef to remove some redundancy in png_malloc_default().
+  Use png_malloc instead of png_zalloc to allocate the palette.
+
+Version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004]
+  Fixed buffer overflow vulnerability (CVE-2004-0597) in png_handle_tRNS().
+  Fixed NULL dereference vulnerability (CVE-2004-0598) in png_handle_iCCP().
+  Fixed integer overflow vulnerability (CVE-2004-0599) in png_read_png().
+  Fixed some harmless bugs in png_handle_sBIT, etc, that would cause
+    duplicate chunk types to go undetected.
+  Fixed some timestamps in the -config version
+  Rearranged order of processing of color types in png_handle_tRNS().
+  Added ROWBYTES macro to calculate rowbytes without integer overflow.
+  Updated makefile.darwin and removed makefile.macosx from scripts directory.
+  Imposed default one million column, one-million row limits on the image
+    dimensions, and added png_set_user_limits() function to override them.
+  Revised use of PNG_SET_USER_LIMITS_SUPPORTED macro.
+  Fixed wrong cast of returns from png_get_user_width|height_max().
+  Changed some "keep the compiler happy" from empty statements to returns,
+  Revised libpng.txt to remove 1.2.x stuff from the 1.0.x distribution
+
+Version 1.0.16rc2 and 1.2.6rc2 [August 7, 2004]
+  Revised makefile.darwin and makefile.solaris.  Removed makefile.macosx.
+  Revised pngtest's png_debug_malloc() to use png_malloc() instead of
+    png_malloc_default() which is not supposed to be exported.
+  Fixed off-by-one error in one of the conversions to PNG_ROWBYTES() in
+    pngpread.c.  Bug was introduced in 1.2.6rc1.
+  Fixed bug in RGB to RGBX transformation introduced in 1.2.6rc1.
+  Fixed old bug in RGB to Gray transformation.
+  Fixed problem with 64-bit compilers by casting arguments to abs()
+    to png_int_32.
+  Changed "ln -sf" to "ln -f -s" in three makefiles (solaris, sco, so9).
+  Changed "HANDLE_CHUNK_*" to "PNG_HANDLE_CHUNK_*" (Cosmin)
+  Added "-@/bin/rm -f $(DL)/$(LIBNAME).so.$(PNGMAJ)" to 15 *NIX makefiles.
+  Added code to update the row_info->colortype in png_do_read_filler() (MSB).
+
+Version 1.0.16rc3 and 1.2.6rc3 [August 9, 2004]
+  Eliminated use of "abs()" in testing cHRM and gAMA values, to avoid
+    trouble with some 64-bit compilers.  Created PNG_OUT_OF_RANGE() macro.
+  Revised documentation of png_set_keep_unknown_chunks().
+  Check handle_as_unknown status in pngpread.c, as in pngread.c previously.
+  Moved  "PNG_HANDLE_CHUNK_*" macros out of PNG_INTERNAL section of png.h
+  Added "rim" definitions for CONST4 and CONST6 in pnggccrd.c
+
+Version 1.0.16rc4 and 1.2.6rc4 [August 10, 2004]
+  Fixed mistake in pngtest.c introduced in 1.2.6rc2 (declaration of
+    "pinfo" was out of place).
+
+Version 1.0.16rc5 and 1.2.6rc5 [August 10, 2004]
+  Moved  "PNG_HANDLE_CHUNK_*" macros out of PNG_ASSEMBLER_CODE_SUPPORTED
+    section of png.h where they were inadvertently placed in version rc3.
+
+Version 1.2.6 and 1.0.16 [August 15, 2004]
+  Revised pngtest so memory allocation testing is only done when PNG_DEBUG==1.
+
+Version 1.2.7beta1 [August 26, 2004]
+  Removed unused pngasmrd.h file.
+  Removed references to uu.net for archived files.  Added references to
+    PNG Spec (second edition) and the PNG ISO/IEC Standard.
+  Added "test-dd" target in 15 makefiles, to run pngtest in DESTDIR.
+  Fixed bug with "optimized window size" in the IDAT datastream, that
+    causes libpng to write PNG files with incorrect zlib header bytes.
+
+Version 1.2.7beta2 [August 28, 2004]
+  Fixed bug with sCAL chunk and big-endian machines (David Munro).
+  Undid new code added in 1.2.6rc2 to update the color_type in
+    png_set_filler().
+  Added png_set_add_alpha() that updates color type.
+
+Version 1.0.17rc1 and 1.2.7rc1 [September 4, 2004]
+  Revised png_set_strip_filler() to not remove alpha if color_type has alpha.
+
+Version 1.2.7 and 1.0.17 [September 12, 2004]
+  Added makefile.hp64
+  Changed projects/msvc/png32ms.def to scripts/png32ms.def in makefile.cygwin
+
+Version 1.2.8beta1 [November 1, 2004]
+  Fixed bug in png_text_compress() that would fail to complete a large block.
+  Fixed bug, introduced in libpng-1.2.7, that overruns a buffer during
+    strip alpha operation in png_do_strip_filler().
+  Added PNG_1_2_X definition in pngconf.h
+  Use #ifdef to comment out png_info_init in png.c and png_read_init in
+    pngread.c (as of 1.3.0)
+
+Version 1.2.8beta2 [November 2, 2004]
+  Reduce color_type to a nonalpha type after strip alpha operation in
+    png_do_strip_filler().
+
+Version 1.2.8beta3 [November 3, 2004]
+  Revised definitions of PNG_MAX_UINT_32, PNG_MAX_SIZE, and PNG_MAXSUM
+
+Version 1.2.8beta4 [November 12, 2004]
+  Fixed (again) definition of PNG_LIBPNG_VER_DLLNUM in png.h (Cosmin).
+  Added PNG_LIBPNG_BUILD_PRIVATE in png.h (Cosmin).
+  Set png_ptr->zstream.data_type to Z_BINARY, to avoid unnecessary detection
+    of data type in deflate (Cosmin).
+  Deprecated but continue to support SPECIALBUILD and PRIVATEBUILD in favor of
+    PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING.
+
+Version 1.2.8beta5 [November 20, 2004]
+  Use png_ptr->flags instead of png_ptr->transformations to pass
+    PNG_STRIP_ALPHA info to png_do_strip_filler(), to preserve ABI
+    compatibility.
+  Revised handling of SPECIALBUILD, PRIVATEBUILD,
+    PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING.
+
+Version 1.2.8rc1 [November 24, 2004]
+  Moved handling of BUILD macros from pngconf.h to png.h
+  Added definition of PNG_LIBPNG_BASE_TYPE in png.h, inadvertently
+    omitted from beta5.
+  Revised scripts/pngw32.rc
+  Despammed mailing addresses by masking "@" with "at".
+  Inadvertently installed a supposedly faster test version of pngrutil.c
+
+Version 1.2.8rc2 [November 26, 2004]
+  Added two missing "\" in png.h
+  Change tests in pngread.c and pngpread.c to
+    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))
+       png_do_read_transformations(png_ptr);
+
+Version 1.2.8rc3 [November 28, 2004]
+  Reverted pngrutil.c to version libpng-1.2.8beta5.
+  Added scripts/makefile.elf with supporting code in pngconf.h for symbol
+    versioning (John Bowler).
+
+Version 1.2.8rc4 [November 29, 2004]
+  Added projects/visualc7 (Simon-pierre).
+
+Version 1.2.8rc5 [November 29, 2004]
+  Fixed new typo in scripts/pngw32.rc
+
+Version 1.2.8 [December 3, 2004]
+  Removed projects/visualc7, added projects/visualc71.
+
+Version 1.2.9beta1 [February 21, 2006]
+  Initialized some structure members in pngwutil.c to avoid gcc-4.0.0 complaints
+  Revised man page and libpng.txt to make it clear that one should not call
+    png_read_end or png_write_end after png_read_png or png_write_png.
+  Updated references to png-mng-implement mailing list.
+  Fixed an incorrect typecast in pngrutil.c
+  Added PNG_NO_READ_SUPPORTED conditional for making a write-only library.
+  Added PNG_NO_WRITE_INTERLACING_SUPPORTED conditional.
+  Optimized alpha-inversion loops in pngwtran.c
+  Moved test for nonzero gamma outside of png_build_gamma_table() in pngrtran.c
+  Make sure num_trans is <= 256 before copying data in png_set_tRNS().
+  Make sure num_palette is <= 256 before copying data in png_set_PLTE().
+  Interchanged order of write_swap_alpha and write_invert_alpha transforms.
+  Added parentheses in the definition of PNG_LIBPNG_BUILD_TYPE (Cosmin).
+  Optimized zlib window flag (CINFO) in contrib/pngsuite/*.png (Cosmin).
+  Updated scripts/makefile.bc32 for Borland C++ 5.6 (Cosmin).
+  Exported png_get_uint_32, png_save_uint_32, png_get_uint_16, png_save_uint_16,
+    png_get_int_32, png_save_int_32, png_get_uint_31 (Cosmin).
+  Added type cast (png_byte) in png_write_sCAL() (Cosmin).
+  Fixed scripts/makefile.cygwin (Christian Biesinger, Cosmin).
+  Default iTXt support was inadvertently enabled.
+
+Version 1.2.9beta2 [February 21, 2006]
+  Check for png_rgb_to_gray and png_gray_to_rgb read transformations before
+    checking for png_read_dither in pngrtran.c
+  Revised checking of chromaticity limits to accommodate extended RGB
+    colorspace (John Denker).
+  Changed line endings in some of the project files to CRLF, even in the
+    "Unix" tar distributions (Cosmin).
+  Made png_get_int_32 and png_save_int_32 always available (Cosmin).
+  Updated scripts/pngos2.def, scripts/pngw32.def and projects/wince/png32ce.def
+    with the newly exported functions.
+  Eliminated distributions without the "configure" script.
+  Updated INSTALL instructions.
+
+Version 1.2.9beta3 [February 24, 2006]
+  Fixed CRCRLF line endings in contrib/visupng/VisualPng.dsp
+  Made libpng.pc respect EXEC_PREFIX (D. P. Kreil, J. Bowler)
+  Removed reference to pngasmrd.h from Makefile.am
+  Renamed CHANGES to ChangeLog.
+  Renamed LICENSE to COPYING.
+  Renamed ANNOUNCE to NEWS.
+  Created AUTHORS file.
+
+Version 1.2.9beta4 [March 3, 2006]
+  Changed definition of PKGCONFIG from $prefix/lib to $libdir in configure.ac
+  Reverted to filenames LICENSE and ANNOUNCE; removed AUTHORS and COPYING.
+  Removed newline from the end of some error and warning messages.
+  Removed test for sqrt() from configure.ac and configure.
+  Made swap tables in pngtrans.c PNG_CONST (Carlo Bramix).
+  Disabled default iTXt support that was inadvertently enabled in
+    libpng-1.2.9beta1.
+  Added "OS2" to list of systems that don't need underscores, in pnggccrd.c
+  Removed libpng version and date from *.c files.
+
+Version 1.2.9beta5 [March 4, 2006]
+  Removed trailing blanks from source files.
+  Put version and date of latest change in each source file, and changed
+    copyright year accordingly.
+  More cleanup of configure.ac, Makefile.am, and associated scripts.
+  Restored scripts/makefile.elf which was inadvertently deleted.
+
+Version 1.2.9beta6 [March 6, 2006]
+  Fixed typo (RELEASE) in configuration files.
+
+Version 1.2.9beta7 [March 7, 2006]
+  Removed libpng.vers and libpng.sym from libpng12_la_SOURCES in Makefile.am
+  Fixed inconsistent #ifdef's around png_sig_bytes() and png_set_sCAL_s()
+    in png.h.
+  Updated makefile.elf as suggested by debian.
+  Made cosmetic changes to some makefiles, adding LN_SF and other macros.
+  Made some makefiles accept "exec_prefix".
+
+Version 1.2.9beta8 [March 9, 2006]
+  Fixed some "#if defined (..." which should be "#if defined(..."
+    Bug introduced in libpng-1.2.8.
+  Fixed inconsistency in definition of png_default_read_data()
+  Restored blank that was lost from makefile.sggcc "clean" target in beta7.
+  Revised calculation of "current" and "major" for irix in ltmain.sh
+  Changed "mkdir" to "MKDIR_P" in some makefiles.
+  Separated PNG_EXPAND and PNG_EXPAND_tRNS.
+  Added png_set_expand_gray_1_2_4_to_8() and deprecated
+    png_set_gray_1_2_4_to_8() which also expands tRNS to alpha.
+
+Version 1.2.9beta9 [March 10, 2006]
+  Include "config.h" in pngconf.h when available.
+  Added some checks for NULL png_ptr or NULL info_ptr (timeless)
+
+Version 1.2.9beta10 [March 20, 2006]
+  Removed extra CR from contrib/visualpng/VisualPng.dsw (Cosmin)
+  Made pnggccrd.c PIC-compliant (Christian Aichinger).
+  Added makefile.mingw (Wolfgang Glas).
+  Revised pngconf.h MMX checking.
+
+Version 1.2.9beta11 [March 22, 2006]
+  Fixed out-of-order declaration in pngwrite.c that was introduced in beta9
+  Simplified some makefiles by using LIBSO, LIBSOMAJ, and LIBSOVER macros.
+
+Version 1.2.9rc1 [March 31, 2006]
+  Defined PNG_USER_PRIVATEBUILD when including "pngusr.h" (Cosmin).
+  Removed nonsensical assertion check from pngtest.c (Cosmin).
+
+Version 1.2.9 [April 14, 2006]
+  Revised makefile.beos and added "none" selector in ltmain.sh
+
+Version 1.2.10beta1 [April 15, 2006]
+  Renamed "config.h" to "png_conf.h" and revised Makefile.am to add
+    -DPNG_BUILDING_LIBPNG to compile directive, and modified pngconf.h
+    to include png_conf.h only when PNG_BUILDING_LIBPNG is defined.
+
+Version 1.2.10beta2 [April 15, 2006]
+  Manually updated Makefile.in and configure.  Changed png_conf.h.in
+    back to config.h.
+
+Version 1.2.10beta3 [April 15, 2006]
+  Change png_conf.h back to config.h in pngconf.h.
+
+Version 1.2.10beta4 [April 16, 2006]
+  Change PNG_BUILDING_LIBPNG to PNG_CONFIGURE_LIBPNG in config/Makefile*.
+
+Version 1.2.10beta5 [April 16, 2006]
+  Added a configure check for compiling assembler code in pnggccrd.c
+
+Version 1.2.10beta6 [April 17, 2006]
+  Revised the configure check for pnggccrd.c
+  Moved -DPNG_CONFIGURE_LIBPNG into @LIBPNG_DEFINES@
+  Added @LIBPNG_DEFINES@ to arguments when building libpng.sym
+
+Version 1.2.10beta7 [April 18, 2006]
+  Change "exec_prefix=$prefix" to "exec_prefix=$(prefix)" in makefiles.
+
+Version 1.2.10rc1 [April 19, 2006]
+  Ensure pngconf.h doesn't define both PNG_USE_PNGGCCRD and PNG_USE_PNGVCRD
+  Fixed "LN_FS" typo in makefile.sco and makefile.solaris.
+
+Version 1.2.10rc2 [April 20, 2006]
+  Added a backslash between -DPNG_CONFIGURE_LIBPNG and -DPNG_NO_ASSEMBLER_CODE
+   in configure.ac and configure
+  Made the configure warning about versioned symbols less arrogant.
+
+Version 1.2.10rc3 [April 21, 2006]
+  Added a note in libpng.txt that png_set_sig_bytes(8) can be used when
+    writing an embedded PNG without the 8-byte signature.
+  Revised makefiles and configure to avoid making links to libpng.so.*
+
+Version 1.2.10 [April 23, 2006]
+  Reverted configure to "rc2" state.
+
+Version 1.2.11beta1 [May 31, 2006]
+  scripts/libpng.pc.in contained "configure" style version info and would
+    not work with makefiles.
+  The shared-library makefiles were linking to libpng.so.0 instead of
+    libpng.so.3 compatibility as the library.
+
+Version 1.2.11beta2 [June 2, 2006]
+  Increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid
+    buffer overflow.
+  Fixed bug in example.c (png_set_palette_rgb -> png_set_palette_to_rgb)
+
+Version 1.2.11beta3 [June 5, 2006]
+  Prepended "#! /bin/sh" to ltmail.sh and contrib/pngminus/*.sh (Cosmin).
+  Removed the accidental leftover Makefile.in~ (Cosmin).
+  Avoided potential buffer overflow and optimized buffer in
+    png_write_sCAL(), png_write_sCAL_s() (Cosmin).
+  Removed the include directories and libraries from CFLAGS and LDFLAGS
+    in scripts/makefile.gcc (Nelson A. de Oliveira, Cosmin).
+
+Version 1.2.11beta4 [June 6, 2006]
+  Allow zero-length IDAT chunks after the entire zlib datastream, but not
+    after another intervening chunk type.
+
+Version 1.0.19rc1, 1.2.11rc1 [June 13, 2006]
+  Deleted extraneous square brackets from [config.h] in configure.ac
+
+Version 1.0.19rc2, 1.2.11rc2 [June 14, 2006]
+  Added prototypes for PNG_INCH_CONVERSIONS functions to png.h
+  Revised INSTALL and autogen.sh
+  Fixed typo in several makefiles (-W1 should be -Wl)
+  Added typedef for png_int_32 and png_uint_32 on 64-bit systems.
+
+Version 1.0.19rc3, 1.2.11rc3 [June 15, 2006]
+  Removed the new typedefs for 64-bit systems (delay until version 1.4.0)
+  Added one zero element to png_gamma_shift[] array in pngrtran.c to avoid
+    reading out of bounds.
+
+Version 1.0.19rc4, 1.2.11rc4 [June 15, 2006]
+  Really removed the new typedefs for 64-bit systems.
+
+Version 1.0.19rc5, 1.2.11rc5 [June 22, 2006]
+  Removed png_sig_bytes entry from scripts/pngw32.def
+
+Version 1.0.19, 1.2.11 [June 26, 2006]
+  None.
+
+Version 1.0.20, 1.2.12 [June 27, 2006]
+  Really increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid
+    buffer overflow.
+
+Version 1.2.13beta1 [October 2, 2006]
+  Removed AC_FUNC_MALLOC from configure.ac
+  Work around Intel-Mac compiler bug by setting PNG_NO_MMX_CODE in pngconf.h
+  Change "logical" to "bitwise" throughout documentation.
+  Detect and fix attempt to write wrong iCCP profile length (CVE-2006-7244)
+
+Version 1.0.21, 1.2.13 [November 14, 2006]
+  Fix potential buffer overflow in sPLT chunk handler.
+  Fix Makefile.am to not try to link to noexistent files.
+  Check all exported functions for NULL png_ptr.
+
+Version 1.2.14beta1 [November 17, 2006]
+  Relocated three misplaced tests for NULL png_ptr.
+  Built Makefile.in with automake-1.9.6 instead of 1.9.2.
+  Build configure with autoconf-2.60 instead of 2.59
+
+Version 1.2.14beta2 [November 17, 2006]
+  Added some typecasts in png_zalloc().
+
+Version 1.2.14rc1 [November 20, 2006]
+  Changed "strtod" to "png_strtod" in pngrutil.c
+
+Version 1.0.22, 1.2.14    [November 27, 2006]
+  Added missing "$(srcdir)" in Makefile.am and Makefile.in
+
+Version 1.2.15beta1 [December 3, 2006]
+  Generated configure with autoconf-2.61 instead of 2.60
+  Revised configure.ac to update libpng.pc and libpng-config.
+
+Version 1.2.15beta2 [December 3, 2006]
+  Always export MMX asm functions, just stubs if not building pnggccrd.c
+
+Version 1.2.15beta3 [December 4, 2006]
+  Add "png_bytep" typecast to profile while calculating length in pngwutil.c
+
+Version 1.2.15beta4 [December 7, 2006]
+  Added scripts/CMakeLists.txt
+  Changed PNG_NO_ASSEMBLER_CODE to PNG_NO_MMX_CODE in scripts, like 1.4.0beta
+
+Version 1.2.15beta5 [December 7, 2006]
+  Changed some instances of PNG_ASSEMBLER_* to PNG_MMX_* in pnggccrd.c
+  Revised scripts/CMakeLists.txt
+
+Version 1.2.15beta6 [December 13, 2006]
+  Revised scripts/CMakeLists.txt and configure.ac
+
+Version 1.2.15rc1 [December 18, 2006]
+  Revised scripts/CMakeLists.txt
+
+Version 1.2.15rc2 [December 21, 2006]
+  Added conditional #undef jmpbuf in pngtest.c to undo #define in AIX headers.
+  Added scripts/makefile.nommx
+
+Version 1.2.15rc3 [December 25, 2006]
+  Fixed shared library numbering error that was introduced in 1.2.15beta6.
+
+Version 1.2.15rc4 [December 27, 2006]
+  Fixed handling of rgb_to_gray when png_ptr->color.gray isn't set.
+
+Version 1.2.15rc5 [December 31, 2006]
+  Revised handling of rgb_to_gray.
+
+Version 1.2.15 [January 5, 2007]
+  Added some (unsigned long) typecasts in pngtest.c to avoid printing errors.
+
+Version 1.2.16beta1 [January 6, 2007]
+  Fix bugs in makefile.nommx
+
+Version 1.2.16beta2 [January 16, 2007]
+  Revised scripts/CMakeLists.txt
+
+Version 1.2.16 [January 31, 2007]
+  No changes.
+
+Version 1.2.17beta1 [March 6, 2007]
+  Revised scripts/CMakeLists.txt to install both shared and static libraries.
+  Deleted a redundant line from pngset.c.
+
+Version 1.2.17beta2 [April 26, 2007]
+  Relocated misplaced test for png_ptr == NULL in pngpread.c
+  Change "==" to "&" for testing PNG_RGB_TO_GRAY_ERR & PNG_RGB_TO_GRAY_WARN
+    flags.
+  Changed remaining instances of PNG_ASSEMBLER_* to PNG_MMX_*
+  Added pngerror() when write_IHDR fails in deflateInit2().
+  Added "const" to some array declarations.
+  Mention examples of libpng usage in the libpng*.txt and libpng.3 documents.
+
+Version 1.2.17rc1 [May 4, 2007]
+  No changes.
+
+Version 1.2.17rc2 [May 8, 2007]
+  Moved several PNG_HAVE_* macros out of PNG_INTERNAL because applications
+    calling set_unknown_chunk_location() need them.
+  Changed transformation flag from PNG_EXPAND_tRNS to PNG_EXPAND in
+    png_set_expand_gray_1_2_4_to_8().
+  Added png_ptr->unknown_chunk to hold working unknown chunk data, so it
+    can be free'ed in case of error.  Revised unknown chunk handling in
+    pngrutil.c and pngpread.c to use this structure.
+
+Version 1.2.17rc3 [May 8, 2007]
+  Revised symbol-handling in configure script.
+
+Version 1.2.17rc4 [May 10, 2007]
+  Revised unknown chunk handling to avoid storing unknown critical chunks.
+
+Version 1.0.25 [May 15, 2007]
+Version 1.2.17 [May 15, 2007]
+  Added "png_ptr->num_trans=0" before error return in png_handle_tRNS,
+    to eliminate a vulnerability (CVE-2007-2445, CERT VU#684664)
+
+Version 1.0.26 [May 15, 2007]
+Version 1.2.18 [May 15, 2007]
+  Reverted the libpng-1.2.17rc3 change to symbol-handling in configure script
+
+Version 1.2.19beta1 [May 18, 2007]
+  Changed "const static" to "static PNG_CONST" everywhere, mostly undoing
+    change of libpng-1.2.17beta2.  Changed other "const" to "PNG_CONST"
+  Changed some handling of unused parameters, to avoid compiler warnings.
+    "if (unused == NULL) return;" becomes "unused = unused".
+
+Version 1.2.19beta2 [May 18, 2007]
+  Only use the valid bits of tRNS value in png_do_expand() (Brian Cartier)
+
+Version 1.2.19beta3 [May 19, 2007]
+  Add some "png_byte" typecasts in png_check_keyword() and write new_key
+  instead of key in zTXt chunk (Kevin Ryde).
+
+Version 1.2.19beta4 [May 21, 2007]
+  Add png_snprintf() function and use it in place of sprint() for improved
+    defense against buffer overflows.
+
+Version 1.2.19beta5 [May 21, 2007]
+  Fixed png_handle_tRNS() to only use the valid bits of tRNS value.
+  Changed handling of more unused parameters, to avoid compiler warnings.
+  Removed some PNG_CONST in pngwutil.c to avoid compiler warnings.
+
+Version 1.2.19beta6 [May 22, 2007]
+  Added some #ifdef PNG_MMX_CODE_SUPPORTED where needed in pngvcrd.c
+  Added a special "_MSC_VER" case that defines png_snprintf to _snprintf
+
+Version 1.2.19beta7 [May 22, 2007]
+  Squelched png_squelch_warnings() in pnggccrd.c and added
+    an #ifdef PNG_MMX_CODE_SUPPORTED block around the declarations that caused
+    the warnings that png_squelch_warnings was squelching.
+
+Version 1.2.19beta8 [May 22, 2007]
+  Removed __MMX__ from test in pngconf.h.
+
+Version 1.2.19beta9 [May 23, 2007]
+  Made png_squelch_warnings() available via PNG_SQUELCH_WARNINGS macro.
+  Revised png_squelch_warnings() so it might work.
+  Updated makefile.sgcc and makefile.solaris; added makefile.solaris-x86.
+
+Version 1.2.19beta10 [May 24, 2007]
+  Resquelched png_squelch_warnings(), use "__attribute__((used))" instead.
+
+Version 1.4.0beta1 [April 20, 2006]
+  Enabled iTXt support (changes png_struct, thus requires so-number change).
+  Cleaned up PNG_ASSEMBLER_CODE_SUPPORTED vs PNG_MMX_CODE_SUPPORTED
+  Eliminated PNG_1_0_X and PNG_1_2_X macros.
+  Removed deprecated functions png_read_init, png_write_init, png_info_init,
+    png_permit_empty_plte, png_set_gray_1_2_4_to_8, png_check_sig, and
+    removed the deprecated macro PNG_MAX_UINT.
+  Moved "PNG_INTERNAL" parts of png.h and pngconf.h into pngintrn.h
+  Removed many WIN32_WCE #ifdefs (Cosmin).
+  Reduced dependency on C-runtime library when on Windows (Simon-Pierre)
+  Replaced sprintf() with png_sprintf() (Simon-Pierre)
+
+Version 1.4.0beta2 [April 20, 2006]
+  Revised makefiles and configure to avoid making links to libpng.so.*
+  Moved some leftover MMX-related defines from pngconf.h to pngintrn.h
+  Updated scripts/pngos2.def, pngw32.def, and projects/wince/png32ce.def
+
+Version 1.4.0beta3 [May 10, 2006]
+  Updated scripts/pngw32.def to comment out MMX functions.
+  Added PNG_NO_GET_INT_32 and PNG_NO_SAVE_INT_32 macros.
+  Scripts/libpng.pc.in contained "configure" style version info and would
+    not work with makefiles.
+  Revised pngconf.h and added pngconf.h.in, so makefiles and configure can
+    pass defines to libpng and applications.
+
+Version 1.4.0beta4 [May 11, 2006]
+  Revised configure.ac, Makefile.am, and many of the makefiles to write
+    their defines in pngconf.h.
+
+Version 1.4.0beta5 [May 15, 2006]
+  Added a missing semicolon in Makefile.am and Makefile.in
+  Deleted extraneous square brackets from configure.ac
+
+Version 1.4.0beta6 [June 2, 2006]
+  Increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid
+    buffer overflow.
+  Changed sonum from 0 to 1.
+  Removed unused prototype for png_check_sig() from png.h
+
+Version 1.4.0beta7 [June 16, 2006]
+  Exported png_write_sig (Cosmin).
+  Optimized buffer in png_handle_cHRM() (Cosmin).
+  Set pHYs = 2835 x 2835 pixels per meter, and added
+    sCAL = 0.352778e-3 x 0.352778e-3 meters, in pngtest.png (Cosmin).
+  Added png_set_benign_errors(), png_benign_error(), png_chunk_benign_error().
+  Added typedef for png_int_32 and png_uint_32 on 64-bit systems.
+  Added "(unsigned long)" typecast on png_uint_32 variables in printf lists.
+
+Version 1.4.0beta8 [June 22, 2006]
+  Added demonstration of user chunk support in pngtest.c, to support the
+    public sTER chunk and a private vpAg chunk.
+
+Version 1.4.0beta9 [July 3, 2006]
+  Removed ordinals from scripts/pngw32.def and removed png_info_int and
+    png_set_gray_1_2_4_to_8 entries.
+  Inline call of png_get_uint_32() in png_get_uint_31().
+  Use png_get_uint_31() to get vpAg width and height in pngtest.c
+  Removed WINCE and Netware projects.
+  Removed standalone Y2KINFO file.
+
+Version 1.4.0beta10 [July 12, 2006]
+  Eliminated automatic copy of pngconf.h to pngconf.h.in from configure and
+    some makefiles, because it was not working reliably.  Instead, distribute
+    pngconf.h.in along with pngconf.h and cause configure and some of the
+    makefiles to update pngconf.h from pngconf.h.in.
+  Added pngconf.h to DEPENDENCIES in Makefile.am
+
+Version 1.4.0beta11 [August 19, 2006]
+  Removed AC_FUNC_MALLOC from configure.ac.
+  Added a warning when writing iCCP profile with mismatched profile length.
+  Patched pnggccrd.c to assemble on x86_64 platforms.
+  Moved chunk header reading into a separate function png_read_chunk_header()
+    in pngrutil.c.  The chunk header (len+sig) is now serialized in a single
+    operation (Cosmin).
+  Implemented support for I/O states. Added png_ptr member io_state, and
+    functions png_get_io_chunk_name() and png_get_io_state() in pngget.c
+    (Cosmin).
+  Added png_get_io_chunk_name and png_get_io_state to scripts/*.def (Cosmin).
+  Renamed scripts/pngw32.* to scripts/pngwin.* (Cosmin).
+  Removed the include directories and libraries from CFLAGS and LDFLAGS
+    in scripts/makefile.gcc (Cosmin).
+  Used png_save_uint_32() to set vpAg width and height in pngtest.c (Cosmin).
+  Cast to proper type when getting/setting vpAg units in pngtest.c (Cosmin).
+  Added pngintrn.h to the Visual C++ projects (Cosmin).
+  Removed scripts/list (Cosmin).
+  Updated copyright year in scripts/pngwin.def (Cosmin).
+  Removed PNG_TYPECAST_NULL and used standard NULL consistently (Cosmin).
+  Disallowed the user to redefine png_size_t, and enforced a consistent use
+    of png_size_t across libpng (Cosmin).
+  Changed the type of png_ptr->rowbytes, PNG_ROWBYTES() and friends
+    to png_size_t (Cosmin).
+  Removed png_convert_size() and replaced png_sizeof with sizeof (Cosmin).
+  Removed some unnecessary type casts (Cosmin).
+  Changed prototype of png_get_compression_buffer_size() and
+    png_set_compression_buffer_size() to work with png_size_t instead of
+    png_uint_32 (Cosmin).
+  Removed png_memcpy_check() and png_memset_check() (Cosmin).
+  Fixed a typo (png_byte --> png_bytep) in libpng.3 and libpng.txt (Cosmin).
+  Clarified that png_zalloc() does not clear the allocated memory,
+    and png_zalloc() and png_zfree() cannot be PNGAPI (Cosmin).
+  Renamed png_mem_size_t to png_alloc_size_t, fixed its definition in
+    pngconf.h, and used it in all memory allocation functions (Cosmin).
+  Renamed pngintrn.h to pngpriv.h, added a comment at the top of the file
+    mentioning that the symbols declared in that file are private, and
+    updated the scripts and the Visual C++ projects accordingly (Cosmin).
+  Removed circular references between pngconf.h and pngconf.h.in in
+    scripts/makefile.vc*win32 (Cosmin).
+  Removing trailing '.' from the warning and error messages (Cosmin).
+  Added pngdefs.h that is built by makefile or configure, instead of
+    pngconf.h.in (Glenn).
+  Detect and fix attempt to write wrong iCCP profile length.
+
+Version 1.4.0beta12 [October 19, 2006]
+  Changed "logical" to "bitwise" in the documentation.
+  Work around Intel-Mac compiler bug by setting PNG_NO_MMX_CODE in pngconf.h
+  Add a typecast to stifle compiler warning in pngrutil.c
+
+Version 1.4.0beta13 [November 10, 2006]
+  Fix potential buffer overflow in sPLT chunk handler.
+  Fix Makefile.am to not try to link to noexistent files.
+
+Version 1.4.0beta14 [November 15, 2006]
+  Check all exported functions for NULL png_ptr.
+
+Version 1.4.0beta15 [November 17, 2006]
+  Relocated two misplaced tests for NULL png_ptr.
+  Built Makefile.in with automake-1.9.6 instead of 1.9.2.
+  Build configure with autoconf-2.60 instead of 2.59
+  Add "install: all" in Makefile.am so "configure; make install" will work.
+
+Version 1.4.0beta16 [November 17, 2006]
+  Added a typecast in png_zalloc().
+
+Version 1.4.0beta17 [December 4, 2006]
+  Changed "new_key[79] = '\0';" to "(*new_key)[79] = '\0';" in pngwutil.c
+  Add "png_bytep" typecast to profile while calculating length in pngwutil.c
+
+Version 1.4.0beta18 [December 7, 2006]
+  Added scripts/CMakeLists.txt
+
+Version 1.4.0beta19 [May 16, 2007]
+  Revised scripts/CMakeLists.txt
+  Rebuilt configure and Makefile.in with newer tools.
+  Added conditional #undef jmpbuf in pngtest.c to undo #define in AIX headers.
+  Added scripts/makefile.nommx
+
+Version 1.4.0beta20 [July 9, 2008]
+  Moved several PNG_HAVE_* macros from pngpriv.h to png.h because applications
+    calling set_unknown_chunk_location() need them.
+  Moved several macro definitions from pngpriv.h to pngconf.h
+  Merge with changes to the 1.2.X branch, as of 1.2.30beta04.
+  Deleted all use of the MMX assembler code and Intel-licensed optimizations.
+  Revised makefile.mingw
+
+Version 1.4.0beta21 [July 21, 2008]
+  Moved local array "chunkdata" from pngrutil.c to the png_struct, so
+    it will be freed by png_read_destroy() in case of a read error (Kurt
+    Christensen).
+
+Version 1.4.0beta22 [July 21, 2008]
+  Change "purpose" and "buffer" to png_ptr->chunkdata to avoid memory leaking.
+
+Version 1.4.0beta23 [July 22, 2008]
+  Change "chunkdata = NULL" to "png_ptr->chunkdata = NULL" several places in
+    png_decompress_chunk().
+
+Version 1.4.0beta24 [July 25, 2008]
+  Change all remaining "chunkdata" to "png_ptr->chunkdata" in
+    png_decompress_chunk(), and remove "chunkdata" from parameter list.
+  Put a call to png_check_chunk_name() in png_read_chunk_header().
+  Revised png_check_chunk_name() to reject a name with a lowercase 3rd byte.
+  Removed two calls to png_check_chunk_name() occurring later in the process.
+  Define PNG_NO_ERROR_NUMBERS by default in pngconf.h
+
+Version 1.4.0beta25 [July 30, 2008]
+  Added a call to png_check_chunk_name() in pngpread.c
+  Reverted png_check_chunk_name() to accept a name with a lowercase 3rd byte.
+  Added png_push_have_buffer() function to pngpread.c
+  Eliminated PNG_BIG_ENDIAN_SUPPORTED and associated png_get_* macros.
+  Made inline expansion of png_get_*() optional with PNG_USE_READ_MACROS.
+  Eliminated all PNG_USELESS_TESTS and PNG_CORRECT_PALETTE_SUPPORTED code.
+  Synced contrib directory and configure files with libpng-1.2.30beta06.
+  Eliminated no-longer-used pngdefs.h (but it's still built in the makefiles)
+  Relocated a misplaced "#endif /* PNG_NO_WRITE_FILTER */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/CHANGES:3091
+
+/*/gather.sh scripts.
+  Changes to remove gcc warnings (John Bowler)
+    Certain optional gcc warning flags resulted in warnings in libpng code.
+    With these changes only -Wconversion and -Wcast-qual cannot be turned on.
+    Changes are trivial rearrangements of code.  -Wconversion is not possible
+    for pngrutil.c (because of the widespread use of += et al on variables
+    smaller than (int) or (unsigned int)) and -Wcast-qual is not possible
+    with pngwio.c and pngwutil.c because the 'write' callback and zlib
+    compression both fail to declare their input buffers with 'const'.
+
+Version 1.5.0beta56 [December 7, 2010]
+  Added the private PNG_UNUSED() macro definition in pngpriv.h.
+  Added some commentary about PNG_EXPORT in png.h and pngconf.h
+  Revised PNG_EXPORT() macro and added PNG_EXPORTA() macro, with the
+    objective of simplifying and improving the cosmetic appearance of png.h.
+  Fixed some incorrect "=" macro names in pnglibconf.dfa
+  Included documentation of changes in 1.5.0 from 1.4.x in libpng-manual.txt
+
+Version 1.5.0beta57 [December 9, 2010]
+  Documented the pngvalid gamma error summary with additional comments and
+    print statements.
+  Improved missing symbol handling in checksym.awk; symbols missing in both
+    the old and new files can now be optionally ignored, treated as errors
+    or warnings.
+  Removed references to pngvcrd.c and pnggccrd.c from the vstudio project.
+  Updated "libpng14" to "libpng15" in the visualc71 project.
+  Enabled the strip16 tests in pngvalid.`
+  Don't display test results (except PASS/FAIL) when running "make test".
+    Instead put them in pngtest-log.txt
+  Added "--with-zprefix=<string>" to configure.ac
+  Updated the prebuilt configuration files to autoconf version 2.68
+
+Version 1.5.0beta58 [December 19, 2010]
+  Fixed interlace image handling and add test cases (John Bowler)
+  Fixed the clean rule in Makefile.am to remove pngtest-log.txt
+  Made minor changes to work around warnings in gcc 3.4
+
+Version 1.5.0rc01 [December 27, 2010]
+  No changes.
+
+Version 1.5.0rc02 [December 27, 2010]
+  Eliminated references to the scripts/*.def files in project/visualc71.
+
+Version 1.5.0rc03 [December 28, 2010]
+  Eliminated scripts/*.def and revised Makefile.am accordingly
+
+Version 1.5.0rc04 [December 29, 2010]
+  Fixed bug in background transformation handling in pngrtran.c (it was
+    looking for the flag in png_ptr->transformations instead of in
+    png_ptr->flags) (David Raymond).
+
+Version 1.5.0rc05 [December 31, 2010]
+  Fixed typo in a comment in CMakeLists.txt (libpng14 => libpng15) (Cosmin)
+
+Version 1.5.0rc06 [January 4, 2011]
+  Changed the new configure option "zprefix=string" to "zlib-prefix=string"
+
+Version 1.5.0rc07 [January 4, 2011]
+  Updated copyright year.
+
+Version 1.5.0 [January 6, 2011]
+  No changes.
+
+version 1.5.1beta01 [January 8, 2011]
+  Added description of png_set_crc_action() to the manual.
+  Added a note in the manual that the type of the iCCP profile was changed
+    from png_charpp to png_bytepp in png_get_iCCP().  This change happened
+    in version 1.5.0beta36 but is not noted in the CHANGES.  Similarly,
+    it was changed from png_charpp to png_const_bytepp in png_set_iCCP().
+  Ensure that png_rgb_to_gray ignores palette mapped images, if libpng
+    internally happens to call it with one, and fixed a failure to handle
+    palette mapped images correctly.  This fixes CVE-2690.
+
+Version 1.5.1beta02 [January 14, 2011]
+  Fixed a bug in handling of interlaced images (bero at arklinux.org).
+  Updated CMakeLists.txt (Clifford Yapp)
+
+Version 1.5.1beta03 [January 14, 2011]
+  Fixed typecasting of some png_debug() statements (Cosmin)
+
+Version 1.5.1beta04 [January 16, 2011]
+  Updated documentation of png_set|get_tRNS() (Thomas Klausner).
+  Mentioned in the documentation that applications must #include "zlib.h"
+    if they need access to anything in zlib.h, and that a number of
+    macros such as png_memset() are no longer accessible by applications.
+  Corrected pngvalid gamma test "sample" function to access all of the color
+    samples of each pixel, instead of sampling the red channel three times.
+  Prefixed variable names index, div, exp, gamma with "png_" to avoid "shadow"
+    warnings, and (mistakenly) changed png_exp() to exp().
+
+Version 1.5.1beta05 [January 16, 2011]
+  Changed variable names png_index, png_div, png_exp, and png_gamma to
+    char_index, divisor, exp_b10, and gamma_val, respectively, and
+    changed exp() back to png_exp().
+
+Version 1.5.1beta06 [January 20, 2011]
+  Prevent png_push_crc_skip() from hanging while reading an unknown chunk
+    or an over-large compressed zTXt chunk with the progressive reader.
+  Eliminated more GCC "shadow" warnings.
+  Revised png_fixed() in png.c to avoid compiler warning about reaching the
+    end without returning anything.
+
+Version 1.5.1beta07 [January 22, 2011]
+  In the manual, describe the png_get_IHDR() arguments in the correct order.
+  Added const_png_structp and const_png_infop types, and used them in
+    prototypes for most png_get_*() functions.
+
+Version 1.5.1beta08 [January 23, 2011]
+  Added png_get_io_chunk_type() and deprecated png_get_io_chunk_name()
+  Added synopses for the IO_STATE functions and other missing synopses
+    to the manual. Removed the synopses from libpngpf.3 because they
+    were out of date and no longer useful.  Better information can be
+    obtained by reading the prototypes and comments in pngpriv.h
+  Attempted to fix cpp on Solaris with S. Studio 12 cc, fix build
+    Added a make macro DFNCPP that is a CPP that will accept the tokens in
+    a .dfn file and adds configure stuff to test for such a CPP.  ./configure
+    should fail if one is not available.
+  Corrected const_png_ in png.h to png_const_ to avoid polluting the namespace.
+  Added png_get_current_row_number and png_get_current_pass_number for the
+    benefit of the user transform callback.
+  Added png_process_data_pause and png_process_data_skip for the benefit of
+    progressive readers that need to stop data processing or want to optimize
+    skipping of unread data (e.g., if the reader marks a chunk to be skipped.)
+
+Version 1.5.1beta09 [January 24, 2011]
+  Enhanced pngvalid, corrected an error in gray_to_rgb, corrected doc error.
+    pngvalid contains tests of transforms, which tests are currently disabled
+    because they are incompletely tested.  gray_to_rgb was failing to expand
+    the bit depth for smaller bit depth images; this seems to be a long
+    standing error and resulted, apparently, in invalid output
+    (CVE-2011-0408, CERT VU#643140).  The documentation did not accurately
+    describe what libpng really does when converting RGB to gray.
+
+Version 1.5.1beta10 [January 27, 2010]
+  Fixed incorrect examples of callback prototypes in the manual, that were
+    introduced in libpng-1.0.0.
+  In addition the order of the png_get_uint macros with respect to the
+    relevant function definitions has been reversed.  This helps the
+    preprocessing of the symbol files be more robust.  Furthermore, the
+    symbol file preprocessing now uses -DPNG_NO_USE_READ_MACROS even when
+    the library may actually be built with PNG_USE_READ_MACROS; this stops
+    the read macros interfering with the symbol file format.
+  Made the manual, synopses, and function prototypes use the function
+    argument names file_gamma, int_file_gamma, and srgb_intent consistently.
+
+Version 1.5.1beta11 [January 28, 2011]
+  Changed PNG_UNUSED from "param=param;" to "{if(param){}}".
+  Corrected local variable type in new API png_process_data_skip()
+    The type was self-evidently incorrect but only causes problems on 64-bit
+    architectures.
+  Added transform tests to pngvalid and simplified the arguments.
+
+Version 1.5.1rc01 [January 29, 2011]
+  No changes.
+
+Version 1.5.1rc02 [January 31, 2011]
+  Added a request in the manual that applications do not use "png_" or
+    "PNG_" to begin any of their own symbols.
+  Changed PNG_UNUSED to "(void)param;" and updated the commentary in pngpriv.h
+
+Version 1.5.1 [February 3, 2011]
+  No changes.
+
+Version 1.5.2beta01 [February 13, 2011]
+  More -Wshadow fixes for older gcc compilers.  Older gcc versions apparently
+    check formal parameters names in function declarations (as well as
+    definitions) to see if they match a name in the global namespace.
+  Revised PNG_EXPORTA macro to not use an empty parameter, to accommodate the
+    old VisualC++ preprocessor.
+  Turned on interlace handling in png_read_png().
+  Fixed gcc pedantic warnings.
+  Handle longjmp in Cygwin.
+  Fixed png_get_current_row_number() in the interlaced case.
+  Cleaned up ALPHA flags and transformations.
+  Implemented expansion to 16 bits.
+
+Version 1.5.2beta02 [February 19, 2011]
+  Fixed mistake in the descriptions of user read_transform and write_transform
+    function prototypes in the manual.  The row_info struct is png_row_infop.
+  Reverted png_get_current_row_number() to previous (1.5.2beta01) behavior.
+  Corrected png_get_current_row_number documentation
+  Fixed the read/write row callback documentation.
+    This documents the current behavior, where the callback is called after
+    every row with information pertaining to the next row.
+
+Version 1.5.2beta03 [March 3, 2011]
+  Fixed scripts/makefile.vcwin32
+  Updated contrib/pngsuite/README to add the word "modify".
+  Define PNG_ALLOCATED to blank when _MSC_VER<1300.
+
+Version 1.5.2rc01 [March 19, 2011]
+  Define remaining attributes to blank when MSC_VER<1300.
+  ifdef out mask arrays in pngread.c when interlacing is not supported.
+
+Version 1.5.2rc02 [March 22, 2011]
+  Added a hint to try CPP=/bin/cpp if "cpp -E" fails in scripts/pnglibconf.mak
+    and in contrib/pngminim/*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/arm/arm_init.c:1
+
+/* arm_init.c - NEON optimised filter functions
+ *
+ * Copyright (c) 2018-2022 Cosmin Truta
+ * Copyright (c) 2014,2016 Glenn Randers-Pehrson
+ * Written by Mans Rullgard, 2011.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/arm/filter_neon.S:1
+
+/* filter_neon.S - placeholder file
+ *
+ * Copyright (c) 2024 Cosmin Truta
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/arm/filter_neon_intrinsics.c:1
+
+/* filter_neon_intrinsics.c - NEON optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2014,2016 Glenn Randers-Pehrson
+ * Written by James Yu <james.yu at linaro.org>, October 2013.
+ * Based on filter_neon.S, written by Mans Rullgard, 2011.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/arm/palette_neon_intrinsics.c:1
+
+/* palette_neon_intrinsics.c - NEON optimised palette expansion functions
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 2017-2018 Arm Holdings. All rights reserved.
+ * Written by Richard Townsend <Richard.Townsend@arm.com>, February 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/intel/filter_sse2_intrinsics.c:1
+
+/* filter_sse2_intrinsics.c - SSE2 optimized filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2016-2017 Glenn Randers-Pehrson
+ * Written by Mike Klein and Matt Sarett
+ * Derived from arm/filter_neon_intrinsics.c
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/intel/intel_init.c:1
+
+/* intel_init.c - SSE2 optimized filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2016-2017 Glenn Randers-Pehrson
+ * Written by Mike Klein and Matt Sarett, Google, Inc.
+ * Derived from arm/arm_init.c
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/loongarch/filter_lsx_intrinsics.c:1
+
+/* filter_lsx_intrinsics.c - LSX optimized filter functions
+ *
+ * Copyright (c) 2021 Loongson Technology Corporation Limited
+ * All rights reserved.
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Contributed by Jin Bo (jinbo@loongson.cn)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/loongarch/loongarch_lsx_init.c:1
+
+/* loongarch_lsx_init.c - LSX optimized filter functions
+ *
+ * Copyright (c) 2021 Loongson Technology Corporation Limited
+ * All rights reserved.
+ * Contributed by Jin Bo <jinbo@loongson.cn>
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/mips/filter_mmi_inline_assembly.c:1
+
+/* filter_mmi_intrinsics.c - MMI optimized filter functions
+ *
+ * Copyright (c) 2024 Cosmin Truta
+ * Written by zhanglixia and guxiwei, 2023
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/mips/filter_msa_intrinsics.c:1
+
+/* filter_msa_intrinsics.c - MSA optimised filter functions
+ *
+ * Copyright (c) 2018-2024 Cosmin Truta
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Written by Mandar Sahastrabuddhe, August 2016
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/mips/mips_init.c:1
+
+/* mips_init.c - MSA optimised filter functions
+ *
+ * Copyright (c) 2018-2024 Cosmin Truta
+ * Copyright (c) 2016 Glenn Randers-Pehrson
+ * Written by Mandar Sahastrabuddhe, 2016
+ * Updated by guxiwei, 2023
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/png.c:1
+
+/* png.c - location for general purpose libpng functions
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/png.h:1
+
+/* png.h - header file for PNG reference library
+ *
+ * libpng version 1.6.57
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license. (See LICENSE, below.)
+ *
+ * Authors and maintainers:
+ *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
+ *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
+ *   libpng versions 0.97, January 1998, through 1.6.35, July 2018:
+ *     Glenn Randers-Pehrson
+ *   libpng versions 1.6.36, December 2018, through 1.6.57, April 2026:
+ *     Cosmin Truta
+ *   See also "Contributing Authors", below.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/png.h:22
+
+/*
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
+ * =========================================
+ *
+ * PNG Reference Library License version 2
+ * ---------------------------------------
+ *
+ *  * Copyright (c) 1995-2026 The PNG Reference Library Authors.
+ *  * Copyright (c) 2018-2026 Cosmin Truta.
+ *  * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
+ *  * Copyright (c) 1996-1997 Andreas Dilger.
+ *  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * The software is supplied "as is", without warranty of any kind,
+ * express or implied, including, without limitation, the warranties
+ * of merchantability, fitness for a particular purpose, title, and
+ * non-infringement.  In no event shall the Copyright owners, or
+ * anyone distributing the software, be liable for any damages or
+ * other liability, whether in contract, tort or otherwise, arising
+ * from, out of, or in connection with the software, or the use or
+ * other dealings in the software, even if advised of the possibility
+ * of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute
+ * this software, or portions hereof, for any purpose, without fee,
+ * subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you
+ *     must not claim that you wrote the original software.  If you
+ *     use this software in a product, an acknowledgment in the product
+ *     documentation would be appreciated, but is not required.
+ *
+ *  2. Altered source versions must be plainly marked as such, and must
+ *     not be misrepresented as being the original software.
+ *
+ *  3. This Copyright notice may not be removed or altered from any
+ *     source or altered source distribution.
+ *
+ *
+ * PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35)
+ * -----------------------------------------------------------------------
+ *
+ * libpng versions 1.0.7, July 1, 2000, through 1.6.35, July 15, 2018 are
+ * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are
+ * derived from libpng-1.0.6, and are distributed according to the same
+ * disclaimer and license as libpng-1.0.6 with the following individuals
+ * added to the list of Contributing Authors:
+ *
+ *     Simon-Pierre Cadieux
+ *     Eric S. Raymond
+ *     Mans Rullgard
+ *     Cosmin Truta
+ *     Gilles Vollant
+ *     James Yu
+ *     Mandar Sahastrabuddhe
+ *     Google Inc.
+ *     Vadim Barkov
+ *
+ * and with the following additions to the disclaimer:
+ *
+ *     There is no warranty against interference with your enjoyment of
+ *     the library or against infringement.  There is no warranty that our
+ *     efforts or the library will fulfill any of your particular purposes
+ *     or needs.  This library is provided with all faults, and the entire
+ *     risk of satisfactory quality, performance, accuracy, and effort is
+ *     with the user.
+ *
+ * Some files in the "contrib" directory and some configure-generated
+ * files that are distributed with libpng have other copyright owners, and
+ * are released under other open source licenses.
+ *
+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+ * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
+ * libpng-0.96, and are distributed according to the same disclaimer and
+ * license as libpng-0.96, with the following individuals added to the
+ * list of Contributing Authors:
+ *
+ *     Tom Lane
+ *     Glenn Randers-Pehrson
+ *     Willem van Schaik
+ *
+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are
+ * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
+ * and are distributed according to the same disclaimer and license as
+ * libpng-0.88, with the following individuals added to the list of
+ * Contributing Authors:
+ *
+ *     John Bowler
+ *     Kevin Bracey
+ *     Sam Bushell
+ *     Magnus Holmgren
+ *     Greg Roelofs
+ *     Tom Tanner
+ *
+ * Some files in the "scripts" directory have other copyright owners,
+ * but are released under this license.
+ *
+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * For the purposes of this copyright and license, "Contributing Authors"
+ * is defined as the following set of individuals:
+ *
+ *     Andreas Dilger
+ *     Dave Martindale
+ *     Guy Eric Schalnat
+ *     Paul Schmidt
+ *     Tim Wegner
+ *
+ * The PNG Reference Library is supplied "AS IS".  The Contributing
+ * Authors and Group 42, Inc. disclaim all warranties, expressed or
+ * implied, including, without limitation, the warranties of
+ * merchantability and of fitness for any purpose.  The Contributing
+ * Authors and Group 42, Inc. assume no liability for direct, indirect,
+ * incidental, special, exemplary, or consequential damages, which may
+ * result from the use of the PNG Reference Library, even if advised of
+ * the possibility of such damage.
+ *
+ * Permission is hereby granted to use, copy, modify, and distribute this
+ * source code, or portions hereof, for any purpose, without fee, subject
+ * to the following restrictions:
+ *
+ *  1. The origin of this source code must not be misrepresented.
+ *
+ *  2. Altered versions must be plainly marked as such and must not
+ *     be misrepresented as being the original source.
+ *
+ *  3. This Copyright notice may not be removed or altered from any
+ *     source or altered source distribution.
+ *
+ * The Contributing Authors and Group 42, Inc. specifically permit,
+ * without fee, and encourage the use of this source code as a component
+ * to supporting the PNG file format in commercial products.  If you use
+ * this source code in a product, acknowledgment is not required but would
+ * be appreciated.
+ *
+ * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
+ *
+ * TRADEMARK
+ * =========
+ *
+ * The name "libpng" has not been registered by the Copyright owners
+ * as a trademark in any jurisdiction.  However, because libpng has
+ * been distributed and maintained world-wide, continually since 1995,
+ * the Copyright owners claim "common-law trademark protection" in any
+ * jurisdiction where common-law trademark is recognized.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/png.h:170
+
+/*
+ * A "png_get_copyright" function is available, for convenient use in "about"
+ * boxes and the like:
+ *
+ *    printf("%s", png_get_copyright(NULL));
+ *
+ * Also, the PNG logo (in PNG format, of course) is supplied in the
+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/png.h:3316
+
+/* With all write APIs if image is in one of the linear formats with 16-bit
+ * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
+ * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
+ * encoded PNG file is written.
+ *
+ * With color-mapped data formats the colormap parameter point to a color-map
+ * with at least image->colormap_entries encoded in the specified format.  If
+ * the format is linear the written PNG color-map will be converted to sRGB
+ * regardless of the convert_to_8_bit flag.
+ *
+ * With all APIs row_stride is handled as in the read APIs - it is the spacing
+ * from one row to the next in component sized units (1 or 2 bytes) and if
+ * negative indicates a bottom-up row layout in the buffer.  If row_stride is
+ * zero, libpng will calculate it for you from the image width and number of
+ * channels.
+ *
+ * Note that the write API does not support interlacing, sub-8-bit pixels or
+ * most ancillary chunks.  If you need to write text chunks (e.g. for copyright
+ * notices) you need to use one of the other APIs.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngconf.h:1
+
+/* pngconf.h - machine-configurable file for libpng
+ *
+ * libpng version 1.6.57
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * Any machine specific code is near the front of this file, so if you
+ * are configuring libpng for a machine, you may want to read the section
+ * starting here down to where it starts to typedef png_color, png_text,
+ * and png_info.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngdebug.h:1
+
+/* pngdebug.h - internal debugging macros for libpng
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngerror.c:1
+
+/* pngerror.c - stub functions for i/o and memory allocation
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all error handling.  Users who
+ * need special error handling are expected to write replacement functions
+ * and use png_set_error_fn() to use those functions.  See the instructions
+ * at each function.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngget.c:1
+
+/* pngget.c - retrieval of values from info struct
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pnginfo.h:1
+
+/* pnginfo.h - internal structures for libpng
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2013,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pnglibconf.h:5
+
+/* Copyright (c) 2018-2025 Cosmin Truta */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pnglibconf.h:6
+
+/* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pnglibconf.h:8
+
+/* This code is released under the libpng license. */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pnglibconf.h:10
+
+/* and license in png.h */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngmem.c:1
+
+/* pngmem.c - stub functions for memory allocation
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2014,2016 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all memory allocation.  Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngpread.c:1
+
+/* pngpread.c - read a png file in push mode
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngpriv.h:1
+
+/* pngpriv.h - private declarations for use inside libpng
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngread.c:1
+
+/* pngread.c - read a PNG file
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains routines that an application calls directly to
+ * read a PNG file or stream.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngrio.c:1
+
+/* pngrio.c - functions for data input
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all input.  Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method.  Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngrtran.c:1
+
+/* pngrtran.c - transforms the data in a row for PNG readers
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains functions optionally called by an application
+ * in order to tell libpng how to handle data when reading a PNG.
+ * Transformations that are used in both reading and writing are
+ * in pngtrans.c.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngrutil.c:1
+
+/* pngrutil.c - utilities to read a PNG file
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains routines that are only called from within
+ * libpng itself during the course of reading an image.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngset.c:1
+
+/* pngset.c - storage of image information into info struct
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * The functions here are used during reads to store data from the file
+ * into the info struct, and during writes to store application data
+ * into the info struct for writing into the file.  This abstracts the
+ * info struct and allows us to change the structure in the future.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngstruct.h:1
+
+/* pngstruct.h - internal structures for libpng
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngtrans.c:1
+
+/* pngtrans.c - transforms the data in a row (used by both readers and writers)
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngwio.c:1
+
+/* pngwio.c - functions for data output
+ *
+ * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2014,2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all output.  Users who need
+ * special handling are expected to write functions that have the same
+ * arguments as these and perform similar functions, but that possibly
+ * use different output methods.  Note that you shouldn't change these
+ * functions, but rather write replacement functions and then change
+ * them at run time with png_set_write_fn(...).
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngwrite.c:1
+
+/* pngwrite.c - general routines to write a PNG file
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngwtran.c:1
+
+/* pngwtran.c - transforms the data in a row for PNG writers
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/pngwutil.c:1
+
+/* pngwutil.c - utilities to write a PNG file
+ *
+ * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1996-1997 Andreas Dilger
+ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file contains routines that are only called from within
+ * libpng itself during the course of writing an image.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/powerpc/filter_vsx_intrinsics.c:1
+
+/* filter_vsx_intrinsics.c - PowerPC optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/powerpc/powerpc_init.c:1
+
+/* powerpc_init.c - POWERPC optimised filter functions
+ *
+ * Copyright (c) 2018 Cosmin Truta
+ * Copyright (c) 2017 Glenn Randers-Pehrson
+ * Written by Vadim Barkov, 2017.
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/riscv/filter_rvv_intrinsics.c:1
+
+/* filter_rvv_intrinsics.c - RISC-V Vector optimized filter functions
+ *
+ * Copyright (c) 2023 Google LLC
+ * Written by Manfred SCHLAEGL, 2022
+ * Revised by:
+ *  - Dragoș Tiselice <dtiselice@google.com>, May 2023
+ *  - Filip Wasil <f.wasil@samsung.com>, March 2025
+ *  - Liang Junzhao <junzhao.liang@spacemit.com>, November 2025
+ *  - Alexander Smorkalov <alexander.smorkalov@opencv.ai>, December 2025
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/libpng/riscv/riscv_init.c:1
+
+/* riscv_init.c - RISC-V Vector optimized filter functions
+ *
+ * Copyright (c) 2023 Google LLC
+ * Written by Dragoș Tiselice <dtiselice@google.com>, May 2023.
+ *            Filip Wasil     <f.wasil@samsung.com>, March 2025.
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/inc/mlas.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    mlas.h
+
+Abstract:
+
+    This module contains the public data structures and procedure prototypes
+    for the Microsoft Machine Learning algebra subprogram library.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/inc/mlas_float16.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    mlas_float16.h
+
+Abstract:
+
+    Utilities for half precision floating type conversions.  Used internally
+    by MLAS on platforms without half precision support.  Provided here as
+    convenience for tests or other client libraries/apps.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/aarch64/SgemmKernelNeon.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelNeon.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/aarch64/SgemvKernelNeon.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemvKernelNeon.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/vector
+    multiply operation (SGEMV).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/aarch64/asmmacro.h:1
+upstream/opencv/3rdparty/mlas/lib/x86/asmmacro.h:1
+upstream/opencv/3rdparty/mlas/lib/x86_64/asmmacro.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    asmmacro.h
+
+Abstract:
+
+    This module implements common macros for the assembly modules.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/arm/sgemmc.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    sgemmc.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/compute.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    compute.cpp
+
+Abstract:
+
+    This module implements miscellaneous computation routines.
+
+    Our usage requires building platform specific versions of the algorithm to
+    target different instruction sets. The implementation below targets the
+    base instruction set (typically SSE2) while assembly implementations target
+    newer instruction sets (such as FMA3).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/erf_neon_fp16.h:1
+
+/*++
+
+Copyright 2025 FUJITSU LIMITED
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+   erf_neon_fp16.h
+
+Abstract:
+
+    This module contains the procedure prototypes for the ERF NEON FP16 intrinsics.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/gelu_neon_fp16.h:1
+
+/*++
+
+Copyright 2025 FUJITSU LIMITED
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    gelu_neon_fp16.h
+
+Abstract:
+
+    This module contains Gelu helper functions .
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/kleidiai/mlasi_kleidiai.h:1
+
+//
+// SPDX-FileCopyrightText: Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>
+//
+// SPDX-License-Identifier: MIT
+//
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLasx.S:1
+
+/*++
+
+Copyright (C) 2023 Loongson Technology Corporation Limited. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelLasx.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses LASX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLsx.S:1
+
+/*++
+
+Copyright (C) 2023 Loongson Technology Corporation Limited. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelLsx.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses Lsx instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4LSX.S:1
+
+/*++
+
+Copyright (C) 2023 Loongson Technology Corporation Limited. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmTransposePackB16x4LSX.s
+
+Abstract:
+
+    This module implements routines for packing buffers for the single precision
+    matrix/matrix multiply operation (SGEMM).
+
+    This implementation uses Lsx instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4Lasx.S:1
+
+/*++
+
+Copyright (C) 2023 Loongson Technology Corporation Limited. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmTransposePackB16x4Lasx.s
+
+Abstract:
+
+    This module implements routines for packing buffers for the single precision
+    matrix/matrix multiply operation (SGEMM).
+
+    This implementation uses Lasx instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/loongarch64/asmmacro.h:1
+
+/*++
+
+Copyright (C) 2023 Loongson Technology Corporation Limited. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    asmmacro.h
+
+Abstract:
+
+    This module implements common macros for the assembly modules.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/mlasi.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    mlasi.h
+
+Abstract:
+
+    This module contains the private data structures and procedure prototypes
+    for the Microsoft Machine Learning algebra subprogram library.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/platform.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    platform.cpp
+
+Abstract:
+
+    This module implements logic to select the best configuration for the
+    this platform.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPOWER10.cpp:1
+upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPower.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelPower.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPackA.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelPackA.S
+
+Abstract:
+
+    This module implements the POWER10 kernel for packing matrix A for single precision SGEMM.
+
+    This implementation targets power10 using VSX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/qgemm.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    qgemm.h
+
+Abstract:
+
+    This module defines the set of template functions to implement a kernel of
+    quantized integer matrix/matrix multiply operation (QGEMM).
+
+    To implement a new kernel, template functions below need to be specialized:
+        MlasGemmQuantFixupZeroPointA
+        MlasGemmQuantFixupZeroPointB
+        MlasGemmQuantCopyPackA
+        MlasGemmQuantCopyPackB
+        MlasGemmQuantKernel
+    Specialization of MlasGemmQuantTryGemvKernel is optional.
+
+    MlasGemmQuantOperation and MlasGemmQuantPackedOperation are shared kernel drivers.
+    MlasGemmQuantScaleSumBuffer is a helper function.
+
+    It also includes the dispatcher logics.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_kernel_rvv.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    sgemm_kernel_rvv.cpp
+
+Abstract:
+
+    This module implements an RVV kernel for the single precision matrix/matrix
+    multiply operation (SGEMM) on riscv64.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_pack_b_rvv.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    sgemm_pack_b_rvv.cpp
+
+Abstract:
+
+    This module implements an RVV packing helper for the single precision
+    matrix/matrix multiply operation (SGEMM) on riscv64.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernel.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernel.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernelZVECTOR.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelZVECTOR.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/scalar/SconvDepthwiseKernelScalar.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SconvDepthwiseKernelScalar.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision direct
+    convolution kernels.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/scalar/SgemmKernelScalar.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelScalar.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/scalar/SgemvKernelScalar.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemvKernelScalar.cpp
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/vector
+    multiply operation (SGEMV).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/sgemm.cpp:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    sgemm.cpp
+
+Abstract:
+
+    This module implements the single precision matrix/matrix multiply
+    operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/softmax.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    softmax.h
+
+Abstract:
+
+    This module includes kernel function prototypes and helper functions for
+    softmax.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/sve/mlasi_sve.h:1
+
+/*++
+
+Copyright 2025 FUJITSU LIMITED
+
+Module Name:
+
+    mlasi_sve.h
+
+Abstract:
+
+    This module contains the procedure prototypes for the SVE intrinsics.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelAvx.S:1
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelAvx.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses AVX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelSse2.S:1
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelSse2.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelSse2.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses SSE2 instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86/x86.get_pc_thunk.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    x86.get_pc_thunk.S
+
+Abstract:
+
+    This module implements __x86.get_pc_thunk.* to avoid external dependency.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvx512FCommon.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    FgemmKernelAvx512FCommon.h
+
+Abstract:
+
+    This module implements the kernels for the floating point matrix/matrix
+    multiply operation (SGEMM and DGEMM).
+
+    This implementation uses AVX512F instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvxCommon.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    FgemmKernelAvxCommon.h
+
+Abstract:
+
+    This module implements the kernels for the floating point matrix/matrix
+    multiply operation (SGEMM and DGEMM).
+
+    This implementation uses AVX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelCommon.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    FgemmKernelCommon.h
+
+Abstract:
+
+    This module contains common kernel macros and structures for the floating
+    point matrix/matrix multiply operation (SGEMM and DGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelFma3Common.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    FgemmKernelFma3Common.h
+
+Abstract:
+
+    This module implements the kernels for the floating point matrix/matrix
+    multiply operation (SGEMM and DGEMM).
+
+    This implementation uses AVX fused multiply/add instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelSse2Common.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    FgemmKernelSse2Common.h
+
+Abstract:
+
+    This module implements the kernels for the floating point matrix/matrix
+    multiply operation (SGEMM and DGEMM).
+
+    This implementation uses SSE2 instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx512F.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelAvx512F.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses AVX512F instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelCommon.h:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelCommon.h
+
+Abstract:
+
+    This module contains common kernel macros and structures for the single
+    precision matrix/matrix multiply operation (SGEMM).
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelFma3.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelFma3.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM).
+
+    This implementation uses AVX fused multiply/add instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1Avx.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelM1Avx.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM). This handles the special case of M=1.
+
+    This implementation uses AVX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1TransposeBAvx.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmKernelM1TransposeBAvx.s
+
+Abstract:
+
+    This module implements the kernels for the single precision matrix/matrix
+    multiply operation (SGEMM). This handles the special case of M=1.
+
+    This implementation uses AVX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Avx.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmTransposePackB16x4Avx.s
+
+Abstract:
+
+    This module implements routines for packing buffers for the single precision
+    matrix/matrix multiply operation (SGEMM).
+
+    This implementation uses AVX instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Sse2.S:1
+
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License.
+
+Module Name:
+
+    SgemmTransposePackB16x4Sse2.s
+
+Abstract:
+
+    This module implements routines for packing buffers for the single precision
+    matrix/matrix multiply operation (SGEMM).
+
+    This implementation uses SSE2 instructions.
+
+--*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/any_lite.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena_impl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/explicitly_constructed.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_heavy.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_inl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/field_access_listener.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_reflection.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_bases.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_table_driven.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_decl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.inc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/has_bits.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/inlined_string_field.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/package_info.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry_lite.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_inl.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_lite.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_type_handler.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata_lite.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/port.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_def.inc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_undef.inc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_internal.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/hash.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/logging.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/macros.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/once.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/port.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stl_util.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/structurally_valid.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.h:1
+
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/casts.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/map_util.h:1
+
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/mutex.h:1
+
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/platform_macros.h:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.cc:1
+upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.h:1
+
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/adler32.c:1
+
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/compress.c:1
+
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2026 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/crc32.c:1
+
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * This interleaved implementation of a CRC makes use of pipelined multiple
+ * arithmetic-logic units, commonly found in modern CPU cores. It is due to
+ * Kadatch and Jenkins (2010). See doc/crc-doc.1.0.pdf in this distribution.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/deflate.c:1
+
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2026 Jean-loup Gailly and Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/deflate.c:6
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many people for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ *      Available at https://datatracker.ietf.org/doc/html/rfc1951
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/deflate.c:56
+upstream/opencv/3rdparty/zlib/inftrees.c:27
+
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/deflate.h:1
+
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2026 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/gzclose.c:1
+
+/* gzclose.c -- zlib gzclose() function
+ * Copyright (C) 2004, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/gzguts.h:1
+
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/gzlib.c:1
+
+/* gzlib.c -- zlib functions common to reading and writing gzip files
+ * Copyright (C) 2004-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/gzread.c:1
+
+/* gzread.c -- zlib functions for reading gzip files
+ * Copyright (C) 2004-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/gzwrite.c:1
+
+/* gzwrite.c -- zlib functions for writing gzip files
+ * Copyright (C) 2004-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/infback.c:1
+
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inffast.c:1
+
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inffast.h:1
+
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inflate.c:1
+
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inflate.h:1
+
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2019 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inftrees.c:1
+
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/inftrees.h:1
+
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/trees.c:1
+
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2026 Jean-loup Gailly
+ * detect_data_type() function provided freely by Cosmin Truta, 2006
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/uncompr.c:1
+
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2026 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/zconf.h.in:1
+
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2026 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/zlib.h:1
+
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.3.2, February 17th, 2026
+
+  Copyright (C) 1995-2026 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 at https://datatracker.ietf.org/doc/html/rfc1950
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/zutil.c:1
+
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2026 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/3rdparty/zlib/zutil.h:1
+
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2026 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/include/opencv2/opencv.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/include/opencv2/calib.hpp:1
+upstream/opencv/modules/calib/include/opencv2/calib3d/calib3d.hpp:1
+upstream/opencv/modules/calib/include/opencv2/calib3d.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx512.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_forward.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lasx.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lsx.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_math.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse_em.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_vsx.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/softfloat.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/vsx_utils.hpp:1
+upstream/opencv/modules/core/src/arithm.dispatch.cpp:1
+upstream/opencv/modules/core/src/arithm.simd.hpp:1
+upstream/opencv/modules/core/src/arithm_ipp.hpp:1
+upstream/opencv/modules/core/src/batch_distance.cpp:1
+upstream/opencv/modules/core/src/channels.cpp:1
+upstream/opencv/modules/core/src/convert.dispatch.cpp:1
+upstream/opencv/modules/core/src/convert.hpp:1
+upstream/opencv/modules/core/src/convert.simd.hpp:1
+upstream/opencv/modules/core/src/convert_scale.dispatch.cpp:1
+upstream/opencv/modules/core/src/convert_scale.simd.hpp:1
+upstream/opencv/modules/core/src/count_non_zero.dispatch.cpp:1
+upstream/opencv/modules/core/src/count_non_zero.simd.hpp:1
+upstream/opencv/modules/core/src/has_non_zero.dispatch.cpp:1
+upstream/opencv/modules/core/src/has_non_zero.simd.hpp:1
+upstream/opencv/modules/core/src/lut.cpp:1
+upstream/opencv/modules/core/src/matrix.cpp:1
+upstream/opencv/modules/core/src/matrix_decomp.cpp:1
+upstream/opencv/modules/core/src/matrix_expressions.cpp:1
+upstream/opencv/modules/core/src/matrix_iterator.cpp:1
+upstream/opencv/modules/core/src/matrix_operations.cpp:1
+upstream/opencv/modules/core/src/matrix_sparse.cpp:1
+upstream/opencv/modules/core/src/matrix_wrap.cpp:1
+upstream/opencv/modules/core/src/mean.dispatch.cpp:1
+upstream/opencv/modules/core/src/mean.simd.hpp:1
+upstream/opencv/modules/core/src/merge.dispatch.cpp:1
+upstream/opencv/modules/core/src/merge.simd.hpp:1
+upstream/opencv/modules/core/src/minmax.dispatch.cpp:1
+upstream/opencv/modules/core/src/minmax.simd.hpp:1
+upstream/opencv/modules/core/src/nan_mask.simd.hpp:1
+upstream/opencv/modules/core/src/norm.dispatch.cpp:1
+upstream/opencv/modules/core/src/opencl/finitemask.cl:1
+upstream/opencv/modules/core/src/persistence.cpp:1
+upstream/opencv/modules/core/src/persistence.hpp:1
+upstream/opencv/modules/core/src/persistence_base64_encoding.cpp:1
+upstream/opencv/modules/core/src/persistence_base64_encoding.hpp:1
+upstream/opencv/modules/core/src/persistence_impl.hpp:1
+upstream/opencv/modules/core/src/persistence_json.cpp:1
+upstream/opencv/modules/core/src/persistence_types.cpp:1
+upstream/opencv/modules/core/src/persistence_xml.cpp:1
+upstream/opencv/modules/core/src/persistence_yml.cpp:1
+upstream/opencv/modules/core/src/reduce.dispatch.cpp:1
+upstream/opencv/modules/core/src/reduce.simd.hpp:1
+upstream/opencv/modules/core/src/softfloat.cpp:1
+upstream/opencv/modules/core/src/split.dispatch.cpp:1
+upstream/opencv/modules/core/src/split.simd.hpp:1
+upstream/opencv/modules/core/src/stat.hpp:1
+upstream/opencv/modules/core/src/sum.dispatch.cpp:1
+upstream/opencv/modules/core/src/sum.simd.hpp:1
+upstream/opencv/modules/features/src/annoy.cpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry/2d.hpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry/3d.hpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry/detail/optimizer.hpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry/mst.hpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry.hpp:1
+upstream/opencv/modules/geometry/src/epnp.cpp:1
+upstream/opencv/modules/geometry/src/epnp.h:1
+upstream/opencv/modules/geometry/src/ippe.cpp:1
+upstream/opencv/modules/geometry/src/ippe.hpp:1
+upstream/opencv/modules/geometry/src/mst.cpp:1
+upstream/opencv/modules/geometry/src/p3p.cpp:1
+upstream/opencv/modules/geometry/src/p3p.h:1
+upstream/opencv/modules/geometry/src/polynom_solver.cpp:1
+upstream/opencv/modules/geometry/src/polynom_solver.h:1
+upstream/opencv/modules/geometry/src/sqpnp.cpp:8
+upstream/opencv/modules/geometry/src/sqpnp.hpp:8
+upstream/opencv/modules/imgproc/src/color.cpp:1
+upstream/opencv/modules/imgproc/src/color.hpp:1
+upstream/opencv/modules/imgproc/src/color.simd_helpers.hpp:1
+upstream/opencv/modules/imgproc/src/color_hsv.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/color_hsv.simd.hpp:1
+upstream/opencv/modules/imgproc/src/color_lab.cpp:1
+upstream/opencv/modules/imgproc/src/color_rgb.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/color_rgb.simd.hpp:1
+upstream/opencv/modules/imgproc/src/color_yuv.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/color_yuv.simd.hpp:1
+upstream/opencv/modules/imgproc/src/contours_approx.cpp:1
+upstream/opencv/modules/imgproc/src/contours_blockstorage.hpp:1
+upstream/opencv/modules/imgproc/src/contours_common.cpp:1
+upstream/opencv/modules/imgproc/src/contours_common.hpp:1
+upstream/opencv/modules/imgproc/src/contours_link.cpp:1
+upstream/opencv/modules/imgproc/src/contours_new.cpp:1
+upstream/opencv/modules/imgproc/src/drawing_text.cpp:1
+upstream/opencv/modules/imgproc/src/emd_new.cpp:1
+upstream/opencv/modules/imgproc/src/fisheye.cpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/charuco_detector.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/graphical_code_detector.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/aruco_utils.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/predefined_dictionaries.hpp:1
+upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp:1
+upstream/opencv/modules/objdetect/src/graphical_code_detector_impl.hpp:1
+upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/depth.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/kinfu_frame.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/pose_graph.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/submap.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_frame.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_settings.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume_settings.hpp:1
+upstream/opencv/modules/ptcloud/include/opencv2/ptcloud.hpp:1
+upstream/opencv/modules/ptcloud/samples/odometry_evaluation.cpp:1
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp:1
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.hpp:1
+upstream/opencv/modules/ptcloud/src/depth_registration.cpp:1
+upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp:1
+upstream/opencv/modules/ptcloud/src/depth_to_3d.hpp:1
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp:1
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.hpp:1
+upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp:1
+upstream/opencv/modules/ptcloud/src/normal.cpp:1
+upstream/opencv/modules/ptcloud/src/octree.cpp:1
+upstream/opencv/modules/ptcloud/src/odometry.cpp:1
+upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp:1
+upstream/opencv/modules/ptcloud/src/odometry_functions.cpp:1
+upstream/opencv/modules/ptcloud/src/odometry_functions.hpp:1
+upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp:1
+upstream/opencv/modules/ptcloud/src/opencl/hash_tsdf.cl:1
+upstream/opencv/modules/ptcloud/src/opencl/icp.cl:1
+upstream/opencv/modules/ptcloud/src/opencl/kinfu_frame.cl:1
+upstream/opencv/modules/ptcloud/src/opencl/tsdf.cl:1
+upstream/opencv/modules/ptcloud/src/plane.cpp:1
+upstream/opencv/modules/ptcloud/src/pose_graph.cpp:1
+upstream/opencv/modules/ptcloud/src/rendering.cpp:1
+upstream/opencv/modules/ptcloud/src/sparse_block_matrix.hpp:1
+upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp:1
+upstream/opencv/modules/ptcloud/src/tsdf_functions.hpp:1
+upstream/opencv/modules/ptcloud/src/volume_impl.cpp:1
+upstream/opencv/modules/ptcloud/src/volume_impl.hpp:1
+upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp:1
+upstream/opencv/modules/stereo/include/opencv2/stereo.hpp:1
+upstream/opencv/modules/stereo/src/stereo_geom.cpp:1
+upstream/opencv/modules/video/src/eccms.cpp:1
+upstream/opencv/modules/videoio/src/cap_android_mediandk.cpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_common.cpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_common.hpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_plugin.cpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_reader.cpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_reader.hpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_writer.cpp:1
+upstream/opencv/modules/videoio/src/cap_mfx_writer.hpp:1
+upstream/opencv/modules/videoio/src/cap_msmf.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/src/calibration.cpp:1
+upstream/opencv/modules/calib/src/distortion_model.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/block.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/border_interpolate.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/color.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/common.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/datamov_utils.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/emulation.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/filters.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/funcattrib.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/functional.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/limits.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/reduce.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/saturate_cast.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/scan.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/simd_functions.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/transform.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/type_traits.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/utility.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/vec_distance.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/vec_math.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/vec_traits.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/warp.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/warp_reduce.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda_stream_accessor.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda_types.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opengl.hpp:1
+upstream/opencv/modules/core/src/alloc.cpp:1
+upstream/opencv/modules/core/src/cuda/gpu_mat.cu:1
+upstream/opencv/modules/core/src/cuda_info.cpp:1
+upstream/opencv/modules/core/src/cuda_stream.cpp:1
+upstream/opencv/modules/core/src/gl_core_3_1.cpp:1
+upstream/opencv/modules/core/src/gl_core_3_1.hpp:1
+upstream/opencv/modules/core/src/lapack.cpp:1
+upstream/opencv/modules/core/src/opengl.cpp:1
+upstream/opencv/modules/core/src/precomp.hpp:1
+upstream/opencv/modules/core/src/rand.cpp:1
+upstream/opencv/modules/core/src/tables.cpp:1
+upstream/opencv/modules/features/include/opencv2/features.hpp:1
+upstream/opencv/modules/features/src/blobdetector.cpp:1
+upstream/opencv/modules/flann/include/opencv2/flann/miniflann.hpp:1
+upstream/opencv/modules/flann/include/opencv2/flann.hpp:1
+upstream/opencv/modules/geometry/src/calibration_base.cpp:1
+upstream/opencv/modules/geometry/src/distortion_model.hpp:1
+upstream/opencv/modules/geometry/src/pinhole.cpp:1
+upstream/opencv/modules/imgcodecs/src/exif.cpp:1
+upstream/opencv/modules/imgcodecs/src/exif.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_bmp.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_bmp.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_exr.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_exr.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_hdr.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_hdr.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_png.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_pxm.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_pxm.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_sunras.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_tiff.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_webp.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_webp.hpp:1
+upstream/opencv/modules/imgcodecs/src/rgbe.cpp:1
+upstream/opencv/modules/imgcodecs/src/rgbe.hpp:1
+upstream/opencv/modules/imgproc/include/opencv2/imgproc.hpp:1
+upstream/opencv/modules/imgproc/src/distortion_model.hpp:1
+upstream/opencv/modules/imgproc/src/filter.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/filter.hpp:1
+upstream/opencv/modules/imgproc/src/filter.simd.hpp:1
+upstream/opencv/modules/imgproc/src/morph.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/morph.simd.hpp:1
+upstream/opencv/modules/imgproc/src/spatialgradient.cpp:1
+upstream/opencv/modules/imgproc/src/thresh.cpp:1
+upstream/opencv/modules/imgproc/src/undistort.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/undistort.simd.hpp:1
+upstream/opencv/modules/photo/src/calibrate.cpp:1
+upstream/opencv/modules/photo/src/cuda/nlm.cu:1
+upstream/opencv/modules/photo/src/denoising.cuda.cpp:1
+upstream/opencv/modules/stitching/src/cuda/build_warp_maps.cu:1
+upstream/opencv/modules/video/src/dis_flow.cpp:1
+upstream/opencv/modules/video/src/optflowgf.cpp:1
+upstream/opencv/modules/video/src/optical_flow_io.cpp:1
+upstream/opencv/modules/video/src/variational_refinement.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/src/calibration_handeye.cpp:1
+upstream/opencv/modules/calib/src/multiview_calibration.cpp:1
+upstream/opencv/modules/core/include/opencv2/core/async.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/bindings_utils.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/check.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda/cuda_compat.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cv_cpu_dispatch.h:1
+upstream/opencv/modules/core/include/opencv2/core/cvstd_wrapper.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/detail/async_promise.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/detail/exception_ptr.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/exception.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/fwddecl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_msa.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_wasm.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/msa_macros.h:1
+upstream/opencv/modules/core/include/opencv2/core/llapi/llapi.h:1
+upstream/opencv/modules/core/include/opencv2/core/matx.inl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/ocl_defs.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_info.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/parallel/parallel_backend.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/private/cuda_stubs.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/simd_intrinsics.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/buffer_area.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/configuration.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/fp_control.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/fp_control_utils.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/instrumentation.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/lock.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/logger.defines.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/logger.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/logtag.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/plugin_loader.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/tls.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/trace.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utils/trace.private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/va_intel.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/version.hpp:1
+upstream/opencv/modules/core/src/async.cpp:1
+upstream/opencv/modules/core/src/bindings_utils.cpp:1
+upstream/opencv/modules/core/src/buffer_area.cpp:1
+upstream/opencv/modules/core/src/check.cpp:1
+upstream/opencv/modules/core/src/command_line_parser.cpp:1
+upstream/opencv/modules/core/src/cuda/gpu_mat_nd.cu:1
+upstream/opencv/modules/core/src/cuda_gpu_mat_nd.cpp:1
+upstream/opencv/modules/core/src/logger.cpp:1
+upstream/opencv/modules/core/src/mathfuncs.hpp:1
+upstream/opencv/modules/core/src/mathfuncs_core.dispatch.cpp:1
+upstream/opencv/modules/core/src/mathfuncs_core.simd.hpp:1
+upstream/opencv/modules/core/src/nan_mask.dispatch.cpp:1
+upstream/opencv/modules/core/src/ocl_disabled.impl.hpp:1
+upstream/opencv/modules/core/src/opencl/fft.cl:1
+upstream/opencv/modules/core/src/opencl/gemm.cl:1
+upstream/opencv/modules/core/src/opencl/meanstddev.cl:1
+upstream/opencv/modules/core/src/opencl/minmaxloc.cl:1
+upstream/opencv/modules/core/src/opencl/normalize.cl:1
+upstream/opencv/modules/core/src/opencl/repeat.cl:1
+upstream/opencv/modules/core/src/parallel/factory_parallel.hpp:1
+upstream/opencv/modules/core/src/parallel/parallel.cpp:1
+upstream/opencv/modules/core/src/parallel/parallel.hpp:1
+upstream/opencv/modules/core/src/parallel/parallel_openmp.cpp:1
+upstream/opencv/modules/core/src/parallel/parallel_tbb.cpp:1
+upstream/opencv/modules/core/src/parallel/plugin_parallel_api.hpp:1
+upstream/opencv/modules/core/src/parallel/plugin_parallel_wrapper.impl.hpp:1
+upstream/opencv/modules/core/src/parallel/registry_parallel.hpp:1
+upstream/opencv/modules/core/src/parallel/registry_parallel.impl.hpp:1
+upstream/opencv/modules/core/src/parallel_impl.cpp:1
+upstream/opencv/modules/core/src/parallel_impl.hpp:1
+upstream/opencv/modules/core/src/stat.dispatch.cpp:1
+upstream/opencv/modules/core/src/stat.simd.hpp:1
+upstream/opencv/modules/core/src/trace.cpp:1
+upstream/opencv/modules/core/src/umatrix.hpp:1
+upstream/opencv/modules/core/src/utils/datafile.cpp:1
+upstream/opencv/modules/core/src/utils/filesystem.cpp:1
+upstream/opencv/modules/core/src/utils/logtagconfig.hpp:1
+upstream/opencv/modules/core/src/utils/logtagconfigparser.cpp:1
+upstream/opencv/modules/core/src/utils/logtagconfigparser.hpp:1
+upstream/opencv/modules/core/src/utils/logtagmanager.cpp:1
+upstream/opencv/modules/core/src/utils/logtagmanager.hpp:1
+upstream/opencv/modules/core/src/utils/plugin_loader.impl.hpp:1
+upstream/opencv/modules/core/src/utils/samples.cpp:1
+upstream/opencv/modules/core/src/va_intel.cpp:1
+upstream/opencv/modules/core/src/va_wrapper.impl.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/layer_reg.private.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/version.hpp:1
+upstream/opencv/modules/dnn/src/backend.cpp:1
+upstream/opencv/modules/dnn/src/backend.hpp:1
+upstream/opencv/modules/dnn/src/cuda/activation_eltwise.cu:1
+upstream/opencv/modules/dnn/src/cuda/activations.cu:1
+upstream/opencv/modules/dnn/src/cuda/array.hpp:1
+upstream/opencv/modules/dnn/src/cuda/atomics.hpp:1
+upstream/opencv/modules/dnn/src/cuda/bbox_utils.hpp:1
+upstream/opencv/modules/dnn/src/cuda/bias_activation.cu:1
+upstream/opencv/modules/dnn/src/cuda/bias_activation_eltwise.cu:1
+upstream/opencv/modules/dnn/src/cuda/bias_eltwise_activation.cu:1
+upstream/opencv/modules/dnn/src/cuda/block_stride_range.hpp:1
+upstream/opencv/modules/dnn/src/cuda/concat.cu:1
+upstream/opencv/modules/dnn/src/cuda/crop_and_resize.cu:1
+upstream/opencv/modules/dnn/src/cuda/detection_output.cu:1
+upstream/opencv/modules/dnn/src/cuda/eltwise_activation.cu:1
+upstream/opencv/modules/dnn/src/cuda/eltwise_ops.cu:1
+upstream/opencv/modules/dnn/src/cuda/execution.hpp:1
+upstream/opencv/modules/dnn/src/cuda/fill_copy.cu:1
+upstream/opencv/modules/dnn/src/cuda/fp_conversion.cu:1
+upstream/opencv/modules/dnn/src/cuda/functors.hpp:1
+upstream/opencv/modules/dnn/src/cuda/grid_nms.cu:1
+upstream/opencv/modules/dnn/src/cuda/grid_stride_range.hpp:1
+upstream/opencv/modules/dnn/src/cuda/index_helpers.hpp:1
+upstream/opencv/modules/dnn/src/cuda/kernel_dispatcher.hpp:1
+upstream/opencv/modules/dnn/src/cuda/limits.hpp:1
+upstream/opencv/modules/dnn/src/cuda/math.hpp:1
+upstream/opencv/modules/dnn/src/cuda/max_unpooling.cu:1
+upstream/opencv/modules/dnn/src/cuda/memory.hpp:1
+upstream/opencv/modules/dnn/src/cuda/mvn.cu:1
+upstream/opencv/modules/dnn/src/cuda/normalize.cu:1
+upstream/opencv/modules/dnn/src/cuda/padding.cu:1
+upstream/opencv/modules/dnn/src/cuda/permute.cu:1
+upstream/opencv/modules/dnn/src/cuda/prior_box.cu:1
+upstream/opencv/modules/dnn/src/cuda/region.cu:1
+upstream/opencv/modules/dnn/src/cuda/resize.cu:1
+upstream/opencv/modules/dnn/src/cuda/roi_pooling.cu:1
+upstream/opencv/modules/dnn/src/cuda/scale_shift.cu:1
+upstream/opencv/modules/dnn/src/cuda/shortcut.cu:1
+upstream/opencv/modules/dnn/src/cuda/slice.cu:1
+upstream/opencv/modules/dnn/src/cuda/types.hpp:1
+upstream/opencv/modules/dnn/src/cuda/vector_traits.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cublas.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/activation.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/convolution.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/cudnn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/lrn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/pooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/recurrent.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/softmax.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transform.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transpose_convolution.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/error.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/event.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/memory.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/nvcc_defs.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/pointer.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/span.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/stream.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/csl/workspace.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/is_iterator.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/resizable_static_array.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/init.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activation_eltwise.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activations.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation_eltwise.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_eltwise_activation.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/concat.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/crop_and_resize.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/detection_output.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_activation.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_ops.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fill_copy.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fp_conversion.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/grid_nms.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/max_unpooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/mvn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/normalize.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/padding.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/permute.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/prior_box.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/region.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/resize.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/roi_pooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/scale_shift.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/shortcut.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/kernels/slice.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/activation.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/batch_norm.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/concat.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/const.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/convolution.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/crop_and_resize.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/detection_output.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/eltwise.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/group_norm.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/inner_product.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/instance_norm.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/layer_norm.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/lrn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul_broadcast.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/max_unpooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/mvn.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/normalize_bbox.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/padding.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/permute.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/pooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/prior_box.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/recurrent_cells.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/region.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reorg.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reshape.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/resize.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/roi_pooling.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/scale_shift.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shortcut.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shuffle_channel.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/slice.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/softmax.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/split.hpp:1
+upstream/opencv/modules/dnn/src/cuda4dnn/primitives/transpose_convolution.hpp:1
+upstream/opencv/modules/dnn/src/debug_utils.cpp:1
+upstream/opencv/modules/dnn/src/dnn.cpp:1
+upstream/opencv/modules/dnn/src/dnn_common.hpp:1
+upstream/opencv/modules/dnn/src/dnn_params.cpp:1
+upstream/opencv/modules/dnn/src/dnn_read.cpp:1
+upstream/opencv/modules/dnn/src/dnn_utils.cpp:1
+upstream/opencv/modules/dnn/src/factory.hpp:1
+upstream/opencv/modules/dnn/src/graph_block_layout.cpp:1
+upstream/opencv/modules/dnn/src/graph_buffer_allocator.cpp:1
+upstream/opencv/modules/dnn/src/graph_const_args.cpp:1
+upstream/opencv/modules/dnn/src/graph_const_fold.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_basic.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_matmul_to_gemm.cpp:1
+upstream/opencv/modules/dnn/src/graph_simplifier.cpp:1
+upstream/opencv/modules/dnn/src/graph_simplifier.hpp:1
+upstream/opencv/modules/dnn/src/int8layers/batch_norm_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/convolution_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/elementwise_layers.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/eltwise_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/fully_connected_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/layers_common.hpp:1
+upstream/opencv/modules/dnn/src/int8layers/layers_common.simd.hpp:1
+upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.hpp:1
+upstream/opencv/modules/dnn/src/int8layers/matmul_int8_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/pooling_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/quantization_utils.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/scale_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/softmax_layer.cpp:1
+upstream/opencv/modules/dnn/src/kv_cache_manager.cpp:1
+upstream/opencv/modules/dnn/src/kv_cache_manager.hpp:1
+upstream/opencv/modules/dnn/src/layer.cpp:1
+upstream/opencv/modules/dnn/src/layer_factory.cpp:1
+upstream/opencv/modules/dnn/src/layer_internals.hpp:1
+upstream/opencv/modules/dnn/src/layers/accum_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/arg_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/attention_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/attention_onnxai_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/avgpool_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/batch_norm_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/bitshift_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/cast2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/cast_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/clip_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/concat2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/const_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/constantofshape_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/conv2_common.cpp:1
+upstream/opencv/modules/dnn/src/layers/conv2_common.hpp:1
+upstream/opencv/modules/dnn/src/layers/conv2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/correlation_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.dispatch.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_threading.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.hpp:1
+upstream/opencv/modules/dnn/src/layers/crop_and_resize_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/cumsum_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/depth_space_ops_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/einsum_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/expand2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/expand_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/flow_warp_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/gather2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/gather_elements_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/gather_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/gemm_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/group_norm_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/if_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/instance_norm_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/layer_norm.cpp:1
+upstream/opencv/modules/dnn/src/layers/loop_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/matmul_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/max_unpooling_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/maxpool_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/nary_eltwise_layers.cpp:1
+upstream/opencv/modules/dnn/src/layers/not_implemented_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/not_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/pad2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/padding_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/proposal_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/quantlizelinear_layer.cpp:2
+upstream/opencv/modules/dnn/src/layers/range_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/recurrent2_layers.cpp:1
+upstream/opencv/modules/dnn/src/layers/reduce_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/reshape2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/resize2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/resize_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/rms_norm.cpp:1
+upstream/opencv/modules/dnn/src/layers/rotary_embedding_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/scale_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/scatterND_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/scatter_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/shape_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/shuffle_channel_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/slice2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/split2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/squeeze_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/tile2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/tile_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/topk2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/topk_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/transform_layout_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/transpose_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/trilu_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/unique_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/unsqueeze_layer.cpp:1
+upstream/opencv/modules/dnn/src/legacy_backend.cpp:1
+upstream/opencv/modules/dnn/src/legacy_backend.hpp:1
+upstream/opencv/modules/dnn/src/math_utils.hpp:1
+upstream/opencv/modules/dnn/src/model.cpp:1
+upstream/opencv/modules/dnn/src/net.cpp:1
+upstream/opencv/modules/dnn/src/net_cann.cpp:1
+upstream/opencv/modules/dnn/src/net_impl.cpp:1
+upstream/opencv/modules/dnn/src/net_impl.hpp:1
+upstream/opencv/modules/dnn/src/net_impl2.cpp:1
+upstream/opencv/modules/dnn/src/net_impl_backend.cpp:1
+upstream/opencv/modules/dnn/src/net_impl_fuse.cpp:1
+upstream/opencv/modules/dnn/src/net_openvino.cpp:1
+upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.cpp:1
+upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.hpp:1
+upstream/opencv/modules/dnn/src/onnx/onnx_importer.cpp:1
+upstream/opencv/modules/dnn/src/onnx/onnx_importer2.cpp:1
+upstream/opencv/modules/dnn/src/op_cann.cpp:1
+upstream/opencv/modules/dnn/src/op_cann.hpp:1
+upstream/opencv/modules/dnn/src/op_cuda.cpp:1
+upstream/opencv/modules/dnn/src/op_cuda.hpp:1
+upstream/opencv/modules/dnn/src/op_webnn.cpp:1
+upstream/opencv/modules/dnn/src/op_webnn.hpp:1
+upstream/opencv/modules/dnn/src/opencl/slice.cl:1
+upstream/opencv/modules/dnn/src/plugin_api.hpp:1
+upstream/opencv/modules/dnn/src/plugin_wrapper.impl.hpp:1
+upstream/opencv/modules/dnn/src/registry.cpp:1
+upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp:1
+upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp:1
+upstream/opencv/modules/dnn/src/tensorflow/tf_importer.cpp:1
+upstream/opencv/modules/dnn/src/tensorflow/tf_io.cpp:1
+upstream/opencv/modules/dnn/src/tensorflow/tf_io.hpp:1
+upstream/opencv/modules/dnn/src/tflite/tflite_importer.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/core_bpe.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/core_bpe.hpp:1
+upstream/opencv/modules/dnn/src/tokenizer/tokenizer.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/unicode-data.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/unicode-data.hpp:1
+upstream/opencv/modules/dnn/src/tokenizer/unicode.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/unicode.hpp:1
+upstream/opencv/modules/dnn/src/tokenizer/utils.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/command.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/context.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/fence.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/op_matmul.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/op_naryeltwise.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/pipeline.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/tensor.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/conv_1x1_fast_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_3x3_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/conv_implicit_gemm_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/gemm_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward_spv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/command.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/context.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/fence.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/internal.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/op_conv.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/op_matmul.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/op_naryEltwise.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/pipeline.cpp:1
+upstream/opencv/modules/features/src/aliked_context.hpp:1
+upstream/opencv/modules/features/src/feature2d_aliked.cpp:1
+upstream/opencv/modules/features/src/matchers_lightglue.cpp:1
+upstream/opencv/modules/geometry/src/fisheye.cpp:1
+upstream/opencv/modules/geometry/src/usac/degeneracy.cpp:1
+upstream/opencv/modules/geometry/src/usac/dls_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/essential_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/estimator.cpp:1
+upstream/opencv/modules/geometry/src/usac/fundamental_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/gamma_values.cpp:1
+upstream/opencv/modules/geometry/src/usac/homography_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/local_optimization.cpp:1
+upstream/opencv/modules/geometry/src/usac/plane_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/pnp_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/quality.cpp:1
+upstream/opencv/modules/geometry/src/usac/ransac_solvers.cpp:1
+upstream/opencv/modules/geometry/src/usac/sampler.cpp:1
+upstream/opencv/modules/geometry/src/usac/sphere_solver.cpp:1
+upstream/opencv/modules/geometry/src/usac/termination.cpp:1
+upstream/opencv/modules/geometry/src/usac/utils.cpp:1
+upstream/opencv/modules/geometry/src/usac.hpp:1
+upstream/opencv/modules/highgui/src/backend.cpp:1
+upstream/opencv/modules/highgui/src/backend.hpp:1
+upstream/opencv/modules/highgui/src/factory.hpp:1
+upstream/opencv/modules/highgui/src/plugin_api.hpp:1
+upstream/opencv/modules/highgui/src/plugin_wrapper.impl.hpp:1
+upstream/opencv/modules/highgui/src/registry.hpp:1
+upstream/opencv/modules/highgui/src/registry.impl.hpp:1
+upstream/opencv/modules/highgui/src/roiSelector.cpp:1
+upstream/opencv/modules/highgui/src/window_framebuffer.cpp:1
+upstream/opencv/modules/highgui/src/window_framebuffer.hpp:1
+upstream/opencv/modules/highgui/src/window_wayland.cpp:1
+upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/macosx.h:1
+upstream/opencv/modules/imgcodecs/src/apple_conversions.h:1
+upstream/opencv/modules/imgcodecs/src/apple_conversions.mm:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_pfm.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_pfm.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_spng.hpp:1
+upstream/opencv/modules/imgcodecs/src/macosx_conversions.mm:1
+upstream/opencv/modules/imgproc/include/opencv2/imgproc/bindings.hpp:1
+upstream/opencv/modules/imgproc/src/accum.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/accum.simd.hpp:1
+upstream/opencv/modules/imgproc/src/opencl/accumulate.cl:1
+upstream/opencv/modules/imgproc/src/opencl/boxFilter3x3.cl:1
+upstream/opencv/modules/imgproc/src/opencl/covardata.cl:1
+upstream/opencv/modules/imgproc/src/opencl/filterSmall.cl:1
+upstream/opencv/modules/imgproc/src/opencl/gaussianBlur3x3.cl:1
+upstream/opencv/modules/imgproc/src/opencl/gaussianBlur5x5.cl:1
+upstream/opencv/modules/imgproc/src/opencl/hough_lines.cl:1
+upstream/opencv/modules/imgproc/src/opencl/laplacian3.cl:1
+upstream/opencv/modules/imgproc/src/opencl/laplacian5.cl:1
+upstream/opencv/modules/imgproc/src/opencl/morph3x3.cl:1
+upstream/opencv/modules/imgproc/src/opencl/pyramid_up.cl:1
+upstream/opencv/modules/imgproc/src/opencl/sepFilter3x3.cl:1
+upstream/opencv/modules/imgproc/src/opencl/warp_transform.cl:1
+upstream/opencv/modules/imgproc/src/stackblur.cpp:1
+upstream/opencv/modules/imgproc/src/stb_truetype.hpp:1
+upstream/opencv/modules/imgproc/src/warp_common.hpp:1
+upstream/opencv/modules/imgproc/src/warp_common.scalar.hpp:1
+upstream/opencv/modules/imgproc/src/warp_common.vector.hpp:1
+upstream/opencv/modules/imgproc/src/warp_kernels.simd.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/face.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/predefined_dictionaries_apriltag.hpp:1
+upstream/opencv/modules/objdetect/src/chessboard.cpp:1
+upstream/opencv/modules/objdetect/src/chessboard.hpp:1
+upstream/opencv/modules/objdetect/src/face_detect.cpp:1
+upstream/opencv/modules/objdetect/src/face_recognize.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/bound_min.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/charts.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/charts.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/checker_model.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/common.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/common.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/debug.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/debug.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/dictionary.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/precomp.hpp:1
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp:1
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.hpp:1
+upstream/opencv/modules/photo/include/opencv2/photo/legacy/constants_c.h:1
+upstream/opencv/modules/photo/include/opencv2/photo/segmentation.hpp:1
+upstream/opencv/modules/photo/src/fast_nlmeans_denoising_opencl.hpp:1
+upstream/opencv/modules/photo/src/opencl/nlmeans.cl:1
+upstream/opencv/modules/ptcloud/src/io_base.cpp:1
+upstream/opencv/modules/ptcloud/src/io_base.hpp:1
+upstream/opencv/modules/ptcloud/src/io_obj.cpp:1
+upstream/opencv/modules/ptcloud/src/io_obj.hpp:1
+upstream/opencv/modules/ptcloud/src/io_ply.cpp:1
+upstream/opencv/modules/ptcloud/src/io_ply.hpp:1
+upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp:1
+upstream/opencv/modules/ptcloud/src/utils.cpp:1
+upstream/opencv/modules/ptcloud/src/utils.hpp:1
+upstream/opencv/modules/stitching/src/util_log.hpp:1
+upstream/opencv/modules/video/include/opencv2/video/detail/tracking.detail.hpp:1
+upstream/opencv/modules/video/include/opencv2/video/legacy/constants_c.h:1
+upstream/opencv/modules/video/src/hal_replacement.hpp:1
+upstream/opencv/modules/video/src/opencl/dis_flow.cl:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature_haar.impl.hpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.hpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.hpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracking_feature.hpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp:1
+upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.hpp:1
+upstream/opencv/modules/video/src/tracking/tracker.cpp:1
+upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp:1
+upstream/opencv/modules/video/src/tracking/tracker_mil.cpp:1
+upstream/opencv/modules/video/src/tracking/tracker_nano.cpp:1
+upstream/opencv/modules/video/src/tracking/tracker_vit.cpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio/container_avi.private.hpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio/registry.hpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio/utils.private.hpp:1
+upstream/opencv/modules/videoio/src/backend.hpp:1
+upstream/opencv/modules/videoio/src/backend_plugin.cpp:1
+upstream/opencv/modules/videoio/src/backend_plugin_legacy.impl.hpp:1
+upstream/opencv/modules/videoio/src/backend_static.cpp:1
+upstream/opencv/modules/videoio/src/cap_ffmpeg_legacy_api.hpp:1
+upstream/opencv/modules/videoio/src/cap_interface.hpp:1
+upstream/opencv/modules/videoio/src/cap_librealsense.cpp:1
+upstream/opencv/modules/videoio/src/cap_librealsense.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor_capture.cpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor_capture.hpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.cpp:1
+upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.hpp:1
+upstream/opencv/modules/videoio/src/cap_ueye.cpp:1
+upstream/opencv/modules/videoio/src/container_avi.cpp:1
+upstream/opencv/modules/videoio/src/plugin_api.hpp:1
+upstream/opencv/modules/videoio/src/plugin_capture_api.hpp:1
+upstream/opencv/modules/videoio/src/plugin_writer_api.hpp:1
+upstream/opencv/modules/videoio/src/videoio_registry.cpp:1
+upstream/opencv/modules/videoio/src/videoio_registry.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/src/fisheye.cpp:1
+upstream/opencv/modules/core/src/algorithm.cpp:1
+upstream/opencv/modules/core/src/parallel.cpp:1
+upstream/opencv/modules/python/src2/pycompat.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/src/main.cpp:1
+upstream/opencv/modules/core/src/system.cpp:1
+upstream/opencv/modules/features/src/main.cpp:1
+upstream/opencv/modules/geometry/src/main.cpp:1
+upstream/opencv/modules/imgproc/src/main.cpp:1
+upstream/opencv/modules/objdetect/src/main.cpp:1
+upstream/opencv/modules/stereo/src/main.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/calib/src/precomp.hpp:1
+upstream/opencv/modules/features/src/feature2d.cpp:1
+upstream/opencv/modules/features/src/precomp.hpp:1
+upstream/opencv/modules/geometry/src/precomp.hpp:1
+upstream/opencv/modules/highgui/include/opencv2/highgui.hpp:1
+upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/ios.h:2
+upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs.hpp:1
+upstream/opencv/modules/imgcodecs/src/ios_conversions.mm:1
+upstream/opencv/modules/imgproc/src/precomp.hpp:1
+upstream/opencv/modules/objdetect/src/precomp.hpp:1
+upstream/opencv/modules/photo/src/precomp.hpp:1
+upstream/opencv/modules/stereo/src/precomp.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/autocalib.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/blenders.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/camera.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/exposure_compensate.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/matchers.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/motion_estimators.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/seam_finders.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/timelapsers.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util_inl.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching/warpers.hpp:1
+upstream/opencv/modules/stitching/include/opencv2/stitching.hpp:1
+upstream/opencv/modules/stitching/src/autocalib.cpp:1
+upstream/opencv/modules/stitching/src/blenders.cpp:1
+upstream/opencv/modules/stitching/src/camera.cpp:1
+upstream/opencv/modules/stitching/src/exposure_compensate.cpp:1
+upstream/opencv/modules/stitching/src/matchers.cpp:1
+upstream/opencv/modules/stitching/src/motion_estimators.cpp:1
+upstream/opencv/modules/stitching/src/precomp.hpp:1
+upstream/opencv/modules/stitching/src/seam_finders.cpp:1
+upstream/opencv/modules/stitching/src/stitcher.cpp:1
+upstream/opencv/modules/stitching/src/timelapsers.cpp:1
+upstream/opencv/modules/stitching/src/util.cpp:1
+upstream/opencv/modules/stitching/src/warpers.cpp:1
+upstream/opencv/modules/stitching/src/warpers_cuda.cpp:1
+upstream/opencv/modules/video/src/precomp.hpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio.hpp:1
+upstream/opencv/modules/videoio/src/cap_ffmpeg_impl.hpp:1
+upstream/opencv/modules/videoio/src/ffmpeg_codecs.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/affine.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/core.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cuda.inl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cvstd.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/cvstd.inl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/eigen.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/mat.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/matx.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/persistence.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/private.cuda.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/private.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/traits.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/types.hpp:1
+upstream/opencv/modules/core/src/cuda_gpu_mat.cpp:1
+upstream/opencv/modules/core/src/cuda_host_mem.cpp:1
+upstream/opencv/modules/core/src/out.cpp:1
+upstream/opencv/modules/core/src/pca.cpp:1
+upstream/opencv/modules/core/src/stl.cpp:1
+upstream/opencv/modules/core/src/types.cpp:1
+upstream/opencv/modules/features/include/opencv2/features/features.hpp:1
+upstream/opencv/modules/flann/include/opencv2/flann/flann.hpp:1
+upstream/opencv/modules/geometry/src/ptsetreg.cpp:1
+upstream/opencv/modules/highgui/include/opencv2/highgui/highgui.hpp:1
+upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/objdetect.hpp:1
+upstream/opencv/modules/objdetect/include/opencv2/objdetect.hpp:1
+upstream/opencv/modules/photo/include/opencv2/photo/photo.hpp:1
+upstream/opencv/modules/video/include/opencv2/video/background_segm.hpp:1
+upstream/opencv/modules/video/include/opencv2/video/tracking.hpp:1
+upstream/opencv/modules/video/include/opencv2/video/video.hpp:1
+upstream/opencv/modules/video/include/opencv2/video.hpp:1
+upstream/opencv/modules/videoio/include/opencv2/videoio/videoio.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/base.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/saturate.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/bufferpool.hpp:1
+upstream/opencv/modules/core/src/bufferpool.impl.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/cuda/simd_functions.hpp:43
+
+/*
+ * Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ *   Neither the name of NVIDIA Corporation nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/cvdef.h:1
+upstream/opencv/modules/core/include/opencv2/core/fast_math.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/hal.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_cpp.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_neon.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/mat.inl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/utility.hpp:1
+upstream/opencv/modules/core/src/hal_internal.cpp:1
+upstream/opencv/modules/core/src/hal_internal.hpp:1
+upstream/opencv/modules/core/src/hal_replacement.hpp:1
+upstream/opencv/modules/geometry/src/hal_replacement.hpp:1
+upstream/opencv/modules/imgproc/src/hal_replacement.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/directx.hpp:1
+upstream/opencv/modules/core/src/directx.cpp:1
+upstream/opencv/modules/core/src/directx.inc.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the copyright holders or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/dualquaternion.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/dualquaternion.inl.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: Liangqian Kong <kongliangqian@huawei.com>
+//         Longbu Wang <wanglongbu@huawei.com>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_math.hpp:12
+
+/* Copyright (C) 2010,2011  RJVB - extensions */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_math.hpp:13
+
+/* Copyright (C) 2011  Julien Pommier
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  (this is the zlib license)
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp:5
+
+// Copyright (C) 2015, PingTouGe Semiconductor Co., Ltd., all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp:5
+
+// The original implementation is contributed by HAN Liutong.
+// Copyright (C) 2022, Institute of Software, Chinese Academy of Sciences.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/neon_utils.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/ocl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/ocl_genbase.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/optim.hpp:1
+upstream/opencv/modules/core/src/conjugate_gradient.cpp:1
+upstream/opencv/modules/core/src/downhill_simplex.cpp:1
+upstream/opencv/modules/core/src/lpsolver.cpp:1
+upstream/opencv/modules/core/src/ocl.cpp:1
+upstream/opencv/modules/core/src/opencl/flip.cl:1
+upstream/opencv/modules/photo/src/denoise_tvl1.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/opencl/ocl_defs.hpp:5
+upstream/opencv/modules/imgproc/src/opencl/accumulate.cl:5
+upstream/opencv/modules/imgproc/src/opencl/covardata.cl:5
+upstream/opencv/modules/photo/src/fast_nlmeans_denoising_opencl.hpp:5
+upstream/opencv/modules/photo/src/opencl/nlmeans.cl:5
+
+// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_svm.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp:1
+upstream/opencv/modules/geometry/src/opencl/moments.cl:1
+
+/* See LICENSE file in the root OpenCV directory */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp:1
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clblas.cpp:1
+upstream/opencv/modules/core/src/opencl/runtime/opencl_clfft.cpp:1
+upstream/opencv/modules/core/src/opencl/runtime/opencl_core.cpp:1
+upstream/opencv/modules/core/src/opencl/runtime/runtime_common.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp:10
+
+//
+//  Part of the file is an extract from the cl_ext.h file from AMD APP SDK package.
+//  Below is the original copyright.
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp:14
+
+/*******************************************************************************
+ * Copyright (c) 2008-2013 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/operations.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/quaternion.hpp:1
+upstream/opencv/modules/core/include/opencv2/core/quaternion.inl.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: Liangqian Kong <chargerKong@126.com>
+//         Longbu Wang <riskiest@gmail.com>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/softfloat.hpp:5
+
+// This file is based on files from package issued with the following license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/softfloat.hpp:7
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3c, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core/va_intel.hpp:5
+upstream/opencv/modules/core/src/va_intel.cpp:5
+
+// Copyright (C) 2015, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/include/opencv2/core.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/arithm.cpp:1
+upstream/opencv/modules/core/src/mathfuncs.cpp:1
+upstream/opencv/modules/core/src/matmul.dispatch.cpp:1
+upstream/opencv/modules/core/src/matmul.simd.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/copy.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Copyright (C) 2025, SpaceMIT Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/dxt.cpp:1
+upstream/opencv/modules/features/src/draw.cpp:1
+upstream/opencv/modules/features/src/featureselect.cpp:1
+upstream/opencv/modules/features/src/gftt.cpp:1
+upstream/opencv/modules/features/src/matchers.cpp:1
+upstream/opencv/modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp:1
+upstream/opencv/modules/geometry/src/approx.cpp:1
+upstream/opencv/modules/geometry/src/convhull.cpp:1
+upstream/opencv/modules/geometry/src/geometry.cpp:1
+upstream/opencv/modules/geometry/src/linefit.cpp:1
+upstream/opencv/modules/geometry/src/matchcontours.cpp:1
+upstream/opencv/modules/geometry/src/moments.cpp:1
+upstream/opencv/modules/geometry/src/shapedescr.cpp:1
+upstream/opencv/modules/geometry/src/subdivision2d.cpp:1
+upstream/opencv/modules/highgui/src/precomp.hpp:1
+upstream/opencv/modules/highgui/src/window.cpp:1
+upstream/opencv/modules/highgui/src/window_gtk.cpp:1
+upstream/opencv/modules/highgui/src/window_w32.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_base.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gdal.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gdal.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmts.hpp:1
+upstream/opencv/modules/imgcodecs/src/loadsave.cpp:1
+upstream/opencv/modules/imgcodecs/src/precomp.hpp:1
+upstream/opencv/modules/imgcodecs/src/utils.cpp:1
+upstream/opencv/modules/imgcodecs/src/utils.hpp:1
+upstream/opencv/modules/imgproc/src/drawing.cpp:1
+upstream/opencv/modules/imgproc/src/generalized_hough.cpp:1
+upstream/opencv/modules/imgproc/src/grabcut.cpp:1
+upstream/opencv/modules/imgproc/src/templmatch.cpp:1
+upstream/opencv/modules/imgproc/src/utils.cpp:1
+upstream/opencv/modules/video/src/ecc.cpp:1
+upstream/opencv/modules/video/src/kalman.cpp:1
+upstream/opencv/modules/videoio/src/cap.cpp:1
+upstream/opencv/modules/videoio/src/cap_dc1394_v2.cpp:1
+upstream/opencv/modules/videoio/src/cap_dshow.cpp:1
+upstream/opencv/modules/videoio/src/cap_ffmpeg.cpp:1
+upstream/opencv/modules/videoio/src/cap_openni2.cpp:1
+upstream/opencv/modules/videoio/src/cap_v4l.cpp:168
+upstream/opencv/modules/videoio/src/precomp.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/glob.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and / or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/intel_gpu_gemm.inl.hpp:1
+
+/*
+* Copyright 2015-2017 Philippe Tillet
+* Copyright (c) 2017, Intel Corporation
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files
+* (the "Software"), to deal in the Software without restriction,
+* including without limitation the rights to use, copy, modify, merge,
+* publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so,
+* subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/kmeans.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2018, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/lda.cpp:1
+upstream/opencv/modules/imgproc/src/colormap.cpp:1
+
+/*
+ * Copyright (c) 2011. Philipp Wagner <bytefish[at]gmx[dot]de>.
+ * Released to public domain under terms of the BSD Simplified license.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of the organization nor the names of its contributors
+ *     may be used to endorse or promote products derived from this software
+ *     without specific prior written permission.
+ *
+ *   See <http://www.opensource.org/licenses/bsd-license>
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/lda.cpp:902
+
+// Initializes & computes the Eigenvalue Decomposition for a general matrix
+    // given in src. This function is a port of the EigenvalueSolver in JAMA,
+    // which has been released to public domain by The MathWorks and the
+    // National Institute of Standards and Technology (NIST).
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/lda.cpp:914
+
+// This function computes the Eigenvalue Decomposition for a general matrix
+    // given in src. This function is a port of the EigenvalueSolver in JAMA,
+    // which has been released to public domain by The MathWorks and the
+    // National Institute of Standards and Technology (NIST).
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/mathfuncs.cpp:1363
+
+/*
+  Finds real roots of cubic, quadratic or linear equation.
+  The original code has been taken from Ken Turkowski web page
+  (http://www.worldserver.com/turk/opensource/) and adopted for OpenCV.
+  Here is the copyright notice.
+
+  -----------------------------------------------------------------------
+  Copyright (C) 1978-1999 Ken Turkowski. <turk@computer.org>
+
+    All rights reserved.
+
+    Warranty Information
+      Even though I have reviewed this software, I make no warranty
+      or representation, either express or implied, with respect to this
+      software, its quality, accuracy, merchantability, or fitness for a
+      particular purpose.  As a result, this software is provided "as is,"
+      and you, its user, are assuming the entire risk as to its quality
+      and accuracy.
+
+    This code may be used and freely distributed as long as it includes
+    this copyright notice and the above warranty information.
+  -----------------------------------------------------------------------
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/matrix_transform.cpp:1
+upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp:1
+upstream/opencv/modules/video/src/lkpyramid.simd.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+// Copyright (C) 2026, Advanced Micro Devices, Inc., all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/norm.simd.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+//
+// Copyright (C) 2025, SpaceMIT Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/arithm.cl:1
+upstream/opencv/modules/core/src/opencl/cvtclr_dx.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the copyright holders or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/convert.cl:1
+upstream/opencv/modules/core/src/opencl/copyset.cl:1
+upstream/opencv/modules/core/src/opencl/inrange.cl:1
+upstream/opencv/modules/core/src/opencl/mixchannels.cl:1
+upstream/opencv/modules/core/src/opencl/reduce2.cl:1
+upstream/opencv/modules/core/src/opencl/split_merge.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the copyright holders or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/copymakeborder.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//    Zero Lin zero.lin@amd.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/fft.cl:5
+upstream/opencv/modules/core/src/opencl/gemm.cl:5
+upstream/opencv/modules/core/src/opencl/meanstddev.cl:5
+upstream/opencv/modules/core/src/opencl/minmaxloc.cl:5
+upstream/opencv/modules/core/src/opencl/normalize.cl:5
+upstream/opencv/modules/core/src/opencl/repeat.cl:5
+upstream/opencv/modules/imgproc/src/opencl/filterSmall.cl:5
+upstream/opencv/modules/imgproc/src/opencl/hough_lines.cl:5
+upstream/opencv/modules/imgproc/src/opencl/laplacian5.cl:5
+
+// Copyright (C) 2014, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/intel_gemm.cl:1
+
+// Copyright (c) 2017, Intel Corporation
+//
+// The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/lut.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//    Rock Li, Rock.li@amd.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/mulspectrums.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the uintel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business uinterruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/reduce.cl:1
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Shengen Yan,yanshengen@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/set_identity.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Jin Ma jin@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/opencl/transpose.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/rand.cpp:854
+
+/*
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+
+   Before using, initialize the state by using init_genrand(seed)
+   or init_by_array(init_key, key_length).
+
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
+        permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/softfloat.cpp:5
+
+// This file is based on files from packages softfloat and fdlibm
+// issued with the following licenses:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/softfloat.cpp:8
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3c, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/softfloat.cpp:43
+
+// FDLIBM licenses:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/softfloat.cpp:45
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/softfloat.cpp:56
+
+/*
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/transpose.simd.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+// Copyright (C) 2026, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/core/src/umatrix.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/include/opencv2/dnn/all_layers.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/dict.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.inl.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/layer.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn/shape_utils.hpp:1
+upstream/opencv/modules/dnn/include/opencv2/dnn.hpp:1
+upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp:1
+upstream/opencv/modules/dnn/src/caffe/caffe_io.hpp:1
+upstream/opencv/modules/dnn/src/caffe/glog_emulator.hpp:1
+upstream/opencv/modules/dnn/src/init.cpp:1
+upstream/opencv/modules/dnn/src/opencl/im2col.cl:1
+upstream/opencv/modules/dnn/src/precomp.hpp:1
+upstream/opencv/modules/photo/src/align.cpp:1
+upstream/opencv/modules/photo/src/contrast_preserve.cpp:1
+upstream/opencv/modules/photo/src/contrast_preserve.hpp:1
+upstream/opencv/modules/photo/src/hdr_common.cpp:1
+upstream/opencv/modules/photo/src/hdr_common.hpp:1
+upstream/opencv/modules/photo/src/merge.cpp:1
+upstream/opencv/modules/photo/src/npr.cpp:1
+upstream/opencv/modules/photo/src/npr.hpp:1
+upstream/opencv/modules/photo/src/seamless_cloning.cpp:1
+upstream/opencv/modules/photo/src/seamless_cloning.hpp:1
+upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp:1
+upstream/opencv/modules/photo/src/tonemap.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/include/opencv2/dnn/layer.details.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/include/opencv2/dnn/utils/inference_engine.hpp:1
+upstream/opencv/modules/dnn/src/ie_ngraph.cpp:1
+upstream/opencv/modules/dnn/src/ie_ngraph.hpp:1
+upstream/opencv/modules/dnn/src/op_inf_engine.cpp:1
+upstream/opencv/modules/dnn/src/op_inf_engine.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2018-2019, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp:42
+upstream/opencv/modules/dnn/src/caffe/caffe_io.hpp:42
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//COPYRIGHT
+//
+//All contributions by the University of California:
+//Copyright (c) 2014, The Regents of the University of California (Regents)
+//All rights reserved.
+//
+//All other contributions:
+//Copyright (c) 2014, the respective contributors
+//All rights reserved.
+//
+//Caffe uses a shared copyright model: each contributor holds copyright over
+//their contributions to Caffe. The project versioning records all such
+//contribution and copyright details. If a contributor wants to further mark
+//their specific copyright on a particular contribution, they should indicate
+//their copyright solely in the commit message of the change when it is
+//committed.
+//
+//LICENSE
+//
+//Redistribution and use in source and binary forms, with or without
+//modification, are permitted provided that the following conditions are met:
+//
+//1. Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//2. Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+//DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+//ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//CONTRIBUTION AGREEMENT
+//
+//By contributing to the BVLC/caffe repository through pull-request, comment,
+//or otherwise, the contributor releases their content to the
+//license and copyright terms herein.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/graph_fusion_attention.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_qdq.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_reshape_transpose.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_scale_softmax.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_shared_gemm.cpp:1
+upstream/opencv/modules/dnn/src/graph_fusion_transpose_matmul.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/conv2_int8_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/int8layers/conv2_int8_layer.cpp:1
+upstream/opencv/modules/dnn/src/int8layers/eltwise2_int8_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/batch_norm2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/convtranspose_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_deconv.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/gridsample_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.cpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/nary_eltwise_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/reduce2_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/transpose_kernels.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/dequantizelinear_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/eyelike_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/sdpa_layer.cpp:1
+upstream/opencv/modules/features/src/disk.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2026, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/graph_simplifier.cpp:5
+upstream/opencv/modules/dnn/src/graph_simplifier.hpp:5
+upstream/opencv/modules/dnn/src/kv_cache_manager.hpp:5
+upstream/opencv/modules/dnn/src/layers/accum_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/correlation_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/flow_warp_layer.cpp:5
+upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.cpp:5
+upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.hpp:5
+upstream/opencv/modules/dnn/src/opencl/slice.cl:5
+
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/int8layers/pool2_int8_layer.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2026, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/affinegrid_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/centercroppad_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/det_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/dft_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/gridsample_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/is_inf_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/is_nan_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/layer_norm2.cpp:1
+upstream/opencv/modules/dnn/src/layers/nll_loss_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/nonmaxsuppression_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/onehot_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/randomnormallike_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/reduce2_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/roialign_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/size_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/softmax_cross_entropy_loss_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/windows_layer.cpp:1
+upstream/opencv/modules/dnn/src/tokenizer/core_gemma.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2025, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/batch_norm_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/max_unpooling_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/scale_layer.cpp:5
+upstream/opencv/modules/dnn/src/tensorflow/tf_importer.cpp:5
+upstream/opencv/modules/dnn/src/tensorflow/tf_io.cpp:5
+upstream/opencv/modules/dnn/src/tensorflow/tf_io.hpp:5
+
+// Copyright (C) 2016, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/bitshift_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/clip_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/resize2_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/unique_layer.cpp:5
+
+// Copyright (C) 2025, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/blank_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/concat_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/convolution_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/deconvolution_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/elementwise_layers.cpp:1
+upstream/opencv/modules/dnn/src/layers/eltwise_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/flatten_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/fully_connected_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/layers_common.cpp:1
+upstream/opencv/modules/dnn/src/layers/layers_common.hpp:1
+upstream/opencv/modules/dnn/src/layers/layers_common.simd.hpp:1
+upstream/opencv/modules/dnn/src/layers/lrn_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/mvn_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/normalize_bbox_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/permute_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/pooling_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/prior_box_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/recurrent_layers.cpp:1
+upstream/opencv/modules/dnn/src/layers/reshape_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/slice_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/softmax_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/split_layer.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/const_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/crop_and_resize_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/shuffle_channel_layer.cpp:5
+upstream/opencv/modules/dnn/src/onnx/onnx_importer.cpp:5
+upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp:5
+upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp:5
+
+// Copyright (C) 2018, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp:5
+
+// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/lib/NN/OpConv_Winograd.fx).
+// Here is the original license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.cpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.cpp:7
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.hpp:7
+
+/*
+    This file is a part of ficus language project.
+    See ficus/LICENSE for the licensing terms
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.cpp:5
+
+// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/lib/NN/OpConv.fx).
+// Here is the original license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp:5
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp:5
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp:5
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp:5
+
+// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/runtime/ficus/impl/gemm.impl.h).
+// Here is the original license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.cpp:5
+upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.hpp:5
+
+// This file is modified from the ficus (https://github.com/vpisarev/ficus/blob/master/lib/NN/OpNN.fx).
+// Here is the original license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/detection_output_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/region_layer.cpp:1
+upstream/opencv/modules/dnn/src/layers/reorg_layer.cpp:1
+
+/*M ///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/nonzero_layer.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the
+// top-level directory of this distribution and at http://opencv.org/license.html.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/layers/padding_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/proposal_layer.cpp:5
+upstream/opencv/modules/dnn/src/layers/resize_layer.cpp:5
+
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/math_utils.hpp:9
+
+// Copyright 2009-2011  Ondrej Glembek;  Microsoft Corporation;  Yanmin Qian;
+//                      Jan Silovsky;  Saarland University
+//
+// See ../../COPYING for clarification regarding multiple authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABLITY OR NON-INFRINGEMENT.
+// See the Apache 2 License for the specific language governing permissions and
+// limitations under the License.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/nms.cpp:1
+upstream/opencv/modules/dnn/src/nms.inl.hpp:1
+upstream/opencv/modules/imgproc/src/fixedpoint.inl.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/ocl4dnn/include/common.hpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_pool.cpp:1
+upstream/opencv/modules/dnn/src/opencl/concat.cl:1
+upstream/opencv/modules/dnn/src/opencl/detection_output.cl:1
+upstream/opencv/modules/dnn/src/opencl/prior_box.cl:1
+upstream/opencv/modules/dnn/src/opencl/region.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (c) 2016-2017 Fabian David Tschopp, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/ocl4dnn/include/math_functions.hpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/include/ocl4dnn.hpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/common.cpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/math_functions.cpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_inner_product.cpp:1
+upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_lrn.cpp:1
+upstream/opencv/modules/dnn/src/opencl/activations.cl:1
+upstream/opencv/modules/dnn/src/opencl/batchnorm.cl:1
+upstream/opencv/modules/dnn/src/opencl/col2im.cl:1
+upstream/opencv/modules/dnn/src/opencl/conv_layer_spatial.cl:1
+upstream/opencv/modules/dnn/src/opencl/eltwise.cl:1
+upstream/opencv/modules/dnn/src/opencl/math.cl:1
+upstream/opencv/modules/dnn/src/opencl/mvn.cl:1
+upstream/opencv/modules/dnn/src/opencl/ocl4dnn_lrn.cl:1
+upstream/opencv/modules/dnn/src/opencl/ocl4dnn_pooling.cl:1
+upstream/opencv/modules/dnn/src/opencl/permute.cl:1
+upstream/opencv/modules/dnn/src/opencl/softmax_loss.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Copyright (c) 2016-2017 Fabian David Tschopp, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_softmax.cpp:1
+upstream/opencv/modules/dnn/src/opencl/conv_spatial_helper.cl:1
+upstream/opencv/modules/dnn/src/opencl/gemm_buffer.cl:1
+upstream/opencv/modules/dnn/src/opencl/gemm_image.cl:1
+upstream/opencv/modules/dnn/src/opencl/matvec_mul.cl:1
+upstream/opencv/modules/features/src/hal_replacement.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/onnx/opencv-onnx.proto:6
+
+// SPDX-License-Identifier: Apache-2.0
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/op_timvx.cpp:1
+upstream/opencv/modules/dnn/src/op_timvx.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019-2021, Shenzhen Institute of Artificial Intelligence and
+// Robotics for Society, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/op_vkcom.cpp:1
+upstream/opencv/modules/dnn/src/op_vkcom.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/buffer.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/op_base.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/op_conv.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/include/vkcom.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/buffer.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/internal.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/op_base.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/src/tensor.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.hpp:1
+upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.cpp:1
+upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.hpp:1
+upstream/opencv/modules/objdetect/src/qrcode.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2018, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/opencl/dummy.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/opencl/lrn.cl:1
+upstream/opencv/modules/dnn/src/opencl/pooling.cl:1
+upstream/opencv/modules/dnn/src/opencl/softmax.cl:1
+
+/*************************************************************************************
+ * Copyright (c) 2015, Advanced Micro Devices, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation and/or
+ *  other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ **************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/tflite/schema.fbs:1
+
+// source: https://github.com/tensorflow/tensorflow/blob/b0164f014fd4f1b5af2c7b578aa7687198c5d92e/tensorflow/lite/schema/schema.fbs
+// Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/tokenizer/core_bpe.hpp:15
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+// MIT License
+//
+// Copyright (c) 2022 OpenAI, Shantanu Jain
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+////////////////////////////////////////////////////////////////////////////////////////*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/tokenizer/unicode-data.hpp:14
+upstream/opencv/modules/dnn/src/tokenizer/unicode.hpp:14
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+// MIT License
+//
+// Copyright (c) 2023‑2024 The ggml authors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+////////////////////////////////////////////////////////////////////////////////////////*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/include/context.hpp:5
+upstream/opencv/modules/dnn/src/vkcom/src/context.cpp:5
+
+/*
+The code has been borrowed from ncnn inference engine (https://github.com/Tencent/ncnn/blob/20230223/src/gpu.cpp)
+and adapted for OpenCV by Zihao Mu.
+Below is the original copyright:
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/include/context.hpp:11
+upstream/opencv/modules/dnn/src/vkcom/src/context.cpp:11
+
+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/src/command.cpp:5
+
+/*
+The code has referenced MNN (https://github.com/alibaba/MNN/blob/2.4.0/source/backend/vulkan/component/VulkanCommandPool.cpp)
+and adapted for OpenCV by Zihao Mu.
+Below is the original copyright:
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/src/command.cpp:11
+
+//
+//  VulkanCommandPool.cpp
+//  MNN
+//
+//  Created by MNN on 2019/01/31.
+//  Copyright © 2018, Alibaba Group Holding Limited
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/src/pipeline.cpp:5
+
+/*
+The code has referenced MNN (https://github.com/alibaba/MNN/blob/2.4.0/source/backend/vulkan/component/VulkanPipeline.cpp)
+and adapted for OpenCV by Zihao Mu.
+Below is the original copyright:
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/dnn/src/vkcom/src/pipeline.cpp:11
+
+//
+//  VulkanPipeline.cpp
+//  MNN
+//
+//  Created by MNN on 2019/01/31.
+//  Copyright © 2018, Alibaba Group Holding Limited
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/3rdparty/annoy/annoylib.h:1
+
+// Copyright (c) 2013 Spotify AB
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/3rdparty/annoy/mman.h:2
+
+// This is from https://code.google.com/p/mman-win32/
+//
+// Licensed under MIT
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/3rdparty/mscr/chi_table.h:1
+
+/*
+**
+**                           License Agreement
+**                           For chi_table.h
+**
+** Copyright (C) 2007 Per-Erik Forssen, all rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+**
+**   * Redistribution's of source code must retain the above copyright notice,
+**     this list of conditions and the following disclaimer.
+**
+**   * Redistribution's in binary form must reproduce the above copyright notice,
+**     this list of conditions and the following disclaimer in the documentation
+**     and/or other materials provided with the distribution.
+**
+**   * The name of the copyright holders may not be used to endorse or promote products
+**     derived from this software without specific prior written permission.
+**
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+**
+** Content origin: http://users.isy.liu.se/cvl/perfo/software/chi_table.h
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/affine_feature.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// This file is based on code issued with the following license.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/affine_feature.cpp:6
+
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+*  Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved.
+*  Copyright (C) 2013, Evgeny Toropov, all rights reserved.
+*  Third party copyrights are property of their respective owners.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * The name of the copyright holders may not be used to endorse
+*     or promote products derived from this software without specific
+*     prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/dynamic.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/evaluation.cpp:1
+
+//*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/fast.avx2.cpp:1
+upstream/opencv/modules/features/src/fast.cpp:1
+upstream/opencv/modules/features/src/fast.hpp:1
+upstream/opencv/modules/features/src/fast_score.cpp:1
+upstream/opencv/modules/features/src/fast_score.hpp:1
+
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/fast.avx2.cpp:4
+upstream/opencv/modules/features/src/fast.cpp:4
+upstream/opencv/modules/features/src/fast.hpp:4
+upstream/opencv/modules/features/src/fast_score.cpp:4
+upstream/opencv/modules/features/src/fast_score.hpp:4
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/keypoint.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/mser.cpp:1
+
+/* Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *     Redistributions of source code must retain the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer.
+ *     Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials
+ *     provided with the distribution.
+ *     The name of Contributor may not be used to endorse or
+ *     promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ * Copyright (C) 2009, Liu Liu All rights reserved.
+ *
+ * OpenCV functions for MSER extraction
+ *
+ * 1. there are two different implementation of MSER, one for gray image, one for color image
+ * 2. the gray image algorithm is taken from:
+ *      Linear Time Maximally Stable Extremal Regions;
+ *    the paper claims to be faster than union-find method;
+ *    it actually get 1.5~2m/s on my centrino L7200 1.2GHz laptop.
+ * 3. the color image algorithm is taken from:
+ *      Maximally Stable Colour Regions for Recognition and Match;
+ *    it should be much slower than gray image method ( 3~4 times );
+ *    the chi_table.h file is taken directly from the paper's source code:
+ *    http://users.isy.liu.se/cvl/perfo/software/chi_table.h
+ *    license (BSD-like) is located in the file: 3rdparty/mscr/chi_table_LICENSE.txt
+ * 4. though the name is *contours*, the result actually is a list of point set.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/opencl/brute_force_match.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Nathan, liujun@multicorewareinc.com
+//    Peng Xiao, pengxiao@outlook.com
+//    Baichuan Su, baichuan@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/opencl/fast.cl:1
+
+// OpenCL port of the FAST corner detector.
+// Copyright (C) 2014, Itseez Inc. See the license at http://opencv.org
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/opencl/gftt.cl:1
+upstream/opencv/modules/imgproc/src/opencl/threshold.cl:1
+upstream/opencv/modules/imgproc/src/opencl/warp_affine.cl:1
+upstream/opencv/modules/imgproc/src/opencl/warp_perspective.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Zhang Ying, zhangying913@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/opencl/orb.cl:1
+
+// OpenCL port of the ORB feature detector and descriptor extractor
+// Copyright (C) 2014, Itseez Inc. See the license at http://opencv.org
+//
+// The original code has been contributed by Peter Andreas Entschev, peter@entschev.com
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/orb.cpp:1
+
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/sift.dispatch.cpp:1
+upstream/opencv/modules/features/src/sift.simd.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/features/src/sift.dispatch.cpp:9
+upstream/opencv/modules/features/src/sift.simd.hpp:9
+
+/**********************************************************************************************\
+ Implementation of SIFT is based on the code from http://blogs.oregonstate.edu/hess/code/sift/
+ Below is the original copyright.
+ Patent US6711293 expired in March 2020.
+
+//    Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+//    All rights reserved.
+
+//    The following patent has been issued for methods embodied in this
+//    software: "Method and apparatus for identifying scale invariant features
+//    in an image and use of same for locating an object in an image," David
+//    G. Lowe, US Patent 6,711,293 (March 23, 2004). Provisional application
+//    filed March 8, 1999. Assignee: The University of British Columbia. For
+//    further details, contact David Lowe (lowe@cs.ubc.ca) or the
+//    University-Industry Liaison Office of the University of British
+//    Columbia.
+
+//    Note that restrictions imposed by this patent (and possibly others)
+//    exist independently of and may be in conflict with the freedoms granted
+//    in this license, which refers to copyright of the program, not patents
+//    for any methods that it implements.  Both copyright and patent law must
+//    be obeyed to legally use and redistribute this program and it is not the
+//    purpose of this license to induce you to infringe any patents or other
+//    property right claims or to contest validity of any such claims.  If you
+//    redistribute or use the program, then this license merely protects you
+//    from committing copyright infringement.  It does not protect you from
+//    committing patent infringement.  So, before you do anything with this
+//    program, make sure that you have permission to do so not merely in terms
+//    of copyright, but also in terms of patent law.
+
+//    Please note that this license is not to be understood as a guarantee
+//    either.  If you use the program according to this license, but in
+//    conflict with patent law, it does not mean that the licensor will refund
+//    you for any losses that you incur if you are sued for your patent
+//    infringement.
+
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
+//    met:
+//        * Redistributions of source code must retain the above copyright and
+//          patent notices, this list of conditions and the following
+//          disclaimer.
+//        * Redistributions in binary form must reproduce the above copyright
+//          notice, this list of conditions and the following disclaimer in
+//          the documentation and/or other materials provided with the
+//          distribution.
+//        * Neither the name of Oregon State University nor the names of its
+//          contributors may be used to endorse or promote products derived
+//          from this software without specific prior written permission.
+
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+//    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+//    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\**********************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/all_indices.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/sampling.h:1
+upstream/opencv/modules/flann/src/flann.cpp:1
+
+/*M*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/allocator.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/autotuned_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/composite_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/dist.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/dynamic_bitset.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/flann_base.hpp:1
+upstream/opencv/modules/flann/include/opencv2/flann/general.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/ground_truth.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/heap.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/index_testing.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/kdtree_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/kdtree_single_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/kmeans_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/linear_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/logger.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/lsh_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/lsh_table.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/matrix.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/nn_index.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/object_factory.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/random.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/result_set.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/simplex_downhill.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/timer.h:1
+
+/*M*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/any.h:3
+
+/*
+ * (C) Copyright Christopher Diggins 2005-2011
+ * (C) Copyright Pablo Aguilar 2005
+ * (C) Copyright Kevlin Henney 2001
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ *
+ * Adapted for FLANN by Marius Muja
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/config.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/defines.h:1
+upstream/opencv/modules/flann/include/opencv2/flann/params.h:1
+
+/*M*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h:1
+
+/*M*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/flann/include/opencv2/flann/saving.h:1
+
+/*M*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE NNIndexGOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/include/opencv2/geometry/segment.hpp:1
+upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.cpp:1
+upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.hpp:1
+upstream/opencv/modules/geometry/src/ptcloud/ptcloud_wrapper.hpp:1
+upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.cpp:1
+upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Yechun Ruan <ruanyc@mail.sustech.edu.cn>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/five-point.cpp:6
+
+/*  Copyright (c) 2013, Bo Li (prclibo@gmail.com), ETH Zurich
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of the copyright holder nor the
+          names of its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/fundam.cpp:1
+upstream/opencv/modules/video/src/bgfg_KNN.cpp:1
+upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/geometry.cpp:198
+
+/*
+ This code is described in "Computational Geometry in C" (Second Edition),
+ Chapter 7.  It is not written to be comprehensible without the
+ explanation in that book.
+
+ Written by Joseph O'Rourke.
+ Last modified: December 1997
+ Questions to orourke@cs.smith.edu.
+ --------------------------------------------------------------------
+ This code is Copyright 1997 by Joseph O'Rourke.  It may be freely
+ redistributed in its entirety provided that this copyright notice is
+ not removed.
+ --------------------------------------------------------------------
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/homography_decomp.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// This is a homography decomposition implementation contributed to OpenCV
+// by Samson Yilma. It implements the homography decomposition algorithm
+// described in the research report:
+// Malis, E and Vargas, M, "Deeper understanding of the homography decomposition
+// for vision-based control", Research Report 6303, INRIA (2007)
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Samson Yilma (samson_yilma@yahoo.com), all rights reserved.
+// Copyright (C) 2018, Intel Corporation, all rights reserved.
+//
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/intersection.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//      Nghia Ho, nghiaho12@yahoo.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of OpenCV Foundation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/ippe.cpp:5
+upstream/opencv/modules/geometry/src/ippe.hpp:5
+upstream/opencv/modules/geometry/src/sqpnp.cpp:12
+upstream/opencv/modules/geometry/src/sqpnp.hpp:12
+
+// This file is based on file issued with the following license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/ippe.cpp:7
+upstream/opencv/modules/geometry/src/ippe.hpp:7
+
+/*============================================================================
+
+Copyright 2017 Toby Collins
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this
+   list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/levmarq.cpp:1
+upstream/opencv/modules/imgproc/src/cornersubpix.cpp:1
+upstream/opencv/modules/imgproc/src/distransform.cpp:1
+upstream/opencv/modules/imgproc/src/floodfill.cpp:1
+upstream/opencv/modules/imgproc/src/samplers.cpp:1
+upstream/opencv/modules/imgproc/src/segmentation.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/min_enclosing_convex_polygon.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  This file is part of OpenCV project.
+ //  It is subject to the license terms in the LICENSE file found in the top-level directory of this
+ //  distribution and at http://opencv.org/license.html.
+ //
+ //  Author: Sara Kuhnert
+ //  Created: 20.05.2025
+ //  E-mail: <sara.kuhnert[AT]gmx.de>
+ //
+ //  THE IMPLEMENTATION OF THE MODULES IS BASED ON THE FOLLOWING PAPER:
+ //
+ //  [1] A. Aggarwal, J. S. Chang, Chee K. Yap: "Minimum area circumscribing Polygons", The Visual
+ //  Computer, 1:112-117, 1985
+ //
+ //  The overall complexity of the algorithm is theta(n^2log(n)log(k)) where "n" represents the number
+ //  of vertices in the input convex polygon and "k" the number of vertices in the output polygon.
+ //
+ //M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/min_enclosing_triangle.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//  INFORMATION REGARDING THE CONTRIBUTION:
+//
+//  Author: Ovidiu Parvu
+//  Affiliation: Brunel University
+//  Created: 11.09.2013
+//  E-mail: <ovidiu.parvu[AT]gmail.com>
+//  Web: http://people.brunel.ac.uk/~cspgoop
+//
+//  These functions were implemented during Ovidiu Parvu's first year as a PhD student at
+//  Brunel University, London, UK. The PhD project is supervised by prof. David Gilbert (principal)
+//  and prof. Nigel Saunders (second).
+//
+//  THE IMPLEMENTATION OF THE MODULES IS BASED ON THE FOLLOWING PAPERS:
+//
+//  [1] V. Klee and M. C. Laskowski, "Finding the smallest triangles containing a given convex
+//  polygon", Journal of Algorithms, vol. 6, no. 3, pp. 359-375, Sep. 1985.
+//  [2] J. O'Rourke, A. Aggarwal, S. Maddila, and M. Baldwin, "An optimal algorithm for finding
+//  minimal enclosing triangles", Journal of Algorithms, vol. 7, no. 2, pp. 258-269, Jun. 1986.
+//
+//  The overall complexity of the algorithm is theta(n) where "n" represents the number
+//  of vertices in the convex polygon.
+//
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2013, Ovidiu Parvu, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/p3p.cpp:14
+upstream/opencv/modules/geometry/src/usac/bundle.cpp:1
+
+// Copyright (c) 2020, Viktor Larsson
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//
+//     * Neither the name of the copyright holder nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/pcc.h:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Yuhang Wang <yuhangwang0012@gmail.com>
+//         Chengwei Ye <broweigg@gmail.com>
+//         Zhangjie Cheng <zhangjiec01@gmail.com>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/ptcloud/normal_estimation.cpp:1
+upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.cpp:1
+upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2022, Wanli Zhong <zhongwl2018@mail.sustech.edu.cn>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/ptcloud/sampling.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Yechun Ruan <ruanyc@mail.sustech.edu.cn>
+// Acknowledgement of the support from Huawei Technologies Co., Ltd.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/rho.cpp:1
+upstream/opencv/modules/geometry/src/rho.h:1
+
+/*
+  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+
+  By downloading, copying, installing or using the software you agree to this license.
+  If you do not agree to this license, do not download, install,
+  copy or use the software.
+
+
+                          BSD 3-Clause License
+
+ Copyright (C) 2014, Olexa Bilaniuk, Hamid Bazargani & Robert Laganiere, all rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+   * Redistribution's of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+   * Redistribution's in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+   * The name of the copyright holders may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ This software is provided by the copyright holders and contributors "as is" and
+ any express or implied warranties, including, but not limited to, the implied
+ warranties of merchantability and fitness for a particular purpose are disclaimed.
+ In no event shall the Intel Corporation or contributors be liable for any direct,
+ indirect, incidental, special, exemplary, or consequential damages
+ (including, but not limited to, procurement of substitute goods or services;
+ loss of use, data, or profits; or business interruption) however caused
+ and on any theory of liability, whether in contract, strict liability,
+ or tort (including negligence or otherwise) arising in any way out of
+ the use of this software, even if advised of the possibility of such damage.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/rotcalipers.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of OpenCV Foundation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/solvepnp.cpp:1
+upstream/opencv/modules/objdetect/src/circlesgrid.cpp:1
+upstream/opencv/modules/objdetect/src/circlesgrid.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/sqpnp.cpp:14
+upstream/opencv/modules/geometry/src/sqpnp.hpp:14
+
+/*
+BSD 3-Clause License
+
+Copyright (c) 2020, George Terzakis
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/sqpnp.cpp:727
+
+/* Solve the nearest orthogonal approximation problem
+ * i.e., given e, find R minimizing ||R-e||_F
+ *
+ * The computation borrows from Markley's FOAM algorithm
+ * "Attitude Determination Using Vector Observations: A Fast Optimal Matrix Algorithm", J. Astronaut. Sci. 1993.
+ *
+ * See also M. Lourakis: "An Efficient Solution to Absolute Orientation", ICPR 2016
+ *
+ *  Copyright (C) 2019 Manolis Lourakis (lourakis **at** ics forth gr)
+ *  Institute of Computer Science, Foundation for Research & Technology - Hellas
+ *  Heraklion, Crete, Greece.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/triangulate.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2009, Intel Corporation and others, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/triangulate.cpp:48
+
+// correctMatches function is Copyright (C) 2009, Jostein Austvik Jacobsen.
+// triangulatePoints function is derived from reconstructPointsFor3View, originally by Valery Mosyagin.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/geometry/src/usac/dls_solver.cpp:5
+
+// Copyright (C) 2019 Czech Technical University.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//
+//     * Neither the name of Czech Technical University nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Please contact the author of this library if you have any questions.
+// Author: Daniel Barath (barath.daniel@sztaki.mta.hu)
+// Modification: Maksym Ivashechkin (ivashmak@cmp.felk.cvut.cz)
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/include/opencv2/highgui/highgui_winrt.hpp:3
+upstream/opencv/modules/videoio/include/opencv2/videoio/cap_winrt.hpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_bridge.cpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_bridge.hpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_capture.cpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_capture.hpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_video.cpp:3
+upstream/opencv/modules/videoio/src/cap_winrt_video.hpp:3
+
+// Copyright (c) Microsoft Open Technologies, Inc.
+// All rights reserved.
+//
+// (3 - clause BSD License)
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+// the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+// following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+// following disclaimer in the documentation and/or other materials provided with the distribution.
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or
+// promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:3
+upstream/opencv/modules/highgui/src/window_QT.h:3
+
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:8
+upstream/opencv/modules/highgui/src/window_QT.h:8
+
+//                          License Agreement
+//               For Open Source Computer Vision Library
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:11
+upstream/opencv/modules/highgui/src/window_QT.h:11
+
+//Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+//Copyright (C) 2008-2010, Willow Garage Inc., all rights reserved.
+//Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:15
+upstream/opencv/modules/highgui/src/window_QT.h:15
+
+//Redistribution and use in source and binary forms, with or without modification,
+//are permitted provided that the following conditions are met:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:18
+upstream/opencv/modules/highgui/src/window_QT.h:18
+
+//  * Redistribution's of source code must retain the above copyright notice,
+//  this list of conditions and the following disclaimer.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:21
+upstream/opencv/modules/highgui/src/window_QT.h:21
+
+//  * Redistribution's in binary form must reproduce the above copyright notice,
+//  this list of conditions and the following disclaimer in the documentation
+//  and/or other materials provided with the distribution.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:25
+upstream/opencv/modules/highgui/src/window_QT.h:25
+
+//  * The name of the copyright holders may not be used to endorse or promote products
+//  derived from this software without specific prior written permission.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_QT.cpp:28
+upstream/opencv/modules/highgui/src/window_QT.h:28
+
+//This software is provided by the copyright holders and contributors "as is" and
+//any express or implied warranties, including, but not limited to, the implied
+//warranties of merchantability and fitness for a particular purpose are disclaimed.
+//In no event shall the Intel Corporation or contributors be liable for any direct,
+//indirect, incidental, special, exemplary, or consequential damages
+//(including, but not limited to, procurement of substitute goods or services;
+//loss of use, data, or profits; or business interruption) however caused
+//and on any theory of liability, whether in contract, strict liability,
+//or tort (including negligence or otherwise) arising in any way out of
+//the use of this software, even if advised of the possibility of such damage.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/highgui/src/window_cocoa.mm:3
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                         License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/bitstrm.cpp:1
+upstream/opencv/modules/imgcodecs/src/bitstrm.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_avif.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_avif.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_base.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gif.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_gif.hpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_sunras.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/exif.hpp:77
+
+///< Copyright information
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp:1
+upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2020, Stefan Brüns <stefan.bruens@rwth-aachen.de>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_pam.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                            License Agreement
+//                 For Open Source Computer Vision Library
+//                         (3-clause BSD License)
+//
+//  Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+//  Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+//  Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+//  Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+//  Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+//  Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+//  Third party copyrights are property of their respective owners.
+//
+//  Redistribution and use in source and binary forms, with or without modification,
+//  are permitted provided that the following conditions are met:
+//
+//    * Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//    * Redistributions in binary form must reproduce the above copyright notice,
+//      this list of conditions and the following disclaimer in the documentation
+//      and/or other materials provided with the distribution.
+//
+//    * Neither the names of the copyright holders nor the names of the contributors
+//      may be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+//  This software is provided by the copyright holders and contributors "as is" and
+//  any express or implied warranties, including, but not limited to, the implied
+//  warranties of merchantability and fitness for a particular purpose are disclaimed.
+//  In no event shall copyright holders or contributors be liable for any direct,
+//  indirect, incidental, special, exemplary, or consequential damages
+//  (including, but not limited to, procurement of substitute goods or services;
+//  loss of use, data, or profits; or business interruption) however caused
+//  and on any theory of liability, whether in contract, strict liability,
+//  or tort (including negligence or otherwise) arising in any way out of
+//  the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_pam.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                            License Agreement
+//                 For Open Source Computer Vision Library
+//                         (3-clause BSD License)
+//
+//  Copyright (C) 2000-2016, Intel Corporation, all rights reserved.
+//  Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+//  Copyright (C) 2009-2016, NVIDIA Corporation, all rights reserved.
+//  Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+//  Copyright (C) 2015-2016, OpenCV Foundation, all rights reserved.
+//  Copyright (C) 2015-2016, Itseez Inc., all rights reserved.
+//  Third party copyrights are property of their respective owners.
+//
+//  Redistribution and use in source and binary forms, with or without modification,
+//  are permitted provided that the following conditions are met:
+//
+//    * Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//    * Redistributions in binary form must reproduce the above copyright notice,
+//      this list of conditions and the following disclaimer in the documentation
+//      and/or other materials provided with the distribution.
+//
+//    * Neither the names of the copyright holders nor the names of the contributors
+//      may be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+//  This software is provided by the copyright holders and contributors "as is" and
+//  any express or implied warranties, including, but not limited to, the implied
+//  warranties of merchantability and fitness for a particular purpose are disclaimed.
+//  In no event shall copyright holders or contributors be liable for any direct,
+//  indirect, incidental, special, exemplary, or consequential damages
+//  (including, but not limited to, procurement of substitute goods or services;
+//  loss of use, data, or profits; or business interruption) however caused
+//  and on any theory of liability, whether in contract, strict liability,
+//  or tort (including negligence or otherwise) arising in any way out of
+//  the use of this software, even if advised of the possibility of such damage.
+//
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp:50
+
+/****************************************************************************************\
+    This part of the file implements PNG codec on base of libpng library,
+    in particular, this code is based on example.c from libpng
+    (see otherlibs/_graphics/readme.txt for copyright notice)
+    and png2bmp sample from libpng distribution (Copyright (C) 1999-2001 MIYASAKA Masaru)
+\****************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp:57
+
+/****************************************************************************\
+ *
+ *  this file includes some modified part of apngasm and APNG Optimizer 1.4
+ *  both have zlib license.
+ *
+ ****************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp:65
+
+/*  apngasm
+ *
+ *  The next generation of apngasm, the APNG Assembler.
+ *  The apngasm CLI tool and library can assemble and disassemble APNG image files.
+ *
+ *  https://github.com/apngasm/apngasm
+
+
+ * APNG Optimizer 1.4
+ *
+ * Makes APNG files smaller.
+ *
+ * http://sourceforge.net/projects/apng/files
+ *
+ * Copyright (c) 2011-2015 Max Stepin
+ * maxst at users.sourceforge.net
+ *
+ * zlib license
+ * ------------
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp:9
+
+/****************************************************************************************\
+    This part of the file implements PNG codec on base of libspng library,
+    in particular, this code is based on example.c from libspng
+    (see 3rdparty/libspng/LICENSE for copyright notice)
+\****************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp:43
+
+/****************************************************************************************\
+    A part of the file implements TIFF reader on base of libtiff library
+    (see otherlibs/_graphics/readme.txt for copyright notice)
+\****************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/include/opencv2/imgproc/imgproc.hpp:1
+upstream/opencv/modules/stereo/src/stereosgbm.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/include/opencv2/imgproc.hpp:1078
+
+/** @brief Line segment detector class
+
+following the algorithm described at @cite Rafael12 .
+
+@note Implementation has been removed from OpenCV version 3.4.6 to 3.4.15 and version 4.1.0 to 4.5.3 due original code license conflict.
+restored again after [Computation of a NFA](https://github.com/rafael-grompone-von-gioi/binomial_nfa) code published under the MIT license.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/accum.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+/
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/bilateral_filter.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/bilateral_filter.simd.hpp:1
+upstream/opencv/modules/imgproc/src/box_filter.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/box_filter.simd.hpp:1
+upstream/opencv/modules/imgproc/src/median_blur.simd.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, 2018, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Copyright (C) 2025, Advanced Micro Devices, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/blend.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Nathan, liujun@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/canny.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/ccl_bolelli_forest.inc.hpp:1
+upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_firstline.inc.hpp:1
+upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_lastline.inc.hpp:1
+upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_singleline.inc.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// 2021 Federico Bolelli <federico.bolelli@unimore.it>
+// 2021 Stefano Allegretti <stefano.allegretti@unimore.it>
+// 2021 Costantino Grana <costantino.grana@unimore.it>
+//
+// This file has been automatically generated using GRAPHGEN (https://github.com/prittt/GRAPHGEN)
+// and taken from the YACCLAB repository (https://github.com/prittt/YACCLAB).
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/clahe.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, NVIDIA Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the copyright holders or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/color_lab.cpp:5
+
+/********************************* COPYRIGHT NOTICE *******************************\
+  The function for RGB to Lab conversion is based on the MATLAB script
+  RGB2Lab.m translated by Mark Ruzon from C code by Yossi Rubner, 23 September 1997.
+  See the page [http://vision.stanford.edu/~ruzon/software/rgblab.html]
+\**********************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/connectedcomponents.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// 2011 Jason Newton <nevion@gmail.com>
+// 2016, 2021 Costantino Grana <costantino.grana@unimore.it>
+// 2016, 2021 Federico Bolelli <federico.bolelli@unimore.it>
+// 2016 Lorenzo Baraldi <lorenzo.baraldi@unimore.it>
+// 2016 Roberto Vezzani <roberto.vezzani@unimore.it>
+// 2016 Michele Cancilla <cancilla.michele@gmail.com>
+// 2021 Stefano Allegretti <stefano.allegretti@unimore.it>
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/corner.avx.cpp:1
+upstream/opencv/modules/imgproc/src/corner.cpp:1
+upstream/opencv/modules/imgproc/src/corner.hpp:1
+upstream/opencv/modules/imgproc/src/imgwarp.avx2.cpp:1
+upstream/opencv/modules/imgproc/src/imgwarp.cpp:1
+upstream/opencv/modules/imgproc/src/imgwarp.hpp:1
+upstream/opencv/modules/imgproc/src/imgwarp.lasx.cpp:1
+upstream/opencv/modules/imgproc/src/imgwarp.sse4_1.cpp:1
+upstream/opencv/modules/imgproc/src/pyramids.cpp:1
+upstream/opencv/modules/imgproc/src/resize.avx2.cpp:1
+upstream/opencv/modules/imgproc/src/resize.hpp:1
+upstream/opencv/modules/imgproc/src/resize.lasx.cpp:1
+upstream/opencv/modules/imgproc/src/resize.sse4_1.cpp:1
+upstream/opencv/modules/imgproc/src/smooth.dispatch.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/demosaicing.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/demosaicing.cpp:44
+
+/********************************* COPYRIGHT NOTICE *******************************\
+  Original code for Bayer->BGR/RGB conversion is provided by Dirk Schaefer
+  from MD-Mathematische Dienste GmbH. Below is the copyright notice:
+
+    IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+    By downloading, copying, installing or using the software you agree
+    to this license. If you do not agree to this license, do not download,
+    install, copy or use the software.
+
+    Contributors License Agreement:
+
+      Copyright (c) 2002,
+      MD-Mathematische Dienste GmbH
+      Im Defdahl 5-10
+      44141 Dortmund
+      Germany
+      www.md-it.de
+
+    Redistribution and use in source and binary forms,
+    with or without modification, are permitted provided
+    that the following conditions are met:
+
+    Redistributions of source code must retain
+    the above copyright notice, this list of conditions and the following disclaimer.
+    Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+    The name of Contributor may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+    THE POSSIBILITY OF SUCH DAMAGE.
+\**********************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/deriv.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2014, Itseez, Inc, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/emd_new.cpp:5
+
+/*
+    Partially based on Yossi Rubner code:
+    =========================================================================
+    emd.c
+
+    Last update: 3/14/98
+
+    An implementation of the Earth Movers Distance.
+    Based of the solution for the Transportation problem as described in
+    "Introduction to Mathematical Programming" by F. S. Hillier and
+    G. J. Lieberman, McGraw-Hill, 1990.
+
+    Copyright (C) 1998 Yossi Rubner
+    Computer Science Department, Stanford University
+    E-Mail: rubner@cs.stanford.edu   URL: http://vision.stanford.edu/~rubner
+    ==========================================================================
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/filterengine.hpp:1
+upstream/opencv/modules/imgproc/src/phasecorr.cpp:1
+
+// This file is a part of OpenCV project.
+// See opencv/LICENSE and http://opencv.org/license.html for the actual licensing terms.
+// See also opencv/doc/LICENSE_CHANGE_NOTICE.txt. Below is the original license:
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/filterengine.hpp:5
+
+/*
+By downloading, copying, installing or using the software you agree to this license.
+If you do not agree to this license, do not download, install,
+copy or use the software.
+
+
+                          License Agreement
+               For Open Source Computer Vision Library
+                       (3-clause BSD License)
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall copyright holders or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/gabor.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/histogram.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//            Intel License Agreement
+//        For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/hough.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2014, Itseez, Inc, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/lsd.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistributions of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/median_blur.dispatch.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, 2018, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/median_blur.simd.hpp:56
+
+/*
+ * This file includes the code, contributed by Simon Perreault
+ * (the function icvMedianBlur_8u_O1)
+ *
+ * Constant-time median filtering -- http://nomis80.org/ctmf.html
+ * Copyright (C) 2006 Simon Perreault
+ *
+ * Contact:
+ *  Laboratoire de vision et systemes numeriques
+ *  Pavillon Adrien-Pouliot
+ *  Universite Laval
+ *  Sainte-Foy, Quebec, Canada
+ *  G1K 7P4
+ *
+ *  perreaul@gel.ulaval.ca
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/bilateral.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Rock Li, Rock.li@amd.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/blend_linear.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, MulticoreWare Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Liu Liujun, liujun@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/boxFilter.cl:1
+upstream/opencv/modules/imgproc/src/opencl/filter2D.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/calc_back_project.cl:1
+upstream/opencv/modules/imgproc/src/opencl/histogram.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//    Xu Pang, pangxu010@163.com
+//    Wenju He, wenju@multicorewareinc.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/canny.cl:1
+upstream/opencv/modules/stitching/src/opencl/warpers.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/clahe.cl:1
+upstream/opencv/modules/video/src/opencl/optical_flow_farneback.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Sen Liu, swjtuls1987@126.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/color_hsv.cl:1
+upstream/opencv/modules/imgproc/src/opencl/color_lab.cl:1
+upstream/opencv/modules/imgproc/src/opencl/color_rgb.cl:1
+upstream/opencv/modules/imgproc/src/opencl/color_yuv.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Jia Haipeng, jiahaipeng95@gmail.com
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/corner.cl:1
+upstream/opencv/modules/imgproc/src/opencl/precornerdetect.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Shengen Yan,yanshengen@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/filter2DSmall.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2014, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/filterSepCol.cl:1
+upstream/opencv/modules/imgproc/src/opencl/filterSepRow.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Copyright (C) 2014, Itseez, Inc, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/filterSep_singlePass.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2014, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/integral_sum.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2014, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/match_template.cl:1
+upstream/opencv/modules/imgproc/src/opencl/medianFilter.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/morph.cl:1
+
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Niko Li, newlife20080214@gmail.com
+//    Zero Lin, zero.lin@amd.com
+//    Yao Wang, bitwangyaoyao@gmail.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/pyr_down.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Dachuan Zhao, dachuan@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/pyr_up.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Zhang Chunpeng	chunpeng@multicorewareinc.com
+//    Dachuan Zhao, dachuan@multicorewareinc.com
+//    Yao Wang, yao@multicorewareinc.com
+//    Peng Xiao, pengxiao@outlook.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/remap.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Wu Zailong, bullet@yeah.net
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/resize.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Zhang Ying, zhangying913@gmail.com
+//	  Niko Li, newlife20080214@gmail.com
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/opencl/threshold_mask.cl:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// @Authors
+//    Zhang Ying, zhangying913@gmail.com
+//    Pierre Chatelier, pierre@chachatelier.fr
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/phasecorr.cpp:5
+
+/*********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2008-2011, William Lucas
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the Willow Garage nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/resize.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, 2017, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/smooth.simd.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014-2015, Itseez Inc., all rights reserved.
+// Copyright (C) 2025, Advanced Micro Devices, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/stackblur.cpp:5
+
+/*
+StackBlur - a fast almost Gaussian Blur
+Theory: http://underdestruction.com/2004/02/25/stackblur-2004
+The code has been borrowed from (https://github.com/flozz/StackBlur)
+and adapted for OpenCV by Zihao Mu.
+
+Below is the original copyright
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/stackblur.cpp:14
+
+/*
+Copyright (c) 2010 Mario Klingemann
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/stb_truetype.cpp:1
+upstream/opencv/modules/imgproc/src/stb_truetype.hpp:16
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/stb_truetype.cpp:43
+
+// stb_truetype.h - v1.26 - public domain
+// authored from 2009-2021 by Sean Barrett / RAD Game Tools
+//
+// =======================================================================
+//
+//    NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES
+//
+// This library does no range checking of the offsets found in the file,
+// meaning an attacker can use it to read arbitrary memory.
+//
+// =======================================================================
+//
+//   This library processes TrueType files:
+//        parse files
+//        extract glyph metrics
+//        extract glyph shapes
+//        render glyphs to one-channel bitmaps with antialiasing (box filter)
+//        render glyphs to one-channel SDF bitmaps (signed-distance field/function)
+//
+//   Todo:
+//        non-MS cmaps
+//        crashproof on bad data
+//        hinting? (no longer patented)
+//        cleartype-style AA?
+//        optimize: use simple memory allocator for intermediates
+//        optimize: build edge-list directly from curves
+//        optimize: rasterize directly from curves?
+//
+// ADDITIONAL CONTRIBUTORS
+//
+//   Mikko Mononen: compound shape support, more cmap formats
+//   Tor Andersson: kerning, subpixel rendering
+//   Dougall Johnson: OpenType / Type 2 font handling
+//   Daniel Ribeiro Maciel: basic GPOS-based kerning
+//
+//   Misc other:
+//       Ryan Gordon
+//       Simon Glass
+//       github:IntellectualKitty
+//       Imanol Celaya
+//       Daniel Ribeiro Maciel
+//
+//   Bug/warning reports/fixes:
+//       "Zer" on mollyrocket       Fabian "ryg" Giesen   github:NiLuJe
+//       Cass Everitt               Martins Mozeiko       github:aloucks
+//       stoiko (Haemimont Games)   Cap Petschulat        github:oyvindjam
+//       Brian Hook                 Omar Cornut           github:vassvik
+//       Walter van Niftrik         Ryan Griege
+//       David Gow                  Peter LaValle
+//       David Given                Sergey Popov
+//       Ivan-Assen Ivanov          Giumo X. Clanjor
+//       Anthony Pesch              Higor Euripedes
+//       Johan Duparc               Thomas Fields
+//       Hou Qiming                 Derek Vinyard
+//       Rob Loach                  Cort Stratton
+//       Kenney Phillis Jr.         Brian Costabile
+//       Ken Voskuil (kaesve)
+//
+// VERSION HISTORY
+//
+//   1.26 (2021-08-28) fix broken rasterizer
+//   1.25 (2021-07-11) many fixes
+//   1.24 (2020-02-05) fix warning
+//   1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS)
+//   1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined
+//   1.21 (2019-02-25) fix warning
+//   1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics()
+//   1.19 (2018-02-11) GPOS kerning, STBTT_fmod
+//   1.18 (2018-01-29) add missing function
+//   1.17 (2017-07-23) make more arguments const; doc fix
+//   1.16 (2017-07-12) SDF support
+//   1.15 (2017-03-03) make more arguments const
+//   1.14 (2017-01-16) num-fonts-in-TTC function
+//   1.13 (2017-01-02) support OpenType fonts, certain Apple fonts
+//   1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual
+//   1.11 (2016-04-02) fix unused-variable warning
+//   1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef
+//   1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly
+//   1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges
+//   1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints;
+//                     variant PackFontRanges to pack and render in separate phases;
+//                     fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?);
+//                     fixed an assert() bug in the new rasterizer
+//                     replace assert() with STBTT_assert() in new rasterizer
+//
+//   Full history can be found at the end of this file.
+//
+// LICENSE
+//
+//   See end of file for license information.
+//
+// USAGE
+//
+//   Include this file in whatever places need to refer to it. In ONE C/C++
+//   file, write:
+//      #define STB_TRUETYPE_IMPLEMENTATION
+//   before the #include of this file. This expands out the actual
+//   implementation into that C/C++ file.
+//
+//   To make the implementation private to the file that generates the implementation,
+//      #define STBTT_STATIC
+//
+//   Simple 3D API (don't ship this, but it's fine for tools and quick start)
+//           stbtt_BakeFontBitmap()               -- bake a font to a bitmap for use as texture
+//           stbtt_GetBakedQuad()                 -- compute quad to draw for a given char
+//
+//   Improved 3D API (more shippable):
+//           #include "stb_rect_pack.h"           -- optional, but you really want it
+//           stbtt_PackBegin()
+//           stbtt_PackSetOversampling()          -- for improved quality on small fonts
+//           stbtt_PackFontRanges()               -- pack and renders
+//           stbtt_PackEnd()
+//           stbtt_GetPackedQuad()
+//
+//   "Load" a font file from a memory buffer (you have to keep the buffer loaded)
+//           stbtt_InitFont()
+//           stbtt_GetFontOffsetForIndex()        -- indexing for TTC font collections
+//           stbtt_GetNumberOfFonts()             -- number of fonts for TTC font collections
+//
+//   Render a unicode codepoint to a bitmap
+//           stbtt_GetCodepointBitmap()           -- allocates and returns a bitmap
+//           stbtt_MakeCodepointBitmap()          -- renders into bitmap you provide
+//           stbtt_GetCodepointBitmapBox()        -- how big the bitmap must be
+//
+//   Character advance/positioning
+//           stbtt_GetCodepointHMetrics()
+//           stbtt_GetFontVMetrics()
+//           stbtt_GetFontVMetricsOS2()
+//           stbtt_GetCodepointKernAdvance()
+//
+//   Starting with version 1.06, the rasterizer was replaced with a new,
+//   faster and generally-more-precise rasterizer. The new rasterizer more
+//   accurately measures pixel coverage for anti-aliasing, except in the case
+//   where multiple shapes overlap, in which case it overestimates the AA pixel
+//   coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If
+//   this turns out to be a problem, you can re-enable the old rasterizer with
+//        #define STBTT_RASTERIZER_VERSION 1
+//   which will incur about a 15% speed hit.
+//
+// ADDITIONAL DOCUMENTATION
+//
+//   Immediately after this block comment are a series of sample programs.
+//
+//   After the sample programs is the "header file" section. This section
+//   includes documentation for each API function.
+//
+//   Some important concepts to understand to use this library:
+//
+//      Codepoint
+//         Characters are defined by unicode codepoints, e.g. 65 is
+//         uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is
+//         the hiragana for "ma".
+//
+//      Glyph
+//         A visual character shape (every codepoint is rendered as
+//         some glyph)
+//
+//      Glyph index
+//         A font-specific integer ID representing a glyph
+//
+//      Baseline
+//         Glyph shapes are defined relative to a baseline, which is the
+//         bottom of uppercase characters. Characters extend both above
+//         and below the baseline.
+//
+//      Current Point
+//         As you draw text to the screen, you keep track of a "current point"
+//         which is the origin of each character. The current point's vertical
+//         position is the baseline. Even "baked fonts" use this model.
+//
+//      Vertical Font Metrics
+//         The vertical qualities of the font, used to vertically position
+//         and space the characters. See docs for stbtt_GetFontVMetrics.
+//
+//      Font Size in Pixels or Points
+//         The preferred interface for specifying font sizes in stb_truetype
+//         is to specify how tall the font's vertical extent should be in pixels.
+//         If that sounds good enough, skip the next paragraph.
+//
+//         Most font APIs instead use "points", which are a common typographic
+//         measurement for describing font size, defined as 72 points per inch.
+//         stb_truetype provides a point API for compatibility. However, true
+//         "per inch" conventions don't make much sense on computer displays
+//         since different monitors have different number of pixels per
+//         inch. For example, Windows traditionally uses a convention that
+//         there are 96 pixels per inch, thus making 'inch' measurements have
+//         nothing to do with inches, and thus effectively defining a point to
+//         be 1.333 pixels. Additionally, the TrueType font data provides
+//         an explicit scale factor to scale a given font's glyphs to points,
+//         but the author has observed that this scale factor is often wrong
+//         for non-commercial fonts, thus making fonts scaled in points
+//         according to the TrueType spec incoherently sized in practice.
+//
+// DETAILED USAGE:
+//
+//  Scale:
+//    Select how high you want the font to be, in points or pixels.
+//    Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute
+//    a scale factor SF that will be used by all other functions.
+//
+//  Baseline:
+//    You need to select a y-coordinate that is the baseline of where
+//    your text will appear. Call GetFontBoundingBox to get the baseline-relative
+//    bounding box for all characters. SF*-y0 will be the distance in pixels
+//    that the worst-case character could extend above the baseline, so if
+//    you want the top edge of characters to appear at the top of the
+//    screen where y=0, then you would set the baseline to SF*-y0.
+//
+//  Current point:
+//    Set the current point where the first character will appear. The
+//    first character could extend left of the current point; this is font
+//    dependent. You can either choose a current point that is the leftmost
+//    point and hope, or add some padding, or check the bounding box or
+//    left-side-bearing of the first character to be displayed and set
+//    the current point based on that.
+//
+//  Displaying a character:
+//    Compute the bounding box of the character. It will contain signed values
+//    relative to <current_point, baseline>. I.e. if it returns x0,y0,x1,y1,
+//    then the character should be displayed in the rectangle from
+//    <current_point+SF*x0, baseline+SF*y0> to <current_point+SF*x1,baseline+SF*y1).
+//
+//  Advancing for the next character:
+//    Call GlyphHMetrics, and compute 'current_point += SF * advance'.
+//
+//
+// ADVANCED USAGE
+//
+//   Quality:
+//
+//    - Use the functions with Subpixel at the end to allow your characters
+//      to have subpixel positioning. Since the font is anti-aliased, not
+//      hinted, this is very import for quality. (This is not possible with
+//      baked fonts.)
+//
+//    - Kerning is now supported, and if you're supporting subpixel rendering
+//      then kerning is worth using to give your text a polished look.
+//
+//   Performance:
+//
+//    - Convert Unicode codepoints to glyph indexes and operate on the glyphs;
+//      if you don't do this, stb_truetype is forced to do the conversion on
+//      every call.
+//
+//    - There are a lot of memory allocations. We should modify it to take
+//      a temp buffer and allocate from the temp buffer (without freeing),
+//      should help performance a lot.
+//
+// NOTES
+//
+//   The system uses the raw data found in the .ttf file without changing it
+//   and without building auxiliary data structures. This is a bit inefficient
+//   on little-endian systems (the data is big-endian), but assuming you're
+//   caching the bitmaps or glyph shapes this shouldn't be a big deal.
+//
+//   It appears to be very hard to programmatically determine what font a
+//   given file is in a general way. I provide an API for this, but I don't
+//   recommend it.
+//
+//
+// PERFORMANCE MEASUREMENTS FOR 1.06:
+//
+//                      32-bit     64-bit
+//   Previous release:  8.83 s     7.68 s
+//   Pool allocations:  7.72 s     6.34 s
+//   Inline sort     :  6.54 s     5.65 s
+//   New rasterizer  :  5.63 s     5.00 s
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/stb_truetype.hpp:10
+
+//////////////// Below is the original copyright information /////////////////
+///////// (btw, OpenCV chooses the option A (MIT) for the license) ///////////
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/sumpixels.avx512_skx.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2019-2020, Intel Corporation, all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/imgproc/src/sumpixels.dispatch.cpp:1
+upstream/opencv/modules/imgproc/src/sumpixels.simd.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2020 Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/barcode.hpp:1
+upstream/opencv/modules/objdetect/src/barcode.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.hpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.hpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.hpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.hpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.hpp:1
+upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/bound_min.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/charts.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/charts.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/checker_detector.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/checker_model.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/common.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/common.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/debug.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/debug.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/dictionary.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/graph_cluster.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/precomp.hpp:5
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp:5
+upstream/opencv/modules/objdetect/src/mcc/wiener_filter.hpp:5
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/unionfind.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zarray.hpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp:1
+upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp:1
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+// Modified by darkliang wangberlinT
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.hpp:1
+
+/// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/calibinit.cpp:1
+
+//M*//////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/calibinit.cpp:42
+
+/************************************************************************************\
+    This is improved variant of chessboard corner detection algorithm that
+    uses a graph of connected quads. It is based on the code contributed
+    by Vladimir Vezhnevets and Philip Gruebele.
+    Here is the copyright notice from the original Vladimir's code:
+    ===============================================================
+
+    The algorithms developed and implemented by Vezhnevets Vladimir
+    aka Dead Moroz (vvp@graphics.cs.msu.ru)
+    See http://graphics.cs.msu.su/en/research/calibration/opencv.html
+    for detailed information.
+
+    Reliability additions and modifications made by Philip Gruebele.
+    <a href="mailto:pgruebele@cox.net">pgruebele@cox.net</a>
+
+    Some further improvements for detection of partially occluded boards at non-ideal
+    lighting conditions have been made by Alex Bovyrin and Kurt Kolonige
+
+\************************************************************************************/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/checkchessboard.cpp:1
+upstream/opencv/modules/objdetect/src/quadsubpix.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                        Intel License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000, Intel Corporation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of Intel Corporation may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Intel Corporation, all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/objdetect/src/qrcode_encoder_table.inl.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Intel Corporation, all rights reserved.
+//
+// This is .hpp file included from qrcode_encoder.cpp
+
+==============================================================================
+Sources:
+upstream/opencv/modules/photo/include/opencv2/photo/ccm.hpp:1
+upstream/opencv/modules/photo/src/ccm/ccm.cpp:1
+upstream/opencv/modules/photo/src/ccm/color.cpp:1
+upstream/opencv/modules/photo/src/ccm/color.hpp:1
+upstream/opencv/modules/photo/src/ccm/colorspace.cpp:1
+upstream/opencv/modules/photo/src/ccm/colorspace.hpp:1
+upstream/opencv/modules/photo/src/ccm/distance.cpp:1
+upstream/opencv/modules/photo/src/ccm/distance.hpp:1
+upstream/opencv/modules/photo/src/ccm/illumobserver.cpp:1
+upstream/opencv/modules/photo/src/ccm/illumobserver.hpp:1
+upstream/opencv/modules/photo/src/ccm/linearize.cpp:1
+upstream/opencv/modules/photo/src/ccm/linearize.hpp:1
+upstream/opencv/modules/photo/src/ccm/operations.cpp:1
+upstream/opencv/modules/photo/src/ccm/operations.hpp:1
+upstream/opencv/modules/photo/src/ccm/utils.cpp:1
+upstream/opencv/modules/photo/src/ccm/utils.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/photo/include/opencv2/photo/cuda.hpp:1
+upstream/opencv/modules/photo/include/opencv2/photo.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/photo/src/arrays.hpp:1
+upstream/opencv/modules/photo/src/denoising.cpp:1
+upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker.hpp:1
+upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker_commons.hpp:1
+upstream/opencv/modules/photo/src/fast_nlmeans_multi_denoising_invoker.hpp:1
+upstream/opencv/modules/photo/src/inpaint.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/photo/src/intelligent_scissors.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp:5
+upstream/opencv/modules/ptcloud/src/color_tsdf_functions.hpp:5
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp:5
+upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.hpp:5
+upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp:5
+upstream/opencv/modules/ptcloud/src/opencl/icp.cl:5
+upstream/opencv/modules/ptcloud/src/opencl/kinfu_frame.cl:5
+upstream/opencv/modules/ptcloud/src/opencl/tsdf.cl:5
+upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp:5
+upstream/opencv/modules/ptcloud/src/tsdf_functions.hpp:5
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/ptcloud/src/octree.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Huawei Technologies Co., Ltd. All rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Author: Zihao Mu <zihaomu6@gmail.com>
+//         Liangqian Kong <chargerKong@126.com>
+//         Longbu Wang <riskiest@gmail.com>
+
+==============================================================================
+Sources:
+upstream/opencv/modules/ptcloud/src/opencl/hash_tsdf.cl:5
+
+// This code is also subject to the license terms in the LICENSE_KinectFusion.md file found in this module's directory
+
+==============================================================================
+Sources:
+upstream/opencv/modules/stereo/src/opencl/stereobm.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/stereo/src/stereobm.cpp:1
+
+//M*//////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/stitching/src/opencl/multibandblend.cl:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2014, Itseez, Inc, all rights reserved.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/video/src/camshift.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/video/src/lkpyramid.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2026, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/video/src/opencl/bgfg_knn.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2018 Ya-Chiu Wu, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Ya-Chiu Wu, yacwu@cs.nctu.edu.tw
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/video/src/opencl/pyrlk.cl:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Dachuan Zhao, dachuan@multicorewareinc.com
+//    Yao Wang, bitwangyaoyao@gmail.com
+//    Xiaopeng Fu, fuxiaopeng2222@163.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/include/opencv2/videoio/cap_ios.h:1
+
+/*  For iOS video I/O
+ *  by Eduard Feicho on 29/07/12
+ *  Copyright 2012. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_android_camera.cpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+// Contributed by Giles Payne
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_aravis.cpp:1
+upstream/opencv/modules/videoio/src/cap_pvapi.cpp:1
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_avfoundation.mm:1
+
+/*
+ *  cap_avfoundation.mm
+ *  For iOS video I/O
+ *  by Xiaochao Yang on 06/15/11 modified from
+ *  cap_qtkit.mm for Nicholas Butko for Mac OS version.
+ *  Copyright 2011. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_avfoundation_mac.mm:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the contributor be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_dshow.cpp:49
+
+/*
+   DirectShow-based Video Capturing module is based on
+   videoInput library by Theodore Watson:
+   http://muonics.net/school/spring05/videoInput/
+
+   Below is the original copyright
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_dshow.cpp:57
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//THE SOFTWARE.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_dshow.hpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2014, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_ffmpeg_hw.hpp:1
+
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2020-2021 Intel Corporation
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_gphoto2.cpp:1
+
+/*
+ * Copyright (c) 2015, Piotr Dobrowolski dobrypd[at]gmail[dot]com
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_gstreamer.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, 2011, Nils Hasler, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_images.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, Nils Hasler, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_ios_abstract_camera.mm:1
+
+/*
+ *  cap_ios_abstract_camera.mm
+ *  For iOS video I/O
+ *  by Eduard Feicho on 29/07/12
+ *  by Alexander Shishkov on 17/07/13
+ *  Copyright 2012. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_ios_photo_camera.mm:1
+
+/*
+ *  cap_ios_photo_camera.mm
+ *  For iOS video I/O
+ *  by Eduard Feicho on 29/07/12
+ *  Copyright 2012. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_ios_video_camera.mm:1
+
+/*
+ *  cap_ios_video_camera.mm
+ *  For iOS video I/O
+ *  by Eduard Feicho on 29/07/12
+ *  by Alexander Shishkov on 17/07/13
+ *  Copyright 2012. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_mjpeg_decoder.cpp:1
+upstream/opencv/modules/videoio/src/cap_mjpeg_encoder.cpp:1
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_msmf.cpp:6
+
+/*
+   Media Foundation-based Video Capturing module is based on
+   videoInput library by Evgeny Pereguda:
+   http://www.codeproject.com/Articles/559437/Capturing-of-video-from-web-camera-on-Windows-7-an
+   Originally licensed under The Code Project Open License (CPOL) 1.02:
+   http://www.codeproject.com/info/cpol10.aspx
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor_capture.cpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor_capture.hpp:5
+
+/*
+* Copyright(C) 2022 by ORBBEC Technology., Inc.
+* Authors:
+*   Huang Zhenchang <yufeng@orbbec.com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.cpp:5
+upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.hpp:5
+
+/*
+* Copyright(C) 2024 by ORBBEC Technology., Inc.
+* Authors:
+*   Huang Zhenchang <yufeng@orbbec.com>
+*   Yu Shuai <daiyin@orbbec.com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp:1
+upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.hpp:1
+upstream/opencv/modules/videoio/src/cap_winrt/MFIncludes.hpp:3
+upstream/opencv/modules/videoio/src/cap_winrt/MediaSink.hpp:1
+upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.cpp:1
+upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.hpp:1
+
+// Copyright (c) Microsoft. All rights reserved.
+//
+// The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+==============================================================================
+Sources:
+upstream/opencv/modules/videoio/src/cap_xine.cpp:1
+
+/*M//////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
diff --git a/src/affine_ops.inc b/src/affine_ops.inc
new file mode 100644
index 0000000..756aaed
--- /dev/null
+++ b/src/affine_ops.inc
@@ -0,0 +1,29 @@
+// Affine free operators are static in upstream affine.hpp. Mirror their
+// implementation in the existing wrapper replacement namespace; class members
+// and aliases retain their upstream identity. Never export a TU-local using.
+export namespace cv::opencv_m_repl {
+template<typename T> requires opencv_m_pick<T>
+inline Affine3<T> operator*(const Affine3<T>& a, const Affine3<T>& b) {
+    return b.concatenate(a);
+}
+
+template<typename T, typename V> requires opencv_m_pick<T> && requires(V v) { v.x; v.y; v.z; }
+inline V operator*(const Affine3<T>& affine, const V& v) {
+    const auto& m = affine.matrix;
+    V result;
+    result.x = m.val[0] * v.x + m.val[1] * v.y + m.val[2] * v.z + m.val[3];
+    result.y = m.val[4] * v.x + m.val[5] * v.y + m.val[6] * v.z + m.val[7];
+    result.z = m.val[8] * v.x + m.val[9] * v.y + m.val[10] * v.z + m.val[11];
+    return result;
+}
+
+template<typename T> requires (__is_same(T, float) || __is_same(T, double))
+inline Vec<T, 3> operator*(const Affine3<T>& affine, const Vec<T, 3>& v) {
+    const auto& m = affine.matrix;
+    Vec<T, 3> result;
+    for (int row = 0; row < 3; ++row)
+        result[row] = m.val[4 * row] * v[0] + m.val[4 * row + 1] * v[1] +
+                      m.val[4 * row + 2] * v[2] + m.val[4 * row + 3];
+    return result;
+}
+}
diff --git a/src/calib.cppm b/src/calib.cppm
new file mode 100644
index 0000000..9916e56
--- /dev/null
+++ b/src/calib.cppm
@@ -0,0 +1,10 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.calib;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.flann;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.objdetect;
+export import mcpplibs.mwrap.opencv.stereo;
+export import mcpplibs.mwrap.opencv.detail.calib;
diff --git a/src/core.cppm b/src/core.cppm
index 141626e..0f182bd 100644
--- a/src/core.cppm
+++ b/src/core.cppm
@@ -1,135 +1,5 @@
-// opencv.core — C++23 module over OpenCV 5 core. The C++ API is unchanged:
-// every exported name is the upstream entity itself (`export using`), only
-// the header inclusion goes away. Function-like macros (CV_Assert, CV_Error,
-// …) cannot cross a module boundary — include <opencv-m/macros.hpp> BEFORE
-// importing when you need them.
-module;
-#include <cstdarg>   // va_list/va_start/va_copy/va_end — cv::format printf reimpl (core_fns.inc)
-#include <cstdio>    // vsnprintf/fputs/FILE/stdout — cv::format / cv::print reimpls (core_fns.inc)
-#include <opencv2/core.hpp>
-#include <opencv2/core/async.hpp>
-#include <opencv2/core/ocl.hpp>
-#include <opencv2/core/quaternion.hpp>
-#include <opencv2/core/softfloat.hpp>
-#include <opencv2/core/version.hpp>
+// Public aggregation keeps imported SDK types separate from Matx template serialization.
+export module mcpplibs.mwrap.opencv.core;
 
-export module opencv.core;
-
-#include "gen_exports/core.inc"
-#include "core_ops.inc"
-#include "matx_ops.inc"
-#include "core_fns.inc"
-
-// ── constant macros re-homed as cv:: constexpr (original spellings) ──────
-// CV_8U / CV_8UC3 / CV_PI … are object-like macros upstream; a module cannot
-// export a macro, so the module exports `cv::CV_8U`-style constexpr values
-// carrying the exact upstream spelling after the namespace. The raw global
-// macros remain available via the <opencv-m/macros.hpp> side header.
-namespace opencv_m_detail {
-inline constexpr int    k_CV_8U  = CV_8U,  k_CV_8S  = CV_8S,  k_CV_16U = CV_16U,
-                        k_CV_16S = CV_16S, k_CV_32S = CV_32S, k_CV_32F = CV_32F,
-                        k_CV_64F = CV_64F, k_CV_16F = CV_16F;
-inline constexpr int    k_CV_CN_MAX = CV_CN_MAX, k_CV_MAT_CN_MASK = CV_MAT_CN_MASK,
-                        k_CV_DEPTH_MAX = CV_DEPTH_MAX;
-inline constexpr double k_CV_PI = CV_PI, k_CV_2PI = CV_2PI, k_CV_LOG2 = CV_LOG2;
-constexpr int k_maketype(int depth, int cn) { return CV_MAKETYPE(depth, cn); }
-#define OPENCV_M_C(base) \
-    inline constexpr int k_##base##C1 = base##C1, k_##base##C2 = base##C2, \
-                         k_##base##C3 = base##C3, k_##base##C4 = base##C4;
-OPENCV_M_C(CV_8U) OPENCV_M_C(CV_8S) OPENCV_M_C(CV_16U) OPENCV_M_C(CV_16S)
-OPENCV_M_C(CV_32S) OPENCV_M_C(CV_32F) OPENCV_M_C(CV_64F) OPENCV_M_C(CV_16F)
-#undef OPENCV_M_C
-}
-
-#undef CV_8U
-#undef CV_8S
-#undef CV_16U
-#undef CV_16S
-#undef CV_32S
-#undef CV_32F
-#undef CV_64F
-#undef CV_16F
-#undef CV_PI
-#undef CV_2PI
-#undef CV_LOG2
-#undef CV_CN_MAX
-#undef CV_MAT_CN_MASK
-#undef CV_DEPTH_MAX
-#undef CV_MAKETYPE
-#undef CV_MAKE_TYPE
-#undef CV_8UC1
-#undef CV_8UC2
-#undef CV_8UC3
-#undef CV_8UC4
-#undef CV_8SC1
-#undef CV_8SC2
-#undef CV_8SC3
-#undef CV_8SC4
-#undef CV_16UC1
-#undef CV_16UC2
-#undef CV_16UC3
-#undef CV_16UC4
-#undef CV_16SC1
-#undef CV_16SC2
-#undef CV_16SC3
-#undef CV_16SC4
-#undef CV_32SC1
-#undef CV_32SC2
-#undef CV_32SC3
-#undef CV_32SC4
-#undef CV_32FC1
-#undef CV_32FC2
-#undef CV_32FC3
-#undef CV_32FC4
-#undef CV_64FC1
-#undef CV_64FC2
-#undef CV_64FC3
-#undef CV_64FC4
-#undef CV_16FC1
-#undef CV_16FC2
-#undef CV_16FC3
-#undef CV_16FC4
-
-export namespace cv {
-inline constexpr int    CV_8U  = opencv_m_detail::k_CV_8U,
-                        CV_8S  = opencv_m_detail::k_CV_8S,
-                        CV_16U = opencv_m_detail::k_CV_16U,
-                        CV_16S = opencv_m_detail::k_CV_16S,
-                        CV_32S = opencv_m_detail::k_CV_32S,
-                        CV_32F = opencv_m_detail::k_CV_32F,
-                        CV_64F = opencv_m_detail::k_CV_64F,
-                        CV_16F = opencv_m_detail::k_CV_16F;
-inline constexpr int    CV_CN_MAX = opencv_m_detail::k_CV_CN_MAX,
-                        CV_MAT_CN_MASK = opencv_m_detail::k_CV_MAT_CN_MASK,
-                        CV_DEPTH_MAX = opencv_m_detail::k_CV_DEPTH_MAX;
-inline constexpr double CV_PI = opencv_m_detail::k_CV_PI,
-                        CV_2PI = opencv_m_detail::k_CV_2PI,
-                        CV_LOG2 = opencv_m_detail::k_CV_LOG2;
-constexpr int CV_MAKETYPE(int depth, int cn) { return opencv_m_detail::k_maketype(depth, cn); }
-#define OPENCV_M_E(base) \
-    inline constexpr int base##C1 = opencv_m_detail::k_##base##C1, \
-                         base##C2 = opencv_m_detail::k_##base##C2, \
-                         base##C3 = opencv_m_detail::k_##base##C3, \
-                         base##C4 = opencv_m_detail::k_##base##C4;
-OPENCV_M_E(CV_8U) OPENCV_M_E(CV_8S) OPENCV_M_E(CV_16U) OPENCV_M_E(CV_16S)
-OPENCV_M_E(CV_32S) OPENCV_M_E(CV_32F) OPENCV_M_E(CV_64F) OPENCV_M_E(CV_16F)
-#undef OPENCV_M_E
-}
-
-// ── global-scope helpers (outside namespace cv upstream) ────────────────
-export using ::CpuFeatures;
-export using ::CPU_MMX;
-export using ::CPU_SSE;
-export using ::CPU_SSE2;
-export using ::CPU_SSE3;
-export using ::CPU_SSSE3;
-export using ::CPU_SSE4_1;
-export using ::CPU_SSE4_2;
-export using ::CPU_POPCNT;
-export using ::CPU_FP16;
-export using ::CPU_AVX;
-export using ::CPU_AVX2;
-export using ::CPU_FMA3;
-export using ::CPU_AVX512_SKX;
-export using ::CPU_NEON;
-export using ::CPU_MAX_FEATURE;
+export import mcpplibs.mwrap.opencv.detail.core;
+export import mcpplibs.mwrap.opencv.detail.matx;
diff --git a/src/core_fns.inc b/src/core_fns.inc
index c254dc3..6975dcf 100644
--- a/src/core_fns.inc
+++ b/src/core_fns.inc
@@ -32,18 +32,20 @@
 //
 // PRUNED (see tools/curated/core.prune.txt): cv::details::char_tolower /
 // char_toupper and cv::ipp::{setUseIPP_NE,useIPP_NE} (internal helpers, not
-// user API); the read()/write() FileStorage *convenience wrappers* over
-// geometry types (Matx/Vec/Point/Rect/…) — those are `static inline`
-// templates over TU-local cv::internal::{WriteStructContext,Vec*Proxy}
-// helpers that cannot be reached self-containedly; the CV_EXPORTS read()/
-// write() *primitives* (scalars/String/Mat/SparseMat/KeyPoint/DMatch) ARE
-// forwarded below.
+// user API). FileStorage's static-inline geometry/vector/enum and stream
+// helpers are adapted separately in generated persistence_ops.inc, including
+// module-private SDK vector proxies and custom-type ADL dispatch. The
+// CV_EXPORTS read()/write() primitives are forwarded below.
 
 // (cstdarg/cstdio are included in core.cppm's global module fragment so the
 // std::va_list / FILE machinery used below is attached to the global module,
 // not to opencv.core.)
 
 namespace opencv_m_fns_up {
+inline constexpr auto min_mmm = static_cast<void (*)(const cv::Mat&, const cv::Mat&, cv::Mat&)>(&cv::min);
+inline constexpr auto max_mmm = static_cast<void (*)(const cv::Mat&, const cv::Mat&, cv::Mat&)>(&cv::max);
+inline constexpr auto min_uuu = static_cast<void (*)(const cv::UMat&, const cv::UMat&, cv::UMat&)>(&cv::min);
+inline constexpr auto max_uuu = static_cast<void (*)(const cv::UMat&, const cv::UMat&, cv::UMat&)>(&cv::max);
 // ── abs (CV_EXPORTS Mat/MatExpr + external-inline softfloat) ────────────
 inline constexpr auto abs_m   = static_cast<cv::MatExpr   (*)(const cv::Mat&)>(&cv::abs);
 inline constexpr auto abs_e   = static_cast<cv::MatExpr   (*)(const cv::MatExpr&)>(&cv::abs);
@@ -120,43 +122,47 @@ public:
 } // namespace opencv_m_fns_detail
 
 export namespace cv {
+using std::min;
+using std::max;
 inline namespace opencv_m_repl {
 
-// scalar min/max (upstream cvstd.hpp does `using std::min/std::max`). We
-// cannot re-export std::min/std::max here: their 2-arg and 3-arg(Compare)
-// templates out-rank our Mat forwards in overload resolution (exact match vs
-// conversion-to-InputArray) and hijack cv::max(Mat,Mat)/cv::max(a,b,dst).
-// Instead expose arithmetic-only scalar forms — same result for the common
-// case, and is_arithmetic_v cleanly excludes Mat/MatExpr/Matx/softfloat so
-// those resolve to the dedicated overloads below.
-template<class _Tp> requires std::is_arithmetic_v<_Tp>
-inline const _Tp& min(const _Tp& a, const _Tp& b) { return a < b ? a : b; }
-template<class _Tp> requires std::is_arithmetic_v<_Tp>
-inline const _Tp& max(const _Tp& a, const _Tp& b) { return a > b ? a : b; }
+// Scalar/generic overloads retain the actual std entities imported by cvstd.hpp.
+// Mat/UMat three-argument forwards below preserve the SDK overloads that prevent
+// std's comparator overload from capturing image operations.
+template<class _D = void> requires opencv_m_pick<_D>
+inline void min(const Mat& a, const Mat& b, Mat& result) { ::opencv_m_fns_up::min_mmm(a, b, result); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline void max(const Mat& a, const Mat& b, Mat& result) { ::opencv_m_fns_up::max_mmm(a, b, result); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline void min(const UMat& a, const UMat& b, UMat& result) { ::opencv_m_fns_up::min_uuu(a, b, result); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline void max(const UMat& a, const UMat& b, UMat& result) { ::opencv_m_fns_up::max_uuu(a, b, result); }
 
 // ── trivial self-contained reimpls (upstream: static inline) ────────────
 // alignPtr / alignSize / divUp / roundUp / getElemSize — utility.hpp
 template<typename _Tp> requires opencv_m_pick<_Tp>
 inline _Tp* alignPtr(_Tp* ptr, int n = (int)sizeof(_Tp))
-{ return (_Tp*)(((size_t)ptr + n-1) & -n); }
+{ CV_DbgAssert((n & (n - 1)) == 0); return (_Tp*)(((size_t)ptr + n-1) & -n); }
 template<class _D = void> requires opencv_m_pick<_D>
-inline size_t alignSize(size_t sz, int n) { return (sz + n-1) & -n; }
+inline size_t alignSize(size_t sz, int n) { CV_DbgAssert((n & (n - 1)) == 0); return (sz + n-1) & -n; }
 template<class _D = void> requires opencv_m_pick<_D>
-inline int divUp(int a, unsigned int b) { return (a + b - 1) / b; }
+inline int divUp(int a, unsigned int b) { CV_DbgAssert(a >= 0); return (a + b - 1) / b; }
 template<class _D = void> requires opencv_m_pick<_D>
 inline size_t divUp(size_t a, unsigned int b) { return (a + b - 1) / b; }
 template<class _D = void> requires opencv_m_pick<_D>
-inline int roundUp(int a, unsigned int b) { return a + b - 1 - (a + b - 1) % b; }
+inline int roundUp(int a, unsigned int b) { CV_DbgAssert(a >= 0); return a + b - 1 - (a + b - 1) % b; }
 template<class _D = void> requires opencv_m_pick<_D>
 inline size_t roundUp(size_t a, unsigned int b) { return a + b - 1 - (a + b - 1) % b; }
 template<class _D = void> requires opencv_m_pick<_D>
 inline size_t getElemSize(int type) { return (size_t)CV_ELEM_SIZE(type); }
 
-// makePtr — cvstd_wrapper.hpp (static_assert on has_custom_delete dropped:
-// that trait is a TU-local GMF helper; the shared_ptr construction is the
-// operative body and the assert never fires for ordinary user types)
+// makePtr — preserve the upstream custom-deleter contract; the trait is now
+// exported as its original global-module entity.
 template<typename _Tp, typename ... A1> requires opencv_m_pick<_Tp>
-inline Ptr<_Tp> makePtr(const A1&... a1) { return (Ptr<_Tp>)std::make_shared<_Tp>(a1...); }
+inline Ptr<_Tp> makePtr(const A1&... a1) {
+    static_assert(!has_custom_delete<_Tp>::value, "Can't use this makePtr with custom DefaultDeleter");
+    return (Ptr<_Tp>)std::make_shared<_Tp>(a1...);
+}
 
 // to{Lower,Upper}Case — cvstd.hpp (char_tolower/char_toupper inlined as a
 // lambda so the body does not reference the pruned cv::details helpers)
diff --git a/src/core_ops.inc b/src/core_ops.inc
index a37907d..f8ab185 100644
--- a/src/core_ops.inc
+++ b/src/core_ops.inc
@@ -3,11 +3,10 @@
 // `static inline` (internal linkage): the namespace-scope operator templates
 // for the everyday value types, and saturate_cast which they depend on.
 //
-// These are self-contained reimplementations (no calls into TU-local
-// upstream helpers — importer-side template instantiation must not expose
-// them). Semantics follow upstream types.hpp; float→integer conversions
-// round to nearest-even (lrint), matching cvRound on every mainstream
-// target. Matx/Vec matrix algebra lives in matx_ops.inc (same rules).
+// SDK-generated value operators live in type_ops.inc; scalar conversions
+// live in saturate_ops.inc. This file owns the ordinary cvRound bridges,
+// shared constraint and Mat/MatExpr external-function forwards. Matx/Vec
+// algebra lives in matx_ops.inc.
 //
 // MIXED-TU STRATEGY (v0.0.3, gcc16-verified):
 // - TEMPLATE replacements carry the trivially-true `opencv_m_pick`
@@ -26,6 +25,13 @@
 // Net: every operator works in BOTH worlds — the v0.0.2 "prefer member
 // forms in mixed TUs" caveat is gone.
 
+// Non-inline module-private bridges preserve the SDK's exact platform rounding
+// without exposing its TU-local helpers through exported conversion templates.
+namespace opencv_m_scalar_bridge {
+int round32(float value) { return ::cvRound(value); }
+int round32(double value) { return ::cvRound(value); }
+}
+
 export namespace cv {
 // inline namespace: distinct entities from the upstream TU-local ones (no
 // in-module redefinition), yet reachable as cv::… via qualified lookup and
@@ -36,206 +42,13 @@ inline namespace opencv_m_repl {
 // CONSTRAINED than upstream's identical-signature one (see header comment)
 template<class> inline constexpr bool opencv_m_pick = true;
 
-// ── saturate_cast (upstream: static inline, core/saturate.hpp) ──────────
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(unsigned char v)      { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(signed char v)        { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(unsigned short v)     { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(short v)              { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(unsigned v)           { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(int v)                { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(float v)              { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(double v)             { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(long long v)          { return _Tp(v); }
-template<typename _Tp> requires opencv_m_pick<_Tp> constexpr _Tp saturate_cast(unsigned long long v) { return _Tp(v); }
-
-template<> inline unsigned char saturate_cast<unsigned char>(int v)
-{ return (unsigned char)((unsigned)v <= 255 ? v : v > 0 ? 255 : 0); }
-template<> inline unsigned char saturate_cast<unsigned char>(float v)
-{ return saturate_cast<unsigned char>((int)__builtin_lrintf(v)); }
-template<> inline unsigned char saturate_cast<unsigned char>(double v)
-{ return saturate_cast<unsigned char>((int)__builtin_lrint(v)); }
-template<> inline signed char saturate_cast<signed char>(int v)
-{ return (signed char)((unsigned)(v + 128) <= 255 ? v : v > 0 ? 127 : -128); }
-template<> inline signed char saturate_cast<signed char>(float v)
-{ return saturate_cast<signed char>((int)__builtin_lrintf(v)); }
-template<> inline signed char saturate_cast<signed char>(double v)
-{ return saturate_cast<signed char>((int)__builtin_lrint(v)); }
-template<> inline unsigned short saturate_cast<unsigned short>(int v)
-{ return (unsigned short)((unsigned)v <= 65535 ? v : v > 0 ? 65535 : 0); }
-template<> inline unsigned short saturate_cast<unsigned short>(float v)
-{ return saturate_cast<unsigned short>((int)__builtin_lrintf(v)); }
-template<> inline unsigned short saturate_cast<unsigned short>(double v)
-{ return saturate_cast<unsigned short>((int)__builtin_lrint(v)); }
-template<> inline short saturate_cast<short>(int v)
-{ return (short)((unsigned)(v + 32768) <= 65535 ? v : v > 0 ? 32767 : -32768); }
-template<> inline short saturate_cast<short>(float v)
-{ return saturate_cast<short>((int)__builtin_lrintf(v)); }
-template<> inline short saturate_cast<short>(double v)
-{ return saturate_cast<short>((int)__builtin_lrint(v)); }
-template<> inline int saturate_cast<int>(float v)  { return (int)__builtin_lrintf(v); }
-template<> inline int saturate_cast<int>(double v) { return (int)__builtin_lrint(v); }
-
-// ── Point_ ──────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Point_<_Tp>& a, const Point_<_Tp>& b)
-{ return a.x == b.x && a.y == b.y; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Point_<_Tp>& a, const Point_<_Tp>& b)
-{ return a.x != b.x || a.y != b.y; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator+(const Point_<_Tp>& a, const Point_<_Tp>& b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator-(const Point_<_Tp>& a, const Point_<_Tp>& b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator-(const Point_<_Tp>& a)
-{ return Point_<_Tp>(saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(const Point_<_Tp>& a, int b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(int a, const Point_<_Tp>& b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(const Point_<_Tp>& a, float b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(float a, const Point_<_Tp>& b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(const Point_<_Tp>& a, double b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator*(double a, const Point_<_Tp>& b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator/(const Point_<_Tp>& a, int b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x / b), saturate_cast<_Tp>(a.y / b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator/(const Point_<_Tp>& a, float b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x / b), saturate_cast<_Tp>(a.y / b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator/(const Point_<_Tp>& a, double b)
-{ return Point_<_Tp>(saturate_cast<_Tp>(a.x / b), saturate_cast<_Tp>(a.y / b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator+=(Point_<_Tp>& a, const Point_<_Tp>& b)
-{ a.x = saturate_cast<_Tp>(a.x + b.x); a.y = saturate_cast<_Tp>(a.y + b.y); return a; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator-=(Point_<_Tp>& a, const Point_<_Tp>& b)
-{ a.x = saturate_cast<_Tp>(a.x - b.x); a.y = saturate_cast<_Tp>(a.y - b.y); return a; }
-
-// ── Point3_ ─────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{ return a.x == b.x && a.y == b.y && a.z == b.z; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{ return a.x != b.x || a.y != b.y || a.z != b.z; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator+(const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{ return Point3_<_Tp>(saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y), saturate_cast<_Tp>(a.z + b.z)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator-(const Point3_<_Tp>& a, const Point3_<_Tp>& b)
-{ return Point3_<_Tp>(saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y), saturate_cast<_Tp>(a.z - b.z)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator-(const Point3_<_Tp>& a)
-{ return Point3_<_Tp>(saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y), saturate_cast<_Tp>(-a.z)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator*(const Point3_<_Tp>& a, double b)
-{ return Point3_<_Tp>(saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b), saturate_cast<_Tp>(a.z * b)); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator*(double a, const Point3_<_Tp>& b)
-{ return Point3_<_Tp>(saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a)); }
-
-// ── Size_ ───────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Size_<_Tp>& a, const Size_<_Tp>& b)
-{ return a.width == b.width && a.height == b.height; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Size_<_Tp>& a, const Size_<_Tp>& b)
-{ return a.width != b.width || a.height != b.height; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator+(const Size_<_Tp>& a, const Size_<_Tp>& b)
-{ return Size_<_Tp>(a.width + b.width, a.height + b.height); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator-(const Size_<_Tp>& a, const Size_<_Tp>& b)
-{ return Size_<_Tp>(a.width - b.width, a.height - b.height); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator*(const Size_<_Tp>& a, _Tp b)
-{ return Size_<_Tp>(a.width * b, a.height * b); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator/(const Size_<_Tp>& a, _Tp b)
-{ return Size_<_Tp>(a.width / b, a.height / b); }
-
-// ── Rect_ ───────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{ return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{ return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator+(const Rect_<_Tp>& a, const Point_<_Tp>& b)
-{ return Rect_<_Tp>(a.x + b.x, a.y + b.y, a.width, a.height); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator-(const Rect_<_Tp>& a, const Point_<_Tp>& b)
-{ return Rect_<_Tp>(a.x - b.x, a.y - b.y, a.width, a.height); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator+(const Rect_<_Tp>& a, const Size_<_Tp>& b)
-{ return Rect_<_Tp>(a.x, a.y, a.width + b.width, a.height + b.height); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator&(const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    _Tp x1 = a.x > b.x ? a.x : b.x;
-    _Tp y1 = a.y > b.y ? a.y : b.y;
-    _Tp x2 = (a.x + a.width < b.x + b.width ? a.x + a.width : b.x + b.width);
-    _Tp y2 = (a.y + a.height < b.y + b.height ? a.y + a.height : b.y + b.height);
-    if (x2 <= x1 || y2 <= y1) return Rect_<_Tp>();
-    return Rect_<_Tp>(x1, y1, x2 - x1, y2 - y1);
-}
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator|(const Rect_<_Tp>& a, const Rect_<_Tp>& b)
-{
-    if (a.width <= 0 || a.height <= 0) return b;
-    if (b.width <= 0 || b.height <= 0) return a;
-    _Tp x1 = a.x < b.x ? a.x : b.x;
-    _Tp y1 = a.y < b.y ? a.y : b.y;
-    _Tp x2 = (a.x + a.width > b.x + b.width ? a.x + a.width : b.x + b.width);
-    _Tp y2 = (a.y + a.height > b.y + b.height ? a.y + a.height : b.y + b.height);
-    return Rect_<_Tp>(x1, y1, x2 - x1, y2 - y1);
-}
-
-// ── Range ───────────────────────────────────────────────────────────────
-// upstream's are plain static-inline functions: ours must NOT tie with
-// them in mixed TUs (identical non-templates would be ambiguous), so they
-// are constrained templates — upstream wins there, we win in pure imports.
-template<class _Rg> requires __is_same(_Rg, Range)
-inline bool operator==(const _Rg& a, const Range& b) { return a.start == b.start && a.end == b.end; }
-template<class _Rg> requires __is_same(_Rg, Range)
-inline bool operator!=(const _Rg& a, const Range& b) { return a.start != b.start || a.end != b.end; }
-template<class _Rg> requires __is_same(_Rg, Range)
-inline bool operator!(const _Rg& r) { return r.start == r.end; }
-template<class _Rg> requires __is_same(_Rg, Range)
-inline Range operator&(const _Rg& a, const Range& b)
-{
-    Range r(a.start > b.start ? a.start : b.start, a.end < b.end ? a.end : b.end);
-    if (r.end < r.start) r.end = r.start;
-    return r;
-}
-// NOTE: these three mix a deduced `_Rg` with a hard-coded scalar (`int`)
-// parameter. Under clang, a trailing requires-clause is checked AFTER the
-// signature is substituted, so an ADL probe that deduces `_Rg=int` (e.g.
-// `int + <cv-scoped enum>` inside cv headers) makes clang form the invalid
-// operator `operator+(const int&, int)` and hard-error ("overloaded operator
-// must have at least one class/enum parameter") before the constraint can
-// exclude it. Moving the Range gate into a defaulted enable_if template
-// parameter makes the substitution fail earlier (SFINAE), so the invalid
-// specialization is never formed. gcc accepts both forms identically.
-template<class _Rg, std::enable_if_t<__is_same(_Rg, Range), int> = 0>
-inline Range operator+(const _Rg& r, int delta) { return Range(r.start + delta, r.end + delta); }
-template<class _Rg, std::enable_if_t<__is_same(_Rg, Range), int> = 0>
-inline Range operator+(int delta, const _Rg& r) { return Range(r.start + delta, r.end + delta); }
-template<class _Rg, std::enable_if_t<__is_same(_Rg, Range), int> = 0>
-inline Range operator-(const _Rg& r, int delta) { return Range(r.start - delta, r.end - delta); }
+#include "saturate_ops.inc"
 
-
-// ── Scalar_ ─────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{ return a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{ return a[0] != b[0] || a[1] != b[1] || a[2] != b[2] || a[3] != b[3]; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator+(const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{ return Scalar_<_Tp>(a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator-(const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
-{ return Scalar_<_Tp>(saturate_cast<_Tp>(a[0] - b[0]), saturate_cast<_Tp>(a[1] - b[1]),
-                      saturate_cast<_Tp>(a[2] - b[2]), saturate_cast<_Tp>(a[3] - b[3])); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator*(const Scalar_<_Tp>& a, _Tp alpha)
-{ return Scalar_<_Tp>(a[0] * alpha, a[1] * alpha, a[2] * alpha, a[3] * alpha); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator*(_Tp alpha, const Scalar_<_Tp>& a)
-{ return Scalar_<_Tp>(a[0] * alpha, a[1] * alpha, a[2] * alpha, a[3] * alpha); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator-(const Scalar_<_Tp>& a)
-{ return Scalar_<_Tp>(saturate_cast<_Tp>(-a[0]), saturate_cast<_Tp>(-a[1]),
-                      saturate_cast<_Tp>(-a[2]), saturate_cast<_Tp>(-a[3])); }
-
-// ── Complex ─────────────────────────────────────────────────────────────
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator==(const Complex<_Tp>& a, const Complex<_Tp>& b)
-{ return a.re == b.re && a.im == b.im; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator!=(const Complex<_Tp>& a, const Complex<_Tp>& b)
-{ return a.re != b.re || a.im != b.im; }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator+(const Complex<_Tp>& a, const Complex<_Tp>& b)
-{ return Complex<_Tp>(a.re + b.re, a.im + b.im); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator-(const Complex<_Tp>& a, const Complex<_Tp>& b)
-{ return Complex<_Tp>(a.re - b.re, a.im - b.im); }
-template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator*(const Complex<_Tp>& a, const Complex<_Tp>& b)
-{ return Complex<_Tp>(a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re); }
+// Point/Point3/Size/Rect/Range/Scalar/Complex operators are generated
+// from the pinned SDK in type_ops.inc, after Matx operators are available.
 
 } // inline namespace opencv_m_repl
-} // export namespace cv
+} // namespace cv
 
 // ── Mat / MatExpr operator delegation ───────────────────────────────────
 // Upstream declares these CV_EXPORTS (external) — but the plain
@@ -245,9 +58,8 @@ template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator*
 // (unique even though calls would be ambiguous), then re-expose it as a
 // delegating operator inside the exported inline namespace — as a
 // CONSTRAINED TEMPLATE, so in mixed TUs upstream's plain functions win
-// (no tie, no ambiguity) while pure-import TUs use these. `double`
-// parameters are loosened to any arithmetic type (callers write `m > 5`);
-// the delegation converts exactly like upstream's double parameter would.
+// (no tie, no ambiguity) while pure-import TUs use these. Original SDK
+// parameter types retain derived-class and implicit scalar conversions.
 namespace opencv_m_up {
 inline constexpr auto up_ne_sh_sh = static_cast<bool (*)(const cv::MatShape&, const cv::MatShape&)>(&cv::operator !=);
 inline constexpr auto up_eq_sh_sh = static_cast<bool (*)(const cv::MatShape&, const cv::MatShape&)>(&cv::operator ==);
@@ -317,133 +129,134 @@ inline constexpr auto up_div_d_e = static_cast<cv::MatExpr (*)(double, const cv:
 
 export namespace cv {
 inline namespace opencv_m_repl {
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatShape) && __is_same(_A1, cv::MatShape))
-inline bool operator != (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_ne_sh_sh(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatShape) && __is_same(_A1, cv::MatShape))
-inline bool operator == (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_eq_sh_sh(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator != (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_ne_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator & (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_and_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator * (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_mul_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator / (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_div_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator < (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_lt_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator <= (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_le_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator == (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_eq_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator > (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_gt_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator >= (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_ge_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator ^ (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_xor_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator | (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_or_m_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator & (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_and_m_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_m_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_m_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator ^ (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_xor_m_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator | (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_or_m_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator != (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_ne_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator * (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_mul_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator / (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_div_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator < (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_lt_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator <= (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_le_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator == (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_eq_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator > (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_gt_m_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator >= (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_ge_m_d(a0, a1); }
-template<class _A0> requires (__is_same(_A0, cv::MatExpr))
-inline cv::MatExpr operator - (const _A0& a0) { return ::opencv_m_up::up_sub_e(a0); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator * (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_mul_e_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_e_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_e_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator / (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_div_e_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator * (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_mul_e_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_e_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_e_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator / (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_div_e_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_e_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && __is_same(_A1, cv::Scalar))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_e_s(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator * (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_mul_e_d(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::MatExpr) && std::is_arithmetic_v<_A1>)
-inline cv::MatExpr operator / (const _A0& a0, _A1 a1) { return ::opencv_m_up::up_div_e_d(a0, a1); }
-template<class _A0> requires (__is_same(_A0, cv::Mat))
-inline cv::MatExpr operator - (const _A0& a0) { return ::opencv_m_up::up_sub_m(a0); }
-template<class _A0> requires (__is_same(_A0, cv::Mat))
-inline cv::MatExpr operator ~ (const _A0& a0) { return ::opencv_m_up::up_not_m(a0); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator * (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_mul_m_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_m_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_m_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Mat) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator / (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_div_m_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator & (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_and_s_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_s_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_s_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator ^ (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_xor_s_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator | (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_or_s_m(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator + (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_add_s_e(a0, a1); }
-template<class _A0, class _A1> requires (__is_same(_A0, cv::Scalar) && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator - (const _A0& a0, const _A1& a1) { return ::opencv_m_up::up_sub_s_e(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator != (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_ne_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator * (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_mul_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator / (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_div_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator < (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_lt_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator <= (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_le_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator == (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_eq_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator > (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_gt_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::Mat))
-inline cv::MatExpr operator >= (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_ge_d_m(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator * (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_mul_d_e(a0, a1); }
-template<class _A0, class _A1> requires (std::is_arithmetic_v<_A0> && __is_same(_A1, cv::MatExpr))
-inline cv::MatExpr operator / (_A0 a0, const _A1& a1) { return ::opencv_m_up::up_div_d_e(a0, a1); }
+// Original SDK parameter shapes preserve derived types and implicit conversions.
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator != (const cv::MatShape& a0, const cv::MatShape& a1) { return ::opencv_m_up::up_ne_sh_sh(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator == (const cv::MatShape& a0, const cv::MatShape& a1) { return ::opencv_m_up::up_eq_sh_sh(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator != (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_ne_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator & (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_and_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_mul_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_add_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_sub_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_div_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator < (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_lt_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator <= (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_le_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator == (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_eq_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator > (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_gt_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator >= (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_ge_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator ^ (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_xor_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator | (const cv::Mat& a0, const cv::Mat& a1) { return ::opencv_m_up::up_or_m_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator & (const cv::Mat& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_and_m_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::Mat& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_add_m_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Mat& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_sub_m_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator ^ (const cv::Mat& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_xor_m_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator | (const cv::Mat& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_or_m_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator != (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_ne_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_mul_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_div_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator < (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_lt_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator <= (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_le_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator == (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_eq_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator > (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_gt_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator >= (const cv::Mat& a0, double a1) { return ::opencv_m_up::up_ge_m_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::MatExpr& a0) { return ::opencv_m_up::up_sub_e(a0); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::MatExpr& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_mul_e_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::MatExpr& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_add_e_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::MatExpr& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_sub_e_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::MatExpr& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_div_e_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::MatExpr& a0, const cv::Mat& a1) { return ::opencv_m_up::up_mul_e_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::MatExpr& a0, const cv::Mat& a1) { return ::opencv_m_up::up_add_e_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::MatExpr& a0, const cv::Mat& a1) { return ::opencv_m_up::up_sub_e_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::MatExpr& a0, const cv::Mat& a1) { return ::opencv_m_up::up_div_e_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::MatExpr& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_add_e_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::MatExpr& a0, const cv::Scalar& a1) { return ::opencv_m_up::up_sub_e_s(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::MatExpr& a0, double a1) { return ::opencv_m_up::up_mul_e_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::MatExpr& a0, double a1) { return ::opencv_m_up::up_div_e_d(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Mat& a0) { return ::opencv_m_up::up_sub_m(a0); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator ~ (const cv::Mat& a0) { return ::opencv_m_up::up_not_m(a0); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (const cv::Mat& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_mul_m_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::Mat& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_add_m_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Mat& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_sub_m_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (const cv::Mat& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_div_m_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator & (const cv::Scalar& a0, const cv::Mat& a1) { return ::opencv_m_up::up_and_s_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::Scalar& a0, const cv::Mat& a1) { return ::opencv_m_up::up_add_s_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Scalar& a0, const cv::Mat& a1) { return ::opencv_m_up::up_sub_s_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator ^ (const cv::Scalar& a0, const cv::Mat& a1) { return ::opencv_m_up::up_xor_s_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator | (const cv::Scalar& a0, const cv::Mat& a1) { return ::opencv_m_up::up_or_s_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator + (const cv::Scalar& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_add_s_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator - (const cv::Scalar& a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_sub_s_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator != (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_ne_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_mul_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_div_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator < (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_lt_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator <= (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_le_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator == (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_eq_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator > (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_gt_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator >= (double a0, const cv::Mat& a1) { return ::opencv_m_up::up_ge_d_m(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator * (double a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_mul_d_e(a0, a1); }
+template<class _D = void> requires opencv_m_pick<_D>
+inline cv::MatExpr operator / (double a0, const cv::MatExpr& a1) { return ::opencv_m_up::up_div_d_e(a0, a1); }
 } // inline namespace opencv_m_repl
 } // export namespace cv
diff --git a/src/core_simd.cppm b/src/core_simd.cppm
new file mode 100644
index 0000000..440b00a
--- /dev/null
+++ b/src/core_simd.cppm
@@ -0,0 +1,4 @@
+// Pure aggregation keeps GCC's GMF/default-argument merge separate from imports.
+export module mcpplibs.mwrap.opencv.core.simd;
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.detail.simd;
diff --git a/src/core_simd_legacy.cppm b/src/core_simd_legacy.cppm
new file mode 100644
index 0000000..5ab9952
--- /dev/null
+++ b/src/core_simd_legacy.cppm
@@ -0,0 +1,4 @@
+// Like the upstream compatibility header, legacy operators require explicit opt-in.
+export module mcpplibs.mwrap.opencv.core.simd.legacy;
+export import mcpplibs.mwrap.opencv.core.simd;
+export import mcpplibs.mwrap.opencv.detail.simd_legacy;
diff --git a/src/cuda_helpers.inc b/src/cuda_helpers.inc
new file mode 100644
index 0000000..5c5abee
--- /dev/null
+++ b/src/cuda_helpers.inc
@@ -0,0 +1,204 @@
+// Generated by tools/generate_cuda_helpers.py; original SDK bodies retained.
+// SDK source: core/cuda.inl.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+namespace opencv_m_cuda_up {
+inline constexpr auto create = static_cast<void (*)(int, int, int, cv::OutputArray)>(&cv::cuda::createContinuous);
+inline constexpr auto ensure = static_cast<void (*)(int, int, int, cv::OutputArray)>(&cv::cuda::ensureSizeIsEnough);
+}
+export namespace cv { namespace cuda { inline namespace opencv_m_cuda_repl {
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void createContinuous(int rows, int cols, int type, OutputArray arr);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void ensureSizeIsEnough(int rows, int cols, int type, OutputArray arr);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline GpuMat createContinuous(int rows, int cols, int type);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void createContinuous(Size size, int type, OutputArray arr);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline GpuMat createContinuous(Size size, int type);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void ensureSizeIsEnough(Size size, int type, OutputArray arr);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void swap(GpuMat& a, GpuMat& b);
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void swap(HostMem& a, HostMem& b);
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void createContinuous(int rows, int cols, int type, OutputArray arr)
+{ ::opencv_m_cuda_up::create(rows, cols, type, arr); }
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void ensureSizeIsEnough(int rows, int cols, int type, OutputArray arr)
+{ ::opencv_m_cuda_up::ensure(rows, cols, type, arr); }
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline GpuMat createContinuous(int rows, int cols, int type)
+{
+    GpuMat m;
+    ::cv::cuda::opencv_m_cuda_repl::createContinuous(rows, cols, type, m);
+    return m;
+}
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void createContinuous(Size size, int type, OutputArray arr)
+{
+    ::cv::cuda::opencv_m_cuda_repl::createContinuous(size.height, size.width, type, arr);
+}
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline GpuMat createContinuous(Size size, int type)
+{
+    GpuMat m;
+    ::cv::cuda::opencv_m_cuda_repl::createContinuous(size, type, m);
+    return m;
+}
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void ensureSizeIsEnough(Size size, int type, OutputArray arr)
+{
+    ::cv::cuda::opencv_m_cuda_repl::ensureSizeIsEnough(size.height, size.width, type, arr);
+}
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void swap(GpuMat& a, GpuMat& b)
+{
+    a.swap(b);
+}
+
+template<class _D> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline void swap(HostMem& a, HostMem& b)
+{
+    a.swap(b);
+}
+} } } // cv::cuda::opencv_m_cuda_repl
+// SDK source: core/cvdef.h
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { namespace cuda { inline namespace opencv_m_cuda_repl {
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline bool operator!(const Event::CreateFlags& val)
+{
+    typedef std::underlying_type<Event::CreateFlags>::type UnderlyingType;
+    return !static_cast<UnderlyingType>(val);
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline bool operator==(const Event::CreateFlags& a, const int& b)
+{
+    return static_cast<int>(a) == static_cast<int>(b);
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline bool operator!=(const Event::CreateFlags& a, const int& b)
+{
+    return static_cast<int>(a) != static_cast<int>(b);
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags operator~(const Event::CreateFlags& val)
+{
+    typedef std::underlying_type<Event::CreateFlags>::type UnderlyingType;
+    return static_cast<Event::CreateFlags>(~static_cast<UnderlyingType>(val));
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags operator|(const Event::CreateFlags& a, const Event::CreateFlags& b)
+{
+    typedef std::underlying_type<Event::CreateFlags>::type UnderlyingType;
+    return static_cast<Event::CreateFlags>(static_cast<UnderlyingType>(a) | static_cast<UnderlyingType>(b));
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags operator&(const Event::CreateFlags& a, const Event::CreateFlags& b)
+{
+    typedef std::underlying_type<Event::CreateFlags>::type UnderlyingType;
+    return static_cast<Event::CreateFlags>(static_cast<UnderlyingType>(a) & static_cast<UnderlyingType>(b));
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags operator^(const Event::CreateFlags& a, const Event::CreateFlags& b)
+{
+    typedef std::underlying_type<Event::CreateFlags>::type UnderlyingType;
+    return static_cast<Event::CreateFlags>(static_cast<UnderlyingType>(a) ^ static_cast<UnderlyingType>(b));
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags& operator|=(Event::CreateFlags& _this, const Event::CreateFlags& val)
+{
+    _this = static_cast<Event::CreateFlags>(static_cast<int>(_this) | static_cast<int>(val));
+    return _this;
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags& operator&=(Event::CreateFlags& _this, const Event::CreateFlags& val)
+{
+    _this = static_cast<Event::CreateFlags>(static_cast<int>(_this) & static_cast<int>(val));
+    return _this;
+}
+
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline Event::CreateFlags& operator^=(Event::CreateFlags& _this, const Event::CreateFlags& val)
+{
+    _this = static_cast<Event::CreateFlags>(static_cast<int>(_this) ^ static_cast<int>(val));
+    return _this;
+}
+
+} } } // cv::cuda::opencv_m_cuda_repl
diff --git a/src/cv.cppm b/src/cv.cppm
index d5bdb18..2d02fcf 100644
--- a/src/cv.cppm
+++ b/src/cv.cppm
@@ -1,12 +1,2 @@
-// opencv.cv — umbrella module: the `import opencv.cv;` analog of
-// `#include <opencv2/opencv.hpp>` / Python's `import cv2` for the modules
-// enabled in this build profile.
 export module opencv.cv;
-
-export import opencv.core;
-export import opencv.imgproc;
-export import opencv.imgcodecs;
-export import opencv.videoio;
-export import opencv.highgui;
-export import opencv.flann;
-export import opencv.geometry;
+export import mcpplibs.mwrap.opencv;
diff --git a/src/detail/calib.cppm b/src/detail/calib.cppm
new file mode 100644
index 0000000..ce21f8a
--- /dev/null
+++ b/src/detail/calib.cppm
@@ -0,0 +1,7 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/calib.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.calib;
+
+#include "../gen_exports/calib.inc"
diff --git a/src/detail/core.cppm b/src/detail/core.cppm
new file mode 100644
index 0000000..a8b9c40
--- /dev/null
+++ b/src/detail/core.cppm
@@ -0,0 +1,45 @@
+// opencv.core — C++23 module over OpenCV 5 core. The C++ API is unchanged:
+// external API entities retain their SDK identity through `export using`.
+// TU-local helpers use SDK-body adapters or exact platform function forwards.
+// Function-like macros (CV_Assert, CV_Error,
+// …) cannot cross a module boundary — include <mwrap/opencv/macros.hpp> BEFORE
+// importing when you need them.
+module;
+#include <cstdarg>   // va_list/va_start/va_copy/va_end — cv::format printf reimpl (core_fns.inc)
+#include <cstdio>    // vsnprintf/fputs/FILE/stdout — cv::format / cv::print reimpls (core_fns.inc)
+#include <sstream>
+#include <opencv2/core.hpp>
+#include <opencv2/core/hal/hal.hpp>
+#include <opencv2/core/llapi/llapi.h>
+#include <opencv2/core/affine.hpp>
+#include <opencv2/core/async.hpp>
+#include <opencv2/core/bindings_utils.hpp>
+#include <opencv2/core/cuda.hpp>
+#include <opencv2/core/detail/async_promise.hpp>
+#include <opencv2/core/dualquaternion.hpp>
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/core/opengl.hpp>
+#include <opencv2/core/parallel/parallel_backend.hpp>
+#include <opencv2/core/quaternion.hpp>
+#include <opencv2/core/softfloat.hpp>
+#include <opencv2/core/utils/allocator_stats.hpp>
+#include <opencv2/core/utils/filesystem.hpp>
+#include <opencv2/core/utils/fp_control_utils.hpp>
+#include <opencv2/core/utils/instrumentation.hpp>
+#include <opencv2/core/utils/logger.hpp>
+#include <opencv2/core/utils/tls.hpp>
+#include <opencv2/core/version.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.core;
+
+#include "../gen_exports/core.inc"
+#include "../core_ops.inc"
+#include "../type_ops.inc"
+#include "../core_fns.inc"
+#include "../portable_helpers.inc"
+#include "../fast_math_helpers.inc"
+#include "../cuda_helpers.inc"
+#include "../utils_helpers.inc"
+#include "../persistence_ops.inc"
+#include "../instrumentation_ops.inc"
+#include "../affine_ops.inc"
diff --git a/src/detail/dnn.cppm b/src/detail/dnn.cppm
new file mode 100644
index 0000000..712c476
--- /dev/null
+++ b/src/detail/dnn.cppm
@@ -0,0 +1,42 @@
+// opencv.dnn — C++23 module over OpenCV 5's deep-learning module (API
+// unchanged). OPTIONAL: this file is compiled only when the package `dnn`
+// feature is enabled, which also builds the vendored dnn module sources
+// (+ vendored protobuf + mlas) into the library. It is
+// selected explicitly or by all-modules — consumers can import it directly with
+// `import mcpplibs.mwrap.opencv.dnn;` (Net, blobFromImage, readNet, NMSBoxes, …).
+module;
+#include <opencv2/dnn.hpp>
+// <opencv2/dnn.hpp> pulls in only the core dnn surface (Net, blobFromImage,
+// readNet, Model classes, Backend/Target). The 181 Layer types + ACTIV_/
+// AUTO_PAD_ enums live in this separate public header — include it so they are
+// visible to the `export using` list below.
+#include <opencv2/dnn/all_layers.hpp>
+#include <opencv2/dnn/shape_utils.hpp>
+#include <opencv2/dnn/utils/inference_engine.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.dnn;
+
+#include "../gen_exports/dnn.inc"
+
+export namespace cv::dnn {
+CV__DNN_INLINE_NS_BEGIN
+// Preserve both the public name and its original ABI namespace spelling.
+using ::cv::dnn::CV__DNN_INLINE_NS::operator==;
+inline namespace opencv_m_shape {
+template<class> inline constexpr bool shape_pick = true;
+#include "../dnn_shapes.inc"
+}
+CV__DNN_INLINE_NS_END
+using CV__DNN_INLINE_NS::operator==;
+using CV__DNN_INLINE_NS::opencv_m_shape::slice;
+using CV__DNN_INLINE_NS::opencv_m_shape::getPlane;
+using CV__DNN_INLINE_NS::opencv_m_shape::shape;
+using CV__DNN_INLINE_NS::opencv_m_shape::total;
+using CV__DNN_INLINE_NS::opencv_m_shape::concat;
+using CV__DNN_INLINE_NS::opencv_m_shape::toString;
+using CV__DNN_INLINE_NS::opencv_m_shape::print;
+using CV__DNN_INLINE_NS::opencv_m_shape::operator<<;
+using CV__DNN_INLINE_NS::opencv_m_shape::normalize_axis;
+using CV__DNN_INLINE_NS::opencv_m_shape::normalize_axis_range;
+using CV__DNN_INLINE_NS::opencv_m_shape::isAllOnes;
+}
diff --git a/src/detail/features.cppm b/src/detail/features.cppm
new file mode 100644
index 0000000..482536e
--- /dev/null
+++ b/src/detail/features.cppm
@@ -0,0 +1,8 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/features.hpp>
+#include <opencv2/features/hal/interface.h>
+
+export module mcpplibs.mwrap.opencv.detail.features;
+
+#include "../gen_exports/features.inc"
diff --git a/src/detail/flann.cppm b/src/detail/flann.cppm
new file mode 100644
index 0000000..98277ad
--- /dev/null
+++ b/src/detail/flann.cppm
@@ -0,0 +1,7 @@
+// opencv.flann — C++23 module over OpenCV 5 flann (API unchanged).
+module;
+#include <opencv2/flann.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.flann;
+
+#include "../gen_exports/flann.inc"
diff --git a/src/detail/geometry.cppm b/src/detail/geometry.cppm
new file mode 100644
index 0000000..8a56af3
--- /dev/null
+++ b/src/detail/geometry.cppm
@@ -0,0 +1,9 @@
+// opencv.geometry — C++23 module over OpenCV 5 geometry (API unchanged).
+module;
+#include <opencv2/geometry.hpp>
+#include <opencv2/geometry/mst.hpp>
+#include <opencv2/geometry/detail/optimizer.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.geometry;
+
+#include "../gen_exports/geometry.inc"
diff --git a/src/detail/highgui.cppm b/src/detail/highgui.cppm
new file mode 100644
index 0000000..df88e06
--- /dev/null
+++ b/src/detail/highgui.cppm
@@ -0,0 +1,8 @@
+// opencv.highgui — C++23 module over OpenCV 5 highgui (API unchanged;
+// headless backend in this build profile).
+module;
+#include <opencv2/highgui.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.highgui;
+
+#include "../gen_exports/highgui.inc"
diff --git a/src/detail/imgcodecs.cppm b/src/detail/imgcodecs.cppm
new file mode 100644
index 0000000..35939b4
--- /dev/null
+++ b/src/detail/imgcodecs.cppm
@@ -0,0 +1,8 @@
+// opencv.imgcodecs — C++23 module over OpenCV 5 imgcodecs (API unchanged).
+module;
+#include <opencv2/imgcodecs.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.imgcodecs;
+
+#include "../gen_exports/imgcodecs.inc"
+#include "../imgcodecs_helpers.inc"
diff --git a/src/detail/imgproc.cppm b/src/detail/imgproc.cppm
new file mode 100644
index 0000000..7a44479
--- /dev/null
+++ b/src/detail/imgproc.cppm
@@ -0,0 +1,9 @@
+// opencv.imgproc — C++23 module over OpenCV 5 imgproc (API unchanged).
+module;
+#include <opencv2/imgproc.hpp>
+#include <opencv2/imgproc/hal/hal.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.imgproc;
+
+#include "../gen_exports/imgproc.inc"
+#include "../imgproc_helpers.inc"
diff --git a/src/detail/matx.cppm b/src/detail/matx.cppm
new file mode 100644
index 0000000..95e8639
--- /dev/null
+++ b/src/detail/matx.cppm
@@ -0,0 +1,6 @@
+// Exact SDK template shapes over already imported original class declarations.
+export module mcpplibs.mwrap.opencv.detail.matx;
+
+import mcpplibs.mwrap.opencv.detail.core;
+#include "../matx_ops.inc"
+#include "../mat_aug_ops.inc"
diff --git a/src/detail/objdetect.cppm b/src/detail/objdetect.cppm
new file mode 100644
index 0000000..d81165a
--- /dev/null
+++ b/src/detail/objdetect.cppm
@@ -0,0 +1,8 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/objdetect.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.objdetect;
+
+#include "../gen_exports/objdetect.inc"
+#include "../objdetect_constants.inc"
diff --git a/src/detail/photo.cppm b/src/detail/photo.cppm
new file mode 100644
index 0000000..9ca5eaa
--- /dev/null
+++ b/src/detail/photo.cppm
@@ -0,0 +1,9 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/photo.hpp>
+#include <opencv2/photo/cuda.hpp>
+#include <opencv2/photo/legacy/constants_c.h>
+
+export module mcpplibs.mwrap.opencv.detail.photo;
+
+#include "../gen_exports/photo.inc"
diff --git a/src/detail/ptcloud.cppm b/src/detail/ptcloud.cppm
new file mode 100644
index 0000000..5f4f065
--- /dev/null
+++ b/src/detail/ptcloud.cppm
@@ -0,0 +1,8 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/ptcloud.hpp>
+#include <opencv2/ptcloud/detail/kinfu_frame.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.ptcloud;
+
+#include "../gen_exports/ptcloud.inc"
diff --git a/src/detail/simd.cppm b/src/detail/simd.cppm
new file mode 100644
index 0000000..d486962
--- /dev/null
+++ b/src/detail/simd.cppm
@@ -0,0 +1,10 @@
+// Original OpenCV intrinsics for the selected library baseline; no SDK type copies.
+module;
+#include <mwrap/opencv/simd.hpp>
+
+#if !defined(MCPP_FEATURE_SIMD_EMULATED) && !CV_SSE2 && !(CV_NEON && (defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)))
+#error "opencv-m simd currently requires an x86_64 SSE2 or ARM64 NEON baseline"
+#endif
+
+export module mcpplibs.mwrap.opencv.detail.simd;
+#include "../simd_exports.inc"
diff --git a/src/detail/simd_legacy.cppm b/src/detail/simd_legacy.cppm
new file mode 100644
index 0000000..65ead43
--- /dev/null
+++ b/src/detail/simd_legacy.cppm
@@ -0,0 +1,6 @@
+module;
+#include <mwrap/opencv/simd.hpp>
+#include <opencv2/core/hal/intrin_legacy_ops.h>
+
+export module mcpplibs.mwrap.opencv.detail.simd_legacy;
+#include "../simd_legacy_exports.inc"
diff --git a/src/detail/stereo.cppm b/src/detail/stereo.cppm
new file mode 100644
index 0000000..ddb1314
--- /dev/null
+++ b/src/detail/stereo.cppm
@@ -0,0 +1,7 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/stereo.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.stereo;
+
+#include "../gen_exports/stereo.inc"
diff --git a/src/detail/stitching.cppm b/src/detail/stitching.cppm
new file mode 100644
index 0000000..3516001
--- /dev/null
+++ b/src/detail/stitching.cppm
@@ -0,0 +1,9 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/stitching.hpp>
+#include <opencv2/stitching/detail/autocalib.hpp>
+#include <opencv2/stitching/detail/timelapsers.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.stitching;
+
+#include "../gen_exports/stitching.inc"
diff --git a/src/detail/video.cppm b/src/detail/video.cppm
new file mode 100644
index 0000000..00c48b0
--- /dev/null
+++ b/src/detail/video.cppm
@@ -0,0 +1,9 @@
+// C++ module adapter; upstream cv:: names remain unchanged.
+module;
+#include <opencv2/video.hpp>
+#include <opencv2/video/detail/tracking.detail.hpp>
+#include <opencv2/video/legacy/constants_c.h>
+
+export module mcpplibs.mwrap.opencv.detail.video;
+
+#include "../gen_exports/video.inc"
diff --git a/src/detail/videoio.cppm b/src/detail/videoio.cppm
new file mode 100644
index 0000000..a1a5dfb
--- /dev/null
+++ b/src/detail/videoio.cppm
@@ -0,0 +1,8 @@
+// opencv.videoio — C++23 module over OpenCV 5 videoio (API unchanged).
+module;
+#include <opencv2/videoio.hpp>
+#include <opencv2/videoio/registry.hpp>
+
+export module mcpplibs.mwrap.opencv.detail.videoio;
+
+#include "../gen_exports/videoio.inc"
diff --git a/src/dnn.cppm b/src/dnn.cppm
index b61e8da..88cf6f3 100644
--- a/src/dnn.cppm
+++ b/src/dnn.cppm
@@ -1,17 +1,7 @@
-// opencv.dnn — C++23 module over OpenCV 5's deep-learning module (API
-// unchanged). OPTIONAL: this file is compiled only when the package `dnn`
-// feature is enabled, which also builds the vendored dnn module sources
-// (+ vendored protobuf + mlas) into the library. It is
-// deliberately NOT part of the `opencv.cv` umbrella — consumers opt in with
-// `import opencv.dnn;` (Net, blobFromImage, readNet, NMSBoxes, …).
-module;
-#include <opencv2/dnn.hpp>
-// <opencv2/dnn.hpp> pulls in only the core dnn surface (Net, blobFromImage,
-// readNet, Model classes, Backend/Target). The 181 Layer types + ACTIV_/
-// AUTO_PAD_ enums live in this separate public header — include it so they are
-// visible to the `export using` list below.
-#include <opencv2/dnn/all_layers.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.dnn;
 
-export module opencv.dnn;
-
-#include "gen_exports/dnn.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.dnn;
diff --git a/src/dnn_shapes.inc b/src/dnn_shapes.inc
new file mode 100644
index 0000000..a3420aa
--- /dev/null
+++ b/src/dnn_shapes.inc
@@ -0,0 +1,253 @@
+// Generated by tools/generate_dnn_shapes.py. Included inside the exported shape adapter.
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+template<class _D = void> requires shape_pick<_D> inline Mat slice(const Mat &m, const _Range &r0)
+{
+    Range ranges[CV_MAX_DIM];
+    for (int i = 1; i < m.dims; i++)
+        ranges[i] = Range::all();
+    ranges[0] = r0;
+    return m(&ranges[0]);
+}
+
+template<class _D = void> requires shape_pick<_D> inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1)
+{
+    CV_Assert(m.dims >= 2);
+    Range ranges[CV_MAX_DIM];
+    for (int i = 2; i < m.dims; i++)
+        ranges[i] = Range::all();
+    ranges[0] = r0;
+    ranges[1] = r1;
+    return m(&ranges[0]);
+}
+
+template<class _D = void> requires shape_pick<_D> inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1, const _Range &r2)
+{
+    CV_Assert(m.dims >= 3);
+    Range ranges[CV_MAX_DIM];
+    for (int i = 3; i < m.dims; i++)
+        ranges[i] = Range::all();
+    ranges[0] = r0;
+    ranges[1] = r1;
+    ranges[2] = r2;
+    return m(&ranges[0]);
+}
+
+template<class _D = void> requires shape_pick<_D> inline Mat slice(const Mat &m, const _Range &r0, const _Range &r1, const _Range &r2, const _Range &r3)
+{
+    CV_Assert(m.dims >= 4);
+    Range ranges[CV_MAX_DIM];
+    for (int i = 4; i < m.dims; i++)
+        ranges[i] = Range::all();
+    ranges[0] = r0;
+    ranges[1] = r1;
+    ranges[2] = r2;
+    ranges[3] = r3;
+    return m(&ranges[0]);
+}
+
+template<class _D = void> requires shape_pick<_D> inline Mat getPlane(const Mat &m, int n, int cn)
+{
+    CV_Assert(m.dims > 2);
+    int sz[CV_MAX_DIM];
+    for(int i = 2; i < m.dims; i++)
+    {
+        sz[i-2] = m.size.p[i];
+    }
+    return Mat(m.dims - 2, sz, m.type(), (void*)m.ptr<float>(n, cn));
+}
+
+template<class _D = void> requires shape_pick<_D> inline MatShape shape(const int* dims, const int n)
+{
+    MatShape shape;
+    shape.assign(dims, dims + n);
+    return shape;
+}
+
+template<class _D = void> requires shape_pick<_D> inline MatShape shape(const Mat& mat)
+{
+    return mat.shape();
+}
+
+template<class _D = void> requires shape_pick<_D> inline MatShape shape(const UMat& mat)
+{
+    return mat.shape();
+}
+
+
+
+
+
+template<class _D = void> requires shape_pick<_D> inline MatShape shape(int a0, int a1=-1, int a2=-1, int a3=-1)
+{
+    int shape_[] = {a0, a1, a2, a3};
+    int dims = 1 + (a1 >= 0) + (a1 >= 0 && a2 >= 0) + (a1 >= 0 && a2 >= 0 && a3 >= 0);
+    return ::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::shape(shape_, dims);
+}
+
+template<class _D = void> requires shape_pick<_D> inline size_t total(const MatShape& shape, int start = -1, int end = -1)
+{
+    //if (shape.empty())
+    //    return 0;
+
+    int dims = (int)shape.size();
+
+    if (start == -1) start = 0;
+    if (end == -1) end = dims;
+
+    CV_CheckLE(0, start, "");
+    CV_CheckLE(start, end, "");
+    CV_CheckLE(end, dims, "");
+
+    size_t elems = 1;
+    for (int i = start; i < end; i++)
+    {
+        elems *= (size_t)shape[i];
+    }
+    return elems;
+}
+
+// TODO: rename to countDimsElements()
+template<class _D = void> requires shape_pick<_D> inline size_t total(const Mat& mat, int start = -1, int end = -1)
+{
+    if (mat.empty())
+        return 0;
+
+    int dims = mat.dims;
+
+    if (start == -1) start = 0;
+    if (end == -1) end = dims;
+
+    CV_CheckLE(0, start, "");
+    CV_CheckLE(start, end, "");
+    CV_CheckLE(end, dims, "");
+
+    size_t elems = 1;
+    for (int i = start; i < end; i++)
+    {
+        elems *= (size_t)mat.size[i];
+    }
+    return elems;
+}
+
+template<class _D = void> requires shape_pick<_D> inline MatShape concat(const MatShape& a, const MatShape& b)
+{
+    MatShape c = a;
+    size_t a_size = a.size(), b_size = b.size(), c_size = a_size + b_size;
+    c.resize(c_size);
+    for (size_t i = 0; i < b_size; i++) {
+        c[i+a_size] = b[i];
+    }
+    return c;
+}
+
+template<class _D = void> requires shape_pick<_D> inline std::string toString(const MatShape& shape, const String& name = "")
+{
+    std::ostringstream ss;
+    if (!name.empty())
+        ss << name << ' ';
+    ss << shape;
+    return ss.str();
+}
+
+template<typename _Tp> requires shape_pick<_Tp> inline std::string toString(const std::vector<_Tp>& shape, const String& name = "")
+{
+    std::ostringstream ss;
+    if (!name.empty())
+        ss << name << ' ';
+    ss << '[';
+    for(size_t i = 0, n = shape.size(); i < n; ++i)
+        ss << ' ' << shape[i];
+    ss << " ]";
+    return ss.str();
+}
+
+template<typename _Tp> requires shape_pick<_Tp> inline void print(const std::vector<_Tp>& shape, const String& name = "")
+{
+    std::cout << ::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::toString(shape, name) << std::endl;
+}
+template<typename _Tp> requires shape_pick<_Tp> inline std::ostream& operator<<(std::ostream &out, const std::vector<_Tp>& shape)
+{
+    out << ::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::toString(shape);
+    return out;
+}
+
+/// @brief Converts axis from `[-dims; dims)` (similar to Python's slice notation) to `[0; dims)` range.
+template<class _D = void> requires shape_pick<_D> inline int normalize_axis(int axis, int dims)
+{
+    CV_Assert(dims >= 0);
+    CV_Check(axis, axis >= -dims && axis <= dims, "");
+    axis = (unsigned)axis < (unsigned)dims ? axis : axis < 0 ? axis + dims : axis - dims;
+    return axis;
+}
+
+template<class _D = void> requires shape_pick<_D> inline int normalize_axis(int axis, const MatShape& shape)
+{
+    return ::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::normalize_axis(axis, (int)shape.size());
+}
+
+template<class _D = void> requires shape_pick<_D> inline Range normalize_axis_range(const Range& r, int axisSize)
+{
+    if (r == Range::all() || r == Range(0, INT_MAX))
+        return Range(0, axisSize);
+    CV_CheckGE(r.start, 0, "");
+    Range clamped(r.start,
+                  r.end > 0 ? std::min(r.end, axisSize) : axisSize + r.end + 1);
+    CV_DbgCheckGE(clamped.start, 0, "");
+    CV_CheckLT(clamped.start, clamped.end, "");
+    CV_CheckLE(clamped.end, axisSize, "");
+    return clamped;
+}
+
+template<class _D = void> requires shape_pick<_D> inline bool isAllOnes(const MatShape &inputShape, int startPos, int endPos)
+{
+    CV_CheckGE(startPos, 0, "");
+    CV_CheckLE(startPos, endPos, "");
+    CV_CheckLE(endPos, inputShape.dims, "");
+
+    for (int i = startPos; i < endPos; i++)
+    {
+        if (inputShape[i] != 1)
+            return false;
+    }
+    return true;
+}
diff --git a/src/fast_math_helpers.inc b/src/fast_math_helpers.inc
new file mode 100644
index 0000000..3c97880
--- /dev/null
+++ b/src/fast_math_helpers.inc
@@ -0,0 +1,65 @@
+// Generated by tools/generate_inline_helpers.py; exact SDK platform function forwards.
+namespace opencv_m_fast_math_bridge {
+int cvRound(double value) { return ::cvRound(value); }
+int cvFloor(double value) { return ::cvFloor(value); }
+int cvCeil(double value) { return ::cvCeil(value); }
+int cvIsNaN(double value) { return ::cvIsNaN(value); }
+int cvIsInf(double value) { return ::cvIsInf(value); }
+int cvRound(float value) { return ::cvRound(value); }
+int cvRound(int value) { return ::cvRound(value); }
+int cvFloor(float value) { return ::cvFloor(value); }
+int cvFloor(int value) { return ::cvFloor(value); }
+int cvCeil(float value) { return ::cvCeil(value); }
+int cvCeil(int value) { return ::cvCeil(value); }
+int cvIsNaN(float value) { return ::cvIsNaN(value); }
+int cvIsInf(float value) { return ::cvIsInf(value); }
+int cvRound(const cv::softfloat& value) { return ::cvRound(value); }
+int cvRound(const cv::softdouble& value) { return ::cvRound(value); }
+int cvFloor(const cv::softfloat& value) { return ::cvFloor(value); }
+int cvFloor(const cv::softdouble& value) { return ::cvFloor(value); }
+int cvCeil(const cv::softfloat& value) { return ::cvCeil(value); }
+int cvCeil(const cv::softdouble& value) { return ::cvCeil(value); }
+int CV_FOURCC(char c1, char c2, char c3, char c4) { return ::CV_FOURCC(c1, c2, c3, c4); }
+}
+export inline namespace opencv_m_fast_math_repl {
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvRound(double value) { return ::opencv_m_fast_math_bridge::cvRound(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvFloor(double value) { return ::opencv_m_fast_math_bridge::cvFloor(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvCeil(double value) { return ::opencv_m_fast_math_bridge::cvCeil(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvIsNaN(double value) { return ::opencv_m_fast_math_bridge::cvIsNaN(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvIsInf(double value) { return ::opencv_m_fast_math_bridge::cvIsInf(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvRound(float value) { return ::opencv_m_fast_math_bridge::cvRound(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvRound(int value) { return ::opencv_m_fast_math_bridge::cvRound(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvFloor(float value) { return ::opencv_m_fast_math_bridge::cvFloor(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvFloor(int value) { return ::opencv_m_fast_math_bridge::cvFloor(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvCeil(float value) { return ::opencv_m_fast_math_bridge::cvCeil(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvCeil(int value) { return ::opencv_m_fast_math_bridge::cvCeil(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvIsNaN(float value) { return ::opencv_m_fast_math_bridge::cvIsNaN(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvIsInf(float value) { return ::opencv_m_fast_math_bridge::cvIsInf(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvRound(const cv::softfloat& value) { return ::opencv_m_fast_math_bridge::cvRound(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvRound(const cv::softdouble& value) { return ::opencv_m_fast_math_bridge::cvRound(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvFloor(const cv::softfloat& value) { return ::opencv_m_fast_math_bridge::cvFloor(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvFloor(const cv::softdouble& value) { return ::opencv_m_fast_math_bridge::cvFloor(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvCeil(const cv::softfloat& value) { return ::opencv_m_fast_math_bridge::cvCeil(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int cvCeil(const cv::softdouble& value) { return ::opencv_m_fast_math_bridge::cvCeil(value); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline int CV_FOURCC(char c1, char c2, char c3, char c4) { return ::opencv_m_fast_math_bridge::CV_FOURCC(c1, c2, c3, c4); }
+}
diff --git a/src/features.cppm b/src/features.cppm
new file mode 100644
index 0000000..71a6451
--- /dev/null
+++ b/src/features.cppm
@@ -0,0 +1,7 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.features;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.features;
diff --git a/src/flann.cppm b/src/flann.cppm
index 99ba5ac..74dc2e4 100644
--- a/src/flann.cppm
+++ b/src/flann.cppm
@@ -1,7 +1,5 @@
-// opencv.flann — C++23 module over OpenCV 5 flann (API unchanged).
-module;
-#include <opencv2/flann.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.flann;
 
-export module opencv.flann;
-
-#include "gen_exports/flann.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.detail.flann;
diff --git a/src/gen_exports/calib.inc b/src/gen_exports/calib.inc
new file mode 100644
index 0000000..9ef1266
--- /dev/null
+++ b/src/gen_exports/calib.inc
@@ -0,0 +1,68 @@
+// Generated by tools/gen_exports.py — export surface of opencv.calib.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::CALIB_CHECK_COND;
+    using cv::CALIB_DISABLE_SCHUR_COMPLEMENT;
+    using cv::CALIB_FIX_ASPECT_RATIO;
+    using cv::CALIB_FIX_FOCAL_LENGTH;
+    using cv::CALIB_FIX_INTRINSIC;
+    using cv::CALIB_FIX_K1;
+    using cv::CALIB_FIX_K2;
+    using cv::CALIB_FIX_K3;
+    using cv::CALIB_FIX_K4;
+    using cv::CALIB_FIX_K5;
+    using cv::CALIB_FIX_K6;
+    using cv::CALIB_FIX_PRINCIPAL_POINT;
+    using cv::CALIB_FIX_S1_S2_S3_S4;
+    using cv::CALIB_FIX_SKEW;
+    using cv::CALIB_FIX_TANGENT_DIST;
+    using cv::CALIB_FIX_TAUX_TAUY;
+    using cv::CALIB_HAND_EYE_ANDREFF;
+    using cv::CALIB_HAND_EYE_DANIILIDIS;
+    using cv::CALIB_HAND_EYE_HORAUD;
+    using cv::CALIB_HAND_EYE_PARK;
+    using cv::CALIB_HAND_EYE_TSAI;
+    using cv::CALIB_MODEL_FISHEYE;
+    using cv::CALIB_MODEL_PINHOLE;
+    using cv::CALIB_RATIONAL_MODEL;
+    using cv::CALIB_RECOMPUTE_EXTRINSIC;
+    using cv::CALIB_ROBOT_WORLD_HAND_EYE_LI;
+    using cv::CALIB_ROBOT_WORLD_HAND_EYE_SHAH;
+    using cv::CALIB_SAME_FOCAL_LENGTH;
+    using cv::CALIB_STEREO_REGISTRATION;
+    using cv::CALIB_THIN_PRISM_MODEL;
+    using cv::CALIB_TILTED_MODEL;
+    using cv::CALIB_USE_EXTRINSIC_GUESS;
+    using cv::CALIB_USE_INTRINSIC_GUESS;
+    using cv::CALIB_USE_LU;
+    using cv::CALIB_USE_QR;
+    using cv::CALIB_ZERO_DISPARITY;
+    using cv::CALIB_ZERO_TANGENT_DIST;
+    using cv::CameraModel;
+    using cv::HandEyeCalibrationMethod;
+    using cv::RobotWorldHandEyeCalibrationMethod;
+    using cv::calibrateCamera;
+    using cv::calibrateCameraRO;
+    using cv::calibrateHandEye;
+    using cv::calibrateMultiview;
+    using cv::calibrateRobotWorldHandEye;
+    using cv::initCameraMatrix2D;
+    using cv::registerCameras;
+    using cv::stereoCalibrate;
+}
+export namespace cv::fisheye {
+    using cv::fisheye::CALIB_CHECK_COND;
+    using cv::fisheye::CALIB_FIX_FOCAL_LENGTH;
+    using cv::fisheye::CALIB_FIX_INTRINSIC;
+    using cv::fisheye::CALIB_FIX_K1;
+    using cv::fisheye::CALIB_FIX_K2;
+    using cv::fisheye::CALIB_FIX_K3;
+    using cv::fisheye::CALIB_FIX_K4;
+    using cv::fisheye::CALIB_FIX_PRINCIPAL_POINT;
+    using cv::fisheye::CALIB_FIX_SKEW;
+    using cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC;
+    using cv::fisheye::CALIB_USE_INTRINSIC_GUESS;
+    using cv::fisheye::CALIB_ZERO_DISPARITY;
+    using cv::fisheye::calibrate;
+    using cv::fisheye::stereoCalibrate;
+}
diff --git a/src/gen_exports/calib.skipped.txt b/src/gen_exports/calib.skipped.txt
new file mode 100644
index 0000000..4393a5f
--- /dev/null
+++ b/src/gen_exports/calib.skipped.txt
@@ -0,0 +1 @@
+odd-name: cv.<unnamed>
diff --git a/src/gen_exports/core.inc b/src/gen_exports/core.inc
index 264e32c..b6711e9 100644
--- a/src/gen_exports/core.inc
+++ b/src/gen_exports/core.inc
@@ -10,9 +10,15 @@ export namespace cv {
     using cv::ALGO_HINT_APPROX;
     using cv::ALGO_HINT_DEFAULT;
     using cv::AccessFlag;
+    using cv::Affine3;
+    using cv::Affine3d;
+    using cv::Affine3f;
     using cv::Algorithm;
     using cv::AlgorithmHint;
+    using cv::Allocator;
     using cv::AsyncArray;
+    using cv::AsyncPromise;
+    using cv::AutoBuffer;
     using cv::AutoLock;
     using cv::BORDER_CONSTANT;
     using cv::BORDER_DEFAULT;
@@ -80,9 +86,15 @@ export namespace cv {
     using cv::DataLayout;
     using cv::DataType;
     using cv::DecompTypes;
+    using cv::DefaultDeleter;
     using cv::DftFlags;
     using cv::DownhillSolver;
+    using cv::DualQuat;
+    using cv::DualQuatd;
+    using cv::DualQuatf;
+    using cv::ErrorCallback;
     using cv::Exception;
+    using cv::FPDenormalsIgnoreHintScope;
     using cv::FileNode;
     using cv::FileNodeIterator;
     using cv::FileStorage;
@@ -93,6 +105,7 @@ export namespace cv {
     using cv::GEMM_3_T;
     using cv::GemmFlags;
     using cv::Hamming;
+    using cv::HammingLUT;
     using cv::InputArray;
     using cv::InputArrayOfArrays;
     using cv::InputOutputArray;
@@ -132,10 +145,12 @@ export namespace cv {
     using cv::Mat4s;
     using cv::Mat4w;
     using cv::MatAllocator;
+    using cv::MatCommaInitializer_;
     using cv::MatConstIterator;
     using cv::MatConstIterator_;
     using cv::MatExpr;
     using cv::MatIterator_;
+    using cv::MatND;
     using cv::MatOp;
     using cv::MatShape;
     using cv::MatSize;
@@ -174,6 +189,7 @@ export namespace cv {
     using cv::Matx61f;
     using cv::Matx66d;
     using cv::Matx66f;
+    using cv::MatxCommaInitializer;
     using cv::Matx_AddOp;
     using cv::Matx_DivOp;
     using cv::Matx_MatMulOp;
@@ -194,6 +210,7 @@ export namespace cv {
     using cv::NORM_MINMAX;
     using cv::NORM_RELATIVE;
     using cv::NORM_TYPE_MASK;
+    using cv::Node;
     using cv::NormTypes;
     using cv::OutputArray;
     using cv::OutputArrayOfArrays;
@@ -204,6 +221,8 @@ export namespace cv {
     using cv::PSNR;
     using cv::ParallelLoopBody;
     using cv::ParallelLoopBodyLambdaWrapper;
+    using cv::Param;
+    using cv::ParamType;
     using cv::Point;
     using cv::Point2d;
     using cv::Point2f;
@@ -217,8 +236,11 @@ export namespace cv {
     using cv::Ptr;
     using cv::QUAT_ASSUME_NOT_UNIT;
     using cv::QUAT_ASSUME_UNIT;
+    using cv::Quat;
     using cv::QuatAssumeType;
     using cv::QuatEnum;
+    using cv::Quatd;
+    using cv::Quatf;
     using cv::REDUCE_AVG;
     using cv::REDUCE_MAX;
     using cv::REDUCE_MIN;
@@ -262,9 +284,14 @@ export namespace cv {
     using cv::SortFlags;
     using cv::SparseMat;
     using cv::SparseMatConstIterator;
+    using cv::SparseMatConstIterator_;
     using cv::SparseMatIterator;
+    using cv::SparseMatIterator_;
     using cv::SparseMat_;
     using cv::String;
+    using cv::TLSData;
+    using cv::TLSDataAccumulator;
+    using cv::TLSDataContainer;
     using cv::TermCriteria;
     using cv::TickMeter;
     using cv::UMat;
@@ -279,32 +306,45 @@ export namespace cv {
     using cv::Vec2d;
     using cv::Vec2f;
     using cv::Vec2i;
+    using cv::Vec2l;
     using cv::Vec2s;
     using cv::Vec2w;
     using cv::Vec3b;
     using cv::Vec3d;
     using cv::Vec3f;
     using cv::Vec3i;
+    using cv::Vec3l;
     using cv::Vec3s;
     using cv::Vec3w;
     using cv::Vec4b;
     using cv::Vec4d;
     using cv::Vec4f;
     using cv::Vec4i;
+    using cv::Vec4l;
     using cv::Vec4s;
     using cv::Vec4w;
     using cv::Vec6d;
     using cv::Vec6f;
     using cv::Vec6i;
+    using cv::Vec6l;
     using cv::Vec8i;
+    using cv::Vec8l;
+    using cv::VecCommaInitializer;
     using cv::_InputArray;
     using cv::_InputOutputArray;
     using cv::_OutputArray;
     using cv::__UMAT_USAGE_FLAGS_32BIT;
     using cv::absdiff;
+    using cv::acos;
+    using cv::acosh;
     using cv::add;
     using cv::addWeighted;
+    using cv::asin;
+    using cv::asinh;
+    using cv::atan;
+    using cv::atanh;
     using cv::batchDistance;
+    using cv::bfloat;
     using cv::bitwise_and;
     using cv::bitwise_not;
     using cv::bitwise_or;
@@ -318,11 +358,14 @@ export namespace cv {
     using cv::checkRange;
     using cv::compare;
     using cv::completeSymm;
+    using cv::conjugate;
     using cv::convertScaleAbs;
     using cv::copyMakeBorder;
     using cv::copyTo;
     using cv::cos;
+    using cv::cosh;
     using cv::countNonZero;
+    using cv::crossProduct;
     using cv::cv_abs;
     using cv::cv_absdiff;
     using cv::dct;
@@ -360,11 +403,19 @@ export namespace cv {
     using cv::getVersionString;
     using cv::glob;
     using cv::hasNonZero;
+    using cv::has_custom_delete;
     using cv::hconcat;
+    using cv::hfloat;
+    using cv::hfloatFromBits;
     using cv::idct;
     using cv::idft;
     using cv::inRange;
     using cv::insertChannel;
+    using cv::int16_t;
+    using cv::int32_t;
+    using cv::int64_t;
+    using cv::int8_t;
+    using cv::inv;
     using cv::invert;
     using cv::kmeans;
     using cv::layoutToString;
@@ -382,11 +433,14 @@ export namespace cv {
     using cv::multiply;
     using cv::noArray;
     using cv::normalize;
+    using cv::nullptr_t;
+    using cv::partition;
     using cv::patchNaNs;
     using cv::perspectiveTransform;
     using cv::phase;
     using cv::polarToCart;
     using cv::pow;
+    using cv::power;
     using cv::pprint;
     using cv::randShuffle;
     using cv::randn;
@@ -404,6 +458,7 @@ export namespace cv {
     using cv::setRNGSeed;
     using cv::setUseOptimized;
     using cv::sin;
+    using cv::sinh;
     using cv::softdouble;
     using cv::softfloat;
     using cv::solve;
@@ -416,24 +471,344 @@ export namespace cv {
     using cv::sqrt;
     using cv::subtract;
     using cv::sum;
+    using cv::tan;
+    using cv::tanh;
     using cv::tempfile;
+    using cv::terminate;
     using cv::theRNG;
     using cv::transform;
     using cv::transpose;
     using cv::transposeND;
     using cv::typeToString;
+    using cv::uint16_t;
+    using cv::uint32_t;
+    using cv::uint64_t;
+    using cv::uint8_t;
     using cv::useOptimized;
     using cv::vconcat;
     using cv::writeScalar;
 }
+export namespace cv::Error {
+    using cv::Error::BadAlign;
+    using cv::Error::BadAlphaChannel;
+    using cv::Error::BadCOI;
+    using cv::Error::BadCallBack;
+    using cv::Error::BadDataPtr;
+    using cv::Error::BadDepth;
+    using cv::Error::BadImageSize;
+    using cv::Error::BadModelOrChSeq;
+    using cv::Error::BadNumChannel1U;
+    using cv::Error::BadNumChannels;
+    using cv::Error::BadOffset;
+    using cv::Error::BadOrder;
+    using cv::Error::BadOrigin;
+    using cv::Error::BadROISize;
+    using cv::Error::BadStep;
+    using cv::Error::BadTileSize;
+    using cv::Error::Code;
+    using cv::Error::GpuApiCallError;
+    using cv::Error::GpuNotSupported;
+    using cv::Error::HeaderIsNull;
+    using cv::Error::MaskIsTiled;
+    using cv::Error::OpenCLApiCallError;
+    using cv::Error::OpenCLDoubleNotSupported;
+    using cv::Error::OpenCLInitError;
+    using cv::Error::OpenCLNoAMDBlasFft;
+    using cv::Error::OpenGlApiCallError;
+    using cv::Error::OpenGlNotSupported;
+    using cv::Error::StsAssert;
+    using cv::Error::StsAutoTrace;
+    using cv::Error::StsBackTrace;
+    using cv::Error::StsBadArg;
+    using cv::Error::StsBadFlag;
+    using cv::Error::StsBadFunc;
+    using cv::Error::StsBadMask;
+    using cv::Error::StsBadMemBlock;
+    using cv::Error::StsBadPoint;
+    using cv::Error::StsBadSize;
+    using cv::Error::StsDivByZero;
+    using cv::Error::StsError;
+    using cv::Error::StsFilterOffsetErr;
+    using cv::Error::StsFilterStructContentErr;
+    using cv::Error::StsInplaceNotSupported;
+    using cv::Error::StsInternal;
+    using cv::Error::StsKernelStructContentErr;
+    using cv::Error::StsNoConv;
+    using cv::Error::StsNoMem;
+    using cv::Error::StsNotImplemented;
+    using cv::Error::StsNullPtr;
+    using cv::Error::StsObjectNotFound;
+    using cv::Error::StsOk;
+    using cv::Error::StsOutOfRange;
+    using cv::Error::StsParseError;
+    using cv::Error::StsUnmatchedFormats;
+    using cv::Error::StsUnmatchedSizes;
+    using cv::Error::StsUnsupportedFormat;
+    using cv::Error::StsVecLengthErr;
+}
 export namespace cv::cuda {
+    using cv::cuda::BufferPool;
+    using cv::cuda::DYNAMIC_PARALLELISM;
+    using cv::cuda::DevPtr;
+    using cv::cuda::DeviceInfo;
     using cv::cuda::Event;
+    using cv::cuda::FEATURE_SET_COMPUTE_10;
+    using cv::cuda::FEATURE_SET_COMPUTE_11;
+    using cv::cuda::FEATURE_SET_COMPUTE_12;
+    using cv::cuda::FEATURE_SET_COMPUTE_13;
+    using cv::cuda::FEATURE_SET_COMPUTE_20;
+    using cv::cuda::FEATURE_SET_COMPUTE_21;
+    using cv::cuda::FEATURE_SET_COMPUTE_30;
+    using cv::cuda::FEATURE_SET_COMPUTE_32;
+    using cv::cuda::FEATURE_SET_COMPUTE_35;
+    using cv::cuda::FEATURE_SET_COMPUTE_50;
+    using cv::cuda::FeatureSet;
+    using cv::cuda::GLOBAL_ATOMICS;
+    using cv::cuda::GpuData;
     using cv::cuda::GpuMat;
     using cv::cuda::GpuMatND;
     using cv::cuda::HostMem;
+    using cv::cuda::IndexArray;
+    using cv::cuda::NATIVE_DOUBLE;
+    using cv::cuda::PtrStep;
+    using cv::cuda::PtrStepSz;
+    using cv::cuda::PtrStepSzb;
+    using cv::cuda::PtrStepSzf;
+    using cv::cuda::PtrStepSzi;
+    using cv::cuda::PtrStepSzus;
+    using cv::cuda::PtrStepb;
+    using cv::cuda::PtrStepf;
+    using cv::cuda::PtrStepi;
+    using cv::cuda::PtrStepus;
+    using cv::cuda::PtrSz;
+    using cv::cuda::SHARED_ATOMICS;
+    using cv::cuda::SizeArray;
+    using cv::cuda::StepArray;
     using cv::cuda::Stream;
+    using cv::cuda::TargetArchs;
+    using cv::cuda::WARP_SHUFFLE_FUNCTIONS;
+    using cv::cuda::createGpuMatFromCudaMemory;
+    using cv::cuda::deviceSupports;
+    using cv::cuda::getCudaEnabledDeviceCount;
+    using cv::cuda::getDevice;
+    using cv::cuda::printCudaDeviceInfo;
+    using cv::cuda::printShortCudaDeviceInfo;
+    using cv::cuda::registerPageLocked;
+    using cv::cuda::resetDevice;
+    using cv::cuda::setBufferPoolConfig;
+    using cv::cuda::setBufferPoolUsage;
+    using cv::cuda::setDevice;
+    using cv::cuda::setGlDevice;
+    using cv::cuda::unregisterPageLocked;
+    using cv::cuda::wrapStream;
+}
+export namespace cv::cudev {
+    using cv::cudev::GpuMat_;
 }
 export namespace cv::details {
+    using cv::details::FPDenormalsIgnoreHintScope;
+    using cv::details::FPDenormalsIgnoreHintScopeNOOP;
+    using cv::details::FPDenormalsModeState;
+    using cv::details::restoreFPDenormalsState;
+    using cv::details::saveFPDenormalsState;
+    using cv::details::setFPDenormalsIgnoreHint;
+}
+export namespace cv::hal {
+    using cv::hal::Cholesky32f;
+    using cv::hal::Cholesky64f;
+    using cv::hal::DCT2D;
+    using cv::hal::DFT1D;
+    using cv::hal::DFT2D;
+    using cv::hal::LU32f;
+    using cv::hal::LU64f;
+    using cv::hal::QR32f;
+    using cv::hal::QR64f;
+    using cv::hal::SVD32f;
+    using cv::hal::SVD64f;
+    using cv::hal::absdiff16bf;
+    using cv::hal::absdiff16f;
+    using cv::hal::absdiff16s;
+    using cv::hal::absdiff16u;
+    using cv::hal::absdiff32f;
+    using cv::hal::absdiff32s;
+    using cv::hal::absdiff32u;
+    using cv::hal::absdiff64f;
+    using cv::hal::absdiff64s;
+    using cv::hal::absdiff64u;
+    using cv::hal::absdiff8s;
+    using cv::hal::absdiff8u;
+    using cv::hal::add16bf;
+    using cv::hal::add16f;
+    using cv::hal::add16s;
+    using cv::hal::add16u;
+    using cv::hal::add32f;
+    using cv::hal::add32s;
+    using cv::hal::add32u;
+    using cv::hal::add64f;
+    using cv::hal::add64s;
+    using cv::hal::add64u;
+    using cv::hal::add8s;
+    using cv::hal::add8u;
+    using cv::hal::addRNGBias32f;
+    using cv::hal::addRNGBias64f;
+    using cv::hal::addWeighted16bf;
+    using cv::hal::addWeighted16f;
+    using cv::hal::addWeighted16s;
+    using cv::hal::addWeighted16u;
+    using cv::hal::addWeighted32f;
+    using cv::hal::addWeighted32s;
+    using cv::hal::addWeighted32u;
+    using cv::hal::addWeighted64f;
+    using cv::hal::addWeighted64s;
+    using cv::hal::addWeighted64u;
+    using cv::hal::addWeighted8s;
+    using cv::hal::addWeighted8u;
+    using cv::hal::and8u;
+    using cv::hal::cartToPolar32f;
+    using cv::hal::cartToPolar64f;
+    using cv::hal::cmp16bf;
+    using cv::hal::cmp16f;
+    using cv::hal::cmp16s;
+    using cv::hal::cmp16u;
+    using cv::hal::cmp32f;
+    using cv::hal::cmp32s;
+    using cv::hal::cmp32u;
+    using cv::hal::cmp64f;
+    using cv::hal::cmp64s;
+    using cv::hal::cmp64u;
+    using cv::hal::cmp8s;
+    using cv::hal::cmp8u;
+    using cv::hal::cvt16bf32f;
+    using cv::hal::cvt16f32f;
+    using cv::hal::cvt32f16bf;
+    using cv::hal::cvt32f16f;
+    using cv::hal::div16bf;
+    using cv::hal::div16f;
+    using cv::hal::div16s;
+    using cv::hal::div16u;
+    using cv::hal::div32f;
+    using cv::hal::div32s;
+    using cv::hal::div32u;
+    using cv::hal::div64f;
+    using cv::hal::div64s;
+    using cv::hal::div64u;
+    using cv::hal::div8s;
+    using cv::hal::div8u;
+    using cv::hal::exp32f;
+    using cv::hal::exp64f;
+    using cv::hal::fastAtan32f;
+    using cv::hal::fastAtan64f;
+    using cv::hal::gemm32f;
+    using cv::hal::gemm32fc;
+    using cv::hal::gemm64f;
+    using cv::hal::gemm64fc;
+    using cv::hal::invSqrt32f;
+    using cv::hal::invSqrt64f;
+    using cv::hal::log32f;
+    using cv::hal::log64f;
+    using cv::hal::magnitude32f;
+    using cv::hal::magnitude64f;
+    using cv::hal::max16bf;
+    using cv::hal::max16f;
+    using cv::hal::max16s;
+    using cv::hal::max16u;
+    using cv::hal::max32f;
+    using cv::hal::max32s;
+    using cv::hal::max32u;
+    using cv::hal::max64f;
+    using cv::hal::max64s;
+    using cv::hal::max64u;
+    using cv::hal::max8s;
+    using cv::hal::max8u;
+    using cv::hal::merge16u;
+    using cv::hal::merge32s;
+    using cv::hal::merge64s;
+    using cv::hal::merge8u;
+    using cv::hal::min16bf;
+    using cv::hal::min16f;
+    using cv::hal::min16s;
+    using cv::hal::min16u;
+    using cv::hal::min32f;
+    using cv::hal::min32s;
+    using cv::hal::min32u;
+    using cv::hal::min64f;
+    using cv::hal::min64s;
+    using cv::hal::min64u;
+    using cv::hal::min8s;
+    using cv::hal::min8u;
+    using cv::hal::mul16bf;
+    using cv::hal::mul16f;
+    using cv::hal::mul16s;
+    using cv::hal::mul16u;
+    using cv::hal::mul32f;
+    using cv::hal::mul32s;
+    using cv::hal::mul32u;
+    using cv::hal::mul64f;
+    using cv::hal::mul64s;
+    using cv::hal::mul64u;
+    using cv::hal::mul8s;
+    using cv::hal::mul8u;
+    using cv::hal::normHamming;
+    using cv::hal::normL1_;
+    using cv::hal::normL2Sqr_;
+    using cv::hal::not8u;
+    using cv::hal::or8u;
+    using cv::hal::polarToCart32f;
+    using cv::hal::polarToCart64f;
+    using cv::hal::recip16bf;
+    using cv::hal::recip16f;
+    using cv::hal::recip16s;
+    using cv::hal::recip16u;
+    using cv::hal::recip32f;
+    using cv::hal::recip32s;
+    using cv::hal::recip32u;
+    using cv::hal::recip64f;
+    using cv::hal::recip64s;
+    using cv::hal::recip64u;
+    using cv::hal::recip8s;
+    using cv::hal::recip8u;
+    using cv::hal::split16u;
+    using cv::hal::split32s;
+    using cv::hal::split64s;
+    using cv::hal::split8u;
+    using cv::hal::sqrt32f;
+    using cv::hal::sqrt64f;
+    using cv::hal::sub16bf;
+    using cv::hal::sub16f;
+    using cv::hal::sub16s;
+    using cv::hal::sub16u;
+    using cv::hal::sub32f;
+    using cv::hal::sub32s;
+    using cv::hal::sub32u;
+    using cv::hal::sub64f;
+    using cv::hal::sub64s;
+    using cv::hal::sub64u;
+    using cv::hal::sub8s;
+    using cv::hal::sub8u;
+    using cv::hal::xor8u;
+}
+export namespace cv::instr {
+    using cv::instr::FLAGS;
+    using cv::instr::FLAGS_EXPAND_SAME_NAMES;
+    using cv::instr::FLAGS_MAPPING;
+    using cv::instr::FLAGS_NONE;
+    using cv::instr::IMPL;
+    using cv::instr::IMPL_IPP;
+    using cv::instr::IMPL_OPENCL;
+    using cv::instr::IMPL_PLAIN;
+    using cv::instr::InstrNode;
+    using cv::instr::NodeData;
+    using cv::instr::NodeDataTls;
+    using cv::instr::TYPE;
+    using cv::instr::TYPE_FUN;
+    using cv::instr::TYPE_GENERAL;
+    using cv::instr::TYPE_MARKER;
+    using cv::instr::TYPE_WRAPPER;
+    using cv::instr::getFlags;
+    using cv::instr::getTrace;
+    using cv::instr::resetTrace;
+    using cv::instr::setUseInstrumentation;
+    using cv::instr::useInstrumentation;
 }
 export namespace cv::ipp {
     using cv::ipp::getIppErrorLocation;
@@ -491,7 +866,153 @@ export namespace cv::ocl {
 export namespace cv::ogl {
     using cv::ogl::Arrays;
     using cv::ogl::Buffer;
+    using cv::ogl::LINES;
+    using cv::ogl::LINE_LOOP;
+    using cv::ogl::LINE_STRIP;
+    using cv::ogl::POINTS;
+    using cv::ogl::POLYGON;
+    using cv::ogl::QUADS;
+    using cv::ogl::QUAD_STRIP;
+    using cv::ogl::RenderModes;
+    using cv::ogl::TRIANGLES;
+    using cv::ogl::TRIANGLE_FAN;
+    using cv::ogl::TRIANGLE_STRIP;
     using cv::ogl::Texture2D;
+    using cv::ogl::convertFromGLTexture2D;
+    using cv::ogl::convertToGLTexture2D;
+    using cv::ogl::mapGLBuffer;
+    using cv::ogl::render;
+    using cv::ogl::unmapGLBuffer;
 }
 export namespace cv::ogl::ocl {
+    using cv::ogl::ocl::initializeContextFromGL;
+}
+export namespace cv::parallel {
+    using cv::parallel::ParallelForAPI;
+    using cv::parallel::setParallelForBackend;
+}
+export namespace cv::samples {
+    using cv::samples::addSamplesDataSearchPath;
+    using cv::samples::addSamplesDataSearchSubDirectory;
+    using cv::samples::findFile;
+    using cv::samples::findFileOrKeep;
+}
+export namespace cv::traits {
+    using cv::traits::Depth;
+    using cv::traits::SafeFmt;
+    using cv::traits::SafeType;
+    using cv::traits::Type;
+}
+export namespace cv::utils {
+    using cv::utils::AllocatorStatisticsInterface;
+    using cv::utils::dumpInputArray;
+    using cv::utils::dumpInputArrayOfArrays;
+    using cv::utils::dumpInputOutputArray;
+    using cv::utils::dumpInputOutputArrayOfArrays;
+    using cv::utils::dumpVectorOfDouble;
+    using cv::utils::dumpVectorOfInt;
+    using cv::utils::dumpVectorOfRect;
+    using cv::utils::getThreadID;
+}
+export namespace cv::utils::fs {
+    using cv::utils::fs::canonical;
+    using cv::utils::fs::createDirectories;
+    using cv::utils::fs::createDirectory;
+    using cv::utils::fs::exists;
+    using cv::utils::fs::getCacheDirectoryForDownloads;
+    using cv::utils::fs::getParent;
+    using cv::utils::fs::getcwd;
+    using cv::utils::fs::glob;
+    using cv::utils::fs::glob_relative;
+    using cv::utils::fs::isDirectory;
+    using cv::utils::fs::join;
+    using cv::utils::fs::remove_all;
+}
+export namespace cv::utils::logging {
+    using cv::utils::logging::ENUM_LOG_LEVEL_FORCE_INT;
+    using cv::utils::logging::LOG_LEVEL_DEBUG;
+    using cv::utils::logging::LOG_LEVEL_ERROR;
+    using cv::utils::logging::LOG_LEVEL_FATAL;
+    using cv::utils::logging::LOG_LEVEL_INFO;
+    using cv::utils::logging::LOG_LEVEL_SILENT;
+    using cv::utils::logging::LOG_LEVEL_VERBOSE;
+    using cv::utils::logging::LOG_LEVEL_WARNING;
+    using cv::utils::logging::LogLevel;
+    using cv::utils::logging::LogTag;
+    using cv::utils::logging::LogTagAuto;
+    using cv::utils::logging::getLogLevel;
+    using cv::utils::logging::getLogTagLevel;
+    using cv::utils::logging::registerLogTag;
+    using cv::utils::logging::setLogLevel;
+    using cv::utils::logging::setLogTagLevel;
 }
+export using ::CPU_AVX;
+export using ::CPU_AVX2;
+export using ::CPU_AVX512_CLX;
+export using ::CPU_AVX512_CNL;
+export using ::CPU_AVX512_COMMON;
+export using ::CPU_AVX512_ICL;
+export using ::CPU_AVX512_KNL;
+export using ::CPU_AVX512_KNM;
+export using ::CPU_AVX512_SKX;
+export using ::CPU_AVX_5124FMAPS;
+export using ::CPU_AVX_5124VNNIW;
+export using ::CPU_AVX_512BITALG;
+export using ::CPU_AVX_512BW;
+export using ::CPU_AVX_512CD;
+export using ::CPU_AVX_512DQ;
+export using ::CPU_AVX_512ER;
+export using ::CPU_AVX_512F;
+export using ::CPU_AVX_512IFMA;
+export using ::CPU_AVX_512IFMA512;
+export using ::CPU_AVX_512PF;
+export using ::CPU_AVX_512VBMI;
+export using ::CPU_AVX_512VBMI2;
+export using ::CPU_AVX_512VL;
+export using ::CPU_AVX_512VNNI;
+export using ::CPU_AVX_512VPOPCNTDQ;
+export using ::CPU_AVX_VNNI;
+export using ::CPU_FMA3;
+export using ::CPU_FP16;
+export using ::CPU_LASX;
+export using ::CPU_LSX;
+export using ::CPU_MAX_FEATURE;
+export using ::CPU_MMX;
+export using ::CPU_MSA;
+export using ::CPU_NEON;
+export using ::CPU_NEON_BF16;
+export using ::CPU_NEON_DOTPROD;
+export using ::CPU_NEON_FP16;
+export using ::CPU_POPCNT;
+export using ::CPU_RISCVV;
+export using ::CPU_RVV;
+export using ::CPU_RVV_ZVFH;
+export using ::CPU_SSE;
+export using ::CPU_SSE2;
+export using ::CPU_SSE3;
+export using ::CPU_SSE4_1;
+export using ::CPU_SSE4_2;
+export using ::CPU_SSSE3;
+export using ::CPU_SVE;
+export using ::CPU_VSX;
+export using ::CPU_VSX3;
+export using ::CpuFeatures;
+export using ::Cv16suf;
+export using ::Cv32suf;
+export using ::Cv64suf;
+export using ::cv_hal_bf16;
+export using ::cv_hal_f16;
+export using ::int64;
+export using ::schar;
+export using ::uchar;
+export using ::uint;
+export using ::uint64;
+export using ::ushort;
+export using ::cvRound64;
+export using ::cvTrunc;
+export using ::CvResult;
+export using ::cvResult;
+export using ::CV_ERROR_FAIL;
+export using ::CV_ERROR_OK;
+export using ::OpenCV_API_Header_t;
+export using ::OpenCV_API_Header;
diff --git a/src/gen_exports/core.skipped.txt b/src/gen_exports/core.skipped.txt
index 4171d48..0de0d8a 100644
--- a/src/gen_exports/core.skipped.txt
+++ b/src/gen_exports/core.skipped.txt
@@ -167,106 +167,55 @@ odd-name: cv.softfloat.operator softdouble
 odd-name: cv.softfloat.operator=
 odd-name: cv.void error
 odd-name: cv.void terminate
-pruned (compile-verify): cv::BlockedRange
-pruned (compile-verify): cv::Split
-pruned (compile-verify): cv::abs
-pruned (compile-verify): cv::alignPtr
-pruned (compile-verify): cv::alignSize
-pruned (compile-verify): cv::allocSingletonBuffer
-pruned (compile-verify): cv::allocSingletonNewBuffer
-pruned (compile-verify): cv::cubeRoot
-pruned (compile-verify): cv::cuda::BufferPool
-pruned (compile-verify): cv::cuda::DYNAMIC_PARALLELISM
-pruned (compile-verify): cv::cuda::DeviceInfo
-pruned (compile-verify): cv::cuda::EventAccessor
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_10
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_11
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_12
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_13
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_20
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_21
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_30
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_32
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_35
-pruned (compile-verify): cv::cuda::FEATURE_SET_COMPUTE_50
-pruned (compile-verify): cv::cuda::FeatureSet
-pruned (compile-verify): cv::cuda::GLOBAL_ATOMICS
-pruned (compile-verify): cv::cuda::GpuData
-pruned (compile-verify): cv::cuda::NATIVE_DOUBLE
-pruned (compile-verify): cv::cuda::SHARED_ATOMICS
-pruned (compile-verify): cv::cuda::StreamAccessor
-pruned (compile-verify): cv::cuda::TargetArchs
-pruned (compile-verify): cv::cuda::WARP_SHUFFLE_FUNCTIONS
-pruned (compile-verify): cv::cuda::createContinuous
-pruned (compile-verify): cv::cuda::createGpuMatFromCudaMemory
-pruned (compile-verify): cv::cuda::deviceSupports
-pruned (compile-verify): cv::cuda::ensureSizeIsEnough
-pruned (compile-verify): cv::cuda::getCudaDriverApiErrorMessage
-pruned (compile-verify): cv::cuda::getCudaEnabledDeviceCount
-pruned (compile-verify): cv::cuda::getDevice
-pruned (compile-verify): cv::cuda::getInputMat
-pruned (compile-verify): cv::cuda::getNppErrorMessage
-pruned (compile-verify): cv::cuda::getOutputMat
-pruned (compile-verify): cv::cuda::printCudaDeviceInfo
-pruned (compile-verify): cv::cuda::printShortCudaDeviceInfo
-pruned (compile-verify): cv::cuda::registerPageLocked
-pruned (compile-verify): cv::cuda::resetDevice
-pruned (compile-verify): cv::cuda::setBufferPoolConfig
-pruned (compile-verify): cv::cuda::setBufferPoolUsage
-pruned (compile-verify): cv::cuda::setDevice
-pruned (compile-verify): cv::cuda::setGlDevice
-pruned (compile-verify): cv::cuda::syncOutput
-pruned (compile-verify): cv::cuda::unregisterPageLocked
-pruned (compile-verify): cv::cuda::wrapStream
-pruned (compile-verify): cv::currentParallelFramework
-pruned (compile-verify): cv::details::char_tolower
-pruned (compile-verify): cv::details::char_toupper
-pruned (compile-verify): cv::determinant
-pruned (compile-verify): cv::divUp
-pruned (compile-verify): cv::double
-pruned (compile-verify): cv::float
-pruned (compile-verify): cv::format
-pruned (compile-verify): cv::getElemSize
-pruned (compile-verify): cv::int
-pruned (compile-verify): cv::ipp::setUseIPP_NE
-pruned (compile-verify): cv::ipp::useIPP_NE
-pruned (compile-verify): cv::makePtr
-pruned (compile-verify): cv::max
-pruned (compile-verify): cv::min
-pruned (compile-verify): cv::norm
-pruned (compile-verify): cv::ogl::LINES
-pruned (compile-verify): cv::ogl::LINE_LOOP
-pruned (compile-verify): cv::ogl::LINE_STRIP
-pruned (compile-verify): cv::ogl::POINTS
-pruned (compile-verify): cv::ogl::POLYGON
-pruned (compile-verify): cv::ogl::QUADS
-pruned (compile-verify): cv::ogl::QUAD_STRIP
-pruned (compile-verify): cv::ogl::RenderModes
-pruned (compile-verify): cv::ogl::TRIANGLES
-pruned (compile-verify): cv::ogl::TRIANGLE_FAN
-pruned (compile-verify): cv::ogl::TRIANGLE_STRIP
-pruned (compile-verify): cv::ogl::convertFromGLTexture2D
-pruned (compile-verify): cv::ogl::convertToGLTexture2D
-pruned (compile-verify): cv::ogl::mapGLBuffer
-pruned (compile-verify): cv::ogl::ocl::initializeContextFromGL
-pruned (compile-verify): cv::ogl::render
-pruned (compile-verify): cv::ogl::unmapGLBuffer
-pruned (compile-verify): cv::parallel_for_
-pruned (compile-verify): cv::print
-pruned (compile-verify): cv::randu
-pruned (compile-verify): cv::read
-pruned (compile-verify): cv::roundUp
-pruned (compile-verify): cv::scalarToRawData
-pruned (compile-verify): cv::schar
-pruned (compile-verify): cv::short
-pruned (compile-verify): cv::swap
-pruned (compile-verify): cv::toLowerCase
-pruned (compile-verify): cv::toUpperCase
-pruned (compile-verify): cv::trace
-pruned (compile-verify): cv::uchar
-pruned (compile-verify): cv::unsigned
-pruned (compile-verify): cv::ushort
-pruned (compile-verify): cv::write
+reviewed using exception: cv::BlockedRange -- 'BlockedRange' has not been declared in 'cv'
+reviewed using exception: cv::Split -- 'Split' has not been declared in 'cv'
+reviewed using exception: cv::abs -- static-inline overloads (int/Complex/Mat_) in the set → core_fns.inc
+reviewed using exception: cv::alignPtr -- static inline utility.hpp → core_fns.inc
+reviewed using exception: cv::alignSize -- static inline utility.hpp → core_fns.inc
+reviewed using exception: cv::allocSingletonBuffer -- 'allocSingletonBuffer' has not been declared in 'cv'
+reviewed using exception: cv::allocSingletonNewBuffer -- 'allocSingletonNewBuffer' has not been declared in 'cv'
+reviewed using exception: cv::cubeRoot -- static-inline double overload in the set → core_fns.inc
+reviewed using exception: cv::cuda::EventAccessor -- 'EventAccessor' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::StreamAccessor -- 'StreamAccessor' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::createContinuous -- mixed TU-local/external overload set: exact SDK adapters in cuda_helpers.inc
+reviewed using exception: cv::cuda::ensureSizeIsEnough -- mixed TU-local/external overload set: exact SDK adapters in cuda_helpers.inc
+reviewed using exception: cv::cuda::getCudaDriverApiErrorMessage -- 'getCudaDriverApiErrorMessage' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::getInputMat -- 'getInputMat' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::getNppErrorMessage -- 'getNppErrorMessage' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::getOutputMat -- 'getOutputMat' has not been declared in 'cv::cuda'
+reviewed using exception: cv::cuda::syncOutput -- 'syncOutput' has not been declared in 'cv::cuda'
+reviewed using exception: cv::currentParallelFramework -- 'currentParallelFramework' has not been declared in 'cv'
+reviewed using exception: cv::details::char_tolower -- internal cvstd.hpp helper behind toLowerCase
+reviewed using exception: cv::details::char_toupper -- internal cvstd.hpp helper behind toUpperCase
+reviewed using exception: cv::determinant -- static-inline Matx overload in the set → matx_ops.inc + core_fns.inc
+reviewed using exception: cv::divUp -- static inline utility.hpp → core_fns.inc
+reviewed using exception: cv::double -- expected unqualified-id before 'double'
+reviewed using exception: cv::float -- expected unqualified-id before 'float'
+reviewed using exception: cv::format -- static-inline Mat/Formatter overload in the set → core_fns.inc
+reviewed using exception: cv::getElemSize -- static inline utility.hpp → core_fns.inc
+reviewed using exception: cv::int -- expected unqualified-id before 'int'
+reviewed using exception: cv::ipp::setUseIPP_NE -- internal IPP not-exact toggle
+reviewed using exception: cv::ipp::useIPP_NE -- internal IPP not-exact query
+reviewed using exception: cv::makePtr -- static inline cvstd_wrapper.hpp → core_fns.inc
+reviewed using exception: cv::max -- static-inline Mat×Matx / Mat_ overloads in the set → core_fns.inc
+reviewed using exception: cv::min -- static-inline Mat×Matx / Mat_ overloads in the set → core_fns.inc
+reviewed using exception: cv::norm -- static-inline Matx/Point overloads in the set → matx_ops.inc + core_fns.inc
+reviewed using exception: cv::parallel_for_ -- static-inline std::function overload in the set → core_fns.inc
+reviewed using exception: cv::print -- static inline operations.hpp → core_fns.inc
+reviewed using exception: cv::randu -- static-inline randu<_Tp>() in the set → core_fns.inc
+reviewed using exception: cv::read -- primitives in core_fns.inc; static-inline helpers in generated persistence_ops.inc
+reviewed using exception: cv::roundUp -- static inline utility.hpp → core_fns.inc
+reviewed using exception: cv::scalarToRawData -- 'scalarToRawData' has not been declared in 'cv'
+reviewed using exception: cv::schar -- 'schar' has not been declared in 'cv'
+reviewed using exception: cv::short -- expected unqualified-id before 'short'
+reviewed using exception: cv::swap -- static-inline MatExpr overload in the set → core_fns.inc
+reviewed using exception: cv::toLowerCase -- static inline cvstd.hpp → core_fns.inc
+reviewed using exception: cv::toUpperCase -- static inline cvstd.hpp → core_fns.inc
+reviewed using exception: cv::trace -- static-inline Matx overload in the set → matx_ops.inc + core_fns.inc
+reviewed using exception: cv::uchar -- 'uchar' has not been declared in 'cv'
+reviewed using exception: cv::unsigned -- expected unqualified-id before 'unsigned'
+reviewed using exception: cv::ushort -- 'ushort' has not been declared in 'cv'
+reviewed using exception: cv::write -- primitives in core_fns.inc; static-inline helpers in generated persistence_ops.inc
 skipped-ns: cv.detail.TEST_CUSTOM
 skipped-ns: cv.detail.TEST_EQ
 skipped-ns: cv.detail.TEST_GE
diff --git a/src/gen_exports/dnn.inc b/src/gen_exports/dnn.inc
index d1bcae3..438bafc 100644
--- a/src/gen_exports/dnn.inc
+++ b/src/gen_exports/dnn.inc
@@ -21,6 +21,7 @@ export namespace cv::dnn {
     using cv::dnn::AccumLayer;
     using cv::dnn::AcosLayer;
     using cv::dnn::AcoshLayer;
+    using cv::dnn::ActivationFunc;
     using cv::dnn::ActivationInt8Params;
     using cv::dnn::ActivationLayer;
     using cv::dnn::ActivationLayerInt8;
@@ -188,6 +189,7 @@ export namespace cv::dnn {
     using cv::dnn::MatMulInt8Layer;
     using cv::dnn::MatMulInt8Params;
     using cv::dnn::MatMulLayer;
+    using cv::dnn::MatType;
     using cv::dnn::MaxPoolLayer;
     using cv::dnn::MaxUnpoolLayer;
     using cv::dnn::MishLayer;
@@ -254,6 +256,7 @@ export namespace cv::dnn {
     using cv::dnn::SizeLayer;
     using cv::dnn::Slice2Layer;
     using cv::dnn::SliceLayer;
+    using cv::dnn::SoftNMSMethod;
     using cv::dnn::SoftmaxCrossEntropyLossLayer;
     using cv::dnn::SoftmaxLayer;
     using cv::dnn::SoftmaxLayerInt8;
@@ -284,14 +287,19 @@ export namespace cv::dnn {
     using cv::dnn::TriluLayer;
     using cv::dnn::UniqueLayer;
     using cv::dnn::UnsqueezeLayer;
+    using cv::dnn::_Range;
     using cv::dnn::argKindToString;
     using cv::dnn::blobFromImage;
     using cv::dnn::blobFromImageWithParams;
     using cv::dnn::blobFromImages;
     using cv::dnn::blobFromImagesWithParams;
     using cv::dnn::enableModelDiagnostics;
+    using cv::dnn::getActivationFunc;
     using cv::dnn::getAvailableBackends;
     using cv::dnn::getAvailableTargets;
+    using cv::dnn::getInferenceEngineBackendType;
+    using cv::dnn::getInferenceEngineCPUType;
+    using cv::dnn::getInferenceEngineVPUType;
     using cv::dnn::imagesFromBlob;
     using cv::dnn::modelFormatToString;
     using cv::dnn::readNet;
@@ -300,6 +308,9 @@ export namespace cv::dnn {
     using cv::dnn::readNetFromTFLite;
     using cv::dnn::readNetFromTensorflow;
     using cv::dnn::readTensorFromONNX;
+    using cv::dnn::releaseHDDLPlugin;
+    using cv::dnn::resetMyriadDevice;
+    using cv::dnn::setInferenceEngineBackendType;
     using cv::dnn::softNMSBoxes;
     using cv::dnn::writeTextGraph;
 }
diff --git a/src/gen_exports/dnn.skipped.txt b/src/gen_exports/dnn.skipped.txt
index d50a350..0e5b47a 100644
--- a/src/gen_exports/dnn.skipped.txt
+++ b/src/gen_exports/dnn.skipped.txt
@@ -9,16 +9,14 @@ odd-name: cv.dnn.Layer.void forward
 odd-name: cv.dnn.Model.operator Net&
 odd-name: cv.dnn.Model.operator=
 odd-name: cv.dnn.std.ostream operator <<
-pruned (compile-verify): cv::dnn::_Range
-pruned (compile-verify): cv::dnn::concat
-pruned (compile-verify): cv::dnn::getActivationFunc
-pruned (compile-verify): cv::dnn::getLayerFactoryImpl
-pruned (compile-verify): cv::dnn::getLayerFactoryMutex
-pruned (compile-verify): cv::dnn::getPlane
-pruned (compile-verify): cv::dnn::isAllOnes
-pruned (compile-verify): cv::dnn::normalize_axis
-pruned (compile-verify): cv::dnn::normalize_axis_range
-pruned (compile-verify): cv::dnn::shape
-pruned (compile-verify): cv::dnn::slice
-pruned (compile-verify): cv::dnn::toString
-pruned (compile-verify): cv::dnn::total
+reviewed using exception: cv::dnn::concat -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::getLayerFactoryImpl -- private layer_reg.private.hpp implementation helper
+reviewed using exception: cv::dnn::getLayerFactoryMutex -- private layer_reg.private.hpp implementation helper
+reviewed using exception: cv::dnn::getPlane -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::isAllOnes -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::normalize_axis -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::normalize_axis_range -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::shape -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::slice -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::toString -- SDK shape body adapted in generated src/dnn_shapes.inc
+reviewed using exception: cv::dnn::total -- SDK shape body adapted in generated src/dnn_shapes.inc
diff --git a/src/gen_exports/features.inc b/src/gen_exports/features.inc
new file mode 100644
index 0000000..b6748af
--- /dev/null
+++ b/src/gen_exports/features.inc
@@ -0,0 +1,44 @@
+// Generated by tools/gen_exports.py — export surface of opencv.features.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::ALIKED;
+    using cv::ANNIndex;
+    using cv::Accumulator;
+    using cv::AffineDescriptorExtractor;
+    using cv::AffineFeature;
+    using cv::AffineFeatureDetector;
+    using cv::BFMatcher;
+    using cv::DescriptorExtractor;
+    using cv::DescriptorMatcher;
+    using cv::DrawMatchesFlags;
+    using cv::FAST;
+    using cv::FastFeatureDetector;
+    using cv::Feature2D;
+    using cv::FeatureDetector;
+    using cv::FlannBasedMatcher;
+    using cv::GFTTDetector;
+    using cv::KeyPointsFilter;
+    using cv::L1;
+    using cv::L2;
+    using cv::LightGlueMatcher;
+    using cv::MSER;
+    using cv::ORB;
+    using cv::SIFT;
+    using cv::SL2;
+    using cv::SiftDescriptorExtractor;
+    using cv::SiftFeatureDetector;
+    using cv::SimpleBlobDetector;
+    using cv::computeRecallPrecisionCurve;
+    using cv::drawKeypoints;
+    using cv::drawMatches;
+    using cv::evaluateFeatureDetector;
+    using cv::getNearestPoint;
+    using cv::getRecall;
+    using cv::goodFeaturesToTrack;
+}
+#if defined(HAVE_OPENCV_DNN)
+export namespace cv {
+    using cv::DISK;
+}
+#endif
+export using ::cvhalKeyPoint;
diff --git a/src/gen_exports/features.skipped.txt b/src/gen_exports/features.skipped.txt
new file mode 100644
index 0000000..ab609a6
--- /dev/null
+++ b/src/gen_exports/features.skipped.txt
@@ -0,0 +1,2 @@
+non-cv: struct
+odd-name: cv.FastFeatureDetector.<unnamed>
diff --git a/src/gen_exports/flann.inc b/src/gen_exports/flann.inc
index ebc2435..329c861 100644
--- a/src/gen_exports/flann.inc
+++ b/src/gen_exports/flann.inc
@@ -2,7 +2,11 @@
 // Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
 export namespace cv::flann {
     using cv::flann::AutotunedIndexParams;
+    using cv::flann::ChiSquareDistance;
     using cv::flann::CompositeIndexParams;
+    using cv::flann::CvType;
+    using cv::flann::DNAmming2;
+    using cv::flann::DNAmmingLUT;
     using cv::flann::FLANN_INDEX_TYPE_16S;
     using cv::flann::FLANN_INDEX_TYPE_16U;
     using cv::flann::FLANN_INDEX_TYPE_32F;
@@ -14,14 +18,196 @@ export namespace cv::flann {
     using cv::flann::FLANN_INDEX_TYPE_BOOL;
     using cv::flann::FLANN_INDEX_TYPE_STRING;
     using cv::flann::FlannIndexType;
+    using cv::flann::GenericIndex;
+    using cv::flann::Hamming;
+    using cv::flann::Hamming2;
+    using cv::flann::HammingLUT;
+    using cv::flann::HellingerDistance;
     using cv::flann::HierarchicalClusteringIndexParams;
+    using cv::flann::HistIntersectionDistance;
     using cv::flann::Index;
     using cv::flann::IndexParams;
+    using cv::flann::Index_;
     using cv::flann::KDTreeIndexParams;
+    using cv::flann::KL_Divergence;
     using cv::flann::KMeansIndexParams;
+    using cv::flann::L1;
+    using cv::flann::L2;
+    using cv::flann::L2_Simple;
     using cv::flann::LAST_VALUE_FLANN_INDEX_TYPE;
     using cv::flann::LinearIndexParams;
     using cv::flann::LshIndexParams;
+    using cv::flann::MaxDistance;
+    using cv::flann::MinkowskiDistance;
     using cv::flann::SavedIndexParams;
     using cv::flann::SearchParams;
+    using cv::flann::get_param;
+    using cv::flann::hierarchicalClustering;
+    using cv::flann::print_params;
+}
+export namespace cvflann {
+    using cvflann::AUTOTUNED;
+    using cvflann::Accumulator;
+    using cvflann::AutotunedIndex;
+    using cvflann::AutotunedIndexParams;
+    using cvflann::BranchStruct;
+    using cvflann::CENTERS_GONZALES;
+    using cvflann::CENTERS_KMEANSPP;
+    using cvflann::CENTERS_RANDOM;
+    using cvflann::COMPOSITE;
+    using cvflann::CS;
+    using cvflann::ChiSquareDistance;
+    using cvflann::CompositeIndex;
+    using cvflann::CompositeIndexParams;
+    using cvflann::DNAmming2;
+    using cvflann::DNAmmingLUT;
+    using cvflann::Datatype;
+    using cvflann::DynamicBitset;
+    using cvflann::EUCLIDEAN;
+    using cvflann::FILEScopeGuard;
+    using cvflann::FLANN_CENTERS_GONZALES;
+    using cvflann::FLANN_CENTERS_GROUPWISE;
+    using cvflann::FLANN_CENTERS_KMEANSPP;
+    using cvflann::FLANN_CENTERS_RANDOM;
+    using cvflann::FLANN_CHECKS_AUTOTUNED;
+    using cvflann::FLANN_CHECKS_UNLIMITED;
+    using cvflann::FLANN_DIST_CHI_SQUARE;
+    using cvflann::FLANN_DIST_CS;
+    using cvflann::FLANN_DIST_DNAMMING;
+    using cvflann::FLANN_DIST_EUCLIDEAN;
+    using cvflann::FLANN_DIST_HAMMING;
+    using cvflann::FLANN_DIST_HELLINGER;
+    using cvflann::FLANN_DIST_HIST_INTERSECT;
+    using cvflann::FLANN_DIST_KL;
+    using cvflann::FLANN_DIST_KULLBACK_LEIBLER;
+    using cvflann::FLANN_DIST_L1;
+    using cvflann::FLANN_DIST_L2;
+    using cvflann::FLANN_DIST_MANHATTAN;
+    using cvflann::FLANN_DIST_MAX;
+    using cvflann::FLANN_DIST_MINKOWSKI;
+    using cvflann::FLANN_FLOAT32;
+    using cvflann::FLANN_FLOAT64;
+    using cvflann::FLANN_INDEX_AUTOTUNED;
+    using cvflann::FLANN_INDEX_COMPOSITE;
+    using cvflann::FLANN_INDEX_HIERARCHICAL;
+    using cvflann::FLANN_INDEX_KDTREE;
+    using cvflann::FLANN_INDEX_KDTREE_SINGLE;
+    using cvflann::FLANN_INDEX_KMEANS;
+    using cvflann::FLANN_INDEX_LINEAR;
+    using cvflann::FLANN_INDEX_LSH;
+    using cvflann::FLANN_INDEX_SAVED;
+    using cvflann::FLANN_INT16;
+    using cvflann::FLANN_INT32;
+    using cvflann::FLANN_INT64;
+    using cvflann::FLANN_INT8;
+    using cvflann::FLANN_LOG_ERROR;
+    using cvflann::FLANN_LOG_FATAL;
+    using cvflann::FLANN_LOG_INFO;
+    using cvflann::FLANN_LOG_NONE;
+    using cvflann::FLANN_LOG_WARN;
+    using cvflann::FLANN_UINT16;
+    using cvflann::FLANN_UINT32;
+    using cvflann::FLANN_UINT64;
+    using cvflann::FLANN_UINT8;
+    using cvflann::False;
+    using cvflann::HELLINGER;
+    using cvflann::HIST_INTERSECT;
+    using cvflann::Hamming;
+    using cvflann::Hamming2;
+    using cvflann::HammingLUT;
+    using cvflann::Heap;
+    using cvflann::HellingerDistance;
+    using cvflann::HierarchicalClusteringIndex;
+    using cvflann::HierarchicalClusteringIndexParams;
+    using cvflann::HistIntersectionDistance;
+    using cvflann::Index;
+    using cvflann::IndexHeader;
+    using cvflann::IndexParams;
+    using cvflann::KDTREE;
+    using cvflann::KDTREE_SINGLE;
+    using cvflann::KDTreeIndex;
+    using cvflann::KDTreeIndexParams;
+    using cvflann::KDTreeSingleIndex;
+    using cvflann::KDTreeSingleIndexParams;
+    using cvflann::KL;
+    using cvflann::KL_Divergence;
+    using cvflann::KMEANS;
+    using cvflann::KMeansIndex;
+    using cvflann::KMeansIndexParams;
+    using cvflann::KNNRadiusUniqueResultSet;
+    using cvflann::KNNResultSet;
+    using cvflann::KNNSimpleResultSet;
+    using cvflann::KNNUniqueResultSet;
+    using cvflann::KULLBACK_LEIBLER;
+    using cvflann::L1;
+    using cvflann::L2;
+    using cvflann::L2_Simple;
+    using cvflann::LINEAR;
+    using cvflann::LinearIndex;
+    using cvflann::LinearIndexParams;
+    using cvflann::Logger;
+    using cvflann::LshIndex;
+    using cvflann::LshIndexParams;
+    using cvflann::MANHATTAN;
+    using cvflann::MAX_DIST;
+    using cvflann::MINKOWSKI;
+    using cvflann::Matrix;
+    using cvflann::MaxDistance;
+    using cvflann::MinkowskiDistance;
+    using cvflann::NNIndex;
+    using cvflann::PooledAllocator;
+    using cvflann::RadiusResultSet;
+    using cvflann::RadiusUniqueResultSet;
+    using cvflann::ResultSet;
+    using cvflann::SAVED;
+    using cvflann::SavedIndexParams;
+    using cvflann::SearchParams;
+    using cvflann::StartStopTimer;
+    using cvflann::True;
+    using cvflann::UniqueRandom;
+    using cvflann::UniqueResultSet;
+    using cvflann::UntypedMatrix;
+    using cvflann::ZeroIterator;
+    using cvflann::abs;
+    using cvflann::allocate;
+    using cvflann::any;
+    using cvflann::computeDistanceRaport;
+    using cvflann::compute_ground_truth;
+    using cvflann::countCorrectMatches;
+    using cvflann::create_index_by_type;
+    using cvflann::ensureSimpleDistance;
+    using cvflann::ensureSquareDistance;
+    using cvflann::find_nearest;
+    using cvflann::flann_algorithm_t;
+    using cvflann::flann_centers_init_t;
+    using cvflann::flann_datatype_t;
+    using cvflann::flann_distance_t;
+    using cvflann::flann_distance_type;
+    using cvflann::flann_log_level_t;
+    using cvflann::get_param;
+    using cvflann::greater;
+    using cvflann::hierarchicalClustering;
+    using cvflann::index_creator;
+    using cvflann::isSquareDist;
+    using cvflann::isSquareDistance;
+    using cvflann::load_header;
+    using cvflann::load_saved_index;
+    using cvflann::load_value;
+    using cvflann::log_verbosity;
+    using cvflann::print_params;
+    using cvflann::rand;
+    using cvflann::rand_double;
+    using cvflann::rand_int;
+    using cvflann::random_sample;
+    using cvflann::round;
+    using cvflann::save_header;
+    using cvflann::save_value;
+    using cvflann::search_with_ground_truth;
+    using cvflann::seed_random;
+    using cvflann::set_distance_type;
+    using cvflann::simpleDistance;
+    using cvflann::squareDistance;
+    using cvflann::test_index_checks;
+    using cvflann::test_index_precision;
+    using cvflann::test_index_precisions;
 }
diff --git a/src/gen_exports/geometry.inc b/src/gen_exports/geometry.inc
index f3ac373..4053725 100644
--- a/src/gen_exports/geometry.inc
+++ b/src/gen_exports/geometry.inc
@@ -29,6 +29,11 @@ export namespace cv {
     using cv::LevMarq;
     using cv::LocalOptimMethod;
     using cv::MAGSAC;
+    using cv::MSTAlgorithm;
+    using cv::MSTEdge;
+    using cv::MST_KRUSKAL;
+    using cv::MST_PRIM;
+    using cv::MatrixType;
     using cv::NEIGH_FLANN_KNN;
     using cv::NEIGH_FLANN_RADIUS;
     using cv::NEIGH_GRID;
@@ -75,11 +80,13 @@ export namespace cv {
     using cv::USAC_PARALLEL;
     using cv::USAC_PROSAC;
     using cv::UsacParams;
+    using cv::VariableType;
     using cv::approxPolyDP;
     using cv::approxPolyN;
     using cv::arcLength;
     using cv::boundingRect;
     using cv::boxPoints;
+    using cv::buildMST;
     using cv::calibrationMatrixValues;
     using cv::composeRT;
     using cv::computeCorrespondEpilines;
@@ -143,6 +150,10 @@ export namespace cv {
     using cv::undistortPoints;
     using cv::voxelGridSampling;
 }
+export namespace cv::detail {
+    using cv::detail::LevMarqBackend;
+    using cv::detail::LevMarqBase;
+}
 export namespace cv::fisheye {
     using cv::fisheye::distortPoints;
     using cv::fisheye::estimateNewCameraMatrixForUndistortRectify;
diff --git a/src/gen_exports/geometry.skipped.txt b/src/gen_exports/geometry.skipped.txt
index e56fc31..d9c963b 100644
--- a/src/gen_exports/geometry.skipped.txt
+++ b/src/gen_exports/geometry.skipped.txt
@@ -2,8 +2,3 @@ non-cv: class
 odd-name: cv.<unnamed>
 odd-name: cv.ModelConstraintFunction = std.function < bool
 odd-name: cv.Subdiv2D.<unnamed>
-pruned (compile-verify): cv::MSTAlgorithm
-pruned (compile-verify): cv::MSTEdge
-pruned (compile-verify): cv::MST_KRUSKAL
-pruned (compile-verify): cv::MST_PRIM
-pruned (compile-verify): cv::buildMST
diff --git a/src/gen_exports/highgui.inc b/src/gen_exports/highgui.inc
index cba54b2..b413f70 100644
--- a/src/gen_exports/highgui.inc
+++ b/src/gen_exports/highgui.inc
@@ -1,6 +1,7 @@
 // Generated by tools/gen_exports.py — export surface of opencv.highgui.
 // Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
 export namespace cv {
+    using cv::ButtonCallback;
     using cv::EVENT_FLAG_ALTKEY;
     using cv::EVENT_FLAG_CTRLKEY;
     using cv::EVENT_FLAG_LBUTTON;
@@ -19,8 +20,10 @@ export namespace cv {
     using cv::EVENT_RBUTTONDBLCLK;
     using cv::EVENT_RBUTTONDOWN;
     using cv::EVENT_RBUTTONUP;
+    using cv::MouseCallback;
     using cv::MouseEventFlags;
     using cv::MouseEventTypes;
+    using cv::OpenGlDrawCallback;
     using cv::QT_CHECKBOX;
     using cv::QT_FONT_BLACK;
     using cv::QT_FONT_BOLD;
@@ -37,6 +40,7 @@ export namespace cv {
     using cv::QtFont;
     using cv::QtFontStyles;
     using cv::QtFontWeights;
+    using cv::TrackbarCallback;
     using cv::WINDOW_AUTOSIZE;
     using cv::WINDOW_FREERATIO;
     using cv::WINDOW_FULLSCREEN;
diff --git a/src/gen_exports/highgui.skipped.txt b/src/gen_exports/highgui.skipped.txt
index e34806d..9d9394e 100644
--- a/src/gen_exports/highgui.skipped.txt
+++ b/src/gen_exports/highgui.skipped.txt
@@ -1 +1 @@
-pruned (compile-verify): cv::winrt_initContainer
+reviewed using exception: cv::winrt_initContainer -- 'winrt_initContainer' has not been declared in 'cv'
diff --git a/src/gen_exports/imgcodecs.skipped.txt b/src/gen_exports/imgcodecs.skipped.txt
index 4d0092b..b3d5e48 100644
--- a/src/gen_exports/imgcodecs.skipped.txt
+++ b/src/gen_exports/imgcodecs.skipped.txt
@@ -4,4 +4,4 @@ odd-name: cv.ImageCollection.iterator.operator *
 odd-name: cv.ImageCollection.iterator.operator++
 odd-name: cv.ImageCollection.iterator.operator- >
 odd-name: cv.ImageCollection.operator[]
-pruned (compile-verify): cv::imwritemulti
+reviewed using exception: cv::imwritemulti -- SDK body adapted in generated imgcodecs_helpers.inc
diff --git a/src/gen_exports/imgproc.inc b/src/gen_exports/imgproc.inc
index 83abd4e..7c713ff 100644
--- a/src/gen_exports/imgproc.inc
+++ b/src/gen_exports/imgproc.inc
@@ -563,3 +563,39 @@ export namespace cv::fisheye {
     using cv::fisheye::initUndistortRectifyMap;
     using cv::fisheye::undistortImage;
 }
+export namespace cv::hal {
+    using cv::hal::cvtBGR5x5toBGR;
+    using cv::hal::cvtBGR5x5toGray;
+    using cv::hal::cvtBGRtoBGR;
+    using cv::hal::cvtBGRtoBGR5x5;
+    using cv::hal::cvtBGRtoGray;
+    using cv::hal::cvtBGRtoHSV;
+    using cv::hal::cvtBGRtoLab;
+    using cv::hal::cvtBGRtoThreePlaneYUV;
+    using cv::hal::cvtBGRtoTwoPlaneYUV;
+    using cv::hal::cvtBGRtoXYZ;
+    using cv::hal::cvtBGRtoYUV;
+    using cv::hal::cvtGraytoBGR;
+    using cv::hal::cvtGraytoBGR5x5;
+    using cv::hal::cvtHSVtoBGR;
+    using cv::hal::cvtLabtoBGR;
+    using cv::hal::cvtMultipliedRGBAtoRGBA;
+    using cv::hal::cvtOnePlaneBGRtoYUV;
+    using cv::hal::cvtOnePlaneYUVtoBGR;
+    using cv::hal::cvtRGBAtoMultipliedRGBA;
+    using cv::hal::cvtThreePlaneYUVtoBGR;
+    using cv::hal::cvtTwoPlaneYUVtoBGR;
+    using cv::hal::cvtXYZtoBGR;
+    using cv::hal::cvtYUVtoBGR;
+    using cv::hal::filter2D;
+    using cv::hal::integral;
+    using cv::hal::morph;
+    using cv::hal::resize;
+    using cv::hal::sepFilter2D;
+    using cv::hal::warpAffine;
+    using cv::hal::warpAffineBlockline;
+    using cv::hal::warpAffineBlocklineNN;
+    using cv::hal::warpPerspective;
+    using cv::hal::warpPerspectiveBlockline;
+    using cv::hal::warpPerspectiveBlocklineNN;
+}
diff --git a/src/gen_exports/imgproc.skipped.txt b/src/gen_exports/imgproc.skipped.txt
index cca7eeb..bc80a59 100644
--- a/src/gen_exports/imgproc.skipped.txt
+++ b/src/gen_exports/imgproc.skipped.txt
@@ -2,7 +2,7 @@ odd-name: cv.Filter2DParams.Scalar borderValue = Scalar
 odd-name: cv.FontFace.operator ->
 odd-name: cv.LineIterator.operator *
 odd-name: cv.LineIterator.operator ++
-pruned (compile-verify): cv::HoughCirclesWithAccumulator
-pruned (compile-verify): cv::HoughLinesWithAccumulator
-pruned (compile-verify): cv::initWideAngleProjMap
-pruned (compile-verify): cv::morphologyDefaultBorderValue
+reviewed using exception: cv::HoughCirclesWithAccumulator -- 'HoughCirclesWithAccumulator' has not been declared in 'cv'
+reviewed using exception: cv::HoughLinesWithAccumulator -- 'HoughLinesWithAccumulator' has not been declared in 'cv'
+reviewed using exception: cv::initWideAngleProjMap -- both SDK overloads adapted in generated imgproc_helpers.inc
+reviewed using exception: cv::morphologyDefaultBorderValue -- SDK body adapted in generated imgproc_helpers.inc
diff --git a/src/gen_exports/objdetect.inc b/src/gen_exports/objdetect.inc
new file mode 100644
index 0000000..8225ac6
--- /dev/null
+++ b/src/gen_exports/objdetect.inc
@@ -0,0 +1,87 @@
+// Generated by tools/gen_exports.py — export surface of opencv.objdetect.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::CALIB_CB_ACCURACY;
+    using cv::CALIB_CB_ADAPTIVE_THRESH;
+    using cv::CALIB_CB_ASYMMETRIC_GRID;
+    using cv::CALIB_CB_CLUSTERING;
+    using cv::CALIB_CB_EXHAUSTIVE;
+    using cv::CALIB_CB_FAST_CHECK;
+    using cv::CALIB_CB_FILTER_QUADS;
+    using cv::CALIB_CB_LARGER;
+    using cv::CALIB_CB_MARKER;
+    using cv::CALIB_CB_NORMALIZE_IMAGE;
+    using cv::CALIB_CB_PLAIN;
+    using cv::CALIB_CB_SYMMETRIC_GRID;
+    using cv::CirclesGridFinderParameters;
+    using cv::FaceDetectorYN;
+    using cv::FaceRecognizerSF;
+    using cv::GraphicalCodeDetector;
+    using cv::QRCodeDetector;
+    using cv::QRCodeDetectorAruco;
+    using cv::QRCodeEncoder;
+    using cv::checkChessboard;
+    using cv::drawChessboardCorners;
+    using cv::estimateChessboardSharpness;
+    using cv::find4QuadCornerSubpix;
+    using cv::findChessboardCorners;
+    using cv::findChessboardCornersSB;
+    using cv::findCirclesGrid;
+}
+export namespace cv::aruco {
+    using cv::aruco::ArucoDetector;
+    using cv::aruco::Board;
+    using cv::aruco::CORNER_REFINE_APRILTAG;
+    using cv::aruco::CORNER_REFINE_CONTOUR;
+    using cv::aruco::CORNER_REFINE_NONE;
+    using cv::aruco::CORNER_REFINE_SUBPIX;
+    using cv::aruco::CharucoBoard;
+    using cv::aruco::CharucoDetector;
+    using cv::aruco::CharucoParameters;
+    using cv::aruco::CornerRefineMethod;
+    using cv::aruco::DICT_4X4_100;
+    using cv::aruco::DICT_4X4_1000;
+    using cv::aruco::DICT_4X4_250;
+    using cv::aruco::DICT_4X4_50;
+    using cv::aruco::DICT_5X5_100;
+    using cv::aruco::DICT_5X5_1000;
+    using cv::aruco::DICT_5X5_250;
+    using cv::aruco::DICT_5X5_50;
+    using cv::aruco::DICT_6X6_100;
+    using cv::aruco::DICT_6X6_1000;
+    using cv::aruco::DICT_6X6_250;
+    using cv::aruco::DICT_6X6_50;
+    using cv::aruco::DICT_7X7_100;
+    using cv::aruco::DICT_7X7_1000;
+    using cv::aruco::DICT_7X7_250;
+    using cv::aruco::DICT_7X7_50;
+    using cv::aruco::DICT_APRILTAG_16h5;
+    using cv::aruco::DICT_APRILTAG_25h9;
+    using cv::aruco::DICT_APRILTAG_36h10;
+    using cv::aruco::DICT_APRILTAG_36h11;
+    using cv::aruco::DICT_ARUCO_MIP_36h12;
+    using cv::aruco::DICT_ARUCO_ORIGINAL;
+    using cv::aruco::DetectorParameters;
+    using cv::aruco::Dictionary;
+    using cv::aruco::GridBoard;
+    using cv::aruco::PredefinedDictionaryType;
+    using cv::aruco::RefineParameters;
+    using cv::aruco::drawDetectedCornersCharuco;
+    using cv::aruco::drawDetectedDiamonds;
+    using cv::aruco::drawDetectedMarkers;
+    using cv::aruco::extendDictionary;
+    using cv::aruco::generateImageMarker;
+    using cv::aruco::getPredefinedDictionary;
+}
+export namespace cv::barcode {
+    using cv::barcode::BarcodeDetector;
+}
+export namespace cv::mcc {
+    using cv::mcc::CChecker;
+    using cv::mcc::CCheckerDetector;
+    using cv::mcc::ColorChart;
+    using cv::mcc::DetectorParametersMCC;
+    using cv::mcc::MCC24;
+    using cv::mcc::SG140;
+    using cv::mcc::VINYL18;
+}
diff --git a/src/gen_exports/objdetect.skipped.txt b/src/gen_exports/objdetect.skipped.txt
new file mode 100644
index 0000000..4939a64
--- /dev/null
+++ b/src/gen_exports/objdetect.skipped.txt
@@ -0,0 +1,4 @@
+odd-name: cv.<unnamed>
+odd-name: cv.GraphicalCodeDetector.operator=
+odd-name: cv.aruco.std.vector < std.vector < int > > getNearestMarkerCorners
+odd-name: cv.aruco.std.vector < std.vector < int > > getNearestMarkerIdx
diff --git a/src/gen_exports/photo.inc b/src/gen_exports/photo.inc
new file mode 100644
index 0000000..b6ac907
--- /dev/null
+++ b/src/gen_exports/photo.inc
@@ -0,0 +1,140 @@
+// Generated by tools/gen_exports.py — export surface of opencv.photo.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::AlignExposures;
+    using cv::AlignMTB;
+    using cv::CalibrateCRF;
+    using cv::CalibrateDebevec;
+    using cv::CalibrateRobertson;
+    using cv::INPAINT_NS;
+    using cv::INPAINT_TELEA;
+    using cv::LDR_SIZE;
+    using cv::MIXED_CLONE;
+    using cv::MIXED_CLONE_WIDE;
+    using cv::MONOCHROME_TRANSFER;
+    using cv::MONOCHROME_TRANSFER_WIDE;
+    using cv::MergeDebevec;
+    using cv::MergeExposures;
+    using cv::MergeMertens;
+    using cv::MergeRobertson;
+    using cv::NORMAL_CLONE;
+    using cv::NORMAL_CLONE_WIDE;
+    using cv::NORMCONV_FILTER;
+    using cv::RECURS_FILTER;
+    using cv::SeamlessCloneFlags;
+    using cv::Tonemap;
+    using cv::TonemapDrago;
+    using cv::TonemapMantiuk;
+    using cv::TonemapReinhard;
+    using cv::colorChange;
+    using cv::correctChromaticAberration;
+    using cv::createAlignMTB;
+    using cv::createCalibrateDebevec;
+    using cv::createCalibrateRobertson;
+    using cv::createMergeDebevec;
+    using cv::createMergeMertens;
+    using cv::createMergeRobertson;
+    using cv::createTonemap;
+    using cv::createTonemapDrago;
+    using cv::createTonemapMantiuk;
+    using cv::createTonemapReinhard;
+    using cv::decolor;
+    using cv::denoise_TVL1;
+    using cv::detailEnhance;
+    using cv::edgePreservingFilter;
+    using cv::fastNlMeansDenoising;
+    using cv::fastNlMeansDenoisingColored;
+    using cv::fastNlMeansDenoisingColoredMulti;
+    using cv::fastNlMeansDenoisingMulti;
+    using cv::illuminationChange;
+    using cv::inpaint;
+    using cv::loadChromaticAberrationParams;
+    using cv::pencilSketch;
+    using cv::seamlessClone;
+    using cv::stylization;
+    using cv::textureFlattening;
+}
+export namespace cv::ccm {
+    using cv::ccm::CCM_AFFINE;
+    using cv::ccm::CCM_LINEAR;
+    using cv::ccm::COLORCHECKER_DIGITAL_SG;
+    using cv::ccm::COLORCHECKER_MACBETH;
+    using cv::ccm::COLORCHECKER_VINYL;
+    using cv::ccm::COLOR_SPACE_ADOBE_RGB;
+    using cv::ccm::COLOR_SPACE_ADOBE_RGBL;
+    using cv::ccm::COLOR_SPACE_APPLE_RGB;
+    using cv::ccm::COLOR_SPACE_APPLE_RGBL;
+    using cv::ccm::COLOR_SPACE_DCI_P3_RGB;
+    using cv::ccm::COLOR_SPACE_DCI_P3_RGBL;
+    using cv::ccm::COLOR_SPACE_LAB_A_10;
+    using cv::ccm::COLOR_SPACE_LAB_A_2;
+    using cv::ccm::COLOR_SPACE_LAB_D50_10;
+    using cv::ccm::COLOR_SPACE_LAB_D50_2;
+    using cv::ccm::COLOR_SPACE_LAB_D55_10;
+    using cv::ccm::COLOR_SPACE_LAB_D55_2;
+    using cv::ccm::COLOR_SPACE_LAB_D65_10;
+    using cv::ccm::COLOR_SPACE_LAB_D65_2;
+    using cv::ccm::COLOR_SPACE_LAB_D75_10;
+    using cv::ccm::COLOR_SPACE_LAB_D75_2;
+    using cv::ccm::COLOR_SPACE_LAB_E_10;
+    using cv::ccm::COLOR_SPACE_LAB_E_2;
+    using cv::ccm::COLOR_SPACE_PRO_PHOTO_RGB;
+    using cv::ccm::COLOR_SPACE_PRO_PHOTO_RGBL;
+    using cv::ccm::COLOR_SPACE_REC_2020_RGB;
+    using cv::ccm::COLOR_SPACE_REC_2020_RGBL;
+    using cv::ccm::COLOR_SPACE_REC_709_RGB;
+    using cv::ccm::COLOR_SPACE_REC_709_RGBL;
+    using cv::ccm::COLOR_SPACE_SRGB;
+    using cv::ccm::COLOR_SPACE_SRGBL;
+    using cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGB;
+    using cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGBL;
+    using cv::ccm::COLOR_SPACE_XYZ_A_10;
+    using cv::ccm::COLOR_SPACE_XYZ_A_2;
+    using cv::ccm::COLOR_SPACE_XYZ_D50_10;
+    using cv::ccm::COLOR_SPACE_XYZ_D50_2;
+    using cv::ccm::COLOR_SPACE_XYZ_D55_10;
+    using cv::ccm::COLOR_SPACE_XYZ_D55_2;
+    using cv::ccm::COLOR_SPACE_XYZ_D65_10;
+    using cv::ccm::COLOR_SPACE_XYZ_D65_2;
+    using cv::ccm::COLOR_SPACE_XYZ_D75_10;
+    using cv::ccm::COLOR_SPACE_XYZ_D75_2;
+    using cv::ccm::COLOR_SPACE_XYZ_E_10;
+    using cv::ccm::COLOR_SPACE_XYZ_E_2;
+    using cv::ccm::CcmType;
+    using cv::ccm::ColorCheckerType;
+    using cv::ccm::ColorCorrectionModel;
+    using cv::ccm::ColorSpace;
+    using cv::ccm::DISTANCE_CIE2000;
+    using cv::ccm::DISTANCE_CIE76;
+    using cv::ccm::DISTANCE_CIE94_GRAPHIC_ARTS;
+    using cv::ccm::DISTANCE_CIE94_TEXTILES;
+    using cv::ccm::DISTANCE_CMC_1TO1;
+    using cv::ccm::DISTANCE_CMC_2TO1;
+    using cv::ccm::DISTANCE_RGB;
+    using cv::ccm::DISTANCE_RGBL;
+    using cv::ccm::DistanceType;
+    using cv::ccm::INITIAL_METHOD_LEAST_SQUARE;
+    using cv::ccm::INITIAL_METHOD_WHITE_BALANCE;
+    using cv::ccm::InitialMethodType;
+    using cv::ccm::LINEARIZATION_COLORLOGPOLYFIT;
+    using cv::ccm::LINEARIZATION_COLORPOLYFIT;
+    using cv::ccm::LINEARIZATION_GAMMA;
+    using cv::ccm::LINEARIZATION_GRAYLOGPOLYFIT;
+    using cv::ccm::LINEARIZATION_GRAYPOLYFIT;
+    using cv::ccm::LINEARIZATION_IDENTITY;
+    using cv::ccm::LinearizationType;
+    using cv::ccm::gammaCorrection;
+    using cv::ccm::read;
+    using cv::ccm::write;
+}
+export namespace cv::cuda {
+    using cv::cuda::fastNlMeansDenoising;
+    using cv::cuda::fastNlMeansDenoisingColored;
+    using cv::cuda::nonLocalMeans;
+}
+export namespace cv::segmentation {
+    using cv::segmentation::IntelligentScissorsMB;
+}
+export using ::InpaintingModes;
+export using ::CV_INPAINT_NS;
+export using ::CV_INPAINT_TELEA;
diff --git a/src/gen_exports/photo.skipped.txt b/src/gen_exports/photo.skipped.txt
new file mode 100644
index 0000000..4393a5f
--- /dev/null
+++ b/src/gen_exports/photo.skipped.txt
@@ -0,0 +1 @@
+odd-name: cv.<unnamed>
diff --git a/src/gen_exports/ptcloud.inc b/src/gen_exports/ptcloud.inc
new file mode 100644
index 0000000..1425e0b
--- /dev/null
+++ b/src/gen_exports/ptcloud.inc
@@ -0,0 +1,56 @@
+// Generated by tools/gen_exports.py — export surface of opencv.ptcloud.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::N_PYRAMIDS;
+    using cv::Octree;
+    using cv::Odometry;
+    using cv::OdometryAlgoType;
+    using cv::OdometryFrame;
+    using cv::OdometryFramePyramidType;
+    using cv::OdometrySettings;
+    using cv::OdometryType;
+    using cv::PYR_CLOUD;
+    using cv::PYR_DEPTH;
+    using cv::PYR_DIX;
+    using cv::PYR_DIY;
+    using cv::PYR_IMAGE;
+    using cv::PYR_MASK;
+    using cv::PYR_NORM;
+    using cv::PYR_NORMMASK;
+    using cv::PYR_TEXMASK;
+    using cv::RASTERIZE_COMPAT_DISABLED;
+    using cv::RASTERIZE_COMPAT_INVDEPTH;
+    using cv::RASTERIZE_CULLING_CCW;
+    using cv::RASTERIZE_CULLING_CW;
+    using cv::RASTERIZE_CULLING_NONE;
+    using cv::RASTERIZE_SHADING_FLAT;
+    using cv::RASTERIZE_SHADING_SHADED;
+    using cv::RASTERIZE_SHADING_WHITE;
+    using cv::RGBD_PLANE_METHOD_DEFAULT;
+    using cv::RgbdNormals;
+    using cv::RgbdPlaneMethod;
+    using cv::TriangleCullingMode;
+    using cv::TriangleGlCompatibleMode;
+    using cv::TriangleRasterizeSettings;
+    using cv::TriangleShadingType;
+    using cv::Volume;
+    using cv::VolumeSettings;
+    using cv::VolumeType;
+    using cv::depthTo3d;
+    using cv::depthTo3dSparse;
+    using cv::findPlanes;
+    using cv::loadMesh;
+    using cv::loadPointCloud;
+    using cv::registerDepth;
+    using cv::rescaleDepth;
+    using cv::saveMesh;
+    using cv::savePointCloud;
+    using cv::triangleRasterize;
+    using cv::triangleRasterizeColor;
+    using cv::triangleRasterizeDepth;
+    using cv::warpFrame;
+}
+export namespace cv::detail {
+    using cv::detail::renderPointsNormals;
+    using cv::detail::renderPointsNormalsColors;
+}
diff --git a/src/gen_exports/ptcloud.skipped.txt b/src/gen_exports/ptcloud.skipped.txt
new file mode 100644
index 0000000..07affe4
--- /dev/null
+++ b/src/gen_exports/ptcloud.skipped.txt
@@ -0,0 +1,3 @@
+non-cv: class
+odd-name: cv.OdometrySettings.operator=
+odd-name: cv.VolumeSettings.operator=
diff --git a/src/gen_exports/stereo.inc b/src/gen_exports/stereo.inc
new file mode 100644
index 0000000..d32b298
--- /dev/null
+++ b/src/gen_exports/stereo.inc
@@ -0,0 +1,18 @@
+// Generated by tools/gen_exports.py — export surface of opencv.stereo.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::STEREO_ZERO_DISPARITY;
+    using cv::StereoBM;
+    using cv::StereoMatcher;
+    using cv::StereoSGBM;
+    using cv::filterSpeckles;
+    using cv::getValidDisparityROI;
+    using cv::rectify3Collinear;
+    using cv::reprojectImageTo3D;
+    using cv::stereoRectify;
+    using cv::stereoRectifyUncalibrated;
+    using cv::validateDisparity;
+}
+export namespace cv::fisheye {
+    using cv::fisheye::stereoRectify;
+}
diff --git a/src/gen_exports/stereo.skipped.txt b/src/gen_exports/stereo.skipped.txt
new file mode 100644
index 0000000..fa7e965
--- /dev/null
+++ b/src/gen_exports/stereo.skipped.txt
@@ -0,0 +1,4 @@
+odd-name: cv.<unnamed>
+odd-name: cv.StereoBM.<unnamed>
+odd-name: cv.StereoMatcher.<unnamed>
+odd-name: cv.StereoSGBM.<unnamed>
diff --git a/src/gen_exports/stitching.inc b/src/gen_exports/stitching.inc
new file mode 100644
index 0000000..efeaa9e
--- /dev/null
+++ b/src/gen_exports/stitching.inc
@@ -0,0 +1,122 @@
+// Generated by tools/gen_exports.py — export surface of opencv.stitching.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::AffineWarper;
+    using cv::CompressedRectilinearPortraitWarper;
+    using cv::CompressedRectilinearWarper;
+    using cv::CylindricalWarper;
+    using cv::FisheyeWarper;
+    using cv::MercatorWarper;
+    using cv::PaniniPortraitWarper;
+    using cv::PaniniWarper;
+    using cv::PlaneWarper;
+    using cv::PyRotationWarper;
+    using cv::SphericalWarper;
+    using cv::StereographicWarper;
+    using cv::Stitcher;
+    using cv::TransverseMercatorWarper;
+    using cv::WarperCreator;
+    using cv::createStitcher;
+    using cv::createStitcherScans;
+}
+export namespace cv::detail {
+    using cv::detail::AffineBasedEstimator;
+    using cv::detail::AffineBestOf2NearestMatcher;
+    using cv::detail::AffineWarper;
+    using cv::detail::BestOf2NearestMatcher;
+    using cv::detail::BestOf2NearestRangeMatcher;
+    using cv::detail::Blender;
+    using cv::detail::BlocksChannelsCompensator;
+    using cv::detail::BlocksCompensator;
+    using cv::detail::BlocksGainCompensator;
+    using cv::detail::BundleAdjusterAffine;
+    using cv::detail::BundleAdjusterAffinePartial;
+    using cv::detail::BundleAdjusterBase;
+    using cv::detail::BundleAdjusterRay;
+    using cv::detail::BundleAdjusterReproj;
+    using cv::detail::CameraParams;
+    using cv::detail::ChannelsCompensator;
+    using cv::detail::CompressedRectilinearPortraitProjector;
+    using cv::detail::CompressedRectilinearPortraitWarper;
+    using cv::detail::CompressedRectilinearProjector;
+    using cv::detail::CompressedRectilinearWarper;
+    using cv::detail::CylindricalPortraitProjector;
+    using cv::detail::CylindricalPortraitWarper;
+    using cv::detail::CylindricalProjector;
+    using cv::detail::CylindricalWarper;
+    using cv::detail::CylindricalWarperGpu;
+    using cv::detail::DisjointSets;
+    using cv::detail::DpSeamFinder;
+    using cv::detail::Estimator;
+    using cv::detail::ExposureCompensator;
+    using cv::detail::FeatherBlender;
+    using cv::detail::FeaturesMatcher;
+    using cv::detail::FisheyeProjector;
+    using cv::detail::FisheyeWarper;
+    using cv::detail::GainCompensator;
+    using cv::detail::Graph;
+    using cv::detail::GraphCutSeamFinder;
+    using cv::detail::GraphCutSeamFinderBase;
+    using cv::detail::GraphEdge;
+    using cv::detail::HomographyBasedEstimator;
+    using cv::detail::ImageFeatures;
+    using cv::detail::LightGlueFeaturesMatcher;
+    using cv::detail::MatchesInfo;
+    using cv::detail::MercatorProjector;
+    using cv::detail::MercatorWarper;
+    using cv::detail::MultiBandBlender;
+    using cv::detail::NoBundleAdjuster;
+    using cv::detail::NoExposureCompensator;
+    using cv::detail::NoSeamFinder;
+    using cv::detail::PairwiseSeamFinder;
+    using cv::detail::PaniniPortraitProjector;
+    using cv::detail::PaniniPortraitWarper;
+    using cv::detail::PaniniProjector;
+    using cv::detail::PaniniWarper;
+    using cv::detail::PlanePortraitProjector;
+    using cv::detail::PlanePortraitWarper;
+    using cv::detail::PlaneProjector;
+    using cv::detail::PlaneWarper;
+    using cv::detail::PlaneWarperGpu;
+    using cv::detail::ProjectorBase;
+    using cv::detail::RotationWarper;
+    using cv::detail::RotationWarperBase;
+    using cv::detail::SeamFinder;
+    using cv::detail::SphericalPortraitProjector;
+    using cv::detail::SphericalPortraitWarper;
+    using cv::detail::SphericalProjector;
+    using cv::detail::SphericalWarper;
+    using cv::detail::SphericalWarperGpu;
+    using cv::detail::StereographicProjector;
+    using cv::detail::StereographicWarper;
+    using cv::detail::Timelapser;
+    using cv::detail::TimelapserCrop;
+    using cv::detail::TransverseMercatorProjector;
+    using cv::detail::TransverseMercatorWarper;
+    using cv::detail::VoronoiSeamFinder;
+    using cv::detail::WAVE_CORRECT_AUTO;
+    using cv::detail::WAVE_CORRECT_HORIZ;
+    using cv::detail::WAVE_CORRECT_VERT;
+    using cv::detail::WaveCorrectKind;
+    using cv::detail::autoDetectWaveCorrectKind;
+    using cv::detail::calibrateRotatingCamera;
+    using cv::detail::computeImageFeatures;
+    using cv::detail::createLaplacePyr;
+    using cv::detail::createLaplacePyrGpu;
+    using cv::detail::createWeightMap;
+    using cv::detail::estimateFocal;
+    using cv::detail::findMaxSpanningTree;
+    using cv::detail::focalsFromHomography;
+    using cv::detail::leaveBiggestComponent;
+    using cv::detail::matchesGraphAsString;
+    using cv::detail::normalizeUsingWeightMap;
+    using cv::detail::overlapRoi;
+    using cv::detail::restoreImageFromLaplacePyr;
+    using cv::detail::restoreImageFromLaplacePyrGpu;
+    using cv::detail::resultRoi;
+    using cv::detail::resultRoiIntersection;
+    using cv::detail::resultTl;
+    using cv::detail::selectRandomSubset;
+    using cv::detail::stitchingLogLevel;
+    using cv::detail::waveCorrect;
+}
diff --git a/src/gen_exports/stitching.skipped.txt b/src/gen_exports/stitching.skipped.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/gen_exports/stitching.skipped.txt
@@ -0,0 +1 @@
+
diff --git a/src/gen_exports/video.inc b/src/gen_exports/video.inc
new file mode 100644
index 0000000..983db2f
--- /dev/null
+++ b/src/gen_exports/video.inc
@@ -0,0 +1,57 @@
+// Generated by tools/gen_exports.py — export surface of opencv.video.
+// Regenerate: python3 tools/gen_exports.py   (do not edit by hand)
+export namespace cv {
+    using cv::BackgroundSubtractor;
+    using cv::BackgroundSubtractorKNN;
+    using cv::BackgroundSubtractorMOG2;
+    using cv::CamShift;
+    using cv::DISOpticalFlow;
+    using cv::DenseOpticalFlow;
+    using cv::ECCParameters;
+    using cv::FarnebackOpticalFlow;
+    using cv::KalmanFilter;
+    using cv::MOTION_AFFINE;
+    using cv::MOTION_EUCLIDEAN;
+    using cv::MOTION_HOMOGRAPHY;
+    using cv::MOTION_TRANSLATION;
+    using cv::OPTFLOW_FARNEBACK_GAUSSIAN;
+    using cv::OPTFLOW_LK_GET_MIN_EIGENVALS;
+    using cv::OPTFLOW_USE_INITIAL_FLOW;
+    using cv::SparseOpticalFlow;
+    using cv::SparsePyrLKOpticalFlow;
+    using cv::Tracker;
+    using cv::TrackerDaSiamRPN;
+    using cv::TrackerMIL;
+    using cv::TrackerNano;
+    using cv::TrackerVit;
+    using cv::VariationalRefinement;
+    using cv::buildOpticalFlowPyramid;
+    using cv::calcOpticalFlowFarneback;
+    using cv::calcOpticalFlowPyrLK;
+    using cv::computeECC;
+    using cv::createBackgroundSubtractorKNN;
+    using cv::createBackgroundSubtractorMOG2;
+    using cv::estimateRigidTransform;
+    using cv::findTransformECC;
+    using cv::findTransformECCMultiScale;
+    using cv::findTransformECCWithMask;
+    using cv::meanShift;
+    using cv::readOpticalFlow;
+    using cv::writeOpticalFlow;
+}
+export namespace cv::detail::tracking {
+    using cv::detail::tracking::ConfidenceMap;
+    using cv::detail::tracking::TrackerFeature;
+    using cv::detail::tracking::TrackerFeatureSet;
+    using cv::detail::tracking::TrackerModel;
+    using cv::detail::tracking::TrackerSampler;
+    using cv::detail::tracking::TrackerSamplerAlgorithm;
+    using cv::detail::tracking::TrackerSamplerCSC;
+    using cv::detail::tracking::TrackerStateEstimator;
+    using cv::detail::tracking::TrackerTargetState;
+    using cv::detail::tracking::Trajectory;
+}
+export using ::CV_LKFLOW_PYR_A_READY;
+export using ::CV_LKFLOW_PYR_B_READY;
+export using ::CV_LKFLOW_INITIAL_GUESSES;
+export using ::CV_LKFLOW_GET_MIN_EIGENVALS;
diff --git a/src/gen_exports/video.skipped.txt b/src/gen_exports/video.skipped.txt
new file mode 100644
index 0000000..4ee8c64
--- /dev/null
+++ b/src/gen_exports/video.skipped.txt
@@ -0,0 +1,2 @@
+odd-name: cv.<unnamed>
+odd-name: cv.DISOpticalFlow.<unnamed>
diff --git a/src/gen_exports/videoio.inc b/src/gen_exports/videoio.inc
index 27f40b7..24f2e89 100644
--- a/src/gen_exports/videoio.inc
+++ b/src/gen_exports/videoio.inc
@@ -388,6 +388,8 @@ export namespace cv {
     using cv::CAP_XIAPI;
     using cv::CAP_XINE;
     using cv::IStreamReader;
+    using cv::IVideoCapture;
+    using cv::IVideoWriter;
     using cv::VIDEOWRITER_PROP_COLOR_SPACE;
     using cv::VIDEOWRITER_PROP_DEPTH;
     using cv::VIDEOWRITER_PROP_DTS_DELAY;
diff --git a/src/gen_exports/videoio.skipped.txt b/src/gen_exports/videoio.skipped.txt
index 232f0ea..02a0e8f 100644
--- a/src/gen_exports/videoio.skipped.txt
+++ b/src/gen_exports/videoio.skipped.txt
@@ -1,25 +1,25 @@
 odd-name: cv.<unnamed>
 odd-name: cv.VideoCapture.operator >>
 odd-name: cv.VideoWriter.operator <<
-pruned (compile-verify): cv::AVIReadContainer
-pruned (compile-verify): cv::AVIWriteContainer
-pruned (compile-verify): cv::CLOSE_CAMERA
-pruned (compile-verify): cv::COLORSPACE_BGR
-pruned (compile-verify): cv::COLORSPACE_GRAY
-pruned (compile-verify): cv::COLORSPACE_RGBA
-pruned (compile-verify): cv::COLORSPACE_YUV444P
-pruned (compile-verify): cv::Codecs
-pruned (compile-verify): cv::MJPEG
-pruned (compile-verify): cv::OPEN_CAMERA
-pruned (compile-verify): cv::PluginStreamReader
-pruned (compile-verify): cv::SHOW_TRACKBAR
-pruned (compile-verify): cv::StreamType
-pruned (compile-verify): cv::UPDATE_IMAGE_ELEMENT
-pruned (compile-verify): cv::db
-pruned (compile-verify): cv::dc
-pruned (compile-verify): cv::icvExtractPattern
-pruned (compile-verify): cv::pc
-pruned (compile-verify): cv::wb
-pruned (compile-verify): cv::winrt_imshow
-pruned (compile-verify): cv::winrt_onVisibilityChanged
-pruned (compile-verify): cv::winrt_setFrameContainer
+reviewed using exception: cv::AVIReadContainer -- 'AVIReadContainer' has not been declared in 'cv'
+reviewed using exception: cv::AVIWriteContainer -- 'AVIWriteContainer' has not been declared in 'cv'
+reviewed using exception: cv::CLOSE_CAMERA -- 'CLOSE_CAMERA' has not been declared in 'cv'
+reviewed using exception: cv::COLORSPACE_BGR -- 'COLORSPACE_BGR' has not been declared in 'cv'
+reviewed using exception: cv::COLORSPACE_GRAY -- 'COLORSPACE_GRAY' has not been declared in 'cv'
+reviewed using exception: cv::COLORSPACE_RGBA -- 'COLORSPACE_RGBA' has not been declared in 'cv'
+reviewed using exception: cv::COLORSPACE_YUV444P -- 'COLORSPACE_YUV444P' has not been declared in 'cv'
+reviewed using exception: cv::Codecs -- 'Codecs' has not been declared in 'cv'
+reviewed using exception: cv::MJPEG -- 'MJPEG' has not been declared in 'cv'
+reviewed using exception: cv::OPEN_CAMERA -- 'OPEN_CAMERA' has not been declared in 'cv'
+reviewed using exception: cv::PluginStreamReader -- 'PluginStreamReader' has not been declared in 'cv'
+reviewed using exception: cv::SHOW_TRACKBAR -- 'SHOW_TRACKBAR' has not been declared in 'cv'
+reviewed using exception: cv::StreamType -- 'StreamType' has not been declared in 'cv'
+reviewed using exception: cv::UPDATE_IMAGE_ELEMENT -- 'UPDATE_IMAGE_ELEMENT' has not been declared in 'cv'
+reviewed using exception: cv::db -- 'db' has not been declared in 'cv'
+reviewed using exception: cv::dc -- 'dc' has not been declared in 'cv'
+reviewed using exception: cv::icvExtractPattern -- 'icvExtractPattern' has not been declared in 'cv'
+reviewed using exception: cv::pc -- 'pc' has not been declared in 'cv'
+reviewed using exception: cv::wb -- 'wb' has not been declared in 'cv'
+reviewed using exception: cv::winrt_imshow -- 'winrt_imshow' has not been declared in 'cv'
+reviewed using exception: cv::winrt_onVisibilityChanged -- 'winrt_onVisibilityChanged' has not been declared in 'cv'
+reviewed using exception: cv::winrt_setFrameContainer -- 'winrt_setFrameContainer' has not been declared in 'cv'
diff --git a/src/geometry.cppm b/src/geometry.cppm
index b4dca4b..c6efba2 100644
--- a/src/geometry.cppm
+++ b/src/geometry.cppm
@@ -1,7 +1,6 @@
-// opencv.geometry — C++23 module over OpenCV 5 geometry (API unchanged).
-module;
-#include <opencv2/geometry.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.geometry;
 
-export module opencv.geometry;
-
-#include "gen_exports/geometry.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.flann;
+export import mcpplibs.mwrap.opencv.detail.geometry;
diff --git a/src/highgui.cppm b/src/highgui.cppm
index 4b883b6..410201d 100644
--- a/src/highgui.cppm
+++ b/src/highgui.cppm
@@ -1,8 +1,6 @@
-// opencv.highgui — C++23 module over OpenCV 5 highgui (API unchanged;
-// headless backend in this build profile).
-module;
-#include <opencv2/highgui.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.highgui;
 
-export module opencv.highgui;
-
-#include "gen_exports/highgui.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.highgui;
diff --git a/src/imgcodecs.cppm b/src/imgcodecs.cppm
index 40031b5..4415502 100644
--- a/src/imgcodecs.cppm
+++ b/src/imgcodecs.cppm
@@ -1,7 +1,6 @@
-// opencv.imgcodecs — C++23 module over OpenCV 5 imgcodecs (API unchanged).
-module;
-#include <opencv2/imgcodecs.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.imgcodecs;
 
-export module opencv.imgcodecs;
-
-#include "gen_exports/imgcodecs.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.imgcodecs;
diff --git a/src/imgcodecs_helpers.inc b/src/imgcodecs_helpers.inc
new file mode 100644
index 0000000..ac1ad43
--- /dev/null
+++ b/src/imgcodecs_helpers.inc
@@ -0,0 +1,53 @@
+// Generated by tools/generate_inline_helpers.py; SDK body retained.
+// SDK source: imgcodecs.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_imgcodecs_repl {
+template<class> inline constexpr bool pick = true;
+template<class _D = void> requires pick<_D>
+inline bool imwritemulti(const String& filename, InputArrayOfArrays img,
+                  const std::vector<int>& params = std::vector<int>())
+{
+    return ::cv::imwrite(filename, img, params);
+}
+} } // cv::opencv_m_imgcodecs_repl
diff --git a/src/imgproc.cppm b/src/imgproc.cppm
index f82c7e7..9be7dab 100644
--- a/src/imgproc.cppm
+++ b/src/imgproc.cppm
@@ -1,7 +1,6 @@
-// opencv.imgproc — C++23 module over OpenCV 5 imgproc (API unchanged).
-module;
-#include <opencv2/imgproc.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.imgproc;
 
-export module opencv.imgproc;
-
-#include "gen_exports/imgproc.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.detail.imgproc;
diff --git a/src/imgproc_helpers.inc b/src/imgproc_helpers.inc
new file mode 100644
index 0000000..4e03999
--- /dev/null
+++ b/src/imgproc_helpers.inc
@@ -0,0 +1,72 @@
+// Generated by tools/generate_inline_helpers.py; SDK bodies retained.
+// SDK source: imgproc.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+namespace opencv_m_imgproc_up {
+inline constexpr auto wide_angle = static_cast<float (*)(cv::InputArray, cv::InputArray,
+    cv::Size, int, int, cv::OutputArray, cv::OutputArray, cv::UndistortTypes, double)>(&cv::initWideAngleProjMap);
+}
+export namespace cv { inline namespace opencv_m_imgproc_repl {
+template<class> inline constexpr bool pick = true;
+template<class _D = void> requires pick<_D>
+inline float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs,
+    Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2,
+    UndistortTypes projType = PROJ_SPHERICAL_EQRECT, double alpha = 0) {
+    return ::opencv_m_imgproc_up::wide_angle(cameraMatrix, distCoeffs, imageSize,
+        destImageWidth, m1type, map1, map2, projType, alpha);
+}
+template<class _D = void> requires pick<_D>
+inline Scalar morphologyDefaultBorderValue()
+{ return Scalar::all(DBL_MAX); }
+
+template<class _D = void> requires pick<_D>
+inline float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs,
+                           Size imageSize, int destImageWidth,
+                           int m1type, OutputArray map1, OutputArray map2,
+                           int projType, double alpha = 0)
+{
+    return ::cv::opencv_m_imgproc_repl::initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize, destImageWidth,
+                                m1type, map1, map2, (UndistortTypes)projType, alpha);
+}
+
+} } // cv::opencv_m_imgproc_repl
diff --git a/src/instrumentation_ops.inc b/src/instrumentation_ops.inc
new file mode 100644
index 0000000..139c42d
--- /dev/null
+++ b/src/instrumentation_ops.inc
@@ -0,0 +1,13 @@
+// Preserve both upstream setFlags overloads without exporting the SDK's
+// internal-linkage int overload. All state remains owned by the SDK.
+namespace opencv_m_instrumentation_up {
+inline constexpr auto set_flags = static_cast<void (*)(cv::instr::FLAGS)>(&cv::instr::setFlags);
+}
+export namespace cv::instr {
+using ::cv::instr::operator==;
+inline namespace opencv_m_repl {
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline void setFlags(FLAGS flags) { ::opencv_m_instrumentation_up::set_flags(flags); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline void setFlags(int flags) { ::opencv_m_instrumentation_up::set_flags(static_cast<FLAGS>(flags)); }
+} }
diff --git a/src/macros.cppm b/src/macros.cppm
new file mode 100644
index 0000000..3271b9b
--- /dev/null
+++ b/src/macros.cppm
@@ -0,0 +1,582 @@
+// Generated by tools/generate_macros.py; do not edit.
+module;
+#include <opencv2/core.hpp>
+#include <opencv2/core/version.hpp>
+#include <opencv2/features/hal/interface.h>
+#include <opencv2/imgproc/hal/interface.h>
+#if defined(MCPP_FEATURE_SIMD)
+#include <mwrap/opencv/simd.hpp>
+#endif
+
+export module mcpplibs.mwrap.opencv.macros;
+
+namespace opencv_m_macro_detail {
+inline constexpr auto k_CV_HAL_ERROR_OK = CV_HAL_ERROR_OK;
+inline constexpr auto k_CV_HAL_ERROR_NOT_IMPLEMENTED = CV_HAL_ERROR_NOT_IMPLEMENTED;
+inline constexpr auto k_CV_HAL_ERROR_UNKNOWN = CV_HAL_ERROR_UNKNOWN;
+inline constexpr auto k_CV_CN_MAX = CV_CN_MAX;
+inline constexpr auto k_CV_CN_SHIFT = CV_CN_SHIFT;
+inline constexpr auto k_CV_DEPTH_MAX = CV_DEPTH_MAX;
+inline constexpr auto k_CV_8U = CV_8U;
+inline constexpr auto k_CV_8S = CV_8S;
+inline constexpr auto k_CV_16U = CV_16U;
+inline constexpr auto k_CV_16S = CV_16S;
+inline constexpr auto k_CV_32S = CV_32S;
+inline constexpr auto k_CV_32F = CV_32F;
+inline constexpr auto k_CV_64F = CV_64F;
+inline constexpr auto k_CV_16F = CV_16F;
+inline constexpr auto k_CV_16BF = CV_16BF;
+inline constexpr auto k_CV_Bool = CV_Bool;
+inline constexpr auto k_CV_64U = CV_64U;
+inline constexpr auto k_CV_64S = CV_64S;
+inline constexpr auto k_CV_32U = CV_32U;
+inline constexpr auto k_CV_DEPTH_CURR_MAX = CV_DEPTH_CURR_MAX;
+inline constexpr auto k_CV_MAT_DEPTH_MASK = CV_MAT_DEPTH_MASK;
+inline constexpr auto k_CV_8UC1 = CV_8UC1;
+inline constexpr auto k_CV_8UC2 = CV_8UC2;
+inline constexpr auto k_CV_8UC3 = CV_8UC3;
+inline constexpr auto k_CV_8UC4 = CV_8UC4;
+inline constexpr auto k_CV_8SC1 = CV_8SC1;
+inline constexpr auto k_CV_8SC2 = CV_8SC2;
+inline constexpr auto k_CV_8SC3 = CV_8SC3;
+inline constexpr auto k_CV_8SC4 = CV_8SC4;
+inline constexpr auto k_CV_16UC1 = CV_16UC1;
+inline constexpr auto k_CV_16UC2 = CV_16UC2;
+inline constexpr auto k_CV_16UC3 = CV_16UC3;
+inline constexpr auto k_CV_16UC4 = CV_16UC4;
+inline constexpr auto k_CV_16SC1 = CV_16SC1;
+inline constexpr auto k_CV_16SC2 = CV_16SC2;
+inline constexpr auto k_CV_16SC3 = CV_16SC3;
+inline constexpr auto k_CV_16SC4 = CV_16SC4;
+inline constexpr auto k_CV_32SC1 = CV_32SC1;
+inline constexpr auto k_CV_32SC2 = CV_32SC2;
+inline constexpr auto k_CV_32SC3 = CV_32SC3;
+inline constexpr auto k_CV_32SC4 = CV_32SC4;
+inline constexpr auto k_CV_32FC1 = CV_32FC1;
+inline constexpr auto k_CV_32FC2 = CV_32FC2;
+inline constexpr auto k_CV_32FC3 = CV_32FC3;
+inline constexpr auto k_CV_32FC4 = CV_32FC4;
+inline constexpr auto k_CV_64FC1 = CV_64FC1;
+inline constexpr auto k_CV_64FC2 = CV_64FC2;
+inline constexpr auto k_CV_64FC3 = CV_64FC3;
+inline constexpr auto k_CV_64FC4 = CV_64FC4;
+inline constexpr auto k_CV_16FC1 = CV_16FC1;
+inline constexpr auto k_CV_16FC2 = CV_16FC2;
+inline constexpr auto k_CV_16FC3 = CV_16FC3;
+inline constexpr auto k_CV_16FC4 = CV_16FC4;
+inline constexpr auto k_CV_64SC1 = CV_64SC1;
+inline constexpr auto k_CV_64SC2 = CV_64SC2;
+inline constexpr auto k_CV_64SC3 = CV_64SC3;
+inline constexpr auto k_CV_64SC4 = CV_64SC4;
+inline constexpr auto k_CV_64UC1 = CV_64UC1;
+inline constexpr auto k_CV_64UC2 = CV_64UC2;
+inline constexpr auto k_CV_64UC3 = CV_64UC3;
+inline constexpr auto k_CV_64UC4 = CV_64UC4;
+inline constexpr auto k_CV_BoolC1 = CV_BoolC1;
+inline constexpr auto k_CV_BoolC2 = CV_BoolC2;
+inline constexpr auto k_CV_BoolC3 = CV_BoolC3;
+inline constexpr auto k_CV_BoolC4 = CV_BoolC4;
+inline constexpr auto k_CV_32UC1 = CV_32UC1;
+inline constexpr auto k_CV_32UC2 = CV_32UC2;
+inline constexpr auto k_CV_32UC3 = CV_32UC3;
+inline constexpr auto k_CV_32UC4 = CV_32UC4;
+inline constexpr auto k_CV_16BFC1 = CV_16BFC1;
+inline constexpr auto k_CV_16BFC2 = CV_16BFC2;
+inline constexpr auto k_CV_16BFC3 = CV_16BFC3;
+inline constexpr auto k_CV_16BFC4 = CV_16BFC4;
+inline constexpr auto k_CV_HAL_CMP_EQ = CV_HAL_CMP_EQ;
+inline constexpr auto k_CV_HAL_CMP_GT = CV_HAL_CMP_GT;
+inline constexpr auto k_CV_HAL_CMP_GE = CV_HAL_CMP_GE;
+inline constexpr auto k_CV_HAL_CMP_LT = CV_HAL_CMP_LT;
+inline constexpr auto k_CV_HAL_CMP_LE = CV_HAL_CMP_LE;
+inline constexpr auto k_CV_HAL_CMP_NE = CV_HAL_CMP_NE;
+inline constexpr auto k_CV_HAL_BORDER_CONSTANT = CV_HAL_BORDER_CONSTANT;
+inline constexpr auto k_CV_HAL_BORDER_REPLICATE = CV_HAL_BORDER_REPLICATE;
+inline constexpr auto k_CV_HAL_BORDER_REFLECT = CV_HAL_BORDER_REFLECT;
+inline constexpr auto k_CV_HAL_BORDER_WRAP = CV_HAL_BORDER_WRAP;
+inline constexpr auto k_CV_HAL_BORDER_REFLECT_101 = CV_HAL_BORDER_REFLECT_101;
+inline constexpr auto k_CV_HAL_BORDER_TRANSPARENT = CV_HAL_BORDER_TRANSPARENT;
+inline constexpr auto k_CV_HAL_BORDER_ISOLATED = CV_HAL_BORDER_ISOLATED;
+inline constexpr auto k_CV_HAL_DFT_INVERSE = CV_HAL_DFT_INVERSE;
+inline constexpr auto k_CV_HAL_DFT_SCALE = CV_HAL_DFT_SCALE;
+inline constexpr auto k_CV_HAL_DFT_ROWS = CV_HAL_DFT_ROWS;
+inline constexpr auto k_CV_HAL_DFT_COMPLEX_OUTPUT = CV_HAL_DFT_COMPLEX_OUTPUT;
+inline constexpr auto k_CV_HAL_DFT_REAL_OUTPUT = CV_HAL_DFT_REAL_OUTPUT;
+inline constexpr auto k_CV_HAL_DFT_TWO_STAGE = CV_HAL_DFT_TWO_STAGE;
+inline constexpr auto k_CV_HAL_DFT_STAGE_COLS = CV_HAL_DFT_STAGE_COLS;
+inline constexpr auto k_CV_HAL_DFT_IS_CONTINUOUS = CV_HAL_DFT_IS_CONTINUOUS;
+inline constexpr auto k_CV_HAL_DFT_IS_INPLACE = CV_HAL_DFT_IS_INPLACE;
+inline constexpr auto k_CV_HAL_SVD_NO_UV = CV_HAL_SVD_NO_UV;
+inline constexpr auto k_CV_HAL_SVD_SHORT_UV = CV_HAL_SVD_SHORT_UV;
+inline constexpr auto k_CV_HAL_SVD_MODIFY_A = CV_HAL_SVD_MODIFY_A;
+inline constexpr auto k_CV_HAL_SVD_FULL_UV = CV_HAL_SVD_FULL_UV;
+inline constexpr auto k_CV_HAL_GEMM_1_T = CV_HAL_GEMM_1_T;
+inline constexpr auto k_CV_HAL_GEMM_2_T = CV_HAL_GEMM_2_T;
+inline constexpr auto k_CV_HAL_GEMM_3_T = CV_HAL_GEMM_3_T;
+inline constexpr auto k_CV_VERSION_MAJOR = CV_VERSION_MAJOR;
+inline constexpr auto k_CV_VERSION_MINOR = CV_VERSION_MINOR;
+inline constexpr auto k_CV_VERSION_REVISION = CV_VERSION_REVISION;
+inline constexpr auto k_CV_VERSION = CV_VERSION;
+inline constexpr auto k_CV_VERSION_STATUS = CV_VERSION_STATUS;
+inline constexpr auto k_CV_PI = CV_PI;
+inline constexpr auto k_CV_2PI = CV_2PI;
+inline constexpr auto k_CV_LOG2 = CV_LOG2;
+inline constexpr auto k_CV_MAX_DIM = CV_MAX_DIM;
+inline constexpr auto k_CV_MAT_CN_MASK = CV_MAT_CN_MASK;
+inline constexpr auto k_CV_MAT_TYPE_MASK = CV_MAT_TYPE_MASK;
+inline constexpr auto k_CV_MAT_CONT_FLAG_SHIFT = CV_MAT_CONT_FLAG_SHIFT;
+inline constexpr auto k_CV_MAT_CONT_FLAG = CV_MAT_CONT_FLAG;
+inline constexpr auto k_CV_SUBMAT_FLAG_SHIFT = CV_SUBMAT_FLAG_SHIFT;
+inline constexpr auto k_CV_SUBMAT_FLAG = CV_SUBMAT_FLAG;
+inline constexpr auto k_CV_AUTOSTEP = CV_AUTOSTEP;
+inline constexpr auto k_CV_HAL_TYPE_5_8 = CV_HAL_TYPE_5_8;
+inline constexpr auto k_CV_HAL_TYPE_7_12 = CV_HAL_TYPE_7_12;
+inline constexpr auto k_CV_HAL_TYPE_9_16 = CV_HAL_TYPE_9_16;
+inline constexpr auto k_CV_HAL_INTER_NEAREST = CV_HAL_INTER_NEAREST;
+inline constexpr auto k_CV_HAL_INTER_LINEAR = CV_HAL_INTER_LINEAR;
+inline constexpr auto k_CV_HAL_INTER_CUBIC = CV_HAL_INTER_CUBIC;
+inline constexpr auto k_CV_HAL_INTER_AREA = CV_HAL_INTER_AREA;
+inline constexpr auto k_CV_HAL_INTER_LANCZOS4 = CV_HAL_INTER_LANCZOS4;
+inline constexpr auto k_CV_HAL_INTER_LINEAR_EXACT = CV_HAL_INTER_LINEAR_EXACT;
+inline constexpr auto k_CV_HAL_INTER_NEAREST_EXACT = CV_HAL_INTER_NEAREST_EXACT;
+inline constexpr auto k_CV_HAL_INTER_MAX = CV_HAL_INTER_MAX;
+inline constexpr auto k_CV_HAL_WARP_FILL_OUTLIERS = CV_HAL_WARP_FILL_OUTLIERS;
+inline constexpr auto k_CV_HAL_WARP_INVERSE_MAP = CV_HAL_WARP_INVERSE_MAP;
+inline constexpr auto k_CV_HAL_WARP_RELATIVE_MAP = CV_HAL_WARP_RELATIVE_MAP;
+inline constexpr auto k_CV_HAL_MORPH_ERODE = CV_HAL_MORPH_ERODE;
+inline constexpr auto k_CV_HAL_MORPH_DILATE = CV_HAL_MORPH_DILATE;
+inline constexpr auto k_CV_HAL_THRESH_BINARY = CV_HAL_THRESH_BINARY;
+inline constexpr auto k_CV_HAL_THRESH_BINARY_INV = CV_HAL_THRESH_BINARY_INV;
+inline constexpr auto k_CV_HAL_THRESH_TRUNC = CV_HAL_THRESH_TRUNC;
+inline constexpr auto k_CV_HAL_THRESH_TOZERO = CV_HAL_THRESH_TOZERO;
+inline constexpr auto k_CV_HAL_THRESH_TOZERO_INV = CV_HAL_THRESH_TOZERO_INV;
+inline constexpr auto k_CV_HAL_THRESH_MASK = CV_HAL_THRESH_MASK;
+inline constexpr auto k_CV_HAL_THRESH_OTSU = CV_HAL_THRESH_OTSU;
+inline constexpr auto k_CV_HAL_THRESH_TRIANGLE = CV_HAL_THRESH_TRIANGLE;
+inline constexpr auto k_CV_HAL_ADAPTIVE_THRESH_MEAN_C = CV_HAL_ADAPTIVE_THRESH_MEAN_C;
+inline constexpr auto k_CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C = CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C;
+#if defined(MCPP_FEATURE_SIMD)
+inline constexpr auto k_CV_SIMD = CV_SIMD;
+inline constexpr auto k_CV_SIMD_WIDTH = CV_SIMD_WIDTH;
+inline constexpr auto k_CV_SIMD_64F = CV_SIMD_64F;
+inline constexpr auto k_CV_SIMD_FP16 = CV_SIMD_FP16;
+inline constexpr auto k_CV_SIMD128 = CV_SIMD128;
+inline constexpr auto k_CV_SIMD128_CPP = CV_SIMD128_CPP;
+inline constexpr auto k_CV_SIMD128_64F = CV_SIMD128_64F;
+inline constexpr auto k_CV_SIMD128_FP16 = CV_SIMD128_FP16;
+inline constexpr auto k_CV_SIMD256 = CV_SIMD256;
+inline constexpr auto k_CV_SIMD256_64F = CV_SIMD256_64F;
+inline constexpr auto k_CV_SIMD256_FP16 = CV_SIMD256_FP16;
+inline constexpr auto k_CV_SIMD512 = CV_SIMD512;
+inline constexpr auto k_CV_SIMD512_64F = CV_SIMD512_64F;
+inline constexpr auto k_CV_SIMD512_FP16 = CV_SIMD512_FP16;
+inline constexpr auto k_CV_SIMD_SCALABLE = CV_SIMD_SCALABLE;
+#endif
+constexpr int k_CV_MAT_DEPTH(int value) { return CV_MAT_DEPTH(value); }
+constexpr int k_CV_IS_INT_TYPE(int value) { return CV_IS_INT_TYPE(value); }
+constexpr int k_CV_IS_FLOAT_TYPE(int value) { return CV_IS_FLOAT_TYPE(value); }
+constexpr int k_CV_MAT_CN(int value) { return CV_MAT_CN(value); }
+constexpr int k_CV_MAT_TYPE(int value) { return CV_MAT_TYPE(value); }
+constexpr int k_CV_IS_MAT_CONT(int value) { return CV_IS_MAT_CONT(value); }
+constexpr int k_CV_IS_CONT_MAT(int value) { return CV_IS_CONT_MAT(value); }
+constexpr int k_CV_ELEM_SIZE1(int value) { return CV_ELEM_SIZE1(value); }
+constexpr int k_CV_ELEM_SIZE(int value) { return CV_ELEM_SIZE(value); }
+constexpr int k_CV_8UC(int value) { return CV_8UC(value); }
+constexpr int k_CV_8SC(int value) { return CV_8SC(value); }
+constexpr int k_CV_16UC(int value) { return CV_16UC(value); }
+constexpr int k_CV_16SC(int value) { return CV_16SC(value); }
+constexpr int k_CV_32SC(int value) { return CV_32SC(value); }
+constexpr int k_CV_32FC(int value) { return CV_32FC(value); }
+constexpr int k_CV_64FC(int value) { return CV_64FC(value); }
+constexpr int k_CV_16FC(int value) { return CV_16FC(value); }
+constexpr int k_CV_64SC(int value) { return CV_64SC(value); }
+constexpr int k_CV_64UC(int value) { return CV_64UC(value); }
+constexpr int k_CV_BoolC(int value) { return CV_BoolC(value); }
+constexpr int k_CV_32UC(int value) { return CV_32UC(value); }
+constexpr int k_CV_16BFC(int value) { return CV_16BFC(value); }
+constexpr int k_CV_MAKETYPE(int depth, int channels) { return CV_MAKETYPE(depth, channels); }
+constexpr int k_CV_MAKE_TYPE(int depth, int channels) { return CV_MAKE_TYPE(depth, channels); }
+template<class A, class B, class C, class D>
+constexpr auto k_CV_FOURCC_MACRO(A a, B b, C c, D d) { return CV_FOURCC_MACRO(a, b, c, d); }
+constexpr int k_CV_IS_SUBMAT(int flags) { return flags & CV_SUBMAT_FLAG; }
+}
+
+#undef CV_HAL_ERROR_OK
+#undef CV_HAL_ERROR_NOT_IMPLEMENTED
+#undef CV_HAL_ERROR_UNKNOWN
+#undef CV_CN_MAX
+#undef CV_CN_SHIFT
+#undef CV_DEPTH_MAX
+#undef CV_8U
+#undef CV_8S
+#undef CV_16U
+#undef CV_16S
+#undef CV_32S
+#undef CV_32F
+#undef CV_64F
+#undef CV_16F
+#undef CV_16BF
+#undef CV_Bool
+#undef CV_64U
+#undef CV_64S
+#undef CV_32U
+#undef CV_DEPTH_CURR_MAX
+#undef CV_MAT_DEPTH_MASK
+#undef CV_8UC1
+#undef CV_8UC2
+#undef CV_8UC3
+#undef CV_8UC4
+#undef CV_8SC1
+#undef CV_8SC2
+#undef CV_8SC3
+#undef CV_8SC4
+#undef CV_16UC1
+#undef CV_16UC2
+#undef CV_16UC3
+#undef CV_16UC4
+#undef CV_16SC1
+#undef CV_16SC2
+#undef CV_16SC3
+#undef CV_16SC4
+#undef CV_32SC1
+#undef CV_32SC2
+#undef CV_32SC3
+#undef CV_32SC4
+#undef CV_32FC1
+#undef CV_32FC2
+#undef CV_32FC3
+#undef CV_32FC4
+#undef CV_64FC1
+#undef CV_64FC2
+#undef CV_64FC3
+#undef CV_64FC4
+#undef CV_16FC1
+#undef CV_16FC2
+#undef CV_16FC3
+#undef CV_16FC4
+#undef CV_64SC1
+#undef CV_64SC2
+#undef CV_64SC3
+#undef CV_64SC4
+#undef CV_64UC1
+#undef CV_64UC2
+#undef CV_64UC3
+#undef CV_64UC4
+#undef CV_BoolC1
+#undef CV_BoolC2
+#undef CV_BoolC3
+#undef CV_BoolC4
+#undef CV_32UC1
+#undef CV_32UC2
+#undef CV_32UC3
+#undef CV_32UC4
+#undef CV_16BFC1
+#undef CV_16BFC2
+#undef CV_16BFC3
+#undef CV_16BFC4
+#undef CV_HAL_CMP_EQ
+#undef CV_HAL_CMP_GT
+#undef CV_HAL_CMP_GE
+#undef CV_HAL_CMP_LT
+#undef CV_HAL_CMP_LE
+#undef CV_HAL_CMP_NE
+#undef CV_HAL_BORDER_CONSTANT
+#undef CV_HAL_BORDER_REPLICATE
+#undef CV_HAL_BORDER_REFLECT
+#undef CV_HAL_BORDER_WRAP
+#undef CV_HAL_BORDER_REFLECT_101
+#undef CV_HAL_BORDER_TRANSPARENT
+#undef CV_HAL_BORDER_ISOLATED
+#undef CV_HAL_DFT_INVERSE
+#undef CV_HAL_DFT_SCALE
+#undef CV_HAL_DFT_ROWS
+#undef CV_HAL_DFT_COMPLEX_OUTPUT
+#undef CV_HAL_DFT_REAL_OUTPUT
+#undef CV_HAL_DFT_TWO_STAGE
+#undef CV_HAL_DFT_STAGE_COLS
+#undef CV_HAL_DFT_IS_CONTINUOUS
+#undef CV_HAL_DFT_IS_INPLACE
+#undef CV_HAL_SVD_NO_UV
+#undef CV_HAL_SVD_SHORT_UV
+#undef CV_HAL_SVD_MODIFY_A
+#undef CV_HAL_SVD_FULL_UV
+#undef CV_HAL_GEMM_1_T
+#undef CV_HAL_GEMM_2_T
+#undef CV_HAL_GEMM_3_T
+#undef CV_VERSION_MAJOR
+#undef CV_VERSION_MINOR
+#undef CV_VERSION_REVISION
+#undef CV_VERSION
+#undef CV_VERSION_STATUS
+#undef CV_PI
+#undef CV_2PI
+#undef CV_LOG2
+#undef CV_MAX_DIM
+#undef CV_MAT_CN_MASK
+#undef CV_MAT_TYPE_MASK
+#undef CV_MAT_CONT_FLAG_SHIFT
+#undef CV_MAT_CONT_FLAG
+#undef CV_SUBMAT_FLAG_SHIFT
+#undef CV_SUBMAT_FLAG
+#undef CV_AUTOSTEP
+#undef CV_HAL_TYPE_5_8
+#undef CV_HAL_TYPE_7_12
+#undef CV_HAL_TYPE_9_16
+#undef CV_HAL_INTER_NEAREST
+#undef CV_HAL_INTER_LINEAR
+#undef CV_HAL_INTER_CUBIC
+#undef CV_HAL_INTER_AREA
+#undef CV_HAL_INTER_LANCZOS4
+#undef CV_HAL_INTER_LINEAR_EXACT
+#undef CV_HAL_INTER_NEAREST_EXACT
+#undef CV_HAL_INTER_MAX
+#undef CV_HAL_WARP_FILL_OUTLIERS
+#undef CV_HAL_WARP_INVERSE_MAP
+#undef CV_HAL_WARP_RELATIVE_MAP
+#undef CV_HAL_MORPH_ERODE
+#undef CV_HAL_MORPH_DILATE
+#undef CV_HAL_THRESH_BINARY
+#undef CV_HAL_THRESH_BINARY_INV
+#undef CV_HAL_THRESH_TRUNC
+#undef CV_HAL_THRESH_TOZERO
+#undef CV_HAL_THRESH_TOZERO_INV
+#undef CV_HAL_THRESH_MASK
+#undef CV_HAL_THRESH_OTSU
+#undef CV_HAL_THRESH_TRIANGLE
+#undef CV_HAL_ADAPTIVE_THRESH_MEAN_C
+#undef CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C
+#undef CV_MAT_DEPTH
+#undef CV_IS_INT_TYPE
+#undef CV_IS_FLOAT_TYPE
+#undef CV_MAT_CN
+#undef CV_MAT_TYPE
+#undef CV_IS_MAT_CONT
+#undef CV_IS_CONT_MAT
+#undef CV_ELEM_SIZE1
+#undef CV_ELEM_SIZE
+#undef CV_8UC
+#undef CV_8SC
+#undef CV_16UC
+#undef CV_16SC
+#undef CV_32SC
+#undef CV_32FC
+#undef CV_64FC
+#undef CV_16FC
+#undef CV_64SC
+#undef CV_64UC
+#undef CV_BoolC
+#undef CV_32UC
+#undef CV_16BFC
+#undef CV_MAKETYPE
+#undef CV_MAKE_TYPE
+#undef CV_IS_SUBMAT
+#undef CV_FOURCC_MACRO
+#if defined(MCPP_FEATURE_SIMD)
+#undef CV_SIMD
+#undef CV_SIMD_WIDTH
+#undef CV_SIMD_64F
+#undef CV_SIMD_FP16
+#undef CV_SIMD128
+#undef CV_SIMD128_CPP
+#undef CV_SIMD128_64F
+#undef CV_SIMD128_FP16
+#undef CV_SIMD256
+#undef CV_SIMD256_64F
+#undef CV_SIMD256_FP16
+#undef CV_SIMD512
+#undef CV_SIMD512_64F
+#undef CV_SIMD512_FP16
+#undef CV_SIMD_SCALABLE
+#endif
+
+export namespace mcpplibs::mwrap::opencv::macros {
+inline constexpr auto CV_HAL_ERROR_OK = opencv_m_macro_detail::k_CV_HAL_ERROR_OK;
+inline constexpr auto CV_HAL_ERROR_NOT_IMPLEMENTED = opencv_m_macro_detail::k_CV_HAL_ERROR_NOT_IMPLEMENTED;
+inline constexpr auto CV_HAL_ERROR_UNKNOWN = opencv_m_macro_detail::k_CV_HAL_ERROR_UNKNOWN;
+inline constexpr auto CV_CN_MAX = opencv_m_macro_detail::k_CV_CN_MAX;
+inline constexpr auto CV_CN_SHIFT = opencv_m_macro_detail::k_CV_CN_SHIFT;
+inline constexpr auto CV_DEPTH_MAX = opencv_m_macro_detail::k_CV_DEPTH_MAX;
+inline constexpr auto CV_8U = opencv_m_macro_detail::k_CV_8U;
+inline constexpr auto CV_8S = opencv_m_macro_detail::k_CV_8S;
+inline constexpr auto CV_16U = opencv_m_macro_detail::k_CV_16U;
+inline constexpr auto CV_16S = opencv_m_macro_detail::k_CV_16S;
+inline constexpr auto CV_32S = opencv_m_macro_detail::k_CV_32S;
+inline constexpr auto CV_32F = opencv_m_macro_detail::k_CV_32F;
+inline constexpr auto CV_64F = opencv_m_macro_detail::k_CV_64F;
+inline constexpr auto CV_16F = opencv_m_macro_detail::k_CV_16F;
+inline constexpr auto CV_16BF = opencv_m_macro_detail::k_CV_16BF;
+inline constexpr auto CV_Bool = opencv_m_macro_detail::k_CV_Bool;
+inline constexpr auto CV_64U = opencv_m_macro_detail::k_CV_64U;
+inline constexpr auto CV_64S = opencv_m_macro_detail::k_CV_64S;
+inline constexpr auto CV_32U = opencv_m_macro_detail::k_CV_32U;
+inline constexpr auto CV_DEPTH_CURR_MAX = opencv_m_macro_detail::k_CV_DEPTH_CURR_MAX;
+inline constexpr auto CV_MAT_DEPTH_MASK = opencv_m_macro_detail::k_CV_MAT_DEPTH_MASK;
+inline constexpr auto CV_8UC1 = opencv_m_macro_detail::k_CV_8UC1;
+inline constexpr auto CV_8UC2 = opencv_m_macro_detail::k_CV_8UC2;
+inline constexpr auto CV_8UC3 = opencv_m_macro_detail::k_CV_8UC3;
+inline constexpr auto CV_8UC4 = opencv_m_macro_detail::k_CV_8UC4;
+inline constexpr auto CV_8SC1 = opencv_m_macro_detail::k_CV_8SC1;
+inline constexpr auto CV_8SC2 = opencv_m_macro_detail::k_CV_8SC2;
+inline constexpr auto CV_8SC3 = opencv_m_macro_detail::k_CV_8SC3;
+inline constexpr auto CV_8SC4 = opencv_m_macro_detail::k_CV_8SC4;
+inline constexpr auto CV_16UC1 = opencv_m_macro_detail::k_CV_16UC1;
+inline constexpr auto CV_16UC2 = opencv_m_macro_detail::k_CV_16UC2;
+inline constexpr auto CV_16UC3 = opencv_m_macro_detail::k_CV_16UC3;
+inline constexpr auto CV_16UC4 = opencv_m_macro_detail::k_CV_16UC4;
+inline constexpr auto CV_16SC1 = opencv_m_macro_detail::k_CV_16SC1;
+inline constexpr auto CV_16SC2 = opencv_m_macro_detail::k_CV_16SC2;
+inline constexpr auto CV_16SC3 = opencv_m_macro_detail::k_CV_16SC3;
+inline constexpr auto CV_16SC4 = opencv_m_macro_detail::k_CV_16SC4;
+inline constexpr auto CV_32SC1 = opencv_m_macro_detail::k_CV_32SC1;
+inline constexpr auto CV_32SC2 = opencv_m_macro_detail::k_CV_32SC2;
+inline constexpr auto CV_32SC3 = opencv_m_macro_detail::k_CV_32SC3;
+inline constexpr auto CV_32SC4 = opencv_m_macro_detail::k_CV_32SC4;
+inline constexpr auto CV_32FC1 = opencv_m_macro_detail::k_CV_32FC1;
+inline constexpr auto CV_32FC2 = opencv_m_macro_detail::k_CV_32FC2;
+inline constexpr auto CV_32FC3 = opencv_m_macro_detail::k_CV_32FC3;
+inline constexpr auto CV_32FC4 = opencv_m_macro_detail::k_CV_32FC4;
+inline constexpr auto CV_64FC1 = opencv_m_macro_detail::k_CV_64FC1;
+inline constexpr auto CV_64FC2 = opencv_m_macro_detail::k_CV_64FC2;
+inline constexpr auto CV_64FC3 = opencv_m_macro_detail::k_CV_64FC3;
+inline constexpr auto CV_64FC4 = opencv_m_macro_detail::k_CV_64FC4;
+inline constexpr auto CV_16FC1 = opencv_m_macro_detail::k_CV_16FC1;
+inline constexpr auto CV_16FC2 = opencv_m_macro_detail::k_CV_16FC2;
+inline constexpr auto CV_16FC3 = opencv_m_macro_detail::k_CV_16FC3;
+inline constexpr auto CV_16FC4 = opencv_m_macro_detail::k_CV_16FC4;
+inline constexpr auto CV_64SC1 = opencv_m_macro_detail::k_CV_64SC1;
+inline constexpr auto CV_64SC2 = opencv_m_macro_detail::k_CV_64SC2;
+inline constexpr auto CV_64SC3 = opencv_m_macro_detail::k_CV_64SC3;
+inline constexpr auto CV_64SC4 = opencv_m_macro_detail::k_CV_64SC4;
+inline constexpr auto CV_64UC1 = opencv_m_macro_detail::k_CV_64UC1;
+inline constexpr auto CV_64UC2 = opencv_m_macro_detail::k_CV_64UC2;
+inline constexpr auto CV_64UC3 = opencv_m_macro_detail::k_CV_64UC3;
+inline constexpr auto CV_64UC4 = opencv_m_macro_detail::k_CV_64UC4;
+inline constexpr auto CV_BoolC1 = opencv_m_macro_detail::k_CV_BoolC1;
+inline constexpr auto CV_BoolC2 = opencv_m_macro_detail::k_CV_BoolC2;
+inline constexpr auto CV_BoolC3 = opencv_m_macro_detail::k_CV_BoolC3;
+inline constexpr auto CV_BoolC4 = opencv_m_macro_detail::k_CV_BoolC4;
+inline constexpr auto CV_32UC1 = opencv_m_macro_detail::k_CV_32UC1;
+inline constexpr auto CV_32UC2 = opencv_m_macro_detail::k_CV_32UC2;
+inline constexpr auto CV_32UC3 = opencv_m_macro_detail::k_CV_32UC3;
+inline constexpr auto CV_32UC4 = opencv_m_macro_detail::k_CV_32UC4;
+inline constexpr auto CV_16BFC1 = opencv_m_macro_detail::k_CV_16BFC1;
+inline constexpr auto CV_16BFC2 = opencv_m_macro_detail::k_CV_16BFC2;
+inline constexpr auto CV_16BFC3 = opencv_m_macro_detail::k_CV_16BFC3;
+inline constexpr auto CV_16BFC4 = opencv_m_macro_detail::k_CV_16BFC4;
+inline constexpr auto CV_HAL_CMP_EQ = opencv_m_macro_detail::k_CV_HAL_CMP_EQ;
+inline constexpr auto CV_HAL_CMP_GT = opencv_m_macro_detail::k_CV_HAL_CMP_GT;
+inline constexpr auto CV_HAL_CMP_GE = opencv_m_macro_detail::k_CV_HAL_CMP_GE;
+inline constexpr auto CV_HAL_CMP_LT = opencv_m_macro_detail::k_CV_HAL_CMP_LT;
+inline constexpr auto CV_HAL_CMP_LE = opencv_m_macro_detail::k_CV_HAL_CMP_LE;
+inline constexpr auto CV_HAL_CMP_NE = opencv_m_macro_detail::k_CV_HAL_CMP_NE;
+inline constexpr auto CV_HAL_BORDER_CONSTANT = opencv_m_macro_detail::k_CV_HAL_BORDER_CONSTANT;
+inline constexpr auto CV_HAL_BORDER_REPLICATE = opencv_m_macro_detail::k_CV_HAL_BORDER_REPLICATE;
+inline constexpr auto CV_HAL_BORDER_REFLECT = opencv_m_macro_detail::k_CV_HAL_BORDER_REFLECT;
+inline constexpr auto CV_HAL_BORDER_WRAP = opencv_m_macro_detail::k_CV_HAL_BORDER_WRAP;
+inline constexpr auto CV_HAL_BORDER_REFLECT_101 = opencv_m_macro_detail::k_CV_HAL_BORDER_REFLECT_101;
+inline constexpr auto CV_HAL_BORDER_TRANSPARENT = opencv_m_macro_detail::k_CV_HAL_BORDER_TRANSPARENT;
+inline constexpr auto CV_HAL_BORDER_ISOLATED = opencv_m_macro_detail::k_CV_HAL_BORDER_ISOLATED;
+inline constexpr auto CV_HAL_DFT_INVERSE = opencv_m_macro_detail::k_CV_HAL_DFT_INVERSE;
+inline constexpr auto CV_HAL_DFT_SCALE = opencv_m_macro_detail::k_CV_HAL_DFT_SCALE;
+inline constexpr auto CV_HAL_DFT_ROWS = opencv_m_macro_detail::k_CV_HAL_DFT_ROWS;
+inline constexpr auto CV_HAL_DFT_COMPLEX_OUTPUT = opencv_m_macro_detail::k_CV_HAL_DFT_COMPLEX_OUTPUT;
+inline constexpr auto CV_HAL_DFT_REAL_OUTPUT = opencv_m_macro_detail::k_CV_HAL_DFT_REAL_OUTPUT;
+inline constexpr auto CV_HAL_DFT_TWO_STAGE = opencv_m_macro_detail::k_CV_HAL_DFT_TWO_STAGE;
+inline constexpr auto CV_HAL_DFT_STAGE_COLS = opencv_m_macro_detail::k_CV_HAL_DFT_STAGE_COLS;
+inline constexpr auto CV_HAL_DFT_IS_CONTINUOUS = opencv_m_macro_detail::k_CV_HAL_DFT_IS_CONTINUOUS;
+inline constexpr auto CV_HAL_DFT_IS_INPLACE = opencv_m_macro_detail::k_CV_HAL_DFT_IS_INPLACE;
+inline constexpr auto CV_HAL_SVD_NO_UV = opencv_m_macro_detail::k_CV_HAL_SVD_NO_UV;
+inline constexpr auto CV_HAL_SVD_SHORT_UV = opencv_m_macro_detail::k_CV_HAL_SVD_SHORT_UV;
+inline constexpr auto CV_HAL_SVD_MODIFY_A = opencv_m_macro_detail::k_CV_HAL_SVD_MODIFY_A;
+inline constexpr auto CV_HAL_SVD_FULL_UV = opencv_m_macro_detail::k_CV_HAL_SVD_FULL_UV;
+inline constexpr auto CV_HAL_GEMM_1_T = opencv_m_macro_detail::k_CV_HAL_GEMM_1_T;
+inline constexpr auto CV_HAL_GEMM_2_T = opencv_m_macro_detail::k_CV_HAL_GEMM_2_T;
+inline constexpr auto CV_HAL_GEMM_3_T = opencv_m_macro_detail::k_CV_HAL_GEMM_3_T;
+inline constexpr auto CV_VERSION_MAJOR = opencv_m_macro_detail::k_CV_VERSION_MAJOR;
+inline constexpr auto CV_VERSION_MINOR = opencv_m_macro_detail::k_CV_VERSION_MINOR;
+inline constexpr auto CV_VERSION_REVISION = opencv_m_macro_detail::k_CV_VERSION_REVISION;
+inline constexpr auto CV_VERSION = opencv_m_macro_detail::k_CV_VERSION;
+inline constexpr auto CV_VERSION_STATUS = opencv_m_macro_detail::k_CV_VERSION_STATUS;
+inline constexpr auto CV_PI = opencv_m_macro_detail::k_CV_PI;
+inline constexpr auto CV_2PI = opencv_m_macro_detail::k_CV_2PI;
+inline constexpr auto CV_LOG2 = opencv_m_macro_detail::k_CV_LOG2;
+inline constexpr auto CV_MAX_DIM = opencv_m_macro_detail::k_CV_MAX_DIM;
+inline constexpr auto CV_MAT_CN_MASK = opencv_m_macro_detail::k_CV_MAT_CN_MASK;
+inline constexpr auto CV_MAT_TYPE_MASK = opencv_m_macro_detail::k_CV_MAT_TYPE_MASK;
+inline constexpr auto CV_MAT_CONT_FLAG_SHIFT = opencv_m_macro_detail::k_CV_MAT_CONT_FLAG_SHIFT;
+inline constexpr auto CV_MAT_CONT_FLAG = opencv_m_macro_detail::k_CV_MAT_CONT_FLAG;
+inline constexpr auto CV_SUBMAT_FLAG_SHIFT = opencv_m_macro_detail::k_CV_SUBMAT_FLAG_SHIFT;
+inline constexpr auto CV_SUBMAT_FLAG = opencv_m_macro_detail::k_CV_SUBMAT_FLAG;
+inline constexpr auto CV_AUTOSTEP = opencv_m_macro_detail::k_CV_AUTOSTEP;
+inline constexpr auto CV_HAL_TYPE_5_8 = opencv_m_macro_detail::k_CV_HAL_TYPE_5_8;
+inline constexpr auto CV_HAL_TYPE_7_12 = opencv_m_macro_detail::k_CV_HAL_TYPE_7_12;
+inline constexpr auto CV_HAL_TYPE_9_16 = opencv_m_macro_detail::k_CV_HAL_TYPE_9_16;
+inline constexpr auto CV_HAL_INTER_NEAREST = opencv_m_macro_detail::k_CV_HAL_INTER_NEAREST;
+inline constexpr auto CV_HAL_INTER_LINEAR = opencv_m_macro_detail::k_CV_HAL_INTER_LINEAR;
+inline constexpr auto CV_HAL_INTER_CUBIC = opencv_m_macro_detail::k_CV_HAL_INTER_CUBIC;
+inline constexpr auto CV_HAL_INTER_AREA = opencv_m_macro_detail::k_CV_HAL_INTER_AREA;
+inline constexpr auto CV_HAL_INTER_LANCZOS4 = opencv_m_macro_detail::k_CV_HAL_INTER_LANCZOS4;
+inline constexpr auto CV_HAL_INTER_LINEAR_EXACT = opencv_m_macro_detail::k_CV_HAL_INTER_LINEAR_EXACT;
+inline constexpr auto CV_HAL_INTER_NEAREST_EXACT = opencv_m_macro_detail::k_CV_HAL_INTER_NEAREST_EXACT;
+inline constexpr auto CV_HAL_INTER_MAX = opencv_m_macro_detail::k_CV_HAL_INTER_MAX;
+inline constexpr auto CV_HAL_WARP_FILL_OUTLIERS = opencv_m_macro_detail::k_CV_HAL_WARP_FILL_OUTLIERS;
+inline constexpr auto CV_HAL_WARP_INVERSE_MAP = opencv_m_macro_detail::k_CV_HAL_WARP_INVERSE_MAP;
+inline constexpr auto CV_HAL_WARP_RELATIVE_MAP = opencv_m_macro_detail::k_CV_HAL_WARP_RELATIVE_MAP;
+inline constexpr auto CV_HAL_MORPH_ERODE = opencv_m_macro_detail::k_CV_HAL_MORPH_ERODE;
+inline constexpr auto CV_HAL_MORPH_DILATE = opencv_m_macro_detail::k_CV_HAL_MORPH_DILATE;
+inline constexpr auto CV_HAL_THRESH_BINARY = opencv_m_macro_detail::k_CV_HAL_THRESH_BINARY;
+inline constexpr auto CV_HAL_THRESH_BINARY_INV = opencv_m_macro_detail::k_CV_HAL_THRESH_BINARY_INV;
+inline constexpr auto CV_HAL_THRESH_TRUNC = opencv_m_macro_detail::k_CV_HAL_THRESH_TRUNC;
+inline constexpr auto CV_HAL_THRESH_TOZERO = opencv_m_macro_detail::k_CV_HAL_THRESH_TOZERO;
+inline constexpr auto CV_HAL_THRESH_TOZERO_INV = opencv_m_macro_detail::k_CV_HAL_THRESH_TOZERO_INV;
+inline constexpr auto CV_HAL_THRESH_MASK = opencv_m_macro_detail::k_CV_HAL_THRESH_MASK;
+inline constexpr auto CV_HAL_THRESH_OTSU = opencv_m_macro_detail::k_CV_HAL_THRESH_OTSU;
+inline constexpr auto CV_HAL_THRESH_TRIANGLE = opencv_m_macro_detail::k_CV_HAL_THRESH_TRIANGLE;
+inline constexpr auto CV_HAL_ADAPTIVE_THRESH_MEAN_C = opencv_m_macro_detail::k_CV_HAL_ADAPTIVE_THRESH_MEAN_C;
+inline constexpr auto CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C = opencv_m_macro_detail::k_CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C;
+#if defined(MCPP_FEATURE_SIMD)
+inline constexpr auto CV_SIMD = opencv_m_macro_detail::k_CV_SIMD;
+inline constexpr auto CV_SIMD_WIDTH = opencv_m_macro_detail::k_CV_SIMD_WIDTH;
+inline constexpr auto CV_SIMD_64F = opencv_m_macro_detail::k_CV_SIMD_64F;
+inline constexpr auto CV_SIMD_FP16 = opencv_m_macro_detail::k_CV_SIMD_FP16;
+inline constexpr auto CV_SIMD128 = opencv_m_macro_detail::k_CV_SIMD128;
+inline constexpr auto CV_SIMD128_CPP = opencv_m_macro_detail::k_CV_SIMD128_CPP;
+inline constexpr auto CV_SIMD128_64F = opencv_m_macro_detail::k_CV_SIMD128_64F;
+inline constexpr auto CV_SIMD128_FP16 = opencv_m_macro_detail::k_CV_SIMD128_FP16;
+inline constexpr auto CV_SIMD256 = opencv_m_macro_detail::k_CV_SIMD256;
+inline constexpr auto CV_SIMD256_64F = opencv_m_macro_detail::k_CV_SIMD256_64F;
+inline constexpr auto CV_SIMD256_FP16 = opencv_m_macro_detail::k_CV_SIMD256_FP16;
+inline constexpr auto CV_SIMD512 = opencv_m_macro_detail::k_CV_SIMD512;
+inline constexpr auto CV_SIMD512_64F = opencv_m_macro_detail::k_CV_SIMD512_64F;
+inline constexpr auto CV_SIMD512_FP16 = opencv_m_macro_detail::k_CV_SIMD512_FP16;
+inline constexpr auto CV_SIMD_SCALABLE = opencv_m_macro_detail::k_CV_SIMD_SCALABLE;
+#endif
+constexpr int CV_MAT_DEPTH(int value) { return opencv_m_macro_detail::k_CV_MAT_DEPTH(value); }
+constexpr int CV_IS_INT_TYPE(int value) { return opencv_m_macro_detail::k_CV_IS_INT_TYPE(value); }
+constexpr int CV_IS_FLOAT_TYPE(int value) { return opencv_m_macro_detail::k_CV_IS_FLOAT_TYPE(value); }
+constexpr int CV_MAT_CN(int value) { return opencv_m_macro_detail::k_CV_MAT_CN(value); }
+constexpr int CV_MAT_TYPE(int value) { return opencv_m_macro_detail::k_CV_MAT_TYPE(value); }
+constexpr int CV_IS_MAT_CONT(int value) { return opencv_m_macro_detail::k_CV_IS_MAT_CONT(value); }
+constexpr int CV_IS_CONT_MAT(int value) { return opencv_m_macro_detail::k_CV_IS_CONT_MAT(value); }
+constexpr int CV_ELEM_SIZE1(int value) { return opencv_m_macro_detail::k_CV_ELEM_SIZE1(value); }
+constexpr int CV_ELEM_SIZE(int value) { return opencv_m_macro_detail::k_CV_ELEM_SIZE(value); }
+constexpr int CV_8UC(int value) { return opencv_m_macro_detail::k_CV_8UC(value); }
+constexpr int CV_8SC(int value) { return opencv_m_macro_detail::k_CV_8SC(value); }
+constexpr int CV_16UC(int value) { return opencv_m_macro_detail::k_CV_16UC(value); }
+constexpr int CV_16SC(int value) { return opencv_m_macro_detail::k_CV_16SC(value); }
+constexpr int CV_32SC(int value) { return opencv_m_macro_detail::k_CV_32SC(value); }
+constexpr int CV_32FC(int value) { return opencv_m_macro_detail::k_CV_32FC(value); }
+constexpr int CV_64FC(int value) { return opencv_m_macro_detail::k_CV_64FC(value); }
+constexpr int CV_16FC(int value) { return opencv_m_macro_detail::k_CV_16FC(value); }
+constexpr int CV_64SC(int value) { return opencv_m_macro_detail::k_CV_64SC(value); }
+constexpr int CV_64UC(int value) { return opencv_m_macro_detail::k_CV_64UC(value); }
+constexpr int CV_BoolC(int value) { return opencv_m_macro_detail::k_CV_BoolC(value); }
+constexpr int CV_32UC(int value) { return opencv_m_macro_detail::k_CV_32UC(value); }
+constexpr int CV_16BFC(int value) { return opencv_m_macro_detail::k_CV_16BFC(value); }
+constexpr int CV_MAKETYPE(int depth, int channels) { return opencv_m_macro_detail::k_CV_MAKETYPE(depth, channels); }
+constexpr int CV_MAKE_TYPE(int depth, int channels) { return opencv_m_macro_detail::k_CV_MAKE_TYPE(depth, channels); }
+template<class A, class B, class C, class D>
+constexpr auto CV_FOURCC_MACRO(A a, B b, C c, D d) { return opencv_m_macro_detail::k_CV_FOURCC_MACRO(a, b, c, d); }
+// Repair the upstream 5.0.0 CV_MAT_SUBMAT_FLAG typo for the typed mapping.
+constexpr int CV_IS_SUBMAT(int flags) { return opencv_m_macro_detail::k_CV_IS_SUBMAT(flags); }
+}
diff --git a/src/mat_aug_ops.inc b/src/mat_aug_ops.inc
new file mode 100644
index 0000000..a27c60d
--- /dev/null
+++ b/src/mat_aug_ops.inc
@@ -0,0 +1,601 @@
+// Generated by tools/generate_mat_aug_ops.py; SDK macro bodies/signatures retained.
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator += (Mat& a, const Mat& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator += (const Mat& a, const Mat& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator += (Mat& a, const Scalar& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator += (const Mat& a, const Scalar& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator += (Mat_<_Tp>& a, const Mat& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator += (Mat_<_Tp>& a, const Scalar& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Scalar& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator += (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::add(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator += (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::add(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator += (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::add(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator += (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::add(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::add(a, Mat(b), (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator -= (Mat& a, const Mat& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator -= (const Mat& a, const Mat& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator -= (Mat& a, const Scalar& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator -= (const Mat& a, const Scalar& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator -= (Mat_<_Tp>& a, const Mat& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator -= (Mat_<_Tp>& a, const Scalar& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Scalar& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator -= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::subtract(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator -= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::subtract(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator -= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::subtract(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator -= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::subtract(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::subtract(a, Mat(b), (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator *= (Mat& a, const Mat& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator *= (const Mat& a, const Mat& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator *= (Mat_<_Tp>& a, const Mat& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator *= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::gemm(a, b, 1, Mat(), 0, a, 0); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator *= (Mat& a, const double& b)
+{ a.convertTo(a, -1, b); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator *= (const Mat& a, const double& b)
+{ a.convertTo(a, -1, b); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator *= (Mat_<_Tp>& a, const double& b)
+{ a.convertTo(a, -1, b); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const double& b)
+{ a.convertTo(a, -1, b); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator *= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator *= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator *= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::gemm(a, Mat(b), 1, Mat(), 0, a, 0); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator /= (Mat& a, const Mat& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator /= (const Mat& a, const Mat& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator /= (Mat_<_Tp>& a, const Mat& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator /= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::divide(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator /= (Mat& a, const double& b)
+{ a.convertTo((Mat&)a, -1, 1./b); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator /= (const Mat& a, const double& b)
+{ a.convertTo((Mat&)a, -1, 1./b); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator /= (Mat_<_Tp>& a, const double& b)
+{ a.convertTo((Mat&)a, -1, 1./b); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const double& b)
+{ a.convertTo((Mat&)a, -1, 1./b); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator /= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::divide(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator /= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::divide(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator /= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::divide(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::divide(a, Mat(b), (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator &= (Mat& a, const Mat& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator &= (const Mat& a, const Mat& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator &= (Mat& a, const Scalar& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator &= (const Mat& a, const Scalar& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator &= (Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator &= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator &= (Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator &= (const Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator &= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator &= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_and(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator &= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_and(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator &= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_and(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator &= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_and(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator &= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_and(a, Mat(b), (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator |= (Mat& a, const Mat& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator |= (const Mat& a, const Mat& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator |= (Mat& a, const Scalar& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator |= (const Mat& a, const Scalar& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator |= (Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator |= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator |= (Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator |= (const Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator |= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator |= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_or(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator |= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_or(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator |= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_or(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator |= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_or(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator |= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_or(a, Mat(b), (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator ^= (Mat& a, const Mat& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator ^= (const Mat& a, const Mat& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator ^= (Mat& a, const Scalar& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator ^= (const Mat& a, const Scalar& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator ^= (Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator ^= (const Mat_<_Tp>& a, const Mat& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator ^= (Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator ^= (const Mat_<_Tp>& a, const Scalar& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator ^= (Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator ^= (const Mat_<_Tp>& a, const Mat_<_Tp>& b)
+{ cv::bitwise_xor(a, b, (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat& operator ^= (Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_xor(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat& operator ^= (const Mat& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_xor(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator ^= (Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_xor(a, Mat(b), (const Mat&)a); return a; }
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator ^= (const Mat_<_Tp>& a, const Matx<_Tp,m,n>& b)
+{ cv::bitwise_xor(a, Mat(b), (const Mat&)a); return a; }
+
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator += (Mat& a, const MatExpr& b)
+{
+    b.op->augAssignAdd(b, a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator += (const Mat& a, const MatExpr& b)
+{
+    b.op->augAssignAdd(b, (Mat&)a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator += (Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignAdd(b, a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator += (const Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignAdd(b, (Mat&)a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator -= (Mat& a, const MatExpr& b)
+{
+    b.op->augAssignSubtract(b, a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator -= (const Mat& a, const MatExpr& b)
+{
+    b.op->augAssignSubtract(b, (Mat&)a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator -= (Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignSubtract(b, a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator -= (const Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignSubtract(b, (Mat&)a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator *= (Mat& a, const MatExpr& b)
+{
+    b.op->augAssignMultiply(b, a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator *= (const Mat& a, const MatExpr& b)
+{
+    b.op->augAssignMultiply(b, (Mat&)a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator *= (Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignMultiply(b, a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator *= (const Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignMultiply(b, (Mat&)a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline Mat& operator /= (Mat& a, const MatExpr& b)
+{
+    b.op->augAssignDivide(b, a);
+    return a;
+}
+
+template<class _D = void> requires opencv_m_pick<_D>
+inline const Mat& operator /= (const Mat& a, const MatExpr& b)
+{
+    b.op->augAssignDivide(b, (Mat&)a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline Mat_<_Tp>& operator /= (Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignDivide(b, a);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp>
+inline const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const MatExpr& b)
+{
+    b.op->augAssignDivide(b, (Mat&)a);
+    return a;
+}
+
+template<typename _Tp, typename T2> requires opencv_m_pick<_Tp>
+[[deprecated]] inline MatCommaInitializer_<_Tp> operator << (const Mat_<_Tp>& m, T2 val)
+{
+    MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
+    return (commaInitializer, val);
+}
+} } // cv::opencv_m_repl
diff --git a/src/matx_ops.inc b/src/matx_ops.inc
index 6b578b1..91236b3 100644
--- a/src/matx_ops.inc
+++ b/src/matx_ops.inc
@@ -1,35 +1,15 @@
-// matx_ops.inc — hand-maintained replacement surface for the Matx/Vec
-// algebra (R1): the namespace-scope `static inline` operator templates and
-// reduction helpers of core/matx.hpp + core/matx.inl.hpp, which have
-// internal linkage upstream and cannot cross a module boundary. Textually
-// included after core_ops.inc in the same module purview; upstream's
-// unqualified saturate_cast calls become fully qualified
-// cv::opencv_m_repl::saturate_cast (gcc16 counts GMF-internal upstream
-// declarations as overload candidates during importer-side instantiation —
-// unqualified calls would be ambiguous).
+// Matx/Vec namespace operators and reductions retain SDK template argument order.
+// The adapter imports original class declarations from detail.core before
+// compiling this file in detail.matx. Keeping these exact patterns beside the
+// textual SDK classes in one producer crashes Clang22 importer lookup.
 //
-// These are self-contained reimplementations (no calls into TU-local
-// upstream helpers): the Matx_AddOp/SubOp/ScaleOp/MatMulOp ctor-tag paths
-// and base.hpp's static-inline normL1/normL2Sqr/normInf are replaced by
-// explicit element loops over the public .val arrays, transcribed 1:1 from
-// matx.inl.hpp — accumulator types and saturate_cast placement included.
-// cv::LU and cv::cv_abs are called (CV_EXPORTS resp. plain-inline external
-// linkage upstream — reachable, not redefined).
-//
-// Deliberately NOT replaced here:
-//  * normalize(Vec)      — plain `inline` upstream (external linkage), not
-//    static; already re-exported by gen_exports/core.inc `using cv::normalize;`.
-//  * Matx members (inv/solve/t/mul/div/ddot/…), Vec members (cross/conj/…)
-//    — member functions, cross the boundary with the class.
-//  * operations.hpp augmenting ops (Mat += Matx, Mat_ ^= Matx, …) — static
-//    inline but Mat-based (cv::add/gemm/…); Mat/MatExpr surface lives in
-//    core_ops.inc.
-//  * operations.hpp randu<_Tp>(), format(), print() family — static inline
-//    but not Matx/Vec algebra (Mat/Formatter based), out of R1 scope.
-//
-// Mixed TUs (textual <opencv2/…> include + import): the header's internal
-// operators and these module operators are both visible there — calls on
-// value types become ambiguous. In mixed TUs prefer member/field forms.
+// Arithmetic bodies use the SDK's public .val storage, accumulator types and
+// saturation points. Calls to the module scalar conversion adapter avoid GCC's
+// ambiguous lookup of TU-local SDK saturate_cast during importer instantiation.
+// Original class members (inv/solve/t/mul/div/ddot/cross/conj) are not replaced.
+// Mat/MatExpr forwards live in detail.core. SDK augmented assignments are
+// generated in mat_aug_ops.inc beside this imported-type producer.
+// Full textual SDK mixing still has the documented compiler-specific limits.
 
 export namespace cv {
 // inline namespace: distinct entities from the upstream TU-local ones (no
@@ -37,27 +17,12 @@ export namespace cv {
 // ADL on the importer side, where the upstream internals are invisible.
 inline namespace opencv_m_repl {
 
-// ── Matx comma-initializer (upstream: CV_DEPRECATED_EXTERNAL static inline) ─
-// NOTE all two-typename / extra-NTTP upstream shapes in this file are
-// reformulated over whole deduced operand types: serialized into a module
-// BMI, templates whose parameters are not all pinned by the first argument
-// (e.g. template<typename _Tp, typename _T2, int m, int n>, or the 4-int
-// Matx multiply below) poison clang 20/22's lookup for that NAME — any use
-// of the operator on ANY cv type in an importer segfaults the frontend
-// (AddArgumentDependentLookupCandidates / InstantiateFunctionDefinition;
-// gcc16 fine; minimal repros archived 2026-07-21). The whole-type form has
-// identical call semantics; in mixed TUs upstream's exact-pattern
-// static-inline templates are more specialized and win (they are TU-local
-// and defined there), pure-import TUs only ever see these.
-template<typename _MA, typename _T2>
-    requires opencv_m_pick<typename _MA::value_type>
-          && __is_same(_MA, typename _MA::mat_type)
-CV_DEPRECATED_EXTERNAL inline
-MatxCommaInitializer<typename _MA::value_type, (int)_MA::rows, (int)_MA::cols>
-operator << (const _MA& mtx, _T2 val)
-{
-    using _Tp = typename _MA::value_type;
-    MatxCommaInitializer<_Tp, (int)_MA::rows, (int)_MA::cols> ci((_MA*)&mtx);
+// ── Matx comma-initializer (upstream template argument order retained) ─
+template<typename _Tp, typename _T2, int m, int n> requires opencv_m_pick<_Tp>
+[[deprecated]] inline MatxCommaInitializer<_Tp, m, n>
+operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
+{
+    MatxCommaInitializer<_Tp, m, n> ci((Matx<_Tp, m, n>*)&mtx);
     ci.dst->val[ci.idx++] = cv::opencv_m_repl::saturate_cast<_Tp>(val);
     return ci;
 }
@@ -68,19 +33,9 @@ operator << (const _MA& mtx, _T2 val)
 // the CV_EXPORTS cv::LU proxy (instantiable for float/double only, as
 // upstream). Small-size arithmetic runs in _Tp and converts to double at
 // return, exactly like the upstream functors.
-// determinant: not the upstream-shaped `template<typename _Tp, int m>
-// (const Matx<_Tp, m, m>&)` form — the repeated NTTP inside one parameter
-// type is another spelling of the clang 20/22 BMI ADL-poisoning bug that hit
-// operator* below (any lookup of the NAME determinant in an importer
-// segfaults). Deduce the Matx whole, encode squareness in the constraint.
-template<typename _MA>
-    requires opencv_m_pick<typename _MA::value_type>
-          && __is_same(_MA, typename _MA::mat_type)
-          && ((int)_MA::rows == (int)_MA::cols)
-inline double determinant(const _MA& a)
-{
-    using _Tp = typename _MA::value_type;
-    constexpr int m = (int)_MA::rows;
+template<typename _Tp, int m> requires opencv_m_pick<_Tp>
+inline double determinant(const Matx<_Tp, m, m>& a)
+{
     if constexpr (m == 1)
         return a.val[0];
     else if constexpr (m == 2)
@@ -153,25 +108,17 @@ template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline double n
 }
 
 // ── Matx algebra (upstream: static inline, matx.hpp/matx.inl.hpp) ───────
-template<typename _MA, typename _MB>
-    requires opencv_m_pick<typename _MA::value_type>
-          && __is_same(_MA, typename _MA::mat_type)
-          && __is_same(_MB, Matx<typename _MB::value_type, (int)_MA::rows, (int)_MA::cols>)
-inline _MA& operator += (_MA& a, const _MB& b)
-{
-    using _Tp1 = typename _MA::value_type;
-    for (int i = 0; i < (int)_MA::channels; i++)
+template<typename _Tp1, typename _Tp2, int m, int n> requires opencv_m_pick<_Tp1>
+inline Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
+{
+    for (int i = 0; i < m*n; i++)
         a.val[i] = cv::opencv_m_repl::saturate_cast<_Tp1>(a.val[i] + b.val[i]);
     return a;
 }
-template<typename _MA, typename _MB>
-    requires opencv_m_pick<typename _MA::value_type>
-          && __is_same(_MA, typename _MA::mat_type)
-          && __is_same(_MB, Matx<typename _MB::value_type, (int)_MA::rows, (int)_MA::cols>)
-inline _MA& operator -= (_MA& a, const _MB& b)
+template<typename _Tp1, typename _Tp2, int m, int n> requires opencv_m_pick<_Tp1>
+inline Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
 {
-    using _Tp1 = typename _MA::value_type;
-    for (int i = 0; i < (int)_MA::channels; i++)
+    for (int i = 0; i < m*n; i++)
         a.val[i] = cv::opencv_m_repl::saturate_cast<_Tp1>(a.val[i] - b.val[i]);
     return a;
 }
@@ -302,29 +249,10 @@ Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
         M.val[i] = cv::opencv_m_repl::saturate_cast<_Tp>(a.val[i] * -1);
     return M;
 }
-// Matx x Matx multiplication. NOT the upstream-shaped 4-parameter form
-// (template<typename _Tp, int m, int n, int l> over Matx<_Tp,m,l> x
-// Matx<_Tp,l,n>): serialized into a module BMI, that exact shape poisons
-// clang 20/22's ADL for the NAME operator* — every `x * y` on ANY cv type
-// in an importer segfaults the compiler frontend inside
-// AddArgumentDependentLookupCandidates (gcc16 is fine; minimal repro
-// archived 2026-07-21). Deduce the two Matx operands whole instead:
-// mat_type self-check keeps it Matx-only (a Vec's mat_type is Matx<T,cn,1>,
-// never Vec itself), the value_type/cols==rows checks encode the same
-// dimension contract. In mixed TUs upstream's exact-pattern static-inline
-// template is more specialized and wins (it is TU-local and defined there);
-// pure-import TUs only ever see this one.
-template<typename _MA, typename _MB>
-    requires opencv_m_pick<typename _MA::value_type>
-          && __is_same(_MA, typename _MA::mat_type)
-          && __is_same(_MB, typename _MB::mat_type)
-          && __is_same(typename _MA::value_type, typename _MB::value_type)
-          && ((int)_MA::cols == (int)_MB::rows)
-inline Matx<typename _MA::value_type, (int)_MA::rows, (int)_MB::cols>
-operator * (const _MA& a, const _MB& b)
-{
-    using _Tp = typename _MA::value_type;
-    constexpr int m = (int)_MA::rows, n = (int)_MB::cols, l = (int)_MA::cols;
+// Preserve the SDK template order: element, output rows, output columns, inner dimension.
+template<typename _Tp, int m, int n, int l> requires opencv_m_pick<_Tp>
+inline Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
+{
     Matx<_Tp, m, n> M; // upstream Matx_MatMulOp: _Tp accumulator, no saturate
     for (int i = 0; i < m; i++)
         for (int j = 0; j < n; j++)
@@ -365,15 +293,11 @@ bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
 }
 
 // ── Vec comma-initializer (upstream: CV_DEPRECATED_EXTERNAL static inline) ─
-template<typename _VA, typename _T2>
-    requires opencv_m_pick<typename _VA::value_type>
-          && __is_same(_VA, Vec<typename _VA::value_type, (int)_VA::channels>)
-CV_DEPRECATED_EXTERNAL inline
-VecCommaInitializer<typename _VA::value_type, (int)_VA::channels>
-operator << (const _VA& vec, _T2 val)
-{
-    using _Tp = typename _VA::value_type;
-    VecCommaInitializer<_Tp, (int)_VA::channels> ci((_VA*)&vec);
+template<typename _Tp, typename _T2, int cn> requires opencv_m_pick<_Tp>
+[[deprecated]] inline VecCommaInitializer<_Tp, cn>
+operator << (const Vec<_Tp, cn>& vec, _T2 val)
+{
+    VecCommaInitializer<_Tp, cn> ci((Vec<_Tp, cn>*)&vec);
     ci.dst->val[ci.idx++] = cv::opencv_m_repl::saturate_cast<_Tp>(val);
     return ci;
 }
@@ -381,25 +305,17 @@ operator << (const _VA& vec, _T2 val)
 // ── Vec algebra (upstream: static inline, matx.hpp/matx.inl.hpp) ────────
 // Note: ==/!= and Matx-typed scalar overloads apply to Vec through
 // derived-to-base deduction against the Matx templates above, as upstream.
-template<typename _VA, typename _VB>
-    requires opencv_m_pick<typename _VA::value_type>
-          && __is_same(_VA, Vec<typename _VA::value_type, (int)_VA::channels>)
-          && __is_same(_VB, Vec<typename _VB::value_type, (int)_VA::channels>)
-inline _VA& operator += (_VA& a, const _VB& b)
-{
-    using _Tp1 = typename _VA::value_type;
-    for (int i = 0; i < (int)_VA::channels; i++)
+template<typename _Tp1, typename _Tp2, int cn> requires opencv_m_pick<_Tp1>
+inline Vec<_Tp1, cn>& operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
+{
+    for (int i = 0; i < cn; i++)
         a.val[i] = cv::opencv_m_repl::saturate_cast<_Tp1>(a.val[i] + b.val[i]);
     return a;
 }
-template<typename _VA, typename _VB>
-    requires opencv_m_pick<typename _VA::value_type>
-          && __is_same(_VA, Vec<typename _VA::value_type, (int)_VA::channels>)
-          && __is_same(_VB, Vec<typename _VB::value_type, (int)_VA::channels>)
-inline _VA& operator -= (_VA& a, const _VB& b)
+template<typename _Tp1, typename _Tp2, int cn> requires opencv_m_pick<_Tp1>
+inline Vec<_Tp1, cn>& operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
 {
-    using _Tp1 = typename _VA::value_type;
-    for (int i = 0; i < (int)_VA::channels; i++)
+    for (int i = 0; i < cn; i++)
         a.val[i] = cv::opencv_m_repl::saturate_cast<_Tp1>(a.val[i] - b.val[i]);
     return a;
 }
diff --git a/src/objdetect.cppm b/src/objdetect.cppm
new file mode 100644
index 0000000..27a07ab
--- /dev/null
+++ b/src/objdetect.cppm
@@ -0,0 +1,8 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.objdetect;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.features;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.objdetect;
diff --git a/src/objdetect_constants.inc b/src/objdetect_constants.inc
new file mode 100644
index 0000000..2494fc9
--- /dev/null
+++ b/src/objdetect_constants.inc
@@ -0,0 +1,5 @@
+// Generated by tools/generate_objdetect_constants.py; original SDK float token retained.
+// An explicit scalar avoids importing a deduced-auto initializer through a private SDK object.
+export namespace cv::aruco { inline namespace opencv_m_constants {
+inline constexpr float DEFAULT_VALID_BIT_ID_THRESHOLD = 0.49f;
+} }
diff --git a/src/opencv.cppm b/src/opencv.cppm
index a16765a..5fce054 100644
--- a/src/opencv.cppm
+++ b/src/opencv.cppm
@@ -1,6 +1,9 @@
-// opencv — library-root module (mcpp convention: src/<package>.cppm).
-// Everything lives in opencv.cv and the per-module interfaces; this root
-// simply forwards so `import opencv;` also works.
-export module opencv;
+export module mcpplibs.mwrap.opencv;
 
-export import opencv.cv;
+// Preload the internal producers before core: GCC's cross-package self-test
+// mapper otherwise falls back to bare BMI names while reading core's imports.
+export import mcpplibs.mwrap.opencv.detail.core;
+export import mcpplibs.mwrap.opencv.detail.matx;
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.macros;
+export import mcpplibs.mwrap.opencv.detail.selected;
diff --git a/src/persistence_ops.inc b/src/persistence_ops.inc
new file mode 100644
index 0000000..c4a09ba
--- /dev/null
+++ b/src/persistence_ops.inc
@@ -0,0 +1,639 @@
+// Generated by tools/generate_persistence.py; SDK bodies retained with module-safe lookup.
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+namespace opencv_m_persistence_up {
+inline constexpr auto insert_string = static_cast<cv::FileStorage&(*)(cv::FileStorage&, const cv::String&)>(&cv::operator<<);
+inline constexpr auto equal = static_cast<bool(*)(const cv::FileNodeIterator&, const cv::FileNodeIterator&)>(&cv::operator==);
+inline constexpr auto unequal = static_cast<bool(*)(const cv::FileNodeIterator&, const cv::FileNodeIterator&)>(&cv::operator!=);
+}
+export namespace cv { inline namespace opencv_m_repl {
+template<class _D = void> requires opencv_m_pick<_D>
+inline FileStorage& operator<<(FileStorage& fs, const String& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<KeyPoint>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<DMatch>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<KeyPoint>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<DMatch>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator==(const FileNodeIterator& a, const FileNodeIterator& b);
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator!=(const FileNodeIterator& a, const FileNodeIterator& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Point_<_Tp>& value, const Point_<_Tp>& default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Point3_<_Tp>& value, const Point3_<_Tp>& default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Size_<_Tp>& value, const Size_<_Tp>& default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Complex<_Tp>& value, const Complex<_Tp>& default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Rect_<_Tp>& value, const Rect_<_Tp>& default_value);
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Vec<_Tp, cn>& value, const Vec<_Tp, cn>& default_value);
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Matx<_Tp, m, n>& value, const Matx<_Tp, m, n>& default_matx = Matx<_Tp, m, n>());
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Scalar_<_Tp>& value, const Scalar_<_Tp>& default_value);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, Range& value, const Range& default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const _Tp& value);
+template<> inline void write( FileStorage& fs, const int& value );
+template<> inline void write( FileStorage& fs, const float& value );
+template<> inline void write( FileStorage& fs, const double& value );
+template<> inline void write( FileStorage& fs, const String& value );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Point_<_Tp>& pt );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Point3_<_Tp>& pt );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Size_<_Tp>& sz );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Complex<_Tp>& c );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Rect_<_Tp>& r );
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Vec<_Tp, cn>& v );
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Matx<_Tp, m, n>& x );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Scalar_<_Tp>& s );
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const Range& r );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write( FileStorage& fs, const std::vector<_Tp>& vec );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Point_<_Tp>& pt );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Point3_<_Tp>& pt );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Size_<_Tp>& sz );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Complex<_Tp>& c );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Rect_<_Tp>& r );
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Vec<_Tp, cn>& v );
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Matx<_Tp, m, n>& x );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Scalar_<_Tp>& s );
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const Range& r );
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const KeyPoint& kpt);
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const DMatch& m);
+template<typename _Tp, void* _Enable = nullptr> requires (std::is_enum_v<_Tp> && opencv_m_pick<_Tp>) inline void write( FileStorage& fs, const String& name, const _Tp& val );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write( FileStorage& fs, const String& name, const std::vector<_Tp>& vec );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write( FileStorage& fs, const String& name, const std::vector< std::vector<_Tp> >& vec );
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const KeyPoint& kpt);
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const DMatch& m);
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const std::vector<KeyPoint>& vec);
+template<class _D = void> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const std::vector<DMatch>& vec);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, bool& value, bool default_value);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, uchar& value, uchar default_value);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, schar& value, schar default_value);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, ushort& value, ushort default_value);
+template<class _D = void> requires opencv_m_pick<_D> inline void read(const FileNode& node, short& value, short default_value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read( FileNodeIterator& it, std::vector<_Tp>& vec, size_t maxCount = (size_t)INT_MAX );
+template<typename _Tp, void* _Enable = nullptr> requires (std::is_enum_v<_Tp> && opencv_m_pick<_Tp>) inline void read(const FileNode& node, _Tp& value, const _Tp& default_value = static_cast<_Tp>(0));
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read( const FileNode& node, std::vector<_Tp>& vec, const std::vector<_Tp>& default_value = std::vector<_Tp>() );
+template<class _D = void> requires opencv_m_pick<_D> inline void read( const FileNode& node, std::vector<KeyPoint>& vec, const std::vector<KeyPoint>& default_value );
+template<class _D = void> requires opencv_m_pick<_D> inline void read( const FileNode& node, std::vector<DMatch>& vec, const std::vector<DMatch>& default_value );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileStorage& operator << (FileStorage& fs, const _Tp& value);
+template<class _D = void> requires opencv_m_pick<_D> inline FileStorage& operator << (FileStorage& fs, const char* str);
+template<class _D = void> requires opencv_m_pick<_D> inline FileStorage& operator << (FileStorage& fs, char* value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileNodeIterator& operator >> (FileNodeIterator& it, _Tp& value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileNodeIterator& operator >> (FileNodeIterator& it, std::vector<_Tp>& vec);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void operator >> (const FileNode& n, _Tp& value);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void operator >> (const FileNode& n, std::vector<_Tp>& vec);
+template<class _D = void> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, KeyPoint& kpt);
+template<class _D = void> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, std::vector<KeyPoint>& vec);
+template<class _D = void> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, std::vector<DMatch>& vec);
+template<class _D = void> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, DMatch& m);
+template<class _D = void> requires opencv_m_pick<_D> inline ptrdiff_t operator - (const FileNodeIterator& it1, const FileNodeIterator& it2);
+template<class _D = void> requires opencv_m_pick<_D> inline bool operator < (const FileNodeIterator& it1, const FileNodeIterator& it2);
+} }
+namespace cv::opencv_m_storage_detail {
+template<class T> void write_value(FileStorage& fs, const String& name, const T& value) {
+    if constexpr (requires { ::cv::opencv_m_repl::write(fs, name, value); })
+        ::cv::opencv_m_repl::write(fs, name, value);
+    else write(fs, name, value); // upstream custom-type ADL extension
+}
+template<class T> void read_value(const FileNode& node, T& value, const T& fallback) {
+    if constexpr (requires { ::cv::opencv_m_repl::read(node, value, fallback); })
+        ::cv::opencv_m_repl::read(node, value, fallback);
+    else read(node, value, fallback); // upstream custom-type ADL extension
+}
+template<typename _Tp, int numflag> class VecWriterProxy
+    {
+    public:
+        VecWriterProxy( FileStorage* _fs ) : fs(_fs) {}
+        void operator()(const std::vector<_Tp>& vec) const
+        {
+            size_t count = vec.size();
+            for (size_t i = 0; i < count; i++)
+                ::cv::opencv_m_repl::write(*fs, vec[i]);
+        }
+    private:
+        FileStorage* fs;
+    };
+
+    template<typename _Tp> class VecWriterProxy<_Tp, 1>
+    {
+    public:
+        VecWriterProxy( FileStorage* _fs ) : fs(_fs) {}
+        void operator()(const std::vector<_Tp>& vec) const
+        {
+            int _fmt = traits::SafeFmt<_Tp>::fmt;
+            char fmt[] = { (char)((_fmt >> 8) + '1'), (char)_fmt, '\0' };
+            fs->writeRaw(fmt, !vec.empty() ? (uchar*)&vec[0] : 0, vec.size() * sizeof(_Tp));
+        }
+    private:
+        FileStorage* fs;
+    };
+
+    template<typename _Tp, int numflag> class VecReaderProxy
+    {
+    public:
+        VecReaderProxy( FileNodeIterator* _it ) : it(_it) {}
+        void operator()(std::vector<_Tp>& vec, size_t count) const
+        {
+            count = std::min(count, it->remaining());
+            vec.resize(count);
+            for (size_t i = 0; i < count; i++, ++(*it))
+                ::cv::opencv_m_storage_detail::read_value(**it, vec[i], _Tp());
+        }
+    private:
+        FileNodeIterator* it;
+    };
+
+    template<typename _Tp> class VecReaderProxy<_Tp, 1>
+    {
+    public:
+        VecReaderProxy( FileNodeIterator* _it ) : it(_it) {}
+        void operator()(std::vector<_Tp>& vec, size_t count) const
+        {
+            size_t remaining = it->remaining();
+            size_t cn = DataType<_Tp>::channels;
+            int _fmt = traits::SafeFmt<_Tp>::fmt;
+            CV_Assert((_fmt >> 8) < 9);
+            char fmt[] = { (char)((_fmt >> 8)+'1'), (char)_fmt, '\0' };
+            CV_Assert((remaining % cn) == 0);
+            size_t remaining1 = remaining / cn;
+            count = count > remaining1 ? remaining1 : count;
+            vec.resize(count);
+            it->readRaw(fmt, !vec.empty() ? (uchar*)&vec[0] : 0, count*sizeof(_Tp));
+        }
+    private:
+        FileNodeIterator* it;
+    };
+} // cv::opencv_m_storage_detail
+export namespace cv { inline namespace opencv_m_repl {
+template<class _D> requires opencv_m_pick<_D>
+inline FileStorage& operator<<(FileStorage& fs, const String& value) { return ::opencv_m_persistence_up::insert_string(fs, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<KeyPoint>& value) { ::opencv_m_fns_up::wr_vkp(fs, name, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<DMatch>& value) { ::opencv_m_fns_up::wr_vdm(fs, name, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<KeyPoint>& value) { ::opencv_m_fns_up::rd_vkp(node, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<DMatch>& value) { ::opencv_m_fns_up::rd_vdm(node, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline bool operator==(const FileNodeIterator& a, const FileNodeIterator& b) { return ::opencv_m_persistence_up::equal(a, b); }
+template<class _D> requires opencv_m_pick<_D>
+inline bool operator!=(const FileNodeIterator& a, const FileNodeIterator& b) { return ::opencv_m_persistence_up::unequal(a, b); }
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Point_<_Tp>& value, const Point_<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 2 ? default_value : Point_<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Point3_<_Tp>& value, const Point3_<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 3 ? default_value : Point3_<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]),
+                                                            saturate_cast<_Tp>(temp[2]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Size_<_Tp>& value, const Size_<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 2 ? default_value : Size_<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Complex<_Tp>& value, const Complex<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 2 ? default_value : Complex<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Rect_<_Tp>& value, const Rect_<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 4 ? default_value : Rect_<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]),
+                                                          saturate_cast<_Tp>(temp[2]), saturate_cast<_Tp>(temp[3]));
+}
+
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Vec<_Tp, cn>& value, const Vec<_Tp, cn>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != cn ? default_value : Vec<_Tp, cn>(&temp[0]);
+}
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Matx<_Tp, m, n>& value, const Matx<_Tp, m, n>& default_matx)
+{
+    Mat temp;
+    ::cv::opencv_m_repl::read(node, temp); // read as a Mat class
+
+    if (temp.empty())
+        value = default_matx;
+    else
+        value = Matx<_Tp, m, n>(temp);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, Scalar_<_Tp>& value, const Scalar_<_Tp>& default_value)
+{
+    std::vector<_Tp> temp; FileNodeIterator it = node.begin(); ::cv::opencv_m_repl::operator>>(it, temp);
+    value = temp.size() != 4 ? default_value : Scalar_<_Tp>(saturate_cast<_Tp>(temp[0]), saturate_cast<_Tp>(temp[1]),
+                                                            saturate_cast<_Tp>(temp[2]), saturate_cast<_Tp>(temp[3]));
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, Range& value, const Range& default_value)
+{
+    Point2i temp(value.start, value.end); const Point2i default_temp = Point2i(default_value.start, default_value.end);
+    ::cv::opencv_m_repl::read(node, temp, default_temp);
+    value.start = temp.x; value.end = temp.y;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const _Tp& value)
+{
+    ::cv::opencv_m_storage_detail::write_value(fs, String(), value);
+}
+
+template<> inline void write(FileStorage& fs, const int& value)
+{
+    writeScalar(fs, value);
+}
+
+template<> inline void write(FileStorage& fs, const float& value)
+{
+    writeScalar(fs, value);
+}
+
+template<> inline void write(FileStorage& fs, const double& value)
+{
+    writeScalar(fs, value);
+}
+
+template<> inline void write(FileStorage& fs, const String& value)
+{
+    writeScalar(fs, value);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Point_<_Tp>& pt)
+{
+    ::cv::opencv_m_repl::write(fs, pt.x);
+    ::cv::opencv_m_repl::write(fs, pt.y);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Point3_<_Tp>& pt)
+{
+    ::cv::opencv_m_repl::write(fs, pt.x);
+    ::cv::opencv_m_repl::write(fs, pt.y);
+    ::cv::opencv_m_repl::write(fs, pt.z);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Size_<_Tp>& sz)
+{
+    ::cv::opencv_m_repl::write(fs, sz.width);
+    ::cv::opencv_m_repl::write(fs, sz.height);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Complex<_Tp>& c)
+{
+    ::cv::opencv_m_repl::write(fs, c.re);
+    ::cv::opencv_m_repl::write(fs, c.im);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Rect_<_Tp>& r)
+{
+    ::cv::opencv_m_repl::write(fs, r.x);
+    ::cv::opencv_m_repl::write(fs, r.y);
+    ::cv::opencv_m_repl::write(fs, r.width);
+    ::cv::opencv_m_repl::write(fs, r.height);
+}
+
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Vec<_Tp, cn>& v)
+{
+    for(int i = 0; i < cn; i++)
+        ::cv::opencv_m_repl::write(fs, v.val[i]);
+}
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Matx<_Tp, m, n>& x)
+{
+    ::cv::opencv_m_repl::write(fs, Mat(x)); // write as a Mat class
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const Scalar_<_Tp>& s)
+{
+    ::cv::opencv_m_repl::write(fs, s.val[0]);
+    ::cv::opencv_m_repl::write(fs, s.val[1]);
+    ::cv::opencv_m_repl::write(fs, s.val[2]);
+    ::cv::opencv_m_repl::write(fs, s.val[3]);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const Range& r)
+{
+    ::cv::opencv_m_repl::write(fs, r.start);
+    ::cv::opencv_m_repl::write(fs, r.end);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const std::vector<_Tp>& vec)
+{
+    ::cv::opencv_m_storage_detail::VecWriterProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> w(&fs);
+    w(vec);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Point_<_Tp>& pt)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, pt);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Point3_<_Tp>& pt)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, pt);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Size_<_Tp>& sz)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, sz);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Complex<_Tp>& c)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, c);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Rect_<_Tp>& r)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, r);
+}
+
+template<typename _Tp, int cn> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Vec<_Tp, cn>& v)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, v);
+}
+
+template<typename _Tp, int m, int n> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Matx<_Tp, m, n>& x)
+{
+    ::cv::opencv_m_repl::write(fs, name, Mat(x)); // write as a Mat class
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const Scalar_<_Tp>& s)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, s);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const Range& r)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, r);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const KeyPoint& kpt)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, kpt.pt.x);
+    ::cv::opencv_m_repl::write(fs, kpt.pt.y);
+    ::cv::opencv_m_repl::write(fs, kpt.size);
+    ::cv::opencv_m_repl::write(fs, kpt.angle);
+    ::cv::opencv_m_repl::write(fs, kpt.response);
+    ::cv::opencv_m_repl::write(fs, kpt.octave);
+    ::cv::opencv_m_repl::write(fs, kpt.class_id);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const String& name, const DMatch& m)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
+    ::cv::opencv_m_repl::write(fs, m.queryIdx);
+    ::cv::opencv_m_repl::write(fs, m.trainIdx);
+    ::cv::opencv_m_repl::write(fs, m.imgIdx);
+    ::cv::opencv_m_repl::write(fs, m.distance);
+}
+
+template<typename _Tp, void* _Enable> requires (std::is_enum_v<_Tp> && opencv_m_pick<_Tp>) inline void write(FileStorage& fs, const String& name, const _Tp& val)
+{
+    ::cv::opencv_m_repl::write(fs, name, static_cast<int>(val));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const std::vector<_Tp>& vec)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ+(traits::SafeFmt<_Tp>::fmt != 0 ? FileNode::FLOW : 0));
+    ::cv::opencv_m_repl::write(fs, vec);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void write(FileStorage& fs, const String& name, const std::vector< std::vector<_Tp> >& vec)
+{
+    cv::internal::WriteStructContext ws(fs, name, FileNode::SEQ);
+    for(size_t i = 0; i < vec.size(); i++)
+    {
+        cv::internal::WriteStructContext ws_(fs, name, FileNode::SEQ+(traits::SafeFmt<_Tp>::fmt != 0 ? FileNode::FLOW : 0));
+        ::cv::opencv_m_repl::write(fs, vec[i]);
+    }
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const KeyPoint& kpt)
+{ ::cv::opencv_m_repl::write(fs, String(), kpt); }
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const DMatch& m)
+{ ::cv::opencv_m_repl::write(fs, String(), m); }
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const std::vector<KeyPoint>& vec)
+{
+    ::cv::opencv_m_storage_detail::VecWriterProxy<KeyPoint, 0> w(&fs);
+    w(vec);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void write(FileStorage& fs, const std::vector<DMatch>& vec)
+{
+    ::cv::opencv_m_storage_detail::VecWriterProxy<DMatch, 0> w(&fs);
+    w(vec);
+
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, bool& value, bool default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, (int)default_value);
+    value = temp != 0;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, uchar& value, uchar default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, (int)default_value);
+    value = saturate_cast<uchar>(temp);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, schar& value, schar default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, (int)default_value);
+    value = saturate_cast<schar>(temp);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, ushort& value, ushort default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, (int)default_value);
+    value = saturate_cast<ushort>(temp);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, short& value, short default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, (int)default_value);
+    value = saturate_cast<short>(temp);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(FileNodeIterator& it, std::vector<_Tp>& vec, size_t maxCount)
+{
+    ::cv::opencv_m_storage_detail::VecReaderProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> r(&it);
+    r(vec, maxCount);
+}
+
+template<typename _Tp, void* _Enable> requires (std::is_enum_v<_Tp> && opencv_m_pick<_Tp>) inline void read(const FileNode& node, _Tp& value, const _Tp& default_value)
+{
+    int temp;
+    ::cv::opencv_m_repl::read(node, temp, static_cast<int>(default_value));
+    value = static_cast<_Tp>(temp);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void read(const FileNode& node, std::vector<_Tp>& vec, const std::vector<_Tp>& default_value)
+{
+    if(node.empty())
+        vec = default_value;
+    else
+    {
+        FileNodeIterator it = node.begin();
+        ::cv::opencv_m_repl::read( it, vec );
+    }
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, std::vector<KeyPoint>& vec, const std::vector<KeyPoint>& default_value)
+{
+    if(node.empty())
+        vec = default_value;
+    else
+        ::cv::opencv_m_repl::read(node, vec);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void read(const FileNode& node, std::vector<DMatch>& vec, const std::vector<DMatch>& default_value)
+{
+    if(node.empty())
+        vec = default_value;
+    else
+        ::cv::opencv_m_repl::read(node, vec);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileStorage& operator << (FileStorage& fs, const _Tp& value)
+{
+    if( !fs.isOpened() )
+        return fs;
+    if( fs.state == FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP )
+        CV_Error( Error::StsError, "No element name has been given" );
+    ::cv::opencv_m_storage_detail::write_value(fs, fs.elname, value);
+    if( fs.state & FileStorage::INSIDE_MAP )
+        fs.state = FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP;
+    return fs;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline FileStorage& operator << (FileStorage& fs, const char* str)
+{
+    return ::opencv_m_persistence_up::insert_string(fs, String(str));
+}
+
+template<class _D> requires opencv_m_pick<_D> inline FileStorage& operator << (FileStorage& fs, char* value)
+{
+    return ::opencv_m_persistence_up::insert_string(fs, String(value));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileNodeIterator& operator >> (FileNodeIterator& it, _Tp& value)
+{
+    ::cv::opencv_m_storage_detail::read_value(*it, value, _Tp());
+    return ++it;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline FileNodeIterator& operator >> (FileNodeIterator& it, std::vector<_Tp>& vec)
+{
+    ::cv::opencv_m_storage_detail::VecReaderProxy<_Tp, traits::SafeFmt<_Tp>::fmt != 0> r(&it);
+    r(vec, (size_t)INT_MAX);
+    return it;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void operator >> (const FileNode& n, _Tp& value)
+{
+    ::cv::opencv_m_storage_detail::read_value(n, value, _Tp());
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline void operator >> (const FileNode& n, std::vector<_Tp>& vec)
+{
+    FileNodeIterator it = n.begin();
+    ::cv::opencv_m_repl::operator>>(it, vec);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, KeyPoint& kpt)
+{
+    FileNodeIterator it = n.begin();
+    ::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(it, kpt.pt.x), kpt.pt.y), kpt.size), kpt.angle), kpt.response), kpt.octave), kpt.class_id);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, std::vector<KeyPoint>& vec)
+{
+    ::cv::opencv_m_repl::read(n, vec);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, std::vector<DMatch>& vec)
+{
+    ::cv::opencv_m_repl::read(n, vec);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline void operator >> (const FileNode& n, DMatch& m)
+{
+    FileNodeIterator it = n.begin();
+    ::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(::cv::opencv_m_repl::operator>>(it, m.queryIdx), m.trainIdx), m.imgIdx), m.distance);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline ptrdiff_t operator - (const FileNodeIterator& it1, const FileNodeIterator& it2)
+{
+    return it2.remaining() - it1.remaining();
+}
+
+template<class _D> requires opencv_m_pick<_D> inline bool operator < (const FileNodeIterator& it1, const FileNodeIterator& it2)
+{
+    return it1.remaining() > it2.remaining();
+}
+} } // cv::opencv_m_repl
diff --git a/src/photo.cppm b/src/photo.cppm
new file mode 100644
index 0000000..84851a3
--- /dev/null
+++ b/src/photo.cppm
@@ -0,0 +1,7 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.photo;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.photo;
diff --git a/src/portable_helpers.inc b/src/portable_helpers.inc
new file mode 100644
index 0000000..74a4bfc
--- /dev/null
+++ b/src/portable_helpers.inc
@@ -0,0 +1,307 @@
+// Generated by tools/generate_inline_helpers.py; SDK bodies with module lookup/raw-array fixes.
+// SDK source: core/base.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normL2Sqr(const _Tp* a, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+    {
+        _AccTp v = (_AccTp)a[i];
+        s += v*v;
+    }
+    return s;
+}
+
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normL1(const _Tp* a, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+        s += ::cv::cv_abs(a[i]);
+    return s;
+}
+
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normInf(const _Tp* a, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+        s = std::max(s, (_AccTp)::cv::cv_abs(a[i]));
+    return s;
+}
+
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normL2Sqr(const _Tp* a, const _Tp* b, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+    {
+        _AccTp v = (_AccTp)a[i] - (_AccTp)b[i];
+        s += v*v;
+    }
+    return s;
+}
+
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normL1(const _Tp* a, const _Tp* b, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+        s += (_AccTp)::cv::cv_absdiff(a[i], b[i]);
+    return s;
+}
+
+template<typename _Tp, typename _AccTp> requires opencv_m_pick<void>
+inline _AccTp normInf(const _Tp* a, const _Tp* b, int n)
+{
+    _AccTp s = 0;
+    for( int i = 0; i < n; i++ )
+        s = std::max(s, (_AccTp)::cv::cv_absdiff(a[i], b[i]));
+    return s;
+}
+
+} } // cv::opencv_m_repl
+// SDK source: core/utility.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<int N, typename T> requires opencv_m_pick<void>
+inline bool isAligned(const T& data)
+{
+    CV_StaticAssert((N & (N - 1)) == 0, "");  // power of 2
+    return (((size_t)data) & (N - 1)) == 0;
+}
+
+template<int N> requires opencv_m_pick<void>
+inline bool isAligned(const void* p1)
+{
+    return ::cv::opencv_m_repl::isAligned<N>((size_t)p1);
+}
+
+template<int N> requires opencv_m_pick<void>
+inline bool isAligned(const void* p1, const void* p2)
+{
+    return ::cv::opencv_m_repl::isAligned<N>(((size_t)p1)|((size_t)p2));
+}
+
+template<int N> requires opencv_m_pick<void>
+inline bool isAligned(const void* p1, const void* p2, const void* p3)
+{
+    return ::cv::opencv_m_repl::isAligned<N>(((size_t)p1)|((size_t)p2)|((size_t)p3));
+}
+
+template<int N> requires opencv_m_pick<void>
+inline bool isAligned(const void* p1, const void* p2, const void* p3, const void* p4)
+{
+    return ::cv::opencv_m_repl::isAligned<N>(((size_t)p1)|((size_t)p2)|((size_t)p3)|((size_t)p4));
+}
+
+} } // cv::opencv_m_repl
+// SDK source: core/types.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<typename _Tp> requires opencv_m_pick<void>
+inline double jaccardDistance(const Rect_<_Tp>& a, const Rect_<_Tp>& b)
+{
+    _Tp Aa = a.area();
+    _Tp Ab = b.area();
+
+    if ((Aa + Ab) <= std::numeric_limits<_Tp>::epsilon()) {
+        // jaccard_index = 1 -> distance = 0
+        return 0.0;
+    }
+
+    double Aab = (a & b).area();
+    // distance = 1 - jaccard_index
+    return 1.0 - Aab / (Aa + Ab - Aab);
+}
+
+} } // cv::opencv_m_repl
+// SDK source: core/mat.inl.hpp
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<typename _Tp> requires opencv_m_pick<void>
+inline _InputArray rawIn(_Tp& v)
+{ return _InputArray::rawIn(v); }
+
+template<typename _Tp> requires opencv_m_pick<void>
+inline _OutputArray rawOut(_Tp& v)
+{ return _OutputArray::rawOut(v); }
+
+template<typename _Tp> requires opencv_m_pick<void>
+inline _InputOutputArray rawInOut(_Tp& v)
+{ return _InputOutputArray().rawInOut(v); }
+
+} } // cv::opencv_m_repl
diff --git a/src/ptcloud.cppm b/src/ptcloud.cppm
new file mode 100644
index 0000000..32aeb87
--- /dev/null
+++ b/src/ptcloud.cppm
@@ -0,0 +1,8 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.ptcloud;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.flann;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.ptcloud;
diff --git a/src/saturate_ops.inc b/src/saturate_ops.inc
new file mode 100644
index 0000000..8016f61
--- /dev/null
+++ b/src/saturate_ops.inc
@@ -0,0 +1,202 @@
+// Generated by tools/generate_saturate.py; included inside cv::opencv_m_repl.
+// Upstream overloads/bodies are retained; only the module constraint and cvRound bridge differ.
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2014, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//! @addtogroup core_utils
+//! @{
+
+/////////////// saturate_cast (used in image & signal processing) ///////////////////
+
+/** @brief Template function for accurate conversion from one primitive type to another.
+
+ The function saturate_cast resembles the standard C++ cast operations, such as static_cast\<T\>()
+ and others. It perform an efficient and accurate conversion from one primitive type to another
+ (see the introduction chapter). saturate in the name means that when the input value v is out of the
+ range of the target type, the result is not formed just by taking low bits of the input, but instead
+ the value is clipped. For example:
+ @code
+ uchar a = saturate_cast<uchar>(-100); // a = 0 (UCHAR_MIN)
+ short b = saturate_cast<short>(33333.33333); // b = 32767 (SHRT_MAX)
+ @endcode
+ Such clipping is done when the target type is unsigned char , signed char , unsigned short or
+ signed short . For 32-bit integers, no clipping is done.
+
+ When the parameter is a floating-point value and the target type is an integer (8-, 16- or 32-bit),
+ the floating-point value is first rounded to the nearest integer and then clipped if needed (when
+ the target type is 8- or 16-bit).
+
+ @param v Function parameter.
+ @sa add, subtract, multiply, divide, Mat::convertTo
+ */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(uchar v)    { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(schar v)    { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(ushort v)   { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(short v)    { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(unsigned v) { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(int v)      { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(float v)    { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(double v)   { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(int64 v)    { return _Tp(v); }
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(uint64 v)   { return _Tp(v); }
+
+template<> inline uchar saturate_cast<uchar>(schar v)        { return (uchar)std::max((int)v, 0); }
+template<> inline uchar saturate_cast<uchar>(ushort v)       { return (uchar)std::min((unsigned)v, (unsigned)UCHAR_MAX); }
+template<> inline uchar saturate_cast<uchar>(int v)          { return (uchar)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
+template<> inline uchar saturate_cast<uchar>(short v)        { return saturate_cast<uchar>((int)v); }
+template<> inline uchar saturate_cast<uchar>(unsigned v)     { return (uchar)std::min(v, (unsigned)UCHAR_MAX); }
+template<> inline uchar saturate_cast<uchar>(float v)        { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<uchar>(iv); }
+template<> inline uchar saturate_cast<uchar>(double v)       { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<uchar>(iv); }
+template<> inline uchar saturate_cast<uchar>(int64 v)        { return (uchar)((uint64)v <= (uint64)UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
+template<> inline uchar saturate_cast<uchar>(uint64 v)       { return (uchar)std::min(v, (uint64)UCHAR_MAX); }
+
+template<> inline schar saturate_cast<schar>(uchar v)        { return (schar)std::min((int)v, SCHAR_MAX); }
+template<> inline schar saturate_cast<schar>(ushort v)       { return (schar)std::min((unsigned)v, (unsigned)SCHAR_MAX); }
+template<> inline schar saturate_cast<schar>(int v)          { return (schar)((unsigned)(v-SCHAR_MIN) <= (unsigned)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN); }
+template<> inline schar saturate_cast<schar>(short v)        { return saturate_cast<schar>((int)v); }
+template<> inline schar saturate_cast<schar>(unsigned v)     { return (schar)std::min(v, (unsigned)SCHAR_MAX); }
+template<> inline schar saturate_cast<schar>(float v)        { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<schar>(iv); }
+template<> inline schar saturate_cast<schar>(double v)       { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<schar>(iv); }
+template<> inline schar saturate_cast<schar>(int64 v)        { return (schar)((uint64)((int64)v-SCHAR_MIN) <= (uint64)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN); }
+template<> inline schar saturate_cast<schar>(uint64 v)       { return (schar)std::min(v, (uint64)SCHAR_MAX); }
+
+template<> inline ushort saturate_cast<ushort>(schar v)      { return (ushort)std::max((int)v, 0); }
+template<> inline ushort saturate_cast<ushort>(short v)      { return (ushort)std::max((int)v, 0); }
+template<> inline ushort saturate_cast<ushort>(int v)        { return (ushort)((unsigned)v <= (unsigned)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
+template<> inline ushort saturate_cast<ushort>(unsigned v)   { return (ushort)std::min(v, (unsigned)USHRT_MAX); }
+template<> inline ushort saturate_cast<ushort>(float v)      { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<ushort>(iv); }
+template<> inline ushort saturate_cast<ushort>(double v)     { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<ushort>(iv); }
+template<> inline ushort saturate_cast<ushort>(int64 v)      { return (ushort)((uint64)v <= (uint64)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
+template<> inline ushort saturate_cast<ushort>(uint64 v)     { return (ushort)std::min(v, (uint64)USHRT_MAX); }
+
+template<> inline short saturate_cast<short>(ushort v)       { return (short)std::min((int)v, SHRT_MAX); }
+template<> inline short saturate_cast<short>(int v)          { return (short)((unsigned)(v - SHRT_MIN) <= (unsigned)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN); }
+template<> inline short saturate_cast<short>(unsigned v)     { return (short)std::min(v, (unsigned)SHRT_MAX); }
+template<> inline short saturate_cast<short>(float v)        { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<short>(iv); }
+template<> inline short saturate_cast<short>(double v)       { int iv = ::opencv_m_scalar_bridge::round32(v); return saturate_cast<short>(iv); }
+template<> inline short saturate_cast<short>(int64 v)        { return (short)((uint64)((int64)v - SHRT_MIN) <= (uint64)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN); }
+template<> inline short saturate_cast<short>(uint64 v)       { return (short)std::min(v, (uint64)SHRT_MAX); }
+
+template<> inline int saturate_cast<int>(unsigned v)         { return (int)std::min(v, (unsigned)INT_MAX); }
+template<> inline int saturate_cast<int>(int64 v)            { return (int)((uint64)(v - INT_MIN) <= (uint64)UINT_MAX ? v : v > 0 ? INT_MAX : INT_MIN); }
+template<> inline int saturate_cast<int>(uint64 v)           { return (int)std::min(v, (uint64)INT_MAX); }
+template<> inline int saturate_cast<int>(float v)            { return ::opencv_m_scalar_bridge::round32(v); }
+template<> inline int saturate_cast<int>(double v)           { return ::opencv_m_scalar_bridge::round32(v); }
+
+template<> inline unsigned saturate_cast<unsigned>(schar v)  { return (unsigned)std::max(v, (schar)0); }
+template<> inline unsigned saturate_cast<unsigned>(short v)  { return (unsigned)std::max(v, (short)0); }
+template<> inline unsigned saturate_cast<unsigned>(int v)    { return (unsigned)std::max(v, (int)0); }
+template<> inline unsigned saturate_cast<unsigned>(int64 v)  { return (unsigned)((uint64)v <= (uint64)UINT_MAX ? v : v > 0 ? UINT_MAX : 0); }
+template<> inline unsigned saturate_cast<unsigned>(uint64 v) { return (unsigned)std::min(v, (uint64)UINT_MAX); }
+template<> inline unsigned saturate_cast<unsigned>(float v)  { return (unsigned)::round(std::max(v, 0.f)); }
+template<> inline unsigned saturate_cast<unsigned>(double v) { return (unsigned)::round(std::max(v, 0.)); }
+
+template<> inline uint64 saturate_cast<uint64>(schar v)      { return (uint64)std::max(v, (schar)0); }
+template<> inline uint64 saturate_cast<uint64>(short v)      { return (uint64)std::max(v, (short)0); }
+template<> inline uint64 saturate_cast<uint64>(int v)        { return (uint64)std::max(v, (int)0); }
+template<> inline uint64 saturate_cast<uint64>(int64 v)      { return (uint64)std::max(v, (int64)0); }
+
+template<> inline int64 saturate_cast<int64>(uint64 v)       { return (int64)std::min(v, (uint64)LLONG_MAX); }
+template<> inline int64 saturate_cast<int64>(float v)        { return (int64)::round((double)v); }
+template<> inline int64 saturate_cast<int64>(double v)       { return (int64)::round(v); }
+template<> inline uint64 saturate_cast<uint64>(float v)      { return (int64)::round((double)std::max(v, 0.f)); }
+template<> inline uint64 saturate_cast<uint64>(double v)     { return (int64)::round(std::max(v, 0.)); }
+
+
+/** @overload */
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(hfloat v) { return saturate_cast<_Tp>((float)v); }
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(bfloat v) { return saturate_cast<_Tp>((float)v); }
+template<typename _Tp> requires opencv_m_pick<_Tp> inline _Tp saturate_cast(bool v) { return saturate_cast<_Tp>(v ? 1 : 0); }
+
+// in theory, we could use a LUT for 8u/8s->16f conversion,
+// but with hardware support for FP32->FP16 conversion the current approach is preferable
+template<> inline hfloat saturate_cast<hfloat>(uchar v)   { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(schar v)   { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(ushort v)  { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(short v)   { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(unsigned v){ return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(int v)     { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(uint64 v)  { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(int64 v)   { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(float v)   { return hfloat(v); }
+template<> inline hfloat saturate_cast<hfloat>(double v)  { return hfloat((float)v); }
+template<> inline hfloat saturate_cast<hfloat>(hfloat v)  { return v; }
+template<> inline hfloat saturate_cast<hfloat>(bfloat v)  { return hfloat((float)v); }
+
+template<> inline bfloat saturate_cast<bfloat>(uchar v)   { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(schar v)   { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(ushort v)  { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(short v)   { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(unsigned v){ return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(int v)     { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(uint64 v)  { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(int64 v)   { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(float v)   { return bfloat(v); }
+template<> inline bfloat saturate_cast<bfloat>(double v)  { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(hfloat v) { return bfloat((float)v); }
+template<> inline bfloat saturate_cast<bfloat>(bfloat v) { return v; }
+
+template<> inline bool saturate_cast<bool>(uchar v) { return v != 0; }
+template<> inline bool saturate_cast<bool>(schar v) { return v != 0; }
+template<> inline bool saturate_cast<bool>(ushort v) { return v != 0; }
+template<> inline bool saturate_cast<bool>(short v) { return v != 0; }
+template<> inline bool saturate_cast<bool>(unsigned v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(int v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(float v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(double v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(uint64_t v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(int64_t v){ return v != 0; }
+template<> inline bool saturate_cast<bool>(hfloat v){ return (float)v != 0; }
+template<> inline bool saturate_cast<bool>(bfloat v){ return (float)v != 0; }
+
+//! @}
diff --git a/src/selected.cppm.in b/src/selected.cppm.in
new file mode 100644
index 0000000..24ae3df
--- /dev/null
+++ b/src/selected.cppm.in
@@ -0,0 +1,3 @@
+export module mcpplibs.mwrap.opencv.detail.selected;
+
+@MCPP_OPENCV_IMPORTS@
diff --git a/src/simd_exports.inc b/src/simd_exports.inc
new file mode 100644
index 0000000..6a44eb2
--- /dev/null
+++ b/src/simd_exports.inc
@@ -0,0 +1,1117 @@
+// Generated by tools/generate_simd.py; original SDK entities, no copied vector types.
+export namespace cv {
+using ::cv::Type2Vec128_Traits;
+using ::cv::VTraits;
+using ::cv::V_RegTraits;
+using ::cv::V_TypeTraits;
+using ::cv::v_abs;
+using ::cv::v_absdiff;
+using ::cv::v_absdiffs;
+using ::cv::v_add;
+using ::cv::v_add_wrap;
+using ::cv::v_and;
+using ::cv::v_broadcast_element;
+using ::cv::v_broadcast_highest;
+using ::cv::v_ceil;
+using ::cv::v_check_all;
+using ::cv::v_check_any;
+using ::cv::v_cleanup;
+using ::cv::v_combine_high;
+using ::cv::v_combine_low;
+using ::cv::v_cos;
+using ::cv::v_cos_default_16f;
+using ::cv::v_cos_default_32f;
+using ::cv::v_cos_default_64f;
+using ::cv::v_cvt_f32;
+using ::cv::v_cvt_f64;
+using ::cv::v_cvt_f64_high;
+using ::cv::v_div;
+using ::cv::v_dotprod;
+using ::cv::v_dotprod_expand;
+using ::cv::v_dotprod_expand_fast;
+using ::cv::v_dotprod_fast;
+using ::cv::v_eq;
+using ::cv::v_erf;
+using ::cv::v_erf_default_32f;
+using ::cv::v_exp;
+using ::cv::v_exp_default_16f;
+using ::cv::v_exp_default_32f;
+using ::cv::v_exp_default_64f;
+using ::cv::v_expand;
+using ::cv::v_expand_high;
+using ::cv::v_expand_low;
+using ::cv::v_extract;
+using ::cv::v_extract_highest;
+using ::cv::v_extract_n;
+using ::cv::v_float32;
+using ::cv::v_float32x4;
+using ::cv::v_float64;
+using ::cv::v_float64x2;
+using ::cv::v_floor;
+using ::cv::v_fma;
+using ::cv::v_ge;
+using ::cv::v_get0;
+using ::cv::v_gt;
+using ::cv::v_int16;
+using ::cv::v_int16x8;
+using ::cv::v_int32;
+using ::cv::v_int32x4;
+using ::cv::v_int64;
+using ::cv::v_int64x2;
+using ::cv::v_int8;
+using ::cv::v_int8x16;
+using ::cv::v_interleave_pairs;
+using ::cv::v_interleave_quads;
+using ::cv::v_invsqrt;
+using ::cv::v_le;
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_aligned;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_deinterleave;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_expand;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_expand_q;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_halves;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_load_low;
+#endif
+using ::cv::v_log;
+using ::cv::v_log_default_16f;
+using ::cv::v_log_default_32f;
+using ::cv::v_log_default_64f;
+using ::cv::v_lt;
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_lut;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_lut_deinterleave;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_lut_pairs;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_lut_quads;
+#endif
+using ::cv::v_magnitude;
+using ::cv::v_matmul;
+using ::cv::v_matmuladd;
+using ::cv::v_max;
+using ::cv::v_min;
+using ::cv::v_mul;
+using ::cv::v_mul_expand;
+using ::cv::v_mul_hi;
+using ::cv::v_mul_wrap;
+using ::cv::v_muladd;
+using ::cv::v_ne;
+using ::cv::v_not;
+using ::cv::v_not_nan;
+using ::cv::v_or;
+using ::cv::v_pack;
+using ::cv::v_pack_b;
+using ::cv::v_pack_store;
+using ::cv::v_pack_triplets;
+using ::cv::v_pack_u;
+using ::cv::v_pack_u_store;
+using ::cv::v_popcount;
+using ::cv::v_recombine;
+using ::cv::v_reduce_max;
+using ::cv::v_reduce_min;
+using ::cv::v_reduce_sad;
+using ::cv::v_reduce_sum;
+using ::cv::v_reduce_sum4;
+using ::cv::v_reinterpret_as_f32;
+using ::cv::v_reinterpret_as_f64;
+using ::cv::v_reinterpret_as_s16;
+using ::cv::v_reinterpret_as_s32;
+using ::cv::v_reinterpret_as_s64;
+using ::cv::v_reinterpret_as_s8;
+using ::cv::v_reinterpret_as_u16;
+using ::cv::v_reinterpret_as_u32;
+using ::cv::v_reinterpret_as_u64;
+using ::cv::v_reinterpret_as_u8;
+using ::cv::v_reverse;
+using ::cv::v_rotate_left;
+using ::cv::v_rotate_right;
+using ::cv::v_round;
+using ::cv::v_rshr_pack;
+using ::cv::v_rshr_pack_store;
+using ::cv::v_rshr_pack_u;
+using ::cv::v_rshr_pack_u_store;
+using ::cv::v_scan_forward;
+using ::cv::v_select;
+using ::cv::v_setall_;
+using ::cv::v_setall_f32;
+using ::cv::v_setall_f64;
+using ::cv::v_setall_s16;
+using ::cv::v_setall_s32;
+using ::cv::v_setall_s64;
+using ::cv::v_setall_s8;
+using ::cv::v_setall_u16;
+using ::cv::v_setall_u32;
+using ::cv::v_setall_u64;
+using ::cv::v_setall_u8;
+using ::cv::v_setzero_;
+using ::cv::v_setzero_f32;
+using ::cv::v_setzero_f64;
+using ::cv::v_setzero_s16;
+using ::cv::v_setzero_s32;
+using ::cv::v_setzero_s64;
+using ::cv::v_setzero_s8;
+using ::cv::v_setzero_u16;
+using ::cv::v_setzero_u32;
+using ::cv::v_setzero_u64;
+using ::cv::v_setzero_u8;
+using ::cv::v_shl;
+using ::cv::v_shr;
+using ::cv::v_signmask;
+using ::cv::v_sin;
+using ::cv::v_sin_default_16f;
+using ::cv::v_sin_default_32f;
+using ::cv::v_sin_default_64f;
+using ::cv::v_sincos;
+using ::cv::v_sincos_default_16f;
+using ::cv::v_sincos_default_32f;
+using ::cv::v_sincos_default_64f;
+using ::cv::v_sqr_magnitude;
+using ::cv::v_sqrt;
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store_aligned;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store_aligned_nocache;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store_high;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store_interleave;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_store_low;
+#endif
+using ::cv::v_sub;
+using ::cv::v_sub_wrap;
+using ::cv::v_transpose4x4;
+using ::cv::v_trunc;
+using ::cv::v_uint16;
+using ::cv::v_uint16x8;
+using ::cv::v_uint32;
+using ::cv::v_uint32x4;
+using ::cv::v_uint64;
+using ::cv::v_uint64x2;
+using ::cv::v_uint8;
+using ::cv::v_uint8x16;
+using ::cv::v_xor;
+using ::cv::v_zip;
+using ::cv::vx_cleanup;
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load_aligned;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load_expand;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load_expand_q;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load_halves;
+#endif
+#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::vx_load_low;
+#endif
+using ::cv::vx_lut;
+using ::cv::vx_lut_pairs;
+using ::cv::vx_lut_quads;
+using ::cv::vx_setall_f32;
+using ::cv::vx_setall_f64;
+using ::cv::vx_setall_s16;
+using ::cv::vx_setall_s32;
+using ::cv::vx_setall_s64;
+using ::cv::vx_setall_s8;
+using ::cv::vx_setall_u16;
+using ::cv::vx_setall_u32;
+using ::cv::vx_setall_u64;
+using ::cv::vx_setall_u8;
+using ::cv::vx_setzero_f32;
+using ::cv::vx_setzero_f64;
+using ::cv::vx_setzero_s16;
+using ::cv::vx_setzero_s32;
+using ::cv::vx_setzero_s64;
+using ::cv::vx_setzero_s8;
+using ::cv::vx_setzero_u16;
+using ::cv::vx_setzero_u32;
+using ::cv::vx_setzero_u64;
+using ::cv::vx_setzero_u8;
+#if CV_SSE2 && !defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_select_si128;
+using ::cv::v_sign_epi64;
+using ::cv::v_srai_epi64;
+#endif
+#if CV_SIMD128_FP16
+using ::cv::v_float16;
+using ::cv::v_float16x8;
+using ::cv::v_reinterpret_as_f16;
+using ::cv::v_setzero_f16;
+using ::cv::v_setall_f16;
+using ::cv::vx_setzero_f16;
+using ::cv::vx_setall_f16;
+using ::cv::v_cvt_f16;
+#endif
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+using ::cv::v_hsum;
+using ::cv::v_minmax;
+using ::cv::v_reg;
+using ::cv::v_reinterpret_as_int;
+using ::cv::v_reinterpret_as_uint;
+using ::cv::v_rshr;
+using ::cv::simd128_width;
+using ::cv::simdmax_width;
+#endif
+}
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+export namespace cv { namespace hal_EMULATOR_CPP {
+using ::cv::hal_EMULATOR_CPP::simd128_width;
+using ::cv::hal_EMULATOR_CPP::simdmax_width;
+} }
+#endif
+export namespace cv {
+}
+export namespace cv { namespace hal {
+using ::cv::hal::StoreMode;
+using ::cv::hal::STORE_UNALIGNED;
+using ::cv::hal::STORE_ALIGNED;
+using ::cv::hal::STORE_ALIGNED_NOCACHE;
+} }
+#if defined(__GNUC__) && !defined(__clang__) && !defined(MCPP_FEATURE_SIMD_EMULATED)
+// GCC loses unaligned intrinsic typedef alignment through imported inline bodies.
+// Ordinary producer-compiled forwards preserve original SDK memory operations.
+namespace opencv_m_simd_up { using namespace ::cv;
+v_float32x4 v_load(const float * a0) { return ::cv::v_load(a0); }
+v_float64x2 v_load(const double * a0) { return ::cv::v_load(a0); }
+v_int16x8 v_load(const short * a0) { return ::cv::v_load(a0); }
+v_int32x4 v_load(const int * a0) { return ::cv::v_load(a0); }
+v_int64x2 v_load(const int64 * a0) { return ::cv::v_load(a0); }
+v_int8x16 v_load(const schar * a0) { return ::cv::v_load(a0); }
+v_uint16x8 v_load(const ushort * a0) { return ::cv::v_load(a0); }
+v_uint32x4 v_load(const unsigned int * a0) { return ::cv::v_load(a0); }
+v_uint64x2 v_load(const uint64 * a0) { return ::cv::v_load(a0); }
+v_uint8x16 v_load(const uchar * a0) { return ::cv::v_load(a0); }
+v_float32x4 v_load_aligned(const float * a0) { return ::cv::v_load_aligned(a0); }
+v_float64x2 v_load_aligned(const double * a0) { return ::cv::v_load_aligned(a0); }
+v_int16x8 v_load_aligned(const short * a0) { return ::cv::v_load_aligned(a0); }
+v_int32x4 v_load_aligned(const int * a0) { return ::cv::v_load_aligned(a0); }
+v_int64x2 v_load_aligned(const int64 * a0) { return ::cv::v_load_aligned(a0); }
+v_int8x16 v_load_aligned(const schar * a0) { return ::cv::v_load_aligned(a0); }
+v_uint16x8 v_load_aligned(const ushort * a0) { return ::cv::v_load_aligned(a0); }
+v_uint32x4 v_load_aligned(const unsigned int * a0) { return ::cv::v_load_aligned(a0); }
+v_uint64x2 v_load_aligned(const uint64 * a0) { return ::cv::v_load_aligned(a0); }
+v_uint8x16 v_load_aligned(const uchar * a0) { return ::cv::v_load_aligned(a0); }
+void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2, v_float64x2 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2, v_float64x2 & a3, v_float64x2 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2, v_float32x4 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2, v_float32x4 & a3, v_float32x4 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2, v_int32x4 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2, v_int32x4 & a3, v_int32x4 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2, v_int64x2 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2, v_int64x2 & a3, v_int64x2 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2, v_int8x16 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2, v_int8x16 & a3, v_int8x16 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2, v_int16x8 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2, v_int16x8 & a3, v_int16x8 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2, v_uint8x16 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2, v_uint8x16 & a3, v_uint8x16 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2, v_uint64x2 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2, v_uint64x2 & a3, v_uint64x2 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2, v_uint32x4 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2, v_uint32x4 & a3, v_uint32x4 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2) { return ::cv::v_load_deinterleave(a0, a1, a2); }
+void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2, v_uint16x8 & a3) { return ::cv::v_load_deinterleave(a0, a1, a2, a3); }
+void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2, v_uint16x8 & a3, v_uint16x8 & a4) { return ::cv::v_load_deinterleave(a0, a1, a2, a3, a4); }
+v_float32x4 v_load_expand(const hfloat * a0) { return ::cv::v_load_expand(a0); }
+v_int16x8 v_load_expand(const schar * a0) { return ::cv::v_load_expand(a0); }
+v_int32x4 v_load_expand(const short * a0) { return ::cv::v_load_expand(a0); }
+v_int64x2 v_load_expand(const int * a0) { return ::cv::v_load_expand(a0); }
+v_uint16x8 v_load_expand(const uchar * a0) { return ::cv::v_load_expand(a0); }
+v_uint32x4 v_load_expand(const ushort * a0) { return ::cv::v_load_expand(a0); }
+v_uint64x2 v_load_expand(const unsigned int * a0) { return ::cv::v_load_expand(a0); }
+v_int32x4 v_load_expand_q(const schar * a0) { return ::cv::v_load_expand_q(a0); }
+v_uint32x4 v_load_expand_q(const uchar * a0) { return ::cv::v_load_expand_q(a0); }
+v_float32x4 v_load_halves(const float * a0, const float * a1) { return ::cv::v_load_halves(a0, a1); }
+v_float64x2 v_load_halves(const double * a0, const double * a1) { return ::cv::v_load_halves(a0, a1); }
+v_int16x8 v_load_halves(const short * a0, const short * a1) { return ::cv::v_load_halves(a0, a1); }
+v_int32x4 v_load_halves(const int * a0, const int * a1) { return ::cv::v_load_halves(a0, a1); }
+v_int64x2 v_load_halves(const int64 * a0, const int64 * a1) { return ::cv::v_load_halves(a0, a1); }
+v_int8x16 v_load_halves(const schar * a0, const schar * a1) { return ::cv::v_load_halves(a0, a1); }
+v_uint16x8 v_load_halves(const ushort * a0, const ushort * a1) { return ::cv::v_load_halves(a0, a1); }
+v_uint32x4 v_load_halves(const unsigned int * a0, const unsigned int * a1) { return ::cv::v_load_halves(a0, a1); }
+v_uint64x2 v_load_halves(const uint64 * a0, const uint64 * a1) { return ::cv::v_load_halves(a0, a1); }
+v_uint8x16 v_load_halves(const uchar * a0, const uchar * a1) { return ::cv::v_load_halves(a0, a1); }
+v_float32x4 v_load_low(const float * a0) { return ::cv::v_load_low(a0); }
+v_float64x2 v_load_low(const double * a0) { return ::cv::v_load_low(a0); }
+v_int16x8 v_load_low(const short * a0) { return ::cv::v_load_low(a0); }
+v_int32x4 v_load_low(const int * a0) { return ::cv::v_load_low(a0); }
+v_int64x2 v_load_low(const int64 * a0) { return ::cv::v_load_low(a0); }
+v_int8x16 v_load_low(const schar * a0) { return ::cv::v_load_low(a0); }
+v_uint16x8 v_load_low(const ushort * a0) { return ::cv::v_load_low(a0); }
+v_uint32x4 v_load_low(const unsigned int * a0) { return ::cv::v_load_low(a0); }
+v_uint64x2 v_load_low(const uint64 * a0) { return ::cv::v_load_low(a0); }
+v_uint8x16 v_load_low(const uchar * a0) { return ::cv::v_load_low(a0); }
+v_float32x4 v_lut(const float * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_float32x4 v_lut(const float * a0, const v_int32x4 & a1) { return ::cv::v_lut(a0, a1); }
+v_float64x2 v_lut(const double * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_float64x2 v_lut(const double * a0, const v_int32x4 & a1) { return ::cv::v_lut(a0, a1); }
+v_int16x8 v_lut(const short * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_int32x4 v_lut(const int * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_int32x4 v_lut(const int * a0, const v_int32x4 & a1) { return ::cv::v_lut(a0, a1); }
+v_int64x2 v_lut(const int64_t * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_int8x16 v_lut(const schar * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_uint16x8 v_lut(const ushort * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_uint32x4 v_lut(const unsigned int * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_uint32x4 v_lut(const unsigned int * a0, const v_int32x4 & a1) { return ::cv::v_lut(a0, a1); }
+v_uint64x2 v_lut(const uint64_t * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+v_uint8x16 v_lut(const uchar * a0, const int * a1) { return ::cv::v_lut(a0, a1); }
+void v_lut_deinterleave(const double * a0, const v_int32x4 & a1, v_float64x2 & a2, v_float64x2 & a3) { return ::cv::v_lut_deinterleave(a0, a1, a2, a3); }
+void v_lut_deinterleave(const float * a0, const v_int32x4 & a1, v_float32x4 & a2, v_float32x4 & a3) { return ::cv::v_lut_deinterleave(a0, a1, a2, a3); }
+v_float32x4 v_lut_pairs(const float * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_float64x2 v_lut_pairs(const double * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_int16x8 v_lut_pairs(const short * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_int32x4 v_lut_pairs(const int * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_int64x2 v_lut_pairs(const int64_t * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_int8x16 v_lut_pairs(const schar * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_uint16x8 v_lut_pairs(const ushort * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_uint32x4 v_lut_pairs(const unsigned int * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_uint64x2 v_lut_pairs(const uint64_t * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_uint8x16 v_lut_pairs(const uchar * a0, const int * a1) { return ::cv::v_lut_pairs(a0, a1); }
+v_float32x4 v_lut_quads(const float * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_int16x8 v_lut_quads(const short * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_int32x4 v_lut_quads(const int * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_int8x16 v_lut_quads(const schar * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_uint16x8 v_lut_quads(const ushort * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_uint32x4 v_lut_quads(const unsigned int * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+v_uint8x16 v_lut_quads(const uchar * a0, const int * a1) { return ::cv::v_lut_quads(a0, a1); }
+void v_store(double * a0, const v_float64x2 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(double * a0, const v_float64x2 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(float * a0, const v_float32x4 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(float * a0, const v_float32x4 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(int * a0, const v_int32x4 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(int * a0, const v_int32x4 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(int64 * a0, const v_int64x2 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(int64 * a0, const v_int64x2 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(schar * a0, const v_int8x16 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(schar * a0, const v_int8x16 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(short * a0, const v_int16x8 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(short * a0, const v_int16x8 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(uchar * a0, const v_uint8x16 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(uchar * a0, const v_uint8x16 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(uint64 * a0, const v_uint64x2 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(uint64 * a0, const v_uint64x2 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(unsigned int * a0, const v_uint32x4 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(unsigned int * a0, const v_uint32x4 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store(ushort * a0, const v_uint16x8 & a1) { return ::cv::v_store(a0, a1); }
+void v_store(ushort * a0, const v_uint16x8 & a1, hal::StoreMode a2) { return ::cv::v_store(a0, a1, a2); }
+void v_store_aligned(double * a0, const v_float64x2 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(float * a0, const v_float32x4 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(int * a0, const v_int32x4 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(int64 * a0, const v_int64x2 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(schar * a0, const v_int8x16 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(short * a0, const v_int16x8 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(uchar * a0, const v_uint8x16 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(uint64 * a0, const v_uint64x2 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(unsigned int * a0, const v_uint32x4 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned(ushort * a0, const v_uint16x8 & a1) { return ::cv::v_store_aligned(a0, a1); }
+void v_store_aligned_nocache(double * a0, const v_float64x2 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(float * a0, const v_float32x4 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(int * a0, const v_int32x4 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(int64 * a0, const v_int64x2 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(schar * a0, const v_int8x16 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(short * a0, const v_int16x8 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(uchar * a0, const v_uint8x16 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(uint64 * a0, const v_uint64x2 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(unsigned int * a0, const v_uint32x4 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_aligned_nocache(ushort * a0, const v_uint16x8 & a1) { return ::cv::v_store_aligned_nocache(a0, a1); }
+void v_store_high(double * a0, const v_float64x2 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(float * a0, const v_float32x4 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(int * a0, const v_int32x4 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(int64 * a0, const v_int64x2 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(schar * a0, const v_int8x16 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(short * a0, const v_int16x8 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(uchar * a0, const v_uint8x16 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(uint64 * a0, const v_uint64x2 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(unsigned int * a0, const v_uint32x4 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_high(ushort * a0, const v_uint16x8 & a1) { return ::cv::v_store_high(a0, a1); }
+void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, const v_float64x2 & a3, const v_float64x2 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, const v_float64x2 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, const v_float32x4 & a3, const v_float32x4 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, const v_float32x4 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, const v_int32x4 & a3, const v_int32x4 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, const v_int32x4 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, const v_int64x2 & a3, const v_int64x2 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, const v_int64x2 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, const v_int8x16 & a3, const v_int8x16 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, const v_int8x16 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, const v_int16x8 & a3, const v_int16x8 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, const v_int16x8 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, const v_uint8x16 & a3, const v_uint8x16 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, const v_uint8x16 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, const v_uint64x2 & a3, const v_uint64x2 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, const v_uint64x2 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, const v_uint32x4 & a3, const v_uint32x4 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, const v_uint32x4 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, const v_uint16x8 & a3, const v_uint16x8 & a4, hal::StoreMode a5) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, const v_uint16x8 & a3, hal::StoreMode a4) { return ::cv::v_store_interleave(a0, a1, a2, a3, a4); }
+void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, hal::StoreMode a3) { return ::cv::v_store_interleave(a0, a1, a2, a3); }
+void v_store_low(double * a0, const v_float64x2 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(float * a0, const v_float32x4 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(int * a0, const v_int32x4 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(int64 * a0, const v_int64x2 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(schar * a0, const v_int8x16 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(short * a0, const v_int16x8 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(uchar * a0, const v_uint8x16 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(uint64 * a0, const v_uint64x2 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(unsigned int * a0, const v_uint32x4 & a1) { return ::cv::v_store_low(a0, a1); }
+void v_store_low(ushort * a0, const v_uint16x8 & a1) { return ::cv::v_store_low(a0, a1); }
+v_float32 vx_load(const float * a0) { return ::cv::vx_load(a0); }
+v_float64 vx_load(const double * a0) { return ::cv::vx_load(a0); }
+v_int16 vx_load(const short * a0) { return ::cv::vx_load(a0); }
+v_int32 vx_load(const int * a0) { return ::cv::vx_load(a0); }
+v_int64 vx_load(const int64 * a0) { return ::cv::vx_load(a0); }
+v_int8 vx_load(const schar * a0) { return ::cv::vx_load(a0); }
+v_uint16 vx_load(const ushort * a0) { return ::cv::vx_load(a0); }
+v_uint32 vx_load(const unsigned int * a0) { return ::cv::vx_load(a0); }
+v_uint64 vx_load(const uint64 * a0) { return ::cv::vx_load(a0); }
+v_uint8 vx_load(const uchar * a0) { return ::cv::vx_load(a0); }
+v_float32 vx_load_aligned(const float * a0) { return ::cv::vx_load_aligned(a0); }
+v_float64 vx_load_aligned(const double * a0) { return ::cv::vx_load_aligned(a0); }
+v_int16 vx_load_aligned(const short * a0) { return ::cv::vx_load_aligned(a0); }
+v_int32 vx_load_aligned(const int * a0) { return ::cv::vx_load_aligned(a0); }
+v_int64 vx_load_aligned(const int64 * a0) { return ::cv::vx_load_aligned(a0); }
+v_int8 vx_load_aligned(const schar * a0) { return ::cv::vx_load_aligned(a0); }
+v_uint16 vx_load_aligned(const ushort * a0) { return ::cv::vx_load_aligned(a0); }
+v_uint32 vx_load_aligned(const unsigned int * a0) { return ::cv::vx_load_aligned(a0); }
+v_uint64 vx_load_aligned(const uint64 * a0) { return ::cv::vx_load_aligned(a0); }
+v_uint8 vx_load_aligned(const uchar * a0) { return ::cv::vx_load_aligned(a0); }
+v_float32 vx_load_expand(const bfloat * a0) { return ::cv::vx_load_expand(a0); }
+v_float32 vx_load_expand(const hfloat * a0) { return ::cv::vx_load_expand(a0); }
+v_int16 vx_load_expand(const schar * a0) { return ::cv::vx_load_expand(a0); }
+v_int32 vx_load_expand(const short * a0) { return ::cv::vx_load_expand(a0); }
+v_int64 vx_load_expand(const int * a0) { return ::cv::vx_load_expand(a0); }
+v_uint16 vx_load_expand(const uchar * a0) { return ::cv::vx_load_expand(a0); }
+v_uint32 vx_load_expand(const ushort * a0) { return ::cv::vx_load_expand(a0); }
+v_uint64 vx_load_expand(const unsigned int * a0) { return ::cv::vx_load_expand(a0); }
+v_int32 vx_load_expand_q(const schar * a0) { return ::cv::vx_load_expand_q(a0); }
+v_uint32 vx_load_expand_q(const uchar * a0) { return ::cv::vx_load_expand_q(a0); }
+v_float32 vx_load_halves(const float * a0, const float * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_float64 vx_load_halves(const double * a0, const double * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_int16 vx_load_halves(const short * a0, const short * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_int32 vx_load_halves(const int * a0, const int * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_int64 vx_load_halves(const int64 * a0, const int64 * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_int8 vx_load_halves(const schar * a0, const schar * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_uint16 vx_load_halves(const ushort * a0, const ushort * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_uint32 vx_load_halves(const unsigned int * a0, const unsigned int * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_uint64 vx_load_halves(const uint64 * a0, const uint64 * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_uint8 vx_load_halves(const uchar * a0, const uchar * a1) { return ::cv::vx_load_halves(a0, a1); }
+v_float32 vx_load_low(const float * a0) { return ::cv::vx_load_low(a0); }
+v_float64 vx_load_low(const double * a0) { return ::cv::vx_load_low(a0); }
+v_int16 vx_load_low(const short * a0) { return ::cv::vx_load_low(a0); }
+v_int32 vx_load_low(const int * a0) { return ::cv::vx_load_low(a0); }
+v_int64 vx_load_low(const int64 * a0) { return ::cv::vx_load_low(a0); }
+v_int8 vx_load_low(const schar * a0) { return ::cv::vx_load_low(a0); }
+v_uint16 vx_load_low(const ushort * a0) { return ::cv::vx_load_low(a0); }
+v_uint32 vx_load_low(const unsigned int * a0) { return ::cv::vx_load_low(a0); }
+v_uint64 vx_load_low(const uint64 * a0) { return ::cv::vx_load_low(a0); }
+v_uint8 vx_load_low(const uchar * a0) { return ::cv::vx_load_low(a0); }
+}
+export namespace cv { inline namespace opencv_m_simd_repl {
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_load(const float * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_load(const double * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_load(const short * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load(const int * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_load(const int64 * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_load(const schar * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_load(const ushort * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load(const unsigned int * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_load(const uint64 * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_load(const uchar * a0) { return ::opencv_m_simd_up::v_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_load_aligned(const float * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_load_aligned(const double * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_load_aligned(const short * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load_aligned(const int * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_load_aligned(const int64 * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_load_aligned(const schar * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_load_aligned(const ushort * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load_aligned(const unsigned int * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_load_aligned(const uint64 * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_load_aligned(const uchar * a0) { return ::opencv_m_simd_up::v_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2, v_float64x2 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const double * a0, v_float64x2 & a1, v_float64x2 & a2, v_float64x2 & a3, v_float64x2 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2, v_float32x4 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const float * a0, v_float32x4 & a1, v_float32x4 & a2, v_float32x4 & a3, v_float32x4 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2, v_int32x4 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int * a0, v_int32x4 & a1, v_int32x4 & a2, v_int32x4 & a3, v_int32x4 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2, v_int64x2 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const int64 * a0, v_int64x2 & a1, v_int64x2 & a2, v_int64x2 & a3, v_int64x2 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2, v_int8x16 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const schar * a0, v_int8x16 & a1, v_int8x16 & a2, v_int8x16 & a3, v_int8x16 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2, v_int16x8 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const short * a0, v_int16x8 & a1, v_int16x8 & a2, v_int16x8 & a3, v_int16x8 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2, v_uint8x16 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uchar * a0, v_uint8x16 & a1, v_uint8x16 & a2, v_uint8x16 & a3, v_uint8x16 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2, v_uint64x2 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const uint64 * a0, v_uint64x2 & a1, v_uint64x2 & a2, v_uint64x2 & a3, v_uint64x2 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2, v_uint32x4 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const unsigned int * a0, v_uint32x4 & a1, v_uint32x4 & a2, v_uint32x4 & a3, v_uint32x4 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2, v_uint16x8 & a3) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_load_deinterleave(const ushort * a0, v_uint16x8 & a1, v_uint16x8 & a2, v_uint16x8 & a3, v_uint16x8 & a4) { return ::opencv_m_simd_up::v_load_deinterleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_load_expand(const hfloat * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_load_expand(const schar * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load_expand(const short * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_load_expand(const int * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_load_expand(const uchar * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load_expand(const ushort * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_load_expand(const unsigned int * a0) { return ::opencv_m_simd_up::v_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load_expand_q(const schar * a0) { return ::opencv_m_simd_up::v_load_expand_q(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load_expand_q(const uchar * a0) { return ::opencv_m_simd_up::v_load_expand_q(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_load_halves(const float * a0, const float * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_load_halves(const double * a0, const double * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_load_halves(const short * a0, const short * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load_halves(const int * a0, const int * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_load_halves(const int64 * a0, const int64 * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_load_halves(const schar * a0, const schar * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_load_halves(const ushort * a0, const ushort * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load_halves(const unsigned int * a0, const unsigned int * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_load_halves(const uint64 * a0, const uint64 * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_load_halves(const uchar * a0, const uchar * a1) { return ::opencv_m_simd_up::v_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_load_low(const float * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_load_low(const double * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_load_low(const short * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_load_low(const int * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_load_low(const int64 * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_load_low(const schar * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_load_low(const ushort * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_load_low(const unsigned int * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_load_low(const uint64 * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_load_low(const uchar * a0) { return ::opencv_m_simd_up::v_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_lut(const float * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_lut(const float * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_lut(const double * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_lut(const double * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_lut(const short * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_lut(const int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_lut(const int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_lut(const int64_t * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_lut(const schar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_lut(const ushort * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_lut(const unsigned int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_lut(const unsigned int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_lut(const uint64_t * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_lut(const uchar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_lut_deinterleave(const double * a0, const v_int32x4 & a1, v_float64x2 & a2, v_float64x2 & a3) { return ::opencv_m_simd_up::v_lut_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_lut_deinterleave(const float * a0, const v_int32x4 & a1, v_float32x4 & a2, v_float32x4 & a3) { return ::opencv_m_simd_up::v_lut_deinterleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_lut_pairs(const float * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64x2 v_lut_pairs(const double * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_lut_pairs(const short * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_lut_pairs(const int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64x2 v_lut_pairs(const int64_t * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_lut_pairs(const schar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_lut_pairs(const ushort * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_lut_pairs(const unsigned int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64x2 v_lut_pairs(const uint64_t * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_lut_pairs(const uchar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_pairs(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32x4 v_lut_quads(const float * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16x8 v_lut_quads(const short * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32x4 v_lut_quads(const int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8x16 v_lut_quads(const schar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16x8 v_lut_quads(const ushort * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32x4 v_lut_quads(const unsigned int * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8x16 v_lut_quads(const uchar * a0, const int * a1) { return ::opencv_m_simd_up::v_lut_quads(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(double * a0, const v_float64x2 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(double * a0, const v_float64x2 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(float * a0, const v_float32x4 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(float * a0, const v_float32x4 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(int * a0, const v_int32x4 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(int64 * a0, const v_int64x2 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(int64 * a0, const v_int64x2 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(schar * a0, const v_int8x16 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(schar * a0, const v_int8x16 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(short * a0, const v_int16x8 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(short * a0, const v_int16x8 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(uchar * a0, const v_uint8x16 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(uchar * a0, const v_uint8x16 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(uint64 * a0, const v_uint64x2 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(uint64 * a0, const v_uint64x2 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(unsigned int * a0, const v_uint32x4 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(unsigned int * a0, const v_uint32x4 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(ushort * a0, const v_uint16x8 & a1) { return ::opencv_m_simd_up::v_store(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store(ushort * a0, const v_uint16x8 & a1, hal::StoreMode a2) { return ::opencv_m_simd_up::v_store(a0, a1, a2); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(double * a0, const v_float64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(float * a0, const v_float32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(int64 * a0, const v_int64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(schar * a0, const v_int8x16 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(short * a0, const v_int16x8 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(uchar * a0, const v_uint8x16 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(uint64 * a0, const v_uint64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(unsigned int * a0, const v_uint32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned(ushort * a0, const v_uint16x8 & a1) { return ::opencv_m_simd_up::v_store_aligned(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(double * a0, const v_float64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(float * a0, const v_float32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(int64 * a0, const v_int64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(schar * a0, const v_int8x16 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(short * a0, const v_int16x8 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(uchar * a0, const v_uint8x16 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(uint64 * a0, const v_uint64x2 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(unsigned int * a0, const v_uint32x4 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_aligned_nocache(ushort * a0, const v_uint16x8 & a1) { return ::opencv_m_simd_up::v_store_aligned_nocache(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(double * a0, const v_float64x2 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(float * a0, const v_float32x4 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(int64 * a0, const v_int64x2 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(schar * a0, const v_int8x16 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(short * a0, const v_int16x8 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(uchar * a0, const v_uint8x16 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(uint64 * a0, const v_uint64x2 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(unsigned int * a0, const v_uint32x4 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_high(ushort * a0, const v_uint16x8 & a1) { return ::opencv_m_simd_up::v_store_high(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, const v_float64x2 & a3, const v_float64x2 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, const v_float64x2 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(double * a0, const v_float64x2 & a1, const v_float64x2 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, const v_float32x4 & a3, const v_float32x4 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, const v_float32x4 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(float * a0, const v_float32x4 & a1, const v_float32x4 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, const v_int32x4 & a3, const v_int32x4 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, const v_int32x4 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int * a0, const v_int32x4 & a1, const v_int32x4 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, const v_int64x2 & a3, const v_int64x2 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, const v_int64x2 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(int64 * a0, const v_int64x2 & a1, const v_int64x2 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, const v_int8x16 & a3, const v_int8x16 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, const v_int8x16 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(schar * a0, const v_int8x16 & a1, const v_int8x16 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, const v_int16x8 & a3, const v_int16x8 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, const v_int16x8 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(short * a0, const v_int16x8 & a1, const v_int16x8 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, const v_uint8x16 & a3, const v_uint8x16 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, const v_uint8x16 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uchar * a0, const v_uint8x16 & a1, const v_uint8x16 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, const v_uint64x2 & a3, const v_uint64x2 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, const v_uint64x2 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(uint64 * a0, const v_uint64x2 & a1, const v_uint64x2 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, const v_uint32x4 & a3, const v_uint32x4 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, const v_uint32x4 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(unsigned int * a0, const v_uint32x4 & a1, const v_uint32x4 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, const v_uint16x8 & a3, const v_uint16x8 & a4, hal::StoreMode a5 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4, a5); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, const v_uint16x8 & a3, hal::StoreMode a4 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3, a4); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_interleave(ushort * a0, const v_uint16x8 & a1, const v_uint16x8 & a2, hal::StoreMode a3 = hal::STORE_UNALIGNED) { return ::opencv_m_simd_up::v_store_interleave(a0, a1, a2, a3); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(double * a0, const v_float64x2 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(float * a0, const v_float32x4 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(int * a0, const v_int32x4 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(int64 * a0, const v_int64x2 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(schar * a0, const v_int8x16 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(short * a0, const v_int16x8 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(uchar * a0, const v_uint8x16 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(uint64 * a0, const v_uint64x2 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(unsigned int * a0, const v_uint32x4 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline void v_store_low(ushort * a0, const v_uint16x8 & a1) { return ::opencv_m_simd_up::v_store_low(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load(const float * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64 vx_load(const double * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16 vx_load(const short * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load(const int * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64 vx_load(const int64 * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8 vx_load(const schar * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16 vx_load(const ushort * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load(const unsigned int * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64 vx_load(const uint64 * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8 vx_load(const uchar * a0) { return ::opencv_m_simd_up::vx_load(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load_aligned(const float * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64 vx_load_aligned(const double * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16 vx_load_aligned(const short * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load_aligned(const int * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64 vx_load_aligned(const int64 * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8 vx_load_aligned(const schar * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16 vx_load_aligned(const ushort * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load_aligned(const unsigned int * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64 vx_load_aligned(const uint64 * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8 vx_load_aligned(const uchar * a0) { return ::opencv_m_simd_up::vx_load_aligned(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load_expand(const bfloat * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load_expand(const hfloat * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16 vx_load_expand(const schar * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load_expand(const short * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64 vx_load_expand(const int * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16 vx_load_expand(const uchar * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load_expand(const ushort * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64 vx_load_expand(const unsigned int * a0) { return ::opencv_m_simd_up::vx_load_expand(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load_expand_q(const schar * a0) { return ::opencv_m_simd_up::vx_load_expand_q(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load_expand_q(const uchar * a0) { return ::opencv_m_simd_up::vx_load_expand_q(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load_halves(const float * a0, const float * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64 vx_load_halves(const double * a0, const double * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16 vx_load_halves(const short * a0, const short * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load_halves(const int * a0, const int * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64 vx_load_halves(const int64 * a0, const int64 * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8 vx_load_halves(const schar * a0, const schar * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16 vx_load_halves(const ushort * a0, const ushort * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load_halves(const unsigned int * a0, const unsigned int * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64 vx_load_halves(const uint64 * a0, const uint64 * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8 vx_load_halves(const uchar * a0, const uchar * a1) { return ::opencv_m_simd_up::vx_load_halves(a0, a1); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float32 vx_load_low(const float * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_float64 vx_load_low(const double * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int16 vx_load_low(const short * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int32 vx_load_low(const int * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int64 vx_load_low(const int64 * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_int8 vx_load_low(const schar * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint16 vx_load_low(const ushort * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint32 vx_load_low(const unsigned int * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint64 vx_load_low(const uint64 * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+template<class _D = void> requires (sizeof(_D*) > 0)
+inline v_uint8 vx_load_low(const uchar * a0) { return ::opencv_m_simd_up::vx_load_low(a0); }
+} }
+#endif
+export namespace cv { inline namespace opencv_m_simd_repl {
+template<class> inline constexpr bool pick = true;
+template<typename _Tp, typename _Tvec> requires pick<_Tp>
+inline void vx_store(_Tp* dst, const _Tvec& value) {
+#if defined(__GNUC__) && !defined(__clang__) && !defined(MCPP_FEATURE_SIMD_EMULATED)
+::opencv_m_simd_up::v_store(dst, value);
+#else
+::cv::v_store(dst, value);
+#endif
+}
+template<typename _Tp, typename _Tvec> requires pick<_Tp>
+inline void vx_store_aligned(_Tp* dst, const _Tvec& value) {
+#if defined(__GNUC__) && !defined(__clang__) && !defined(MCPP_FEATURE_SIMD_EMULATED)
+::opencv_m_simd_up::v_store_aligned(dst, value);
+#else
+::cv::v_store_aligned(dst, value);
+#endif
+}
+} }
+namespace opencv_m_simd_broadcast {
+auto fixed(const uchar& value) { return ::cv::v_setall<uchar>(value); }
+auto maximum(const uchar& value) { return ::cv::vx_setall<uchar>(value); }
+auto fixed(const schar& value) { return ::cv::v_setall<schar>(value); }
+auto maximum(const schar& value) { return ::cv::vx_setall<schar>(value); }
+auto fixed(const ushort& value) { return ::cv::v_setall<ushort>(value); }
+auto maximum(const ushort& value) { return ::cv::vx_setall<ushort>(value); }
+auto fixed(const short& value) { return ::cv::v_setall<short>(value); }
+auto maximum(const short& value) { return ::cv::vx_setall<short>(value); }
+auto fixed(const unsigned& value) { return ::cv::v_setall<unsigned>(value); }
+auto maximum(const unsigned& value) { return ::cv::vx_setall<unsigned>(value); }
+auto fixed(const int& value) { return ::cv::v_setall<int>(value); }
+auto maximum(const int& value) { return ::cv::vx_setall<int>(value); }
+auto fixed(const float& value) { return ::cv::v_setall<float>(value); }
+auto maximum(const float& value) { return ::cv::vx_setall<float>(value); }
+auto fixed(const uint64& value) { return ::cv::v_setall<uint64>(value); }
+auto maximum(const uint64& value) { return ::cv::vx_setall<uint64>(value); }
+auto fixed(const int64& value) { return ::cv::v_setall<int64>(value); }
+auto maximum(const int64& value) { return ::cv::vx_setall<int64>(value); }
+#if CV_SIMD128_64F
+auto fixed(const double& value) { return ::cv::v_setall<double>(value); }
+auto maximum(const double& value) { return ::cv::vx_setall<double>(value); }
+#endif
+}
+export namespace cv { inline namespace opencv_m_simd_repl {
+template<class T> requires pick<T> && requires { typename ::cv::Type2Vec128_Traits<T>::vec_type; }
+inline auto v_setall(const T& value) -> decltype(::opencv_m_simd_broadcast::fixed(value)) {
+return ::opencv_m_simd_broadcast::fixed(value);
+}
+template<class T> requires pick<T> && requires { typename ::cv::Type2Vec128_Traits<T>::vec_type; }
+inline auto vx_setall(const T& value) -> decltype(::opencv_m_simd_broadcast::maximum(value)) {
+return ::opencv_m_simd_broadcast::maximum(value);
+}
+} }
diff --git a/src/simd_legacy_exports.inc b/src/simd_legacy_exports.inc
new file mode 100644
index 0000000..fbdf704
--- /dev/null
+++ b/src/simd_legacy_exports.inc
@@ -0,0 +1,24 @@
+// Generated by tools/generate_simd_legacy.py; original SDK operator templates.
+export namespace cv::hal {
+using ::cv::hal::operator+;
+using ::cv::hal::operator-;
+using ::cv::hal::operator*;
+using ::cv::hal::operator/;
+using ::cv::hal::operator&;
+using ::cv::hal::operator|;
+using ::cv::hal::operator^;
+using ::cv::hal::operator==;
+using ::cv::hal::operator!=;
+using ::cv::hal::operator<;
+using ::cv::hal::operator>;
+using ::cv::hal::operator<=;
+using ::cv::hal::operator>=;
+using ::cv::hal::operator+=;
+using ::cv::hal::operator-=;
+using ::cv::hal::operator*=;
+using ::cv::hal::operator/=;
+using ::cv::hal::operator&=;
+using ::cv::hal::operator|=;
+using ::cv::hal::operator^=;
+using ::cv::hal::operator~;
+}
diff --git a/src/stereo.cppm b/src/stereo.cppm
new file mode 100644
index 0000000..93d7884
--- /dev/null
+++ b/src/stereo.cppm
@@ -0,0 +1,7 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.stereo;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.stereo;
diff --git a/src/stitching.cppm b/src/stitching.cppm
new file mode 100644
index 0000000..55022ef
--- /dev/null
+++ b/src/stitching.cppm
@@ -0,0 +1,9 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.stitching;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.features;
+export import mcpplibs.mwrap.opencv.flann;
+export import mcpplibs.mwrap.opencv.geometry;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.stitching;
diff --git a/src/type_ops.inc b/src/type_ops.inc
new file mode 100644
index 0000000..c8d33bd
--- /dev/null
+++ b/src/type_ops.inc
@@ -0,0 +1,951 @@
+// Generated by tools/generate_type_ops.py; pinned SDK operator bodies retained.
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+export namespace cv { inline namespace opencv_m_repl {
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator += (Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator -= (Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (const Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (_Tp b, const Complex<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (const Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (_Tp b, const Complex<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (_Tp b, const Complex<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator += (Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator -= (Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator *= (Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (const Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator /= (Complex<_Tp>& a, const Complex<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (const Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (_Tp b, const Complex<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator /= (const Complex<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator += (Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator -= (Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator + (const Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator - (const Point_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator - (const Point_<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (int a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (float a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (double a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator += (Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator -= (Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator + (const Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator - (const Point3_<_Tp>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator - (const Point3_<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (int a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (float a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (double a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, int b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, float b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, double b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator *= (Size_<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator * (const Size_<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator /= (Size_<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator / (const Size_<_Tp>& a, _Tp b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator += (Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator + (const Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator -= (Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator - (const Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Size_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Point_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Point_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Size_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Size_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator &= ( Rect_<_Tp>& a, const Rect_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator |= ( Rect_<_Tp>& a, const Rect_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Size_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator & (const Rect_<_Tp>& a, const Rect_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator | (const Rect_<_Tp>& a, const Rect_<_Tp>& b);
+template<class _D = void> requires opencv_m_pick<_D> inline bool operator == (const Range& r1, const Range& r2);
+template<class _D = void> requires opencv_m_pick<_D> inline bool operator != (const Range& r1, const Range& r2);
+template<class _D = void> requires opencv_m_pick<_D> inline bool operator !(const Range& r);
+template<class _D = void> requires opencv_m_pick<_D> inline Range operator & (const Range& r1, const Range& r2);
+template<class _D = void> requires opencv_m_pick<_D> inline Range& operator &= (Range& r1, const Range& r2);
+template<class _D = void> requires opencv_m_pick<_D> inline Range operator + (const Range& r1, int delta);
+template<class _D = void> requires opencv_m_pick<_D> inline Range operator + (int delta, const Range& r1);
+template<class _D = void> requires opencv_m_pick<_D> inline Range operator - (const Range& r1, int delta);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator += (Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator -= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator *= ( Scalar_<_Tp>& a, _Tp v );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b );
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator + (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator - (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, _Tp alpha);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (_Tp alpha, const Scalar_<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator - (const Scalar_<_Tp>& a);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator *= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, _Tp alpha);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<float> operator / (const Scalar_<float>& a, float alpha);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<double> operator / (const Scalar_<double>& a, double alpha);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, _Tp alpha);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (_Tp a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b);
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b);
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    return a.re == b.re && a.im == b.im;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    return a.re != b.re || a.im != b.im;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    return Complex<_Tp>( a.re + b.re, a.im + b.im );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator += (Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    a.re += b.re; a.im += b.im;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    return Complex<_Tp>( a.re - b.re, a.im - b.im );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator -= (Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    a.re -= b.re; a.im -= b.im;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a)
+{
+    return Complex<_Tp>(-a.re, -a.im);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    return Complex<_Tp>( a.re*b.re - a.im*b.im, a.re*b.im + a.im*b.re );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (const Complex<_Tp>& a, _Tp b)
+{
+    return Complex<_Tp>( a.re*b, a.im*b );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator * (_Tp b, const Complex<_Tp>& a)
+{
+    return Complex<_Tp>( a.re*b, a.im*b );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (const Complex<_Tp>& a, _Tp b)
+{
+    return Complex<_Tp>( a.re + b, a.im );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (const Complex<_Tp>& a, _Tp b)
+{ return Complex<_Tp>( a.re - b, a.im ); }
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator + (_Tp b, const Complex<_Tp>& a)
+{
+    return Complex<_Tp>( a.re + b, a.im );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator - (_Tp b, const Complex<_Tp>& a)
+{
+    return Complex<_Tp>( b - a.re, -a.im );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator += (Complex<_Tp>& a, _Tp b)
+{
+    a.re += b; return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator -= (Complex<_Tp>& a, _Tp b)
+{
+    a.re -= b; return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator *= (Complex<_Tp>& a, _Tp b)
+{
+    a.re *= b; a.im *= b; return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (const Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    double t = 1./((double)b.re*b.re + (double)b.im*b.im);
+    return Complex<_Tp>( (_Tp)((a.re*b.re + a.im*b.im)*t),
+                        (_Tp)((-a.re*b.im + a.im*b.re)*t) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp>& operator /= (Complex<_Tp>& a, const Complex<_Tp>& b)
+{
+    a = a / b;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (const Complex<_Tp>& a, _Tp b)
+{
+    _Tp t = (_Tp)1/b;
+    return Complex<_Tp>( a.re*t, a.im*t );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator / (_Tp b, const Complex<_Tp>& a)
+{
+    return Complex<_Tp>(b)/a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Complex<_Tp> operator /= (const Complex<_Tp>& a, _Tp b)
+{
+    _Tp t = (_Tp)1/b;
+    a.re *= t; a.im *= t; return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator += (Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    a.x += b.x;
+    a.y += b.y;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator -= (Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    a.x -= b.x;
+    a.y -= b.y;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, int b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, float b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator *= (Point_<_Tp>& a, double b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, int b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, float b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp>& operator /= (Point_<_Tp>& a, double b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return a.x == b.x && a.y == b.y;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return a.x != b.x || a.y != b.y;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator + (const Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator - (const Point_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator - (const Point_<_Tp>& a)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, int b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (int a, const Point_<_Tp>& b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, float b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (float a, const Point_<_Tp>& b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Point_<_Tp>& a, double b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (double a, const Point_<_Tp>& b)
+{
+    return Point_<_Tp>( saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b)
+{
+    Matx<_Tp, 2, 1> tmp = a * Vec<_Tp,2>(b.x, b.y);
+    return Point_<_Tp>(tmp.val[0], tmp.val[1]);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point_<_Tp>& b)
+{
+    Matx<_Tp, 3, 1> tmp = a * Vec<_Tp,3>(b.x, b.y, 1);
+    return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, int b)
+{
+    Point_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, float b)
+{
+    Point_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point_<_Tp> operator / (const Point_<_Tp>& a, double b)
+{
+    Point_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator += (Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    a.x += b.x;
+    a.y += b.y;
+    a.z += b.z;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator -= (Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    a.x -= b.x;
+    a.y -= b.y;
+    a.z -= b.z;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, int b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    a.z = saturate_cast<_Tp>(a.z * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, float b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    a.z = saturate_cast<_Tp>(a.z * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator *= (Point3_<_Tp>& a, double b)
+{
+    a.x = saturate_cast<_Tp>(a.x * b);
+    a.y = saturate_cast<_Tp>(a.y * b);
+    a.z = saturate_cast<_Tp>(a.z * b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, int b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    a.z = saturate_cast<_Tp>(a.z / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, float b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    a.z = saturate_cast<_Tp>(a.z / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp>& operator /= (Point3_<_Tp>& a, double b)
+{
+    a.x = saturate_cast<_Tp>(a.x / b);
+    a.y = saturate_cast<_Tp>(a.y / b);
+    a.z = saturate_cast<_Tp>(a.z / b);
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    return a.x == b.x && a.y == b.y && a.z == b.z;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    return a.x != b.x || a.y != b.y || a.z != b.z;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator + (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y), saturate_cast<_Tp>(a.z + b.z));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator - (const Point3_<_Tp>& a, const Point3_<_Tp>& b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y), saturate_cast<_Tp>(a.z - b.z));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator - (const Point3_<_Tp>& a)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y), saturate_cast<_Tp>(-a.z) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, int b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b), saturate_cast<_Tp>(a.z*b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (int a, const Point3_<_Tp>& b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, float b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b), saturate_cast<_Tp>(a.z * b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (float a, const Point3_<_Tp>& b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Point3_<_Tp>& a, double b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(a.x * b), saturate_cast<_Tp>(a.y * b), saturate_cast<_Tp>(a.z * b) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (double a, const Point3_<_Tp>& b)
+{
+    return Point3_<_Tp>( saturate_cast<_Tp>(b.x * a), saturate_cast<_Tp>(b.y * a), saturate_cast<_Tp>(b.z * a) );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b)
+{
+    Matx<_Tp, 3, 1> tmp = a * Vec<_Tp,3>(b.x, b.y, b.z);
+    return Point3_<_Tp>(tmp.val[0], tmp.val[1], tmp.val[2]);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b)
+{
+    return a * Matx<_Tp, 4, 1>(b.x, b.y, b.z, 1);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, int b)
+{
+    Point3_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, float b)
+{
+    Point3_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Point3_<_Tp> operator / (const Point3_<_Tp>& a, double b)
+{
+    Point3_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator *= (Size_<_Tp>& a, _Tp b)
+{
+    a.width *= b;
+    a.height *= b;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator * (const Size_<_Tp>& a, _Tp b)
+{
+    Size_<_Tp> tmp(a);
+    tmp *= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator /= (Size_<_Tp>& a, _Tp b)
+{
+    a.width /= b;
+    a.height /= b;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator / (const Size_<_Tp>& a, _Tp b)
+{
+    Size_<_Tp> tmp(a);
+    tmp /= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator += (Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    a.width += b.width;
+    a.height += b.height;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator + (const Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    Size_<_Tp> tmp(a);
+    tmp += b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp>& operator -= (Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    a.width -= b.width;
+    a.height -= b.height;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Size_<_Tp> operator - (const Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    Size_<_Tp> tmp(a);
+    tmp -= b;
+    return tmp;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    return a.width == b.width && a.height == b.height;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Size_<_Tp>& a, const Size_<_Tp>& b)
+{
+    return !(a == b);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Point_<_Tp>& b )
+{
+    a.x += b.x;
+    a.y += b.y;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Point_<_Tp>& b )
+{
+    a.x -= b.x;
+    a.y -= b.y;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Size_<_Tp>& b )
+{
+    a.width += b.width;
+    a.height += b.height;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Size_<_Tp>& b )
+{
+    const _Tp width = a.width - b.width;
+    const _Tp height = a.height - b.height;
+    CV_DbgAssert(width >= 0 && height >= 0);
+    a.width = width;
+    a.height = height;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator &= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
+{
+    if (a.empty() || b.empty()) {
+        a = Rect_<_Tp>();
+        return a;
+    }
+    const Rect_<_Tp>& Rx_min = (a.x < b.x) ? a : b;
+    const Rect_<_Tp>& Rx_max = (a.x < b.x) ? b : a;
+    const Rect_<_Tp>& Ry_min = (a.y < b.y) ? a : b;
+    const Rect_<_Tp>& Ry_max = (a.y < b.y) ? b : a;
+    // Looking at the formula below, we will compute Rx_min.width - (Rx_max.x - Rx_min.x)
+    // but we want to avoid overflows. Rx_min.width >= 0 and (Rx_max.x - Rx_min.x) >= 0
+    // by definition so the difference does not overflow. The only thing that can overflow
+    // is (Rx_max.x - Rx_min.x). And it can only overflow if Rx_min.x < 0.
+    // Let us first deal with the following case.
+    if ((Rx_min.x < 0 && Rx_min.x + Rx_min.width < Rx_max.x) ||
+        (Ry_min.y < 0 && Ry_min.y + Ry_min.height < Ry_max.y)) {
+        a = Rect_<_Tp>();
+        return a;
+    }
+    // We now know that either Rx_min.x >= 0, or
+    // Rx_min.x < 0 && Rx_min.x + Rx_min.width >= Rx_max.x and therefore
+    // Rx_min.width >= (Rx_max.x - Rx_min.x) which means (Rx_max.x - Rx_min.x)
+    // is inferior to a valid int and therefore does not overflow.
+    a.width = std::min(Rx_min.width - (Rx_max.x - Rx_min.x), Rx_max.width);
+    a.height = std::min(Ry_min.height - (Ry_max.y - Ry_min.y), Ry_max.height);
+    a.x = Rx_max.x;
+    a.y = Ry_max.y;
+    if (a.empty())
+        a = Rect_<_Tp>();
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp>& operator |= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
+{
+    if (a.empty()) {
+        a = b;
+    }
+    else if (!b.empty()) {
+        _Tp x1 = std::min(a.x, b.x);
+        _Tp y1 = std::min(a.y, b.y);
+        a.width = std::max(a.x + a.width, b.x + b.width) - x1;
+        a.height = std::max(a.y + a.height, b.y + b.height) - y1;
+        a.x = x1;
+        a.y = y1;
+    }
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
+{
+    return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
+{
+    return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return Rect_<_Tp>( a.x + b.x, a.y + b.y, a.width, a.height );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b)
+{
+    return Rect_<_Tp>( a.x - b.x, a.y - b.y, a.width, a.height );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b)
+{
+    return Rect_<_Tp>( a.x, a.y, a.width + b.width, a.height + b.height );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Size_<_Tp>& b)
+{
+    const _Tp width = a.width - b.width;
+    const _Tp height = a.height - b.height;
+    CV_DbgAssert(width >= 0 && height >= 0);
+    return Rect_<_Tp>( a.x, a.y, width, height );
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator & (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
+{
+    Rect_<_Tp> c = a;
+    return c &= b;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Rect_<_Tp> operator | (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
+{
+    Rect_<_Tp> c = a;
+    return c |= b;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline bool operator == (const Range& r1, const Range& r2)
+{
+    return r1.start == r2.start && r1.end == r2.end;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline bool operator != (const Range& r1, const Range& r2)
+{
+    return !(::cv::opencv_m_repl::operator==(r1, r2));
+}
+
+template<class _D> requires opencv_m_pick<_D> inline bool operator !(const Range& r)
+{
+    return r.start == r.end;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline Range operator & (const Range& r1, const Range& r2)
+{
+    Range r(std::max(r1.start, r2.start), std::min(r1.end, r2.end));
+    r.end = std::max(r.end, r.start);
+    return r;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline Range& operator &= (Range& r1, const Range& r2)
+{
+    r1 = ::cv::opencv_m_repl::operator&(r1, r2);
+    return r1;
+}
+
+template<class _D> requires opencv_m_pick<_D> inline Range operator + (const Range& r1, int delta)
+{
+    return Range(r1.start + delta, r1.end + delta);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline Range operator + (int delta, const Range& r1)
+{
+    return Range(r1.start + delta, r1.end + delta);
+}
+
+template<class _D> requires opencv_m_pick<_D> inline Range operator - (const Range& r1, int delta)
+{
+    return ::cv::opencv_m_repl::operator+(r1, -delta);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator += (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    a.val[0] += b.val[0];
+    a.val[1] += b.val[1];
+    a.val[2] += b.val[2];
+    a.val[3] += b.val[3];
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator -= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    a.val[0] -= b.val[0];
+    a.val[1] -= b.val[1];
+    a.val[2] -= b.val[2];
+    a.val[3] -= b.val[3];
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator *= ( Scalar_<_Tp>& a, _Tp v )
+{
+    a.val[0] *= v;
+    a.val[1] *= v;
+    a.val[2] *= v;
+    a.val[3] *= v;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator == ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
+{
+    return a.val[0] == b.val[0] && a.val[1] == b.val[1] &&
+           a.val[2] == b.val[2] && a.val[3] == b.val[3];
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline bool operator != ( const Scalar_<_Tp>& a, const Scalar_<_Tp>& b )
+{
+    return a.val[0] != b.val[0] || a.val[1] != b.val[1] ||
+           a.val[2] != b.val[2] || a.val[3] != b.val[3];
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator + (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    return Scalar_<_Tp>(a.val[0] + b.val[0],
+                        a.val[1] + b.val[1],
+                        a.val[2] + b.val[2],
+                        a.val[3] + b.val[3]);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator - (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    return Scalar_<_Tp>(saturate_cast<_Tp>(a.val[0] - b.val[0]),
+                        saturate_cast<_Tp>(a.val[1] - b.val[1]),
+                        saturate_cast<_Tp>(a.val[2] - b.val[2]),
+                        saturate_cast<_Tp>(a.val[3] - b.val[3]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, _Tp alpha)
+{
+    return Scalar_<_Tp>(a.val[0] * alpha,
+                        a.val[1] * alpha,
+                        a.val[2] * alpha,
+                        a.val[3] * alpha);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (_Tp alpha, const Scalar_<_Tp>& a)
+{
+    return a*alpha;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator - (const Scalar_<_Tp>& a)
+{
+    return Scalar_<_Tp>(saturate_cast<_Tp>(-a.val[0]),
+                        saturate_cast<_Tp>(-a.val[1]),
+                        saturate_cast<_Tp>(-a.val[2]),
+                        saturate_cast<_Tp>(-a.val[3]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator * (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    return Scalar_<_Tp>(saturate_cast<_Tp>(a[0]*b[0] - a[1]*b[1] - a[2]*b[2] - a[3]*b[3]),
+                        saturate_cast<_Tp>(a[0]*b[1] + a[1]*b[0] + a[2]*b[3] - a[3]*b[2]),
+                        saturate_cast<_Tp>(a[0]*b[2] - a[1]*b[3] + a[2]*b[0] + a[3]*b[1]),
+                        saturate_cast<_Tp>(a[0]*b[3] + a[1]*b[2] - a[2]*b[1] + a[3]*b[0]));
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator *= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    a = a * b;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, _Tp alpha)
+{
+    return Scalar_<_Tp>(a.val[0] / alpha,
+                        a.val[1] / alpha,
+                        a.val[2] / alpha,
+                        a.val[3] / alpha);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<float> operator / (const Scalar_<float>& a, float alpha)
+{
+    float s = 1 / alpha;
+    return Scalar_<float>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<double> operator / (const Scalar_<double>& a, double alpha)
+{
+    double s = 1 / alpha;
+    return Scalar_<double>(a.val[0] * s, a.val[1] * s, a.val[2] * s, a.val[3] * s);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, _Tp alpha)
+{
+    a = a / alpha;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (_Tp a, const Scalar_<_Tp>& b)
+{
+    _Tp s = a / (b[0]*b[0] + b[1]*b[1] + b[2]*b[2] + b[3]*b[3]);
+    return b.conj() * s;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    return a * ((_Tp)1 / b);
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar_<_Tp>& operator /= (Scalar_<_Tp>& a, const Scalar_<_Tp>& b)
+{
+    a = a / b;
+    return a;
+}
+
+template<typename _Tp> requires opencv_m_pick<_Tp> inline Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
+{
+    Matx<double, 4, 1> c((Matx<double, 4, 4>)a, b, Matx_MatMulOp());
+    return reinterpret_cast<const Scalar&>(c);
+}
+} } // cv::opencv_m_repl
diff --git a/src/utils_helpers.inc b/src/utils_helpers.inc
new file mode 100644
index 0000000..c887ba3
--- /dev/null
+++ b/src/utils_helpers.inc
@@ -0,0 +1,42 @@
+// Generated by tools/generate_inline_helpers.py; exact original SDK utility forwards.
+namespace opencv_m_utils_up {
+using cv::String; using cv::Rect; using cv::TermCriteria; using cv::RotatedRect; using cv::Range;
+String dumpBool(bool argument) { return ::cv::utils::dumpBool(argument); }
+String dumpInt(int argument) { return ::cv::utils::dumpInt(argument); }
+String dumpInt64(int64 argument) { return ::cv::utils::dumpInt64(argument); }
+String dumpSizeT(size_t argument) { return ::cv::utils::dumpSizeT(argument); }
+String dumpFloat(float argument) { return ::cv::utils::dumpFloat(argument); }
+String dumpDouble(double argument) { return ::cv::utils::dumpDouble(argument); }
+String dumpCString(const char* argument) { return ::cv::utils::dumpCString(argument); }
+String dumpString(const String& argument) { return ::cv::utils::dumpString(argument); }
+String dumpRect(const Rect& argument) { return ::cv::utils::dumpRect(argument); }
+String dumpTermCriteria(const TermCriteria& argument) { return ::cv::utils::dumpTermCriteria(argument); }
+String dumpRotatedRect(const RotatedRect& argument) { return ::cv::utils::dumpRotatedRect(argument); }
+String dumpRange(const Range& argument) { return ::cv::utils::dumpRange(argument); }
+}
+export namespace cv { namespace utils { inline namespace opencv_m_utils_repl {
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpBool(bool argument) { return ::opencv_m_utils_up::dumpBool(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpInt(int argument) { return ::opencv_m_utils_up::dumpInt(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpInt64(int64 argument) { return ::opencv_m_utils_up::dumpInt64(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpSizeT(size_t argument) { return ::opencv_m_utils_up::dumpSizeT(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpFloat(float argument) { return ::opencv_m_utils_up::dumpFloat(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpDouble(double argument) { return ::opencv_m_utils_up::dumpDouble(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpCString(const char* argument) { return ::opencv_m_utils_up::dumpCString(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpString(const String& argument) { return ::opencv_m_utils_up::dumpString(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpRect(const Rect& argument) { return ::opencv_m_utils_up::dumpRect(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpTermCriteria(const TermCriteria& argument) { return ::opencv_m_utils_up::dumpTermCriteria(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpRotatedRect(const RotatedRect& argument) { return ::opencv_m_utils_up::dumpRotatedRect(argument); }
+template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>
+inline String dumpRange(const Range& argument) { return ::opencv_m_utils_up::dumpRange(argument); }
+} } } // cv::utils::opencv_m_utils_repl
diff --git a/src/video.cppm b/src/video.cppm
new file mode 100644
index 0000000..7541334
--- /dev/null
+++ b/src/video.cppm
@@ -0,0 +1,6 @@
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.video;
+
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.video;
diff --git a/src/videoio.cppm b/src/videoio.cppm
index 523a003..8f6fcd1 100644
--- a/src/videoio.cppm
+++ b/src/videoio.cppm
@@ -1,8 +1,7 @@
-// opencv.videoio — C++23 module over OpenCV 5 videoio (API unchanged).
-module;
-#include <opencv2/videoio.hpp>
-#include <opencv2/videoio/registry.hpp>
+// Generated by tools/generate_build.py; the header adapter lives in detail.
+export module mcpplibs.mwrap.opencv.videoio;
 
-export module opencv.videoio;
-
-#include "gen_exports/videoio.inc"
+export import mcpplibs.mwrap.opencv.core;
+export import mcpplibs.mwrap.opencv.imgcodecs;
+export import mcpplibs.mwrap.opencv.imgproc;
+export import mcpplibs.mwrap.opencv.detail.videoio;
diff --git a/templates/imgproc/mcpp.toml.in b/templates/imgproc/mcpp.toml.in
index 6804a9c..ad51726 100644
--- a/templates/imgproc/mcpp.toml.in
+++ b/templates/imgproc/mcpp.toml.in
@@ -3,11 +3,8 @@ name        = "{{project.name}}"
 version     = "0.1.0"
 description = "OpenCV image pipeline ({{project.name}})"
 
-# `opencv` is spelled out: templates substitute only project.name,
-# self.name and self.version — there is no namespace placeholder yet.
-# See mcpp-index#163.
-[dependencies.opencv]
-{{self.name}} = "{{self.version}}"
+[dependencies]
+"{{self.name}}" = { version = "{{self.version}}", features = ["imgproc", "imgcodecs-png", "imgcodecs-jpeg"] }
 
 [targets.{{project.name}}]
 kind = "bin"
diff --git a/templates/imgproc/src/main.cpp.in b/templates/imgproc/src/main.cpp.in
index 29f0f9d..1101705 100644
--- a/templates/imgproc/src/main.cpp.in
+++ b/templates/imgproc/src/main.cpp.in
@@ -1,21 +1,12 @@
-// {{project.name}} — OpenCV 5 via C++23 modules: same API, no OpenCV headers.
-#include <cstdio>   // stderr: a C macro, so not exported by `import std;`
 import std;
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
-int main(int argc, char** argv) {
-    if (argc < 2) {
-        std::println(stderr, "usage: {{project.name}} <image-file>");
-        return 1;
-    }
-    cv::Mat img = cv::imread(argv[1], cv::IMREAD_COLOR);
-    if (img.empty()) {
-        std::println(stderr, "cannot read {}", argv[1]);
-        return 1;
-    }
-    std::println("{}: {}x{}, {} channels", argv[1], img.cols, img.rows, img.channels());
+int main() {
+    namespace macros = mcpplibs::mwrap::opencv::macros;
+    cv::Mat image(64, 64, macros::CV_8UC3, cv::Scalar(20, 80, 160));
     cv::Mat gray;
-    cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY);
-    cv::imwrite("out.png", gray);
-    std::println("out.png written");
+    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
+    if (gray.rows != 64 || gray.cols != 64 || gray.channels() != 1) return 1;
+    if (!cv::imwrite("out.png", gray)) return 2;
+    std::println("OpenCV {}: wrote {}x{} out.png", cv::getVersionString(), gray.cols, gray.rows);
 }
diff --git a/templates/imgproc/template.toml b/templates/imgproc/template.toml
index 047b03e..00d819a 100644
--- a/templates/imgproc/template.toml
+++ b/templates/imgproc/template.toml
@@ -1,4 +1,4 @@
 [template]
-description  = "Image pipeline skeleton with import opencv.cv"
-default      = true
-post_message = "cd into the project and run `mcpp run -- <image-file>`."
+description = "Generate an image, convert it to grayscale, and write a PNG"
+default = true
+post_message = "Run `mcpp run` to generate out.png; no input image is required."
diff --git a/templates/onnxruntime/mcpp.toml.in b/templates/onnxruntime/mcpp.toml.in
new file mode 100644
index 0000000..352fd6f
--- /dev/null
+++ b/templates/onnxruntime/mcpp.toml.in
@@ -0,0 +1,10 @@
+[package]
+name = "{{project.name}}"
+version = "0.1.0"
+description = "OpenCV ONNX Runtime CPU inference"
+
+[dependencies]
+"{{self.name}}" = { version = "{{self.version}}", features = ["dnn-onnxruntime"] }
+
+[target.x86_64-linux-gnu]
+cxx_runtime = "toolchain-coupled"
diff --git a/templates/onnxruntime/src/main.cpp.in b/templates/onnxruntime/src/main.cpp.in
new file mode 100644
index 0000000..c3c987b
--- /dev/null
+++ b/templates/onnxruntime/src/main.cpp.in
@@ -0,0 +1,32 @@
+#include "model.hpp"
+import std;
+import mcpplibs.mwrap.onnxruntime;
+import mcpplibs.mwrap.opencv;
+
+int main() {
+    struct ModelFile {
+        std::filesystem::path path = std::filesystem::temp_directory_path() /
+            ("mwrap-opencv-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) + ".onnx");
+        ~ModelFile() { std::error_code error; std::filesystem::remove(path, error); }
+    } model;
+    {
+        std::ofstream out(model.path, std::ios::binary);
+        out.write(reinterpret_cast<const char*>(opencv_ort_model), sizeof(opencv_ort_model));
+    }
+    auto net = cv::dnn::readNetFromONNX(model.path.string(), cv::dnn::ENGINE_ORT);
+    cv::Mat input(1, 3, mcpplibs::mwrap::opencv::macros::CV_32F);
+    for (int i = 0; i < 3; ++i) input.at<float>(0, i) = float(i + 1);
+    net.setInput(input, "x");
+    const auto output = net.forward("y");
+    if (output.total() != 3) return 1;
+    for (int i = 0; i < 3; ++i)
+        if (output.ptr<float>()[i] != float(2 * (i + 1))) return 2;
+    // Exercise the exception ABI as well as inference in the SDK process.
+    try {
+        cv::error(cv::Error::StsBadArg, "runtime contract", __func__, __FILE__, __LINE__);
+        return 3;
+    } catch (const cv::Exception& error) {
+        if (error.code != cv::Error::StsBadArg) return 4;
+    }
+    std::println("OpenCV {} -> ONNX Runtime {}: CPU Add inference passed", cv::getVersionString(), Ort::GetVersionString());
+}
diff --git a/templates/onnxruntime/src/model.hpp b/templates/onnxruntime/src/model.hpp
new file mode 100644
index 0000000..bdaf24b
--- /dev/null
+++ b/templates/onnxruntime/src/model.hpp
@@ -0,0 +1,2 @@
+#pragma once
+inline constexpr unsigned char opencv_ort_model[] = {0x08, 0x08, 0x12, 0x0d, 0x6d, 0x77, 0x72, 0x61, 0x70, 0x2d, 0x66, 0x69, 0x78, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x5a, 0x0a, 0x1c, 0x0a, 0x01, 0x78, 0x0a, 0x01, 0x78, 0x12, 0x01, 0x79, 0x1a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x03, 0x41, 0x64, 0x64, 0x12, 0x10, 0x6d, 0x77, 0x72, 0x61, 0x70, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x63, 0x76, 0x5f, 0x6f, 0x72, 0x74, 0x5a, 0x13, 0x0a, 0x01, 0x78, 0x12, 0x0e, 0x0a, 0x0c, 0x08, 0x01, 0x12, 0x08, 0x0a, 0x02, 0x08, 0x01, 0x0a, 0x02, 0x08, 0x03, 0x62, 0x13, 0x0a, 0x01, 0x79, 0x12, 0x0e, 0x0a, 0x0c, 0x08, 0x01, 0x12, 0x08, 0x0a, 0x02, 0x08, 0x01, 0x0a, 0x02, 0x08, 0x03, 0x42, 0x02, 0x10, 0x0d};
diff --git a/templates/onnxruntime/template.toml b/templates/onnxruntime/template.toml
new file mode 100644
index 0000000..02ef4ac
--- /dev/null
+++ b/templates/onnxruntime/template.toml
@@ -0,0 +1,3 @@
+[template]
+description = "Run a generated ONNX model through OpenCV's ONNX Runtime CPU engine"
+post_message = "Run `mcpp run` to verify OpenCV -> ONNX Runtime CPU inference."
diff --git a/templates/video/mcpp.toml.in b/templates/video/mcpp.toml.in
new file mode 100644
index 0000000..2cb6d93
--- /dev/null
+++ b/templates/video/mcpp.toml.in
@@ -0,0 +1,7 @@
+[package]
+name = "{{project.name}}"
+version = "0.1.0"
+description = "OpenCV video file quickstart"
+
+[dependencies]
+"{{self.name}}" = { version = "{{self.version}}", features = ["videoio-native", "videoio-ffmpeg"] }
diff --git a/templates/video/src/main.cpp.in b/templates/video/src/main.cpp.in
new file mode 100644
index 0000000..f0bb7fd
--- /dev/null
+++ b/templates/video/src/main.cpp.in
@@ -0,0 +1,32 @@
+import std;
+import mcpplibs.mwrap.opencv;
+
+int main() {
+    struct Output {
+        std::filesystem::path path = "{{project.name}}.avi";
+        ~Output() { std::error_code error; std::filesystem::remove(path, error); }
+    } output;
+    const auto cameras = cv::videoio_registry::getCameraBackends();
+    for (auto backend : cameras)
+        std::println("Registered camera backend: {} (no device opened)", cv::videoio_registry::getBackendName(backend));
+    cv::VideoWriter writer(output.path.string(), cv::CAP_FFMPEG,
+        cv::VideoWriter::fourcc('M', 'J', 'P', 'G'), 24.0, cv::Size(96, 64));
+    if (!writer.isOpened()) return 1;
+    for (int frame = 0; frame < 12; ++frame) {
+        cv::Mat image(64, 96, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30 + frame, 60, 90));
+        writer.write(image);
+    }
+    writer.release();
+    cv::VideoCapture reader(output.path.string(), cv::CAP_FFMPEG);
+    if (!reader.isOpened() || reader.getBackendName() != "FFMPEG") return 2;
+    cv::Mat decoded;
+    int count = 0;
+    while (reader.read(decoded)) {
+        if (decoded.rows != 64 || decoded.cols != 96 || decoded.channels() != 3) return 3;
+        cv::Mat expected(64, 96, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30 + count, 60, 90));
+        if (cv::norm(decoded, expected, cv::NORM_L1) / (64.0 * 96 * 3) >= 15.0) return 4;
+        ++count;
+    }
+    std::println("FFmpeg encoded and decoded {} frames", count);
+    return count == 12 ? 0 : 5;
+}
diff --git a/templates/video/template.toml b/templates/video/template.toml
new file mode 100644
index 0000000..768a34f
--- /dev/null
+++ b/templates/video/template.toml
@@ -0,0 +1,3 @@
+[template]
+description = "Encode and decode generated frames with FFmpeg and inspect the native camera backend"
+post_message = "Run `mcpp run` to encode/decode a generated video without a camera."
diff --git a/templates/window/mcpp.toml.in b/templates/window/mcpp.toml.in
new file mode 100644
index 0000000..f057264
--- /dev/null
+++ b/templates/window/mcpp.toml.in
@@ -0,0 +1,7 @@
+[package]
+name = "{{project.name}}"
+version = "0.1.0"
+description = "OpenCV native window quickstart"
+
+[dependencies]
+"{{self.name}}" = { version = "{{self.version}}", features = ["highgui-native", "imgcodecs-png"] }
diff --git a/templates/window/src/main.cpp.in b/templates/window/src/main.cpp.in
new file mode 100644
index 0000000..53f2fdc
--- /dev/null
+++ b/templates/window/src/main.cpp.in
@@ -0,0 +1,18 @@
+import std;
+import mcpplibs.mwrap.opencv;
+
+int main(int argc, char** argv) {
+    const bool smoke = argc > 1 && std::string_view(argv[1]) == "--smoke-test";
+    const auto backend = cv::currentUIFramework();
+    if (backend.empty()) return 1;
+    cv::Mat image(128, 192, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30, 90, 180));
+    cv::namedWindow("{{project.name}}", cv::WINDOW_NORMAL);
+    cv::imshow("{{project.name}}", image);
+    std::println("OpenCV window backend: {}. Press a key in the window to close it.", backend);
+    cv::waitKey(smoke ? 100 : 0);
+    const auto rect = cv::getWindowImageRect("{{project.name}}");
+    const bool displayed = rect.width > 0 && rect.height > 0;
+    cv::destroyAllWindows();
+    cv::waitKey(10);
+    return displayed ? 0 : 2;
+}
diff --git a/templates/window/template.toml b/templates/window/template.toml
new file mode 100644
index 0000000..3f9de47
--- /dev/null
+++ b/templates/window/template.toml
@@ -0,0 +1,3 @@
+[template]
+description = "Display a generated image with the platform's native highgui backend"
+post_message = "Run `mcpp run` and press a key in the window to close it. CI can pass --smoke-test."
diff --git a/tests/api_surface_test.cpp b/tests/api_surface_test.cpp
index d7c55de..cb2a8a3 100644
--- a/tests/api_surface_test.cpp
+++ b/tests/api_surface_test.cpp
@@ -1,35 +1,57 @@
 // API-surface smoke tests through the module layer ONLY (no textual OpenCV
 // headers in this TU): the imported names must expose the OpenCV C++ API
-// unchanged, and the constant macros must be reachable as cv:: constexpr.
+// unchanged, with macro constants in the wrapper's macros namespace.
 #include <gtest/gtest.h>
 
 #include <vector>
+#include <string>
 
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 TEST(ApiSurface, VersionMatchesPinnedRelease) {
     EXPECT_EQ(cv::getVersionString(), "5.0.0");
     EXPECT_EQ(cv::getVersionMajor(), 5);
 }
 
+TEST(ApiSurface, BuildInformationMatchesSelectedCodecs) {
+    const std::string info = cv::getBuildInformation();
+#if defined(MCPP_FEATURE_IMGCODECS_PNG)
+    EXPECT_NE(info.find("PNG: YES"), std::string::npos);
+#else
+    EXPECT_NE(info.find("PNG: NO"), std::string::npos);
+#endif
+#if defined(MCPP_FEATURE_IMGCODECS_JPEG)
+    EXPECT_NE(info.find("JPEG: YES"), std::string::npos);
+#else
+    EXPECT_NE(info.find("JPEG: NO"), std::string::npos);
+#endif
+#if defined(MCPP_FEATURE_IMGCODECS_WEBP)
+    EXPECT_NE(info.find("WEBP: YES"), std::string::npos);
+#else
+    EXPECT_NE(info.find("WEBP: NO"), std::string::npos);
+#endif
+}
+
 TEST(ApiSurface, CoreTypesAndConstants) {
-    static_assert(cv::CV_MAKETYPE(cv::CV_8U, 3) == cv::CV_8UC3);
-    cv::Mat m(4, 4, cv::CV_8UC3, cv::Scalar(1, 2, 3));
+    static_assert(mcpplibs::mwrap::opencv::macros::CV_MAKETYPE(mcpplibs::mwrap::opencv::macros::CV_8U, 3) == mcpplibs::mwrap::opencv::macros::CV_8UC3);
+    cv::Mat m(4, 4, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(1, 2, 3));
     EXPECT_EQ(m.rows, 4);
-    EXPECT_EQ(m.type(), cv::CV_8UC3);
+    EXPECT_EQ(m.type(), mcpplibs::mwrap::opencv::macros::CV_8UC3);
     cv::Point2f p(1.f, 2.f);
     cv::Rect r(0, 0, 4, 4);
     EXPECT_TRUE(r.contains(cv::Point(1, 1)));
     EXPECT_FLOAT_EQ(p.x, 1.f);
 }
 
+#if defined(MCPP_FEATURE_IMGPROC)
 TEST(ApiSurface, ImgprocEnumsAndOps) {
-    cv::Mat src(8, 8, cv::CV_8UC3, cv::Scalar(10, 20, 30)), dst, gray;
+    cv::Mat src(8, 8, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(10, 20, 30)), dst, gray;
     cv::resize(src, dst, {16, 16}, 0, 0, cv::INTER_CUBIC);
     cv::cvtColor(dst, gray, cv::COLOR_BGR2GRAY);
     EXPECT_TRUE(gray.size() == cv::Size(16, 16));  // see printer note below
     EXPECT_EQ(gray.channels(), 1);
 }
+#endif
 
 TEST(ApiSurface, ReplacementValueOps) {
     // upstream declares these operators `static inline` (TU-local) — the
@@ -51,9 +73,11 @@ TEST(ApiSurface, ReplacementValueOps) {
     EXPECT_EQ(cv::saturate_cast<short>(1e9f), 32767);
 }
 
+#if defined(MCPP_FEATURE_VIDEOIO)
 TEST(ApiSurface, VideoioRegistry) {
     EXPECT_FALSE(cv::videoio_registry::getBackends().empty());
 }
+#endif
 
 TEST(MatxOps, Algebra) {
     // R1 replacement surface: Matx/Vec namespace-scope operators.
diff --git a/tests/core_cpp_types_test.cpp b/tests/core_cpp_types_test.cpp
new file mode 100644
index 0000000..a2d5840
--- /dev/null
+++ b/tests/core_cpp_types_test.cpp
@@ -0,0 +1,232 @@
+#include <gtest/gtest.h>
+#include <chrono>
+#include <filesystem>
+#include <memory>
+#include <thread>
+#include <type_traits>
+#include <vector>
+
+import mcpplibs.mwrap.opencv.core;
+import mcpplibs.mwrap.opencv.macros;
+
+TEST(CoreCppTypes, UpstreamGlobalAndCppAliasesRemainAvailable) {
+    static_assert(std::is_same_v<uchar, unsigned char>);
+    static_assert(std::is_same_v<schar, signed char>);
+    static_assert(std::is_same_v<ushort, unsigned short>);
+    static_assert(sizeof(int64) == 8 && sizeof(uint64) == 8);
+    static_assert(std::is_same_v<cv::int64_t, std::int64_t>);
+    static_assert(sizeof(cv::Vec3l::value_type) == 8);
+    static_assert(sizeof(cv::bfloat) == 2 && sizeof(cv::hfloat) == 2);
+    static_assert(CPU_AVX512_ICL > CPU_AVX2 && CPU_RVV_ZVFH > CPU_RVV);
+    Cv32suf bits{};
+    bits.f = 1.0f;
+    EXPECT_EQ(bits.u, 0x3f800000u);
+    cv::MatND matrix(2, 3, mcpplibs::mwrap::opencv::macros::CV_8UC1);
+    EXPECT_EQ(matrix.total(), 6u);
+}
+
+TEST(CoreCppTypes, AffineCompositionPointsVectorsAndInverse) {
+    const cv::Affine3d translation(cv::Vec3d(0, 0, 0), cv::Vec3d(1, 2, 3));
+    const auto vector = translation * cv::Vec3d(4, 5, 6);
+    const auto point = translation * cv::Point3d(4, 5, 6);
+    EXPECT_DOUBLE_EQ(vector[0], 5);
+    EXPECT_DOUBLE_EQ(vector[1], 7);
+    EXPECT_DOUBLE_EQ(vector[2], 9);
+    EXPECT_DOUBLE_EQ(point.x, 5);
+    EXPECT_DOUBLE_EQ(point.y, 7);
+    EXPECT_DOUBLE_EQ(point.z, 9);
+    const auto identity = translation.inv() * translation;
+    const auto restored = identity * cv::Vec3d(4, 5, 6);
+    EXPECT_NEAR(restored[0], 4, 1e-12);
+    EXPECT_NEAR(restored[1], 5, 1e-12);
+    EXPECT_NEAR(restored[2], 6, 1e-12);
+}
+
+TEST(CoreCppTypes, QuaternionRotationAndGrowingAutoBuffer) {
+    const auto q = cv::Quatd::createFromAngleAxis(
+        mcpplibs::mwrap::opencv::macros::CV_PI / 2, cv::Vec3d(0, 0, 1));
+    const auto rotated = q.toRotMat3x3() * cv::Vec3d(1, 0, 0);
+    EXPECT_NEAR(rotated[0], 0, 1e-12);
+    EXPECT_NEAR(rotated[1], 1, 1e-12);
+    EXPECT_NEAR(rotated[2], 0, 1e-12);
+    cv::AutoBuffer<int, 4> buffer(3, 7);
+    buffer.resize(12);
+    EXPECT_EQ(buffer.size(), 12u);
+    EXPECT_EQ(buffer.data()[2], 7);
+    buffer.data()[11] = 42;
+    EXPECT_EQ(buffer.data()[11], 42);
+    std::vector<int> labels;
+    const int classes = cv::partition(std::vector<int>{1, 2, 1, 3, 2}, labels,
+        [](int a, int b) { return a == b; });
+    EXPECT_EQ(classes, 3);
+    EXPECT_EQ(labels[0], labels[2]);
+    EXPECT_EQ(labels[1], labels[4]);
+    EXPECT_NE(labels[0], labels[1]);
+}
+
+TEST(CoreCppTypes, ErrorCodesTraitsAndLoggingKeepTheirCppSurface) {
+    static_assert(cv::traits::Type<cv::Vec3b>::value == mcpplibs::mwrap::opencv::macros::CV_8UC3);
+    static_assert(cv::traits::Depth<float>::value == mcpplibs::mwrap::opencv::macros::CV_32F);
+    static_assert(cv::ParamType<int>::type == cv::Param::INT);
+    try {
+        cv::error(cv::Error::StsBadArg, "module error surface", __func__, __FILE__, __LINE__);
+        FAIL() << "cv::error must throw";
+    } catch (const cv::Exception& error) {
+        EXPECT_EQ(error.code, cv::Error::StsBadArg);
+    }
+    namespace logging = cv::utils::logging;
+    const auto previous = logging::setLogLevel(logging::LOG_LEVEL_DEBUG);
+    EXPECT_EQ(logging::getLogLevel(), logging::LOG_LEVEL_DEBUG);
+    logging::setLogLevel(previous);
+}
+
+TEST(CoreCppTypes, QuaternionFreeFunctionsOperateThroughDirectImport) {
+    const auto quarter_turn = cv::Quatd::createFromAngleAxis(
+        mcpplibs::mwrap::opencv::macros::CV_PI / 2, cv::Vec3d(0, 0, 1));
+    const auto inverted = cv::inv(quarter_turn).toRotMat3x3() * cv::Vec3d(1, 0, 0);
+    EXPECT_NEAR(inverted[0], 0, 1e-12);
+    EXPECT_NEAR(inverted[1], -1, 1e-12);
+    const auto half_turn = cv::power(quarter_turn, 2.0).toRotMat3x3() * cv::Vec3d(1, 0, 0);
+    EXPECT_NEAR(half_turn[0], -1, 1e-12);
+    EXPECT_NEAR(half_turn[1], 0, 1e-12);
+}
+
+TEST(CoreCppTypes, DualQuaternionPreservesRigidTransform) {
+    const auto pose = cv::DualQuatd::createFromAngleAxisTrans(
+        0.0, cv::Vec3d(0, 0, 1), cv::Vec3d(1, 2, 3));
+    const auto translated = pose.toAffine3() * cv::Point3d(4, 5, 6);
+    EXPECT_NEAR(translated.x, 5, 1e-12);
+    EXPECT_NEAR(translated.y, 7, 1e-12);
+    EXPECT_NEAR(translated.z, 9, 1e-12);
+}
+
+TEST(CoreCppTypes, AsyncPromiseTransfersAMatrix) {
+    cv::AsyncPromise promise;
+    auto result = promise.getArrayResult();
+    cv::Mat source(2, 3, mcpplibs::mwrap::opencv::macros::CV_32F, cv::Scalar(7));
+    promise.setValue(source);
+    cv::Mat destination;
+    result.get(destination);
+    ASSERT_EQ(destination.rows, 2);
+    ASSERT_EQ(destination.cols, 3);
+    EXPECT_FLOAT_EQ(destination.at<float>(1, 2), 7);
+}
+
+TEST(CoreCppTypes, FilesystemHelpersOperateOnATemporaryTree) {
+    namespace fs = std::filesystem;
+    const auto directory = fs::temp_directory_path() / ("opencv-mwrap-" +
+        std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
+    struct Cleanup {
+        fs::path path;
+        ~Cleanup() { std::error_code ec; fs::remove_all(path, ec); }
+    } cleanup{directory};
+    const auto nested = directory / "child";
+    ASSERT_TRUE(cv::utils::fs::createDirectories(nested.string()));
+    EXPECT_TRUE(cv::utils::fs::exists(nested.string()));
+    EXPECT_TRUE(cv::utils::fs::isDirectory(nested.string()));
+    cv::utils::fs::remove_all(directory.string());
+    EXPECT_FALSE(cv::utils::fs::exists(directory.string()));
+}
+
+TEST(CoreCppTypes, TlsStorageSeparatesThreadValues) {
+    cv::TLSData<int> storage;
+    *storage.get() = 7;
+    int child_value = 0;
+    std::thread worker([&] {
+        *storage.get() = 11;
+        child_value = *storage.get();
+    });
+    worker.join();
+    EXPECT_EQ(child_value, 11);
+    EXPECT_EQ(*storage.get(), 7);
+}
+
+namespace {
+class CallerParallelBackend final : public cv::parallel::ParallelForAPI {
+    int threads_ = 2;
+public:
+    int calls = 0;
+    void parallel_for(int tasks, FN_parallel_for_body_cb_t callback, void* data) override {
+        ++calls;
+        callback(0, tasks, data);
+    }
+    int getThreadNum() const override { return 0; }
+    int getNumThreads() const override { return threads_; }
+    int setNumThreads(int value) override { const int previous = threads_; threads_ = value; return previous; }
+    const char* getName() const override { return "mwrap-caller"; }
+};
+class FillParallelBody final : public cv::ParallelLoopBody {
+    std::vector<int>& values_;
+public:
+    explicit FillParallelBody(std::vector<int>& values) : values_(values) {}
+    void operator()(const cv::Range& range) const override {
+        for (int i = range.start; i < range.end; ++i) values_[i] = i + 1;
+    }
+};
+}
+
+TEST(CoreCppTypes, CallerCanSupplyTheParallelBackend) {
+    const int previous_threads = cv::getNumThreads();
+    cv::setNumThreads(2);
+    auto backend = std::make_shared<CallerParallelBackend>();
+    cv::parallel::setParallelForBackend(backend);
+    struct Restore {
+        int threads;
+        ~Restore() {
+            cv::parallel::setParallelForBackend(std::shared_ptr<cv::parallel::ParallelForAPI>{});
+            cv::setNumThreads(threads);
+        }
+    } restore{previous_threads};
+    std::vector<int> values(100, 0);
+    cv::parallel_for_(cv::Range(0, 100), FillParallelBody(values), 2);
+    EXPECT_GT(backend->calls, 0);
+    for (int i = 0; i < 100; ++i) EXPECT_EQ(values[i], i + 1);
+}
+
+TEST(CoreCppTypes, CpuBuildExposesTheUpstreamDeviceQuerySurface) {
+    EXPECT_EQ(cv::cuda::getCudaEnabledDeviceCount(), 0);
+    static_assert(cv::cuda::FEATURE_SET_COMPUTE_20 == 20);
+    static_assert(cv::ogl::TRIANGLES == 0x0004);
+}
+
+TEST(CoreCppTypes, StdAliasesAndImageMinMaxRetainTheirOverloads) {
+    const double first = -0.0, second = 0.0;
+    EXPECT_EQ(&cv::min(first, second), &first);
+    EXPECT_EQ(&cv::max(first, second), &first);
+    EXPECT_EQ(cv::min(std::string("alpha"), std::string("beta")), "alpha");
+    EXPECT_EQ(cv::max(3, 5, std::greater<int>{}), 3);
+    EXPECT_EQ(cv::min({3, 1, 2}), 1);
+    cv::Mat a(2, 2, mcpplibs::mwrap::opencv::macros::CV_32F, cv::Scalar(6));
+    cv::Mat b(2, 2, mcpplibs::mwrap::opencv::macros::CV_32F, cv::Scalar(3)), result;
+    cv::min(a, b, result);
+    EXPECT_FLOAT_EQ(result.at<float>(0, 0), 3);
+    cv::max(a, b, result);
+    EXPECT_FLOAT_EQ(result.at<float>(0, 0), 6);
+    cv::UMat ua, ub, ur;
+    a.copyTo(ua); b.copyTo(ub);
+    cv::min(ua, ub, ur);
+    EXPECT_FLOAT_EQ(ur.getMat(cv::ACCESS_READ).at<float>(0, 0), 3);
+    cv::max(ua, ub, ur);
+    EXPECT_FLOAT_EQ(ur.getMat(cv::ACCESS_READ).at<float>(0, 0), 6);
+}
+
+struct MwrapCustomResource { int* deletions; };
+namespace cv {
+template<> struct DefaultDeleter<MwrapCustomResource> {
+    void operator()(MwrapCustomResource* resource) const {
+        ++*resource->deletions;
+        delete resource;
+    }
+};
+}
+TEST(CoreCppTypes, PtrHonorsTheUpstreamCustomDeleterTrait) {
+    static_assert(cv::has_custom_delete<MwrapCustomResource>::value);
+    int deletions = 0;
+    {
+        cv::Ptr<MwrapCustomResource> resource(new MwrapCustomResource{&deletions});
+        ASSERT_FALSE(resource.empty());
+        resource.release();
+    }
+    EXPECT_EQ(deletions, 1);
+    EXPECT_EQ(*cv::makePtr<int>(7), 7);
+}
diff --git a/tests/dnn_compat_sdk_reference.cpp b/tests/dnn_compat_sdk_reference.cpp
new file mode 100644
index 0000000..544bd62
--- /dev/null
+++ b/tests/dnn_compat_sdk_reference.cpp
@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#if defined(MCPP_FEATURE_DNN)
+#include <opencv2/dnn.hpp>
+#include <opencv2/dnn/utils/inference_engine.hpp>
+#include "fixtures/dnn_compat_fixture.hpp"
+TEST(DnnCompatSdk, OriginalEqualitySignaturesAndUnavailableBackendContracts) {
+    EXPECT_NO_THROW(dnn_compat_fixture::emit("sdk"));
+}
+#endif
diff --git a/tests/dnn_compat_test.cpp b/tests/dnn_compat_test.cpp
new file mode 100644
index 0000000..676b1c5
--- /dev/null
+++ b/tests/dnn_compat_test.cpp
@@ -0,0 +1,15 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#if defined(MCPP_FEATURE_DNN)
+import mcpplibs.mwrap.opencv.dnn;
+#include "fixtures/dnn_compat_fixture.hpp"
+TEST(DnnCompat, OriginalEqualitySignaturesAndUnavailableBackendContracts) {
+    EXPECT_NO_THROW(dnn_compat_fixture::emit("module"));
+}
+#endif
diff --git a/tests/dnn_module_test.cpp b/tests/dnn_module_test.cpp
index 74530a3..1b2ca54 100644
--- a/tests/dnn_module_test.cpp
+++ b/tests/dnn_module_test.cpp
@@ -5,14 +5,15 @@
 // (would collide with the dep's modules/dnn/src/dnn.cpp — #240 family).
 #include <gtest/gtest.h>
 #if defined(MCPP_FEATURE_DNN)
-import opencv.cv;
-import opencv.dnn;
+#include "fixtures/ort_model.hpp"
+import mcpplibs.mwrap.opencv;
+import mcpplibs.mwrap.opencv.dnn;
 
 // blobFromImage through the module layer must yield a correctly shaped/valued
 // NCHW blob (exercises the dnn core + the whole protobuf/mlas link closure),
 // and an empty Net must construct.
 TEST(DnnModule, BlobFromImageAndNet) {
-    cv::Mat img(32, 32, cv::CV_8UC3, cv::Scalar(10, 20, 30));
+    cv::Mat img(32, 32, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(10, 20, 30));
     cv::Mat blob = cv::dnn::blobFromImage(img, 1.0 / 255.0, cv::Size(16, 16),
                                           cv::Scalar(), true, false);
     ASSERT_EQ(blob.dims, 4);
@@ -25,4 +26,33 @@ TEST(DnnModule, BlobFromImageAndNet) {
     cv::dnn::Net net;
     EXPECT_TRUE(net.empty());
 }
+
+namespace {
+void verify_native_engine(int engine) {
+    // The buffer overload honors ENGINE_CLASSIC directly. No external runtime
+    // is requested, so these cases also run on the musl/main-module matrix.
+    auto net = cv::dnn::readNetFromONNX(reinterpret_cast<const char*>(opencv_ort_model),
+                                     sizeof(opencv_ort_model), engine);
+    ASSERT_FALSE(net.empty());
+    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
+    cv::Mat input(1, 3, mcpplibs::mwrap::opencv::macros::CV_32F);
+    for (int i = 0; i < 3; ++i) input.at<float>(0, i) = float(i + 1);
+    net.setInput(input, "x");
+    const auto output = net.forward("y");
+    ASSERT_EQ(output.total(), 3u);
+    for (int i = 0; i < 3; ++i) EXPECT_FLOAT_EQ(output.ptr<float>()[i], float(2 * (i + 1)));
+}
+}
+
+TEST(DnnModule, ClassicCpuEngineExecutesOnnxAdd) { verify_native_engine(cv::dnn::ENGINE_CLASSIC); }
+TEST(DnnModule, NewCpuEngineExecutesOnnxAdd) { verify_native_engine(cv::dnn::ENGINE_NEW); }
+TEST(DnnModule, PublicDispatchedActivationFunctionRunsRelu) {
+    cv::dnn::ActivationFunc relu = cv::dnn::getActivationFunc(cv::dnn::ACTIV_RELU);
+    ASSERT_NE(relu, nullptr);
+    const float input[]{-3, -1, 0, 2, 4};
+    float output[5]{};
+    relu(input, output, 5, nullptr);
+    const float expected[]{0, 0, 0, 2, 4};
+    for (int i = 0; i < 5; ++i) EXPECT_FLOAT_EQ(output[i], expected[i]);
+}
 #endif
diff --git a/tests/dnn_onnxruntime_test.cpp b/tests/dnn_onnxruntime_test.cpp
new file mode 100644
index 0000000..eab4fac
--- /dev/null
+++ b/tests/dnn_onnxruntime_test.cpp
@@ -0,0 +1,79 @@
+#include <gtest/gtest.h>
+#if defined(MCPP_FEATURE_DNN_ONNXRUNTIME)
+#include <chrono>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iterator>
+#include <string>
+#include <vector>
+#include "fixtures/ort_model.hpp"
+
+import mcpplibs.mwrap.onnxruntime;
+import mcpplibs.mwrap.opencv;
+
+namespace fs = std::filesystem;
+
+class OrtTestFiles {
+    std::string previous;
+    bool had_previous;
+public:
+    fs::path directory;
+    OrtTestFiles() {
+        const auto* old = std::getenv("OPENCV_TEMP_PATH");
+        had_previous = old != nullptr;
+        if (old) previous = old;
+        directory = fs::temp_directory_path() / ("mwrap-opencv-ort-" +
+            std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
+        fs::create_directories(directory);
+        const auto path = directory.string();
+#ifdef _WIN32
+        _putenv_s("OPENCV_TEMP_PATH", path.c_str());
+#else
+        setenv("OPENCV_TEMP_PATH", path.c_str(), 1);
+#endif
+    }
+    ~OrtTestFiles() {
+#ifdef _WIN32
+        _putenv_s("OPENCV_TEMP_PATH", had_previous ? previous.c_str() : "");
+#else
+        if (had_previous) setenv("OPENCV_TEMP_PATH", previous.c_str(), 1);
+        else unsetenv("OPENCV_TEMP_PATH");
+#endif
+        std::error_code error;
+        fs::remove_all(directory, error);
+    }
+};
+
+TEST(DnnOnnxruntime, ExecutesOrtCpuAndProducesItsSessionProfile) {
+    OrtTestFiles files;
+    const auto model = files.directory / "add.onnx";
+    {
+        std::ofstream out(model, std::ios::binary);
+        out.write(reinterpret_cast<const char*>(opencv_ort_model), sizeof(opencv_ort_model));
+    }
+    ASSERT_EQ(std::string(Ort::GetVersionString()), "1.25.1");
+    auto net = cv::dnn::readNetFromONNX(model.string(), cv::dnn::ENGINE_ORT);
+    ASSERT_FALSE(net.empty());
+    net.setProfilingMode(cv::dnn::DNN_PROFILE_DETAILED);
+    net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
+    cv::Mat input(1, 3, mcpplibs::mwrap::opencv::macros::CV_32F);
+    for (int i = 0; i < 3; ++i) input.at<float>(0, i) = float(i + 1);
+    net.setInput(input, "x");
+    const auto output = net.forward("y");
+    ASSERT_EQ(output.total(), 3u);
+    for (int i = 0; i < 3; ++i) EXPECT_FLOAT_EQ(output.ptr<float>()[i], float(2 * (i + 1)));
+    std::vector<std::string> names, times, counts;
+    net.getPerfProfile(names, times, counts); // closes the real ORT profiler
+    bool executed_cpu = false;
+    for (const auto& entry : fs::directory_iterator(files.directory)) {
+        if (entry.path().extension() != ".json") continue;
+        std::ifstream in(entry.path());
+        const std::string json((std::istreambuf_iterator<char>(in)), {});
+        if (json.find("model_run") != std::string::npos &&
+            json.find("CPUExecutionProvider") != std::string::npos)
+            executed_cpu = true;
+    }
+    EXPECT_TRUE(executed_cpu) << "No ORT CPU session profile; native OpenCV fallback must not pass";
+}
+#endif
diff --git a/tests/dnn_shapes_test.cpp b/tests/dnn_shapes_test.cpp
new file mode 100644
index 0000000..f8b99bf
--- /dev/null
+++ b/tests/dnn_shapes_test.cpp
@@ -0,0 +1,69 @@
+#include <gtest/gtest.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#if defined(MCPP_FEATURE_DNN)
+import mcpplibs.mwrap.opencv.dnn;
+import mcpplibs.mwrap.opencv.macros;
+namespace types = mcpplibs::mwrap::opencv::macros;
+
+TEST(DnnShapes, ShapeConstructionProductsAndAxisContracts) {
+    const int sizes[]{2, 3, 4};
+    const auto dimensions = cv::dnn::shape(sizes, 3);
+    ASSERT_EQ(dimensions.dims, 3);
+    EXPECT_EQ(cv::dnn::total(dimensions), 24u);
+    EXPECT_EQ(cv::dnn::total(dimensions, 1, 3), 12u);
+    const auto combined = cv::dnn::concat(cv::dnn::shape(2, 3), cv::dnn::shape(4));
+    EXPECT_TRUE(dimensions == combined);
+    EXPECT_TRUE(cv::dnn::isAllOnes(cv::dnn::shape(2, 1, 1), 1, 3));
+    EXPECT_FALSE(cv::dnn::isAllOnes(dimensions, 0, 3));
+    EXPECT_EQ(cv::dnn::normalize_axis(-1, dimensions), 2);
+    EXPECT_EQ(cv::dnn::normalize_axis(-3, 3), 0);
+    EXPECT_THROW(cv::dnn::normalize_axis(4, 3), cv::Exception);
+    EXPECT_THROW(cv::dnn::total(dimensions, 2, 1), cv::Exception);
+    const auto all = cv::dnn::normalize_axis_range(cv::Range::all(), 5);
+    EXPECT_EQ(all.start, 0);
+    EXPECT_EQ(all.end, 5);
+    const auto tail = cv::dnn::normalize_axis_range(cv::Range(1, -2), 5);
+    EXPECT_EQ(tail.start, 1);
+    EXPECT_EQ(tail.end, 4);
+}
+
+TEST(DnnShapes, SlicesAndPlanesShareTheirOriginalTensorStorage) {
+    const int sizes[]{2, 3, 4, 5};
+    cv::Mat tensor(4, sizes, types::CV_32F, cv::Scalar(7));
+    const auto dimensions = cv::dnn::shape(tensor);
+    EXPECT_EQ(cv::dnn::total(tensor), 120u);
+    EXPECT_EQ(cv::dnn::total(tensor, 2), 20u);
+    EXPECT_TRUE(cv::dnn::shape(tensor.getUMat(cv::ACCESS_READ)) == dimensions);
+    const cv::dnn::_Range first(1), second(1), third(1, 2), fourth(2, 2);
+    EXPECT_EQ(cv::dnn::slice(tensor, first).total(), 60u);
+    EXPECT_EQ(cv::dnn::slice(tensor, first, second).total(), 20u);
+    EXPECT_EQ(cv::dnn::slice(tensor, first, second, third).total(), 10u);
+    EXPECT_EQ(cv::dnn::slice(tensor, first, second, third, fourth).total(), 4u);
+    auto plane = cv::dnn::getPlane(tensor, 1, 2);
+    ASSERT_EQ(plane.rows, 4);
+    ASSERT_EQ(plane.cols, 5);
+    plane.at<float>(0, 0) = 9;
+    EXPECT_FLOAT_EQ(tensor.ptr<float>(1, 2)[0], 9);
+    EXPECT_EQ(cv::dnn::total(cv::Mat()), 0u);
+}
+
+TEST(DnnShapes, GenericFormattingRetainsTheSdkTextAndStream) {
+    const std::vector<float> dimensions{1, 2};
+    EXPECT_EQ(cv::dnn::toString(dimensions), "[ 1 2 ]");
+    EXPECT_EQ(cv::dnn::toString(dimensions, "shape"), "shape [ 1 2 ]");
+    std::ostringstream text;
+    EXPECT_EQ(&cv::dnn::operator<<(text, dimensions), &text);
+    EXPECT_EQ(text.str(), "[ 1 2 ]");
+    const auto formatted = cv::dnn::toString(cv::dnn::shape(2, 3), "tensor");
+    EXPECT_EQ(formatted.find("tensor "), 0u);
+    EXPECT_NE(formatted.find('2'), std::string::npos);
+    EXPECT_NE(formatted.find('3'), std::string::npos);
+    testing::internal::CaptureStdout();
+    cv::dnn::print(dimensions, "shape");
+    EXPECT_EQ(testing::internal::GetCapturedStdout(), "shape [ 1 2 ]\n");
+}
+#endif
diff --git a/tests/fixtures/dnn_compat_fixture.hpp b/tests/fixtures/dnn_compat_fixture.hpp
new file mode 100644
index 0000000..0f603dd
--- /dev/null
+++ b/tests/fixtures/dnn_compat_fixture.hpp
@@ -0,0 +1,48 @@
+#pragma once
+namespace dnn_compat_fixture {
+template<class Function>
+void unavailable(std::ostringstream& output, Function function) {
+    try {
+        function();
+    } catch (const cv::Exception& error) {
+        if (error.code != cv::Error::StsNotImplemented)
+            throw std::runtime_error("unexpected SDK backend error");
+        output << error.code << '\n';
+        return;
+    }
+    throw std::runtime_error("unavailable backend silently accepted");
+}
+
+inline void emit(const char* consumer) {
+    using namespace cv::dnn;
+    static_assert(std::is_same_v<decltype(&getInferenceEngineBackendType),cv::String (*)()>);
+    static_assert(std::is_same_v<decltype(&setInferenceEngineBackendType),cv::String (*)(const cv::String&)>);
+    static_assert(std::is_same_v<decltype(&getInferenceEngineVPUType),cv::String (*)()>);
+    static_assert(std::is_same_v<decltype(&getInferenceEngineCPUType),cv::String (*)()>);
+    static_assert(std::is_same_v<decltype(&resetMyriadDevice),void (*)()>);
+    static_assert(std::is_same_v<decltype(&releaseHDDLPlugin),void (*)()>);
+    bool (*equal)(const Arg&,const Arg&)=&cv::dnn::operator==;
+    bool (*qualified_equal)(const Arg&,const Arg&)=&cv::dnn::dnn5_v20260605::operator==;
+    if (equal != qualified_equal) throw std::runtime_error("SDK ABI namespace equality identity");
+    std::ostringstream output;
+    for (int index : {0,1,-1,42}) {
+        Arg left(index), same(index), other(index+1);
+        if (!equal(left,same) || equal(left,other) || !(left==same) || left==other)
+            throw std::runtime_error("SDK Arg equality changed");
+        output << int(left) << ',' << left.empty() << ',' << equal(left,same) << '\n';
+    }
+    unavailable(output, [] { return getInferenceEngineBackendType(); });
+    unavailable(output, [] { return setInferenceEngineBackendType("NGRAPH"); });
+    unavailable(output, [] { return getInferenceEngineVPUType(); });
+    unavailable(output, [] { return getInferenceEngineCPUType(); });
+    // These are original SDK no-ops in this build without Inference Engine.
+    resetMyriadDevice();
+    releaseHDDLPlugin();
+    output << "SDK unavailable-backend and cleanup contracts\n";
+    if (const char* directory=std::getenv("OPENCV_M_DNN_COMPAT_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory)/(std::string(consumer)+".txt"),std::ios::binary);
+        file << output.str();
+        if (!file) throw std::runtime_error("DNN compatibility oracle output");
+    }
+}
+}
diff --git a/tests/fixtures/fp_state_fixture.hpp b/tests/fixtures/fp_state_fixture.hpp
new file mode 100644
index 0000000..9f69145
--- /dev/null
+++ b/tests/fixtures/fp_state_fixture.hpp
@@ -0,0 +1,69 @@
+#pragma once
+namespace fp_state_fixture {
+using State = cv::details::FPDenormalsModeState;
+inline bool same(const State& a, const State& b) {
+    for (int i=0; i<16; ++i) if (a.reserved[i]!=b.reserved[i]) return false;
+    return true;
+}
+inline State snapshot() {
+    State result{};
+    cv::details::saveFPDenormalsState(result);
+    return result;
+}
+inline void require(bool value) {
+    if (!value) throw std::runtime_error("SDK floating-point state was not restored");
+}
+inline void emit(const char* consumer) {
+    cv::cudev::GpuMat_<unsigned char>* device_matrix = nullptr;
+    require(device_matrix == nullptr); // Declaration only, as in the core SDK.
+    static_assert(sizeof(State)==64);
+    static_assert(std::is_same_v<decltype(&cv::details::saveFPDenormalsState),int (*)(State&)>);
+    static_assert(std::is_same_v<decltype(&cv::details::restoreFPDenormalsState),bool (*)(const State&)>);
+    static_assert(std::is_same_v<decltype(&cv::details::setFPDenormalsIgnoreHint),void (*)(bool,State&)>);
+    State original{};
+    const int slots=cv::details::saveFPDenormalsState(original);
+    struct Restore {
+        const State& state;
+        int slots;
+        ~Restore() { if(slots>0) cv::details::restoreFPDenormalsState(state); }
+    } restore{original,slots};
+    std::ostringstream out;
+    out << sizeof(State) << ',' << slots << '\n';
+    State saved{};
+    cv::details::setFPDenormalsIgnoreHint(true,saved);
+    out << same(original,saved) << ',' << same(original,snapshot()) << ',';
+    const bool restored=cv::details::restoreFPDenormalsState(saved);
+    require(same(original,snapshot()));
+    out << restored << '\n';
+    {
+        cv::details::FPDenormalsIgnoreHintScope scope(true);
+        out << same(original,snapshot()) << ',';
+    }
+    require(same(original,snapshot()));
+    {
+        cv::details::FPDenormalsIgnoreHintScope scope(false);
+        out << same(original,snapshot()) << ',';
+    }
+    require(same(original,snapshot()));
+    {
+        cv::details::FPDenormalsIgnoreHintScope scope(original);
+        require(same(original,snapshot()));
+    }
+    {
+        cv::details::FPDenormalsIgnoreHintScopeNOOP scope(true), from_state(original);
+        require(same(original,snapshot()));
+    }
+    out << same(original,snapshot()) << '\n';
+#if defined(MCPP_FEATURE_VIDEOIO)
+    // These SDK declarations are intentionally incomplete. Do not instantiate them.
+    cv::IVideoCapture* capture=nullptr;
+    cv::IVideoWriter* writer=nullptr;
+    out << (capture==nullptr) << ',' << (writer==nullptr) << '\n';
+#endif
+    if (const char* directory=std::getenv("OPENCV_M_FP_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory)/(std::string(consumer)+".txt"),std::ios::binary);
+        file << out.str();
+        if (!file) throw std::runtime_error("FP state oracle output");
+    }
+}
+}
diff --git a/tests/fixtures/mat_aug_fixture.hpp b/tests/fixtures/mat_aug_fixture.hpp
new file mode 100644
index 0000000..42566cf
--- /dev/null
+++ b/tests/fixtures/mat_aug_fixture.hpp
@@ -0,0 +1,129 @@
+#pragma once
+namespace mat_aug_fixture {
+template<class T, class Left, class Right, class Operation>
+void record(std::ostringstream& out, const Left& initial, const Right& right, Operation operation) {
+    for (bool constant : {false, true}) {
+        Left value(initial.clone());
+        if (constant) {
+            const Left& left = value;
+            static_assert(std::is_same_v<decltype(operation(left, right)), const Left&>);
+            if (&operation(left, right) != &left) throw std::runtime_error("const assignment identity");
+        } else {
+            static_assert(std::is_same_v<decltype(operation(value, right)), Left&>);
+            if (&operation(value, right) != &value) throw std::runtime_error("assignment identity");
+        }
+        for (int row = 0; row < 2; ++row)
+            for (int col = 0; col < 2; ++col) out << double(value.template at<T>(row, col)) << ',';
+        out << '\n';
+    }
+}
+
+template<class T, class Operation>
+void family(std::ostringstream& out, Operation operation) {
+    cv::Mat_<T> left(2, 2), right(2, 2);
+    left(0,0)=8; left(0,1)=4; left(1,0)=2; left(1,1)=6;
+    right(0,0)=2; right(0,1)=1; right(1,0)=1; right(1,1)=2;
+    const cv::Mat untyped_left=left, untyped_right=right;
+    const cv::Matx<T,2,2> fixed(2,1,1,2);
+    record<T>(out,untyped_left,untyped_right,operation);
+    record<T>(out,left,untyped_right,operation);
+    record<T>(out,left,right,operation);
+    record<T>(out,untyped_left,fixed,operation);
+    record<T>(out,left,fixed,operation);
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+inline cv::Mat_<float> comma_matrix() {
+    // Exercise the original deprecated API without making warning policy the oracle.
+    return (cv::Mat_<float>(2,2)<<1.f,2.f,3.f,4.f);
+}
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+inline void emit(const char* consumer) {
+    std::ostringstream out;
+#define MWRAP_AUG(OP, TYPE, RIGHT) \
+    { \
+        const auto operation=[](auto& a,const auto& b)->decltype(auto) { return cv::operator OP(a,b); }; \
+        family<TYPE>(out,operation); \
+        cv::Mat_<TYPE> typed(2,2,TYPE(8)); \
+        const cv::Mat untyped=typed; \
+        record<TYPE>(out,untyped,RIGHT,operation); \
+        record<TYPE>(out,typed,RIGHT,operation); \
+    }
+    MWRAP_AUG(+=, float, cv::Scalar(2))
+    MWRAP_AUG(-=, float, cv::Scalar(2))
+    MWRAP_AUG(*=, float, 2.0)
+    MWRAP_AUG(/=, float, 2.0)
+    MWRAP_AUG(&=, uchar, cv::Scalar(3))
+    MWRAP_AUG(|=, uchar, cv::Scalar(3))
+    MWRAP_AUG(^=, uchar, cv::Scalar(3))
+#undef MWRAP_AUG
+    // Original expression assignment overloads use MatOp's augmented path.
+#define MWRAP_EXPR_AUG(OP) \
+    { \
+        const auto operation=[](auto& a,const auto& b)->decltype(auto) { return cv::operator OP(a,b); }; \
+        cv::Mat_<float> typed(2,2,float(8)); \
+        const cv::Mat plain=typed; \
+        const cv::MatExpr expression=plain+cv::Scalar(1); \
+        record<float>(out,plain,expression,operation); \
+        record<float>(out,typed,expression,operation); \
+    }
+    MWRAP_EXPR_AUG(+=)
+    MWRAP_EXPR_AUG(-=)
+    MWRAP_EXPR_AUG(*=)
+    MWRAP_EXPR_AUG(/=)
+#undef MWRAP_EXPR_AUG
+    cv::Mat_<float>& (*expression_assignment)(cv::Mat_<float>&,const cv::MatExpr&)=&cv::operator+=<float>;
+    const cv::Mat& (*constant_expression_assignment)(const cv::Mat&,const cv::MatExpr&)=&cv::operator/=;
+    (void)expression_assignment;
+    (void)constant_expression_assignment;
+    using Typed=cv::Mat_<uchar>;
+    using Fixed=cv::Matx<uchar,2,2>;
+    Typed& (*typed)(Typed&,const Typed&)=&cv::operator^=<uchar>;
+    const Typed& (*constant)(const Typed&,const Fixed&)=&cv::operator^=<uchar,2,2>;
+    cv::Mat& (*plain)(cv::Mat&,const cv::Scalar&)=&cv::operator^=;
+    Typed a(2,2,uchar(8)), b(2,2,uchar(3));
+    if (&typed(a,b)!=&a || a(0,0)!=11) throw std::runtime_error("typed explicit assignment");
+    const Fixed fixed(1,1,1,1);
+    const Typed& c=a;
+    if (&constant(c,fixed)!=&c || a(0,0)!=10) throw std::runtime_error("fixed explicit assignment");
+    cv::Mat plain_a=a;
+    if (&plain(plain_a,cv::Scalar(2))!=&plain_a || a(0,0)!=8) throw std::runtime_error("plain assignment pointer");
+    out << "explicit-signatures-and-identity\n";
+    // Derived Mat operands and user conversions must follow the SDK overloads.
+    cv::Mat_<float> left(2,2,float(8)), right(2,2,float(2));
+    const auto values=[&](const cv::Mat& value) {
+        cv::Mat converted;
+        value.convertTo(converted,cv::traits::Type<float>::value);
+        for (int row=0;row<2;++row)
+            for (int col=0;col<2;++col) out << converted.at<float>(row,col) << ',';
+        out << '\n';
+    };
+    values(left+right); values(left-right); values(left*right); values(left/right);
+    values(left+2); values(2+left); values(left*2); values(2*left);
+    values(left>2); values(left==8);
+    struct Number { operator double() const { return 2; } };
+    values(left*Number{});
+    struct Matrix { const cv::Mat& value; operator cv::Mat() const { return value; } };
+    values(Matrix{left}+right);
+    cv::MatExpr (*add)(const cv::Mat&,const cv::Mat&)=&cv::operator+;
+    values(add(left,right));
+    values(comma_matrix());
+    out << "typed-and-user-conversions\n";
+    if (const char* directory=std::getenv("OPENCV_M_MAT_AUG_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory)/(std::string(consumer)+".txt"),std::ios::binary);
+        file << out.str();
+        if (!file) throw std::runtime_error("Mat assignment oracle output");
+    }
+}
+}
diff --git a/tests/fixtures/matx_templates_fixture.hpp b/tests/fixtures/matx_templates_fixture.hpp
new file mode 100644
index 0000000..f10eb3a
--- /dev/null
+++ b/tests/fixtures/matx_templates_fixture.hpp
@@ -0,0 +1,114 @@
+#pragma once
+// Both consumers instantiate the same public SDK expressions independently.
+// Comma initializers are deprecated upstream; testing their compatibility is intentional.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+namespace matx_templates_fixture {
+template<class T, unsigned N> void values(std::ostringstream& out, const T (&data)[N]) {
+    for (auto value : data) out << +value << ',';
+    out << '\n';
+}
+template<int Mode> void matrix_initializer(std::ostringstream& out) {
+    cv::Matx<float, 2, 3> m;
+    auto first = [&] {
+        if constexpr (Mode == 0) return cv::operator<<(m, 1.75);
+        else if constexpr (Mode == 1) return cv::operator<<<float>(m, 1.75);
+        else if constexpr (Mode == 2) return cv::operator<<<float, int>(m, 1.75);
+        else if constexpr (Mode == 3) return cv::operator<<<float, int, 2>(m, 1.75);
+        else return cv::operator<<<float, int, 2, 3>(m, 1.75);
+    }();
+    (first, 2, 3, 4, 5, 6);
+    values(out, m.val);
+}
+template<int Mode> void vector_initializer(std::ostringstream& out) {
+    cv::Vec<float, 3> v;
+    auto first = [&] {
+        if constexpr (Mode == 0) return cv::operator<<(v, 1.75);
+        else if constexpr (Mode == 1) return cv::operator<<<float>(v, 1.75);
+        else if constexpr (Mode == 2) return cv::operator<<<float, int>(v, 1.75);
+        else return cv::operator<<<float, int, 3>(v, 1.75);
+    }();
+    (first, 2, 3);
+    values(out, v.val);
+}
+template<int Mode> void matrix_augmentation(std::ostringstream& out) {
+    cv::Matx<uchar, 2, 2> a(250, 3, 8, 10);
+    const cv::Matx<float, 2, 2> b(10.75f, -7.25f, 2.5f, 5.5f);
+    if constexpr (Mode == 0) { a += b; a -= b; }
+    else if constexpr (Mode == 1) { cv::operator+=<uchar>(a,b); cv::operator-=<uchar>(a,b); }
+    else if constexpr (Mode == 2) { cv::operator+=<uchar,float>(a,b); cv::operator-=<uchar,float>(a,b); }
+    else if constexpr (Mode == 3) { cv::operator+=<uchar,float,2>(a,b); cv::operator-=<uchar,float,2>(a,b); }
+    else { cv::operator+=<uchar,float,2,2>(a,b); cv::operator-=<uchar,float,2,2>(a,b); }
+    values(out, a.val);
+}
+template<int Mode> void vector_augmentation(std::ostringstream& out) {
+    cv::Vec<uchar, 3> a(250, 3, 8);
+    const cv::Vec<float, 3> b(10.75f, -7.25f, 2.5f);
+    if constexpr (Mode == 0) { a += b; a -= b; }
+    else if constexpr (Mode == 1) { cv::operator+=<uchar>(a,b); cv::operator-=<uchar>(a,b); }
+    else if constexpr (Mode == 2) { cv::operator+=<uchar,float>(a,b); cv::operator-=<uchar,float>(a,b); }
+    else { cv::operator+=<uchar,float,3>(a,b); cv::operator-=<uchar,float,3>(a,b); }
+    values(out, a.val);
+}
+template<int Mode> void matrix_product(std::ostringstream& out) {
+    const cv::Matx<float, 2, 3> a(1, 2, 3, 4, 5, 6);
+    const cv::Matx<float, 3, 2> b(7, 8, 9, 10, 11, 12);
+    auto product = [&] {
+        if constexpr (Mode == 0) return a*b;
+        else if constexpr (Mode == 1) return cv::operator*<float>(a,b);
+        else if constexpr (Mode == 2) return cv::operator*<float,2>(a,b);
+        else if constexpr (Mode == 3) return cv::operator*<float,2,2>(a,b);
+        else return cv::operator*<float,2,2,3>(a,b);
+    }();
+    static_assert(std::is_same_v<decltype(product), cv::Matx22f>);
+    values(out, product.val);
+}
+inline void emit(const char* consumer) {
+    std::ostringstream out;
+    out << std::setprecision(17);
+    const cv::Matx33f a(4,2,1,0,5,3,2,1,6);
+    using Determinant = double (*)(const cv::Matx33f&);
+    const auto determinant = static_cast<Determinant>(&cv::determinant<float,3>);
+    out << cv::determinant(a) << ',' << cv::determinant<float>(a) << ','
+        << cv::determinant<float,3>(a) << ',' << determinant(a) << '\n';
+    const cv::Matx44d large(2,1,0,0,0,3,1,0,0,0,4,1,1,0,0,5);
+    out << cv::determinant<double,4>(large) << '\n';
+    matrix_initializer<0>(out); matrix_initializer<1>(out); matrix_initializer<2>(out);
+    matrix_initializer<3>(out); matrix_initializer<4>(out);
+    vector_initializer<0>(out); vector_initializer<1>(out); vector_initializer<2>(out); vector_initializer<3>(out);
+    matrix_augmentation<0>(out); matrix_augmentation<1>(out); matrix_augmentation<2>(out);
+    matrix_augmentation<3>(out); matrix_augmentation<4>(out);
+    vector_augmentation<0>(out); vector_augmentation<1>(out); vector_augmentation<2>(out); vector_augmentation<3>(out);
+    matrix_product<0>(out); matrix_product<1>(out); matrix_product<2>(out);
+    matrix_product<3>(out); matrix_product<4>(out);
+    // Derived-to-base deduction and exact SDK reference-return types.
+    cv::Matx<float, 3, 1> column(1,2,3);
+    cv::Vec3f v(4,5,6);
+    static_assert(std::is_same_v<decltype(column += v), cv::Matx<float,3,1>&>);
+    column += v;
+    static_assert(std::is_same_v<decltype(v += column), cv::Matx<float,3,1>&>);
+    v += column;
+    values(out, column.val); values(out, v.val);
+    using Augment = cv::Matx<uchar,2,2>& (*)(cv::Matx<uchar,2,2>&, const cv::Matx<float,2,2>&);
+    const auto augment = static_cast<Augment>(&cv::operator+=<uchar,float,2,2>);
+    cv::Matx<uchar,2,2> bytes = cv::Matx<uchar,2,2>::all(250);
+    augment(bytes, cv::Matx<float,2,2>::all(10.75f));
+    values(out, bytes.val);
+    struct Derived : cv::Matx33f { using cv::Matx33f::Matx; };
+    const Derived derived(4,2,1,0,5,3,2,1,6);
+    out << cv::determinant(derived) << '\n';
+    using Product = cv::Matx22f (*)(const cv::Matx<float,2,3>&, const cv::Matx<float,3,2>&);
+    const auto product = static_cast<Product>(&cv::operator*<float,2,2,3>);
+    values(out, product(cv::Matx<float,2,3>::all(1),cv::Matx<float,3,2>::all(2)).val);
+    if (const char* directory = std::getenv("OPENCV_M_MATX_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory) / (std::string(consumer) + ".txt"), std::ios::binary);
+        file << out.str();
+        if (!file) throw std::runtime_error("Matx template oracle output");
+    }
+}
+}
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/tests/fixtures/ort_add.onnx b/tests/fixtures/ort_add.onnx
new file mode 100644
index 0000000..7ff79ea
--- /dev/null
+++ b/tests/fixtures/ort_add.onnx
@@ -0,0 +1,12 @@
+
mwrap-fixture:Z
+
+
x
+
x
ydouble_input"Addmwrap_opencv_ortZ
+
x
+

+

+b
+
y
+

+

+B
\ No newline at end of file
diff --git a/tests/fixtures/ort_model.hpp b/tests/fixtures/ort_model.hpp
new file mode 100644
index 0000000..bdaf24b
--- /dev/null
+++ b/tests/fixtures/ort_model.hpp
@@ -0,0 +1,2 @@
+#pragma once
+inline constexpr unsigned char opencv_ort_model[] = {0x08, 0x08, 0x12, 0x0d, 0x6d, 0x77, 0x72, 0x61, 0x70, 0x2d, 0x66, 0x69, 0x78, 0x74, 0x75, 0x72, 0x65, 0x3a, 0x5a, 0x0a, 0x1c, 0x0a, 0x01, 0x78, 0x0a, 0x01, 0x78, 0x12, 0x01, 0x79, 0x1a, 0x0c, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0x03, 0x41, 0x64, 0x64, 0x12, 0x10, 0x6d, 0x77, 0x72, 0x61, 0x70, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x63, 0x76, 0x5f, 0x6f, 0x72, 0x74, 0x5a, 0x13, 0x0a, 0x01, 0x78, 0x12, 0x0e, 0x0a, 0x0c, 0x08, 0x01, 0x12, 0x08, 0x0a, 0x02, 0x08, 0x01, 0x0a, 0x02, 0x08, 0x03, 0x62, 0x13, 0x0a, 0x01, 0x79, 0x12, 0x0e, 0x0a, 0x0c, 0x08, 0x01, 0x12, 0x08, 0x0a, 0x02, 0x08, 0x01, 0x0a, 0x02, 0x08, 0x03, 0x42, 0x02, 0x10, 0x0d};
diff --git a/tests/fixtures/persistence_fixture.hpp b/tests/fixtures/persistence_fixture.hpp
new file mode 100644
index 0000000..871262f
--- /dev/null
+++ b/tests/fixtures/persistence_fixture.hpp
@@ -0,0 +1,59 @@
+#pragma once
+// Included after either the native SDK header or the module import. The two
+// independent consumers must produce byte-identical SDK serialization.
+namespace persistence_fixture {
+enum class Mode { high = 7 };
+struct Value { int first, second; };
+inline void write(cv::FileStorage& storage, const cv::String& name, const Value& value) {
+    cv::write(storage, name, cv::Vec2i(value.first, value.second));
+}
+inline void read(const cv::FileNode& node, Value& value, const Value& fallback) {
+    cv::Vec2i fields;
+    cv::read(node, fields, cv::Vec2i(fallback.first, fallback.second));
+    value = {fields[0], fields[1]};
+}
+inline std::string serialize(int format) {
+    cv::FileStorage output("generated", cv::FileStorage::WRITE | cv::FileStorage::MEMORY | format);
+    cv::write(output, "point", cv::Point2f(1.5f, -2.5f));
+    cv::write(output, "point3", cv::Point3d(1, 2, 3));
+    cv::write(output, "size", cv::Size2i(12, 8));
+    cv::write(output, "rectangle", cv::Rect2d(1, 2, 3, 4));
+    cv::write(output, "complex", cv::Complexd(3, -4));
+    cv::write(output, "vector", cv::Vec3f(2, 4, 6));
+    cv::write(output, "matrix", cv::Matx22d(1, 2, 3, 4));
+    cv::write(output, "scalar", cv::Scalar(3, 5, 7, 9));
+    cv::write(output, "range", cv::Range(2, 6));
+    output << "integers" << std::vector<int>{3, 4, 5};
+    output << "nested" << std::vector<std::vector<int>>{{1, 2}, {3}};
+    output << "points" << std::vector<cv::Point2f>{cv::Point2f(1, 2), cv::Point2f(3, 4)};
+    output << "matches" << std::vector<cv::DMatch>{cv::DMatch(0, 1, 2.5f)};
+    output << "mode" << Mode::high;
+    cv::write<Mode, nullptr>(output, "explicit_mode", Mode::high);
+    output << "custom" << Value{17, 23};
+    return output.releaseAndGetString();
+}
+inline void emit(const char* prefix) {
+    const auto* directory = std::getenv("OPENCV_M_PERSISTENCE_OUTPUT");
+    using Format = std::pair<const char*, int>;
+    for (const auto [name, format] : {
+            Format{"yaml", cv::FileStorage::FORMAT_YAML},
+            Format{"xml", cv::FileStorage::FORMAT_XML},
+            Format{"json", cv::FileStorage::FORMAT_JSON},
+            Format{"yaml-base64", cv::FileStorage::FORMAT_YAML | cv::FileStorage::BASE64},
+            Format{"xml-base64", cv::FileStorage::FORMAT_XML | cv::FileStorage::BASE64},
+            Format{"json-base64", cv::FileStorage::FORMAT_JSON | cv::FileStorage::BASE64}}) {
+        const auto text = serialize(format);
+        if (text.empty()) throw std::runtime_error("empty serialization");
+        cv::FileStorage input(text, cv::FileStorage::READ | cv::FileStorage::MEMORY);
+        Value value{};
+        input["custom"] >> value;
+        if (value.first != 17 || value.second != 23) throw std::runtime_error("custom serializer mismatch");
+        if (directory) {
+            const auto file = std::filesystem::path(directory) / (std::string(prefix) + "-" + name + ".txt");
+            std::ofstream output(file, std::ios::binary);
+            output.write(text.data(), static_cast<std::streamsize>(text.size()));
+            if (!output) throw std::runtime_error("cannot write serialization evidence");
+        }
+    }
+}
+}
diff --git a/tests/fixtures/simd_fixture.hpp b/tests/fixtures/simd_fixture.hpp
new file mode 100644
index 0000000..db578a6
--- /dev/null
+++ b/tests/fixtures/simd_fixture.hpp
@@ -0,0 +1,158 @@
+#pragma once
+namespace simd_fixture {
+inline void require(bool value, const char* message) {
+    if (!value) throw std::runtime_error(message);
+}
+template<class T, std::size_t N> void values(std::ostringstream& out, const std::array<T, N>& data) {
+    for (const auto value : data) out << +value << ',';
+    out << '\n';
+}
+template<class T> void broadcast(std::ostringstream& out, const T& value) {
+    using Vector = typename cv::Type2Vec128_Traits<T>::vec_type;
+    std::array<T,16/sizeof(T)> lanes{};
+    // Both the deduced and explicit forms belong to the SDK API.
+    Vector fixed = cv::v_setall<T>(value);
+    cv::v_store(lanes.data(),fixed);
+    for (const auto lane : lanes) require(lane==value,"fixed generic broadcast");
+    values(out,lanes);
+    cv::v_store(lanes.data(),cv::vx_setall(value));
+    for (const auto lane : lanes) require(lane==value,"maximum generic broadcast");
+    values(out,lanes);
+    using Broadcast = Vector (*)(const T&);
+    const auto fixed_function=static_cast<Broadcast>(&cv::v_setall<T>);
+    const auto maximum_function=static_cast<Broadcast>(&cv::vx_setall<T>);
+    cv::v_store(lanes.data(),fixed_function(value));
+    for (const auto lane : lanes) require(lane==value,"fixed broadcast function pointer");
+    cv::v_store(lanes.data(),maximum_function(value));
+    for (const auto lane : lanes) require(lane==value,"maximum broadcast function pointer");
+}
+inline void emit(const char* consumer) {
+    static_assert(sizeof(cv::v_float32x4) == 16 && sizeof(cv::v_uint8x16) == 16);
+    require(cv::VTraits<cv::v_float32>::vlanes() == 4, "baseline float lanes");
+    require(cv::VTraits<cv::v_uint8>::vlanes() == 16, "baseline byte lanes");
+    std::ostringstream out;
+    out << std::setprecision(17);
+    broadcast(out,uchar(250)); broadcast(out,schar(-7));
+    broadcast(out,ushort(60000)); broadcast(out,short(-1000));
+    broadcast(out,unsigned(4000000000u)); broadcast(out,int(-123456));
+    broadcast(out,uint64(0xffffffffffffffffULL)); broadcast(out,int64(-9223372036854775807LL));
+    broadcast(out,float(1.25)); broadcast(out,double(-2.5));
+    std::array<float, 5> input{99, 1.25f, -2.5f, 4.f, 9.f};
+    std::array<float, 4> floats{};
+    auto a = cv::v_load(input.data() + 1);
+    auto b = cv::v_setall_f32(2.f);
+    cv::v_store(floats.data(), cv::v_add(a, b));
+    require(floats == std::array<float, 4>{3.25f, -0.5f, 6.f, 11.f}, "unaligned load/add/store");
+    values(out, floats);
+    std::array<float, 5> unaligned_output{};
+    cv::v_store(unaligned_output.data() + 1, a);
+    require(unaligned_output[1] == 1.25f && unaligned_output[4] == 9.f, "unaligned destination store");
+    cv::v_store(floats.data(), cv::v_fma(a, b, cv::v_setall_f32(0.5f)));
+    require(floats == std::array<float, 4>{3.f, -4.5f, 8.5f, 18.5f}, "multiply/add");
+    values(out, floats);
+    cv::v_store(floats.data(), cv::v_div(a, b));
+    values(out, floats);
+    std::array<uchar, 16> bytes{}, wrapped{};
+    const auto high = cv::v_setall_u8(250), ten = cv::v_setall_u8(10);
+    cv::v_store(bytes.data(), cv::v_add(high, ten));
+    cv::v_store(wrapped.data(), cv::v_add_wrap(high, ten));
+    require(bytes[0] == 255 && bytes[15] == 255 && wrapped[0] == 4, "byte saturation versus wrapping");
+    values(out, bytes); values(out, wrapped);
+    std::array<short, 8> signed_values{-5, 0, 5, 255, 256, 300, 1000, 42};
+    const auto wide = cv::v_load(signed_values.data());
+    cv::v_store(bytes.data(), cv::v_pack_u(wide, wide));
+    require(bytes[0] == 0 && bytes[3] == 255 && bytes[4] == 255 && bytes[7] == 42, "unsigned saturating pack");
+    values(out, bytes);
+    cv::v_uint16x8 low, upper;
+    cv::v_expand(cv::v_load(bytes.data()), low, upper);
+    std::array<ushort, 8> expanded{};
+    cv::v_store(expanded.data(), low);
+    require(expanded[4] == 255 && expanded[7] == 42, "widen low lanes");
+    values(out, expanded);
+    cv::v_store(expanded.data(), upper); values(out, expanded);
+    std::array<int, 4> left{1, -2, 3, 4}, right{1, 2, 0, 4}, integers{};
+    auto x = cv::v_load(left.data()), y = cv::v_load(right.data());
+    cv::v_store(integers.data(), cv::v_eq(x, y));
+    require(integers == std::array<int, 4>{-1, 0, 0, -1}, "comparison lane masks");
+    values(out, integers);
+    cv::v_store(integers.data(), cv::v_select(cv::v_gt(x, y), x, y));
+    require(integers == std::array<int, 4>{1, 2, 3, 4}, "mask selection");
+    values(out, integers);
+    cv::v_store(integers.data(), cv::v_reverse(x));
+    require(integers == std::array<int, 4>{4, 3, -2, 1}, "lane reversal");
+    values(out, integers);
+    cv::v_store(integers.data(), cv::v_extract<1>(x, y));
+    require(integers == std::array<int, 4>{-2, 3, 4, 1}, "lane extraction");
+    values(out, integers);
+    cv::v_int32x4 zipped_low, zipped_high;
+    cv::v_zip(x, y, zipped_low, zipped_high);
+    cv::v_store(integers.data(), zipped_low); values(out, integers);
+    cv::v_store(integers.data(), zipped_high); values(out, integers);
+    std::array<float, 4> halves{2.5f, -2.5f, 3.5f, -3.5f};
+    cv::v_store(integers.data(), cv::v_round(cv::v_load(halves.data())));
+    require(integers == std::array<int, 4>{2, -2, 4, -4}, "nearest-even rounding");
+    values(out, integers);
+    std::array<short, 8> sequence{1, 2, 3, 4, 5, 6, 7, 8};
+    cv::v_store(integers.data(), cv::v_dotprod(cv::v_load(sequence.data()), cv::v_setall_s16(1)));
+    require(integers == std::array<int, 4>{3, 7, 11, 15}, "adjacent dot products");
+    values(out, integers);
+    require(cv::v_reduce_sum(x) == 6, "integer reduction");
+    std::array<int64, 2> signed64{-5, 7}, comparison64{};
+    cv::v_store(comparison64.data(), cv::v_eq(cv::v_load(signed64.data()), cv::v_setall_s64(7)));
+    require(comparison64[0] == 0 && comparison64[1] == -1, "64-bit comparisons");
+    values(out, comparison64);
+    std::array<double, 2> squares{4, 9}, doubles{};
+    cv::v_store(doubles.data(), cv::v_sqrt(cv::v_load(squares.data())));
+    require(doubles == std::array<double, 2>{2, 3}, "double precision square roots");
+    values(out, doubles);
+    std::array<uchar, 48> rgb{}, restored{};
+    for (std::size_t i = 0; i < rgb.size(); ++i) rgb[i] = static_cast<uchar>(i);
+    cv::v_uint8x16 red, green, blue;
+    cv::v_load_deinterleave(rgb.data(), red, green, blue);
+    cv::v_store_interleave(restored.data(), red, green, blue);
+    require(rgb == restored, "three-channel interleaved roundtrip");
+    values(out, restored);
+    alignas(16) std::array<float, 4> aligned{};
+    cv::vx_store_aligned(aligned.data(), cv::vx_load(input.data() + 1));
+    require(aligned[0] == 1.25f && aligned[3] == 9.f, "legacy aligned store forward");
+    cv::vx_store(floats.data(), cv::vx_load(input.data() + 1)); values(out, floats);
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+    static_assert(cv::simd128_width == 16 && cv::simdmax_width == 16);
+    static_assert(std::is_same_v<decltype(cv::simd128_width), decltype(cv::hal_EMULATOR_CPP::simd128_width)>);
+    static_assert(cv::hal_EMULATOR_CPP::simdmax_width == cv::simdmax_width);
+    // Keep the SDK's generic lane-count templates, beyond the 128-bit aliases.
+    std::array<float, 8> lanes{1, 2, 3, 4, 5, 6, 7, 8};
+    const cv::v_reg<float, 8> generic(lanes.data());
+    auto twice = cv::v_add(generic, generic);
+    require(twice.s[7] == 16, "generic eight-lane arithmetic");
+    auto quotient = cv::v_div(twice, generic);
+    auto difference = cv::v_sub(twice, generic);
+    auto product = cv::v_mul(generic, quotient);
+    auto low_double = cv::v_cvt_f64(twice);
+    auto high_double = cv::v_cvt_f64_high(twice);
+    require(low_double.s[3] == 8 && high_double.s[0] == 10, "generic double conversion halves");
+    require(difference.s[6] == 7 && product.s[5] == 12, "generic arithmetic overloads");
+    std::array<unsigned, 8> bit_lanes{1, 2, 3, 4, 5, 6, 7, 8};
+    const cv::v_reg<unsigned, 8> bits(bit_lanes.data());
+    auto signed_bits = cv::v_reinterpret_as_int(generic);
+    auto mask_bits = cv::v_not(cv::v_xor(bits, bits));
+    auto all_bits = cv::v_or(bits, mask_bits);
+    auto unchanged_bits = cv::v_and(bits, mask_bits);
+    require(mask_bits.s[0] == ~0u && all_bits.s[7] == ~0u && unchanged_bits.s[4] == bits.s[4], "generic bitwise templates");
+    cv::v_reg<float, 8> minima, maxima;
+    cv::v_minmax(generic, twice, minima, maxima);
+    cv::v_reg<double, 4> horizontal;
+    cv::v_hsum(generic, horizontal);
+    std::array<int, 8> rounding{1, 2, 3, 4, 5, 6, 7, 8};
+    auto shifted = cv::v_rshr<1>(cv::v_reg<int, 8>(rounding.data()));
+    require(minima.s[7] == 8 && maxima.s[7] == 16 && horizontal.s[3] == 15 && shifted.s[6] == 4, "generic reductions and rounding shift");
+    for (int i = 0; i < 8; ++i)
+        out << twice.s[i] << ',' << quotient.s[i] << ',' << signed_bits.s[i] << ',' << shifted.s[i] << ';';
+    out << '\n' << low_double.s[3] << ',' << high_double.s[0] << ',' << horizontal.s[3] << '\n';
+#endif
+    if (const char* directory = std::getenv("OPENCV_M_SIMD_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory) / (std::string(consumer) + ".txt"), std::ios::binary);
+        file << out.str(); require(bool(file), "SIMD oracle output");
+    }
+}
+}
diff --git a/tests/fixtures/simd_legacy_fixture.hpp b/tests/fixtures/simd_legacy_fixture.hpp
new file mode 100644
index 0000000..aa397d6
--- /dev/null
+++ b/tests/fixtures/simd_legacy_fixture.hpp
@@ -0,0 +1,78 @@
+#pragma once
+namespace simd_legacy_fixture {
+struct EqualityBase {
+    int value;
+    friend bool operator==(const EqualityBase&,const EqualityBase&)=default;
+};
+struct DerivedIterator : EqualityBase {
+    explicit DerivedIterator(int value) : EqualityBase{value} {}
+};
+using V = cv::v_float32x4;
+inline void dump(std::ostringstream& out, const V& value) {
+    std::array<unsigned,4> bits{};
+    cv::v_store(bits.data(), cv::v_reinterpret_as_u32(value));
+    for (auto bit : bits) out << bit << ',';
+    out << '\n';
+}
+template<class F> void compound(std::ostringstream& out, const V& a, const V& b, F apply) {
+    V copy = a;
+    V& reference = apply(copy,b);
+    if (&reference != &copy) throw std::runtime_error("legacy compound reference identity");
+    dump(out, copy);
+}
+inline void emit(const char* consumer) {
+    using cv::hal::operator+;
+    // MSVC array iterators compare through a base class. Broadly importing
+    // legacy != selects its unconstrained vector template over that conversion.
+    const DerivedIterator first(0), last(1);
+    static_assert(std::is_same_v<decltype(first!=last),bool>);
+    if (!(first!=last)) throw std::runtime_error("derived iterator comparison");
+    const V a = cv::v_setall_f32(6), b = cv::v_setall_f32(2);
+    std::ostringstream out;
+    dump(out, cv::hal::operator+(a,b));
+    dump(out, cv::hal::operator-(a,b));
+    dump(out, cv::hal::operator*(a,b));
+    dump(out, cv::hal::operator/(a,b));
+    dump(out, cv::hal::operator&(a,b));
+    dump(out, cv::hal::operator|(a,b));
+    dump(out, cv::hal::operator^(a,b));
+    dump(out, cv::hal::operator==(a,b));
+    dump(out, cv::hal::operator!=(a,b));
+    dump(out, cv::hal::operator<(a,b));
+    dump(out, cv::hal::operator>(a,b));
+    dump(out, cv::hal::operator<=(a,b));
+    dump(out, cv::hal::operator>=(a,b));
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+    // The original emulator declares v_not<float,N> without a definition.
+    // Exercise the defined integer overload; retain the SDK's floating failure.
+    dump(out, cv::v_reinterpret_as_f32(cv::hal::operator~(cv::v_reinterpret_as_u32(a))));
+#else
+    dump(out, cv::hal::operator~(a));
+#endif
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator+=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator-=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator*=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator/=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator&=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator|=(x,y); });
+    compound(out,a,b,[](auto& x,const auto& y)->auto& { return cv::hal::operator^=(x,y); });
+    // Normal operator syntax and explicit template/function-pointer selection.
+    dump(out, a+b);
+    using Add = V (*)(const V&,const V&);
+    const auto add = static_cast<Add>(&cv::hal::operator+<V>);
+    dump(out, add(a,b));
+    std::array<uchar,16> bytes{};
+    const auto high=cv::v_setall_u8(250), ten=cv::v_setall_u8(10);
+    cv::v_store(bytes.data(), high+ten);
+    for (auto value : bytes) {
+        if (value != 255) throw std::runtime_error("legacy byte saturation");
+        out << +value << ',';
+    }
+    out << '\n';
+    if (const char* directory=std::getenv("OPENCV_M_SIMD_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory)/(std::string(consumer)+"-legacy.txt"),std::ios::binary);
+        file << out.str();
+        if (!file) throw std::runtime_error("legacy SIMD oracle output");
+    }
+}
+}
diff --git a/tests/fixtures/utility_helpers_fixture.hpp b/tests/fixtures/utility_helpers_fixture.hpp
new file mode 100644
index 0000000..7d138e4
--- /dev/null
+++ b/tests/fixtures/utility_helpers_fixture.hpp
@@ -0,0 +1,238 @@
+#pragma once
+
+namespace utility_helpers_fixture {
+inline void require(bool value, const char* message) {
+    if (!value) throw std::runtime_error(message);
+}
+struct Record { int id; float value; };
+
+inline void emit(const char* consumer) {
+    std::ostringstream result;
+    result << std::setprecision(17);
+    const short first[]{-3, 4, 0}, second[]{1, -2, 0};
+    const auto l2 = cv::normL2Sqr<short, long long>(first, 3);
+    const auto l1 = cv::normL1<short, long long>(first, 3);
+    const auto inf = cv::normInf<short, long long>(first, 3);
+    require(l2 == 25 && l1 == 7 && inf == 4, "single-array norms");
+    const auto diff2 = cv::normL2Sqr<short, long long>(first, second, 3);
+    const auto diff1 = cv::normL1<short, long long>(first, second, 3);
+    const auto diff_inf = cv::normInf<short, long long>(first, second, 3);
+    require(diff2 == 52 && diff1 == 10 && diff_inf == 6, "two-array norms");
+    result << l2 << ',' << l1 << ',' << inf << ',' << diff2 << ',' << diff1 << ',' << diff_inf << '\n';
+    const uint64 low[]{0, uint64(1) << 63}, high[]{std::numeric_limits<uint64>::max(), uint64(1) << 63};
+    require(cv::normL1<uint64, uint64>(low, high, 2) == high[0], "unsigned norm must not overflow signed subtraction");
+    require(cv::normInf<uint64, uint64>(low, high, 2) == high[0], "unsigned maximum distance");
+    const float values[]{0.25f, -0.5f, 1.75f}, other[]{0.5f, 0.25f, -1.f};
+    result << cv::normL2Sqr<float, double>(values, 3) << ','
+           << cv::normL1<float, double>(values, 3) << ',' << cv::normInf<float, double>(values, 3) << ','
+           << cv::normL2Sqr<float, double>(values, other, 3) << ','
+           << cv::normL1<float, double>(values, other, 3) << ',' << cv::normInf<float, double>(values, other, 3) << '\n';
+    require(cv::normL2Sqr<float, double>(nullptr, 0) == 0 &&
+            cv::normL1<float, double>(nullptr, nullptr, 0) == 0 &&
+            cv::normInf<float, double>(nullptr, 0) == 0, "empty norms");
+
+    alignas(64) std::array<uchar, 128> storage{};
+    const void* aligned = storage.data();
+    const void* misaligned = storage.data() + 1;
+    const auto address = reinterpret_cast<std::uintptr_t>(aligned);
+    require((cv::isAligned<64, std::uintptr_t>(address)), "numeric alignment overload");
+    require(cv::isAligned<64>(aligned) && cv::isAligned<64>(aligned, aligned) &&
+            cv::isAligned<64>(aligned, aligned, aligned) &&
+            cv::isAligned<64>(aligned, aligned, aligned, aligned), "pointer alignment overloads");
+    require(!cv::isAligned<64>(misaligned) && !cv::isAligned<64>(aligned, misaligned) &&
+            !cv::isAligned<64>(aligned, aligned, misaligned) &&
+            !cv::isAligned<64>(aligned, aligned, aligned, misaligned), "misaligned pointers");
+    result << "alignment: five valid/four rejected\n";
+    const double distance = cv::jaccardDistance(cv::Rect(0, 0, 4, 4), cv::Rect(2, 2, 4, 4));
+    require(std::abs(distance - 6.0 / 7.0) < 1e-14, "rectangle intersection/union distance");
+    require(cv::jaccardDistance(cv::Rect(), cv::Rect()) == 0 &&
+            cv::jaccardDistance(cv::Rect(0, 0, 1, 1), cv::Rect(2, 2, 1, 1)) == 1, "empty/disjoint rectangles");
+    result << "jaccard: " << distance << '\n';
+    const int largest = std::numeric_limits<int>::max();
+    const double boundary = cv::jaccardDistance(cv::Rect(largest - 4, 0, 8, 1), cv::Rect(largest - 2, 0, 1, 1));
+    require(boundary == 0.875, "SDK overflow-safe rectangle intersection");
+    result << "jaccard boundary: " << boundary << '\n';
+    cv::Point3i point(2, 3, 4);
+    point *= 3;
+    point -= cv::Point3i(1, 2, 3);
+    point /= 2.0;
+    require(point == cv::Point3i(2, 4, 4), "point compound overloads and nearest-even conversion");
+    cv::Size size(3, 4);
+    size += cv::Size(1, 2);
+    size *= 2;
+    size /= 2;
+    require(size == cv::Size(4, 6), "size compound overloads");
+    cv::Rect rectangle(1, 2, 3, 4);
+    rectangle += cv::Point(2, 3);
+    rectangle -= cv::Point(1, 1);
+    rectangle += cv::Size(2, 2);
+    rectangle -= cv::Size(1, 1);
+    rectangle &= cv::Rect(3, 5, 8, 8);
+    require(rectangle == cv::Rect(3, 5, 3, 4), "rectangle compound intersection");
+    rectangle |= cv::Rect(0, 0, 1, 1);
+    require(rectangle == cv::Rect(0, 0, 6, 9), "rectangle compound union");
+    const cv::Scalar left(1, 2, 3, 4), right(5, 6, 7, 8);
+    cv::Scalar product = left * right;
+    require(product == cv::Scalar(-60, 12, 30, 24), "SDK scalar hypercomplex product");
+    product /= right;
+    for (int index = 0; index < 4; ++index)
+        require(std::abs(product[index] - left[index]) < 1e-13, "SDK scalar quotient");
+    cv::Complexd complex(2, 3), divisor(4, -1);
+    complex = complex * divisor;
+    require(complex == cv::Complexd(11, 10), "complex product");
+    complex /= divisor;
+    require(std::abs(complex.re - 2) < 1e-13 && std::abs(complex.im - 3) < 1e-13, "complex quotient");
+    cv::Range range(1, 6);
+    range &= cv::Range(3, 8);
+    require(range == cv::Range(3, 6) && (2 + range) - 2 == range && !cv::Range(4, 4), "range overloads");
+    result << "operators: " << point.x << ',' << point.y << ',' << point.z << ',' << size.width << ','
+           << size.height << ',' << rectangle.width << ',' << rectangle.height << ',' << complex.re << ','
+           << complex.im << ',' << range.start << ',' << range.end << '\n';
+
+    const std::vector<Record> records{{3, 1.5f}, {7, -2.f}};
+    const auto input = cv::rawIn(records).getMat();
+    require(input.total() == records.size() && input.elemSize() == sizeof(Record) &&
+            input.data == reinterpret_cast<const uchar*>(records.data()), "raw vector input identity");
+    std::vector<Record> output;
+    auto destination = cv::rawOut(output);
+    destination.create(1, 2, input.type());
+    auto view = destination.getMat();
+    reinterpret_cast<Record*>(view.data)[0] = {9, 2.5f};
+    reinterpret_cast<Record*>(view.data)[1] = {4, -1.f};
+    auto writable = cv::rawInOut(output).getMat();
+    reinterpret_cast<Record*>(writable.data)[1].id = 11;
+    require(output.size() == 2 && output[0].id == 9 && output[0].value == 2.5f &&
+            output[1].id == 11 && output[1].value == -1.f, "raw vector output identity");
+    std::array<int, 2> array{13, 17};
+    const auto array_input = cv::rawIn(array).getMat();
+    require(array_input.type() == cv::traits::Type<int>::value && array_input.total() == 2,
+            "raw std::array retains SDK element typing");
+    auto array_output = cv::rawOut(array).getMat();
+    reinterpret_cast<int*>(array_output.data)[0] = 19;
+#if defined(OPENCV_M_NATIVE_REFERENCE)
+    // The pinned header's free wrapper incorrectly calls this non-static
+    // member without an instance. Compare the adapter with the SDK member.
+    cv::_InputOutputArray owner;
+    auto array_rw = owner.rawInOut(array).getMat();
+#else
+    auto array_rw = cv::rawInOut(array).getMat();
+#endif
+    reinterpret_cast<int*>(array_rw.data)[1] = 23;
+    require(array[0] == 19 && array[1] == 23, "raw array storage identity");
+    result << "raw: " << input.type() << ',' << input.total() << ',' << array_input.type() << ','
+           << output[0].id << ',' << output[1].id << ',' << array[0] << ',' << array[1] << '\n';
+    require(cvTrunc(cv::softfloat(2.9f)) == 2 && cvTrunc(cv::softdouble(-2.9)) == -2, "soft scalar truncation");
+    require(cvRound64(cv::softdouble(2.5)) == 2 && cvRound64(cv::softdouble(-2.5)) == -2 &&
+            cvRound64(cv::softdouble(4294967297.0)) == 4294967297LL, "soft scalar nearest-even int64");
+    require(cv::utils::getThreadID() >= 0 && cv::utils::getThreadID() == cv::utils::getThreadID(), "thread identity");
+    result << "scalar: 2,-2,2,-2,4294967297\n";
+    for (double value : {-3.75, -2.5, -0.0, 0.0, 2.5, 3.75}) {
+        const float narrow = static_cast<float>(value);
+        const int rounded = ::cvRound(value), floor = ::cvFloor(value), ceil = ::cvCeil(value);
+        require(rounded == ::cvRound(narrow) && floor == ::cvFloor(narrow) && ceil == ::cvCeil(narrow),
+                "global fast math float/double overloads");
+        require(rounded == ::cvRound(cv::softdouble(value)) && rounded == ::cvRound(cv::softfloat(narrow)) &&
+                floor == ::cvFloor(cv::softdouble(value)) && floor == ::cvFloor(cv::softfloat(narrow)) &&
+                ceil == ::cvCeil(cv::softdouble(value)) && ceil == ::cvCeil(cv::softfloat(narrow)),
+                "global fast math SoftFloat overloads");
+        result << "round: " << value << ',' << rounded << ',' << floor << ',' << ceil << '\n';
+    }
+    for (int value : {std::numeric_limits<int>::min(), -1, 0, 1, std::numeric_limits<int>::max()})
+        require(::cvRound(value) == value && ::cvFloor(value) == value && ::cvCeil(value) == value,
+                "integer fast math identity");
+    require(::cvIsInf(std::numeric_limits<double>::infinity()) &&
+            ::cvIsInf(-std::numeric_limits<float>::infinity()) &&
+            ::cvIsNaN(std::numeric_limits<double>::quiet_NaN()) &&
+            ::cvIsNaN(std::numeric_limits<float>::quiet_NaN()) &&
+            !::cvIsInf(0.0) && !::cvIsInf(-0.f) && !::cvIsNaN(0.0) && !::cvIsNaN(-0.f),
+            "global infinity/NaN classification");
+    auto round_address = static_cast<int (*)(double)>(&::cvRound);
+    require(round_address(2.5) == 2, "fast math overload address");
+    require(::CV_FOURCC('M', 'J', 'P', 'G') == 0x47504a4d &&
+            ::CV_FOURCC(char(0xff), 'A', 'B', char(0x7f)) == 0x7f4241ff,
+            "legacy global fourcc byte packing");
+    result << "fast math: classification,integer,address,fourcc\n";
+    OpenCV_API_Header header{sizeof(OpenCV_API_Header), 1, 2, 5, 0, 0, "", "mwrap fixture"};
+    OpenCV_API_Header_t* same_header = &header;
+    cvResult code = CV_ERROR_OK;
+    CvResult same_code = code;
+    require(same_header->valid_size == sizeof(OpenCV_API_Header_t) &&
+            same_header->min_api_version == 1 && same_header->api_version == 2 &&
+            same_header->opencv_version_major == 5 && same_code == 0 && CV_ERROR_FAIL == -1 &&
+            std::string(same_header->api_description) == "mwrap fixture", "original preview plugin ABI types");
+    result << "plugin ABI: " << sizeof(header) << ',' << sizeof(code) << ',' << CV_ERROR_FAIL << '\n';
+    const int float_type = cv::traits::Type<float>::value;
+    cv::Mat parent(4, 6, float_type), contiguous = parent(cv::Rect(1, 1, 4, 3));
+    require(!contiguous.isContinuous(), "CPU input has row gaps");
+    cv::cuda::createContinuous(cv::Size(4, 3), float_type, contiguous);
+    require(contiguous.isContinuous() && contiguous.rows == 3 && contiguous.cols == 4 &&
+            contiguous.type() == float_type, "CUDA namespace helper supports CPU Mat");
+    auto* original_storage = contiguous.data;
+    cv::cuda::ensureSizeIsEnough(cv::Size(3, 2), float_type, contiguous);
+    require(contiguous.data == original_storage && contiguous.rows == 2 && contiguous.cols == 3,
+            "CPU buffer reuse through Size overload");
+    cv::cuda::ensureSizeIsEnough(5, 7, float_type, contiguous);
+    require(contiguous.rows == 5 && contiguous.cols == 7 && contiguous.type() == float_type,
+            "CPU buffer grows through dimensions overload");
+    cv::cuda::createContinuous(7, 5, float_type, contiguous);
+    require(contiguous.isContinuous() && contiguous.rows == 7 && contiguous.cols == 5,
+            "CPU continuous buffer reshape");
+    auto return_by_size = static_cast<cv::cuda::GpuMat (*)(cv::Size, int)>(&cv::cuda::createContinuous);
+    auto return_by_dims = static_cast<cv::cuda::GpuMat (*)(int, int, int)>(&cv::cuda::createContinuous);
+    require(return_by_size && return_by_dims, "GPU-returning overload signatures available");
+    cv::cuda::GpuMat empty_first(nullptr), empty_second(nullptr);
+    cv::cuda::swap(empty_first, empty_second);
+    require(empty_first.empty() && empty_second.empty(), "empty GPU headers swap without device allocation");
+    cv::cuda::HostMem locked(cv::cuda::HostMem::PAGE_LOCKED), shared(cv::cuda::HostMem::SHARED);
+    cv::cuda::swap(locked, shared);
+    require(locked.alloc_type == cv::cuda::HostMem::SHARED &&
+            shared.alloc_type == cv::cuda::HostMem::PAGE_LOCKED, "host header allocation modes swap");
+    using Event = cv::cuda::Event;
+    Event::CreateFlags flags = Event::DEFAULT;
+    require(!flags, "zero event flags");
+    flags = Event::BLOCKING_SYNC | Event::DISABLE_TIMING;
+    require(flags == 3 && flags != 0 && !(!flags), "event flags OR and logical comparisons");
+    require((flags & Event::DISABLE_TIMING) == 2 && (flags ^ Event::DISABLE_TIMING) == 1 &&
+            (~Event::DEFAULT) != 0, "event flags AND/XOR/NOT");
+    flags &= Event::DISABLE_TIMING;
+    flags |= Event::INTERPROCESS;
+    flags ^= Event::DISABLE_TIMING;
+    require(flags == 4, "event flag compound operators preserve enum type");
+    result << "cuda CPU helpers: " << contiguous.rows << ',' << contiguous.cols << ',' << static_cast<int>(flags) << '\n';
+    const std::vector<cv::String> descriptions{
+        cv::utils::dumpBool(true), cv::utils::dumpBool(false), cv::utils::dumpInt(-17),
+        cv::utils::dumpInt64(4294967297LL), cv::utils::dumpSizeT(4096),
+        cv::utils::dumpFloat(2.375f), cv::utils::dumpDouble(-2.375),
+        cv::utils::dumpCString("SDK"), cv::utils::dumpString("module"),
+        cv::utils::dumpRect(cv::Rect(1, -2, 3, 4)),
+        cv::utils::dumpTermCriteria(cv::TermCriteria(3, 10, 0.125)),
+        cv::utils::dumpRotatedRect(cv::RotatedRect(cv::Point2f(1, 2), cv::Size2f(3, 4), 15)),
+        cv::utils::dumpRange(cv::Range(2, 7)), cv::utils::dumpRange(cv::Range::all()),
+        cv::utils::dumpVectorOfInt({-1, 2, 3}),
+        cv::utils::dumpVectorOfDouble({0.125, -2.375}),
+        cv::utils::dumpVectorOfRect({cv::Rect(1, 2, 3, 4)})};
+    require(descriptions[0] == "Bool: True" && descriptions[1] == "Bool: False" &&
+            descriptions[2] == "Int: -17" && descriptions[3] == "Int64: 4294967297" &&
+            descriptions[4] == "size_t: 4096" && descriptions[12] == "range: (s=2, e=7)" &&
+            descriptions[13] == "range: all", "public utility formatting contracts");
+    for (const auto& text : descriptions) result << text << '\n';
+    cv::Mat diagnostic(2, 3, cv::traits::Type<float>::value, cv::Scalar(7));
+    std::vector<cv::Mat> diagnostic_arrays{diagnostic, diagnostic};
+    const std::vector<cv::String> arrays{
+        cv::utils::dumpInputArray(diagnostic), cv::utils::dumpInputArrayOfArrays(diagnostic_arrays),
+        cv::utils::dumpInputOutputArray(diagnostic),
+        cv::utils::dumpInputOutputArrayOfArrays(diagnostic_arrays)};
+    for (const auto& text : arrays) {
+        require(text.find("empty()=false") != cv::String::npos && text.find("ERROR") == cv::String::npos,
+                "public array diagnostic helper");
+        result << text << '\n';
+    }
+    auto cache_accessor = &cv::utils::fs::getCacheDirectoryForDownloads;
+    require(cache_accessor != nullptr, "download cache accessor signature without filesystem side effects");
+    if (const char* directory = std::getenv("OPENCV_M_UTILITY_OUTPUT")) {
+        std::ofstream file(std::filesystem::path(directory) / (std::string(consumer) + ".txt"), std::ios::binary);
+        file << result.str();
+        require(bool(file), "utility oracle output");
+    }
+}
+}
diff --git a/tests/flann_cpp_test.cpp b/tests/flann_cpp_test.cpp
new file mode 100644
index 0000000..f3242bc
--- /dev/null
+++ b/tests/flann_cpp_test.cpp
@@ -0,0 +1,40 @@
+#include <gtest/gtest.h>
+#include <type_traits>
+#include <vector>
+
+#if defined(MCPP_FEATURE_FLANN)
+import mcpplibs.mwrap.opencv.flann;
+import mcpplibs.mwrap.opencv.macros;
+
+TEST(FlannCpp, GenericIndexFindsTheNearestFloatVector) {
+    static_assert(std::is_same_v<cv::flann::L2<float>, cvflann::L2<float>>);
+    std::vector<float> points{0, 0, 1, 0, 4, 4, 9, 9};
+    cv::Mat dataset(4, 2, mcpplibs::mwrap::opencv::macros::CV_32F, points.data());
+    cv::flann::GenericIndex<cv::flann::L2<float>> index(dataset, cvflann::LinearIndexParams());
+    std::vector<float> query{0.1f, 0.2f}, distances(1);
+    std::vector<int> indices(1);
+    index.knnSearch(query, indices, distances, 1, cvflann::SearchParams(cvflann::FLANN_CHECKS_UNLIMITED));
+    EXPECT_EQ(indices[0], 0);
+    EXPECT_NEAR(distances[0], 0.05f, 1e-6f);
+}
+
+TEST(FlannCpp, LowLevelNamespaceAndMatrixViewRemainAvailable) {
+    std::vector<float> points{0, 0, 1, 0, 4, 4, 9, 9};
+    cvflann::Matrix<float> dataset(points.data(), 4, 2);
+    cvflann::Index<cvflann::L2<float>> index(dataset, cvflann::LinearIndexParams());
+    index.buildIndex();
+    float query_data[]{3.9f, 4.1f};
+    int index_data[]{-1};
+    float distance_data[]{-1};
+    cvflann::Matrix<float> query(query_data, 1, 2), distances(distance_data, 1, 1);
+    cvflann::Matrix<int> indices(index_data, 1, 1);
+    index.knnSearch(query, indices, distances, 1, cvflann::SearchParams(cvflann::FLANN_CHECKS_UNLIMITED));
+    EXPECT_EQ(index_data[0], 2);
+    EXPECT_NEAR(distance_data[0], 0.02f, 1e-6f);
+    EXPECT_EQ(dataset.rows, 4u);
+    EXPECT_EQ(dataset.cols, 2u);
+    const float a[]{1, 2}, b[]{2, 4};
+    EXPECT_FLOAT_EQ(cvflann::L1<float>()(a, b, 2), 3);
+    EXPECT_FLOAT_EQ(cvflann::L2<float>()(a, b, 2), 5);
+}
+#endif
diff --git a/tests/fp_state_sdk_reference.cpp b/tests/fp_state_sdk_reference.cpp
new file mode 100644
index 0000000..5fd29e0
--- /dev/null
+++ b/tests/fp_state_sdk_reference.cpp
@@ -0,0 +1,14 @@
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <opencv2/core.hpp>
+#include <opencv2/core/utils/fp_control_utils.hpp>
+#if defined(MCPP_FEATURE_VIDEOIO)
+#include <opencv2/videoio.hpp>
+#endif
+#include "fixtures/fp_state_fixture.hpp"
+int main() { fp_state_fixture::emit("sdk"); }
diff --git a/tests/fp_state_test.cpp b/tests/fp_state_test.cpp
new file mode 100644
index 0000000..5177d61
--- /dev/null
+++ b/tests/fp_state_test.cpp
@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+import mcpplibs.mwrap.opencv.core;
+#if defined(MCPP_FEATURE_VIDEOIO)
+import mcpplibs.mwrap.opencv.videoio;
+#endif
+#include "fixtures/fp_state_fixture.hpp"
+TEST(FpState, OriginalQualifiedApiSignaturesStateAndScopeRestoration) {
+    EXPECT_NO_THROW(fp_state_fixture::emit("module"));
+}
diff --git a/tests/full_mix_test.cpp b/tests/full_mix_test.cpp
index ddf5995..c809a9a 100644
--- a/tests/full_mix_test.cpp
+++ b/tests/full_mix_test.cpp
@@ -16,7 +16,7 @@
 #include <opencv2/core/types.hpp>
 #include <opencv2/core/mat.hpp>
 
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 TEST(FullMix, ValueTypeOperators) {
     cv::Size s1(128, 128), s2(128, 128);
diff --git a/tests/geometry_optimizer_test.cpp b/tests/geometry_optimizer_test.cpp
new file mode 100644
index 0000000..102b8ac
--- /dev/null
+++ b/tests/geometry_optimizer_test.cpp
@@ -0,0 +1,48 @@
+#include <gtest/gtest.h>
+#include <memory>
+
+#if defined(MCPP_FEATURE_GEOMETRY)
+import mcpplibs.mwrap.opencv.geometry;
+
+namespace {
+class RejectingBackend final : public cv::detail::LevMarqBackend {
+public:
+    int prepared = 0, evaluated = 0;
+    bool enableGeo() override { return false; }
+    void prepareVars() override { ++prepared; }
+    bool calcFunc(double&, bool, bool) override { ++evaluated; return false; }
+    void currentOplusX(const cv::Mat_<double>&, bool) override { ADD_FAILURE(); }
+    const cv::Mat_<double> getJtb() override { ADD_FAILURE(); return {}; }
+    const cv::Mat_<double> getDiag() override { ADD_FAILURE(); return {}; }
+    void setDiag(const cv::Mat_<double>&) override { ADD_FAILURE(); }
+    void doJacobiScaling(const cv::Mat_<double>&) override { ADD_FAILURE(); }
+    bool decompose() override { ADD_FAILURE(); return false; }
+    bool solveDecomposed(const cv::Mat_<double>&, cv::Mat_<double>&) override { ADD_FAILURE(); return false; }
+    bool calcJtbv(cv::Mat_<double>&) override { ADD_FAILURE(); return false; }
+    void acceptProbe() override { ADD_FAILURE(); }
+};
+}
+
+TEST(GeometryOptimizer, CustomBackendRejectionPreservesTheSdkReport) {
+    auto backend = cv::makePtr<RejectingBackend>();
+    cv::LevMarq::Settings settings;
+    settings.setGeodesic(false);
+    cv::detail::LevMarqBase optimizer(backend, settings);
+    const auto report = optimizer.optimize();
+    EXPECT_FALSE(report.found);
+    EXPECT_EQ(report.iters, 0);
+    EXPECT_DOUBLE_EQ(report.energy, 0);
+    EXPECT_EQ(backend->prepared, 1);
+    EXPECT_EQ(backend->evaluated, 1);
+}
+
+TEST(GeometryOptimizer, UnsupportedGeodesicStopsBeforeEvaluatingTheBackend) {
+    auto backend = cv::makePtr<RejectingBackend>();
+    cv::LevMarq::Settings settings;
+    settings.setGeodesic(true);
+    cv::detail::LevMarqBase optimizer(backend, settings);
+    EXPECT_FALSE(optimizer.optimize().found);
+    EXPECT_EQ(backend->prepared, 0);
+    EXPECT_EQ(backend->evaluated, 0);
+}
+#endif
diff --git a/tests/hal_interface_test.cpp b/tests/hal_interface_test.cpp
new file mode 100644
index 0000000..caaf3f9
--- /dev/null
+++ b/tests/hal_interface_test.cpp
@@ -0,0 +1,60 @@
+#include <gtest/gtest.h>
+#include <array>
+#include <cmath>
+
+import mcpplibs.mwrap.opencv.core;
+import mcpplibs.mwrap.opencv.macros;
+#if defined(MCPP_FEATURE_IMGPROC)
+import mcpplibs.mwrap.opencv.imgproc;
+#endif
+#if defined(MCPP_FEATURE_FEATURES)
+import mcpplibs.mwrap.opencv.features;
+
+TEST(HalInterface, OriginalKeyPointRecordRetainsItsFields) {
+    cvhalKeyPoint point{2.5f, 3.5f, 7.f, -1.f, 0.75f, 2, 19};
+    EXPECT_FLOAT_EQ(point.x, 2.5f);
+    EXPECT_FLOAT_EQ(point.y, 3.5f);
+    EXPECT_FLOAT_EQ(point.size, 7.f);
+    EXPECT_FLOAT_EQ(point.angle, -1.f);
+    EXPECT_FLOAT_EQ(point.response, 0.75f);
+    EXPECT_EQ(point.octave, 2);
+    EXPECT_EQ(point.class_id, 19);
+}
+#endif
+
+TEST(HalInterface, CoreArithmeticDispatchRetainsSaturationAndNorms) {
+    const std::array<uchar, 4> first{0, 255, 10, 250}, second{1, 1, 20, 20};
+    std::array<uchar, 4> result{};
+    cv::hal::add8u(first.data(), 4, second.data(), 4, result.data(), 4, 4, 1, nullptr);
+    EXPECT_EQ(result, (std::array<uchar, 4>{1, 255, 30, 255}));
+    EXPECT_EQ(cv::hal::normHamming(first.data(), 4), 16);
+    EXPECT_EQ(cv::hal::normL1_(first.data(), second.data(), 4), 495);
+    const std::array<float, 3> input{0, 1, -1};
+    std::array<float, 3> exponent{};
+    cv::hal::exp32f(input.data(), exponent.data(), 3);
+    EXPECT_NEAR(exponent[0], 1, 1e-6);
+    EXPECT_NEAR(exponent[1], std::exp(1.f), 1e-5);
+    EXPECT_NEAR(exponent[2], std::exp(-1.f), 1e-6);
+}
+
+#if defined(MCPP_FEATURE_IMGPROC)
+TEST(HalInterface, ColorConversionMatchesThePublicImageApi) {
+    namespace types = mcpplibs::mwrap::opencv::macros;
+    cv::Mat bgr(1, 3, types::CV_8UC3);
+    bgr.at<cv::Vec3b>(0, 0) = cv::Vec3b(20, 80, 160);
+    bgr.at<cv::Vec3b>(0, 1) = cv::Vec3b(255, 0, 0);
+    bgr.at<cv::Vec3b>(0, 2) = cv::Vec3b(0, 255, 0);
+    cv::Mat gray(1, 3, types::CV_8UC1), reference;
+    cv::hal::cvtBGRtoGray(bgr.data, bgr.step[0], gray.data, gray.step[0],
+                         bgr.cols, bgr.rows, types::CV_8U, 3, false);
+    cv::cvtColor(bgr, reference, cv::COLOR_BGR2GRAY);
+    EXPECT_EQ(cv::norm(gray, reference, cv::NORM_INF), 0);
+    cv::Mat expanded(1, 3, types::CV_8UC3);
+    cv::hal::cvtGraytoBGR(gray.data, gray.step[0], expanded.data, expanded.step[0],
+                         gray.cols, gray.rows, types::CV_8U, 3);
+    for (int col = 0; col < gray.cols; ++col) {
+        const auto value = gray.at<uchar>(0, col);
+        EXPECT_EQ(expanded.at<cv::Vec3b>(0, col), cv::Vec3b(value, value, value));
+    }
+}
+#endif
diff --git a/tests/highgui_native_test.cpp b/tests/highgui_native_test.cpp
new file mode 100644
index 0000000..ef2282b
--- /dev/null
+++ b/tests/highgui_native_test.cpp
@@ -0,0 +1,20 @@
+#include <gtest/gtest.h>
+#include <string>
+
+import mcpplibs.mwrap.opencv;
+
+#if defined(MCPP_FEATURE_HIGHGUI_NATIVE) || defined(MCPP_FEATURE_HIGHGUI_GTK3) || defined(MCPP_FEATURE_HIGHGUI_WIN32) || defined(MCPP_FEATURE_HIGHGUI_COCOA)
+TEST(HighguiNative, CreateDisplayProcessAndDestroyWindow) {
+    ASSERT_FALSE(cv::currentUIFramework().empty());
+    const std::string name = "mwrap-native-window-test";
+    cv::Mat image(48, 64, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(20, 90, 160));
+    cv::namedWindow(name, cv::WINDOW_NORMAL);
+    cv::imshow(name, image);
+    cv::waitKey(40);
+    const auto rect = cv::getWindowImageRect(name);
+    EXPECT_GT(rect.width, 0);
+    EXPECT_GT(rect.height, 0);
+    cv::destroyWindow(name);
+    cv::waitKey(10);
+}
+#endif
diff --git a/tests/image_helpers_test.cpp b/tests/image_helpers_test.cpp
new file mode 100644
index 0000000..5721141
--- /dev/null
+++ b/tests/image_helpers_test.cpp
@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+#include <cmath>
+#include <filesystem>
+#include <vector>
+
+#if defined(MCPP_FEATURE_OBJDETECT)
+import mcpplibs.mwrap.opencv.objdetect;
+TEST(ImageHelpers, ArucoThresholdMatchesTheSdkDetectorDefault) {
+    static_assert(cv::aruco::DEFAULT_VALID_BIT_ID_THRESHOLD == 0.49f);
+    const cv::aruco::DetectorParameters defaults;
+    EXPECT_FLOAT_EQ(defaults.validBitIdThreshold, cv::aruco::DEFAULT_VALID_BIT_ID_THRESHOLD);
+    const float* volatile address = &cv::aruco::DEFAULT_VALID_BIT_ID_THRESHOLD;
+    EXPECT_FLOAT_EQ(*address, 0.49f);
+}
+#endif
+
+#if defined(MCPP_FEATURE_IMGPROC)
+import mcpplibs.mwrap.opencv.imgproc;
+import mcpplibs.mwrap.opencv.macros;
+namespace types = mcpplibs::mwrap::opencv::macros;
+
+TEST(ImageHelpers, ExplicitMagicBorderMatchesDefaultErosionAndDilation) {
+    cv::Mat image(2, 2, types::CV_64F, cv::Scalar(7)), implicit, explicit_border;
+    cv::Mat kernel = cv::Mat::ones(3, 3, types::CV_8U);
+    const auto border = cv::morphologyDefaultBorderValue();
+    cv::erode(image, implicit, kernel);
+    cv::erode(image, explicit_border, kernel, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, border);
+    EXPECT_DOUBLE_EQ(cv::norm(implicit, explicit_border, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(explicit_border.at<double>(0, 0), 7);
+    cv::dilate(image, implicit, kernel);
+    cv::dilate(image, explicit_border, kernel, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, border);
+    EXPECT_DOUBLE_EQ(cv::norm(implicit, explicit_border, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(explicit_border.at<double>(0, 0), 7);
+}
+
+TEST(ImageHelpers, WideAngleDefaultEnumAndIntegerOverloadsAgree) {
+    cv::Mat camera = cv::Mat::eye(3, 3, types::CV_64F);
+    camera.at<double>(0, 0) = camera.at<double>(1, 1) = 30;
+    camera.at<double>(0, 2) = 16;
+    camera.at<double>(1, 2) = 12;
+    cv::Mat distortion = cv::Mat::zeros(5, 1, types::CV_64F);
+    cv::Mat default_x, default_y, enum_x, enum_y, integer_x, integer_y;
+    const float baseline = cv::initWideAngleProjMap(camera, distortion, cv::Size(32, 24), 32,
+        types::CV_32FC1, default_x, default_y);
+    const float explicit_enum = cv::initWideAngleProjMap(camera, distortion, cv::Size(32, 24), 32,
+        types::CV_32FC1, enum_x, enum_y, cv::PROJ_SPHERICAL_EQRECT, 0);
+    const float integer = cv::initWideAngleProjMap(camera, distortion, cv::Size(32, 24), 32,
+        types::CV_32FC1, integer_x, integer_y, static_cast<int>(cv::PROJ_SPHERICAL_EQRECT));
+    EXPECT_TRUE(std::isfinite(baseline));
+    EXPECT_GT(baseline, 0);
+    EXPECT_EQ(default_x.cols, 32);
+    EXPECT_FLOAT_EQ(baseline, explicit_enum);
+    EXPECT_FLOAT_EQ(baseline, integer);
+    EXPECT_DOUBLE_EQ(cv::norm(default_x, enum_x, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(cv::norm(default_y, enum_y, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(cv::norm(default_x, integer_x, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(cv::norm(default_y, integer_y, cv::NORM_INF), 0);
+}
+#endif
+
+#if defined(MCPP_FEATURE_IMGCODECS)
+import mcpplibs.mwrap.opencv.imgcodecs;
+
+TEST(ImageHelpers, ImwriteMultiRetainsTheSingleFrameSdkDispatch) {
+    struct Cleanup {
+        cv::String path = cv::tempfile(".bmp");
+        ~Cleanup() { std::error_code error; std::filesystem::remove(path, error); }
+    } file;
+    cv::Mat image(8, 8, types::CV_8UC3, cv::Scalar(20, 80, 160));
+    const std::vector<cv::Mat> images{image};
+    ASSERT_TRUE(cv::imwritemulti(file.path, images));
+    const auto restored = cv::imread(file.path, cv::IMREAD_UNCHANGED);
+    ASSERT_FALSE(restored.empty());
+    EXPECT_DOUBLE_EQ(cv::norm(restored, image, cv::NORM_INF), 0);
+}
+#endif
diff --git a/tests/instrumentation_test.cpp b/tests/instrumentation_test.cpp
new file mode 100644
index 0000000..98c50a9
--- /dev/null
+++ b/tests/instrumentation_test.cpp
@@ -0,0 +1,38 @@
+#include <gtest/gtest.h>
+#include <string>
+
+import mcpplibs.mwrap.opencv.core;
+
+TEST(Instrumentation, PublicNodeRetainsSdkConstructionAndTiming) {
+    cv::instr::NodeData node("module-consumer", "consumer.cpp", 42, nullptr,
+                             false, cv::instr::TYPE_MARKER, cv::instr::IMPL_PLAIN);
+    EXPECT_EQ(node.m_funName, "module-consumer");
+    EXPECT_EQ(node.m_lineNum, 42);
+    EXPECT_EQ(node.m_instrType, cv::instr::TYPE_MARKER);
+    EXPECT_EQ(node.m_implType, cv::instr::IMPL_PLAIN);
+    node.m_ticksTotal = static_cast<uint64>(cv::getTickFrequency());
+    node.m_counter = 2;
+    EXPECT_NEAR(node.getTotalMs(), 1000, 0.001);
+    EXPECT_NEAR(node.getMeanMs(), 500, 0.001);
+    cv::instr::NodeData copy(node);
+    EXPECT_EQ(copy.m_funName, node.m_funName);
+    EXPECT_EQ(copy.m_counter, 2);
+    EXPECT_TRUE(node == copy);
+    cv::instr::NodeDataTls local;
+    EXPECT_EQ(local.m_ticksTotal, 0u);
+}
+
+TEST(Instrumentation, DisabledSdkContractIsPreservedRatherThanEmulated) {
+    // The current SDK configuration does not enable ENABLE_INSTRUMENTATION.
+    // These are upstream no-ops, not wrapper-owned state or tracing support.
+    EXPECT_FALSE(cv::instr::useInstrumentation());
+    cv::instr::setUseInstrumentation(true);
+    EXPECT_FALSE(cv::instr::useInstrumentation());
+    cv::instr::setFlags(cv::instr::FLAGS_MAPPING);
+    EXPECT_EQ(cv::instr::getFlags(), cv::instr::FLAGS_NONE);
+    cv::instr::setFlags(static_cast<int>(cv::instr::FLAGS_EXPAND_SAME_NAMES));
+    EXPECT_EQ(cv::instr::getFlags(), cv::instr::FLAGS_NONE);
+    EXPECT_EQ(cv::instr::getTrace(), nullptr);
+    EXPECT_NO_THROW(cv::instr::resetTrace());
+    cv::instr::setUseInstrumentation(false);
+}
diff --git a/tests/macro_layout_test.cpp b/tests/macro_layout_test.cpp
new file mode 100644
index 0000000..bb5dcaf
--- /dev/null
+++ b/tests/macro_layout_test.cpp
@@ -0,0 +1,84 @@
+#include <gtest/gtest.h>
+#include <array>
+#include <cstdint>
+#include <type_traits>
+
+import mcpplibs.mwrap.opencv;
+
+namespace macros = mcpplibs::mwrap::opencv::macros;
+
+TEST(MacroLayout, FourccPackingPreservesSignednessAndHalConstants) {
+    static_assert(macros::CV_FOURCC_MACRO('M', 'J', 'P', 'G') == 0x47504a4d);
+    static_assert(macros::CV_FOURCC_MACRO(0xff, 'A', 'B', 0x7f) == 0x7f4241ff);
+    static_assert(std::is_same_v<decltype(macros::CV_FOURCC_MACRO(0U, 0U, 0U, 0U)), unsigned>);
+    static_assert(macros::CV_FOURCC_MACRO(0U, 0U, 0U, 0xffU) == 0xff000000U);
+    EXPECT_EQ(macros::CV_FOURCC_MACRO('M', 'J', 'P', 'G'), ::CV_FOURCC('M', 'J', 'P', 'G'));
+    EXPECT_EQ(macros::CV_HAL_TYPE_5_8, 0);
+    EXPECT_EQ(macros::CV_HAL_TYPE_7_12, 1);
+    EXPECT_EQ(macros::CV_HAL_TYPE_9_16, 2);
+    EXPECT_EQ(macros::CV_HAL_INTER_LINEAR, 1);
+    EXPECT_EQ(macros::CV_HAL_INTER_NEAREST_EXACT, 6);
+    EXPECT_EQ(macros::CV_HAL_MORPH_DILATE, 1);
+    EXPECT_EQ(macros::CV_HAL_THRESH_OTSU, 8);
+    EXPECT_EQ(macros::CV_HAL_ADAPTIVE_THRESH_GAUSSIAN_C, 1);
+}
+
+TEST(MacroLayout, EveryOpenCv5DepthMatchesActualMatStorage) {
+    constexpr std::array depths{macros::CV_8U, macros::CV_8S, macros::CV_16U,
+        macros::CV_16S, macros::CV_32S, macros::CV_32F, macros::CV_64F,
+        macros::CV_16F, macros::CV_16BF, macros::CV_Bool, macros::CV_64U,
+        macros::CV_64S, macros::CV_32U};
+    constexpr std::array sizes{1, 1, 2, 2, 4, 4, 8, 2, 2, 1, 8, 8, 4};
+    static_assert(depths.size() == macros::CV_DEPTH_CURR_MAX);
+    for (unsigned depth = 0; depth < depths.size(); ++depth) {
+        EXPECT_EQ(depths[depth], depth);
+        for (int channels : {1, 2, 3, 4, 7, macros::CV_CN_MAX}) {
+            const auto type = macros::CV_MAKE_TYPE(depths[depth], channels);
+            cv::Mat matrix(3, 5, type);
+            EXPECT_EQ(matrix.depth(), depths[depth]);
+            EXPECT_EQ(matrix.channels(), channels);
+            EXPECT_EQ(matrix.elemSize1(), sizes[depth]);
+            EXPECT_EQ(matrix.elemSize(), sizes[depth] * channels);
+            EXPECT_EQ(macros::CV_MAT_DEPTH(matrix.flags), matrix.depth());
+            EXPECT_EQ(macros::CV_MAT_CN(matrix.flags), matrix.channels());
+            EXPECT_EQ(macros::CV_MAT_TYPE(matrix.flags), matrix.type());
+            EXPECT_EQ(macros::CV_ELEM_SIZE1(type), matrix.elemSize1());
+            EXPECT_EQ(macros::CV_ELEM_SIZE(type), matrix.elemSize());
+        }
+    }
+}
+
+TEST(MacroLayout, NewDepthFamiliesAndStorageAccess) {
+    static_assert(macros::CV_16BFC(3) == macros::CV_16BFC3);
+    static_assert(macros::CV_BoolC(4) == macros::CV_BoolC4);
+    static_assert(macros::CV_64UC(2) == macros::CV_64UC2);
+    static_assert(macros::CV_64SC(1) == macros::CV_64SC1);
+    static_assert(macros::CV_32UC(3) == macros::CV_32UC3);
+    static_assert(macros::CV_8UC(3) == macros::CV_8UC3);
+    static_assert(macros::CV_IS_INT_TYPE(macros::CV_64UC1));
+    static_assert(macros::CV_IS_FLOAT_TYPE(macros::CV_16BFC1));
+    static_assert(!macros::CV_IS_FLOAT_TYPE(macros::CV_BoolC1));
+    cv::Mat unsigned64(2, 3, macros::CV_64UC1);
+    unsigned64.ptr<std::uint64_t>(1)[2] = UINT64_C(0xfedcba9876543210);
+    EXPECT_EQ(unsigned64.ptr<std::uint64_t>(1)[2], UINT64_C(0xfedcba9876543210));
+    cv::Mat signed64(2, 3, macros::CV_64SC1);
+    signed64.ptr<std::int64_t>(1)[2] = -INT64_C(0x123456789abcdef);
+    EXPECT_EQ(signed64.ptr<std::int64_t>(1)[2], -INT64_C(0x123456789abcdef));
+    cv::Mat unsigned32(2, 3, macros::CV_32UC1);
+    unsigned32.ptr<std::uint32_t>(1)[2] = UINT32_C(0xfedcba98);
+    EXPECT_EQ(unsigned32.ptr<std::uint32_t>(1)[2], UINT32_C(0xfedcba98));
+    cv::Mat boolean(2, 3, macros::CV_BoolC1);
+    boolean.ptr<bool>(1)[2] = true;
+    EXPECT_TRUE(boolean.ptr<bool>(1)[2]);
+}
+
+TEST(MacroLayout, RoiAndContinuityFlagsMatchMat) {
+    cv::Mat parent(8, 10, macros::CV_8UC3);
+    cv::Mat roi = parent(cv::Rect(2, 2, 4, 3));
+    EXPECT_EQ(macros::CV_IS_SUBMAT(parent.flags) != 0, parent.isSubmatrix());
+    EXPECT_EQ(macros::CV_IS_SUBMAT(roi.flags) != 0, roi.isSubmatrix());
+    EXPECT_EQ(macros::CV_IS_MAT_CONT(parent.flags) != 0, parent.isContinuous());
+    EXPECT_EQ(macros::CV_IS_CONT_MAT(roi.flags) != 0, roi.isContinuous());
+    EXPECT_FALSE(roi.isContinuous());
+    EXPECT_TRUE(roi.isSubmatrix());
+}
diff --git a/tests/macros_mix_test.cpp b/tests/macros_mix_test.cpp
index 6fd6b4e..0460063 100644
--- a/tests/macros_mix_test.cpp
+++ b/tests/macros_mix_test.cpp
@@ -1,13 +1,13 @@
 // The optional macros side header must coexist with the import in one TU.
 // In such a mixed TU the RAW macro spellings are the ones to use (an active
-// CV_8UC3 macro would mangle the cv::CV_8UC3 spelling — that constexpr
+// CV_8UC3 macro would mangle the mcpplibs::mwrap::opencv::macros::CV_8UC3 spelling — that constexpr
 // surface is for module-only TUs, see api_surface_test.cpp).
 #include <gtest/gtest.h>
 
 // Canonical mixing order: textual includes BEFORE the import.
-#include <opencv-m/macros.hpp>
+#include <mwrap/opencv/macros.hpp>
 
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 TEST(MacrosMix, AssertAndTypeMacros) {
     cv::Mat m(2, 2, CV_8UC1, cv::Scalar(7));
@@ -20,3 +20,18 @@ TEST(MacrosMix, VersionMacros) {
     EXPECT_EQ(CV_VERSION_MAJOR, 5);
     EXPECT_EQ(cv::getVersionMajor(), CV_VERSION_MAJOR);
 }
+
+TEST(MacrosMix, GlobalFastMathCoexistsWithTextualHeaders) {
+    EXPECT_EQ(::cvRound(2.5), 2);
+    EXPECT_EQ(::cvFloor(-2.5f), -3);
+    EXPECT_EQ(::cvCeil(2), 2);
+    EXPECT_EQ(::CV_FOURCC('M', 'J', 'P', 'G'), CV_FOURCC_MACRO('M', 'J', 'P', 'G'));
+}
+
+TEST(MacrosMix, SubmatrixMacroMatchesMatFlags) {
+    cv::Mat image(8, 10, CV_8UC1);
+    cv::Mat roi = image(cv::Rect(2, 2, 4, 3));
+    EXPECT_EQ(CV_IS_SUBMAT(image.flags) != 0, image.isSubmatrix());
+    EXPECT_EQ(CV_IS_SUBMAT(roi.flags) != 0, roi.isSubmatrix());
+    EXPECT_TRUE(roi.isSubmatrix());
+}
diff --git a/tests/main_modules_test.cpp b/tests/main_modules_test.cpp
new file mode 100644
index 0000000..a610087
--- /dev/null
+++ b/tests/main_modules_test.cpp
@@ -0,0 +1,201 @@
+// Exercise the newly integrated main modules through the aggregate module.
+// Inputs are generated locally; no camera, model or image download is needed.
+#include <gtest/gtest.h>
+#include <limits>
+#include <vector>
+
+#if defined(MCPP_FEATURE_FEATURES)
+import mcpplibs.mwrap.opencv.features;
+#endif
+#if defined(MCPP_FEATURE_OBJDETECT)
+import mcpplibs.mwrap.opencv.objdetect;
+#endif
+#if defined(MCPP_FEATURE_STEREO)
+import mcpplibs.mwrap.opencv.stereo;
+#endif
+#if defined(MCPP_FEATURE_CALIB)
+import mcpplibs.mwrap.opencv.calib;
+#endif
+#if defined(MCPP_FEATURE_PHOTO)
+import mcpplibs.mwrap.opencv.photo;
+#endif
+#if defined(MCPP_FEATURE_PTCLOUD)
+import mcpplibs.mwrap.opencv.ptcloud;
+#endif
+#if defined(MCPP_FEATURE_STITCHING)
+import mcpplibs.mwrap.opencv.stitching;
+#endif
+#if defined(MCPP_FEATURE_VIDEO)
+import mcpplibs.mwrap.opencv.video;
+#endif
+import mcpplibs.mwrap.opencv;
+namespace types = mcpplibs::mwrap::opencv::macros;
+
+#if defined(MCPP_FEATURE_PHOTO)
+TEST(MainModules, OriginalGlobalInpaintingEnumRemainsAvailable) {
+    InpaintingModes mode = CV_INPAINT_TELEA;
+    EXPECT_EQ(static_cast<int>(mode), cv::INPAINT_TELEA);
+    EXPECT_EQ(static_cast<int>(CV_INPAINT_NS), cv::INPAINT_NS);
+}
+#endif
+#if defined(MCPP_FEATURE_VIDEO)
+TEST(MainModules, OriginalGlobalOpticalFlowFlagsRemainAvailable) {
+    EXPECT_EQ(CV_LKFLOW_PYR_A_READY, 1);
+    EXPECT_EQ(CV_LKFLOW_PYR_B_READY, 2);
+    EXPECT_EQ(static_cast<int>(CV_LKFLOW_INITIAL_GUESSES), cv::OPTFLOW_USE_INITIAL_FLOW);
+    EXPECT_EQ(static_cast<int>(CV_LKFLOW_GET_MIN_EIGENVALS), cv::OPTFLOW_LK_GET_MIN_EIGENVALS);
+}
+#endif
+
+#if defined(MCPP_FEATURE_PTCLOUD)
+TEST(MainModules, PointCloudCpuRenderingAndInvalidPoints) {
+    cv::Mat points(1, 2, types::CV_32FC4, cv::Scalar(0, 0, 1, 0));
+    cv::Mat normals(1, 2, types::CV_32FC4, cv::Scalar(0, 0, -1, 0));
+    cv::Mat colors(1, 2, types::CV_32FC4, cv::Scalar(12, 34, 56, 0));
+    points.at<cv::Vec4f>(0, 1)[0] = std::numeric_limits<float>::quiet_NaN();
+    cv::Mat image;
+    cv::detail::renderPointsNormalsColors(points, normals, colors, image);
+    ASSERT_EQ(image.type(), types::CV_8UC4);
+    EXPECT_EQ(image.size(), points.size());
+    EXPECT_EQ(image.at<cv::Vec4b>(0, 0), cv::Vec4b(12, 34, 56, 0));
+    EXPECT_EQ(image.at<cv::Vec4b>(0, 1), cv::Vec4b(0, 32, 0, 0));
+    cv::detail::renderPointsNormals(points, normals, image, cv::Vec3f(0, 0, -1));
+    const auto shaded = image.at<cv::Vec4b>(0, 0);
+    EXPECT_GT(shaded[0], 200);
+    EXPECT_EQ(shaded[0], shaded[1]);
+    EXPECT_EQ(shaded[1], shaded[2]);
+    EXPECT_EQ(shaded[3], 0);
+    EXPECT_EQ(image.at<cv::Vec4b>(0, 1), cv::Vec4b(0, 32, 0, 0));
+    EXPECT_THROW(cv::detail::renderPointsNormals(points, cv::Mat(), image, cv::Vec3f()), cv::Exception);
+}
+#endif
+
+#if defined(MCPP_FEATURE_FEATURES)
+TEST(MainModules, FeaturesSiftDescriptors) {
+    cv::Mat image(128, 128, types::CV_8UC1, cv::Scalar(0));
+    for (int y = 0; y < 8; ++y)
+        for (int x = 0; x < 8; ++x)
+            if ((x + y) % 2)
+                cv::rectangle(image, cv::Rect(x * 16, y * 16, 16, 16), cv::Scalar(255), -1);
+    auto sift = cv::SIFT::create(32);
+    std::vector<cv::KeyPoint> points;
+    cv::Mat descriptors;
+    sift->detectAndCompute(image, cv::noArray(), points, descriptors);
+    ASSERT_FALSE(points.empty());
+    EXPECT_EQ(descriptors.rows, static_cast<int>(points.size()));
+    EXPECT_EQ(descriptors.cols, 128);
+}
+#endif
+
+#if defined(MCPP_FEATURE_OBJDETECT)
+TEST(MainModules, ObjdetectQrEncoder) {
+    cv::Mat code;
+    cv::QRCodeEncoder::create()->encode("mwrap", code);
+    ASSERT_FALSE(code.empty());
+    EXPECT_EQ(code.rows, code.cols);
+    EXPECT_GT(code.rows, 20);
+    EXPECT_GT(cv::countNonZero(code), 0);
+    EXPECT_LT(cv::countNonZero(code), code.rows * code.cols);
+}
+#endif
+
+#if defined(MCPP_FEATURE_STEREO)
+TEST(MainModules, StereoBlockMatching) {
+    cv::Mat left(64, 96, types::CV_8UC1);
+    cv::randu(left, 0, 255);
+    cv::Mat disparity;
+    cv::StereoBM::create(16, 5)->compute(left, left, disparity);
+    EXPECT_EQ(disparity.rows, left.rows);
+    EXPECT_EQ(disparity.cols, left.cols);
+    EXPECT_EQ(disparity.type(), types::CV_16SC1);
+}
+#endif
+
+#if defined(MCPP_FEATURE_CALIB)
+TEST(MainModules, CalibCameraInitializationFromProjectedViews) {
+    cv::Mat intrinsic = cv::Mat::eye(3, 3, types::CV_64F);
+    intrinsic.at<double>(0, 0) = intrinsic.at<double>(1, 1) = 500;
+    intrinsic.at<double>(0, 2) = 319.5;
+    intrinsic.at<double>(1, 2) = 239.5;
+    std::vector<std::vector<cv::Point3f>> objects(3);
+    std::vector<std::vector<cv::Point2f>> images(3);
+    for (int view = 0; view < 3; ++view) {
+        for (int y = 0; y < 4; ++y)
+            for (int x = 0; x < 5; ++x)
+                objects[view].emplace_back(x * 0.1f, y * 0.1f, 0.f);
+        cv::projectPoints(objects[view], cv::Vec3d(0.1 + view * 0.1, 0.2, 0.05),
+                          cv::Vec3d(0.1, -0.1, 2.0 + view), intrinsic, cv::noArray(), images[view]);
+    }
+    const auto estimated = cv::initCameraMatrix2D(objects, images, cv::Size(640, 480));
+    EXPECT_NEAR(estimated.at<double>(0, 0), 500.0, 0.2);
+    EXPECT_NEAR(estimated.at<double>(1, 1), 500.0, 0.2);
+    EXPECT_DOUBLE_EQ(estimated.at<double>(0, 2), 319.5);
+}
+#endif
+
+#if defined(MCPP_FEATURE_PHOTO)
+TEST(MainModules, PhotoDenoiseConstantImage) {
+    cv::Mat image(24, 24, types::CV_8UC1, cv::Scalar(73)), denoised;
+    cv::fastNlMeansDenoising(image, denoised, 3.f, 3, 7);
+    EXPECT_TRUE(denoised.size() == image.size());
+    EXPECT_EQ(cv::norm(image, denoised, cv::NORM_INF), 0.0);
+}
+#endif
+
+#if defined(MCPP_FEATURE_PTCLOUD)
+TEST(MainModules, PtcloudDepthToThreeDimensions) {
+    cv::Mat depth(2, 3, types::CV_32F, cv::Scalar(1));
+    cv::Mat intrinsic = cv::Mat::eye(3, 3, types::CV_32F), cloud;
+    cv::depthTo3d(depth, intrinsic, cloud);
+    ASSERT_EQ(cloud.type(), types::CV_32FC4);
+    const auto point = cloud.at<cv::Vec4f>(1, 2);
+    EXPECT_FLOAT_EQ(point[0], 2.f);
+    EXPECT_FLOAT_EQ(point[1], 1.f);
+    EXPECT_FLOAT_EQ(point[2], 1.f);
+    EXPECT_FLOAT_EQ(point[3], 0.f);
+}
+#endif
+
+#if defined(MCPP_FEATURE_STITCHING)
+TEST(MainModules, StitchingRejectsInsufficientImages) {
+    auto stitcher = cv::Stitcher::create();
+    std::vector<cv::Mat> images{cv::Mat(32, 32, types::CV_8UC3, cv::Scalar(10, 20, 30))};
+    cv::Mat panorama;
+    EXPECT_EQ(static_cast<int>(stitcher->stitch(images, panorama)),
+              static_cast<int>(cv::Stitcher::ERR_NEED_MORE_IMGS));
+}
+#endif
+
+#if defined(MCPP_FEATURE_VIDEO)
+TEST(MainModules, VideoKalmanPredictionAndOpticalFlow) {
+    cv::KalmanFilter filter(2, 1);
+    filter.transitionMatrix = cv::Mat::eye(2, 2, types::CV_32F);
+    filter.statePost = cv::Mat(2, 1, types::CV_32F, cv::Scalar(5));
+    const auto predicted = filter.predict();
+    EXPECT_FLOAT_EQ(predicted.at<float>(0, 0), 5.f);
+    cv::Mat image(32, 32, types::CV_8UC1, cv::Scalar(50)), flow;
+    cv::calcOpticalFlowFarneback(image, image, flow, .5, 1, 5, 1, 5, 1.1, 0);
+    EXPECT_EQ(flow.type(), types::CV_32FC2);
+    EXPECT_LE(cv::norm(flow, cv::NORM_INF), 1e-6);
+}
+#endif
+
+#if defined(MCPP_FEATURE_GEOMETRY)
+TEST(MainModules, GeometryBuildsTheMinimumSpanningTree) {
+    const std::vector<cv::MSTEdge> edges{{0, 1, 1}, {1, 2, 2}, {0, 2, 9}};
+    for (const auto algorithm : {cv::MST_PRIM, cv::MST_KRUSKAL}) {
+        std::vector<cv::MSTEdge> tree;
+        ASSERT_TRUE(cv::buildMST(3, edges, tree, algorithm));
+        ASSERT_EQ(tree.size(), 2u);
+        double weight = 0;
+        for (const auto& edge : tree) weight += edge.weight;
+        EXPECT_DOUBLE_EQ(weight, 3);
+    }
+}
+#endif
+
+#if defined(MCPP_FEATURE_FEATURES) && defined(MCPP_FEATURE_DNN)
+TEST(MainModules, DiskApiRejectsAnAbsentModel) {
+    EXPECT_THROW(cv::DISK::create(""), cv::Exception);
+}
+#endif
diff --git a/tests/mat_aug_sdk_reference.cpp b/tests/mat_aug_sdk_reference.cpp
new file mode 100644
index 0000000..84a3e7f
--- /dev/null
+++ b/tests/mat_aug_sdk_reference.cpp
@@ -0,0 +1,13 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <opencv2/core.hpp>
+#include "fixtures/mat_aug_fixture.hpp"
+TEST(MatAugSdk, OriginalSignaturesValuesAndReferenceIdentity) {
+    EXPECT_NO_THROW(mat_aug_fixture::emit("sdk"));
+}
diff --git a/tests/mat_aug_test.cpp b/tests/mat_aug_test.cpp
new file mode 100644
index 0000000..fdc031e
--- /dev/null
+++ b/tests/mat_aug_test.cpp
@@ -0,0 +1,13 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+import mcpplibs.mwrap.opencv.core;
+#include "fixtures/mat_aug_fixture.hpp"
+TEST(MatAug, OriginalSignaturesValuesAndReferenceIdentity) {
+    EXPECT_NO_THROW(mat_aug_fixture::emit("module"));
+}
diff --git a/tests/matx_templates_sdk_reference.cpp b/tests/matx_templates_sdk_reference.cpp
new file mode 100644
index 0000000..3f58d7a
--- /dev/null
+++ b/tests/matx_templates_sdk_reference.cpp
@@ -0,0 +1,11 @@
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <opencv2/core.hpp>
+#include "fixtures/matx_templates_fixture.hpp"
+int main() { matx_templates_fixture::emit("sdk"); }
diff --git a/tests/matx_templates_test.cpp b/tests/matx_templates_test.cpp
new file mode 100644
index 0000000..da7d936
--- /dev/null
+++ b/tests/matx_templates_test.cpp
@@ -0,0 +1,14 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+import mcpplibs.mwrap.opencv.core;
+#include "fixtures/matx_templates_fixture.hpp"
+TEST(MatxTemplates, OriginalExplicitArgumentsPrefixesAndDerivedDeduction) {
+    EXPECT_NO_THROW(matx_templates_fixture::emit("module"));
+}
diff --git a/tests/persistence_sdk_reference.cpp b/tests/persistence_sdk_reference.cpp
new file mode 100644
index 0000000..66a5442
--- /dev/null
+++ b/tests/persistence_sdk_reference.cpp
@@ -0,0 +1,13 @@
+// Intentionally textual-only: no module is imported into the SDK oracle.
+#include <opencv2/core.hpp>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+#include "fixtures/persistence_fixture.hpp"
+int main() {
+    persistence_fixture::emit("sdk");
+}
diff --git a/tests/persistence_test.cpp b/tests/persistence_test.cpp
new file mode 100644
index 0000000..052c4ac
--- /dev/null
+++ b/tests/persistence_test.cpp
@@ -0,0 +1,135 @@
+#include <gtest/gtest.h>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+import mcpplibs.mwrap.opencv.core;
+#include "fixtures/persistence_fixture.hpp"
+
+TEST(Persistence, XmlYamlJsonAndCustomSerializers) {
+    EXPECT_NO_THROW(persistence_fixture::emit("module"));
+}
+
+namespace {
+enum class Mode { low = 3, high = 7 };
+}
+
+namespace custom_record {
+struct Value { int first, second; };
+void write(cv::FileStorage& storage, const cv::String& name, const Value& value) {
+    cv::write(storage, name, cv::Vec2i(value.first, value.second));
+}
+void read(const cv::FileNode& node, Value& value, const Value& fallback) {
+    cv::Vec2i fields;
+    cv::read(node, fields, cv::Vec2i(fallback.first, fallback.second));
+    value = {fields[0], fields[1]};
+}
+}
+
+TEST(Persistence, GeometryMatricesVectorsAndStreamsUseTheSdkFormat) {
+    cv::FileStorage writer("generated.yml", cv::FileStorage::WRITE | cv::FileStorage::MEMORY);
+    const cv::Point2f point(1.5f, -2.5f);
+    const cv::Point3d point3(1, 2, 3);
+    const cv::Size2i size(12, 8);
+    const cv::Rect2d rectangle(1, 2, 3, 4);
+    const cv::Complexd complex(3, -4);
+    const cv::Vec3f vector(2, 4, 6);
+    const cv::Matx22d matrix(1, 2, 3, 4);
+    const cv::Scalar scalar(3, 5, 7, 9);
+    cv::write(writer, "point", point);
+    cv::write(writer, "point3", point3);
+    cv::write(writer, "size", size);
+    cv::write(writer, "rectangle", rectangle);
+    cv::write(writer, "complex", complex);
+    cv::write(writer, "vector", vector);
+    cv::write(writer, "matrix", matrix);
+    cv::write(writer, "scalar", scalar);
+    cv::write(writer, "range", cv::Range(2, 6));
+    writer << "integers" << std::vector<int>{3, 4, 5};
+    writer << "points" << std::vector<cv::Point2f>{point, cv::Point2f(7, 8)};
+    writer << "nested" << std::vector<std::vector<int>>{{1, 2}, {3}};
+    writer << "matches" << std::vector<cv::DMatch>{cv::DMatch(0, 1, 2.5f)};
+    writer << "mode" << Mode::high;
+    writer << "custom" << custom_record::Value{17, 23};
+    writer << "large" << 300;
+    writer << "fallback" << "[" << 1 << "]";
+    const auto text = writer.releaseAndGetString();
+    ASSERT_NE(text.find("%YAML"), std::string::npos);
+    cv::FileStorage reader(text, cv::FileStorage::READ | cv::FileStorage::MEMORY);
+    cv::Point2f restoredPoint;
+    cv::Point3d restoredPoint3;
+    cv::Size2i restoredSize;
+    cv::Rect2d restoredRect;
+    cv::Complexd restoredComplex;
+    cv::Vec3f restoredVector;
+    cv::Matx22d restoredMatrix;
+    cv::Scalar restoredScalar;
+    cv::Range restoredRange;
+    cv::read(reader["point"], restoredPoint, cv::Point2f());
+    cv::read(reader["point3"], restoredPoint3, cv::Point3d());
+    cv::read(reader["size"], restoredSize, cv::Size2i());
+    cv::read(reader["rectangle"], restoredRect, cv::Rect2d());
+    cv::read(reader["complex"], restoredComplex, cv::Complexd());
+    cv::read(reader["vector"], restoredVector, cv::Vec3f());
+    cv::read(reader["matrix"], restoredMatrix);
+    cv::read(reader["scalar"], restoredScalar, cv::Scalar());
+    cv::read(reader["range"], restoredRange, cv::Range());
+    EXPECT_EQ(restoredPoint, point);
+    EXPECT_EQ(restoredPoint3, point3);
+    EXPECT_EQ(restoredSize, size);
+    EXPECT_EQ(restoredRect, rectangle);
+    EXPECT_DOUBLE_EQ(restoredComplex.re, complex.re);
+    EXPECT_DOUBLE_EQ(restoredComplex.im, complex.im);
+    EXPECT_EQ(cv::norm(restoredVector, vector), 0);
+    EXPECT_EQ(cv::norm(restoredMatrix - matrix), 0);
+    EXPECT_EQ(restoredScalar, scalar);
+    EXPECT_EQ(restoredRange, cv::Range(2, 6));
+    std::vector<int> integers;
+    std::vector<cv::Point2f> points;
+    reader["integers"] >> integers;
+    reader["points"] >> points;
+    EXPECT_EQ(integers, (std::vector<int>{3, 4, 5}));
+    ASSERT_EQ(points.size(), 2u);
+    EXPECT_EQ(points[0], point);
+    EXPECT_EQ(points[1], cv::Point2f(7, 8));
+    std::vector<std::vector<int>> nested;
+    reader["nested"] >> nested;
+    EXPECT_EQ(nested, (std::vector<std::vector<int>>{{1, 2}, {3}}));
+    std::vector<cv::DMatch> matches;
+    reader["matches"] >> matches;
+    ASSERT_EQ(matches.size(), 1u);
+    EXPECT_EQ(matches[0].queryIdx, 0);
+    EXPECT_EQ(matches[0].trainIdx, 1);
+    EXPECT_FLOAT_EQ(matches[0].distance, 2.5f);
+    Mode mode = Mode::low;
+    cv::read<Mode, nullptr>(reader["mode"], mode);
+    EXPECT_EQ(mode, Mode::high);
+    custom_record::Value custom{};
+    reader["custom"] >> custom;
+    EXPECT_EQ(custom.first, 17);
+    EXPECT_EQ(custom.second, 23);
+    uchar saturated = 0;
+    cv::read(reader["large"], saturated, static_cast<uchar>(0));
+    EXPECT_EQ(saturated, 255);
+    cv::read(reader["missing"], restoredPoint, cv::Point2f(11, 13));
+    EXPECT_EQ(restoredPoint, cv::Point2f(11, 13));
+    cv::read(reader["fallback"], restoredPoint, point);
+    EXPECT_EQ(restoredPoint, point);
+    auto iterator = reader["integers"].begin();
+    std::vector<int> prefix;
+    cv::read(iterator, prefix, 2);
+    EXPECT_EQ(prefix, (std::vector<int>{3, 4}));
+    int last = 0;
+    iterator >> last;
+    EXPECT_EQ(last, 5);
+    EXPECT_TRUE(iterator == reader["integers"].end());
+    EXPECT_FALSE(iterator != reader["integers"].end());
+    const auto begin = reader["integers"].begin();
+    const auto end = reader["integers"].end();
+    EXPECT_EQ(end - begin, 3);
+    EXPECT_TRUE(begin < end);
+}
diff --git a/tests/roundtrip_test.cpp b/tests/roundtrip_test.cpp
index e8181bb..ae4bf9c 100644
--- a/tests/roundtrip_test.cpp
+++ b/tests/roundtrip_test.cpp
@@ -5,12 +5,13 @@
 
 #include <vector>
 
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
+#if defined(MCPP_FEATURE_IMGPROC) && defined(MCPP_FEATURE_IMGCODECS)
 namespace {
 
 cv::Mat make_test_image() {
-    cv::Mat img(64, 64, cv::CV_8UC3, cv::Scalar(30, 60, 90));
+    cv::Mat img(64, 64, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30, 60, 90));
     cv::circle(img, {32, 32}, 20, {255, 255, 255}, -1);
     cv::rectangle(img, {4, 4}, {60, 60}, {0, 128, 255}, 2);
     return img;
@@ -18,6 +19,32 @@ cv::Mat make_test_image() {
 
 } // namespace
 
+TEST(Roundtrip, BuiltInBitmapAndPortablePixmapArePixelExact) {
+    const auto image = make_test_image();
+    for (const char* extension : {".bmp", ".ppm"}) {
+        SCOPED_TRACE(extension);
+        std::vector<unsigned char> encoded;
+        ASSERT_TRUE(cv::imencode(extension, image, encoded));
+        const auto decoded = cv::imdecode(encoded, cv::IMREAD_UNCHANGED);
+        ASSERT_FALSE(decoded.empty());
+        ASSERT_EQ(decoded.type(), image.type());
+        ASSERT_TRUE(decoded.size() == image.size());
+        EXPECT_DOUBLE_EQ(cv::norm(decoded, image, cv::NORM_INF), 0);
+    }
+}
+
+TEST(Roundtrip, PortableFloatMapPreservesFloatPixels) {
+    cv::Mat image(8, 12, mcpplibs::mwrap::opencv::macros::CV_32FC3, cv::Scalar(0.125, 0.5, 2.0));
+    std::vector<unsigned char> encoded;
+    ASSERT_TRUE(cv::imencode(".pfm", image, encoded));
+    const auto decoded = cv::imdecode(encoded, cv::IMREAD_UNCHANGED);
+    ASSERT_FALSE(decoded.empty());
+    ASSERT_EQ(decoded.type(), image.type());
+    ASSERT_TRUE(decoded.size() == image.size());
+    EXPECT_DOUBLE_EQ(cv::norm(decoded, image, cv::NORM_INF), 0);
+}
+
+#if defined(MCPP_FEATURE_IMGCODECS_PNG)
 TEST(Roundtrip, PngIsPixelExact) {
     cv::Mat img = make_test_image();
     std::vector<unsigned char> buf;
@@ -29,7 +56,9 @@ TEST(Roundtrip, PngIsPixelExact) {
     cv::absdiff(img, back, diff);
     EXPECT_EQ(cv::countNonZero(diff.reshape(1)), 0);
 }
+#endif
 
+#if defined(MCPP_FEATURE_IMGCODECS_JPEG)
 TEST(Roundtrip, JpegIsClose) {
     cv::Mat img = make_test_image();
     std::vector<unsigned char> buf;
@@ -39,3 +68,6 @@ TEST(Roundtrip, JpegIsClose) {
     ASSERT_TRUE(back.size() == img.size());
     EXPECT_LT(cv::norm(img, back, cv::NORM_L1) / (64.0 * 64 * 3), 12.0);  // q95 ringing on sharp synthetic edges ≈ 7
 }
+#endif
+
+#endif
diff --git a/tests/saturate_parity_test.cpp b/tests/saturate_parity_test.cpp
new file mode 100644
index 0000000..1b5465c
--- /dev/null
+++ b/tests/saturate_parity_test.cpp
@@ -0,0 +1,70 @@
+#include <gtest/gtest.h>
+#include <limits>
+#include <type_traits>
+#include <tuple>
+#include <opencv2/core/saturate.hpp>
+
+// Bind the upstream header overloads before importing the adapter namespace.
+namespace upstream_saturate {
+template<class To, class From>
+inline constexpr auto function = static_cast<To (*)(From)>(&cv::saturate_cast<To>);
+const auto unsigned_from_int = function<unsigned, int>;
+const auto byte_from_short = function<uchar, ushort>;
+const auto wide_from_double = function<uint64, double>;
+}
+
+import mcpplibs.mwrap.opencv.core;
+
+TEST(SaturateParity, NegativeIntegersClampForUnsignedDestinations) {
+    ASSERT_EQ(upstream_saturate::unsigned_from_int(-1), 0u);
+    EXPECT_EQ(cv::opencv_m_repl::saturate_cast<unsigned>(-1), upstream_saturate::unsigned_from_int(-1));
+}
+
+TEST(SaturateParity, WideUnsignedSourcesClampForByteDestinations) {
+    ASSERT_EQ(upstream_saturate::byte_from_short(256), 255);
+    EXPECT_EQ(cv::opencv_m_repl::saturate_cast<uchar>(ushort(256)), upstream_saturate::byte_from_short(256));
+}
+
+TEST(SaturateParity, WideIntegerDestinationsFollowUpstreamRounding) {
+    ASSERT_EQ(upstream_saturate::wide_from_double(1.8), 2u);
+    EXPECT_EQ(cv::opencv_m_repl::saturate_cast<uint64>(1.8), upstream_saturate::wide_from_double(1.8));
+}
+
+namespace {
+using ScalarTypes = std::tuple<uchar, schar, ushort, short, unsigned, int, int64, uint64,
+                               float, double, cv::hfloat, cv::bfloat, bool>;
+template<class To, class From>
+void check_conversion(From value) {
+    const auto expected = upstream_saturate::function<To, From>(value);
+    const auto actual = cv::opencv_m_repl::saturate_cast<To>(value);
+    if constexpr (std::is_same_v<To, cv::hfloat> || std::is_same_v<To, cv::bfloat>)
+        EXPECT_EQ(float(actual), float(expected));
+    else
+        EXPECT_EQ(actual, expected);
+}
+template<class From, std::size_t... Index>
+void check_destinations(From value, std::index_sequence<Index...>) {
+    (check_conversion<std::tuple_element_t<Index, ScalarTypes>>(value), ...);
+}
+template<class From>
+void check_values(std::initializer_list<From> values) {
+    for (const auto value : values)
+        check_destinations(value, std::make_index_sequence<std::tuple_size_v<ScalarTypes>>{});
+}
+}
+
+TEST(SaturateParity, AllThirteenScalarTypesMatchThePinnedHeader) {
+    check_values<uchar>({0, 1, 128, 255});
+    check_values<schar>({-128, -1, 0, 127});
+    check_values<ushort>({0, 255, 256, 65535});
+    check_values<short>({-32768, -1, 256, 32767});
+    check_values<unsigned>({0, 256, 65536, std::numeric_limits<unsigned>::max()});
+    check_values<int>({std::numeric_limits<int>::min(), -1, 0, 128, 32768, std::numeric_limits<int>::max()});
+    check_values<int64>({std::numeric_limits<int64>::min(), -1, 0, 256, std::numeric_limits<int64>::max()});
+    check_values<uint64>({0, 256, 65536, std::numeric_limits<unsigned>::max(), std::numeric_limits<uint64>::max()});
+    check_values<float>({-32768.5f, -2.5f, -0.1f, 0, 1.8f, 2.5f, 3.5f, 255.5f, 32767.5f, 65504});
+    check_values<double>({-32768.5, -2.5, -0.1, 0, 1.8, 2.5, 3.5, 255.5, 32767.5, 65504});
+    check_values<cv::hfloat>({cv::hfloat(-2.5f), cv::hfloat(0.f), cv::hfloat(1.8f), cv::hfloat(65504.f)});
+    check_values<cv::bfloat>({cv::bfloat(-2.5f), cv::bfloat(0.f), cv::bfloat(1.8f), cv::bfloat(65504.f)});
+    check_values<bool>({false, true});
+}
diff --git a/tests/simd_legacy_sdk_reference.cpp b/tests/simd_legacy_sdk_reference.cpp
new file mode 100644
index 0000000..c52e77a
--- /dev/null
+++ b/tests/simd_legacy_sdk_reference.cpp
@@ -0,0 +1,19 @@
+#if defined(MCPP_FEATURE_SIMD)
+#include <array>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+#define CV_FORCE_SIMD128_CPP 1
+#endif
+#include <opencv2/core/simd_intrinsics.hpp>
+#include <opencv2/core/hal/intrin_legacy_ops.h>
+#include "fixtures/simd_legacy_fixture.hpp"
+int main() { simd_legacy_fixture::emit("sdk"); }
+#else
+int main() { return 0; }
+#endif
diff --git a/tests/simd_legacy_test.cpp b/tests/simd_legacy_test.cpp
new file mode 100644
index 0000000..4b41b10
--- /dev/null
+++ b/tests/simd_legacy_test.cpp
@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+#if defined(MCPP_FEATURE_SIMD)
+#include <array>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+import mcpplibs.mwrap.opencv.core.simd.legacy;
+#include "fixtures/simd_legacy_fixture.hpp"
+TEST(SimdLegacy, OriginalOperatorsReferencesAndSaturation) {
+    EXPECT_NO_THROW(simd_legacy_fixture::emit("module"));
+}
+#endif
diff --git a/tests/simd_sdk_reference.cpp b/tests/simd_sdk_reference.cpp
new file mode 100644
index 0000000..3cc3069
--- /dev/null
+++ b/tests/simd_sdk_reference.cpp
@@ -0,0 +1,19 @@
+#if defined(MCPP_FEATURE_SIMD)
+#include <array>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+// Independent original SDK reference: deliberately no wrapper linkage shim.
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+#define CV_FORCE_SIMD128_CPP 1
+#endif
+#include <opencv2/core/simd_intrinsics.hpp>
+#include "fixtures/simd_fixture.hpp"
+int main() { simd_fixture::emit("sdk"); }
+#else
+int main() { return 0; }
+#endif
diff --git a/tests/simd_test.cpp b/tests/simd_test.cpp
new file mode 100644
index 0000000..d8925c8
--- /dev/null
+++ b/tests/simd_test.cpp
@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+#if defined(MCPP_FEATURE_SIMD)
+#include <array>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+import mcpplibs.mwrap.opencv.core.simd;
+import mcpplibs.mwrap.opencv.macros;
+#include "fixtures/simd_fixture.hpp"
+TEST(Simd, OriginalSdkArithmeticMemoryPackingAndLaneContracts) {
+    EXPECT_NO_THROW(simd_fixture::emit("module"));
+}
+TEST(Simd, TypedCapabilitiesDescribeTheCompiledLibraryBaseline) {
+    namespace macros = mcpplibs::mwrap::opencv::macros;
+    static_assert(macros::CV_SIMD_WIDTH == 16);
+    static_assert(macros::CV_SIMD128 == 1 && macros::CV_SIMD128_64F == 1);
+    static_assert(macros::CV_SIMD256 == 0 && macros::CV_SIMD512 == 0);
+#if defined(MCPP_FEATURE_SIMD_EMULATED)
+    static_assert(macros::CV_SIMD128_CPP == 1);
+#else
+    static_assert(macros::CV_SIMD128_CPP == 0);
+#endif
+    EXPECT_EQ(sizeof(cv::v_float32), macros::CV_SIMD_WIDTH);
+    EXPECT_EQ(cv::VTraits<cv::v_float32>::vlanes(), 4);
+}
+#endif
diff --git a/tests/stitching_detail_test.cpp b/tests/stitching_detail_test.cpp
new file mode 100644
index 0000000..bb69ba2
--- /dev/null
+++ b/tests/stitching_detail_test.cpp
@@ -0,0 +1,56 @@
+#include <gtest/gtest.h>
+#include <vector>
+
+#if defined(MCPP_FEATURE_STITCHING)
+import mcpplibs.mwrap.opencv.stitching;
+import mcpplibs.mwrap.opencv.macros;
+
+namespace macros = mcpplibs::mwrap::opencv::macros;
+
+TEST(StitchingDetail, CpuBlenderComposesTwoTiles) {
+    auto blender = cv::detail::Blender::createDefault(cv::detail::Blender::NO, false);
+    blender->prepare(cv::Rect(0, 0, 16, 8));
+    cv::Mat left(8, 8, macros::CV_16SC3, cv::Scalar(20, 40, 80));
+    cv::Mat right(8, 8, macros::CV_16SC3, cv::Scalar(90, 60, 30));
+    cv::Mat mask(8, 8, macros::CV_8UC1, cv::Scalar(255));
+    blender->feed(left, mask, cv::Point(0, 0));
+    blender->feed(right, mask, cv::Point(8, 0));
+    cv::Mat result, result_mask;
+    blender->blend(result, result_mask);
+    ASSERT_TRUE(result.size() == cv::Size(16, 8));
+    EXPECT_EQ(result.type(), macros::CV_16SC3);
+    EXPECT_EQ(cv::countNonZero(result_mask), 128);
+    EXPECT_DOUBLE_EQ(cv::norm(result(cv::Rect(0, 0, 8, 8)), left, cv::NORM_INF), 0);
+    EXPECT_DOUBLE_EQ(cv::norm(result(cv::Rect(8, 0, 8, 8)), right, cv::NORM_INF), 0);
+}
+
+TEST(StitchingDetail, CameraIntrinsicsAndPlaneWarp) {
+    cv::detail::CameraParams camera;
+    camera.focal = 100;
+    camera.aspect = 1.5;
+    camera.ppx = 8;
+    camera.ppy = 4;
+    const auto intrinsics = camera.K();
+    EXPECT_DOUBLE_EQ(intrinsics.at<double>(0, 0), 100);
+    EXPECT_DOUBLE_EQ(intrinsics.at<double>(1, 1), 150);
+    EXPECT_DOUBLE_EQ(intrinsics.at<double>(0, 2), 8);
+    EXPECT_DOUBLE_EQ(intrinsics.at<double>(1, 2), 4);
+    cv::detail::PlaneWarper warper(1);
+    cv::Mat identity = cv::Mat::eye(3, 3, macros::CV_32FC1);
+    const auto point = warper.warpPoint(cv::Point2f(5, 7), identity, identity);
+    EXPECT_NEAR(point.x, 5, 1e-6);
+    EXPECT_NEAR(point.y, 7, 1e-6);
+}
+
+TEST(StitchingDetail, TimelapserPlacesAFrameInTheGlobalRoi) {
+    auto timelapser = cv::detail::Timelapser::createDefault(cv::detail::Timelapser::AS_IS);
+    timelapser->initialize(std::vector<cv::Point>{cv::Point(3, 2)}, std::vector<cv::Size>{cv::Size(8, 6)});
+    cv::Mat frame(6, 8, macros::CV_16SC3, cv::Scalar(15, 30, 45));
+    cv::Mat mask(6, 8, macros::CV_8UC1, cv::Scalar(255));
+    timelapser->process(frame, mask, cv::Point(3, 2));
+    cv::Mat restored;
+    timelapser->getDst().copyTo(restored);
+    EXPECT_TRUE(restored.size() == frame.size());
+    EXPECT_DOUBLE_EQ(cv::norm(restored, frame, cv::NORM_INF), 0);
+}
+#endif
diff --git a/tests/tracking_extension_test.cpp b/tests/tracking_extension_test.cpp
new file mode 100644
index 0000000..e99e3c6
--- /dev/null
+++ b/tests/tracking_extension_test.cpp
@@ -0,0 +1,67 @@
+#include <gtest/gtest.h>
+#include <memory>
+#include <vector>
+
+#if defined(MCPP_FEATURE_VIDEO)
+import mcpplibs.mwrap.opencv.video;
+import mcpplibs.mwrap.opencv.macros;
+namespace types = mcpplibs::mwrap::opencv::macros;
+
+namespace {
+class MeanFeature final : public cv::detail::tracking::TrackerFeature {
+public:
+    int calls = 0;
+protected:
+    bool computeImpl(const std::vector<cv::Mat>& images, cv::Mat& response) override {
+        ++calls;
+        response.create(1, static_cast<int>(images.size()), types::CV_32F);
+        for (int index = 0; index < response.cols; ++index)
+            response.at<float>(0, index) = static_cast<float>(cv::mean(images[index])[0]);
+        return true;
+    }
+};
+}
+
+TEST(TrackingExtension, UserFeatureRunsThroughTheSdkFeatureSet) {
+    auto feature = cv::makePtr<MeanFeature>();
+    cv::detail::tracking::TrackerFeatureSet set;
+    ASSERT_TRUE(set.addTrackerFeature(feature));
+    std::vector<cv::Mat> images{
+        cv::Mat(4, 4, types::CV_8U, cv::Scalar(9)),
+        cv::Mat(4, 4, types::CV_8U, cv::Scalar(17))};
+    set.extraction(images);
+    EXPECT_EQ(feature->calls, 1);
+    ASSERT_EQ(set.getTrackerFeatures().size(), 1u);
+    ASSERT_EQ(set.getResponses().size(), 1u);
+    const auto& response = set.getResponses()[0];
+    ASSERT_EQ(response.cols, 2);
+    EXPECT_FLOAT_EQ(response.at<float>(0, 0), 9);
+    EXPECT_FLOAT_EQ(response.at<float>(0, 1), 17);
+    EXPECT_THROW(set.addTrackerFeature(feature), cv::Exception);
+}
+
+TEST(TrackingExtension, TargetStateAndDefaultSamplerExecuteSdkMethods) {
+    auto state = cv::makePtr<cv::detail::tracking::TrackerTargetState>();
+    state->setTargetPosition(cv::Point2f(3, 5));
+    state->setTargetWidth(7);
+    state->setTargetHeight(11);
+    EXPECT_EQ(state->getTargetPosition(), cv::Point2f(3, 5));
+    EXPECT_EQ(state->getTargetWidth(), 7);
+    EXPECT_EQ(state->getTargetHeight(), 11);
+    cv::detail::tracking::ConfidenceMap confidence{{state, 0.75f}};
+    cv::detail::tracking::Trajectory trajectory{state};
+    EXPECT_EQ(confidence[0].first.get(), trajectory[0].get());
+    cv::detail::tracking::TrackerSamplerCSC sampler;
+    sampler.setMode(cv::detail::tracking::TrackerSamplerCSC::MODE_INIT_POS);
+    cv::Mat image(32, 32, types::CV_8U, cv::Scalar(23));
+    std::vector<cv::Mat> samples;
+    // Pinned OpenCV returns false even after populating samples. Preserve
+    // that SDK behavior; do not "repair" the return value in the wrapper.
+    EXPECT_FALSE(sampler.sampling(image, cv::Rect(12, 12, 4, 4), samples));
+    ASSERT_FALSE(samples.empty());
+    for (const auto& sample : samples) {
+        EXPECT_EQ(sample.size(), cv::Size(4, 4));
+        EXPECT_DOUBLE_EQ(cv::mean(sample)[0], 23);
+    }
+}
+#endif
diff --git a/tests/unifont_module_test.cpp b/tests/unifont_module_test.cpp
index c03de64..9622359 100644
--- a/tests/unifont_module_test.cpp
+++ b/tests/unifont_module_test.cpp
@@ -1,15 +1,15 @@
-// unifont feature test — through the module layer (import opencv.cv). The
+// unifont feature test — through the module layer (import mcpplibs.mwrap.opencv). The
 // "uni" builtin FontFace only exists when the library is built with
 // HAVE_UNIFONT (build.mcpp embeds the vendored font), so its usability IS
 // the feature probe: CJK rendering must produce real ink. Only built with
 // `--features unifont` (no new module surface); without it this TU has no tests.
 #include <gtest/gtest.h>
 #if defined(MCPP_FEATURE_UNIFONT)
-import opencv.cv;
+import mcpplibs.mwrap.opencv;
 
 TEST(UnifontModule, CjkPutTextInks) {
     cv::FontFace uni("uni");
-    cv::Mat img(64, 256, cv::CV_8UC1, cv::Scalar(0));
+    cv::Mat img(64, 256, mcpplibs::mwrap::opencv::macros::CV_8UC1, cv::Scalar(0));
     cv::putText(img, "中文字体", cv::Point(8, 44), cv::Scalar(255), uni, 28);
     EXPECT_GT(cv::countNonZero(img), 100);  // glyphs actually rendered
 }
diff --git a/tests/utility_helpers_sdk_reference.cpp b/tests/utility_helpers_sdk_reference.cpp
new file mode 100644
index 0000000..6b26874
--- /dev/null
+++ b/tests/utility_helpers_sdk_reference.cpp
@@ -0,0 +1,21 @@
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <opencv2/core.hpp>
+#include <opencv2/core/softfloat.hpp>
+#include <opencv2/core/llapi/llapi.h>
+#include <opencv2/core/cuda.hpp>
+#include <opencv2/core/bindings_utils.hpp>
+#define OPENCV_M_NATIVE_REFERENCE 1
+#include "fixtures/utility_helpers_fixture.hpp"
+
+int main() { utility_helpers_fixture::emit("sdk"); }
diff --git a/tests/utility_helpers_test.cpp b/tests/utility_helpers_test.cpp
new file mode 100644
index 0000000..5a926a3
--- /dev/null
+++ b/tests/utility_helpers_test.cpp
@@ -0,0 +1,20 @@
+#include <gtest/gtest.h>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+import mcpplibs.mwrap.opencv.core;
+#include "fixtures/utility_helpers_fixture.hpp"
+
+TEST(UtilityHelpers, NormAlignmentRawArrayGeometryAndScalarContracts) {
+    EXPECT_NO_THROW(utility_helpers_fixture::emit("module"));
+}
diff --git a/tests/videoio_backend_test.cpp b/tests/videoio_backend_test.cpp
new file mode 100644
index 0000000..2b85986
--- /dev/null
+++ b/tests/videoio_backend_test.cpp
@@ -0,0 +1,81 @@
+#include <gtest/gtest.h>
+#if defined(MCPP_FEATURE_VIDEOIO_NATIVE) || defined(MCPP_FEATURE_VIDEOIO_V4L2) || defined(MCPP_FEATURE_VIDEOIO_MSMF) || defined(MCPP_FEATURE_VIDEOIO_AVFOUNDATION) || defined(MCPP_FEATURE_VIDEOIO_FFMPEG)
+#include <algorithm>
+#include <chrono>
+#include <filesystem>
+#include <string>
+
+import mcpplibs.mwrap.opencv;
+
+namespace {
+void roundtrip_video(int backend, int codec, const char* extension) {
+    struct VideoFile {
+        std::filesystem::path path;
+        ~VideoFile() { std::error_code error; std::filesystem::remove(path, error); }
+    } file{std::filesystem::temp_directory_path() / ("mwrap-video-" +
+        std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) + extension)};
+    const auto expected_backend = cv::videoio_registry::getBackendName(static_cast<cv::VideoCaptureAPIs>(backend));
+    cv::VideoWriter writer(file.path.string(), backend, codec, 24.0, cv::Size(96, 64));
+    ASSERT_TRUE(writer.isOpened()) << expected_backend;
+    ASSERT_EQ(writer.getBackendName(), expected_backend);
+    for (int i = 0; i < 12; ++i) {
+        cv::Mat image(64, 96, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30 + i, 60, 90));
+        writer.write(image);
+    }
+    writer.release();
+    ASSERT_GT(std::filesystem::file_size(file.path), 0u);
+    cv::VideoCapture reader(file.path.string(), backend);
+    ASSERT_TRUE(reader.isOpened()) << expected_backend;
+    ASSERT_EQ(reader.getBackendName(), expected_backend);
+    cv::Mat decoded;
+    int count = 0;
+    while (reader.read(decoded)) {
+        ASSERT_FALSE(decoded.empty());
+        ASSERT_TRUE(decoded.size() == cv::Size(96, 64));
+        ASSERT_EQ(decoded.channels(), 3);
+        cv::Mat reference(64, 96, mcpplibs::mwrap::opencv::macros::CV_8UC3, cv::Scalar(30 + count, 60, 90));
+        EXPECT_LT(cv::norm(decoded, reference, cv::NORM_L1) / (64.0 * 96 * 3), 15.0);
+        ++count;
+    }
+    EXPECT_EQ(count, 12);
+}
+}
+
+#if defined(MCPP_FEATURE_VIDEOIO_NATIVE) || defined(MCPP_FEATURE_VIDEOIO_V4L2) || defined(MCPP_FEATURE_VIDEOIO_MSMF) || defined(MCPP_FEATURE_VIDEOIO_AVFOUNDATION)
+TEST(VideoioBackend, NativeBackendIsBuiltInAndRegistered) {
+#if defined(__linux__)
+    const auto backend = cv::CAP_V4L2;
+#elif defined(_WIN32)
+    const auto backend = cv::CAP_MSMF;
+#else
+    const auto backend = cv::CAP_AVFOUNDATION;
+#endif
+    EXPECT_TRUE(cv::videoio_registry::hasBackend(backend));
+    EXPECT_TRUE(cv::videoio_registry::isBackendBuiltIn(backend));
+    const auto cameras = cv::videoio_registry::getCameraBackends();
+    EXPECT_NE(std::find(cameras.begin(), cameras.end(), backend), cameras.end());
+}
+
+#if defined(__linux__)
+TEST(VideoioBackend, V4l2ReportsAnUnavailableDevice) {
+    cv::VideoCapture absent(99999, cv::CAP_V4L2);
+    EXPECT_FALSE(absent.isOpened()); // No physical-camera coverage is claimed.
+}
+#else
+TEST(VideoioBackend, NativeFileEncodingAndDecoding) {
+#if defined(_WIN32)
+    const int backend = cv::CAP_MSMF;
+#else
+    const int backend = cv::CAP_AVFOUNDATION;
+#endif
+    roundtrip_video(backend, cv::VideoWriter::fourcc('H', '2', '6', '4'), ".mp4");
+}
+#endif
+#endif
+
+#if defined(MCPP_FEATURE_VIDEOIO_FFMPEG)
+TEST(VideoioBackend, FfmpegFileEncodingAndDecoding) {
+    roundtrip_video(cv::CAP_FFMPEG, cv::VideoWriter::fourcc('M', 'J', 'P', 'G'), ".avi");
+}
+#endif
+#endif
diff --git a/tests/webp_codec_test.cpp b/tests/webp_codec_test.cpp
new file mode 100644
index 0000000..95a0446
--- /dev/null
+++ b/tests/webp_codec_test.cpp
@@ -0,0 +1,80 @@
+#include <gtest/gtest.h>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#if defined(MCPP_FEATURE_IMGCODECS)
+import mcpplibs.mwrap.opencv.imgcodecs;
+import mcpplibs.mwrap.opencv.macros;
+
+#if defined(MCPP_FEATURE_IMGCODECS_WEBP)
+namespace {
+cv::Mat make_frame(int bias) {
+    namespace types = mcpplibs::mwrap::opencv::macros;
+    cv::Mat image(8, 8, types::CV_8UC4);
+    for (int y = 0; y < image.rows; ++y)
+        for (int x = 0; x < image.cols; ++x)
+            image.at<cv::Vec4b>(y, x) = cv::Vec4b(20 + x + bias, 60 + y, 100 + bias, 180);
+    return image;
+}
+}
+
+TEST(WebPCodec, LosslessPreservesAlphaAndTransparentRgb) {
+    auto image = make_frame(0);
+    image.at<cv::Vec4b>(0, 0) = cv::Vec4b(7, 19, 23, 0);
+    ASSERT_TRUE(cv::haveImageWriter(".webp"));
+    std::vector<uchar> encoded;
+    ASSERT_TRUE(cv::imencode(".webp", image, encoded,
+        {cv::IMWRITE_WEBP_LOSSLESS_MODE, cv::IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR}));
+    const auto restored = cv::imdecode(encoded, cv::IMREAD_UNCHANGED);
+    ASSERT_FALSE(restored.empty());
+    ASSERT_EQ(restored.type(), image.type());
+    ASSERT_TRUE(restored.size() == image.size());
+    EXPECT_DOUBLE_EQ(cv::norm(restored, image, cv::NORM_INF), 0);
+}
+
+TEST(WebPCodec, AnimationKeepsFramesTimingAndLoopCount) {
+    cv::Animation animation(3);
+    animation.frames = {make_frame(0), make_frame(50)};
+    animation.durations = {80, 120};
+    std::vector<uchar> encoded;
+    ASSERT_TRUE(cv::imencodeanimation(".webp", animation, encoded, {cv::IMWRITE_WEBP_QUALITY, 101}));
+    cv::Animation restored;
+    ASSERT_TRUE(cv::imdecodeanimation(encoded, restored));
+    EXPECT_EQ(restored.loop_count, 3);
+    EXPECT_EQ(restored.durations, animation.durations);
+    ASSERT_EQ(restored.frames.size(), 2u);
+    for (int frame = 0; frame < 2; ++frame) {
+        ASSERT_EQ(restored.frames[frame].type(), animation.frames[frame].type());
+        ASSERT_TRUE(restored.frames[frame].size() == animation.frames[frame].size());
+        EXPECT_DOUBLE_EQ(cv::norm(restored.frames[frame], animation.frames[frame], cv::NORM_INF), 0);
+    }
+}
+
+TEST(WebPCodec, XmpMetadataRoundtripsThroughMuxAndDemux) {
+    namespace types = mcpplibs::mwrap::opencv::macros;
+    const std::string xmp = "<x:xmpmeta xmlns:x='adobe:ns:meta/'>mwrap</x:xmpmeta>";
+    cv::Mat chunk(1, static_cast<int>(xmp.size()), types::CV_8U,
+                  const_cast<char*>(xmp.data()));
+    const auto image = make_frame(0);
+    const std::vector<int> metadata_types{cv::IMAGE_METADATA_XMP};
+    const std::vector<cv::Mat> metadata{chunk};
+    std::vector<uchar> encoded;
+    ASSERT_TRUE(cv::imencodeWithMetadata(".webp", image, metadata_types, metadata, encoded,
+        {cv::IMWRITE_WEBP_LOSSLESS_MODE, cv::IMWRITE_WEBP_LOSSLESS_ON}));
+    std::vector<int> restored_types;
+    std::vector<cv::Mat> restored_metadata;
+    const auto restored = cv::imdecodeWithMetadata(encoded, restored_types, restored_metadata, cv::IMREAD_UNCHANGED);
+    ASSERT_FALSE(restored.empty());
+    EXPECT_DOUBLE_EQ(cv::norm(restored, image, cv::NORM_INF), 0);
+    ASSERT_EQ(restored_types, metadata_types);
+    ASSERT_EQ(restored_metadata.size(), 1u);
+    ASSERT_EQ(restored_metadata[0].total(), xmp.size());
+    EXPECT_EQ(std::memcmp(restored_metadata[0].data, xmp.data(), xmp.size()), 0);
+}
+#else
+TEST(WebPCodec, DisabledFeatureDoesNotRegisterTheCodec) {
+    EXPECT_FALSE(cv::haveImageWriter(".webp"));
+}
+#endif
+#endif
diff --git a/tools/_files.py b/tools/_files.py
new file mode 100644
index 0000000..888c3b7
--- /dev/null
+++ b/tools/_files.py
@@ -0,0 +1,8 @@
+"""Preserve timestamps of unchanged generated build inputs."""
+from pathlib import Path
+
+
+def write_if_changed(path: Path, text: str):
+    if path.exists() and path.read_text(encoding="utf-8") == text:
+        return
+    path.write_text(text, encoding="utf-8", newline="\n")
diff --git a/tools/audit_api.py b/tools/audit_api.py
new file mode 100644
index 0000000..e4c591e
--- /dev/null
+++ b/tools/audit_api.py
@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""Inventory facade-visible upstream C++ declarations with the resolved Clang.
+
+This is an audit, not the Python binding parser. It includes namespace-level
+classes/templates, overloads, aliases, unscoped enumerators and global helpers.
+Header coverage is reported separately: an existing facade cannot prove that
+headers it does not include are covered. Raw ASTs stay under target/.
+"""
+import argparse
+import json
+from pathlib import Path
+import re
+import subprocess
+
+
+KINDS = {"CXXRecordDecl", "RecordDecl", "ClassTemplateDecl", "FunctionTemplateDecl",
+         "FunctionDecl", "TypedefDecl", "TypeAliasDecl", "TypeAliasTemplateDecl",
+         "EnumDecl", "VarDecl", "UsingDecl"}
+
+
+def namespace_const(node):
+    """Recognize namespace-level const objects with implicit internal linkage.
+
+    Clang omits storageClass on these. Pointee constness does not make a
+    pointer/reference object const; aliases use their desugared type.
+    """
+    if node.get("inline") or node.get("storageClass") == "extern":
+        return False
+    type_ = node.get("type", {})
+    spelling = type_.get("desugaredQualType", type_.get("qualType", ""))
+    spelling = re.sub(r"(?:\[[^]]*\])+$", "", spelling).strip()
+    if "&" in spelling:
+        return False
+    if "*" in spelling:
+        pointer = re.search(r"\([^)]*\*([^)]*)\)", spelling)
+        tail = pointer[1] if pointer else spelling.rsplit("*", 1)[1]
+        return "const" in tail.split()
+    return spelling.startswith("const ") or spelling.endswith(" const")
+
+
+def compiler_flags(entry, keep_modules=False):
+    arguments = entry["arguments"]
+    flags = []
+    number = 1
+    while number < len(arguments):
+        flag = arguments[number]
+        if flag in {"-o", "-MF", "-MT", "-MQ", "-x"}:
+            number += 2
+            continue
+        if (flag in {"-c", "-MMD", "-MD"} or flag == entry["file"] or flag.startswith("-fmodule-output")
+                or (not keep_modules and flag.startswith(
+                    ("-fmodule-file=", "-fprebuilt-module-path=", "-fmodule-mapper=")))):
+            number += 1
+            continue
+        flags.append(flag)
+        number += 1
+    return flags
+
+
+def optional_simd_facades(root, commands, active_arguments):
+    # CDBs can retain commands for previously enabled optional source files.
+    # The active root's feature flags, not file presence alone, select this API.
+    if "-DMCPP_FEATURE_SIMD" not in active_arguments:
+        return []
+    result = []
+    compiled = {Path(item["file"]).resolve() for item in commands}
+    for source, module in (("simd", "core.simd"), ("simd_legacy", "core.simd.legacy")):
+        path = root / "src/detail" / (source + ".cppm")
+        assert path in compiled, f"Active SIMD facade has no compile command: {path}"
+        result.append((module, path))
+    return result
+
+
+def ast_declarations(lines, capture=None):
+    """Read one top-level Clang declaration at a time, not the huge TU tree.
+
+    Clang's JSON printer indents translation-unit children four spaces.
+    Class/function bodies remain inside their containing declaration, so peak
+    memory is bounded by one declaration rather than the entire standard library.
+    """
+    block = None
+    for line in lines:
+        if capture:
+            capture.write(line)
+        if block is None:
+            if line.startswith("    {"):
+                block = [line]
+            continue
+        block.append(line)
+        if line.rstrip() in ("    }", "    },"):
+            text = "".join(block).rstrip().removesuffix(",")
+            block = None
+            yield json.loads(text)
+    assert block is None, "Truncated AST declaration"
+
+
+def inventory(declarations, root):
+    entities = {}
+    last_file = ""
+    namespaces = {}
+    imports = []
+    variable_linkage = {}
+
+    def restore_locations(value):
+        """Clang elides repeated file names across the entire JSON stream.
+
+        Traverse every location, including class/function bodies and ranges,
+        before filtering declarations. includedFrom is an include-stack hint,
+        not the physical source location and must not update the cursor.
+        """
+        nonlocal last_file
+        if isinstance(value, list):
+            for child in value:
+                restore_locations(child)
+        elif isinstance(value, dict):
+            if "offset" in value:
+                if value.get("file"):
+                    last_file = value["file"]
+                elif last_file:
+                    value["file"] = last_file
+            for key, child in value.items():
+                if key != "includedFrom":
+                    restore_locations(child)
+
+    def source_file(node, parent_file):
+        loc = node.get("loc", {})
+        # Macro-created declaration names belong to their expansion header.
+        loc = loc.get("expansionLoc", loc)
+        file = loc.get("file") or parent_file
+        return file, loc.get("line")
+
+    def visit(nodes, namespace="", parent_file="", namespace_ids=None):
+        namespace_ids = namespace_ids or set()
+        for node in nodes:
+            kind = node.get("kind")
+            file, line = source_file(node, parent_file)
+            if kind == "NamespaceDecl":
+                name = node.get("name", "")
+                if not name:
+                    continue  # anonymous namespaces cannot be imported by name
+                path = namespace if node.get("isInline") else "::".join(filter(None, (namespace, name)))
+                namespaces[node.get("id")] = path
+                # Source ownership below filters standard-library internals,
+                # while preserving cvflann and OpenCV-owned std extensions.
+                visit(node.get("inner", []), path, file, {node.get("id")})
+                continue
+            if kind == "UsingDirectiveDecl":
+                target = node.get("nominatedNamespace", {})
+                if namespace.startswith("cv"):
+                    imports.append((namespace, target.get("id"), target.get("name", "")))
+                continue
+            if kind == "LinkageSpecDecl":
+                visit(node.get("inner", []), namespace, file, namespace_ids)
+                continue
+            if kind not in KINDS or node.get("isImplicit"):
+                continue
+            if node.get("parentDeclContextId") and node["parentDeclContextId"] not in namespace_ids:
+                continue  # an out-of-line class member rides with its class
+            if not file:
+                continue
+            variable_internal = False
+            if kind == "VarDecl":
+                previous = node.get("previousDecl")
+                variable_internal = variable_linkage.get(previous,
+                    node.get("storageClass") == "static" or namespace_const(node))
+                if node.get("id"):
+                    variable_linkage[node["id"]] = variable_internal
+            try:
+                relative = Path(file).resolve().relative_to(root / "upstream/opencv")
+            except ValueError:
+                continue
+            match = re.match(r"modules/([^/]+)/include/", relative.as_posix())
+            if not match or "/private" in relative.as_posix() or ".private." in relative.name:
+                continue
+            name = node.get("name", "")
+            if kind == "UsingDecl":
+                name = name.rsplit("::", 1)[-1]
+
+            def add(leaf, decl):
+                if not leaf or leaf.startswith("__") or (not leaf.isidentifier() and not leaf.startswith("operator")):
+                    return
+                qualified = "::".join(filter(None, (namespace, leaf)))
+                item = entities.setdefault(qualified, {"kinds": set(), "headers": set(), "signatures": set(),
+                                                       "modules": set(), "internal-linkage": False})
+                item["kinds"].add(decl["kind"])
+                item["headers"].add(relative.as_posix())
+                item["modules"].add(match[1])
+                if decl.get("type", {}).get("qualType"):
+                    item["signatures"].add(decl["type"]["qualType"])
+                if decl["kind"] in {"FunctionTemplateDecl", "TypeAliasTemplateDecl"}:
+                    for child in decl.get("inner", []):
+                        if child.get("kind") in {"FunctionDecl", "TypeAliasDecl"} and child.get("type", {}).get("qualType"):
+                            item["signatures"].add(child["type"]["qualType"])
+                item["internal-linkage"] |= variable_internal or decl.get("storageClass") == "static" or any(
+                    child.get("storageClass") == "static" for child in decl.get("inner", [])
+                    if child.get("kind") == "FunctionDecl")
+
+            add(name, node)
+            if kind == "EnumDecl" and not node.get("scopedEnumTag"):
+                for child in node.get("inner", []):
+                    if child.get("kind") == "EnumConstantDecl":
+                        add(child.get("name", ""), child)
+    for node in declarations:
+        restore_locations(node)
+        visit([node])
+        del node
+    aliases = []
+    for public, identifier, name in imports:
+        canonical = namespaces.get(identifier, public + "::" + name)
+        if canonical != public and canonical.startswith(public + "::"):
+            aliases.append((canonical, public))
+    for name, item in entities.items():
+        public_names, pending = {name}, [name]
+        while pending:
+            candidate = pending.pop()
+            for canonical, public in aliases:
+                if candidate.startswith(canonical + "::"):
+                    alias = public + candidate[len(canonical):]
+                    if alias not in public_names:
+                        public_names.add(alias)
+                        pending.append(alias)
+        item["public-name"] = min(public_names, key=lambda value: (value.count("::"), len(value)))
+    return {name: {key: sorted(value) if isinstance(value, set) else value for key, value in item.items()}
+            for name, item in sorted(entities.items())}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--commands", type=Path, default=Path("compile_commands.json"))
+    parser.add_argument("--output", type=Path, default=Path("target/api-audit/inventory.json"))
+    parser.add_argument("--reuse-ast", action="store_true", help="re-analyze the same captured AST during audit development")
+    parser.add_argument("--keep-ast", action="store_true", help="retain the large raw compiler AST; normally it is streamed")
+    parser.add_argument("--verify-exports", action="store_true",
+                        help="compile an import-only consumer for every listed export using resolved test BMIs")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    commands = json.loads(args.commands.read_text())
+    entry = next(item for item in commands if item["file"].endswith("/src/core.cppm"))
+    assert "clang" in Path(entry["arguments"][0]).name, "Capture an all-modules Clang build first"
+    for module in (root / "port/config/modules.txt").read_text().split():
+        if module != "core":
+            assert "-DHAVE_OPENCV_" + module.upper() in entry["arguments"], "Use --features all-modules"
+    work = root / "target/api-audit"
+    work.mkdir(parents=True, exist_ok=True)
+    probe = work / "upstream.cpp"
+    prefixes = []
+    for module in (root / "port/config/modules.txt").read_text().split():
+        facade = root / "src/detail" / (module + ".cppm")
+        if not facade.exists():
+            facade = root / "src" / (module + ".cppm")
+        source = facade.read_text()
+        prefixes.append(source.split("export module", 1)[0].replace("module;", ""))
+    optional_facades = []
+    for module, facade in optional_simd_facades(root, commands, entry["arguments"]):
+        source = facade.read_text()
+        prefixes.append(source.split("export module", 1)[0].replace("module;", ""))
+        optional_facades.append(module)
+    probe.write_text("\n".join(prefixes))
+    ast_path, includes_path = work / "upstream.ast.json", work / "includes.log"
+    if not args.reuse_ast:
+        command = [entry["arguments"][0], *compiler_flags(entry), "-x", "c++", "-H",
+                   "-fsyntax-only", "-Xclang", "-ast-dump=json", str(probe)]
+        print("Auditing the exact resolved Clang/header configuration", flush=True)
+        with includes_path.open("w") as err:
+            with subprocess.Popen(command, cwd=root, stdout=subprocess.PIPE, stderr=err, text=True) as process:
+                if args.keep_ast:
+                    with ast_path.open("w") as capture:
+                        entities = inventory(ast_declarations(process.stdout, capture), root)
+                else:
+                    entities = inventory(ast_declarations(process.stdout), root)
+                code = process.wait()
+        if code:
+            raise SystemExit(includes_path.read_text()[-12000:])
+    else:
+        with ast_path.open() as source:
+            entities = inventory(ast_declarations(source), root)
+    using_names = set()
+    for path in list((root / "src/gen_exports").glob("*.inc")) + list((root / "src").glob("*.cppm")):
+        using_names.update(re.findall(r"^\s*(?:export\s+)?using\s+(?:::)?([A-Za-z_][^;\s]*)\s*;", path.read_text(), re.M))
+    if "core.simd" in optional_facades:
+        from simd_surface import enabled_names
+        using_names.update(enabled_names(root, commands, compiler_flags))
+    for name, item in entities.items():
+        item["listed-export"] = name in using_names or item["public-name"] in using_names
+    loaded = set()
+    for line in includes_path.read_text().splitlines():
+        match = re.match(r"\.+ (.+?)(?: \(.*\))?$", line)
+        if match:
+            try:
+                loaded.add(Path(match[1]).resolve().relative_to(root / "upstream/opencv").as_posix())
+            except ValueError:
+                pass
+    headers = {}
+    for path in sorted((root / "upstream/opencv/modules").glob("*/include/opencv2/**/*")):
+        if path.suffix not in {".hpp", ".h"} or not path.is_file():
+            continue
+        relative = path.relative_to(root / "upstream/opencv").as_posix()
+        if "/private" in relative or ".private." in relative:
+            headers[relative] = "private-implementation"
+        else:
+            headers[relative] = "loaded" if relative in loaded else "not-in-facade"
+    profile = {"target": Path(entry["directory"]).parent.name,
+               "compiler": Path(entry["arguments"][0]).name,
+               "features": sorted({flag.removeprefix("-DMCPP_FEATURE_").lower().replace("_", "-")
+                                   for flag in entry["arguments"] if flag.startswith("-DMCPP_FEATURE_")})}
+    report = {"opencv": "5.0.0", "profile": profile,
+              "scope": "Declarations visible from current facades; not-in-facade headers still require review",
+              "entities": entities, "headers": headers}
+    report["optional-facades"] = optional_facades
+    if args.verify_exports:
+        consumer = next((item for item in commands if item["file"].endswith("/tests/main_modules_test.cpp")), None)
+        assert consumer is not None, "Run an all-modules Clang test first to capture the consumer compile command"
+        probe = work / "exports.cpp"
+        probe.write_text("import mcpplibs.mwrap.opencv;\n" + "\n".join(
+            f"namespace export_probe_{number} {{ using ::{name}; }}"
+            for number, name in enumerate(sorted(using_names))) + "\n")
+        command = [consumer["arguments"][0], *compiler_flags(consumer, keep_modules=True),
+                   "-x", "c++", "-fsyntax-only", str(probe)]
+        result = subprocess.run(command, cwd=root, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        (work / "export-consumer.log").write_text(result.stdout)
+        if result.returncode:
+            raise SystemExit(result.stdout)
+        verified_modules = []
+        for module in (root / "port/config/modules.txt").read_text().split():
+            module_names = set(re.findall(r"^\s*(?:export\s+)?using\s+(?:::)?([A-Za-z_][^;\s]*)\s*;",
+                                         (root / "src/gen_exports" / (module + ".inc")).read_text(), re.M))
+            probe.write_text("import mcpplibs.mwrap.opencv." + module + ";\n" +
+                             "void core_visibility() { cv::Mat image; cv::Point point; cv::Size size; }\n" +
+                             "\n".join(f"namespace export_probe_{number} {{ using ::{name}; }}"
+                                       for number, name in enumerate(sorted(module_names))) + "\n")
+            result = subprocess.run(command, cwd=root, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+            with (work / "export-consumer.log").open("a") as log:
+                log.write(f"\nDirect import {module}: {len(module_names)} own export names\n" + result.stdout)
+            if result.returncode:
+                raise SystemExit(f"Direct import failed: {module}\n" + result.stdout)
+            verified_modules.append(module)
+        report["export-consumer"] = {"verified-names": len(using_names),
+                                     "verified-direct-modules": verified_modules,
+                                     "scope": "Root/direct-module name lookup and core dependency visibility; not overload instantiation or behavior coverage"}
+        print(f"Import-only consumers resolved all {len(using_names)} listed root exports and {len(verified_modules)} direct module surfaces")
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n")
+    unlisted = sum(not item["listed-export"] for item in entities.values())
+    print(f"Inventoried {len(entities)} namespace/global entities; {unlisted} are not in export-using lists")
+    print("Manual adapters must be verified by a module consumer; an absent using-list entry alone is not proof of a missing API")
+    print(f"Header candidates: {len(headers)}; {sum(value == 'not-in-facade' for value in headers.values())} not in facades; "
+          f"{sum(value == 'private-implementation' for value in headers.values())} private implementation headers")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/check_cpp_contracts.py b/tools/check_cpp_contracts.py
new file mode 100644
index 0000000..bb8f830
--- /dev/null
+++ b/tools/check_cpp_contracts.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Check imported makePtr retains the upstream custom-deleter rejection."""
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+
+from audit_api import compiler_flags
+
+ROOT = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--commands", type=Path, default=ROOT / "compile_commands.json")
+args = parser.parse_args()
+commands = json.loads(args.commands.read_text())
+entry = next(item for item in commands if Path(item["file"]).name == "core_cpp_types_test.cpp")
+flags = compiler_flags(entry, keep_modules=True)
+with tempfile.TemporaryDirectory(prefix="opencv-cpp-contract-") as directory:
+    probe = Path(directory) / "contract.cpp"
+    def compile_source(source):
+        # GCC requires textual standard-library RTTI declarations while
+        # instantiating shared_ptr from an imported global-module definition.
+        probe.write_text('#include <memory>\n' + source)
+        return subprocess.run([entry["arguments"][0], *flags, "-fsyntax-only", str(probe)],
+                              cwd=entry["directory"], text=True, stdout=subprocess.PIPE,
+                              stderr=subprocess.STDOUT)
+    positive = compile_source('import mcpplibs.mwrap.opencv.core;\nint main() { return *cv::makePtr<int>(7); }\n')
+    assert positive.returncode == 0, positive.stdout
+    negative = compile_source('''import mcpplibs.mwrap.opencv.core;
+struct CustomResource {};
+namespace cv {
+template<> struct DefaultDeleter<CustomResource> {
+    void operator()(CustomResource* value) const { delete value; }
+};
+}
+static_assert(cv::has_custom_delete<CustomResource>::value);
+int main() { auto pointer = cv::makePtr<CustomResource>(); }
+''')
+    assert negative.returncode != 0, "makePtr accepted a custom DefaultDeleter"
+    assert "Can't use this makePtr with custom DefaultDeleter" in negative.stdout, negative.stdout
+print("Imported makePtr accepts ordinary types and rejects custom DefaultDeleter types")
diff --git a/tools/check_dnn_compat.py b/tools/check_dnn_compat.py
new file mode 100644
index 0000000..87061c9
--- /dev/null
+++ b/tools/check_dnn_compat.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Compare original DNN Arg equality and unavailable legacy backend behavior."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp", default="mcpp")
+parser.add_argument("--toolchain")
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-dnn-compat-oracle-") as directory:
+    command = [args.mcpp, "test", "dnn_compat", "--features", "all-modules,simd-emulated",
+               "--strict", "--timeout", "120"]
+    if args.toolchain:
+        command += ["--toolchain", args.toolchain]
+    subprocess.run(command, cwd=Path(__file__).resolve().parents[1],
+                   env=dict(os.environ, OPENCV_M_DNN_COMPAT_OUTPUT=directory), check=True)
+    sdk = (Path(directory) / "sdk.txt").read_bytes()
+    module = (Path(directory) / "module.txt").read_bytes()
+    assert sdk and sdk == module, "DNN compatibility behavior differs from original SDK"
+    print(f"SDK and module DNN equality/backend contracts match ({len(sdk)} bytes)")
diff --git a/tools/check_entity_review.py b/tools/check_entity_review.py
new file mode 100644
index 0000000..4ef984c
--- /dev/null
+++ b/tools/check_entity_review.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Validate exact source-reviewed rejections from the import-only API probe.
+
+Coverage of reviewed rejections is not overload or runtime completeness.
+"""
+import argparse
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+import tomllib
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--inventory", type=Path, default=ROOT / "target/api-audit/inventory.json")
+    parser.add_argument("--probe", type=Path, default=ROOT / "target/api-audit/unlisted-import-probe/report.json")
+    parser.add_argument("--require-complete", action="store_true", help="also reject explicit public-gap decisions")
+    args = parser.parse_args()
+    review = tomllib.loads((ROOT / "port/api/entity-review.toml").read_text())
+    inventory = json.loads(args.inventory.read_text())
+    probe = json.loads(args.probe.read_text())
+    assert review["schema"] == 1 and review["upstream-version"] == inventory["opencv"]
+    assert probe["profile"] == inventory["profile"], "Inventory/probe profiles differ"
+    features = set(probe["profile"]["features"])
+    assert "all-modules" in features, "Review the complete main-module inventory"
+    rejected = set(probe["not-visible"])
+    recorded, active, counts, gaps = set(), set(), Counter(), []
+    for group in review["groups"]:
+        assert group["decision"] in {"upstream-internal", "binding-only", "cuda-sdk", "public-gap"}, group
+        assert group["reason"].strip() and group["evidence"] and group["names"], group
+        source = ROOT / "upstream/opencv" / group["source"]
+        assert source.resolve().is_relative_to((ROOT / "upstream/opencv").resolve()), source
+        data = source.read_bytes()
+        assert hashlib.sha256(data).hexdigest() == group["source-sha256"], f"Re-review changed SDK source: {source}"
+        assert all(anchor in data.decode() for anchor in group["evidence"]), source
+        names = set(group["names"])
+        assert len(names) == len(group["names"]) and not names & recorded, "Duplicate reviewed name"
+        recorded.update(names)
+        if not set(group.get("features", [])) <= features:
+            continue
+        if set(group.get("without-features", [])) & features:
+            continue
+        if group.get("when-header-loaded") and inventory["headers"].get(group["source"]) != "loaded":
+            continue
+        for name in names:
+            assert name in inventory["entities"], f"Reviewed name absent from active inventory: {name}"
+            assert group["source"] in inventory["entities"][name]["headers"], name
+        assert names <= rejected, f"Remove stale exclusions for newly visible names: {sorted(names - rejected)}"
+        active.update(names)
+        counts[group["decision"]] += len(names)
+        if group["decision"] == "public-gap":
+            gaps.extend(names)
+    assert rejected == active, f"Unreviewed rejected names: {sorted(rejected - active)}"
+    print(f"Source-reviewed rejected names: {len(active)}; decisions: {json.dumps(dict(sorted(counts.items())))}")
+    print("Each rejection has exact names, a reason, pinned source hash and literal source evidence")
+    print("This check does not certify visible overloads, runtime backends or other-ISA header coverage")
+    if args.require_complete and gaps:
+        raise SystemExit("Unfinished public entity decisions:\n" + "\n".join(sorted(gaps)))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/check_fp_state.py b/tools/check_fp_state.py
new file mode 100644
index 0000000..84b73ab
--- /dev/null
+++ b/tools/check_fp_state.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""Compare independent SDK/import consumers of qualified FP state APIs."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+parser=argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp",default="mcpp")
+parser.add_argument("--toolchain")
+args=parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-fp-state-oracle-") as directory:
+    command=[args.mcpp,"test","fp_state","--features","all-modules,simd-emulated","--strict","--timeout","120"]
+    if args.toolchain:
+        command += ["--toolchain",args.toolchain]
+    subprocess.run(command,cwd=Path(__file__).resolve().parents[1],
+                   env=dict(os.environ,OPENCV_M_FP_OUTPUT=directory),check=True)
+    sdk=(Path(directory)/"sdk.txt").read_bytes()
+    module=(Path(directory)/"module.txt").read_bytes()
+    assert sdk and sdk==module,"FP state behavior differs from the original SDK"
+    print(f"SDK and module FP state/opaque videoio API match ({len(sdk)} bytes)")
diff --git a/tools/check_header_review.py b/tools/check_header_review.py
new file mode 100644
index 0000000..400e251
--- /dev/null
+++ b/tools/check_header_review.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Check explicit pinned-header review coverage without hiding public gaps."""
+import argparse
+from collections import Counter
+import json
+from pathlib import Path
+import re
+import tomllib
+
+ROOT = Path(__file__).resolve().parents[1]
+DECISIONS = {"cuda-sdk", "public-gap", "partial", "partial-native", "runtime-internal", "forwarder", "platform-sdk",
+             "parallel-sdk", "upstream-internal", "implementation", "textual-only",
+             "binding-only", "implemented", "typed-mapped", "documentation"}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--inventory", type=Path, default=ROOT / "target/api-audit/inventory.json")
+    parser.add_argument("--require-complete", action="store_true",
+                        help="fail while reviewed public API gaps remain; use for full-support acceptance")
+    args = parser.parse_args()
+    review = tomllib.loads((ROOT / "port/api/header-review.toml").read_text())
+    assert review["schema"] == 1 and review["upstream-version"] == "5.0.0"
+    inventory = json.loads(args.inventory.read_text())
+    assert inventory["opencv"] == review["upstream-version"]
+    records, counts, gaps = {}, Counter(), []
+    for group in review["groups"]:
+        decision = group["decision"]
+        assert decision in DECISIONS and group["reason"].strip(), group
+        for header in group["headers"]:
+            assert header not in records, f"Duplicate review: {header}"
+            assert header in inventory["headers"], f"Unknown review: {header}"
+            path = ROOT / "upstream/opencv" / header
+            assert path.is_file(), header
+            records[header] = decision
+            counts[decision] += 1
+            if decision in {"public-gap", "partial", "partial-native"}:
+                gaps.append(header)
+            if decision == "implemented":
+                assert inventory["headers"][header] == "loaded", f"Implemented facade header not loaded: {header}"
+            if decision == "forwarder":
+                source = re.sub(r"/\*.*?\*/|//[^\n]*", "", path.read_text(), flags=re.S)
+                assert "#include" in source and all(
+                    not line.strip() or line.lstrip().startswith("#") for line in source.splitlines()), header
+    missing = sorted(header for header, status in inventory["headers"].items()
+                     if status == "not-in-facade" and header not in records)
+    assert not missing, f"Unreviewed headers: {missing}"
+    print("Reviewed header decisions:", json.dumps(dict(sorted(counts.items()))))
+    print(f"Unfinished public API acceptance records: {len(gaps)}; review coverage is not implementation coverage")
+    if args.require_complete and gaps:
+        raise SystemExit("Full-support acceptance still has public gaps:\n" + "\n".join(gaps))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/check_interface_flags.py b/tools/check_interface_flags.py
new file mode 100644
index 0000000..b5ae1b3
--- /dev/null
+++ b/tools/check_interface_flags.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Reject private x86 ISA flags on public/internal wrapper module BMIs."""
+import json
+from pathlib import Path
+import re
+
+root = Path(__file__).resolve().parents[1]
+commands = json.loads((root / "compile_commands.json").read_text())
+checked = 0
+failures = []
+for entry in commands:
+    path = Path(entry["file"]).resolve()
+    if path.suffix != ".cppm" or not path.is_relative_to(root / "src"):
+        continue
+    checked += 1
+    flags = [flag for flag in entry["arguments"] if re.match(r"-m(?:sse|avx|arch=)", flag)]
+    if flags:
+        failures.append(f"{path.relative_to(root)}: {', '.join(flags)}")
+if not checked:
+    raise SystemExit("No wrapper module compile commands found; build first")
+if failures:
+    raise SystemExit("Non-baseline wrapper module flags:\n" + "\n".join(failures))
+print(f"Verified baseline ISA flags for {checked} wrapper module interfaces")
diff --git a/tools/check_mat_aug.py b/tools/check_mat_aug.py
new file mode 100644
index 0000000..58a3b11
--- /dev/null
+++ b/tools/check_mat_aug.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Compare SDK/import Mat assignments, expressions and operand conversions."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp", default="mcpp")
+parser.add_argument("--toolchain")
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-mat-aug-oracle-") as directory:
+    command = [args.mcpp, "test", "mat_aug", "--features", "all-modules,simd-emulated",
+               "--strict", "--timeout", "120"]
+    if args.toolchain:
+        command += ["--toolchain", args.toolchain]
+    subprocess.run(command, cwd=Path(__file__).resolve().parents[1],
+                   env=dict(os.environ, OPENCV_M_MAT_AUG_OUTPUT=directory), check=True)
+    sdk = (Path(directory) / "sdk.txt").read_bytes()
+    module = (Path(directory) / "module.txt").read_bytes()
+    assert sdk and sdk == module, "Mat assignment behavior differs from original SDK"
+    assert len(sdk.splitlines()) == 130, "114 assignments, signature marker and 14 conversion/initializer cases/marker required"
+    print(f"SDK and module Mat assignments/conversions match ({len(sdk)} bytes; 114 assignment cases)")
diff --git a/tools/check_matx_templates.py b/tools/check_matx_templates.py
new file mode 100644
index 0000000..cb75a12
--- /dev/null
+++ b/tools/check_matx_templates.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Compare original SDK and imported Matx/Vec template-call contracts."""
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+from audit_api import compiler_flags
+
+ROOT = Path(__file__).resolve().parents[1]
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp", default="mcpp")
+parser.add_argument("--toolchain")
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-matx-template-oracle-") as directory:
+    command = [args.mcpp, "test", "matx_templates", "--strict", "--timeout", "120"]
+    if args.toolchain:
+        command += ["--toolchain", args.toolchain]
+    subprocess.run(command, cwd=ROOT,
+                   env=dict(os.environ, OPENCV_M_MATX_OUTPUT=directory), check=True)
+    sdk = (Path(directory) / "sdk.txt").read_bytes()
+    module = (Path(directory) / "module.txt").read_bytes()
+    assert sdk and sdk == module, "Matx/Vec template results differ from original SDK"
+    print(f"Original SDK and module Matx/Vec results match ({len(sdk)} bytes)")
+    commands = json.loads((ROOT / "compile_commands.json").read_text())
+    consumer = next(entry for entry in commands if Path(entry["file"]).name == "matx_templates_test.cpp")
+    output = ROOT / "target/api-audit/matx-templates"
+    output.mkdir(parents=True, exist_ok=True)
+    invalid = {
+        "determinant-dimension": "cv::Matx33f m; (void)cv::determinant<float,2>(m);",
+        "product-dimension": "cv::Matx<float,2,3> a; cv::Matx<float,3,2> b; (void)cv::operator*<float,2,3,3>(a,b);",
+        "const-augmentation": "const cv::Matx22f a; cv::Matx22f b; (void)cv::operator+=<float,float,2,2>(a,b);",
+    }
+    for name, body in invalid.items():
+        for label, preamble in (("sdk", "#include <opencv2/core.hpp>\n"),
+                                ("module", "import mcpplibs.mwrap.opencv.core;\n")):
+            probe = output / (name + "-" + label + ".cpp")
+            probe.write_text(preamble + "void probe() { " + body + " }\n")
+            result = subprocess.run([consumer["arguments"][0],
+                                     *compiler_flags(consumer, keep_modules=label == "module"),
+                                     "-x", "c++", "-fsyntax-only", str(probe)],
+                                    cwd=consumer["directory"], capture_output=True, text=True)
+            diagnostics = result.stdout + result.stderr
+            probe.with_suffix(".log").write_text(diagnostics)
+            assert result.returncode > 0 and "error:" in diagnostics, diagnostics
+            assert not any(marker in diagnostics for marker in
+                           ("frontend command failed", "internal compiler error", "PLEASE ATTACH", "Stack dump:")), diagnostics
+    print("SDK/import contracts reject wrong determinant/product dimensions and const augmentation")
diff --git a/tools/check_mwrap_release.py b/tools/check_mwrap_release.py
new file mode 100644
index 0000000..9bedddb
--- /dev/null
+++ b/tools/check_mwrap_release.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Check the immutable mwrap release coordinate and bilingual entry pages."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import tomllib
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--tag', help='release tag; omitted during PR checks')
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    package = tomllib.loads((root / 'mcpp.toml').read_text(encoding="utf-8"))['package']
+    assert package['namespace'] == 'mcpplibs.mwrap', package
+    assert re.fullmatch(r'[A-Za-z_][A-Za-z_0-9]*', package['name']), package['name']
+    upstream = package['metadata']['mwrap']['upstream-version']
+    version = package['version']
+    assert version == upstream or re.fullmatch(re.escape(upstream) + r'\.[1-9][0-9]*', version), (version, upstream)
+    if args.tag:
+        assert args.tag == 'mwrap-' + version, (args.tag, version)
+    assert package['license'] == 'Apache-2.0', package['license']
+    assert package['authors'] == ['mcpp-community'], package.get('authors')
+    license_text = (root / 'LICENSE').read_text(encoding='utf-8')
+    assert 'Apache License' in license_text and 'Version 2.0' in license_text
+    assert 'mcpp-community' in (root / 'NOTICE').read_text(encoding='utf-8')
+    documents = json.loads((root / 'upstream/documents.json').read_text(encoding='utf-8'))['documents']
+    assert any(Path(d['path']).name.startswith('README') for d in documents)
+    assert any(Path(d['path']).name.startswith(('LICENSE', 'COPYING')) for d in documents)
+    deployed = {entry['from'] for entry in tomllib.loads((root / 'mcpp.toml').read_text(encoding='utf-8')).get('runtime', {}).get('deploy', [])}
+    assert {'LICENSE', 'NOTICE'} <= deployed
+    for document in documents:
+        path = Path(document['path'])
+        assert not path.is_absolute() and '..' not in path.parts and path.parts[0] == 'upstream'
+        assert hashlib.sha256((root / path).read_bytes()).hexdigest() == document['sha256'], path
+        assert document['source'] and path.as_posix() in deployed, path
+    identity = package['namespace'] + '.' + package['name']
+    for name, other in [('README.md', 'README.zh.md'), ('README.zh.md', 'README.md')]:
+        text = (root / name).read_text(encoding="utf-8")
+        assert len(text.splitlines()) <= 150, name
+        assert '](' + other + ')' in '\n'.join(text.splitlines()[:12]), name
+        assert identity in text and version in text, name
+        assert text.count('```') % 2 == 0, name
+    print(identity + '@' + version)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/check_persistence_format.py b/tools/check_persistence_format.py
new file mode 100644
index 0000000..910842d
--- /dev/null
+++ b/tools/check_persistence_format.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Compare independent native-header and module SDK serialization consumers."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+ROOT = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument('--mcpp', default='mcpp')
+parser.add_argument('--toolchain')
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix='opencv-persistence-format-') as directory:
+    command = [args.mcpp, 'test', 'persistence', '--features', 'all-modules', '--strict', '--timeout', '120']
+    if args.toolchain:
+        command += ['--toolchain', args.toolchain]
+    env = dict(os.environ, OPENCV_M_PERSISTENCE_OUTPUT=directory)
+    subprocess.run(command, cwd=ROOT, env=env, check=True)
+    for format in ('yaml', 'xml', 'json', 'yaml-base64', 'xml-base64', 'json-base64'):
+        sdk = (Path(directory) / f'sdk-{format}.txt').read_bytes()
+        module = (Path(directory) / f'module-{format}.txt').read_bytes()
+        assert sdk and sdk == module, f'{format}: module serialization differs from the pinned SDK'
+        print(f'{format}: native SDK and module output match ({len(sdk)} bytes)')
diff --git a/tools/check_simd.py b/tools/check_simd.py
new file mode 100644
index 0000000..8fb1e2d
--- /dev/null
+++ b/tools/check_simd.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Compare original-header and import-only SIMD consumers on the same target."""
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+from audit_api import compiler_flags
+
+ROOT = Path(__file__).resolve().parents[1]
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp", default="mcpp")
+parser.add_argument("--toolchain")
+parser.add_argument("--emulated", action="store_true", help="select the original SDK software implementation")
+parser.add_argument("--profile", default="dev", choices=("dev", "release", "dist"))
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-simd-oracle-") as directory:
+    command = [args.mcpp, "test", "simd", "--features", "simd-emulated" if args.emulated else "simd", "--profile", args.profile,
+               "--strict", "--timeout", "120"]
+    if args.toolchain:
+        command += ["--toolchain", args.toolchain]
+    subprocess.run(command, cwd=Path(__file__).resolve().parents[1],
+                   env=dict(os.environ, OPENCV_M_SIMD_OUTPUT=directory), check=True)
+    sdk = (Path(directory) / "sdk.txt").read_bytes()
+    module = (Path(directory) / "module.txt").read_bytes()
+    assert sdk and sdk == module, "SIMD results differ from original SDK"
+    print(f"Original SDK and module SIMD results match ({len(sdk)} bytes)")
+    legacy_sdk = (Path(directory) / "sdk-legacy.txt").read_bytes()
+    legacy_module = (Path(directory) / "module-legacy.txt").read_bytes()
+    assert legacy_sdk and legacy_sdk == legacy_module, "Legacy SIMD operators differ from original SDK"
+    print(f"All 21 original legacy operators match SDK behavior ({len(legacy_sdk)} bytes)")
+    subprocess.run([os.sys.executable, str(Path(__file__).with_name("check_simd_surface.py"))], check=True)
+    commands = json.loads((ROOT / "compile_commands.json").read_text())
+    consumer = next(entry for entry in commands if Path(entry["file"]).name == "simd_test.cpp")
+    for module_name in ("mcpplibs.mwrap.opencv.core.simd", "mcpplibs.mwrap.opencv"):
+        probe = Path(directory) / "legacy-opt-in.cpp"
+        probe.write_text("import " + module_name + ";\nusing cv::hal::operator+;\n")
+        result = subprocess.run([consumer["arguments"][0], *compiler_flags(consumer, keep_modules=True),
+                                 "-x", "c++", "-fsyntax-only", str(probe)],
+                                cwd=consumer["directory"], capture_output=True, text=True)
+        diagnostics = result.stdout + result.stderr
+        assert result.returncode > 0 and "operator+" in diagnostics, diagnostics
+        assert not any(value in diagnostics for value in ("frontend command failed", "internal compiler error", "Stack dump:")), diagnostics
+    print("Base SIMD and root imports keep legacy operators opt-in")
diff --git a/tools/check_simd_surface.py b/tools/check_simd_surface.py
new file mode 100644
index 0000000..c28d0bf
--- /dev/null
+++ b/tools/check_simd_surface.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Resolve every enabled SIMD export through direct and aggregate imports."""
+import json
+from pathlib import Path
+import subprocess
+
+from audit_api import compiler_flags
+from simd_surface import enabled_names
+
+ROOT = Path(__file__).resolve().parents[1]
+commands = json.loads((ROOT / "compile_commands.json").read_text())
+consumer = next(e for e in commands if Path(e["file"]).name == "simd_test.cpp")
+directory = ROOT / "target/api-audit/simd"
+directory.mkdir(parents=True, exist_ok=True)
+names = enabled_names(ROOT, commands, compiler_flags)
+for label, module in (("direct", "mcpplibs.mwrap.opencv.core.simd"), ("aggregate", "mcpplibs.mwrap.opencv")):
+    probe = directory / (label + ".cpp")
+    probe.write_text("import " + module + ";\n" + "\n".join(
+        f"namespace sdk_export_{i} {{ using ::{name}; }}" for i, name in enumerate(sorted(names))) + "\n")
+    result = subprocess.run([consumer["arguments"][0], *compiler_flags(consumer, keep_modules=True),
+                             "-x", "c++", "-fsyntax-only", str(probe)], cwd=consumer["directory"],
+                            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    (directory / (label + ".log")).write_text(result.stdout)
+    if result.returncode:
+        raise SystemExit(result.stdout)
+print(f"Resolved {len(names)} SIMD names through direct and aggregate imports")
+for label, preamble in (
+    ("sdk", "#if defined(MCPP_FEATURE_SIMD_EMULATED)\n#define CV_FORCE_SIMD128_CPP 1\n#endif\n#include <opencv2/core/simd_intrinsics.hpp>\n"),
+    ("module", "import mcpplibs.mwrap.opencv.core.simd;\n"),
+):
+    for function in ("v_setall", "vx_setall"):
+        probe = directory / (label + "-unsupported-" + function + ".cpp")
+        probe.write_text(preamble + "void probe() { (void)cv::" + function + "('x'); }\n")
+        result = subprocess.run([consumer["arguments"][0], *compiler_flags(consumer, keep_modules=label == "module"),
+                                 "-x", "c++", "-fsyntax-only", str(probe)], cwd=consumer["directory"],
+                                capture_output=True, text=True)
+        diagnostics = result.stdout + result.stderr
+        probe.with_suffix(".log").write_text(diagnostics)
+        assert result.returncode > 0 and "error:" in diagnostics, diagnostics
+        assert not any(marker in diagnostics for marker in
+                       ("frontend command failed", "internal compiler error", "Stack dump:")), diagnostics
+print("SDK/import broadcasts reject unsupported plain-char traits")
+if "cv::v_reg" in names:
+    # The pinned SDK itself has no V_TypeTraits<T>::reinterpret_uint. Preserve
+    # that template's visibility, and verify the same instantiation diagnostic
+    # independently on original headers and imports instead of deleting it.
+    for label, preamble in (
+        ("sdk", "#define CV_FORCE_SIMD128_CPP 1\n#include <opencv2/core/simd_intrinsics.hpp>\n"),
+        ("module", "import mcpplibs.mwrap.opencv.core.simd;\n"),
+    ):
+        probe = directory / (label + "-reinterpret-uint.cpp")
+        probe.write_text(preamble + "void probe() { cv::v_reg<float, 8> value; (void)cv::v_reinterpret_as_uint(value); }\n")
+        result = subprocess.run([consumer["arguments"][0], *compiler_flags(consumer, keep_modules=True),
+                                 "-x", "c++", "-fsyntax-only", str(probe)], cwd=consumer["directory"],
+                                capture_output=True, text=True)
+        diagnostics = result.stdout + result.stderr
+        (directory / (label + "-reinterpret-uint.log")).write_text(diagnostics)
+        assert result.returncode and "reinterpret_uint" in diagnostics, diagnostics
+    print("Original SDK and module preserve the pinned reinterpret_uint instantiation failure")
diff --git a/tools/check_upstream.py b/tools/check_upstream.py
new file mode 100644
index 0000000..c6e9389
--- /dev/null
+++ b/tools/check_upstream.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Verify every retained upstream file against the checksum-pinned archive."""
+import argparse
+import hashlib
+from pathlib import Path
+import tarfile
+import tomllib
+
+
+def main():
+    root = Path(__file__).resolve().parents[1]
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--archive", type=Path, default=root / "target/vendor-import/opencv-5.0.0.tar.gz")
+    parser.add_argument("--root", type=Path, default=root / "upstream/opencv")
+    args = parser.parse_args()
+    pin = tomllib.loads((root / "upstream/sources.lock.toml").read_text())["opencv"]
+    with args.archive.open("rb") as stream:
+        actual = hashlib.file_digest(stream, "sha256").hexdigest()
+    assert actual == pin["sha256"], (actual, pin["sha256"])
+    count = 0
+    with tarfile.open(args.archive) as archive:
+        for file in sorted(args.root.rglob("*")):
+            if not file.is_file() or "__pycache__" in file.parts:
+                continue
+            relative = file.relative_to(args.root)
+            member = archive.extractfile("opencv-" + pin["version"] + "/" + relative.as_posix())
+            assert member is not None and member.read() == file.read_bytes(), str(relative)
+            count += 1
+    print(f"Verified {count} retained files against OpenCV {pin['version']} archive SHA256 {actual}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/check_utility_helpers.py b/tools/check_utility_helpers.py
new file mode 100644
index 0000000..4854ca4
--- /dev/null
+++ b/tools/check_utility_helpers.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Compare independent header/module consumers of portable SDK helpers."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+ROOT = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--mcpp", default="mcpp")
+parser.add_argument("--toolchain")
+args = parser.parse_args()
+with tempfile.TemporaryDirectory(prefix="opencv-utility-oracle-") as directory:
+    command = [args.mcpp, "test", "utility_helpers", "--features", "all-modules", "--strict", "--timeout", "120"]
+    if args.toolchain:
+        command += ["--toolchain", args.toolchain]
+    env = dict(os.environ, OPENCV_M_UTILITY_OUTPUT=directory)
+    subprocess.run(command, cwd=ROOT, env=env, check=True)
+    sdk = (Path(directory) / "sdk.txt").read_bytes()
+    module = (Path(directory) / "module.txt").read_bytes()
+    assert sdk and sdk == module, "Portable helper results differ from the pinned SDK"
+    print(f"SDK/member and module helper results match ({len(sdk)} bytes)")
diff --git a/tools/curated/calib.txt b/tools/curated/calib.txt
new file mode 100644
index 0000000..c9024c8
--- /dev/null
+++ b/tools/curated/calib.txt
@@ -0,0 +1,14 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+fisheye::CALIB_CHECK_COND
+fisheye::CALIB_FIX_FOCAL_LENGTH
+fisheye::CALIB_FIX_INTRINSIC
+fisheye::CALIB_FIX_K1
+fisheye::CALIB_FIX_K2
+fisheye::CALIB_FIX_K3
+fisheye::CALIB_FIX_K4
+fisheye::CALIB_FIX_PRINCIPAL_POINT
+fisheye::CALIB_FIX_SKEW
+fisheye::CALIB_RECOMPUTE_EXTRINSIC
+fisheye::CALIB_USE_INTRINSIC_GUESS
+fisheye::CALIB_ZERO_DISPARITY
diff --git a/tools/curated/core.globals.txt b/tools/curated/core.globals.txt
new file mode 100644
index 0000000..3700caa
--- /dev/null
+++ b/tools/curated/core.globals.txt
@@ -0,0 +1,75 @@
+# Public global declarations from core/cvdef.h and core/hal/interface.h.
+CPU_AVX
+CPU_AVX2
+CPU_AVX512_CLX
+CPU_AVX512_CNL
+CPU_AVX512_COMMON
+CPU_AVX512_ICL
+CPU_AVX512_KNL
+CPU_AVX512_KNM
+CPU_AVX512_SKX
+CPU_AVX_5124FMAPS
+CPU_AVX_5124VNNIW
+CPU_AVX_512BITALG
+CPU_AVX_512BW
+CPU_AVX_512CD
+CPU_AVX_512DQ
+CPU_AVX_512ER
+CPU_AVX_512F
+CPU_AVX_512IFMA
+CPU_AVX_512IFMA512
+CPU_AVX_512PF
+CPU_AVX_512VBMI
+CPU_AVX_512VBMI2
+CPU_AVX_512VL
+CPU_AVX_512VNNI
+CPU_AVX_512VPOPCNTDQ
+CPU_AVX_VNNI
+CPU_FMA3
+CPU_FP16
+CPU_LASX
+CPU_LSX
+CPU_MAX_FEATURE
+CPU_MMX
+CPU_MSA
+CPU_NEON
+CPU_NEON_BF16
+CPU_NEON_DOTPROD
+CPU_NEON_FP16
+CPU_POPCNT
+CPU_RISCVV
+CPU_RVV
+CPU_RVV_ZVFH
+CPU_SSE
+CPU_SSE2
+CPU_SSE3
+CPU_SSE4_1
+CPU_SSE4_2
+CPU_SSSE3
+CPU_SVE
+CPU_VSX
+CPU_VSX3
+CpuFeatures
+Cv16suf
+Cv32suf
+Cv64suf
+cv_hal_bf16
+cv_hal_f16
+int64
+schar
+uchar
+uint
+uint64
+ushort
+
+# Public softfloat scalar conversions.
+cvRound64
+cvTrunc
+
+# Original preview C plugin ABI declarations; no plugin backend is implied.
+CvResult
+cvResult
+CV_ERROR_FAIL
+CV_ERROR_OK
+OpenCV_API_Header_t
+OpenCV_API_Header
diff --git a/tools/curated/core.prune.txt b/tools/curated/core.prune.txt
index bc57e57..b5a4193 100644
--- a/tools/curated/core.prune.txt
+++ b/tools/curated/core.prune.txt
@@ -1,4 +1,4 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
 BlockedRange   # 'BlockedRange' has not been declared in 'cv'
 Split   # 'Split' has not been declared in 'cv'
 allocSingletonBuffer   # 'allocSingletonBuffer' has not been declared in 'cv'
@@ -13,66 +13,15 @@ short   # expected unqualified-id before 'short'
 uchar   # 'uchar' has not been declared in 'cv'
 unsigned   # expected unqualified-id before 'unsigned'
 ushort   # 'ushort' has not been declared in 'cv'
-cuda::BufferPool   # 'BufferPool' has not been declared in 'cv::cuda'
-cuda::DYNAMIC_PARALLELISM   # 'DYNAMIC_PARALLELISM' has not been declared in 'cv::cuda'
-cuda::DeviceInfo   # 'DeviceInfo' has not been declared in 'cv::cuda'
 cuda::EventAccessor   # 'EventAccessor' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_10   # 'FEATURE_SET_COMPUTE_10' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_11   # 'FEATURE_SET_COMPUTE_11' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_12   # 'FEATURE_SET_COMPUTE_12' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_13   # 'FEATURE_SET_COMPUTE_13' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_20   # 'FEATURE_SET_COMPUTE_20' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_21   # 'FEATURE_SET_COMPUTE_21' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_30   # 'FEATURE_SET_COMPUTE_30' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_32   # 'FEATURE_SET_COMPUTE_32' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_35   # 'FEATURE_SET_COMPUTE_35' has not been declared in 'cv::cuda'
-cuda::FEATURE_SET_COMPUTE_50   # 'FEATURE_SET_COMPUTE_50' has not been declared in 'cv::cuda'
-cuda::FeatureSet   # 'FeatureSet' has not been declared in 'cv::cuda'
-cuda::GLOBAL_ATOMICS   # 'GLOBAL_ATOMICS' has not been declared in 'cv::cuda'
-cuda::GpuData   # 'GpuData' has not been declared in 'cv::cuda'
-cuda::NATIVE_DOUBLE   # 'NATIVE_DOUBLE' has not been declared in 'cv::cuda'
-cuda::SHARED_ATOMICS   # 'SHARED_ATOMICS' has not been declared in 'cv::cuda'
 cuda::StreamAccessor   # 'StreamAccessor' has not been declared in 'cv::cuda'
-cuda::TargetArchs   # 'TargetArchs' has not been declared in 'cv::cuda'
-cuda::WARP_SHUFFLE_FUNCTIONS   # 'WARP_SHUFFLE_FUNCTIONS' has not been declared in 'cv::cuda'
-cuda::createContinuous   # 'createContinuous' has not been declared in 'cv::cuda'
-cuda::createGpuMatFromCudaMemory   # 'createGpuMatFromCudaMemory' has not been declared in 'cv::cuda'
-cuda::deviceSupports   # 'deviceSupports' has not been declared in 'cv::cuda'
-cuda::ensureSizeIsEnough   # 'ensureSizeIsEnough' has not been declared in 'cv::cuda'
+cuda::createContinuous   # mixed TU-local/external overload set: exact SDK adapters in cuda_helpers.inc
+cuda::ensureSizeIsEnough   # mixed TU-local/external overload set: exact SDK adapters in cuda_helpers.inc
 cuda::getCudaDriverApiErrorMessage   # 'getCudaDriverApiErrorMessage' has not been declared in 'cv::cuda'
-cuda::getCudaEnabledDeviceCount   # 'getCudaEnabledDeviceCount' has not been declared in 'cv::cuda'
-cuda::getDevice   # 'getDevice' has not been declared in 'cv::cuda'
 cuda::getInputMat   # 'getInputMat' has not been declared in 'cv::cuda'
 cuda::getNppErrorMessage   # 'getNppErrorMessage' has not been declared in 'cv::cuda'
 cuda::getOutputMat   # 'getOutputMat' has not been declared in 'cv::cuda'
-cuda::printCudaDeviceInfo   # 'printCudaDeviceInfo' has not been declared in 'cv::cuda'
-cuda::printShortCudaDeviceInfo   # 'printShortCudaDeviceInfo' has not been declared in 'cv::cuda'
-cuda::registerPageLocked   # 'registerPageLocked' has not been declared in 'cv::cuda'
-cuda::resetDevice   # 'resetDevice' has not been declared in 'cv::cuda'
-cuda::setBufferPoolConfig   # 'setBufferPoolConfig' has not been declared in 'cv::cuda'
-cuda::setBufferPoolUsage   # 'setBufferPoolUsage' has not been declared in 'cv::cuda'
-cuda::setDevice   # 'setDevice' has not been declared in 'cv::cuda'
-cuda::setGlDevice   # 'setGlDevice' has not been declared in 'cv::cuda'
 cuda::syncOutput   # 'syncOutput' has not been declared in 'cv::cuda'
-cuda::unregisterPageLocked   # 'unregisterPageLocked' has not been declared in 'cv::cuda'
-cuda::wrapStream   # 'wrapStream' has not been declared in 'cv::cuda'
-ogl::LINES   # 'LINES' has not been declared in 'cv::ogl'
-ogl::LINE_LOOP   # 'LINE_LOOP' has not been declared in 'cv::ogl'
-ogl::LINE_STRIP   # 'LINE_STRIP' has not been declared in 'cv::ogl'
-ogl::POINTS   # 'POINTS' has not been declared in 'cv::ogl'
-ogl::POLYGON   # 'POLYGON' has not been declared in 'cv::ogl'
-ogl::QUADS   # 'QUADS' has not been declared in 'cv::ogl'
-ogl::QUAD_STRIP   # 'QUAD_STRIP' has not been declared in 'cv::ogl'
-ogl::RenderModes   # 'RenderModes' has not been declared in 'cv::ogl'
-ogl::TRIANGLES   # 'TRIANGLES' has not been declared in 'cv::ogl'
-ogl::TRIANGLE_FAN   # 'TRIANGLE_FAN' has not been declared in 'cv::ogl'
-ogl::TRIANGLE_STRIP   # 'TRIANGLE_STRIP' has not been declared in 'cv::ogl'
-ogl::convertFromGLTexture2D   # 'convertFromGLTexture2D' has not been declared in 'cv::ogl'
-ogl::convertToGLTexture2D   # 'convertToGLTexture2D' has not been declared in 'cv::ogl'
-ogl::mapGLBuffer   # 'mapGLBuffer' has not been declared in 'cv::ogl'
-ogl::render   # 'render' has not been declared in 'cv::ogl'
-ogl::unmapGLBuffer   # 'unmapGLBuffer' has not been declared in 'cv::ogl'
-ogl::ocl::initializeContextFromGL   # 'initializeContextFromGL' has not been declared in 'cv::ogl::ocl'
 
 # ── v0.0.6: static-inline / internal-linkage free functions (clang cannot
 #    `export using` an internal-linkage using-declaration). Replaced by the
@@ -94,13 +43,13 @@ norm   # static-inline Matx/Point overloads in the set → matx_ops.inc + core_f
 parallel_for_   # static-inline std::function overload in the set → core_fns.inc
 print   # static inline operations.hpp → core_fns.inc
 randu   # static-inline randu<_Tp>() in the set → core_fns.inc
-read   # FileStorage primitives forwarded in core_fns.inc; geometry-type convenience wrappers pruned (see below)
+read   # primitives in core_fns.inc; static-inline helpers in generated persistence_ops.inc
 roundUp   # static inline utility.hpp → core_fns.inc
 swap   # static-inline MatExpr overload in the set → core_fns.inc
 toLowerCase   # static inline cvstd.hpp → core_fns.inc
 toUpperCase   # static inline cvstd.hpp → core_fns.inc
 trace   # static-inline Matx overload in the set → matx_ops.inc + core_fns.inc
-write   # FileStorage primitives forwarded in core_fns.inc; geometry-type convenience wrappers pruned (see below)
+write   # primitives in core_fns.inc; static-inline helpers in generated persistence_ops.inc
 # internal helpers, NOT user API — dropped outright (no replacement):
 details::char_tolower   # internal cvstd.hpp helper behind toLowerCase
 details::char_toupper   # internal cvstd.hpp helper behind toUpperCase
diff --git a/tools/curated/core.txt b/tools/curated/core.txt
index 9580c41..75e0f79 100644
--- a/tools/curated/core.txt
+++ b/tools/curated/core.txt
@@ -180,3 +180,452 @@ sqrt
 pow
 exp
 log
+
+# Additional public C++ types found by the Clang inventory (not Python-only API).
+Affine3
+Affine3d
+Affine3f
+Allocator
+AutoBuffer
+DefaultDeleter
+ErrorCallback
+HammingLUT
+MatCommaInitializer_
+MatND
+MatxCommaInitializer
+Quat
+Quatd
+Quatf
+SparseMatConstIterator_
+SparseMatIterator_
+Vec2l
+Vec3l
+Vec4l
+Vec6l
+Vec8l
+VecCommaInitializer
+bfloat
+hfloat
+int8_t
+int16_t
+int32_t
+int64_t
+uint8_t
+uint16_t
+uint32_t
+uint64_t
+nullptr_t
+partition
+
+# Public C++ entities restored from the Clang facade inventory.
+Error::BadAlign
+Error::BadAlphaChannel
+Error::BadCOI
+Error::BadCallBack
+Error::BadDataPtr
+Error::BadDepth
+Error::BadImageSize
+Error::BadModelOrChSeq
+Error::BadNumChannel1U
+Error::BadNumChannels
+Error::BadOffset
+Error::BadOrder
+Error::BadOrigin
+Error::BadROISize
+Error::BadStep
+Error::BadTileSize
+Error::Code
+Error::GpuApiCallError
+Error::GpuNotSupported
+Error::HeaderIsNull
+Error::MaskIsTiled
+Error::OpenCLApiCallError
+Error::OpenCLDoubleNotSupported
+Error::OpenCLInitError
+Error::OpenCLNoAMDBlasFft
+Error::OpenGlApiCallError
+Error::OpenGlNotSupported
+Error::StsAssert
+Error::StsAutoTrace
+Error::StsBackTrace
+Error::StsBadArg
+Error::StsBadFlag
+Error::StsBadFunc
+Error::StsBadMask
+Error::StsBadMemBlock
+Error::StsBadPoint
+Error::StsBadSize
+Error::StsDivByZero
+Error::StsError
+Error::StsFilterOffsetErr
+Error::StsFilterStructContentErr
+Error::StsInplaceNotSupported
+Error::StsInternal
+Error::StsKernelStructContentErr
+Error::StsNoConv
+Error::StsNoMem
+Error::StsNotImplemented
+Error::StsNullPtr
+Error::StsObjectNotFound
+Error::StsOk
+Error::StsOutOfRange
+Error::StsParseError
+Error::StsUnmatchedFormats
+Error::StsUnmatchedSizes
+Error::StsUnsupportedFormat
+Error::StsVecLengthErr
+Param
+ParamType
+acos
+acosh
+asin
+asinh
+atan
+atanh
+cosh
+crossProduct
+hfloatFromBits
+inv
+power
+samples::addSamplesDataSearchPath
+samples::addSamplesDataSearchSubDirectory
+samples::findFile
+samples::findFileOrKeep
+sinh
+tan
+tanh
+terminate
+traits::Depth
+traits::SafeFmt
+traits::SafeType
+traits::Type
+utils::logging::ENUM_LOG_LEVEL_FORCE_INT
+utils::logging::LOG_LEVEL_DEBUG
+utils::logging::LOG_LEVEL_ERROR
+utils::logging::LOG_LEVEL_FATAL
+utils::logging::LOG_LEVEL_INFO
+utils::logging::LOG_LEVEL_SILENT
+utils::logging::LOG_LEVEL_VERBOSE
+utils::logging::LOG_LEVEL_WARNING
+utils::logging::LogLevel
+utils::logging::LogTag
+utils::logging::LogTagAuto
+utils::logging::getLogLevel
+utils::logging::getLogTagLevel
+utils::logging::registerLogTag
+utils::logging::setLogLevel
+utils::logging::setLogTagLevel
+Node
+has_custom_delete
+
+# Portable standalone public headers, loaded explicitly by the facade.
+AsyncPromise
+DualQuat
+DualQuatd
+DualQuatf
+FPDenormalsIgnoreHintScope
+TLSData
+TLSDataAccumulator
+TLSDataContainer
+conjugate
+parallel::ParallelForAPI
+parallel::setParallelForBackend
+utils::AllocatorStatisticsInterface
+utils::fs::canonical
+utils::fs::createDirectories
+utils::fs::createDirectory
+utils::fs::exists
+utils::fs::getParent
+utils::fs::getcwd
+utils::fs::glob
+utils::fs::glob_relative
+utils::fs::isDirectory
+utils::fs::join
+utils::fs::remove_all
+
+# Public CPU-build device API declarations; this does not enable a GPU backend.
+cuda::BufferPool
+cuda::DYNAMIC_PARALLELISM
+cuda::DevPtr
+cuda::DeviceInfo
+cuda::FEATURE_SET_COMPUTE_10
+cuda::FEATURE_SET_COMPUTE_11
+cuda::FEATURE_SET_COMPUTE_12
+cuda::FEATURE_SET_COMPUTE_13
+cuda::FEATURE_SET_COMPUTE_20
+cuda::FEATURE_SET_COMPUTE_21
+cuda::FEATURE_SET_COMPUTE_30
+cuda::FEATURE_SET_COMPUTE_32
+cuda::FEATURE_SET_COMPUTE_35
+cuda::FEATURE_SET_COMPUTE_50
+cuda::FeatureSet
+cuda::GLOBAL_ATOMICS
+cuda::GpuData
+cuda::IndexArray
+cuda::NATIVE_DOUBLE
+cuda::PtrStep
+cuda::PtrStepSz
+cuda::PtrStepSzb
+cuda::PtrStepSzf
+cuda::PtrStepSzi
+cuda::PtrStepSzus
+cuda::PtrStepb
+cuda::PtrStepf
+cuda::PtrStepi
+cuda::PtrStepus
+cuda::PtrSz
+cuda::SHARED_ATOMICS
+cuda::SizeArray
+cuda::StepArray
+cuda::TargetArchs
+cuda::WARP_SHUFFLE_FUNCTIONS
+cuda::createGpuMatFromCudaMemory
+cuda::deviceSupports
+cuda::getCudaEnabledDeviceCount
+cuda::getDevice
+cuda::printCudaDeviceInfo
+cuda::printShortCudaDeviceInfo
+cuda::registerPageLocked
+cuda::resetDevice
+cuda::setBufferPoolConfig
+cuda::setBufferPoolUsage
+cuda::setDevice
+cuda::setGlDevice
+cuda::unregisterPageLocked
+cuda::wrapStream
+ogl::LINES
+ogl::LINE_LOOP
+ogl::LINE_STRIP
+ogl::POINTS
+ogl::POLYGON
+ogl::QUADS
+ogl::QUAD_STRIP
+ogl::RenderModes
+ogl::TRIANGLES
+ogl::TRIANGLE_FAN
+ogl::TRIANGLE_STRIP
+ogl::convertFromGLTexture2D
+ogl::convertToGLTexture2D
+ogl::mapGLBuffer
+ogl::ocl::initializeContextFromGL
+ogl::render
+ogl::unmapGLBuffer
+
+# Public instrumentation external interface (not the internal trace helpers).
+instr::TYPE
+instr::TYPE_GENERAL
+instr::TYPE_MARKER
+instr::TYPE_WRAPPER
+instr::TYPE_FUN
+instr::IMPL
+instr::IMPL_PLAIN
+instr::IMPL_IPP
+instr::IMPL_OPENCL
+instr::NodeDataTls
+instr::NodeData
+instr::InstrNode
+instr::getTrace
+instr::useInstrumentation
+instr::setUseInstrumentation
+instr::resetTrace
+instr::FLAGS
+instr::FLAGS_NONE
+instr::FLAGS_MAPPING
+instr::FLAGS_EXPAND_SAME_NAMES
+instr::getFlags
+
+# Public HAL interface; SDK @cond IGNORED legacy helpers stay private.
+hal::Cholesky32f
+hal::Cholesky64f
+hal::DCT2D
+hal::DFT1D
+hal::DFT2D
+hal::LU32f
+hal::LU64f
+hal::QR32f
+hal::QR64f
+hal::SVD32f
+hal::SVD64f
+hal::absdiff16bf
+hal::absdiff16f
+hal::absdiff16s
+hal::absdiff16u
+hal::absdiff32f
+hal::absdiff32s
+hal::absdiff32u
+hal::absdiff64f
+hal::absdiff64s
+hal::absdiff64u
+hal::absdiff8s
+hal::absdiff8u
+hal::add16bf
+hal::add16f
+hal::add16s
+hal::add16u
+hal::add32f
+hal::add32s
+hal::add32u
+hal::add64f
+hal::add64s
+hal::add64u
+hal::add8s
+hal::add8u
+hal::addRNGBias32f
+hal::addRNGBias64f
+hal::addWeighted16bf
+hal::addWeighted16f
+hal::addWeighted16s
+hal::addWeighted16u
+hal::addWeighted32f
+hal::addWeighted32s
+hal::addWeighted32u
+hal::addWeighted64f
+hal::addWeighted64s
+hal::addWeighted64u
+hal::addWeighted8s
+hal::addWeighted8u
+hal::and8u
+hal::cartToPolar32f
+hal::cartToPolar64f
+hal::cmp16bf
+hal::cmp16f
+hal::cmp16s
+hal::cmp16u
+hal::cmp32f
+hal::cmp32s
+hal::cmp32u
+hal::cmp64f
+hal::cmp64s
+hal::cmp64u
+hal::cmp8s
+hal::cmp8u
+hal::cvt16bf32f
+hal::cvt16f32f
+hal::cvt32f16bf
+hal::cvt32f16f
+hal::div16bf
+hal::div16f
+hal::div16s
+hal::div16u
+hal::div32f
+hal::div32s
+hal::div32u
+hal::div64f
+hal::div64s
+hal::div64u
+hal::div8s
+hal::div8u
+hal::exp32f
+hal::exp64f
+hal::fastAtan32f
+hal::fastAtan64f
+hal::gemm32f
+hal::gemm32fc
+hal::gemm64f
+hal::gemm64fc
+hal::invSqrt32f
+hal::invSqrt64f
+hal::log32f
+hal::log64f
+hal::magnitude32f
+hal::magnitude64f
+hal::max16bf
+hal::max16f
+hal::max16s
+hal::max16u
+hal::max32f
+hal::max32s
+hal::max32u
+hal::max64f
+hal::max64s
+hal::max64u
+hal::max8s
+hal::max8u
+hal::merge16u
+hal::merge32s
+hal::merge64s
+hal::merge8u
+hal::min16bf
+hal::min16f
+hal::min16s
+hal::min16u
+hal::min32f
+hal::min32s
+hal::min32u
+hal::min64f
+hal::min64s
+hal::min64u
+hal::min8s
+hal::min8u
+hal::mul16bf
+hal::mul16f
+hal::mul16s
+hal::mul16u
+hal::mul32f
+hal::mul32s
+hal::mul32u
+hal::mul64f
+hal::mul64s
+hal::mul64u
+hal::mul8s
+hal::mul8u
+hal::normHamming
+hal::normL1_
+hal::normL2Sqr_
+hal::not8u
+hal::or8u
+hal::polarToCart32f
+hal::polarToCart64f
+hal::recip16bf
+hal::recip16f
+hal::recip16s
+hal::recip16u
+hal::recip32f
+hal::recip32s
+hal::recip32u
+hal::recip64f
+hal::recip64s
+hal::recip64u
+hal::recip8s
+hal::recip8u
+hal::split16u
+hal::split32s
+hal::split64s
+hal::split8u
+hal::sqrt32f
+hal::sqrt64f
+hal::sub16bf
+hal::sub16f
+hal::sub16s
+hal::sub16u
+hal::sub32f
+hal::sub32s
+hal::sub32u
+hal::sub64f
+hal::sub64s
+hal::sub64u
+hal::sub8s
+hal::sub8u
+hal::xor8u
+
+utils::getThreadID
+
+# Public helpers outside bindings_utils.hpp's ignored binding-test region.
+utils::dumpInputArray
+utils::dumpInputArrayOfArrays
+utils::dumpInputOutputArray
+utils::dumpInputOutputArrayOfArrays
+utils::dumpVectorOfInt
+utils::dumpVectorOfDouble
+utils::dumpVectorOfRect
+utils::fs::getCacheDirectoryForDownloads
+
+# Original per-thread floating-point state API and RAII types.
+details::FPDenormalsModeState
+details::FPDenormalsIgnoreHintScope
+details::FPDenormalsIgnoreHintScopeNOOP
+details::setFPDenormalsIgnoreHint
+details::saveFPDenormalsState
+details::restoreFPDenormalsState
+# Original incomplete SDK declaration; exposing pointers needs no CUDA SDK.
+cudev::GpuMat_
diff --git a/tools/curated/dnn.prune.txt b/tools/curated/dnn.prune.txt
index ff8cd31..b304062 100644
--- a/tools/curated/dnn.prune.txt
+++ b/tools/curated/dnn.prune.txt
@@ -1,16 +1,14 @@
-# names failing compile-verification for opencv.dnn — internal shape_utils.hpp
-# / layer-factory helpers that hdr_parser collected but that are not part of
-# the public surface reachable through <opencv2/dnn.hpp> + all_layers.hpp.
-dnn::concat
-dnn::getActivationFunc
-dnn::getLayerFactoryImpl
-dnn::getLayerFactoryMutex
-dnn::getPlane
-dnn::isAllOnes
-dnn::normalize_axis
-dnn::normalize_axis_range
-dnn::shape
-dnn::slice
-dnn::toString
-dnn::total
-dnn::_Range
+# Static-inline public shape helpers are adapted in src/dnn_shapes.inc rather
+# than exported with using declarations. Private layer-factory helpers remain
+# unavailable; their names are not part of the public contract.
+dnn::concat   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::getLayerFactoryImpl   # private layer_reg.private.hpp implementation helper
+dnn::getLayerFactoryMutex   # private layer_reg.private.hpp implementation helper
+dnn::getPlane   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::isAllOnes   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::normalize_axis   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::normalize_axis_range   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::shape   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::slice   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::toString   # SDK shape body adapted in generated src/dnn_shapes.inc
+dnn::total   # SDK shape body adapted in generated src/dnn_shapes.inc
diff --git a/tools/curated/dnn.txt b/tools/curated/dnn.txt
new file mode 100644
index 0000000..f85ae93
--- /dev/null
+++ b/tools/curated/dnn.txt
@@ -0,0 +1,14 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+dnn::ActivationFunc
+dnn::MatType
+dnn::SoftNMSMethod
+dnn::getActivationFunc
+dnn::_Range
+# Public legacy backend utilities retain the SDK's unavailable-backend behavior.
+dnn::getInferenceEngineBackendType
+dnn::setInferenceEngineBackendType
+dnn::getInferenceEngineVPUType
+dnn::getInferenceEngineCPUType
+dnn::resetMyriadDevice
+dnn::releaseHDDLPlugin
diff --git a/tools/curated/features.conditional.txt b/tools/curated/features.conditional.txt
new file mode 100644
index 0000000..c6738b1
--- /dev/null
+++ b/tools/curated/features.conditional.txt
@@ -0,0 +1,2 @@
+# features.hpp exposes DISK only when the optional DNN module is compiled.
+HAVE_OPENCV_DNN DISK
diff --git a/tools/curated/features.globals.txt b/tools/curated/features.globals.txt
new file mode 100644
index 0000000..bc81f83
--- /dev/null
+++ b/tools/curated/features.globals.txt
@@ -0,0 +1,2 @@
+# Original public feature HAL record, without a copied ABI type.
+cvhalKeyPoint
diff --git a/tools/curated/features.txt b/tools/curated/features.txt
new file mode 100644
index 0000000..a4b6d7d
--- /dev/null
+++ b/tools/curated/features.txt
@@ -0,0 +1,14 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+Accumulator
+AffineDescriptorExtractor
+AffineFeatureDetector
+DescriptorExtractor
+DrawMatchesFlags
+FeatureDetector
+FlannBasedMatcher
+L1
+L2
+SL2
+SiftDescriptorExtractor
+SiftFeatureDetector
diff --git a/tools/curated/flann.qualified.txt b/tools/curated/flann.qualified.txt
new file mode 100644
index 0000000..3ead01d
--- /dev/null
+++ b/tools/curated/flann.qualified.txt
@@ -0,0 +1,166 @@
+# Low-level FLANN API keeps its original cvflann namespace.
+# Namespace const implementation values and anyimpl helpers are not re-exported here.
+cvflann::AUTOTUNED
+cvflann::Accumulator
+cvflann::AutotunedIndex
+cvflann::AutotunedIndexParams
+cvflann::BranchStruct
+cvflann::CENTERS_GONZALES
+cvflann::CENTERS_KMEANSPP
+cvflann::CENTERS_RANDOM
+cvflann::COMPOSITE
+cvflann::CS
+cvflann::ChiSquareDistance
+cvflann::CompositeIndex
+cvflann::CompositeIndexParams
+cvflann::DNAmming2
+cvflann::DNAmmingLUT
+cvflann::Datatype
+cvflann::DynamicBitset
+cvflann::EUCLIDEAN
+cvflann::FILEScopeGuard
+cvflann::FLANN_CENTERS_GONZALES
+cvflann::FLANN_CENTERS_GROUPWISE
+cvflann::FLANN_CENTERS_KMEANSPP
+cvflann::FLANN_CENTERS_RANDOM
+cvflann::FLANN_CHECKS_AUTOTUNED
+cvflann::FLANN_CHECKS_UNLIMITED
+cvflann::FLANN_DIST_CHI_SQUARE
+cvflann::FLANN_DIST_CS
+cvflann::FLANN_DIST_DNAMMING
+cvflann::FLANN_DIST_EUCLIDEAN
+cvflann::FLANN_DIST_HAMMING
+cvflann::FLANN_DIST_HELLINGER
+cvflann::FLANN_DIST_HIST_INTERSECT
+cvflann::FLANN_DIST_KL
+cvflann::FLANN_DIST_KULLBACK_LEIBLER
+cvflann::FLANN_DIST_L1
+cvflann::FLANN_DIST_L2
+cvflann::FLANN_DIST_MANHATTAN
+cvflann::FLANN_DIST_MAX
+cvflann::FLANN_DIST_MINKOWSKI
+cvflann::FLANN_FLOAT32
+cvflann::FLANN_FLOAT64
+cvflann::FLANN_INDEX_AUTOTUNED
+cvflann::FLANN_INDEX_COMPOSITE
+cvflann::FLANN_INDEX_HIERARCHICAL
+cvflann::FLANN_INDEX_KDTREE
+cvflann::FLANN_INDEX_KDTREE_SINGLE
+cvflann::FLANN_INDEX_KMEANS
+cvflann::FLANN_INDEX_LINEAR
+cvflann::FLANN_INDEX_LSH
+cvflann::FLANN_INDEX_SAVED
+cvflann::FLANN_INT16
+cvflann::FLANN_INT32
+cvflann::FLANN_INT64
+cvflann::FLANN_INT8
+cvflann::FLANN_LOG_ERROR
+cvflann::FLANN_LOG_FATAL
+cvflann::FLANN_LOG_INFO
+cvflann::FLANN_LOG_NONE
+cvflann::FLANN_LOG_WARN
+cvflann::FLANN_UINT16
+cvflann::FLANN_UINT32
+cvflann::FLANN_UINT64
+cvflann::FLANN_UINT8
+cvflann::False
+cvflann::HELLINGER
+cvflann::HIST_INTERSECT
+cvflann::Hamming
+cvflann::Hamming2
+cvflann::HammingLUT
+cvflann::Heap
+cvflann::HellingerDistance
+cvflann::HierarchicalClusteringIndex
+cvflann::HierarchicalClusteringIndexParams
+cvflann::HistIntersectionDistance
+cvflann::Index
+cvflann::IndexHeader
+cvflann::IndexParams
+cvflann::KDTREE
+cvflann::KDTREE_SINGLE
+cvflann::KDTreeIndex
+cvflann::KDTreeIndexParams
+cvflann::KDTreeSingleIndex
+cvflann::KDTreeSingleIndexParams
+cvflann::KL
+cvflann::KL_Divergence
+cvflann::KMEANS
+cvflann::KMeansIndex
+cvflann::KMeansIndexParams
+cvflann::KNNRadiusUniqueResultSet
+cvflann::KNNResultSet
+cvflann::KNNSimpleResultSet
+cvflann::KNNUniqueResultSet
+cvflann::KULLBACK_LEIBLER
+cvflann::L1
+cvflann::L2
+cvflann::L2_Simple
+cvflann::LINEAR
+cvflann::LinearIndex
+cvflann::LinearIndexParams
+cvflann::Logger
+cvflann::LshIndex
+cvflann::LshIndexParams
+cvflann::MANHATTAN
+cvflann::MAX_DIST
+cvflann::MINKOWSKI
+cvflann::Matrix
+cvflann::MaxDistance
+cvflann::MinkowskiDistance
+cvflann::NNIndex
+cvflann::PooledAllocator
+cvflann::RadiusResultSet
+cvflann::RadiusUniqueResultSet
+cvflann::ResultSet
+cvflann::SAVED
+cvflann::SavedIndexParams
+cvflann::SearchParams
+cvflann::StartStopTimer
+cvflann::True
+cvflann::UniqueRandom
+cvflann::UniqueResultSet
+cvflann::UntypedMatrix
+cvflann::ZeroIterator
+cvflann::abs
+cvflann::allocate
+cvflann::any
+cvflann::computeDistanceRaport
+cvflann::compute_ground_truth
+cvflann::countCorrectMatches
+cvflann::create_index_by_type
+cvflann::ensureSimpleDistance
+cvflann::ensureSquareDistance
+cvflann::find_nearest
+cvflann::flann_algorithm_t
+cvflann::flann_centers_init_t
+cvflann::flann_datatype_t
+cvflann::flann_distance_t
+cvflann::flann_distance_type
+cvflann::flann_log_level_t
+cvflann::get_param
+cvflann::greater
+cvflann::hierarchicalClustering
+cvflann::index_creator
+cvflann::isSquareDist
+cvflann::isSquareDistance
+cvflann::load_header
+cvflann::load_saved_index
+cvflann::load_value
+cvflann::log_verbosity
+cvflann::print_params
+cvflann::rand
+cvflann::rand_double
+cvflann::rand_int
+cvflann::random_sample
+cvflann::round
+cvflann::save_header
+cvflann::save_value
+cvflann::search_with_ground_truth
+cvflann::seed_random
+cvflann::set_distance_type
+cvflann::simpleDistance
+cvflann::squareDistance
+cvflann::test_index_checks
+cvflann::test_index_precision
+cvflann::test_index_precisions
diff --git a/tools/curated/flann.txt b/tools/curated/flann.txt
new file mode 100644
index 0000000..866791f
--- /dev/null
+++ b/tools/curated/flann.txt
@@ -0,0 +1,22 @@
+
+# Additional public template API from flann.hpp (the Python parser omits it).
+flann::ChiSquareDistance
+flann::CvType
+flann::DNAmming2
+flann::DNAmmingLUT
+flann::GenericIndex
+flann::Hamming
+flann::Hamming2
+flann::HammingLUT
+flann::HellingerDistance
+flann::HistIntersectionDistance
+flann::Index_
+flann::KL_Divergence
+flann::L1
+flann::L2
+flann::L2_Simple
+flann::MaxDistance
+flann::MinkowskiDistance
+flann::get_param
+flann::hierarchicalClustering
+flann::print_params
diff --git a/tools/curated/geometry.prune.txt b/tools/curated/geometry.prune.txt
index b7152ba..e096847 100644
--- a/tools/curated/geometry.prune.txt
+++ b/tools/curated/geometry.prune.txt
@@ -1,6 +1 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
-MSTAlgorithm   # 'MSTAlgorithm' has not been declared in 'cv'
-MSTEdge   # 'MSTEdge' has not been declared in 'cv'
-MST_KRUSKAL   # 'MST_KRUSKAL' has not been declared in 'cv'
-MST_PRIM   # 'MST_PRIM' has not been declared in 'cv'
-buildMST   # 'buildMST' has not been declared in 'cv'
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
diff --git a/tools/curated/geometry.txt b/tools/curated/geometry.txt
new file mode 100644
index 0000000..d30a835
--- /dev/null
+++ b/tools/curated/geometry.txt
@@ -0,0 +1,13 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+MatrixType
+VariableType
+
+# Portable standalone public headers, loaded explicitly by the facade.
+MSTAlgorithm
+MSTEdge
+MST_KRUSKAL
+MST_PRIM
+buildMST
+detail::LevMarqBackend
+detail::LevMarqBase
diff --git a/tools/curated/highgui.prune.txt b/tools/curated/highgui.prune.txt
index dfd8ff9..46a8708 100644
--- a/tools/curated/highgui.prune.txt
+++ b/tools/curated/highgui.prune.txt
@@ -1,2 +1,2 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
 winrt_initContainer   # 'winrt_initContainer' has not been declared in 'cv'
diff --git a/tools/curated/highgui.txt b/tools/curated/highgui.txt
new file mode 100644
index 0000000..4bf3f18
--- /dev/null
+++ b/tools/curated/highgui.txt
@@ -0,0 +1,6 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+ButtonCallback
+MouseCallback
+OpenGlDrawCallback
+TrackbarCallback
diff --git a/tools/curated/imgcodecs.prune.txt b/tools/curated/imgcodecs.prune.txt
index bc8a676..1ad30b4 100644
--- a/tools/curated/imgcodecs.prune.txt
+++ b/tools/curated/imgcodecs.prune.txt
@@ -1,2 +1,2 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
-imwritemulti   # static inline (internal linkage) — clang rejects export; use imwrite(vector) instead
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
+imwritemulti   # SDK body adapted in generated imgcodecs_helpers.inc
diff --git a/tools/curated/imgproc.prune.txt b/tools/curated/imgproc.prune.txt
index 38dee52..0399e24 100644
--- a/tools/curated/imgproc.prune.txt
+++ b/tools/curated/imgproc.prune.txt
@@ -1,5 +1,5 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
 HoughCirclesWithAccumulator   # 'HoughCirclesWithAccumulator' has not been declared in 'cv'
 HoughLinesWithAccumulator   # 'HoughLinesWithAccumulator' has not been declared in 'cv'
-initWideAngleProjMap   # static inline (internal linkage) — clang rejects export; unusable across module boundary
-morphologyDefaultBorderValue   # static inline (internal linkage) — clang rejects export
+initWideAngleProjMap   # both SDK overloads adapted in generated imgproc_helpers.inc
+morphologyDefaultBorderValue   # SDK body adapted in generated imgproc_helpers.inc
diff --git a/tools/curated/imgproc.txt b/tools/curated/imgproc.txt
new file mode 100644
index 0000000..f186afc
--- /dev/null
+++ b/tools/curated/imgproc.txt
@@ -0,0 +1,36 @@
+
+# Public HAL interface; SDK @cond IGNORED legacy helpers stay private.
+hal::cvtBGR5x5toBGR
+hal::cvtBGR5x5toGray
+hal::cvtBGRtoBGR
+hal::cvtBGRtoBGR5x5
+hal::cvtBGRtoGray
+hal::cvtBGRtoHSV
+hal::cvtBGRtoLab
+hal::cvtBGRtoThreePlaneYUV
+hal::cvtBGRtoTwoPlaneYUV
+hal::cvtBGRtoXYZ
+hal::cvtBGRtoYUV
+hal::cvtGraytoBGR
+hal::cvtGraytoBGR5x5
+hal::cvtHSVtoBGR
+hal::cvtLabtoBGR
+hal::cvtMultipliedRGBAtoRGBA
+hal::cvtOnePlaneBGRtoYUV
+hal::cvtOnePlaneYUVtoBGR
+hal::cvtRGBAtoMultipliedRGBA
+hal::cvtThreePlaneYUVtoBGR
+hal::cvtTwoPlaneYUVtoBGR
+hal::cvtXYZtoBGR
+hal::cvtYUVtoBGR
+hal::filter2D
+hal::integral
+hal::morph
+hal::resize
+hal::sepFilter2D
+hal::warpAffine
+hal::warpAffineBlockline
+hal::warpAffineBlocklineNN
+hal::warpPerspective
+hal::warpPerspectiveBlockline
+hal::warpPerspectiveBlocklineNN
diff --git a/tools/curated/photo.globals.txt b/tools/curated/photo.globals.txt
new file mode 100644
index 0000000..4efcabc
--- /dev/null
+++ b/tools/curated/photo.globals.txt
@@ -0,0 +1,4 @@
+# Original global enum spellings retained by the upstream compatibility header.
+InpaintingModes
+CV_INPAINT_NS
+CV_INPAINT_TELEA
diff --git a/tools/curated/ptcloud.txt b/tools/curated/ptcloud.txt
new file mode 100644
index 0000000..ffacac9
--- /dev/null
+++ b/tools/curated/ptcloud.txt
@@ -0,0 +1,9 @@
+
+# Public C++ entities restored from the Clang facade inventory.
+OdometryAlgoType
+OdometryType
+VolumeType
+
+# Public CPU rendering functions declared in detail/kinfu_frame.hpp.
+detail::renderPointsNormals
+detail::renderPointsNormalsColors
diff --git a/tools/curated/stitching.txt b/tools/curated/stitching.txt
new file mode 100644
index 0000000..b8751c0
--- /dev/null
+++ b/tools/curated/stitching.txt
@@ -0,0 +1,101 @@
+# Public stitching/detail headers are the upstream advanced stitching API.
+# Their namespace does not make them private implementation declarations.
+detail::AffineBasedEstimator
+detail::AffineBestOf2NearestMatcher
+detail::AffineWarper
+detail::BestOf2NearestMatcher
+detail::BestOf2NearestRangeMatcher
+detail::Blender
+detail::BlocksChannelsCompensator
+detail::BlocksCompensator
+detail::BlocksGainCompensator
+detail::BundleAdjusterAffine
+detail::BundleAdjusterAffinePartial
+detail::BundleAdjusterBase
+detail::BundleAdjusterRay
+detail::BundleAdjusterReproj
+detail::CameraParams
+detail::ChannelsCompensator
+detail::CompressedRectilinearPortraitProjector
+detail::CompressedRectilinearPortraitWarper
+detail::CompressedRectilinearProjector
+detail::CompressedRectilinearWarper
+detail::CylindricalPortraitProjector
+detail::CylindricalPortraitWarper
+detail::CylindricalProjector
+detail::CylindricalWarper
+detail::CylindricalWarperGpu
+detail::DisjointSets
+detail::DpSeamFinder
+detail::Estimator
+detail::ExposureCompensator
+detail::FeatherBlender
+detail::FeaturesMatcher
+detail::FisheyeProjector
+detail::FisheyeWarper
+detail::GainCompensator
+detail::Graph
+detail::GraphCutSeamFinder
+detail::GraphCutSeamFinderBase
+detail::GraphEdge
+detail::HomographyBasedEstimator
+detail::ImageFeatures
+detail::LightGlueFeaturesMatcher
+detail::MatchesInfo
+detail::MercatorProjector
+detail::MercatorWarper
+detail::MultiBandBlender
+detail::NoBundleAdjuster
+detail::NoExposureCompensator
+detail::NoSeamFinder
+detail::PairwiseSeamFinder
+detail::PaniniPortraitProjector
+detail::PaniniPortraitWarper
+detail::PaniniProjector
+detail::PaniniWarper
+detail::PlanePortraitProjector
+detail::PlanePortraitWarper
+detail::PlaneProjector
+detail::PlaneWarper
+detail::PlaneWarperGpu
+detail::ProjectorBase
+detail::RotationWarper
+detail::RotationWarperBase
+detail::SeamFinder
+detail::SphericalPortraitProjector
+detail::SphericalPortraitWarper
+detail::SphericalProjector
+detail::SphericalWarper
+detail::SphericalWarperGpu
+detail::StereographicProjector
+detail::StereographicWarper
+detail::Timelapser
+detail::TimelapserCrop
+detail::TransverseMercatorProjector
+detail::TransverseMercatorWarper
+detail::VoronoiSeamFinder
+detail::WAVE_CORRECT_AUTO
+detail::WAVE_CORRECT_HORIZ
+detail::WAVE_CORRECT_VERT
+detail::WaveCorrectKind
+detail::autoDetectWaveCorrectKind
+detail::calibrateRotatingCamera
+detail::computeImageFeatures
+detail::createLaplacePyr
+detail::createLaplacePyrGpu
+detail::createWeightMap
+detail::estimateFocal
+detail::findMaxSpanningTree
+detail::focalsFromHomography
+detail::leaveBiggestComponent
+detail::matchesGraphAsString
+detail::normalizeUsingWeightMap
+detail::overlapRoi
+detail::restoreImageFromLaplacePyr
+detail::restoreImageFromLaplacePyrGpu
+detail::resultRoi
+detail::resultRoiIntersection
+detail::resultTl
+detail::selectRandomSubset
+detail::stitchingLogLevel
+detail::waveCorrect
diff --git a/tools/curated/video.globals.txt b/tools/curated/video.globals.txt
new file mode 100644
index 0000000..f258e63
--- /dev/null
+++ b/tools/curated/video.globals.txt
@@ -0,0 +1,5 @@
+# Original global constants retained by the upstream compatibility header.
+CV_LKFLOW_PYR_A_READY
+CV_LKFLOW_PYR_B_READY
+CV_LKFLOW_INITIAL_GUESSES
+CV_LKFLOW_GET_MIN_EIGENVALS
diff --git a/tools/curated/video.txt b/tools/curated/video.txt
new file mode 100644
index 0000000..d952c5b
--- /dev/null
+++ b/tools/curated/video.txt
@@ -0,0 +1,11 @@
+# Documented public extension interfaces in tracking.detail.hpp.
+detail::tracking::TrackerFeature
+detail::tracking::TrackerFeatureSet
+detail::tracking::TrackerSamplerAlgorithm
+detail::tracking::TrackerSampler
+detail::tracking::TrackerTargetState
+detail::tracking::ConfidenceMap
+detail::tracking::Trajectory
+detail::tracking::TrackerStateEstimator
+detail::tracking::TrackerModel
+detail::tracking::TrackerSamplerCSC
diff --git a/tools/curated/videoio.prune.txt b/tools/curated/videoio.prune.txt
index 6f75ec0..2de67aa 100644
--- a/tools/curated/videoio.prune.txt
+++ b/tools/curated/videoio.prune.txt
@@ -1,4 +1,4 @@
-# names failing compile-verification — maintained by tools/prune_loop.py
+# Reviewed using-declaration exceptions; compilation never rewrites this list.
 AVIReadContainer   # 'AVIReadContainer' has not been declared in 'cv'
 AVIWriteContainer   # 'AVIWriteContainer' has not been declared in 'cv'
 CLOSE_CAMERA   # 'CLOSE_CAMERA' has not been declared in 'cv'
diff --git a/tools/curated/videoio.txt b/tools/curated/videoio.txt
new file mode 100644
index 0000000..4357ff0
--- /dev/null
+++ b/tools/curated/videoio.txt
@@ -0,0 +1,3 @@
+# Opaque types declared by the original public videoio header.
+IVideoCapture
+IVideoWriter
diff --git a/tools/gen_exports.py b/tools/gen_exports.py
index 3d1865e..ac49248 100644
--- a/tools/gen_exports.py
+++ b/tools/gen_exports.py
@@ -12,19 +12,22 @@
 
 Names are deduped across modules (first module wins, module order below), so
 each entity is exported by exactly one home module. Sub-namespace names
-(cv.ocl.X, cv.utils.X, …) group into nested namespace blocks; cv.detail and
-private surfaces are dropped.
+(cv.ocl.X, cv.utils.X, …) group into nested namespace blocks. The binding
+parser skips detail/private namespaces; curated lists explicitly restore public
+C++ surfaces such as stitching/detail, with Clang/consumer audits tracking gaps.
 
 Usage: gen_exports.py [opencv-root]      (default: the vendored
-                                          third_party/opencv-5.0.0 tree)
+                                          upstream/opencv tree)
 """
 import re
 import sys
 from collections import defaultdict
 from pathlib import Path
+from _files import write_if_changed
 
 REPO = Path(__file__).resolve().parent.parent
-MODULE_ORDER = ["core", "imgproc", "imgcodecs", "videoio", "highgui", "flann", "geometry", "dnn"]
+MODULE_ORDER = ["core", "imgproc", "imgcodecs", "videoio", "highgui", "flann", "geometry", "dnn",
+                "features", "objdetect", "stereo", "calib", "photo", "ptcloud", "stitching", "video"]
 SKIP_HEADER_PARTS = ("detail", "legacy", "private", "cuda", "opencl", "hal",
                      "utils", "llapi", "parallel", "detection_based_tracker")
 SKIP_NS = ("detail", "internal", "traits", "hal", "instr", "utils", "samples",
@@ -34,7 +37,7 @@
 def opencv_root() -> Path:
     if len(sys.argv) > 1:
         return Path(sys.argv[1]).resolve()
-    return REPO / "third_party" / "opencv-5.0.0"  # vendored source
+    return REPO / "upstream" / "opencv"
 
 
 def module_headers(root: Path, mod: str):
@@ -61,6 +64,7 @@ def main() -> None:
 
     for mod in MODULE_ORDER:
         names = defaultdict(set)          # sub-namespace ("", "ocl", …) -> names
+        qualified_names = defaultdict(set) # upstream namespaces outside cv
         skipped: list[str] = []
 
         def claim(fq: str, ns: str, name: str):
@@ -150,25 +154,43 @@ def add(dotted: str):
                 line = line.split("#", 1)[0].strip()
                 if not line:
                     continue
+                if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*(?:::[A-Za-z_][A-Za-z0-9_]*)*", line):
+                    raise ValueError(f"Invalid C++ export name in {curated}: {line}")
                 fq = "cv::" + line
                 parts = line.split("::")
                 claim(fq, "::".join(parts[:-1]), parts[-1])
 
-        # prune list: names that fail compile-verification (internal linkage,
-        # header not in the module's GMF, …) — maintained by tools/prune_loop.py
+        qualified_file = REPO / "tools" / "curated" / f"{mod}.qualified.txt"
+        if qualified_file.exists():
+            for raw in qualified_file.read_text().splitlines():
+                name = raw.split("#", 1)[0].strip()
+                if not name:
+                    continue
+                if not re.fullmatch(r"(?:[A-Za-z_][A-Za-z0-9_]*::)+[A-Za-z_][A-Za-z0-9_]*", name):
+                    raise ValueError(f"Invalid qualified export in {qualified_file}: {name}")
+                if name not in claimed:
+                    claimed[name] = mod
+                    namespace, leaf = name.rsplit("::", 1)
+                    qualified_names[namespace].add(leaf)
+
+        # Reviewed exceptions to using-declarations: explicit adapters or an
+        # excluded/private surface. Compile failures never edit these lists.
         prune = REPO / "tools" / "curated" / f"{mod}.prune.txt"
         if prune.exists():
-            for line in prune.read_text().splitlines():
-                line = line.split("#", 1)[0].strip()
+            for raw in prune.read_text().splitlines():
+                line, _, reason = raw.partition("#")
+                line, reason = line.strip(), reason.strip()
                 if not line:
                     continue
+                if not reason:
+                    raise ValueError(f"Export exception needs a reason: {prune}: {line}")
                 parts = line.split("::")
                 ns, leaf = "::".join(parts[:-1]), parts[-1]
                 if leaf in names[ns]:
                     names[ns].discard(leaf)
-                    skipped.append(f"pruned (compile-verify): cv::{line}")
+                    skipped.append(f"reviewed using exception: cv::{line} -- {reason}")
 
-        per_mod[mod] = {"names": names, "skipped": skipped}
+        per_mod[mod] = {"names": names, "qualified": qualified_names, "skipped": skipped}
 
     for mod in MODULE_ORDER:
         names, skipped = per_mod[mod]["names"], per_mod[mod]["skipped"]
@@ -182,8 +204,42 @@ def add(dotted: str):
                 lines.append(f"    using {fqns}::{n};")
                 total += 1
             lines.append("}")
-        (out_dir / f"{mod}.inc").write_text("\n".join(lines) + "\n")
-        (out_dir / f"{mod}.skipped.txt").write_text("\n".join(sorted(set(skipped))) + "\n")
+        for namespace, entries in sorted(per_mod[mod]["qualified"].items()):
+            lines.append(f"export namespace {namespace} {{")
+            for name in sorted(entries):
+                lines.append(f"    using {namespace}::{name};")
+                total += 1
+            lines.append("}")
+        conditional_file = REPO / "tools" / "curated" / f"{mod}.conditional.txt"
+        if conditional_file.exists():
+            for raw in conditional_file.read_text().splitlines():
+                entry = raw.split("#", 1)[0].strip()
+                if not entry:
+                    continue
+                guard, name = entry.split()
+                if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", guard) or not re.fullmatch(r"[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*", name):
+                    raise ValueError(f"Invalid conditional export in {conditional_file}: {entry}")
+                fq = "cv::" + name
+                if fq in claimed:
+                    raise ValueError(f"Conditional export also generated unconditionally: {fq}")
+                claimed[fq] = mod
+                namespace, leaf = fq.rsplit("::", 1)
+                lines += [f"#if defined({guard})", f"export namespace {namespace} {{",
+                          f"    using {fq};", "}", "#endif"]
+                total += 1
+        # OpenCV also owns public global aliases, CPU enums and helper types.
+        # Their original namespace must survive the module facade unchanged.
+        globals_file = REPO / "tools" / "curated" / f"{mod}.globals.txt"
+        if globals_file.exists():
+            for raw in globals_file.read_text().splitlines():
+                name = raw.split("#", 1)[0].strip()
+                if name:
+                    if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name):
+                        raise ValueError(f"Invalid global export in {globals_file}: {name}")
+                    lines.append(f"export using ::{name};")
+                    total += 1
+        write_if_changed(out_dir / f"{mod}.inc", "\n".join(lines) + "\n")
+        write_if_changed(out_dir / f"{mod}.skipped.txt", "\n".join(sorted(set(skipped))) + "\n")
         print(f"{mod:10} {total:4} names   ({len(skipped)} skipped notes)")
 
 
diff --git a/tools/generate_build.py b/tools/generate_build.py
new file mode 100644
index 0000000..144a712
--- /dev/null
+++ b/tools/generate_build.py
@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""Generate the mcpp manifest and feature source catalogs from pinned build data."""
+import copy
+import glob
+import json
+from pathlib import Path
+import re
+from _files import write_if_changed
+
+ROOT = Path(__file__).resolve().parents[1]
+CONFIG = ROOT / "port/config"
+
+
+def expand_braces(pattern):
+    match = re.search(r"\{([^{}]+)\}", pattern)
+    if not match:
+        return [pattern]
+    return [expanded for value in match.group(1).split(",")
+            for expanded in expand_braces(pattern[:match.start()] + value + pattern[match.end():])]
+
+
+def expand(pattern):
+    paths = {Path(path).relative_to(ROOT).as_posix()
+             for candidate in expand_braces(pattern)
+             for path in glob.glob(str(ROOT / candidate), recursive=True) if Path(path).is_file()}
+    if not paths:
+        raise ValueError(f"Source pattern matched no files: {pattern}")
+    return sorted(paths)
+
+
+def source_group(path):
+    if any(name in path for name in ("/libjpeg-turbo/", "/jpeg12/", "/jpeg16/")):
+        return "imgcodecs-jpeg"
+    if "/libpng/" in path:
+        return "imgcodecs-png"
+    if "/zlib/" in path:
+        return "core"
+    if "cap_ffmpeg" in path:
+        return "videoio-ffmpeg"
+    if "cap_v4l" in path:
+        return "videoio-v4l2"
+    match = re.search(r"/(?:modules|tu/w)/([^/]+)/", path)
+    if match:
+        return match.group(1)
+    raise ValueError(f"Unclassified source: {path}")
+
+
+def module_dependencies(name):
+    cmake = (ROOT / "upstream/opencv/modules" / name / "CMakeLists.txt").read_text()
+    match = re.search(r"ocv_(?:define|add)_module\s*\((.*?)\)", cmake, re.S)
+    if not match:
+        raise ValueError(f"No upstream module definition for {name}")
+    required = re.split(r"\b(?:OPTIONAL|WRAP|PRIVATE_REQUIRED|PRIVATE_OPTIONAL)\b", match.group(1))[0]
+    return sorted(set(re.findall(r"\bopencv_([a-z0-9_]+)\b", required)) - {"core", name})
+
+
+def scalar(value):
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, list):
+        return "[" + ", ".join(scalar(item) for item in value) + "]"
+    return str(value)
+
+
+def key(value):
+    return value if re.fullmatch(r"[A-Za-z0-9_-]+", value) else scalar(value)
+
+
+def tables(data, prefix=(), array=False):
+    output = []
+    if prefix:
+        joined = ".".join(key(part) for part in prefix)
+        output.append(("[[" + joined + "]]" if array else "[" + joined + "]") + "\n")
+    for name, value in data.items():
+        if not isinstance(value, dict) and not (isinstance(value, list) and value and isinstance(value[0], dict)):
+            output.append(f"{key(name)} = {scalar(value)}\n")
+    output.append("\n")
+    for name, value in data.items():
+        if isinstance(value, dict):
+            output += tables(value, prefix + (name,))
+        elif isinstance(value, list) and value and isinstance(value[0], dict):
+            for item in value:
+                output += tables(item, prefix + (name,), array=True)
+    return output
+
+
+def generate():
+    config = json.loads((CONFIG / "platforms.json").read_text())
+    modules = sorted(p.name for p in (ROOT / "upstream/opencv/modules").iterdir()
+                     if p.is_dir() and (ROOT / "src" / (p.name + ".cppm")).exists())
+    write_if_changed(CONFIG / "modules.txt", "\n".join(modules) + "\n")
+    dependencies = {name: module_dependencies(name) for name in modules}
+    write_if_changed(CONFIG / "module-dependencies.json", json.dumps(dependencies, indent=2) + "\n")
+    # Keep textual GMFs and named dependency imports in separate units. GCC
+    # otherwise rejects duplicate SVD defaults when core.hpp meets import core
+    # in one unit. Independent adapter units preserve upstream entity identity.
+    (ROOT / "src/detail").mkdir(exist_ok=True)
+    for name in modules:
+        if name == "core":
+            continue
+        facade = ROOT / "src" / (name + ".cppm")
+        begin, end = "// BEGIN GENERATED MODULE DEPENDENCIES", "// END GENERATED MODULE DEPENDENCIES"
+        declaration = "export module mcpplibs.mwrap.opencv." + name + ";"
+        adapter = ROOT / "src/detail" / (name + ".cppm")
+        if not adapter.exists():
+            source = facade.read_text()
+            source = re.sub(re.escape(begin) + r".*?" + re.escape(end) + r"\n*", "", source, flags=re.S)
+            assert declaration in source, facade
+            source = source.replace(declaration, "export module mcpplibs.mwrap.opencv.detail." + name + ";", 1)
+            source = source.replace('"gen_exports/', '"../gen_exports/')
+            write_if_changed(adapter, source)
+        block = "\n".join(
+            "export import mcpplibs.mwrap.opencv." + dependency + ";"
+            for dependency in ["core", *dependencies[name]])
+        write_if_changed(facade, "// Generated by tools/generate_build.py; the header adapter lives in detail.\n" +
+                          declaration + "\n\n" + block + "\nexport import mcpplibs.mwrap.opencv.detail." + name + ";\n")
+    targets = copy.deepcopy(config["target"])
+    added_modules = ["calib", "features", "objdetect", "photo", "ptcloud", "stereo", "stitching", "video"]
+    for predicate, target in targets.items():
+        build = target.get("build", {})
+        if "sources" in build:
+            os_name = {"cfg(linux)": "linux", "cfg(macos)": "macosx", "cfg(windows)": "windows"}[predicate]
+            groups = {}
+            for pattern in build.pop("sources"):
+                for path in expand(pattern):
+                    groups.setdefault(source_group(path), set()).add(path)
+            # Upstream's default module source glob is recursive. Keep all
+            # implementation subdirectories, including barcode/aruco/ccm and
+            # tracking; architecture-specific FAST is a separate x86 TU.
+            for name in added_modules:
+                sources = (ROOT / "upstream/opencv/modules" / name / "src").rglob("*.cpp")
+                groups[name] = {p.relative_to(ROOT).as_posix() for p in sources
+                                if not re.search(r"\.(?:avx\w*|sse\w*|neon)\.cpp$", p.name)}
+            if os_name in ("linux", "windows"):
+                groups["features"].add("upstream/opencv/modules/features/src/fast.avx2.cpp")
+                build.setdefault("flags", []).append({
+                    "glob": "**/features/src/fast.avx2.cpp", "cxxflags": ["-mavx2"],
+                    "defines": ["CV_CPU_COMPILE_AVX2=1", "CV_CPU_DISPATCH_MODE=AVX2"]})
+            directory = CONFIG / "sources" / os_name
+            directory.mkdir(parents=True, exist_ok=True)
+            for group, paths in sorted(groups.items()):
+                write_if_changed(directory / (group + ".txt"), "\n".join(sorted(paths)) + "\n")
+        for field in ("cflags", "cxxflags"):
+            if field in build:
+                build[field] = [flag for flag in build[field] if flag != "-DHAVE_CAMV4L2"]
+        for flags in build.get("flags", []):
+            if "defines" in flags:
+                flags["defines"] = [value for value in flags["defines"]
+                                    if value not in {"HAVE_FFMPEG", "HAVE_FFMPEG_LIBAVDEVICE"}]
+    features = {"default": []}
+    for codec in ("zlib", "libpng", "libjpeg-turbo"):
+        targets["cfg(unix)"]["build"]["flags"].append({
+            "glob": f"**/3rdparty/{codec}/**",
+            "cflags": ["-fvisibility=hidden"], "cxxflags": ["-fvisibility=hidden"]})
+    for bits in (12, 16):
+        targets["cfg(unix)"]["build"]["flags"].append({
+            "glob": f"**/tu/jpeg{bits}/**",
+            "cflags": ["-fvisibility=hidden"], "cxxflags": ["-fvisibility=hidden"]})
+    for name in modules:
+        if name == "core":
+            continue
+        features[name] = {"implies": dependencies[name], "sources": [f"src/{name}.cppm", f"src/detail/{name}.cppm"],
+                          "defines": ["HAVE_OPENCV_" + name.upper()]}
+    features["all-modules"] = {"implies": [name for name in modules if name != "core"]}
+    # Public CPU intrinsics are an opt-in utility surface, separate from the
+    # sixteen upstream algorithm modules and from private implementation ISAs.
+    features["simd"] = {"sources": ["src/core_simd.cppm", "src/detail/simd.cppm",
+                                  "src/core_simd_legacy.cppm", "src/detail/simd_legacy.cppm"]}
+    features["simd-emulated"] = {"implies": ["simd"]}
+    # Retain the upstream DNN-specific TU flags, but gate all sources through
+    # the module feature and the per-target source catalogs.
+    if "dnn" in features:
+        features["dnn"].update(copy.deepcopy(config["dnn"]))
+        features["dnn"]["implies"] = dependencies["dnn"]
+        features["dnn"]["sources"] = ["src/dnn.cppm", "src/detail/dnn.cppm"]
+    features.update({
+        "imgcodecs-jpeg": {"implies": ["imgcodecs"]},
+        "imgcodecs-png": {"implies": ["imgcodecs"]},
+        "imgcodecs-webp": {"implies": ["imgcodecs"], "flags": [
+            {"glob": "**/imgcodecs/**", "defines": ["HAVE_WEBP=1"]}]},
+        "videoio-ffmpeg": {"implies": ["videoio"], "defines": ["HAVE_FFMPEG", "HAVE_FFMPEG_LIBAVDEVICE"]},
+        "videoio-v4l2": {"implies": ["videoio"], "defines": ["HAVE_CAMV4L2"]},
+        "videoio-native": {"implies": ["videoio"]},
+        "videoio-msmf": {"implies": ["videoio"]},
+        "videoio-avfoundation": {"implies": ["videoio"]},
+        "unifont": {"implies": ["imgproc"], "defines": ["HAVE_UNIFONT"]},
+        "highgui-native": {"implies": ["highgui", "imgcodecs"]},
+        "highgui-gtk3": {"implies": ["highgui", "imgcodecs"]},
+        "highgui-win32": {"implies": ["highgui"]},
+        "highgui-cocoa": {"implies": ["highgui"]},
+        "dnn-onnxruntime": {"implies": ["dnn"], "defines": ["HAVE_ONNXRUNTIME=1"]},
+    })
+    features["videoio"]["flags"] = [{"glob": "**/modules/videoio/**", "defines": [
+        "ENABLE_PLUGINS", "NDEBUG", "__OPENCV_BUILD=1", "_USE_MATH_DEFINES",
+        "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]}]
+    # GTK's pthread compiler mode is private to its implementation TU. Baking
+    # it into a public BMI would require every consumer to use -pthread too.
+    for name in ("highgui-native", "highgui-gtk3"):
+        features[name]["flags"] = [{"glob": "**/highgui/src/window_gtk.cpp", "cxxflags": ["-pthread"]}]
+    gtk_target = targets.setdefault('cfg(all(os = "linux", env = "gnu", arch = "x86_64"))', {})
+    gtk_target["feature-xlings"] = {
+        name: {"xim:gtk3": "3.24.43", "xim:libXtst": "1.2.5"}
+        for name in ("highgui-native", "highgui-gtk3")}
+    # FFmpeg's x86 snapshots contain NASM sources. Declare the managed tool
+    # before build planning: a host NASM otherwise prevents auto-provisioning
+    # and makes strict consumers fail (notably Strawberry Perl on Windows).
+    nasm_target = targets.setdefault('cfg(all(arch = "x86_64", any(os = "linux", os = "windows")))', {})
+    nasm_target.setdefault("feature-xlings", {})["videoio-ffmpeg"] = {"xim:nasm": "3.02"}
+    build = copy.deepcopy(config["build"])
+    for name in added_modules:
+        build["include_dirs"].append(f"upstream/opencv/modules/{name}/include")
+        # These are upstream implementation flags, never public BMI flags.
+        private_defines = ["__OPENCV_BUILD=1", "NDEBUG", "_USE_MATH_DEFINES",
+                           "__STDC_CONSTANT_MACROS", "__STDC_FORMAT_MACROS", "__STDC_LIMIT_MACROS"]
+        targets["cfg(unix)"]["build"]["flags"].append({
+            "glob": f"**/modules/{name}/**", "defines": private_defines})
+        targets["cfg(windows)"]["build"]["flags"].append({
+            "glob": f"**/modules/{name}/**", "defines": private_defines})
+    # The bundled zlib is an implementation detail, not another provider of
+    # the public zlib ABI used by GUI SDKs and other dependencies.
+    build.setdefault("defines", []).append("Z_PREFIX")
+    # build.mcpp emits the selected interface with concrete imports after
+    # feature resolution, before mcpp scans the generated module.
+    build["sources"] = ["src/opencv.cppm", "src/core.cppm", "src/detail/core.cppm", "src/detail/matx.cppm", "src/macros.cppm"]
+    notices = [ROOT / "LICENSE", ROOT / "NOTICE", ROOT / "upstream/opencv/README.md", ROOT / "port/licenses/UPSTREAM_SOURCE_NOTICES.txt", *sorted(
+        path for path in (ROOT / "upstream/opencv").rglob("*")
+        if path.is_file() and any(word in path.name for word in
+                                 ("LICENSE", "COPYING", "COPYRIGHT", "NOTICE")))]
+    # Static implementation objects do not appear in a shared-library license
+    # scan. Preserve each retained notice explicitly, including its source path
+    # so unrelated LICENSE basenames cannot overwrite one another.
+    license_deploy = []
+    for path in notices:
+        relative = path.relative_to(ROOT)
+        destination = "licenses/opencv"
+        if relative.parent != Path("."):
+            destination += "/" + relative.parent.as_posix()
+        license_deploy.append({"from": relative.as_posix(), "to": destination})
+    # The ORT CPU SDK brings a shared GNU C++ runtime on ELF. Local executables
+    # and tests must not embed a competing exception runtime. This is the same
+    # contract used by the standalone ORT project and the ORT consumer template.
+    targets.setdefault("x86_64-linux-gnu", {})["cxx_runtime"] = "toolchain-coupled"
+    manifest = {
+        "package": {"namespace": "mcpplibs.mwrap", "name": "opencv", "version": "5.0.0",
+                    "description": "OpenCV 5.0.0 public C++ APIs through optional mwrap modules",
+                    "license": "Apache-2.0", "authors": ["mcpp-community"], "repo": "https://github.com/mcpplibs/opencv-m",
+                    "metadata": {"mwrap": {"upstream-version": "5.0.0", "wrapper-revision": 0}}},
+        "build": build, "target": targets,
+        "runtime": {"deploy": license_deploy},
+        "dev-dependencies": {"compat": {"gtest": "1.15.2"}},
+        "features": features,
+        "feature-deps": {"videoio-ffmpeg": {"compat": {"ffmpeg": "8.1.2"}},
+                         "imgcodecs-webp": {"compat": {"libwebp": {
+                             "version": "1.5.0", "features": ["demux", "mux"]}}},
+                         "dnn-onnxruntime": {"mcpplibs.mwrap": {"onnxruntime": "1.25.1"}}},
+        "targets": {"opencv": {"kind": "lib"}},
+    }
+    write_if_changed(ROOT / "mcpp.toml",
+        ("# Generated by tools/generate_build.py; edit port/config inputs.\n" + "".join(tables(manifest))).rstrip() + "\n")
+    # The installed header contains only the mandatory module; optional
+    # availability names come from the selected package features.
+    write_if_changed(ROOT / "generated/common/opencv2/opencv_modules.hpp",
+        "#pragma once\n#define HAVE_OPENCV_CORE\n")
+
+
+if __name__ == "__main__":
+    generate()
diff --git a/tools/generate_cuda_helpers.py b/tools/generate_cuda_helpers.py
new file mode 100644
index 0000000..11045e3
--- /dev/null
+++ b/tools/generate_cuda_helpers.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Generate CPU-usable cuda.hpp helpers and exact SDK Event flag operators."""
+import argparse
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+from generate_inline_helpers import bodies, license_for
+
+ROOT = Path(__file__).resolve().parents[1]
+SDK = ROOT / "upstream/opencv/modules/core/include/opencv2/core"
+
+
+def generate():
+    source = (SDK / "cuda.inl.hpp").read_text()
+    helpers = list(bodies(source, ["createContinuous", "ensureSizeIsEnough", "swap"], False))
+    assert len(helpers) == 6, len(helpers)
+    result = "// Generated by tools/generate_cuda_helpers.py; original SDK bodies retained.\n"
+    result += license_for(source, "core/cuda.inl.hpp")
+    result += '''namespace opencv_m_cuda_up {
+inline constexpr auto create = static_cast<void (*)(int, int, int, cv::OutputArray)>(&cv::cuda::createContinuous);
+inline constexpr auto ensure = static_cast<void (*)(int, int, int, cv::OutputArray)>(&cv::cuda::ensureSizeIsEnough);
+}
+export namespace cv { namespace cuda { inline namespace opencv_m_cuda_repl {
+'''
+    prefix = "template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D> inline "
+    functions = [
+        ("void createContinuous(int rows, int cols, int type, OutputArray arr)",
+         "{ ::opencv_m_cuda_up::create(rows, cols, type, arr); }"),
+        ("void ensureSizeIsEnough(int rows, int cols, int type, OutputArray arr)",
+         "{ ::opencv_m_cuda_up::ensure(rows, cols, type, arr); }"),
+    ]
+    for _, head, body in helpers:
+        for name in ("createContinuous", "ensureSizeIsEnough"):
+            body = re.sub(r"(?<![\w:])" + name + r"\(", "::cv::cuda::opencv_m_cuda_repl::" + name + "(", body)
+        functions.append((" ".join(head.split()), body))
+    result += "\n".join(prefix + head + ";" for head, _ in functions) + "\n\n"
+    result += "\n\n".join(prefix.replace("_D = void", "_D") + head + "\n" + body for head, body in functions)
+    result += "\n} } } // cv::cuda::opencv_m_cuda_repl\n"
+
+    # Expand the pinned macro definitions rather than transcribing flag algebra.
+    source = (SDK / "cvdef.h").read_text()
+    definitions = {}
+    for match in re.finditer(r"(?m)^#define (__CV_ENUM_FLAGS_\w+)\(([^\n)]*)\)", source):
+        end = source.index("\n", match.end()) + 1
+        while source[source.rfind("\n", 0, end - 1) + 1:end].rstrip().endswith("\\"):
+            end = source.index("\n", end) + 1
+        body = source[match.end():end].replace("\\\n", "\n").strip()
+        definitions[match[1]] = (match[2].split(","), body)
+    invocation = source[source.index("#define CV_ENUM_FLAGS(EnumType)"):]
+    invocation = invocation[:invocation.index("/****************************************************************")]
+    operators = re.findall(r"(__CV_ENUM_FLAGS_\w+)\s*\(([^)]+)\)", invocation)
+    assert len(operators) == 10, len(operators)
+    cuda_header = (SDK / "cuda.hpp").read_text()
+    assert "CV_ENUM_FLAGS(Event::CreateFlags)" in cuda_header
+    result += license_for(source, "core/cvdef.h")
+    result += "export namespace cv { namespace cuda { inline namespace opencv_m_cuda_repl {\n"
+    for name, arguments in operators:
+        parameters, body = definitions[name]
+        values = [value.strip().replace("EnumType", "Event::CreateFlags") for value in arguments.split(",")]
+        assert len(values) == len(parameters)
+        for parameter, value in zip(parameters, values):
+            body = re.sub(r"\b" + parameter.strip() + r"\b", value, body)
+        assert body.startswith("static inline "), body
+        result += prefix + body.removeprefix("static inline ") + "\n\n"
+    result += "} } } // cv::cuda::opencv_m_cuda_repl\n"
+    return "\n".join(line.rstrip() for line in result.splitlines()) + "\n"
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    output = ROOT / "src/cuda_helpers.inc"
+    content = generate()
+    if args.check:
+        assert output.read_text() == content, "Run python3 tools/generate_cuda_helpers.py"
+    else:
+        write_if_changed(output, content)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_dnn_shapes.py b/tools/generate_dnn_shapes.py
new file mode 100644
index 0000000..ccd26cd
--- /dev/null
+++ b/tools/generate_dnn_shapes.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Retain pinned DNN shape-helper bodies while adapting TU-local linkage."""
+import argparse
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--check", action="store_true")
+args = parser.parse_args()
+source = (ROOT / "upstream/opencv/modules/dnn/include/opencv2/dnn/shape_utils.hpp").read_text()
+body = source.split("//Slicing", 1)[1].split("CV__DNN_INLINE_NS_END", 1)[0]
+# _Range remains the actual SDK class, exported in gen_exports/dnn.inc.
+body, ranges = re.subn(r"struct _Range : public cv::Range\n\{.*?\n\};", "", body, flags=re.S)
+assert ranges == 1
+body, disabled = re.subn(r"#if 0.*?#endif", "", body, flags=re.S)
+assert disabled == 1
+body, anonymous = re.subn(r"namespace \{inline bool is_neg\(int i\) \{ return i < 0; \}\}", "", body)
+assert anonymous == 1
+body, templates = re.subn(r"template<typename _Tp>\nstatic inline", "template<typename _Tp> requires shape_pick<_Tp> inline", body)
+assert templates == 3
+body, functions = re.subn(r"static inline\s+", "template<class _D = void> requires shape_pick<_D> inline ", body)
+assert functions == 17, functions
+# Keep calls between helpers in this adapter, rather than referring from an
+# exported template to the SDK's internal-linkage global-module functions.
+for helper in ("shape", "toString", "normalize_axis"):
+    body = re.sub(r"(?<![.\w:])" + helper + r"\(",
+                  "::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::" + helper + "(", body)
+    # Definitions themselves must retain their unqualified declarator.
+    body = re.sub(r"(inline (?:MatShape|std::string|int) )::cv::dnn::CV__DNN_INLINE_NS::opencv_m_shape::" + helper,
+                  r"\1" + helper, body)
+license_text = source[:source.index("#ifndef OPENCV_DNN_DNN_SHAPE_UTILS_HPP")]
+result = ("// Generated by tools/generate_dnn_shapes.py. Included inside the exported shape adapter.\n"
+          + license_text + body.strip() + "\n")
+output = ROOT / "src/dnn_shapes.inc"
+if args.check:
+    assert output.read_text() == result, "Run python3 tools/generate_dnn_shapes.py"
+else:
+    output.write_text(result)
diff --git a/tools/generate_inline_helpers.py b/tools/generate_inline_helpers.py
new file mode 100644
index 0000000..d638a1c
--- /dev/null
+++ b/tools/generate_inline_helpers.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""Restore portable static-inline helpers from the pinned public SDK headers."""
+import argparse
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+from generate_persistence import braced_end
+
+ROOT = Path(__file__).resolve().parents[1]
+SDK = ROOT / "upstream/opencv/modules"
+
+
+def bodies(source, names, templated):
+    prefix = r"template<([^>\n]+)>\s+static inline\s+" if templated else r"(?:CV_WRAP\s+)?static inline\s+"
+    pattern = re.compile(r"(?m)^" + prefix + r"([^;{}]+?)\s*\{")
+    for match in pattern.finditer(source):
+        head = match[2] if templated else match[1]
+        name = re.search(r"\b(" + "|".join(names) + r")\s*\(", head)
+        if not name:
+            continue
+        opening = match.end() - 1
+        body = source[opening:braced_end(source, opening)]
+        yield (match[1] if templated else "class _D = void"), head.strip(), body
+
+
+def license_for(source, name):
+    return "// SDK source: " + name + "\n" + source[:source.index("#ifndef")]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    core = "// Generated by tools/generate_inline_helpers.py; SDK bodies with module lookup/raw-array fixes.\n"
+    expected = {"base.hpp": 6, "utility.hpp": 5, "types.hpp": 1, "mat.inl.hpp": 3}
+    names = {"base.hpp": ["normL1", "normL2Sqr", "normInf"], "utility.hpp": ["isAligned"],
+             "types.hpp": ["jaccardDistance"], "mat.inl.hpp": ["rawIn", "rawOut", "rawInOut"]}
+    for header in expected:
+        source = (SDK / "core/include/opencv2/core" / header).read_text()
+        functions = list(bodies(source, names[header], True))
+        assert len(functions) == expected[header], (header, len(functions))
+        core += license_for(source, "core/" + header)
+        core += "export namespace cv { inline namespace opencv_m_repl {\n"
+        for template, head, body in functions:
+            body = re.sub(r"(?<![\w:])isAligned<", "::cv::opencv_m_repl::isAligned<", body)
+            body = re.sub(r"(?<![\w:])cv_abs(diff)?\(", r"::cv::cv_abs\1(", body)
+            if header == "mat.inl.hpp" and " rawInOut(" in head:
+                # OpenCV 5 omits `static` on the std::array member overload.
+                # Calling through an instance supports that original member
+                # and is equivalent for the existing static vector overload.
+                declaration = (SDK / "core/include/opencv2/core/mat.hpp").read_text()
+                assert re.search(r"template<typename _Tp, std::size_t _Nm>\s+_InputOutputArray rawInOut\(std::array<_Tp, _Nm>& arr\);", declaration)
+                assert body.count("_InputOutputArray::rawInOut(v)") == 1
+                body = body.replace("_InputOutputArray::rawInOut(v)", "_InputOutputArray().rawInOut(v)")
+            core += f"template<{template}> requires opencv_m_pick<void>\ninline {head}\n{body}\n\n"
+        core += "} } // cv::opencv_m_repl\n"
+
+    source = (SDK / "imgproc/include/opencv2/imgproc.hpp").read_text()
+    image = "// Generated by tools/generate_inline_helpers.py; SDK bodies retained.\n" + license_for(source, "imgproc.hpp")
+    image += '''namespace opencv_m_imgproc_up {
+inline constexpr auto wide_angle = static_cast<float (*)(cv::InputArray, cv::InputArray,
+    cv::Size, int, int, cv::OutputArray, cv::OutputArray, cv::UndistortTypes, double)>(&cv::initWideAngleProjMap);
+}
+export namespace cv { inline namespace opencv_m_imgproc_repl {
+template<class> inline constexpr bool pick = true;
+template<class _D = void> requires pick<_D>
+inline float initWideAngleProjMap(InputArray cameraMatrix, InputArray distCoeffs,
+    Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2,
+    UndistortTypes projType = PROJ_SPHERICAL_EQRECT, double alpha = 0) {
+    return ::opencv_m_imgproc_up::wide_angle(cameraMatrix, distCoeffs, imageSize,
+        destImageWidth, m1type, map1, map2, projType, alpha);
+}
+'''
+    functions = list(bodies(source, ["morphologyDefaultBorderValue", "initWideAngleProjMap"], False))
+    assert len(functions) == 2, len(functions)
+    for template, head, body in functions:
+        body = re.sub(r"(?<![\w:])initWideAngleProjMap\(", "::cv::opencv_m_imgproc_repl::initWideAngleProjMap(", body)
+        image += f"template<{template}> requires pick<_D>\ninline {head}\n{body}\n\n"
+    image += "} } // cv::opencv_m_imgproc_repl\n"
+
+    source = (SDK / "imgcodecs/include/opencv2/imgcodecs.hpp").read_text()
+    codecs = "// Generated by tools/generate_inline_helpers.py; SDK body retained.\n" + license_for(source, "imgcodecs.hpp")
+    codecs += "export namespace cv { inline namespace opencv_m_imgcodecs_repl {\n"
+    codecs += "template<class> inline constexpr bool pick = true;\n"
+    functions = list(bodies(source, ["imwritemulti"], False))
+    assert len(functions) == 1, len(functions)
+    for template, head, body in functions:
+        body = body.replace("return imwrite(", "return ::cv::imwrite(")
+        codecs += f"template<{template}> requires pick<_D>\ninline {head}\n{body}\n"
+    codecs += "} } // cv::opencv_m_imgcodecs_repl\n"
+    # Global fast-math overload sets mix internal platform-specific functions
+    # and external SoftFloat functions. Capture each exact original overload
+    # before declaring constrained public forwards in a global inline namespace.
+    fast_source = (SDK / "core/include/opencv2/core/fast_math.hpp").read_text()
+    fast_signatures = re.findall(
+        r"CV_INLINE int\s+(cv(?:Round|Floor|Ceil|IsNaN|IsInf))\s*\(\s*(float|double|int) value\s*\)",
+        fast_source)
+    assert len(fast_signatures) == 13, fast_signatures
+    signatures = [(name, value_type + " value", "value") for name, value_type in fast_signatures]
+    soft_source = (SDK / "core/include/opencv2/core/softfloat.hpp").read_text()
+    soft_signatures = re.findall(
+        r"CV_EXPORTS int\s+(cv(?:Round|Floor|Ceil))\(const cv::(softfloat|softdouble)&\s+a\);", soft_source)
+    assert len(soft_signatures) == 6, soft_signatures
+    signatures += [(name, "const cv::" + value_type + "& value", "value") for name, value_type in soft_signatures]
+    cvdef_source = (SDK / "core/include/opencv2/core/cvdef.h").read_text()
+    assert "CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4)" in cvdef_source
+    signatures.append(("CV_FOURCC", "char c1, char c2, char c3, char c4", "c1, c2, c3, c4"))
+    fast = "// Generated by tools/generate_inline_helpers.py; exact SDK platform function forwards.\n"
+    fast += "namespace opencv_m_fast_math_bridge {\n"
+    for name, parameters, arguments in signatures:
+        fast += f"int {name}({parameters}) {{ return ::{name}({arguments}); }}\n"
+    fast += "}\nexport inline namespace opencv_m_fast_math_repl {\n"
+    for name, parameters, arguments in signatures:
+        fast += "template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>\n"
+        fast += f"inline int {name}({parameters}) {{ return ::opencv_m_fast_math_bridge::{name}({arguments}); }}\n"
+    fast += "}\n"
+    source = (SDK / "core/include/opencv2/core/bindings_utils.hpp").read_text()
+    public = source[:source.index("//! @cond IGNORED")]
+    names = ["dumpBool", "dumpInt", "dumpInt64", "dumpSizeT", "dumpFloat", "dumpDouble",
+             "dumpCString", "dumpString", "dumpRect", "dumpTermCriteria", "dumpRotatedRect", "dumpRange"]
+    helpers = list(bodies(public, names, False))
+    assert len(helpers) == 12, len(helpers)
+    utils = "// Generated by tools/generate_inline_helpers.py; exact original SDK utility forwards.\n"
+    utils += "namespace opencv_m_utils_up {\n"
+    utils += "using cv::String; using cv::Rect; using cv::TermCriteria; using cv::RotatedRect; using cv::Range;\n"
+    for _, head, _ in helpers:
+        name = re.search(r"\b(dump\w+)\(", head)[1]
+        utils += f"{head} {{ return ::cv::utils::{name}(argument); }}\n"
+    utils += "}\nexport namespace cv { namespace utils { inline namespace opencv_m_utils_repl {\n"
+    for _, head, _ in helpers:
+        name = re.search(r"\b(dump\w+)\(", head)[1]
+        utils += "template<class _D = void> requires ::cv::opencv_m_repl::opencv_m_pick<_D>\n"
+        utils += f"inline {head} {{ return ::opencv_m_utils_up::{name}(argument); }}\n"
+    utils += "} } } // cv::utils::opencv_m_utils_repl\n"
+    for name, content in [("portable_helpers.inc", core), ("imgproc_helpers.inc", image),
+                          ("imgcodecs_helpers.inc", codecs), ("fast_math_helpers.inc", fast),
+                          ("utils_helpers.inc", utils)]:
+        output = ROOT / "src" / name
+        if args.check:
+            assert output.read_text() == content, "Run python3 tools/generate_inline_helpers.py: " + name
+        else:
+            write_if_changed(output, content)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_macros.py b/tools/generate_macros.py
new file mode 100644
index 0000000..098f405
--- /dev/null
+++ b/tools/generate_macros.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Generate typed OpenCV type/layout macro mappings from pinned headers.
+
+Declaration/annotation/control-flow macros remain available through the textual
+side header. This module maps values and pure type/layout calculations only.
+"""
+import argparse
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def generate():
+    header = ROOT / "upstream/opencv/modules/core/include/opencv2/core/hal/interface.h"
+    constants = [name for name, _ in re.findall(
+        r"^#define (CV_\w+)[ \t]+([^\n]+)", header.read_text(), re.M)
+        if name not in {"CV_USRTYPE1", "CV_MAKE_TYPE"}]
+    constants += ["CV_VERSION_MAJOR", "CV_VERSION_MINOR", "CV_VERSION_REVISION",
+                  "CV_VERSION", "CV_VERSION_STATUS", "CV_PI", "CV_2PI", "CV_LOG2",
+                  "CV_MAX_DIM", "CV_MAT_CN_MASK", "CV_MAT_TYPE_MASK",
+                  "CV_MAT_CONT_FLAG_SHIFT", "CV_MAT_CONT_FLAG", "CV_SUBMAT_FLAG_SHIFT",
+                  "CV_SUBMAT_FLAG", "CV_AUTOSTEP"]
+    hal_headers = ["features/hal/interface.h", "imgproc/hal/interface.h"]
+    for relative in hal_headers:
+        module = relative.split("/", 1)[0]
+        source = (ROOT / "upstream/opencv/modules" / module / "include/opencv2" / relative).read_text()
+        constants += re.findall(r"^#define (CV_HAL_\w+)[ \t]+[^\n]+", source, re.M)
+    unary = ["CV_MAT_DEPTH", "CV_IS_INT_TYPE", "CV_IS_FLOAT_TYPE", "CV_MAT_CN",
+             "CV_MAT_TYPE", "CV_IS_MAT_CONT", "CV_IS_CONT_MAT", "CV_ELEM_SIZE1", "CV_ELEM_SIZE"]
+    unary += re.findall(r"^#define (CV_\w+C)\(n\)", header.read_text(), re.M)
+    functions = {name: ("int value", "value") for name in unary}
+    functions.update({name: ("int depth, int channels", "depth, channels")
+                      for name in ("CV_MAKETYPE", "CV_MAKE_TYPE")})
+    simd_constants = ["CV_SIMD", "CV_SIMD_WIDTH", "CV_SIMD_64F", "CV_SIMD_FP16",
+                      "CV_SIMD128", "CV_SIMD128_CPP", "CV_SIMD128_64F", "CV_SIMD128_FP16",
+                      "CV_SIMD256", "CV_SIMD256_64F", "CV_SIMD256_FP16",
+                      "CV_SIMD512", "CV_SIMD512_64F", "CV_SIMD512_FP16", "CV_SIMD_SCALABLE"]
+    lines = ["// Generated by tools/generate_macros.py; do not edit.", "module;",
+             "#include <opencv2/core.hpp>", "#include <opencv2/core/version.hpp>",
+             *[f"#include <opencv2/{path}>" for path in hal_headers],
+             "#if defined(MCPP_FEATURE_SIMD)", "#include <mwrap/opencv/simd.hpp>", "#endif", "",
+             "export module mcpplibs.mwrap.opencv.macros;", "",
+             "namespace opencv_m_macro_detail {"]
+    lines += [f"inline constexpr auto k_{name} = {name};" for name in constants]
+    lines += ["#if defined(MCPP_FEATURE_SIMD)",
+              *[f"inline constexpr auto k_{name} = {name};" for name in simd_constants], "#endif"]
+    lines += [f"constexpr int k_{name}({params}) {{ return {name}({args}); }}"
+              for name, (params, args) in functions.items()]
+    lines += ["template<class A, class B, class C, class D>",
+              "constexpr auto k_CV_FOURCC_MACRO(A a, B b, C c, D d) { return CV_FOURCC_MACRO(a, b, c, d); }"]
+    # OpenCV 5.0.0's CV_IS_SUBMAT references an undefined CV_MAT_SUBMAT_FLAG.
+    # Adapt that single typed mapping to the actual upstream Mat flag. The
+    # optional raw side header retains the original upstream macro unchanged.
+    lines += ["constexpr int k_CV_IS_SUBMAT(int flags) { return flags & CV_SUBMAT_FLAG; }", "}", ""]
+    lines += [f"#undef {name}" for name in [*constants, *functions, "CV_IS_SUBMAT", "CV_FOURCC_MACRO"]]
+    lines += ["#if defined(MCPP_FEATURE_SIMD)", *[f"#undef {name}" for name in simd_constants], "#endif"]
+    lines += ["", "export namespace mcpplibs::mwrap::opencv::macros {"]
+    lines += [f"inline constexpr auto {name} = opencv_m_macro_detail::k_{name};" for name in constants]
+    lines += ["#if defined(MCPP_FEATURE_SIMD)",
+              *[f"inline constexpr auto {name} = opencv_m_macro_detail::k_{name};" for name in simd_constants], "#endif"]
+    lines += [f"constexpr int {name}({params}) {{ return opencv_m_macro_detail::k_{name}({args}); }}"
+              for name, (params, args) in functions.items()]
+    lines += ["template<class A, class B, class C, class D>",
+              "constexpr auto CV_FOURCC_MACRO(A a, B b, C c, D d) { return opencv_m_macro_detail::k_CV_FOURCC_MACRO(a, b, c, d); }"]
+    lines += ["// Repair the upstream 5.0.0 CV_MAT_SUBMAT_FLAG typo for the typed mapping.",
+              "constexpr int CV_IS_SUBMAT(int flags) { return opencv_m_macro_detail::k_CV_IS_SUBMAT(flags); }", "}", ""]
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    path = ROOT / "src/macros.cppm"
+    content = generate()
+    if args.check:
+        if path.read_text() != content:
+            raise SystemExit("src/macros.cppm is stale; run tools/generate_macros.py")
+    else:
+        path.write_text(content)
diff --git a/tools/generate_mat_aug_ops.py b/tools/generate_mat_aug_ops.py
new file mode 100644
index 0000000..25bd1dd
--- /dev/null
+++ b/tools/generate_mat_aug_ops.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Generate pinned SDK Mat assignment, expression and initializer adapters."""
+import argparse
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+from generate_persistence import braced_end
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def arguments(text):
+    result, start, depth = [], 0, 0
+    for position, char in enumerate(text):
+        if char in "(<":
+            depth += 1
+        elif char in ")>":
+            depth -= 1
+        elif char == "," and depth == 0:
+            result.append(text[start:position].strip())
+            start = position + 1
+    assert depth == 0, text
+    return [*result, text[start:].strip()]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    source = (ROOT / "upstream/opencv/modules/core/include/opencv2/core/operations.hpp").read_text()
+    entries = re.findall(r"(?m)^CV_MAT_AUG_OPERATOR(_TN|_T)?\s*\((.*)\)$", source)
+    assert len(entries) == 49, len(entries)
+    result = "// Generated by tools/generate_mat_aug_ops.py; SDK macro bodies/signatures retained.\n"
+    result += source[:source.index("#ifndef")]
+    result += "export namespace cv { inline namespace opencv_m_repl {\n"
+    for kind, text in entries:
+        values = arguments(text)
+        op, body, left = values[:3]
+        if kind == "_TN":
+            assert len(values) == 3
+            template, right = "typename _Tp, int m, int n", "Matx<_Tp,m,n>"
+        elif kind == "_T":
+            assert len(values) == 4
+            template, right = "typename _Tp", values[3]
+        else:
+            assert len(values) == 4
+            template, right = "class _D = void", values[3]
+        constraint = "opencv_m_pick<_Tp>" if kind else "opencv_m_pick<_D>"
+        for const in ("", "const "):
+            result += (f"template<{template}> requires {constraint}\n"
+                       f"inline {const}{left}& operator {op} ({const}{left}& a, const {right}& b)\n"
+                       f"{{ {body}; return a; }}\n\n")
+    expression_source = (ROOT / "upstream/opencv/modules/core/include/opencv2/core/mat.inl.hpp").read_text()
+    pattern = re.compile(r"(?m)^(?:template<([^\n>]+)>\s*)?static inline\s+([^{};]+?)\s*\{")
+    expressions = []
+    for match in pattern.finditer(expression_source):
+        head = " ".join(match[2].split())
+        if "const MatExpr& b" not in head or not re.search(r"operator\s*(?:\+=|-=|\*=|/=)\s*\(", head):
+            continue
+        template = match[1] or "class _D = void"
+        assert template in {"typename _Tp", "class _D = void"}, template
+        constraint = "opencv_m_pick<_Tp>" if match[1] else "opencv_m_pick<_D>"
+        opening = match.end() - 1
+        body = expression_source[opening:braced_end(expression_source, opening)]
+        expressions.append(f"template<{template}> requires {constraint}\ninline {head}\n{body}\n")
+    assert len(expressions) == 16, len(expressions)
+    comma_pattern = re.compile(r"template<([^\n>]+)>\s+CV_DEPRECATED_EXTERNAL static inline\s+(MatCommaInitializer_[^{};]+?)\s*\{")
+    comma = list(comma_pattern.finditer(expression_source))
+    assert len(comma) == 1 and comma[0][1] == "typename _Tp, typename T2"
+    match = comma[0]
+    opening = match.end() - 1
+    expressions.append("template<" + match[1] + "> requires opencv_m_pick<_Tp>\n[[deprecated]] inline "
+                       + " ".join(match[2].split()) + "\n" + expression_source[opening:braced_end(expression_source, opening)] + "\n")
+    result += expression_source[:expression_source.index("#ifndef")]
+    result += "\n".join(expressions)
+    result += "} } // cv::opencv_m_repl\n"
+    path = ROOT / "src/mat_aug_ops.inc"
+    if args.check:
+        assert path.read_text() == result, "Run python3 tools/generate_mat_aug_ops.py"
+    else:
+        write_if_changed(path, result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_objdetect_constants.py b/tools/generate_objdetect_constants.py
new file mode 100644
index 0000000..73f6dcd
--- /dev/null
+++ b/tools/generate_objdetect_constants.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Map the SDK TU-local ArUco float without an imported auto/APValue chain."""
+import argparse
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    source = (ROOT / "upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp").read_text()
+    match = re.search(r"static constexpr float DEFAULT_VALID_BIT_ID_THRESHOLD\{([0-9.]+f)\};", source)
+    assert match, "Review the upstream constant declaration before regenerating"
+    result = "// Generated by tools/generate_objdetect_constants.py; original SDK float token retained.\n"
+    result += "// An explicit scalar avoids importing a deduced-auto initializer through a private SDK object.\n"
+    result += "export namespace cv::aruco { inline namespace opencv_m_constants {\n"
+    result += f"inline constexpr float DEFAULT_VALID_BIT_ID_THRESHOLD = {match[1]};\n"
+    result += "} }\n"
+    output = ROOT / "src/objdetect_constants.inc"
+    if args.check:
+        assert output.read_text() == result, "Run python3 tools/generate_objdetect_constants.py"
+    else:
+        write_if_changed(output, result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_ort_model.py b/tools/generate_ort_model.py
new file mode 100644
index 0000000..8ef0bc4
--- /dev/null
+++ b/tools/generate_ort_model.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Generate a small ONNX Add model, IR8/opset13, float[1,3] -> float[1,3]."""
+import argparse
+from pathlib import Path
+
+
+def varint(value):
+    out = bytearray()
+    while value > 127:
+        out.append((value & 127) | 128)
+        value >>= 7
+    out.append(value)
+    return bytes(out)
+
+
+def field(number, value):
+    if isinstance(value, int):
+        return varint(number << 3) + varint(value)
+    if isinstance(value, str):
+        value = value.encode()
+    return varint((number << 3) | 2) + varint(len(value)) + value
+
+
+def model():
+    shape = field(1, field(1, 1)) + field(1, field(1, 3))
+    tensor_type = field(1, 1) + field(2, shape)
+    def value_info(name):
+        return field(1, name) + field(2, field(1, tensor_type))
+    node = field(1, "x") + field(1, "x") + field(2, "y") + field(3, "double_input") + field(4, "Add")
+    graph = field(1, node) + field(2, "mwrap_opencv_ort")
+    graph += field(11, value_info("x")) + field(12, value_info("y"))
+    return field(1, 8) + field(2, "mwrap-fixture") + field(7, graph) + field(8, field(2, 13))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    content = model()
+    header = "#pragma once\ninline constexpr unsigned char opencv_ort_model[] = {"
+    header += ", ".join(f"0x{x:02x}" for x in content) + "};\n"
+    outputs = {root / "tests/fixtures/ort_add.onnx": content,
+               root / "tests/fixtures/ort_model.hpp": header.encode(),
+               root / "templates/onnxruntime/src/model.hpp": header.encode()}
+    for path, data in outputs.items():
+        if args.check:
+            assert path.read_bytes() == data, str(path)
+        else:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(data)
diff --git a/tools/generate_persistence.py b/tools/generate_persistence.py
new file mode 100644
index 0000000..a89a401
--- /dev/null
+++ b/tools/generate_persistence.py
@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Adapt pinned SDK persistence helpers without changing their data formats."""
+import argparse
+from pathlib import Path
+import re
+from _files import write_if_changed
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def split_top(text, separator):
+    parts, start, depth, quoted, escaped = [], 0, [], '', False
+    for i, char in enumerate(text):
+        if quoted:
+            if escaped:
+                escaped = False
+            elif char == '\\':
+                escaped = True
+            elif char == quoted:
+                quoted = ''
+            continue
+        if char in '\"\'':
+            quoted = char
+        elif char in '(<[':
+            depth.append(char)
+        elif char in ')>]':
+            if depth:
+                depth.pop()
+        elif char == separator and not depth:
+            parts.append(text[start:i]); start = i + 1
+    return [*parts, text[start:]]
+
+
+def without_defaults(text):
+    return ', '.join(split_top(part, '=')[0].strip() for part in split_top(text, ','))
+
+
+def braced_end(text, start):
+    depth = 0
+    for i in range(start, len(text)):
+        if text[i] == '{': depth += 1
+        elif text[i] == '}':
+            depth -= 1
+            if not depth: return i + 1
+    raise AssertionError('Unclosed upstream definition')
+
+
+def adapt_head(head):
+    head = re.sub(r'\bstatic\s+inline\s*', '', head).strip()
+    if head.startswith('template<'):
+        depth = 0
+        opening = head.index('<')
+        for closing in range(opening, len(head)):
+            if head[closing] == '<': depth += 1
+            elif head[closing] == '>':
+                depth -= 1
+                if not depth: break
+        assert depth == 0
+        args = head[opening + 1:closing]
+        head = head[closing + 1:].strip()
+        if not args:
+            prefix = 'template<> '
+        else:
+            if 'std::enable_if' in args:
+                assert '_Tp' in args
+                # The valid SDK parameter type is void*. Keep the optional
+                # template argument without exporting its dependent enable_if
+                # type, which crashes Clang's module deserializer.
+                args = 'typename _Tp, void* _Enable = nullptr'
+                constraint = '(std::is_enum_v<_Tp> && opencv_m_pick<_Tp>)'
+            else:
+                assert '_Tp' in args, args
+                constraint = 'opencv_m_pick<_Tp>'
+            prefix = f'template<{args}> requires {constraint} '
+    else:
+        prefix = 'template<class _D = void> requires opencv_m_pick<_D> '
+    head = re.sub(r'^inline\s+', '', head)
+    signature = ' '.join(head.split())
+    assert '(' in signature and ')' in signature, (head, signature)
+    left, right = signature.index('('), signature.rindex(')')
+    definition = signature[:left + 1] + without_defaults(signature[left + 1:right]) + signature[right:]
+    definition_prefix = prefix.replace('_D = void', '_D').replace(' = nullptr', '')
+    return prefix + 'inline ' + signature, definition_prefix + 'inline ' + definition
+
+
+def adapt_body(body):
+    body = body.replace('cv::internal::VecWriterProxy', '::cv::opencv_m_storage_detail::VecWriterProxy')
+    body = body.replace('cv::internal::VecReaderProxy', '::cv::opencv_m_storage_detail::VecReaderProxy')
+    # Preserve custom serializers through ADL only when no built-in adapter
+    # handles the type. Built-ins must not rediscover SDK TU-local overloads.
+    body = re.sub(r'\bwrite\(\s*fs,\s*(String\(\)|fs\.elname),\s*value\s*\)',
+                  r'::cv::opencv_m_storage_detail::write_value(fs, \1, value)', body)
+    body = re.sub(r'\bread\(\s*(\*it|n),\s*value,\s*_Tp\(\)\s*\)',
+                  r'::cv::opencv_m_storage_detail::read_value(\1, value, _Tp())', body)
+    body = re.sub(r'(?<![\w:.])write\s*\(', '::cv::opencv_m_repl::write(', body)
+    body = re.sub(r'(?<![\w:.])read\s*\(', '::cv::opencv_m_repl::read(', body)
+    # These are the SDK's iterator extraction chains, not shift arithmetic.
+    def chain(match):
+        expression = 'it'
+        for value in match[1].split('>>'):
+            expression = f'::cv::opencv_m_repl::operator>>({expression}, {value.strip()})'
+        return expression + ';'
+    body = re.sub(r'\bit\s*>>\s*([^;]+);', chain, body)
+    body = re.sub(r'return \(fs << String\((str|value)\)\);',
+                  r'return ::opencv_m_persistence_up::insert_string(fs, String(\1));', body)
+    return body
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--check', action='store_true')
+    args = parser.parse_args()
+    source = (ROOT / 'upstream/opencv/modules/core/include/opencv2/core/persistence.hpp').read_text()
+    marker = re.compile(r'(?m)^(?:template<[^\n]+>\s*)?static inline\s+|^template<> inline\s+')
+    functions = []
+    end = 0
+    for match in marker.finditer(source):
+        if match.start() < end: continue
+        opening = source.index('{', match.end()); end = braced_end(source, opening)
+        head, body = source[match.start():opening], source[opening:end]
+        assert re.search(r'\b(?:read|write)\s*\(|operator\s*(?:<<|>>|-|<)\s*\(', head), head
+        declaration, definition = adapt_head(head)
+        functions.append((declaration, definition, adapt_body(body)))
+    assert len(functions) == 65, len(functions)
+    proxy_start = source.index('    template<typename _Tp, int numflag> class VecWriterProxy')
+    proxy_end = source.index('} // internal', proxy_start)
+    proxies = source[proxy_start:proxy_end].strip()
+    proxies = re.sub(r'(?<![\w:.])write\s*\(', '::cv::opencv_m_repl::write(', proxies)
+    proxies = re.sub(r'(?<![\w:.])read\s*\(', '::cv::opencv_m_storage_detail::read_value(', proxies)
+    copyright = source[:source.index('#ifndef OPENCV_CORE_PERSISTENCE_HPP')]
+    extras = '''template<class _D = void> requires opencv_m_pick<_D>
+inline FileStorage& operator<<(FileStorage& fs, const String& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<KeyPoint>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<DMatch>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<KeyPoint>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<DMatch>& value);
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator==(const FileNodeIterator& a, const FileNodeIterator& b);
+template<class _D = void> requires opencv_m_pick<_D>
+inline bool operator!=(const FileNodeIterator& a, const FileNodeIterator& b);
+'''
+    dispatch = '''namespace cv::opencv_m_storage_detail {
+template<class T> void write_value(FileStorage& fs, const String& name, const T& value) {
+    if constexpr (requires { ::cv::opencv_m_repl::write(fs, name, value); })
+        ::cv::opencv_m_repl::write(fs, name, value);
+    else write(fs, name, value); // upstream custom-type ADL extension
+}
+template<class T> void read_value(const FileNode& node, T& value, const T& fallback) {
+    if constexpr (requires { ::cv::opencv_m_repl::read(node, value, fallback); })
+        ::cv::opencv_m_repl::read(node, value, fallback);
+    else read(node, value, fallback); // upstream custom-type ADL extension
+}
+'''
+    result = '// Generated by tools/generate_persistence.py; SDK bodies retained with module-safe lookup.\n' + copyright
+    result += '''namespace opencv_m_persistence_up {
+inline constexpr auto insert_string = static_cast<cv::FileStorage&(*)(cv::FileStorage&, const cv::String&)>(&cv::operator<<);
+inline constexpr auto equal = static_cast<bool(*)(const cv::FileNodeIterator&, const cv::FileNodeIterator&)>(&cv::operator==);
+inline constexpr auto unequal = static_cast<bool(*)(const cv::FileNodeIterator&, const cv::FileNodeIterator&)>(&cv::operator!=);
+}
+export namespace cv { inline namespace opencv_m_repl {
+'''
+    result += extras + '\n'.join(item[0] + ';' for item in functions) + '\n} }\n'
+    result += dispatch + proxies + '\n} // cv::opencv_m_storage_detail\n'
+    result += 'export namespace cv { inline namespace opencv_m_repl {\n'
+    result += '''template<class _D> requires opencv_m_pick<_D>
+inline FileStorage& operator<<(FileStorage& fs, const String& value) { return ::opencv_m_persistence_up::insert_string(fs, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<KeyPoint>& value) { ::opencv_m_fns_up::wr_vkp(fs, name, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void write(FileStorage& fs, const String& name, const std::vector<DMatch>& value) { ::opencv_m_fns_up::wr_vdm(fs, name, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<KeyPoint>& value) { ::opencv_m_fns_up::rd_vkp(node, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline void read(const FileNode& node, std::vector<DMatch>& value) { ::opencv_m_fns_up::rd_vdm(node, value); }
+template<class _D> requires opencv_m_pick<_D>
+inline bool operator==(const FileNodeIterator& a, const FileNodeIterator& b) { return ::opencv_m_persistence_up::equal(a, b); }
+template<class _D> requires opencv_m_pick<_D>
+inline bool operator!=(const FileNodeIterator& a, const FileNodeIterator& b) { return ::opencv_m_persistence_up::unequal(a, b); }
+'''
+    result += '\n\n'.join(definition + '\n' + body for _, definition, body in functions)
+    result += '\n} } // cv::opencv_m_repl\n'
+    output = ROOT / 'src/persistence_ops.inc'
+    if args.check:
+        assert output.read_text() == result, 'Run python3 tools/generate_persistence.py'
+    else:
+        write_if_changed(output, result)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/generate_saturate.py b/tools/generate_saturate.py
new file mode 100644
index 0000000..d96f123
--- /dev/null
+++ b/tools/generate_saturate.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Preserve all pinned upstream scalar-conversion overloads in the module adapter."""
+import argparse
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    source = ROOT / "upstream/opencv/modules/core/include/opencv2/core/saturate.hpp"
+    text = source.read_text()
+    match = re.search(r"namespace cv\s*\{(.*)\n\} // cv", text, re.S)
+    assert match, "Review upstream namespace layout before regeneration"
+    body, count = re.subn(r"template<typename _Tp> static inline",
+        "template<typename _Tp> requires opencv_m_pick<_Tp> inline", match[1])
+    assert count == 13, "Review upstream source-type overloads before regeneration"
+    # cvRound is TU-local. An ordinary private module function preserves its
+    # exact platform implementation without exposing that entity in templates.
+    body = body.replace("cvRound(v)", "::opencv_m_scalar_bridge::round32(v)")
+    # Freeze the C-math lookup that upstream performed before other cv headers.
+    body = re.sub(r"(?<![\w:])round\(", "::round(", body)
+    result = ("// Generated by tools/generate_saturate.py; included inside cv::opencv_m_repl.\n"
+              "// Upstream overloads/bodies are retained; only the module constraint and cvRound bridge differ.\n"
+              + text[:text.index("#ifndef OPENCV_CORE_SATURATE_HPP")] + body.strip() + "\n")
+    output = ROOT / "src/saturate_ops.inc"
+    if args.check:
+        assert output.read_text() == result, "Run python3 tools/generate_saturate.py"
+    else:
+        output.write_text(result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_simd.py b/tools/generate_simd.py
new file mode 100644
index 0000000..1edb25c
--- /dev/null
+++ b/tools/generate_simd.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Generate explicit exports of original baseline SIMD SDK entities."""
+import argparse
+import json
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    surface = json.loads((ROOT / "port/api/simd-surface.json").read_text())
+    assert surface["upstream-version"] == "5.0.0"
+    result = "// Generated by tools/generate_simd.py; original SDK entities, no copied vector types.\n"
+    result += "export namespace cv {\n"
+    memory = surface["gcc-memory-bridges"]
+    for name in surface["common"]:
+        if name in memory:
+            result += "#if !defined(__GNUC__) || defined(__clang__) || defined(MCPP_FEATURE_SIMD_EMULATED)\n"
+        result += f"using ::cv::{name};\n"
+        if name in memory:
+            result += "#endif\n"
+    for group, condition in (("sse2", "CV_SSE2 && !defined(MCPP_FEATURE_SIMD_EMULATED)"), ("fp16", "CV_SIMD128_FP16"),
+                             ("emulated", "defined(MCPP_FEATURE_SIMD_EMULATED)")):
+        result += "#if " + condition + "\n"
+        names = surface[group] + (surface["emulated-enums"] if group == "emulated" else [])
+        result += "\n".join(f"using ::cv::{name};" for name in names) + "\n#endif\n"
+    result += "}\n#if defined(MCPP_FEATURE_SIMD_EMULATED)\nexport namespace cv { namespace hal_EMULATOR_CPP {\n"
+    result += "\n".join(f"using ::cv::hal_EMULATOR_CPP::{name};" for name in surface["emulated-enums"])
+    result += "\n} }\n#endif\nexport namespace cv {\n"
+    result += "}\nexport namespace cv { namespace hal {\n"
+    result += "\n".join(f"using ::cv::hal::{name};" for name in
+                        ("StoreMode", "STORE_UNALIGNED", "STORE_ALIGNED", "STORE_ALIGNED_NOCACHE")) + "\n} }\n"
+    result += "#if defined(__GNUC__) && !defined(__clang__) && !defined(MCPP_FEATURE_SIMD_EMULATED)\n"
+    result += "// GCC loses unaligned intrinsic typedef alignment through imported inline bodies.\n"
+    result += "// Ordinary producer-compiled forwards preserve original SDK memory operations.\n"
+    result += "namespace opencv_m_simd_up { using namespace ::cv;\n"
+    wrappers = []
+    for name, signatures in memory.items():
+        seen = set()
+        for signature in signatures:
+            # The SDK forward declaration uses uint while its definition uses
+            # unsigned int. Both denote one overload, not two adapters.
+            signature = re.sub(r"\buint\b", "unsigned int", signature)
+            if signature in seen:
+                continue
+            seen.add(signature)
+            match = re.fullmatch(r"(.+?)\s*\((.*)\)", signature)
+            assert match, signature
+            returned, parameters = match.groups()
+            types = [value.strip() for value in parameters.split(",")]
+            assert not any("(" in value or re.search(r"\b_Tp\b", value) for value in types), signature
+            params = [value + " a" + str(i) for i, value in enumerate(types)]
+            public_params = list(params)
+            if name == "v_store_interleave" and types[-1] == "hal::StoreMode":
+                public_params[-1] += " = hal::STORE_UNALIGNED"
+            arguments = ", ".join("a" + str(i) for i in range(len(types)))
+            result += f"{returned} {name}({', '.join(params)}) {{ return ::cv::{name}({arguments}); }}\n"
+            wrappers.append((returned, name, public_params, arguments))
+    result += "}\nexport namespace cv { inline namespace opencv_m_simd_repl {\n"
+    for returned, name, params, arguments in wrappers:
+        result += "template<class _D = void> requires (sizeof(_D*) > 0)\n"
+        result += f"inline {returned} {name}({', '.join(params)}) {{ return ::opencv_m_simd_up::{name}({arguments}); }}\n"
+    result += "} }\n#endif\n"
+    result += "export namespace cv { inline namespace opencv_m_simd_repl {\n"
+    result += "template<class> inline constexpr bool pick = true;\n"
+    for name in surface["legacy-adapters"]:
+        function = name.replace("vx_", "v_", 1)
+        result += "template<typename _Tp, typename _Tvec> requires pick<_Tp>\n"
+        result += f"inline void {name}(_Tp* dst, const _Tvec& value) {{\n"
+        result += f"#if defined(__GNUC__) && !defined(__clang__) && !defined(MCPP_FEATURE_SIMD_EMULATED)\n::opencv_m_simd_up::{function}(dst, value);\n"
+        result += f"#else\n::cv::{function}(dst, value);\n#endif\n}}\n"
+    result += "} }\n"
+    # Literal static-inline primary templates in simd_utils.impl.hpp cannot be
+    # exported directly. Compile exact SDK specializations in the producer.
+    helper = (ROOT / "upstream/opencv/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp").read_text()
+    scalars = re.findall(r"^CV_INTRIN_DEF_TYPE2VEC128_TRAITS\(([^,]+),", helper, re.M)
+    assert len(scalars) == len(set(scalars)) == 10, scalars
+    result += "namespace opencv_m_simd_broadcast {\n"
+    for scalar in scalars:
+        if scalar == "double":
+            result += "#if CV_SIMD128_64F\n"
+        for name in surface["broadcast-adapters"]:
+            helper_name = "fixed" if name == "v_setall" else "maximum"
+            result += f"auto {helper_name}(const {scalar}& value) {{ return ::cv::{name}<{scalar}>(value); }}\n"
+        if scalar == "double":
+            result += "#endif\n"
+    result += "}\nexport namespace cv { inline namespace opencv_m_simd_repl {\n"
+    for name in surface["broadcast-adapters"]:
+        helper_name = "fixed" if name == "v_setall" else "maximum"
+        result += "template<class T> requires pick<T> && requires { typename ::cv::Type2Vec128_Traits<T>::vec_type; }\n"
+        result += f"inline auto {name}(const T& value) -> decltype(::opencv_m_simd_broadcast::{helper_name}(value)) {{\n"
+        result += f"return ::opencv_m_simd_broadcast::{helper_name}(value);\n}}\n"
+    result += "} }\n"
+    output = ROOT / "src/simd_exports.inc"
+    if args.check:
+        assert output.read_text() == result, "Run python3 tools/generate_simd.py"
+    else:
+        write_if_changed(output, result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_simd_legacy.py b/tools/generate_simd_legacy.py
new file mode 100644
index 0000000..8a25667
--- /dev/null
+++ b/tools/generate_simd_legacy.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Re-export original SDK legacy operators without copying template bodies."""
+import argparse
+from pathlib import Path
+import re
+from _files import write_if_changed
+
+ROOT = Path(__file__).resolve().parents[1]
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--check", action="store_true")
+args = parser.parse_args()
+source = (ROOT / "upstream/opencv/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h").read_text()
+operators = re.findall(r"^(?:BIN_OP|BIN_A_OP|UN_OP)\(([^,]+),", source, re.M)
+assert len(operators) == len(set(operators)) == 21, operators
+result = "// Generated by tools/generate_simd_legacy.py; original SDK operator templates.\n"
+result += "export namespace cv::hal {\n"
+result += "".join("using ::cv::hal::operator" + op.strip() + ";\n" for op in operators)
+result += "}\n"
+output = ROOT / "src/simd_legacy_exports.inc"
+if args.check:
+    assert output.read_text() == result, "Run python3 tools/generate_simd_legacy.py"
+else:
+    write_if_changed(output, result)
diff --git a/tools/generate_source_notices.py b/tools/generate_source_notices.py
new file mode 100644
index 0000000..a1229e3
--- /dev/null
+++ b/tools/generate_source_notices.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Retain embedded copyright/license comments from the pinned SDK in bundles.
+
+Named LICENSE/COPYING/NOTICE files are deployed separately. This conservative
+supplement collects C/C++ comment blocks throughout retained text sources, not
+just leading preambles. Identical blocks are stored once with every location.
+It preserves comment bytes and does not rewrite or classify upstream licenses.
+"""
+import argparse
+from collections import defaultdict
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[1]
+OUTPUT = ROOT / "port/licenses/UPSTREAM_SOURCE_NOTICES.txt"
+TOKEN = re.compile(
+    rb'(?P<block>/\*.*?\*/)|(?P<line>//[^\r\n]*(?:\r?\n[ \t]*//[^\r\n]*)*)'
+    rb'|(?:u8|u|U|L)?R"(?P<delimiter>[^ ()\\\t\r\n]{0,16})\(.*?\)(?P=delimiter)"'
+    rb'|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'',
+    re.DOTALL,
+)
+TERMS = re.compile(rb"copyright|licen[cs]e|redistribution|SPDX-|public domain|patent", re.I)
+
+
+def render():
+    blocks = defaultdict(list)
+    sdk = ROOT / "upstream/opencv"
+    # WindowsPath comparisons case-fold names; PosixPath comparisons do not.
+    # Explicit string components retain one order on every host and preserve
+    # the original Linux artifact bytes, including directory-before-file order.
+    for path in sorted(sdk.rglob("*"), key=lambda path: path.relative_to(sdk).parts):
+        if not path.is_file() or "__pycache__" in path.parts:
+            continue
+        source = path.read_bytes()
+        if b"\0" in source:
+            continue
+        for match in TOKEN.finditer(source):
+            comment = match["block"] or match["line"]
+            if comment is not None and TERMS.search(comment):
+                line = source.count(b"\n", 0, match.start()) + 1
+                blocks[comment].append(f"{path.relative_to(ROOT).as_posix()}:{line}")
+    assert blocks, "No source notices found"
+    result = bytearray(
+        b"Generated by tools/generate_source_notices.py from retained OpenCV 5.0.0 sources.\n"
+        b"Embedded copyright and license comments; original comment bytes preserved.\n"
+        b"Named license files are distributed alongside this supplement.\n\n"
+    )
+    # Insertion order follows sorted source paths and comment positions.
+    for comment, locations in blocks.items():
+        result.extend(b"=" * 78 + b"\nSources:\n")
+        result.extend(("\n".join(locations) + "\n\n").encode("utf-8"))
+        result.extend(comment)
+        result.extend(b"\n\n")
+    return bytes(result), len(blocks), sum(map(len, blocks.values()))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    result, unique, occurrences = render()
+    if args.check:
+        assert OUTPUT.read_bytes() == result, "Run python3 tools/generate_source_notices.py"
+    elif not OUTPUT.exists() or OUTPUT.read_bytes() != result:
+        OUTPUT.parent.mkdir(parents=True, exist_ok=True)
+        OUTPUT.write_bytes(result)
+    print(f"Source notices: {unique} distinct blocks, {occurrences} locations, {len(result)} bytes")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/generate_type_ops.py b/tools/generate_type_ops.py
new file mode 100644
index 0000000..7179d4a
--- /dev/null
+++ b/tools/generate_type_ops.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Generate all 122 pinned types.hpp free operators with named-module linkage."""
+import argparse
+from pathlib import Path
+import re
+
+from _files import write_if_changed
+from generate_persistence import braced_end
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    source = (ROOT / "upstream/opencv/modules/core/include/opencv2/core/types.hpp").read_text()
+    pattern = re.compile(r"(?m)^(?:template<([^\n>]+)>\s*)?static inline\s+([^{};]+?)\s*\{")
+    functions = []
+    for match in pattern.finditer(source):
+        head = " ".join(match[2].split())
+        if not re.search(r"\boperator\s*[^a-zA-Z\s]", head):
+            continue
+        opening = match.end() - 1
+        body = source[opening:braced_end(source, opening)]
+        if match[1]:
+            template = match[1]
+            assert template == "typename _Tp", template
+            constraint = "opencv_m_pick<_Tp>"
+        else:
+            template = "class _D = void"
+            constraint = "opencv_m_pick<_D>"
+            # SDK Range operators are non-template/TU-local. Qualified calls
+            # prevent their priority over the module's constrained adapters.
+            body = body.replace("!(r1 == r2)", "!(::cv::opencv_m_repl::operator==(r1, r2))")
+            body = body.replace("r1 = r1 & r2;", "r1 = ::cv::opencv_m_repl::operator&(r1, r2);")
+            body = body.replace("return r1 + (-delta);", "return ::cv::opencv_m_repl::operator+(r1, -delta);")
+        prefix = f"template<{template}> requires {constraint} inline "
+        definition = prefix.replace("_D = void", "_D") + head
+        functions.append((prefix + head, definition, body))
+    assert len(functions) == 122, len(functions)
+    result = "// Generated by tools/generate_type_ops.py; pinned SDK operator bodies retained.\n"
+    result += source[:source.index("#ifndef")]
+    result += "export namespace cv { inline namespace opencv_m_repl {\n"
+    result += "\n".join(declaration + ";" for declaration, _, _ in functions) + "\n\n"
+    result += "\n\n".join(definition + "\n" + body for _, definition, body in functions)
+    result += "\n} } // cv::opencv_m_repl\n"
+    output = ROOT / "src/type_ops.inc"
+    if args.check:
+        assert output.read_text() == result, "Run python3 tools/generate_type_ops.py"
+    else:
+        write_if_changed(output, result)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/probe_unlisted_api.py b/tools/probe_unlisted_api.py
new file mode 100644
index 0000000..358af83
--- /dev/null
+++ b/tools/probe_unlisted_api.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Report original-name visibility for inventory entities outside using lists.
+
+This is a diagnostic, not a completeness gate. A visible name does not prove
+overload/signature or behavior parity; rejected names still need source review.
+"""
+import argparse
+import json
+from pathlib import Path
+import re
+import subprocess
+
+from audit_api import compiler_flags
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--commands", type=Path, default=Path("compile_commands.json"))
+    parser.add_argument("--inventory", type=Path, default=ROOT / "target/api-audit/inventory.json")
+    parser.add_argument("--output", type=Path, default=ROOT / "target/api-audit/unlisted-import-probe/report.json")
+    args = parser.parse_args()
+    inventory = json.loads(args.inventory.read_text())
+    commands = json.loads(args.commands.read_text())
+    consumer = next(item for item in commands if item["file"].endswith("/tests/main_modules_test.cpp"))
+    assert "clang" in Path(consumer["arguments"][0]).name, "Use a recorded Clang all-module consumer"
+    flags = compiler_flags(consumer, keep_modules=True)
+    features = sorted({flag.removeprefix("-DMCPP_FEATURE_").lower().replace("_", "-")
+                       for flag in flags if flag.startswith("-DMCPP_FEATURE_")})
+    assert features == inventory["profile"]["features"], "Inventory and consumer feature profiles differ"
+    # Explicit legacy import is opt-in. Retain only BMI mappings from this same
+    # consumer profile, never stale commands from another feature/toolchain run.
+    imports = ["mcpplibs.mwrap.opencv"]
+    if "core.simd.legacy" in inventory.get("optional-facades", []):
+        imports.append("mcpplibs.mwrap.opencv.core.simd.legacy")
+        for entry in commands:
+            if entry["directory"] == consumer["directory"]:
+                for flag in entry["arguments"]:
+                    if flag.startswith("-fmodule-file=") and flag not in flags:
+                        flags.append(flag)
+    work = args.output.parent
+    work.mkdir(parents=True, exist_ok=True)
+    source = (work / "probe.cpp").resolve()
+    names = sorted(name for name, item in inventory["entities"].items() if not item["listed-export"])
+    remaining, failures = names[:], {}
+    for attempt in range(4):
+        source.write_text("".join(f"import {name};\n" for name in imports) + "".join(
+            f"namespace unlisted_{number} {{ using ::{name}; }}\n" for number, name in enumerate(remaining)))
+        command = [consumer["arguments"][0], *flags, "-ferror-limit=0", "-x", "c++", "-fsyntax-only", str(source)]
+        result = subprocess.run(command, cwd=ROOT, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        (work / f"attempt-{attempt}.log").write_text(result.stdout)
+        if not result.returncode:
+            break
+        rejected = {}
+        for line in result.stdout.splitlines():
+            match = re.match(re.escape(str(source)) + r":(\d+):\d+: (?:fatal )?error: (.*)", line)
+            if match:
+                number = int(match[1]) - len(imports) - 1
+                assert 0 <= number < len(remaining), line
+                rejected.setdefault(remaining[number], []).append(match[2])
+        assert rejected, result.stdout
+        failures.update(rejected)
+        remaining = [name for name in remaining if name not in rejected]
+    else:
+        raise RuntimeError("Name probe did not converge; inspect retained compiler diagnostics")
+    assert not result.returncode
+    assert set(remaining) | set(failures) == set(names)
+    report = {"scope": "Original qualified-name lookup only; not overload, signature or behavior completeness",
+              "profile": inventory["profile"], "imports": imports, "commands": str(args.commands.resolve()),
+              "total": len(names), "visible": remaining, "not-visible": failures}
+    args.output.write_text(json.dumps(report, indent=2) + "\n")
+    print(f"Unlisted original names: {len(names)}; visible: {len(remaining)}; not visible: {len(failures)}")
+    print("Rejected names require source classification; successful names still require behavioral coverage")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/prune_loop.py b/tools/prune_loop.py
index 3bfc676..d7ef02d 100644
--- a/tools/prune_loop.py
+++ b/tools/prune_loop.py
@@ -1,61 +1,62 @@
 #!/usr/bin/env python3
-"""prune_loop.py — compile-verify the export surface and prune failing names.
+"""Report export compile failures without deleting or rewriting public APIs.
 
-Runs `mcpp build`, parses gcc errors that point into src/gen_exports/*.inc,
-appends the offending names to tools/curated/<module>.prune.txt (with the
-reason as a comment), regenerates, and repeats until the build is green or an
-iteration makes no progress (then it prints the残 errors and exits 1).
-
-Usage: prune_loop.py [opencv-root]   (root forwarded to gen_exports.py)
+The historical filename is retained for existing tooling. This command now
+builds once and writes diagnostics; every missing export requires explicit
+review, an adapter or a justified exclusion. --log replays a captured build.
 """
+import argparse
+import json
+from pathlib import Path
 import re
 import subprocess
-import sys
-from collections import defaultdict
-from pathlib import Path
 
-REPO = Path(__file__).resolve().parent.parent
-INC_ERR = re.compile(r"gen_exports/(\w+)\.inc:(\d+):(?:\d+:)? error: (.*)")
+ROOT = Path(__file__).resolve().parents[1]
+INC_ERR = re.compile(r"gen_exports/(\w+)\.inc:(\d+):(?:\d+:)?\s*(?:fatal )?error:\s*(.*)")
+DECL = re.compile(r"^\s*\d+\s*\|\s*(?:export\s+)?using\s+([^;]+);")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("opencv_root", nargs="?", type=Path, help="legacy argument; must match the pinned SDK")
+    parser.add_argument("--mcpp", default="mcpp")
+    parser.add_argument("--features", default="all-modules")
+    parser.add_argument("--toolchain")
+    parser.add_argument("--log", type=Path, help="analyze an existing log instead of building")
+    parser.add_argument("--report", type=Path, default=ROOT / "target/api-audit/export-diagnostics.json")
+    args = parser.parse_args()
+    if args.opencv_root and args.opencv_root.resolve() != ROOT / "upstream/opencv":
+        parser.error("this diagnostic builds the checkout's pinned upstream/opencv only")
+    if args.log:
+        output = args.log.read_text()
+        failed = bool(re.search(r"(?:fatal )?error:|build failed", output))
+    else:
+        command = [args.mcpp, "build", "--strict", "--no-color", "--features", args.features]
+        if args.toolchain:
+            command += ["--toolchain", args.toolchain]
+        result = subprocess.run(command, cwd=ROOT, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        output, failed = result.stdout, result.returncode != 0
+    output = re.sub(r"\x1b\[[0-9;]*m", "", output)
+    lines, errors = output.splitlines(), []
+    for number, line in enumerate(lines):
+        match = INC_ERR.search(line)
+        if not match:
+            continue
+        # Use recorded context rather than today's possibly stale line number.
+        declaration = next((found[1] for context in lines[number + 1:number + 4]
+                            if (found := DECL.match(context))), None)
+        errors.append({"module": match[1], "line": int(match[2]), "declaration": declaration,
+                       "reason": match[3], "status": "requires-review"})
+    args.report.parent.mkdir(parents=True, exist_ok=True)
+    args.report.write_text(json.dumps({"build": "failed" if failed else "passed", "export-errors": errors,
+                                      "automatic-api-removals": 0}, indent=2) + "\n")
+    args.report.with_suffix(".log").write_text(output)
+    print(f"Build {'failed' if failed else 'passed'}; {len(errors)} export diagnostics; no API files changed.")
+    print("Review report:", args.report)
+    if failed and not errors:
+        print("\n".join(lines[-30:]))
+    raise SystemExit(1 if failed else 0)
+
 
-for iteration in range(1, 30):
-    r = subprocess.run(["mcpp", "build"], cwd=REPO, capture_output=True, text=True)
-    if r.returncode == 0:
-        print(f"iteration {iteration}: build GREEN")
-        sys.exit(0)
-    errs = defaultdict(dict)   # module -> {lineno: reason}
-    for line in (r.stderr + r.stdout).splitlines():
-        m = INC_ERR.search(line)
-        if m:
-            errs[m.group(1)].setdefault(int(m.group(2)), m.group(3).strip())
-    if not errs:
-        print(f"iteration {iteration}: build failed but no .inc errors — manual attention needed")
-        print("\n".join((r.stderr + r.stdout).splitlines()[-40:]))
-        sys.exit(1)
-    total = 0
-    for mod, lines in errs.items():
-        inc = (REPO / "src" / "gen_exports" / f"{mod}.inc").read_text().splitlines()
-        prune_path = REPO / "tools" / "curated" / f"{mod}.prune.txt"
-        old = prune_path.read_text() if prune_path.exists() else \
-            "# names failing compile-verification — maintained by tools/prune_loop.py\n"
-        add = []
-        for ln, reason in sorted(lines.items()):
-            src = inc[ln - 1].strip()
-            m = re.match(r"using (?:cv::)?([A-Za-z0-9_:]+?);", src)
-            if not m:
-                continue
-            name = m.group(1)
-            if re.search(rf"^{re.escape(name.split('::')[-1])}\b", old, re.M) and name in old:
-                continue
-            add.append(f"{name}   # {reason[:90]}")
-        if add:
-            prune_path.write_text(old + "\n".join(add) + "\n")
-            total += len(add)
-            print(f"iteration {iteration}: {mod}: pruned {len(add)}")
-    if total == 0:
-        print(f"iteration {iteration}: no new prunes derivable — manual attention needed")
-        print("\n".join((r.stderr + r.stdout).splitlines()[-40:]))
-        sys.exit(1)
-    subprocess.run([sys.executable, str(REPO / "tools" / "gen_exports.py"), *sys.argv[1:]],
-                   check=True, cwd=REPO)
-print("iteration limit reached")
-sys.exit(1)
+if __name__ == "__main__":
+    main()
diff --git a/tools/simd_surface.py b/tools/simd_surface.py
new file mode 100644
index 0000000..172382b
--- /dev/null
+++ b/tools/simd_surface.py
@@ -0,0 +1,25 @@
+"""Read the SIMD names enabled by the actual producer's preprocessor flags."""
+import json
+from pathlib import Path
+import re
+import subprocess
+
+
+def enabled_names(root, commands, compiler_flags):
+    producer = next(e for e in commands if Path(e["file"]).resolve() == root / "src/detail/simd.cppm")
+    directory = root / "target/api-audit/simd"
+    directory.mkdir(parents=True, exist_ok=True)
+    expanded = subprocess.run([producer["arguments"][0], *compiler_flags(producer),
+                               "-E", "-P", "-x", "c++", producer["file"]], cwd=producer["directory"],
+                              capture_output=True, text=True, check=True).stdout
+    (directory / "expanded.cpp").write_text(expanded)
+    parts = re.split(r"export\s+(?:__preprocessed_)?module\s+mcpplibs\s*\.\s*mwrap\s*\.\s*opencv\s*\.\s*detail\s*\.\s*simd\s*;", expanded)
+    assert len(parts) == 2, "SIMD preprocessor probe did not find the adapter module"
+    names = set(re.findall(r"\busing\s+::(cv(?:::[A-Za-z_]\w*)+)\s*;", parts[1]))
+    surface = json.loads((root / "port/api/simd-surface.json").read_text())
+    names.update("cv::" + name for name in surface["legacy-adapters"])
+    names.update("cv::" + name for name in surface["broadcast-adapters"])
+    if "clang" not in Path(producer["arguments"][0]).name:
+        names.update("cv::" + name for name in surface["gcc-memory-bridges"])
+    assert len(names) >= 215, f"Unexpectedly small SIMD surface: {len(names)}"
+    return names
diff --git a/tools/test_audit_api.py b/tools/test_audit_api.py
new file mode 100644
index 0000000..68d8681
--- /dev/null
+++ b/tools/test_audit_api.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Regression checks for the C++ inventory (not an API completeness claim)."""
+import io
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+from audit_api import ast_declarations, inventory, optional_simd_facades
+
+
+class InventoryTest(unittest.TestCase):
+    def test_inactive_feature_does_not_audit_stale_simd_commands(self):
+        root = Path("/fixture").resolve()
+        stale = [{"file": str(root / "src/detail/simd.cppm")}]
+        self.assertEqual(optional_simd_facades(root, stale, ["-DMCPP_FEATURE_ALL_MODULES"]), [])
+
+    def test_active_simd_requires_both_actual_adapter_commands(self):
+        root = Path("/fixture").resolve()
+        commands = [{"file": str(root / "src/detail" / (name + ".cppm"))}
+                    for name in ("simd", "simd_legacy")]
+        selected = optional_simd_facades(root, commands, ["-DMCPP_FEATURE_SIMD"])
+        self.assertEqual([name for name, _ in selected], ["core.simd", "core.simd.legacy"])
+        with self.assertRaisesRegex(AssertionError, "no compile command"):
+            optional_simd_facades(root, commands[:1], ["-DMCPP_FEATURE_SIMD"])
+
+    def test_transitive_simd_namespace_imports(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            header = str(root / "upstream/opencv/modules/core/include/opencv2/core/hal/intrin.hpp")
+            tree = {"id": "cv", "kind": "NamespaceDecl", "name": "cv", "loc": {"file": header}, "inner": [
+                {"id": "base", "kind": "NamespaceDecl", "name": "hal_baseline", "inner": [
+                    {"id": "width", "kind": "NamespaceDecl", "name": "simd128_cpp", "inner": [
+                        {"kind": "FunctionDecl", "name": "vx_load", "type": {"qualType": "vector (const float *)"}}]},
+                    {"kind": "UsingDirectiveDecl", "nominatedNamespace": {"id": "width", "name": "simd128_cpp"}}]},
+                {"kind": "UsingDirectiveDecl", "nominatedNamespace": {"id": "base", "name": "hal_baseline"}}]}
+            found = inventory(iter([tree]), root)
+            self.assertEqual(found["cv::hal_baseline::simd128_cpp::vx_load"]["public-name"], "cv::vx_load")
+
+    def test_streams_translation_unit_children_and_rejects_truncation(self):
+        tree = {"kind": "TranslationUnitDecl", "inner": [
+            {"kind": "NamespaceDecl", "name": "cv", "inner": [
+                {"kind": "CXXRecordDecl", "name": "Mat"}]},
+            {"kind": "FunctionDecl", "name": "cvRound"}]}
+        capture = io.StringIO()
+        self.assertEqual(list(ast_declarations(io.StringIO(json.dumps(tree, indent=2)), capture)), tree["inner"])
+        self.assertEqual(json.loads(capture.getvalue()), tree)
+        with self.assertRaisesRegex(AssertionError, "Truncated"):
+            list(ast_declarations(io.StringIO('    {\n      "kind": "FunctionDecl"\n')))
+
+    def test_file_elision_nested_headers_and_function_bodies(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            a = str(root / "upstream/opencv/modules/core/include/opencv2/core.hpp")
+            b = str(root / "upstream/opencv/modules/geometry/include/opencv2/geometry.hpp")
+            namespace = {"id": "n", "kind": "NamespaceDecl", "name": "cv",
+                "loc": {"offset": 0, "file": a}, "inner": [
+                    {"kind": "CXXRecordDecl", "name": "Alpha", "loc": {"offset": 10}},
+                    {"kind": "CXXRecordDecl", "name": "Beta", "loc": {"offset": 0, "file": b,
+                        "includedFrom": {"file": a}}},
+                    {"kind": "CXXRecordDecl", "name": "Gamma", "loc": {"offset": 20}},
+                    {"kind": "FunctionDecl", "name": "helper", "loc": {"offset": 40},
+                     "inner": [{"kind": "CompoundStmt", "range": {"end": {"offset": 90, "file": a}}}]},
+                    {"kind": "CXXRecordDecl", "name": "Tail", "loc": {"offset": 100}}]}
+            found = inventory(iter([namespace]), root)
+            self.assertEqual(found["cv::Alpha"]["modules"], ["core"])
+            self.assertEqual(found["cv::Beta"]["modules"], ["geometry"])
+            self.assertEqual(found["cv::Gamma"]["modules"], ["geometry"])
+            self.assertEqual(found["cv::Tail"]["modules"], ["core"])
+
+    def test_namespaces_enumerators_overloads_internal_linkage_and_members(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            header = str(root / "upstream/opencv/modules/dnn/include/opencv2/dnn.hpp")
+            nested = {"id": "abi", "kind": "NamespaceDecl", "name": "dnn5_v20260605", "inner": [
+                {"kind": "CXXRecordDecl", "name": "Net"},
+                {"kind": "FunctionDecl", "name": "call", "type": {"qualType": "int (int)"}},
+                {"kind": "FunctionDecl", "name": "call", "type": {"qualType": "int (float)"}},
+                {"kind": "FunctionTemplateDecl", "name": "helper", "inner": [
+                    {"kind": "FunctionDecl", "storageClass": "static", "type": {"qualType": "T (T)"}}]},
+                {"kind": "EnumDecl", "name": "Mode", "inner": [
+                    {"kind": "EnumConstantDecl", "name": "MODE_CPU"}]},
+                {"kind": "EnumDecl", "name": "Scoped", "scopedEnumTag": "class", "inner": [
+                    {"kind": "EnumConstantDecl", "name": "HIDDEN"}]},
+                {"kind": "FunctionDecl", "name": "forward", "parentDeclContextId": "class-net"}]}
+            tree = {"id": "cv", "kind": "NamespaceDecl", "name": "cv", "loc": {"offset": 0, "file": header},
+                    "inner": [{"id": "dnn", "kind": "NamespaceDecl", "name": "dnn", "inner": [nested,
+                        {"kind": "UsingDirectiveDecl", "nominatedNamespace": {"id": "abi", "name": "dnn5_v20260605"}}]}]}
+            found = inventory(iter([tree]), root)
+            self.assertEqual(found["cv::dnn::dnn5_v20260605::Net"]["public-name"], "cv::dnn::Net")
+            self.assertEqual(found["cv::dnn::dnn5_v20260605::call"]["signatures"], ["int (float)", "int (int)"])
+            self.assertTrue(found["cv::dnn::dnn5_v20260605::helper"]["internal-linkage"])
+            self.assertEqual(found["cv::dnn::dnn5_v20260605::helper"]["signatures"], ["T (T)"])
+            self.assertIn("cv::dnn::dnn5_v20260605::MODE_CPU", found)
+            self.assertFalse(any(name.endswith(("HIDDEN", "forward")) for name in found))
+
+    def test_implicit_const_linkage_and_external_redeclarations(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            header = str(root / "upstream/opencv/modules/flann/include/opencv2/flann.hpp")
+            declarations = [
+                {"id": "ext", "kind": "VarDecl", "name": "external", "storageClass": "extern", "type": {"qualType": "const int"}},
+                {"id": "def", "kind": "VarDecl", "name": "external", "previousDecl": "ext", "type": {"qualType": "const int"}},
+                {"kind": "VarDecl", "name": "blocksize", "type": {"qualType": "const int"}},
+                {"kind": "VarDecl", "name": "pointee", "type": {"qualType": "const char *"}},
+                {"kind": "VarDecl", "name": "pointer", "type": {"qualType": "int *const"}},
+                {"kind": "VarDecl", "name": "reference", "type": {"qualType": "const int &"}},
+                {"kind": "VarDecl", "name": "inline_value", "inline": True, "type": {"qualType": "const int"}},
+                {"kind": "VarDecl", "name": "alias", "type": {"qualType": "size_type", "desugaredQualType": "const unsigned long"}},
+            ]
+            tree = {"id": "flann", "kind": "NamespaceDecl", "name": "cvflann", "loc": {"offset": 0, "file": header}, "inner": declarations}
+            found = inventory(iter([tree]), root)
+            for name in ["blocksize", "pointer", "alias"]:
+                self.assertTrue(found["cvflann::" + name]["internal-linkage"], name)
+            for name in ["external", "pointee", "reference", "inline_value"]:
+                self.assertFalse(found["cvflann::" + name]["internal-linkage"], name)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/test_build_config.py b/tools/test_build_config.py
new file mode 100644
index 0000000..fdde2b0
--- /dev/null
+++ b/tools/test_build_config.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Exercise the compiled build program with LF and Windows CRLF checkouts."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("program", type=Path, help="compiled build.mcpp executable")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    program = args.program.resolve()
+    results = []
+    for ending in (b"\n", b"\r\n"):
+        with tempfile.TemporaryDirectory(prefix="opencv-config-") as directory:
+            fixture = Path(directory)
+            inputs = [root / "src/selected.cppm.in", root / "port/config/modules.txt",
+                      root / "generated/linux/cvconfig.h", root / "generated/linux/INCLUDE_DIRS.txt"]
+            inputs += sorted((root / "port/config/sources/linux").glob("*.txt"))
+            for source in inputs:
+                dest = fixture / source.relative_to(root)
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                dest.write_bytes(source.read_bytes().replace(b"\r\n", b"\n").replace(b"\n", ending))
+            out = fixture / "out"
+            out.mkdir()
+            env = {key: value for key, value in os.environ.items() if not key.startswith("MCPP_FEATURE_")}
+            env.update(MCPP_MANIFEST_DIR=str(fixture), MCPP_OUT_DIR=str(out), MCPP_TARGET_OS="linux",
+                       MCPP_FEATURE_IMGPROC="1", MCPP_FEATURE_GEOMETRY="1", MCPP_FEATURE_FLANN="1")
+            result = subprocess.run([str(program)], env=env, check=True, capture_output=True)
+            selected = (out / "selected.cppm").read_text()
+            assert "export import mcpplibs.mwrap.opencv.imgproc;" in selected, selected
+            assert "export import mcpplibs.mwrap.opencv.imgcodecs;" not in selected, selected
+            config = (out / "cvconfig.h").read_text()
+            assert "#define HAVE_JPEG" not in config, config
+            assert "#define HAVE_PNG" not in config, config
+            # Compare source directives and generated configuration, normalizing
+            # only the temporary output path, which necessarily differs.
+            directives = result.stdout.decode().replace(str(out), "<out>")
+            results.append((selected, config, directives))
+    assert results[0] == results[1], "LF and CRLF checkouts selected different build inputs"
+    print("Build configuration: LF and CRLF select identical modules, sources and codec configuration")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/test_candidate.py b/tools/test_candidate.py
new file mode 100644
index 0000000..8ed50cb
--- /dev/null
+++ b/tools/test_candidate.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Test the checkout against an unpublished SDK/wrapper index in isolation."""
+import argparse
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import tomllib
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--index", required=True, type=Path)
+    parser.add_argument("--mcpp", default="mcpp")
+    parser.add_argument("--toolchain", default="llvm@23.1.3")
+    parser.add_argument("--features", default="dnn-onnxruntime")
+    parser.add_argument("--filter", help="run matching test binaries; omit to run the complete suite")
+    parser.add_argument("--target", help="explicit target triple for native or cross verification")
+    parser.add_argument("--absent-dependency", action="append", default=[],
+                        help="require an optional package to be absent from the lock and compilation database")
+    parser.add_argument("--keep", action="store_true", help="retain the exact staged project for diagnosis")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    index = args.index.resolve()
+    subprocess.run([os.sys.executable, str(index / "tests/prepare_mwrap_indices.py")], cwd=index, check=True)
+    class Workspace:
+        def __enter__(self):
+            self.directory = tempfile.mkdtemp(prefix="mwrap-opencv-candidate-")
+            return self.directory
+        def __exit__(self, kind, value, traceback):
+            if args.keep:
+                print("Retained candidate:", self.directory, flush=True)
+            else:
+                shutil.rmtree(self.directory)
+    with Workspace() as directory:
+        source = Path(directory) / "source"
+        shutil.copytree(root, source, ignore=shutil.ignore_patterns(
+            ".git", "target", ".mcpp", ".xlings", "__pycache__", "mcpp.lock", "compile_commands.json",
+            ".candidate-index", "mcpp-2026.*"))
+        with (source / "mcpp.toml").open("a") as manifest:
+            manifest.write('\n[indices]\n')
+            for namespace in ("compat", "mcpplibs.mwrap"):
+                path = index / "tests/mwrap/.indices" / namespace
+                manifest.write('"' + namespace + '" = { path = "' + path.as_posix() + '" }\n')
+        command = [args.mcpp, "test"]
+        if args.filter:
+            command.append(args.filter)
+        command += ["--strict", "--features", args.features,
+                    "--toolchain", args.toolchain, "--timeout", "120"]
+        if args.target:
+            command += ["--target", args.target]
+        print("+", " ".join(command), flush=True)
+        subprocess.run(command, cwd=source, check=True)
+        if args.absent_dependency:
+            # mcpp emits no lock for an empty production graph; test-only
+            # dependencies are excluded from it. Check actual units as well.
+            lock = source / "mcpp.lock"
+            packages = tomllib.loads(lock.read_text()).get("package", {}) if lock.exists() else {}
+            commands = json.loads((source / "compile_commands.json").read_text())
+            for identity in args.absent_dependency:
+                assert identity not in packages, f"Unexpected optional dependency: {identity}"
+                namespace, name = identity.rsplit(".", 1)
+                marker = f"/{namespace}-x-{name}/"
+                assert not any(marker in entry["file"].replace("\\", "/") for entry in commands), identity
+                print("Verified absent optional dependency:", identity, flush=True)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/test_export_diagnostics.py b/tools/test_export_diagnostics.py
new file mode 100644
index 0000000..55f7d11
--- /dev/null
+++ b/tools/test_export_diagnostics.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""A failed export diagnostic must never delete or rewrite an API."""
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class DiagnosticPolicyTest(unittest.TestCase):
+    def test_failure_reports_the_recorded_declaration_without_changing_exports(self):
+        with tempfile.TemporaryDirectory(prefix="opencv-export-policy-") as directory:
+            root = Path(directory)
+            (root / "tools/curated").mkdir(parents=True)
+            (root / "src/gen_exports").mkdir(parents=True)
+            shutil.copyfile(ROOT / "tools/prune_loop.py", root / "tools/prune_loop.py")
+            exports = root / "src/gen_exports/core.inc"
+            curated = root / "tools/curated/core.prune.txt"
+            exports.write_text("export namespace cv {\nusing cv::Missing;\n}\n")
+            curated.write_text("# Reviewed exceptions only.\n")
+            before = [hashlib.sha256(path.read_bytes()).hexdigest() for path in (exports, curated)]
+            log = root / "failure.log"
+            log.write_text("gen_exports/core.inc:2:12: error: no member named 'Missing' in namespace 'cv'\n"
+                           "    2 | using cv::Missing;\n")
+            report = root / "report.json"
+            # No compiler/build tool is available. A replay is read-only even
+            # when the export itself is invalid; all files are sandbox fixtures.
+            env = dict(os.environ, PATH="")
+            result = subprocess.run([sys.executable, str(root / "tools/prune_loop.py"),
+                                     "--log", str(log), "--report", str(report)],
+                                    env=env, text=True, capture_output=True)
+            self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
+            self.assertEqual(before, [hashlib.sha256(path.read_bytes()).hexdigest() for path in (exports, curated)])
+            recorded = json.loads(report.read_text())
+            self.assertEqual(recorded["automatic-api-removals"], 0)
+            self.assertEqual(recorded["export-errors"][0]["declaration"], "cv::Missing")
+            self.assertEqual(recorded["export-errors"][0]["status"], "requires-review")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/test_source_notices.py b/tools/test_source_notices.py
new file mode 100644
index 0000000..bde1ff1
--- /dev/null
+++ b/tools/test_source_notices.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Verify host-independent ordering, quoted-text exclusion and original bytes."""
+from pathlib import Path
+import tempfile
+
+import generate_source_notices as generator
+
+
+class WindowsOrderedPath(type(Path())):
+    def __lt__(self, other):
+        return tuple(part.casefold() for part in self.parts) < tuple(part.casefold() for part in other.parts)
+
+
+with tempfile.TemporaryDirectory(prefix="opencv-notice-order-") as directory:
+    sdk = Path(directory) / "upstream/opencv"
+    sdk.mkdir(parents=True)
+    first = b"/* Copyright Z\r\n * original CRLF conditions\r\n */"
+    second = b"// Copyright a\n// original notice"
+    (sdk / "Z.h").write_bytes(first + b"\nint z;\n")
+    (sdk / "a.h").write_bytes(second + b"\nint a;\n")
+    (sdk / "strings.hpp").write_bytes(
+        b'const char* ordinary = "// Copyright string only";\n'
+        b'const char* raw = R"tag(/* License string only */)tag";\n')
+    generator.ROOT = Path(directory)
+    native, unique, locations = generator.render()
+    generator.ROOT = WindowsOrderedPath(directory)
+    emulated, other_unique, other_locations = generator.render()
+    assert native == emulated, "Host path comparison changed notice bytes/order"
+    assert unique == other_unique == 2 and locations == other_locations == 2
+    assert native.index(first) < native.index(second), "Expected canonical case-sensitive order"
+    assert first in native and second in native, "Original comment bytes must survive"
+    assert b"string only" not in native, "Quoted strings are not source notices"
+print("Notice ordering matches across host path rules; original bytes and quoted-text exclusion pass")
diff --git a/tools/test_template.py b/tools/test_template.py
new file mode 100644
index 0000000..a237501
--- /dev/null
+++ b/tools/test_template.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Render an installed candidate's default mcpp template, then build and run it."""
+import argparse
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import tomllib
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mcpp", default="mcpp")
+    parser.add_argument("--toolchain", default="llvm@23.1.3")
+    parser.add_argument("--template", help="named template; omit for the package default")
+    parser.add_argument("--run-arg", action="append", default=[])
+    parser.add_argument("--index", type=Path, help="candidate SDK/wrapper index for unpublished feature dependencies")
+    args = parser.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    metadata = tomllib.loads((root / "mcpp.toml").read_text())["package"]
+    namespace, name, version = (metadata[key] for key in ("namespace", "name", "version"))
+    identity = namespace + "." + name
+    with tempfile.TemporaryDirectory(prefix=name + "-template-") as directory:
+        temporary = Path(directory)
+        home = temporary / "home"
+        package = home / "registry/data/xpkgs" / (namespace + "-x-" + name) / version / (name + "-" + version)
+        shutil.copytree(root, package, ignore=shutil.ignore_patterns(
+            ".git", "target", ".mcpp", ".xlings", ".candidate-index", "__pycache__", "mcpp.lock", "compile_commands.json", "mcpp-2026.*"))
+        index = home / "indices/mcpplibs/pkgs/mwrap"
+        index.mkdir(parents=True)
+        entry = '{url="https://example.invalid/candidate.tar.gz",sha256="fixture"}'
+        descriptor = ('package={spec="1",namespace=' + json.dumps(namespace) + ',name=' + json.dumps(name) +
+                      ',description="Installed template fixture",type="package",mcpp="mcpp.toml",xpm={')
+        descriptor += ",".join(platform + "={[" + json.dumps(version) + "]=" + entry + "}"
+                               for platform in ("linux", "macosx", "windows")) + "}}\n"
+        (index / (identity + ".lua")).write_text(descriptor)
+        env = dict(os.environ, MCPP_HOME=str(home))
+        selector = identity + "@" + version
+        for command in ([args.mcpp, "new", "--list-templates", selector],
+                        [args.mcpp, "new", "quickstart", "--template", selector + (":" + args.template if args.template else "")]):
+            print("+", " ".join(command), flush=True)
+            subprocess.run(command, cwd=temporary, env=env, check=True)
+        project = temporary / "quickstart"
+        manifest = project / "mcpp.toml"
+        text = manifest.read_text()
+        dependency = tomllib.loads(text)["dependencies"][identity]
+        options = {"version": dependency} if isinstance(dependency, str) else dependency
+        assert options["version"] == version, options
+        replacement = '{ path = ' + json.dumps(package.as_posix())
+        if options.get("features"):
+            replacement += ', features = ' + json.dumps(options["features"])
+        replacement += ' }'
+        lines = text.splitlines()
+        matches = [i for i, line in enumerate(lines) if line.startswith(json.dumps(identity) + " =")]
+        assert len(matches) == 1, "Expected exactly one qualified dependency from self.name"
+        lines[matches[0]] = json.dumps(identity) + " = " + replacement
+        manifest.write_text("\n".join(lines) + "\n")
+        if args.index:
+            candidate_index = args.index.resolve()
+            subprocess.run([os.sys.executable, str(candidate_index / "tests/prepare_mwrap_indices.py")],
+                           cwd=candidate_index, check=True)
+            with manifest.open("a") as out:
+                out.write("\n[indices]\n")
+                for namespace in ("compat", "mcpplibs.mwrap"):
+                    view = candidate_index / "tests/mwrap/.indices" / namespace
+                    out.write(json.dumps(namespace) + ' = { path = ' + json.dumps(view.as_posix()) + ' }\n')
+        command = [args.mcpp, "build", "--toolchain", args.toolchain, "--strict"]
+        print("+", " ".join(command), flush=True)
+        subprocess.run(command, cwd=project, check=True)
+        command = [args.mcpp, "run", "--toolchain", args.toolchain]
+        if args.run_arg:
+            command += ["--", *args.run_arg]
+        print("+", " ".join(command), flush=True)
+        subprocess.run(command, cwd=project, check=True)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/vendor/import_opencv.sh b/tools/vendor/import_opencv.sh
index 6097504..b21e867 100755
--- a/tools/vendor/import_opencv.sh
+++ b/tools/vendor/import_opencv.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# One-time (re-)import of the pinned OpenCV source into third_party/.
+# Re-import the pinned OpenCV source into upstream/opencv/.
 # Host-independent: with no argument it downloads the pinned official tarball
 # itself (into a gitignored work dir) and verifies its sha256 before pruning.
 # Usage: tools/vendor/import_opencv.sh [path-to-extracted-opencv-5.0.0]
@@ -9,44 +9,49 @@ PIN_SHA="b0528f5a1d379d59d4701cb28c36e22214cc51cf64594e5b56f2d3e6c0233095"
 URL_GLOBAL="https://github.com/opencv/opencv/archive/refs/tags/${VER}.tar.gz"
 URL_CN="https://gitcode.com/mcpp-res/opencv/releases/download/${VER}/opencv-${VER}.tar.gz"
 ROOT="$(git rev-parse --show-toplevel)"
-DST="$ROOT/third_party/opencv-${VER}"
+DST="$ROOT/upstream/opencv"
 
+WORK="$ROOT/target/vendor-import"
+mkdir -p "$WORK"
+TAR="$WORK/opencv-${VER}.tar.gz"
+if ! echo "$PIN_SHA  $TAR" | sha256sum -c - 2>/dev/null; then
+    URL="$URL_GLOBAL"; [ "${MCPP_MIRROR:-}" = "CN" ] && URL="$URL_CN"
+    echo "downloading $URL"
+    curl -fL --retry 3 -o "$TAR" "$URL"
+    echo "$PIN_SHA  $TAR" | sha256sum -c -
+fi
 SRC="${1:-}"
 if [ -z "$SRC" ]; then
-    WORK="$ROOT/target/vendor-import"
-    mkdir -p "$WORK"
-    TAR="$WORK/opencv-${VER}.tar.gz"
-    if ! echo "$PIN_SHA  $TAR" | sha256sum -c - 2>/dev/null; then
-        URL="$URL_GLOBAL"; [ "${MCPP_MIRROR:-}" = "CN" ] && URL="$URL_CN"
-        echo "downloading $URL"
-        curl -fL --retry 3 -o "$TAR" "$URL"
-        echo "$PIN_SHA  $TAR" | sha256sum -c -
-    fi
     rm -rf "$WORK/opencv-${VER}"
     tar -xzf "$TAR" -C "$WORK"
     SRC="$WORK/opencv-${VER}"
-else
-    # provenance check when the tarball sits next to a user-supplied tree
-    TAR="$(dirname "$SRC")/opencv-${VER}.tar.gz"
-    if [ -f "$TAR" ]; then
-        echo "$PIN_SHA  $TAR" | sha256sum -c - || exit 1
-    fi
 fi
 [ -f "$SRC/CMakeLists.txt" ] || { echo "not an opencv tree: $SRC" >&2; exit 1; }
-
-rm -rf "$DST"; mkdir -p "$DST"
-KEEP_MODULES="core imgproc imgcodecs highgui videoio dnn flann geometry"
+# A caller-supplied tree must also match the pinned archive, not merely carry
+# the expected directory/version name.
+python3 "$ROOT/tools/check_upstream.py" --archive "$TAR" --root "$SRC"
+STAGE=$(mktemp -d "$WORK/import.XXXXXX")
+trap 'rm -rf "$STAGE"' EXIT
+NEW="$STAGE/opencv"
+mkdir -p "$NEW"
+KEEP_MODULES="core imgproc imgcodecs highgui videoio dnn flann geometry calib features objdetect photo ptcloud stereo stitching video"
 KEEP_3RDPARTY="libjpeg-turbo libpng zlib protobuf mlas flatbuffers dlpack"
-cp "$SRC"/{LICENSE,COPYRIGHT,README.md} "$DST/"
-cp -r "$SRC/include" "$DST/include"
-mkdir -p "$DST/modules" "$DST/3rdparty" "$DST/modules/python"
-for m in $KEEP_MODULES; do cp -r "$SRC/modules/$m" "$DST/modules/$m"; done
-cp -r "$SRC/modules/python/src2" "$DST/modules/python/src2"
-for t in $KEEP_3RDPARTY; do cp -r "$SRC/3rdparty/$t" "$DST/3rdparty/$t"; done
-cp "$SRC/3rdparty/readme.txt" "$DST/3rdparty/"
+cp "$SRC"/{LICENSE,COPYRIGHT,README.md} "$NEW/"
+cp -r "$SRC/include" "$NEW/include"
+mkdir -p "$NEW/modules" "$NEW/3rdparty" "$NEW/modules/python"
+for m in $KEEP_MODULES; do cp -r "$SRC/modules/$m" "$NEW/modules/$m"; done
+cp -r "$SRC/modules/python/src2" "$NEW/modules/python/src2"
+for t in $KEEP_3RDPARTY; do cp -r "$SRC/3rdparty/$t" "$NEW/3rdparty/$t"; done
+cp "$SRC/3rdparty/readme.txt" "$NEW/3rdparty/"
 # Slim the kept modules: test/perf trees and non-C++ binding misc dirs.
 for m in $KEEP_MODULES; do
-    rm -rf "$DST/modules/$m"/{test,perf}
-    for b in java objc python js; do rm -rf "$DST/modules/$m/misc/$b"; done
+    rm -rf "$NEW/modules/$m"/{test,perf}
+    for b in java objc python js; do rm -rf "$NEW/modules/$m/misc/$b"; done
 done
-du -sh "$DST"
+du -sh "$NEW"
+mkdir -p "$ROOT/upstream"
+if [ -d "$DST" ]; then mv "$DST" "$STAGE/previous"; fi
+if ! mv "$NEW" "$DST"; then
+    if [ -d "$STAGE/previous" ]; then mv "$STAGE/previous" "$DST"; fi
+    exit 1
+fi
diff --git a/tools/vendor/port_descriptor.py b/tools/vendor/port_descriptor.py
index 3ea47c8..4051890 100644
--- a/tools/vendor/port_descriptor.py
+++ b/tools/vendor/port_descriptor.py
@@ -4,10 +4,10 @@
 Reads the (machine-generated) descriptor via a real lua interpreter
 (dump_descriptor.lua -> JSON) and emits:
 
-  gen/common/            files byte-identical across ALL 3 OS blocks
+  generated/common/            files byte-identical across ALL 3 OS blocks
                          (+ synth/ = outputs of the descriptor's embedded
                           build.mcpp: fonts, OpenCL kernel embeddings)
-  gen/<os>/              everything else, path = generated_files key minus
+  generated/<os>/              everything else, path = generated_files key minus
                          the mcpp_generated/ prefix; plus tu/<grp>/ stubs
                          materialized from tu_manifest.txt; plus
                          INCLUDE_DIRS.txt consumed by the repo's build.mcpp
@@ -16,8 +16,8 @@
 
 Faithfulness rules: no value is invented or 'improved'; every rewrite is a
 pure path-prefix mapping:
-  */X            -> third_party/opencv-5.0.0/X       (tarball-relative)
-  mcpp_generated/X -> gen/common/X or gen/<os>/X     (by the dedupe outcome)
+  */X            -> upstream/opencv/X       (tarball-relative)
+  mcpp_generated/X -> generated/common/X or generated/<os>/X     (by the dedupe outcome)
 Stub file bytes are kept identical to what the embedded build.mcpp emits
 (cross-checked by actually compiling and running it).
 """
@@ -31,7 +31,7 @@
 from pathlib import Path
 
 OSES = ["linux", "macosx", "windows"]
-VENDOR = "third_party/opencv-5.0.0"
+VENDOR = "upstream/opencv"
 GEN_PREFIX = "mcpp_generated/"
 
 
@@ -140,7 +140,7 @@ def dedupe(self):
     def where(self, o, rel):
         return "common" if self.loc.get(rel) == "common" else o
 
-    # ── write gen/ trees ─────────────────────────────────────────────────
+    # ── write generated/ trees ─────────────────────────────────────────────────
     def write_gen(self):
         counts = {"common": 0, **{o: 0 for o in OSES}}
         written_common = set()
@@ -156,8 +156,8 @@ def write_gen(self):
                 out.write_text(content)
                 counts[loc] += 1
         # the one consumer-visible generated header must be OS-neutral
-        assert (self.repo / "gen/common/opencv2/opencv_modules.hpp").exists(), \
-            "opencv_modules.hpp did not dedupe into gen/common"
+        assert (self.repo / "generated/common/opencv2/opencv_modules.hpp").exists(), \
+            "opencv_modules.hpp did not dedupe into generated/common"
         print("gen files:", counts)
 
     # ── run the descriptor's own build.mcpp once; harvest + cross-check ──
@@ -183,8 +183,8 @@ def synth(self, scratch):
                    MCPP_FEATURE_DNN="1")
         env.pop("MCPP_FEATURE_UNIFONT", None)
         sh([exe], env=env, stdout=subprocess.DEVNULL)
-        # harvest fonts + kernels into gen/common/synth (layout mirrors OUT)
-        synth_dir = self.repo / "gen/common/synth"
+        # harvest fonts + kernels into generated/common/synth (layout mirrors OUT)
+        synth_dir = self.repo / "generated/common/synth"
         shutil.rmtree(synth_dir, ignore_errors=True)
         n = 0
         for f in sorted(out.rglob("*")):
@@ -202,7 +202,7 @@ def synth(self, scratch):
             dst.parent.mkdir(parents=True, exist_ok=True)
             shutil.copyfile(f, dst)
             n += 1
-        print(f"synth harvested {n} files into gen/common/synth "
+        print(f"synth harvested {n} files into generated/common/synth "
               f"(+ {sum(1 for _ in out.rglob('tu/**/*') if _.is_file())} stubs cross-checked)")
 
     # ── path rewrites ────────────────────────────────────────────────────
@@ -216,8 +216,8 @@ def rw(self, o, g):
             for e in expand_braces(rel):
                 locs.setdefault(self.where(o, e), []).append(e)
             if len(locs) == 1:
-                return [f"gen/{loc}/{rel}" for loc in locs]
-            return [f"gen/{loc}/{e}" for loc, es in sorted(locs.items()) for e in es]
+                return [f"generated/{loc}/{rel}" for loc in locs]
+            return [f"generated/{loc}/{e}" for loc, es in sorted(locs.items()) for e in es]
         return [g]  # '**/...' and plain globs pass through
 
     def rw_flags(self, o, entries):
@@ -225,7 +225,7 @@ def rw_flags(self, o, entries):
         for e in entries:
             e2 = dict(e)
             [e2["glob"]] = self.rw(o, e2["glob"])
-            # unix asm entry must not reach the windows asm stubs under gen/:
+            # unix asm entry must not reach the windows asm stubs under generated/:
             # every real .asm lives in the vendored tree, scope it there.
             if e2["glob"] == "**/*.asm":
                 e2["glob"] = VENDOR + "/**/*.asm"
@@ -234,7 +234,7 @@ def rw_flags(self, o, entries):
 
     # ── windows stub layer (workaround for the missing per-OS per-glob
     #    flags in the manifest, mcpp-community/mcpp#258): every windows TU
-    #    becomes a one-line include stub under gen/windows/tu/w/<group>/ —
+    #    becomes a one-line include stub under generated/windows/tu/w/<group>/ —
     #    the PATH becomes the OS namespace, so the windows flag tables can
     #    key on stub-dir globs inside the ordinary global [[build.flags]]
     #    table with zero cross-OS overlap. Same trick the pre-0.0.97
@@ -270,7 +270,7 @@ def _expand_sources(self, o, entries):
         return files
 
     def _stub_for(self, path, prefix="w"):
-        """(stub relpath under gen/windows/tu/<prefix>/, stub content)."""
+        """(stub relpath under generated/windows/tu/<prefix>/, stub content)."""
         grp = self._wgroup(path)
         mangled = path.replace("/", "_")
         rel = f"tu/{prefix}/{grp}/{mangled}"
@@ -278,11 +278,11 @@ def _stub_for(self, path, prefix="w"):
             # NASM: resolved via the -I fed from include_dirs (simd dir is on it)
             content = f'; opencv-m windows asm stub\n%include "{Path(path).name}"\n'
         else:
-            # resolved via -I third_party/opencv-5.0.0 or -I gen/common
+            # resolved via -I upstream/opencv or -I generated/common
             if path.startswith(VENDOR + "/"):
                 inc = path[len(VENDOR) + 1:]
-            elif path.startswith("gen/common/"):
-                inc = path[len("gen/common/"):]
+            elif path.startswith("generated/common/"):
+                inc = path[len("generated/common/"):]
             else:
                 raise SystemExit(f"windows stub: unexpected source root {path}")
             content = f'/* opencv-m windows TU stub (mcpp#258 workaround) */\n#include "{inc}"\n'
@@ -291,19 +291,19 @@ def _stub_for(self, path, prefix="w"):
     def _remap_win_glob(self, g, prefix="w"):
         import re as _re
         if g == "**/*.asm":
-            return f"gen/windows/tu/{prefix}/asm/**"
+            return f"generated/windows/tu/{prefix}/asm/**"
         m = _re.match(r"\*\*/modules/([a-z0-9_]+)/\*\*(.*)$", g)
         if m:
-            return f"gen/windows/tu/{prefix}/{m.group(1)}/**{m.group(2)}"
+            return f"generated/windows/tu/{prefix}/{m.group(1)}/**{m.group(2)}"
         m = _re.match(r"\*\*/3rdparty/([a-zA-Z0-9_.-]+)/\*\*(.*)$", g)
         if m:
-            return f"gen/windows/tu/{prefix}/{m.group(1)}/**{m.group(2)}"
+            return f"generated/windows/tu/{prefix}/{m.group(1)}/**{m.group(2)}"
         m = _re.match(r"\*\*/tu/([a-z0-9_]+)/\*\*$", g)
         if m:
-            return f"gen/windows/tu/{prefix}/{m.group(1)}/**"
+            return f"generated/windows/tu/{prefix}/{m.group(1)}/**"
         if "*" not in g:  # per-file entry -> its stub path
             rel, _ = self._stub_for(g, prefix)
-            return f"gen/windows/{rel}"
+            return f"generated/windows/{rel}"
         raise SystemExit(f"windows flag glob not remappable: {g}")
 
     def windows_stub_layer(self):
@@ -315,24 +315,24 @@ def windows_stub_layer(self):
         for g in blk["sources"]:
             srcs += self.rw(CFGW, g)
         for rel in self.base_stubs[CFGW]:
-            srcs.append(f"gen/{self.where(CFGW, rel)}/{rel}")
+            srcs.append(f"generated/{self.where(CFGW, rel)}/{rel}")
         files = self._expand_sources(CFGW, srcs)
         n = 0
         for f in files:
             # the committed common/os tu stubs are already one include hop;
             # windows re-stubs point at the REAL target directly
             if "/tu/jpeg" in f:
-                content = self.staged[CFGW][f.split("gen/common/")[-1]] if f.startswith("gen/common/") else None
+                content = self.staged[CFGW][f.split("generated/common/")[-1]] if f.startswith("generated/common/") else None
                 grp = self._wgroup(f)
                 rel = f"tu/w/{grp}/{f.replace('/', '_')}"
                 assert content is not None
             else:
                 rel, content = self._stub_for(f)
-            out = self.repo / "gen/windows" / rel
+            out = self.repo / "generated/windows" / rel
             out.parent.mkdir(parents=True, exist_ok=True)
             out.write_text(content.replace("\\n", "\n") if "\\n" in content else content)
             n += 1
-        print(f"windows stub layer: {n} stubs under gen/windows/tu/w/")
+        print(f"windows stub layer: {n} stubs under generated/windows/tu/w/")
 
         # windows flag tables remapped onto the stub namespace -> can join the
         # global tables conflict-free
@@ -352,18 +352,18 @@ def windows_stub_layer(self):
         for g in blk["features"]["dnn"]["sources"]:
             dnn_srcs += self.rw(CFGW, g)
         for relstub in self.feat_stubs[CFGW].get("dnn", []):
-            dnn_srcs.append(f"gen/{self.where(CFGW, relstub)}/{relstub}")
+            dnn_srcs.append(f"generated/{self.where(CFGW, relstub)}/{relstub}")
         dnn_files = self._expand_sources(CFGW, dnn_srcs)
         stub_paths = []
         for f in dnn_files:
             rel, content = self._stub_for(f, "wdnn")
-            out = self.repo / "gen/windows" / rel
+            out = self.repo / "generated/windows" / rel
             out.parent.mkdir(parents=True, exist_ok=True)
             out.write_text(content.replace("\\n", "\n") if "\\n" in content else content)
-            stub_paths.append(f"gen/windows/{rel}")
-        (self.repo / "gen/windows/DNN_SOURCES.txt").write_text(
+            stub_paths.append(f"generated/windows/{rel}")
+        (self.repo / "generated/windows/DNN_SOURCES.txt").write_text(
             "\n".join(stub_paths) + ("\n" if stub_paths else ""))
-        print(f"windows dnn: {len(stub_paths)} stubs -> gen/windows/DNN_SOURCES.txt")
+        print(f"windows dnn: {len(stub_paths)} stubs -> generated/windows/DNN_SOURCES.txt")
         return base_win, dnn_win
 
     # ── INCLUDE_DIRS.txt (consumed by the repo build.mcpp) ───────────────
@@ -375,7 +375,7 @@ def include_dirs(self, o):
                 rel = "" if d == "mcpp_generated" else d[len(GEN_PREFIX):]
                 for loc in (o, "common"):
                     p = self.repo / "gen" / loc / rel if rel else self.repo / "gen" / loc
-                    line = f"gen/{loc}/{rel}" if rel else f"gen/{loc}"
+                    line = f"generated/{loc}/{rel}" if rel else f"generated/{loc}"
                     if p.is_dir() and line not in priv:
                         priv.append(line)
             elif d == "*":
@@ -384,7 +384,7 @@ def include_dirs(self, o):
                 glob_dirs.append(VENDOR + "/" + d[2:])
             else:
                 glob_dirs.append(d)
-        priv.append("gen/common/synth")  # replaces the old `-I $MCPP_OUT_DIR`
+        priv.append("generated/common/synth")  # replaces the old `-I $MCPP_OUT_DIR`
         f = self.repo / "gen" / o / "INCLUDE_DIRS.txt"
         f.parent.mkdir(parents=True, exist_ok=True)
         f.write_text("\n".join(priv) + "\n")
@@ -423,13 +423,13 @@ def fragments(self):
         - features.toml: [features] with the OS-NEUTRAL dnn subset (entries
           whose rewritten path is identical for every OS that has dnn) +
           unified dnn flag table; the per-OS remainder (ISA dispatch TUs,
-          mlas, feature-gated stubs) goes to gen/<os>/DNN_SOURCES.txt, which
+          mlas, feature-gated stubs) goes to generated/<os>/DNN_SOURCES.txt, which
           build.mcpp injects via mcpp:source= when the feature is active.
         """
         self.frag.mkdir(parents=True, exist_ok=True)
         CFG = {"linux": "linux", "macosx": "macos", "windows": "windows"}
 
-        # global include dirs (also writes gen/<os>/INCLUDE_DIRS.txt)
+        # global include dirs (also writes generated/<os>/INCLUDE_DIRS.txt)
         glob_dirs = self.include_dirs("linux")
         for o in ("macosx", "windows"):
             extra = set(self.include_dirs(o)) - set(glob_dirs)
@@ -508,7 +508,7 @@ def union_flags(per_os):
         win_base_flags, win_dnn_flags = self.windows_stub_layer()
         base_union = base_union + win_base_flags
         base = ["# [build].include_dirs additions (after \"include\"):",
-                "include_dirs = " + self.tarr(["include", "gen/common"] + glob_dirs), "",
+                "include_dirs = " + self.tarr(["include", "generated/common"] + glob_dirs), "",
                 "# base per-glob flags: union of the three OS tables (disjoint or identical):", "",
                 self.emit_flag_entries("build.flags", base_union)]
         (self.frag / "base.toml").write_text("\n".join(base))
@@ -517,13 +517,13 @@ def emit_os_sections():
             for o in OSES:
                 blk = self.mcpp[o]
                 if o == "windows":
-                    srcs = ["gen/windows/tu/w/**/*.{c,cc,cpp,asm}"]
+                    srcs = ["generated/windows/tu/w/**/*.{c,cc,cpp,asm}"]
                 else:
                     srcs = []
                     for g in blk["sources"]:
                         srcs += self.rw(o, g)
                     for rel in self.base_stubs[o]:
-                        srcs.append(f"gen/{self.where(o, rel)}/{rel}")
+                        srcs.append(f"generated/{self.where(o, rel)}/{rel}")
                 hoist_flags = []
                 for d in self.hoisted[o]:
                     if "-D" + d not in hoist_flags:
@@ -536,7 +536,7 @@ def emit_os_sections():
                 (self.frag / f"{o}.toml").write_text("\n".join(body))
 
         # dnn feature: OS-neutral subset in the manifest, per-OS remainder in
-        # gen/<os>/DNN_SOURCES.txt (build.mcpp injects when the feature is on)
+        # generated/<os>/DNN_SOURCES.txt (build.mcpp injects when the feature is on)
         dnn_os = {}
         for o in OSES:
             feats = self.mcpp[o].get("features", {})
@@ -546,7 +546,7 @@ def emit_os_sections():
             for g in feats["dnn"]["sources"]:
                 lst += self.rw(o, g)
             for rel in self.feat_stubs[o].get("dnn", []):
-                lst.append(f"gen/{self.where(o, rel)}/{rel}")
+                lst.append(f"generated/{self.where(o, rel)}/{rel}")
             dnn_os[o] = lst
             assert feats["dnn"]["defines"] == ["HAVE_OPENCV_DNN"] or \
                 "HAVE_OPENCV_DNN" in feats["dnn"]["defines"], o
@@ -560,7 +560,7 @@ def emit_os_sections():
                 continue
             f = self.repo / "gen" / o / "DNN_SOURCES.txt"
             f.write_text("\n".join(dnn_os[o]) + ("\n" if dnn_os[o] else ""))
-            print(f"dnn {o}: {len(dnn_os[o])} sources -> gen/{o}/DNN_SOURCES.txt")
+            print(f"dnn {o}: {len(dnn_os[o])} sources -> generated/{o}/DNN_SOURCES.txt")
 
         dnn_flags = union_flags({o: apply_hoist(o, self.rw_flags(o, self.mcpp[o]["features"]["dnn"]["flags"]), DNN_HOIST)
                                  for o in dnn_os if o != "windows"}) + win_dnn_flags
@@ -571,7 +571,7 @@ def emit_os_sections():
                  "# The dnn LIBRARY sources are per-OS by construction (windows compiles",
                  "# them through its tu/w/ stub namespace so its per-glob flags can key on",
                  "# the paths) -> ALL of them are injected by build.mcpp from",
-                 "# gen/<os>/DNN_SOURCES.txt; only the module interface lives here.",
+                 "# generated/<os>/DNN_SOURCES.txt; only the module interface lives here.",
                  "sources = " + self.tarr(["src/dnn.cppm"])]
         feats.append("")
         feats.append(self.emit_flag_entries("features.dnn.flags", dnn_flags))
diff --git a/upstream/documents.json b/upstream/documents.json
new file mode 100644
index 0000000..691aa93
--- /dev/null
+++ b/upstream/documents.json
@@ -0,0 +1,20 @@
+{
+  "upstream": "https://github.com/opencv/opencv/tree/5.0.0",
+  "documents": [
+    {
+      "path": "upstream/opencv/README.md",
+      "source": "https://github.com/opencv/opencv/tree/5.0.0/README.md",
+      "sha256": "7e4047375a342b27a9b7ca689bad87619e94136db980070eaefa64a0adcbdf7b"
+    },
+    {
+      "path": "upstream/opencv/LICENSE",
+      "source": "https://github.com/opencv/opencv/tree/5.0.0/LICENSE",
+      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    },
+    {
+      "path": "upstream/opencv/COPYRIGHT",
+      "source": "https://github.com/opencv/opencv/tree/5.0.0/COPYRIGHT",
+      "sha256": "5b8559278fabdb2d38e5251facf259e394f5dc2c604c5e91c1b3befb99ecbc11"
+    }
+  ]
+}
diff --git a/third_party/opencv-5.0.0/3rdparty/dlpack/LICENSE b/upstream/opencv/3rdparty/dlpack/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/dlpack/LICENSE
rename to upstream/opencv/3rdparty/dlpack/LICENSE
diff --git a/third_party/opencv-5.0.0/3rdparty/dlpack/include/dlpack/dlpack.h b/upstream/opencv/3rdparty/dlpack/include/dlpack/dlpack.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/dlpack/include/dlpack/dlpack.h
rename to upstream/opencv/3rdparty/dlpack/include/dlpack/dlpack.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/LICENSE.txt b/upstream/opencv/3rdparty/flatbuffers/LICENSE.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/LICENSE.txt
rename to upstream/opencv/3rdparty/flatbuffers/LICENSE.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/README.md b/upstream/opencv/3rdparty/flatbuffers/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/README.md
rename to upstream/opencv/3rdparty/flatbuffers/README.md
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/allocator.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/allocator.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/allocator.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/allocator.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/array.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/array.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/array.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/array.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/base.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/base.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/base.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/base.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/buffer.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/buffer.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/buffer_ref.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer_ref.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/buffer_ref.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/buffer_ref.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/default_allocator.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/default_allocator.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/default_allocator.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/default_allocator.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/detached_buffer.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/detached_buffer.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/detached_buffer.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/detached_buffer.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/stl_emulation.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/stl_emulation.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/stl_emulation.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/stl_emulation.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/string.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/string.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/string.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/string.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/struct.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/struct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/struct.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/struct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/table.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/table.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/table.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/table.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/vector.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/vector.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/vector_downward.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector_downward.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/vector_downward.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/vector_downward.h
diff --git a/third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/verifier.h b/upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/verifier.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/flatbuffers/include/flatbuffers/verifier.h
rename to upstream/opencv/3rdparty/flatbuffers/include/flatbuffers/verifier.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/CMakeLists.txt b/upstream/opencv/3rdparty/libjpeg-turbo/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/CMakeLists.txt
rename to upstream/opencv/3rdparty/libjpeg-turbo/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/LICENSE.md b/upstream/opencv/3rdparty/libjpeg-turbo/LICENSE.md
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/LICENSE.md
rename to upstream/opencv/3rdparty/libjpeg-turbo/LICENSE.md
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/README.ijg b/upstream/opencv/3rdparty/libjpeg-turbo/README.ijg
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/README.ijg
rename to upstream/opencv/3rdparty/libjpeg-turbo/README.ijg
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/README.md b/upstream/opencv/3rdparty/libjpeg-turbo/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/README.md
rename to upstream/opencv/3rdparty/libjpeg-turbo/README.md
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jconfig.h.in b/upstream/opencv/3rdparty/libjpeg-turbo/jconfig.h.in
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jconfig.h.in
rename to upstream/opencv/3rdparty/libjpeg-turbo/jconfig.h.in
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jconfigint.h.in b/upstream/opencv/3rdparty/libjpeg-turbo/jconfigint.h.in
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jconfigint.h.in
rename to upstream/opencv/3rdparty/libjpeg-turbo/jconfigint.h.in
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jversion.h.in b/upstream/opencv/3rdparty/libjpeg-turbo/jversion.h.in
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/jversion.h.in
rename to upstream/opencv/3rdparty/libjpeg-turbo/jversion.h.in
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/CMakeLists.txt b/upstream/opencv/3rdparty/libjpeg-turbo/simd/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/CMakeLists.txt
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jccolext-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jccolext-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jccolext-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jccolext-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jchuff-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jchuff-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jchuff-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jchuff-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd_neon.S b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd_neon.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd_neon.S
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch32/jsimd_neon.S
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jccolext-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jccolext-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jccolext-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jccolext-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jchuff-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd_neon.S b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd_neon.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd_neon.S
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/aarch64/jsimd_neon.S
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/align.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/align.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/align.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/align.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jccolor-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgray-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcgryext-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgryext-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcgryext-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcgryext-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jchuff.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jchuff.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jchuff.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jchuff.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcphuff-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jcsample-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdcolext-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolext-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdcolext-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolext-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdcolor-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmerge-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdmrgext-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmrgext-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdmrgext-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdmrgext-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jdsample-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctfst-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jfdctint-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctfst-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctint-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jidctred-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/jquanti-neon.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h.in b/upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h.in
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h.in
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/arm/neon-compat.h.in
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jccolor-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jccolor-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgray-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgray-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcgryext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcgryext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jchuff-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jchuff-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jchuff-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jchuff-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcphuff-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcphuff-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcphuff-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcphuff-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jcsample-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jcsample-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdcolor-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdcolor-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmerge-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmerge-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdmrgext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jdsample-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jdsample-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-3dn.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-3dn.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-3dn.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-3dn.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-sse.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-sse.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-sse.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctflt-sse.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctfst-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jfdctint-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jfdctint-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-3dn.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-3dn.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-3dn.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-3dn.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctflt-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctfst-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctfst-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctfst-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctfst-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctfst-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctfst-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctfst-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctfst-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctint-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctint-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctred-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctred-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctred-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctred-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctred-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctred-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jidctred-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jidctred-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-3dn.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-3dn.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-3dn.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-3dn.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-mmx.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-mmx.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-mmx.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-mmx.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-sse.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-sse.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquant-sse.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquant-sse.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquantf-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquantf-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquantf-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquantf-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquanti-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquanti-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquanti-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquanti-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquanti-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquanti-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jquanti-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jquanti-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jsimdcpu.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jsimdcpu.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/i386/jsimdcpu.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/i386/jsimdcpu.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/jsimd.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/jsimd.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/jsimd.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/jsimd.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2.S b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2.S
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2.S
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2_asm.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2_asm.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2_asm.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips/jsimd_dspr2_asm.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jccolext-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolext-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jccolext-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolext-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jccolor-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolor-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jccolor-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jccolor-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcgray-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgray-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcgray-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgray-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcgryext-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgryext-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcgryext-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcgryext-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcsample-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcsample-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcsample.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jcsample.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jcsample.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdcolext-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolext-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdcolext-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolext-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdcolor-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolor-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdcolor-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdcolor-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdmerge-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmerge-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdmerge-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmerge-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdmrgext-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmrgext-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdmrgext-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdmrgext-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdsample-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdsample-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jdsample-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jdsample-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jfdctfst-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctfst-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jfdctfst-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctfst-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jfdctint-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctint-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jfdctint-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jfdctint-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jidctfst-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctfst-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jidctfst-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctfst-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jidctint-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctint-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jidctint-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jidctint-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jquanti-mmi.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jquanti-mmi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jquanti-mmi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jquanti-mmi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jsimd_mmi.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd_mmi.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/jsimd_mmi.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/jsimd_mmi.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/loongson-mmintrin.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/loongson-mmintrin.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/mips64/loongson-mmintrin.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/mips64/loongson-mmintrin.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jcolsamp.inc b/upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jcolsamp.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jcolsamp.inc
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jcolsamp.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jdct.inc b/upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jdct.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jdct.inc
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jdct.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc b/upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdcfg.inc.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdext.inc b/upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdext.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/nasm/jsimdext.inc
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/nasm/jsimdext.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jccolext-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolext-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jccolext-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolext-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jccolor-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolor-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jccolor-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jccolor-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcgray-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgray-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcgray-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgray-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcgryext-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgryext-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcgryext-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcgryext-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcsample-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcsample-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcsample.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jcsample.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jcsample.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdcolext-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolext-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdcolext-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolext-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdcolor-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolor-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdcolor-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdcolor-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdmerge-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmerge-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdmerge-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmerge-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdmrgext-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmrgext-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdmrgext-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdmrgext-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdsample-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdsample-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jdsample-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jdsample-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jfdctfst-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctfst-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jfdctfst-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctfst-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jfdctint-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctint-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jfdctint-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jfdctint-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jidctfst-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctfst-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jidctfst-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctfst-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jidctint-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctint-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jidctint-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jidctint-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jquanti-altivec.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jquanti-altivec.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jquanti-altivec.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jquanti-altivec.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jsimd_altivec.h b/upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd_altivec.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/powerpc/jsimd_altivec.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/powerpc/jsimd_altivec.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jccolor-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgray-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcgryext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jchuff-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcphuff-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jcsample-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdcolor-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmerge-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdmrgext-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jdsample-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctflt-sse.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctfst-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jfdctint-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctflt-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctfst-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctint-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jidctred-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquantf-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-avx2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jquanti-sse2.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm b/upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm
rename to upstream/opencv/3rdparty/libjpeg-turbo/simd/x86_64/jsimdcpu.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jaricom.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jaricom.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jaricom.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jaricom.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcapimin.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcapimin.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcapimin.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcapimin.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcapistd.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcapistd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcapistd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcapistd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcarith.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcarith.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcarith.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcarith.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccoefct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jccoefct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccoefct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jccoefct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccolext.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jccolext.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccolext.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jccolext.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccolor.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jccolor.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jccolor.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jccolor.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcdctmgr.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcdctmgr.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcdctmgr.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcdctmgr.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcdiffct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcdiffct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcdiffct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcdiffct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jchuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jchuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jchuff.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jchuff.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jchuff.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcicc.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcicc.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcicc.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcicc.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcinit.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcinit.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcinit.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcinit.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jclhuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jclhuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jclhuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jclhuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jclossls.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jclossls.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jclossls.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jclossls.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmainct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcmainct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmainct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcmainct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmarker.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcmarker.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmarker.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcmarker.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmaster.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmaster.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmaster.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcmaster.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcmaster.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcomapi.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcomapi.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcomapi.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcomapi.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcparam.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcparam.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcparam.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcparam.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcphuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcphuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcphuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcprepct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcprepct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcprepct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcprepct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcsample.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcsample.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcsample.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcsample.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcstest.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jcstest.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jcstest.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jcstest.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jctrans.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jctrans.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jctrans.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jctrans.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdapimin.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdapimin.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdapimin.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdapimin.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdapistd.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdapistd.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdapistd.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdapistd.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdarith.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdarith.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdarith.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdarith.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatadst-tj.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst-tj.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatadst-tj.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst-tj.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatadst.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatadst.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdatadst.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatasrc-tj.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc-tj.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatasrc-tj.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc-tj.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatasrc.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdatasrc.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdatasrc.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcoefct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcoefct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcoefct.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcoefct.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdcoefct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcol565.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdcol565.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcol565.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdcol565.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcolext.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolext.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcolext.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolext.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcolor.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolor.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdcolor.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdcolor.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdct.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdct.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jddctmgr.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jddctmgr.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jddctmgr.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jddctmgr.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jddiffct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jddiffct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jddiffct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jddiffct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdhuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdhuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdhuff.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdhuff.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdhuff.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdicc.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdicc.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdicc.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdicc.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdinput.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdinput.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdinput.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdinput.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdlhuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdlhuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdlhuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdlhuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdlossls.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdlossls.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdlossls.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdlossls.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmainct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmainct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmainct.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmainct.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmainct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmarker.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmarker.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmarker.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmarker.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmaster.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmaster.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmaster.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmaster.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmaster.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmerge.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmerge.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmerge.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmerge.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmerge.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmrg565.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrg565.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmrg565.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrg565.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmrgext.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrgext.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdmrgext.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdmrgext.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdphuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdphuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdphuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdphuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdpostct.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdpostct.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdpostct.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdpostct.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdsample.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdsample.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdsample.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdsample.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdsample.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdtrans.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jdtrans.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jdtrans.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jdtrans.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jerror.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jerror.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jerror.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jerror.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jerror.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctflt.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctflt.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctflt.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctflt.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctfst.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctfst.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctfst.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctfst.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctint.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctint.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jfdctint.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jfdctint.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctflt.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jidctflt.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctflt.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jidctflt.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctfst.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jidctfst.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctfst.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jidctfst.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctint.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jidctint.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctint.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jidctint.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctred.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jidctred.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jidctred.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jidctred.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jinclude.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jinclude.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jinclude.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jinclude.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jlossls.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jlossls.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jlossls.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jlossls.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemmgr.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jmemmgr.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemmgr.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jmemmgr.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemnobs.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jmemnobs.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemnobs.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jmemnobs.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemsys.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jmemsys.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmemsys.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jmemsys.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmorecfg.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jmorecfg.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jmorecfg.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jmorecfg.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeg_nbits.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeg_nbits.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeg_nbits.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeg_nbits.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jpeg_nbits.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpegapicomp.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jpegapicomp.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpegapicomp.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jpegapicomp.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpegint.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jpegint.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpegint.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jpegint.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeglib.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jpeglib.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jpeglib.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jpeglib.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jquant1.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jquant1.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jquant1.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jquant1.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jquant2.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jquant2.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jquant2.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jquant2.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsamplecomp.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jsamplecomp.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsamplecomp.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jsamplecomp.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsimd.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jsimd.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsimd.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jsimd.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsimddct.h b/upstream/opencv/3rdparty/libjpeg-turbo/src/jsimddct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jsimddct.h
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jsimddct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jstdhuff.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jstdhuff.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jstdhuff.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jstdhuff.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jutils.c b/upstream/opencv/3rdparty/libjpeg-turbo/src/jutils.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/jutils.c
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/jutils.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/libjpeg.txt b/upstream/opencv/3rdparty/libjpeg-turbo/src/libjpeg.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/libjpeg.txt
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/libjpeg.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/structure.txt b/upstream/opencv/3rdparty/libjpeg-turbo/src/structure.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libjpeg-turbo/src/structure.txt
rename to upstream/opencv/3rdparty/libjpeg-turbo/src/structure.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/CHANGES b/upstream/opencv/3rdparty/libpng/CHANGES
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/CHANGES
rename to upstream/opencv/3rdparty/libpng/CHANGES
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/CMakeLists.txt b/upstream/opencv/3rdparty/libpng/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/CMakeLists.txt
rename to upstream/opencv/3rdparty/libpng/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/LICENSE b/upstream/opencv/3rdparty/libpng/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/LICENSE
rename to upstream/opencv/3rdparty/libpng/LICENSE
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/README b/upstream/opencv/3rdparty/libpng/README
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/README
rename to upstream/opencv/3rdparty/libpng/README
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/arm/arm_init.c b/upstream/opencv/3rdparty/libpng/arm/arm_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/arm/arm_init.c
rename to upstream/opencv/3rdparty/libpng/arm/arm_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/arm/filter_neon.S b/upstream/opencv/3rdparty/libpng/arm/filter_neon.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/arm/filter_neon.S
rename to upstream/opencv/3rdparty/libpng/arm/filter_neon.S
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/arm/filter_neon_intrinsics.c b/upstream/opencv/3rdparty/libpng/arm/filter_neon_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/arm/filter_neon_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/arm/filter_neon_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/arm/palette_neon_intrinsics.c b/upstream/opencv/3rdparty/libpng/arm/palette_neon_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/arm/palette_neon_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/arm/palette_neon_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/intel/filter_sse2_intrinsics.c b/upstream/opencv/3rdparty/libpng/intel/filter_sse2_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/intel/filter_sse2_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/intel/filter_sse2_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/intel/intel_init.c b/upstream/opencv/3rdparty/libpng/intel/intel_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/intel/intel_init.c
rename to upstream/opencv/3rdparty/libpng/intel/intel_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/loongarch/filter_lsx_intrinsics.c b/upstream/opencv/3rdparty/libpng/loongarch/filter_lsx_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/loongarch/filter_lsx_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/loongarch/filter_lsx_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/loongarch/loongarch_lsx_init.c b/upstream/opencv/3rdparty/libpng/loongarch/loongarch_lsx_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/loongarch/loongarch_lsx_init.c
rename to upstream/opencv/3rdparty/libpng/loongarch/loongarch_lsx_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/mips/filter_mmi_inline_assembly.c b/upstream/opencv/3rdparty/libpng/mips/filter_mmi_inline_assembly.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/mips/filter_mmi_inline_assembly.c
rename to upstream/opencv/3rdparty/libpng/mips/filter_mmi_inline_assembly.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/mips/filter_msa_intrinsics.c b/upstream/opencv/3rdparty/libpng/mips/filter_msa_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/mips/filter_msa_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/mips/filter_msa_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/mips/mips_init.c b/upstream/opencv/3rdparty/libpng/mips/mips_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/mips/mips_init.c
rename to upstream/opencv/3rdparty/libpng/mips/mips_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/png.c b/upstream/opencv/3rdparty/libpng/png.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/png.c
rename to upstream/opencv/3rdparty/libpng/png.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/png.h b/upstream/opencv/3rdparty/libpng/png.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/png.h
rename to upstream/opencv/3rdparty/libpng/png.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngconf.h b/upstream/opencv/3rdparty/libpng/pngconf.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngconf.h
rename to upstream/opencv/3rdparty/libpng/pngconf.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngdebug.h b/upstream/opencv/3rdparty/libpng/pngdebug.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngdebug.h
rename to upstream/opencv/3rdparty/libpng/pngdebug.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngerror.c b/upstream/opencv/3rdparty/libpng/pngerror.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngerror.c
rename to upstream/opencv/3rdparty/libpng/pngerror.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngget.c b/upstream/opencv/3rdparty/libpng/pngget.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngget.c
rename to upstream/opencv/3rdparty/libpng/pngget.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pnginfo.h b/upstream/opencv/3rdparty/libpng/pnginfo.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pnginfo.h
rename to upstream/opencv/3rdparty/libpng/pnginfo.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pnglibconf.h b/upstream/opencv/3rdparty/libpng/pnglibconf.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pnglibconf.h
rename to upstream/opencv/3rdparty/libpng/pnglibconf.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngmem.c b/upstream/opencv/3rdparty/libpng/pngmem.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngmem.c
rename to upstream/opencv/3rdparty/libpng/pngmem.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngpread.c b/upstream/opencv/3rdparty/libpng/pngpread.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngpread.c
rename to upstream/opencv/3rdparty/libpng/pngpread.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngpriv.h b/upstream/opencv/3rdparty/libpng/pngpriv.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngpriv.h
rename to upstream/opencv/3rdparty/libpng/pngpriv.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngread.c b/upstream/opencv/3rdparty/libpng/pngread.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngread.c
rename to upstream/opencv/3rdparty/libpng/pngread.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngrio.c b/upstream/opencv/3rdparty/libpng/pngrio.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngrio.c
rename to upstream/opencv/3rdparty/libpng/pngrio.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngrtran.c b/upstream/opencv/3rdparty/libpng/pngrtran.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngrtran.c
rename to upstream/opencv/3rdparty/libpng/pngrtran.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngrutil.c b/upstream/opencv/3rdparty/libpng/pngrutil.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngrutil.c
rename to upstream/opencv/3rdparty/libpng/pngrutil.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngset.c b/upstream/opencv/3rdparty/libpng/pngset.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngset.c
rename to upstream/opencv/3rdparty/libpng/pngset.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngstruct.h b/upstream/opencv/3rdparty/libpng/pngstruct.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngstruct.h
rename to upstream/opencv/3rdparty/libpng/pngstruct.h
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngtrans.c b/upstream/opencv/3rdparty/libpng/pngtrans.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngtrans.c
rename to upstream/opencv/3rdparty/libpng/pngtrans.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngwio.c b/upstream/opencv/3rdparty/libpng/pngwio.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngwio.c
rename to upstream/opencv/3rdparty/libpng/pngwio.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngwrite.c b/upstream/opencv/3rdparty/libpng/pngwrite.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngwrite.c
rename to upstream/opencv/3rdparty/libpng/pngwrite.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngwtran.c b/upstream/opencv/3rdparty/libpng/pngwtran.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngwtran.c
rename to upstream/opencv/3rdparty/libpng/pngwtran.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/pngwutil.c b/upstream/opencv/3rdparty/libpng/pngwutil.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/pngwutil.c
rename to upstream/opencv/3rdparty/libpng/pngwutil.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/powerpc/filter_vsx_intrinsics.c b/upstream/opencv/3rdparty/libpng/powerpc/filter_vsx_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/powerpc/filter_vsx_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/powerpc/filter_vsx_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/powerpc/powerpc_init.c b/upstream/opencv/3rdparty/libpng/powerpc/powerpc_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/powerpc/powerpc_init.c
rename to upstream/opencv/3rdparty/libpng/powerpc/powerpc_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/riscv/filter_rvv_intrinsics.c b/upstream/opencv/3rdparty/libpng/riscv/filter_rvv_intrinsics.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/riscv/filter_rvv_intrinsics.c
rename to upstream/opencv/3rdparty/libpng/riscv/filter_rvv_intrinsics.c
diff --git a/third_party/opencv-5.0.0/3rdparty/libpng/riscv/riscv_init.c b/upstream/opencv/3rdparty/libpng/riscv/riscv_init.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/libpng/riscv/riscv_init.c
rename to upstream/opencv/3rdparty/libpng/riscv/riscv_init.c
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/CMakeLists.txt b/upstream/opencv/3rdparty/mlas/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/CMakeLists.txt
rename to upstream/opencv/3rdparty/mlas/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/LICENSE b/upstream/opencv/3rdparty/mlas/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/LICENSE
rename to upstream/opencv/3rdparty/mlas/LICENSE
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/README.md b/upstream/opencv/3rdparty/mlas/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/README.md
rename to upstream/opencv/3rdparty/mlas/README.md
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/inc/mlas.h b/upstream/opencv/3rdparty/mlas/inc/mlas.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/inc/mlas.h
rename to upstream/opencv/3rdparty/mlas/inc/mlas.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/inc/mlas_float16.h b/upstream/opencv/3rdparty/mlas/inc/mlas_float16.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/inc/mlas_float16.h
rename to upstream/opencv/3rdparty/mlas/inc/mlas_float16.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/SgemmKernelNeon.S b/upstream/opencv/3rdparty/mlas/lib/aarch64/SgemmKernelNeon.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/SgemmKernelNeon.S
rename to upstream/opencv/3rdparty/mlas/lib/aarch64/SgemmKernelNeon.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/SgemvKernelNeon.S b/upstream/opencv/3rdparty/mlas/lib/aarch64/SgemvKernelNeon.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/SgemvKernelNeon.S
rename to upstream/opencv/3rdparty/mlas/lib/aarch64/SgemvKernelNeon.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/asmmacro.h b/upstream/opencv/3rdparty/mlas/lib/aarch64/asmmacro.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/aarch64/asmmacro.h
rename to upstream/opencv/3rdparty/mlas/lib/aarch64/asmmacro.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/arm/sgemmc.cpp b/upstream/opencv/3rdparty/mlas/lib/arm/sgemmc.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/arm/sgemmc.cpp
rename to upstream/opencv/3rdparty/mlas/lib/arm/sgemmc.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/arm64/SgemmKernelNeon.asm b/upstream/opencv/3rdparty/mlas/lib/arm64/SgemmKernelNeon.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/arm64/SgemmKernelNeon.asm
rename to upstream/opencv/3rdparty/mlas/lib/arm64/SgemmKernelNeon.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/arm64ec/SgemmKernelNeon.asm b/upstream/opencv/3rdparty/mlas/lib/arm64ec/SgemmKernelNeon.asm
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/arm64ec/SgemmKernelNeon.asm
rename to upstream/opencv/3rdparty/mlas/lib/arm64ec/SgemmKernelNeon.asm
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/compute.cpp b/upstream/opencv/3rdparty/mlas/lib/compute.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/compute.cpp
rename to upstream/opencv/3rdparty/mlas/lib/compute.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/core/common/common.h b/upstream/opencv/3rdparty/mlas/lib/core/common/common.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/core/common/common.h
rename to upstream/opencv/3rdparty/mlas/lib/core/common/common.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/core/common/narrow.h b/upstream/opencv/3rdparty/mlas/lib/core/common/narrow.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/core/common/narrow.h
rename to upstream/opencv/3rdparty/mlas/lib/core/common/narrow.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/erf_neon_fp16.h b/upstream/opencv/3rdparty/mlas/lib/erf_neon_fp16.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/erf_neon_fp16.h
rename to upstream/opencv/3rdparty/mlas/lib/erf_neon_fp16.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/flashattn.cpp b/upstream/opencv/3rdparty/mlas/lib/flashattn.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/flashattn.cpp
rename to upstream/opencv/3rdparty/mlas/lib/flashattn.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/gelu_neon_fp16.h b/upstream/opencv/3rdparty/mlas/lib/gelu_neon_fp16.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/gelu_neon_fp16.h
rename to upstream/opencv/3rdparty/mlas/lib/gelu_neon_fp16.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/kleidiai/mlasi_kleidiai.h b/upstream/opencv/3rdparty/mlas/lib/kleidiai/mlasi_kleidiai.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/kleidiai/mlasi_kleidiai.h
rename to upstream/opencv/3rdparty/mlas/lib/kleidiai/mlasi_kleidiai.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmKernelLasx.S b/upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLasx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmKernelLasx.S
rename to upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLasx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmKernelLsx.S b/upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLsx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmKernelLsx.S
rename to upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmKernelLsx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4LSX.S b/upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4LSX.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4LSX.S
rename to upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4LSX.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4Lasx.S b/upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4Lasx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4Lasx.S
rename to upstream/opencv/3rdparty/mlas/lib/loongarch64/SgemmTransposePackB16x4Lasx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/asmmacro.h b/upstream/opencv/3rdparty/mlas/lib/loongarch64/asmmacro.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/loongarch64/asmmacro.h
rename to upstream/opencv/3rdparty/mlas/lib/loongarch64/asmmacro.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/mlasi.h b/upstream/opencv/3rdparty/mlas/lib/mlasi.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/mlasi.h
rename to upstream/opencv/3rdparty/mlas/lib/mlasi.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/platform.cpp b/upstream/opencv/3rdparty/mlas/lib/platform.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/platform.cpp
rename to upstream/opencv/3rdparty/mlas/lib/platform.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPOWER10.cpp b/upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPOWER10.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPOWER10.cpp
rename to upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPOWER10.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPackA.S b/upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPackA.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPackA.S
rename to upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPackA.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPower.cpp b/upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPower.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/power/SgemmKernelPower.cpp
rename to upstream/opencv/3rdparty/mlas/lib/power/SgemmKernelPower.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/qgemm.h b/upstream/opencv/3rdparty/mlas/lib/qgemm.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/qgemm.h
rename to upstream/opencv/3rdparty/mlas/lib/qgemm.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/riscv64/sgemm_kernel_rvv.cpp b/upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_kernel_rvv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/riscv64/sgemm_kernel_rvv.cpp
rename to upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_kernel_rvv.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/riscv64/sgemm_pack_b_rvv.cpp b/upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_pack_b_rvv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/riscv64/sgemm_pack_b_rvv.cpp
rename to upstream/opencv/3rdparty/mlas/lib/riscv64/sgemm_pack_b_rvv.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/s390x/SgemmKernel.cpp b/upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernel.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/s390x/SgemmKernel.cpp
rename to upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernel.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/s390x/SgemmKernelZVECTOR.cpp b/upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernelZVECTOR.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/s390x/SgemmKernelZVECTOR.cpp
rename to upstream/opencv/3rdparty/mlas/lib/s390x/SgemmKernelZVECTOR.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SconvDepthwiseKernelScalar.cpp b/upstream/opencv/3rdparty/mlas/lib/scalar/SconvDepthwiseKernelScalar.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SconvDepthwiseKernelScalar.cpp
rename to upstream/opencv/3rdparty/mlas/lib/scalar/SconvDepthwiseKernelScalar.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SgemmKernelScalar.cpp b/upstream/opencv/3rdparty/mlas/lib/scalar/SgemmKernelScalar.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SgemmKernelScalar.cpp
rename to upstream/opencv/3rdparty/mlas/lib/scalar/SgemmKernelScalar.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SgemvKernelScalar.cpp b/upstream/opencv/3rdparty/mlas/lib/scalar/SgemvKernelScalar.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/scalar/SgemvKernelScalar.cpp
rename to upstream/opencv/3rdparty/mlas/lib/scalar/SgemvKernelScalar.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/sgemm.cpp b/upstream/opencv/3rdparty/mlas/lib/sgemm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/sgemm.cpp
rename to upstream/opencv/3rdparty/mlas/lib/sgemm.cpp
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/softmax.h b/upstream/opencv/3rdparty/mlas/lib/softmax.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/softmax.h
rename to upstream/opencv/3rdparty/mlas/lib/softmax.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/sve/mlasi_sve.h b/upstream/opencv/3rdparty/mlas/lib/sve/mlasi_sve.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/sve/mlasi_sve.h
rename to upstream/opencv/3rdparty/mlas/lib/sve/mlasi_sve.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/SgemmKernelAvx.S b/upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelAvx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/SgemmKernelAvx.S
rename to upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelAvx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/SgemmKernelSse2.S b/upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelSse2.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/SgemmKernelSse2.S
rename to upstream/opencv/3rdparty/mlas/lib/x86/SgemmKernelSse2.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/asmmacro.h b/upstream/opencv/3rdparty/mlas/lib/x86/asmmacro.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/asmmacro.h
rename to upstream/opencv/3rdparty/mlas/lib/x86/asmmacro.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/x86.get_pc_thunk.S b/upstream/opencv/3rdparty/mlas/lib/x86/x86.get_pc_thunk.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86/x86.get_pc_thunk.S
rename to upstream/opencv/3rdparty/mlas/lib/x86/x86.get_pc_thunk.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelAvx512FCommon.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvx512FCommon.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelAvx512FCommon.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvx512FCommon.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelAvxCommon.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvxCommon.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelAvxCommon.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelAvxCommon.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelCommon.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelCommon.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelCommon.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelCommon.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelFma3Common.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelFma3Common.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelFma3Common.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelFma3Common.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelSse2Common.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelSse2Common.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/FgemmKernelSse2Common.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/FgemmKernelSse2Common.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelAvx.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelAvx.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelAvx512F.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx512F.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelAvx512F.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelAvx512F.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelCommon.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelCommon.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelCommon.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelCommon.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelFma3.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelFma3.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelFma3.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelFma3.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelM1Avx.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1Avx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelM1Avx.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1Avx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelM1TransposeBAvx.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1TransposeBAvx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelM1TransposeBAvx.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelM1TransposeBAvx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelSse2.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelSse2.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmKernelSse2.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmKernelSse2.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Avx.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Avx.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Avx.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Avx.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Sse2.S b/upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Sse2.S
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Sse2.S
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/SgemmTransposePackB16x4Sse2.S
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/asmmacro.h b/upstream/opencv/3rdparty/mlas/lib/x86_64/asmmacro.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/lib/x86_64/asmmacro.h
rename to upstream/opencv/3rdparty/mlas/lib/x86_64/asmmacro.h
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/patches/0001-mlasi-opencv-threading.diff b/upstream/opencv/3rdparty/mlas/patches/0001-mlasi-opencv-threading.diff
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/patches/0001-mlasi-opencv-threading.diff
rename to upstream/opencv/3rdparty/mlas/patches/0001-mlasi-opencv-threading.diff
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/patches/0002-platform-gemm-only.diff b/upstream/opencv/3rdparty/mlas/patches/0002-platform-gemm-only.diff
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/patches/0002-platform-gemm-only.diff
rename to upstream/opencv/3rdparty/mlas/patches/0002-platform-gemm-only.diff
diff --git a/third_party/opencv-5.0.0/3rdparty/mlas/patches/0003-mlas-h-msc-ver-guard.diff b/upstream/opencv/3rdparty/mlas/patches/0003-mlas-h-msc-ver-guard.diff
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/mlas/patches/0003-mlas-h-msc-ver-guard.diff
rename to upstream/opencv/3rdparty/mlas/patches/0003-mlas-h-msc-ver-guard.diff
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/CMakeLists.txt b/upstream/opencv/3rdparty/protobuf/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/CMakeLists.txt
rename to upstream/opencv/3rdparty/protobuf/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/LICENSE b/upstream/opencv/3rdparty/protobuf/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/LICENSE
rename to upstream/opencv/3rdparty/protobuf/LICENSE
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/README.md b/upstream/opencv/3rdparty/protobuf/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/README.md
rename to upstream/opencv/3rdparty/protobuf/README.md
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/any.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any_lite.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/any_lite.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/any_lite.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/any_lite.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena_impl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena_impl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arena_impl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/arena_impl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arenastring.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arenastring.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arenastring.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/arenastring.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/arenastring.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.pb.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.pb.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.pb.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.pb.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor.pb.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor.pb.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor_database.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor_database.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor_database.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/descriptor_database.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/descriptor_database.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/dynamic_message.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/dynamic_message.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/dynamic_message.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/dynamic_message.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/dynamic_message.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/explicitly_constructed.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/explicitly_constructed.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/explicitly_constructed.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/explicitly_constructed.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set_heavy.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_heavy.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set_heavy.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_heavy.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set_inl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_inl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/extension_set_inl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/extension_set_inl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/field_access_listener.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/field_access_listener.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/field_access_listener.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/field_access_listener.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/field_mask.pb.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/field_mask.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/field_mask.pb.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/field_mask.pb.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_reflection.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_reflection.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_reflection.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_reflection.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_util.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_util.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_util.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_enum_util.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_enum_util.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_bases.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_bases.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_bases.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_bases.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_reflection.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_table_driven.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_table_driven.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_table_driven.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_table_driven.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_decl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_decl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_decl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_decl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.inc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_util.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_util.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_util.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/generated_message_util.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/generated_message_util.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/has_bits.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/has_bits.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/has_bits.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/has_bits.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/implicit_weak_message.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/inlined_string_field.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/inlined_string_field.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/inlined_string_field.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/inlined_string_field.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/coded_stream.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/coded_stream.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/coded_stream.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/coded_stream.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/coded_stream.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/io_win32.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/io_win32.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/io_win32.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/io_win32.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/io_win32.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/package_info.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/package_info.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/package_info.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/package_info.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/strtod.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/strtod.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/strtod.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/strtod.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/strtod.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/tokenizer.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/tokenizer.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/tokenizer.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/tokenizer.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/tokenizer.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_entry.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_entry.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_entry_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_entry_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_entry_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field_inl.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_inl.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field_inl.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_inl.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_field_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_field_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_type_handler.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_type_handler.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/map_type_handler.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/map_type_handler.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/message.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message_lite.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message_lite.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/message_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/message_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/metadata.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/metadata.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/metadata_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/metadata_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/metadata_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/parse_context.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/parse_context.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/parse_context.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/parse_context.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/parse_context.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/port.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/port.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port_def.inc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_def.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port_def.inc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_def.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port_undef.inc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_undef.inc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/port_undef.inc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/port_undef.inc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_internal.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_internal.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_internal.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_internal.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_ops.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_ops.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_ops.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/reflection_ops.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/reflection_ops.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_field.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_field.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_field.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_field.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_field.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/repeated_ptr_field.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/bytestream.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/callback.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/callback.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/callback.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/callback.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/casts.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/casts.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/casts.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/casts.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/common.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/common.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/common.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/common.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/common.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/hash.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/hash.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/hash.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/hash.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/int128.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/int128.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/int128.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/int128.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/int128.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/logging.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/logging.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/logging.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/logging.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/macros.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/macros.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/macros.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/macros.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/map_util.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/map_util.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/map_util.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/map_util.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/mutex.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/mutex.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/mutex.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/mutex.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/once.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/once.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/once.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/once.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/platform_macros.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/platform_macros.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/platform_macros.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/platform_macros.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/port.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/port.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/port.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/port.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/status.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/status.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/status.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/status.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/status.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stl_util.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stl_util.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stl_util.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stl_util.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringpiece.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/stringprintf.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/structurally_valid.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/structurally_valid.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/structurally_valid.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/structurally_valid.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/strutil.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/strutil.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/strutil.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/strutil.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/strutil.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/substitute.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/substitute.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/substitute.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/stubs/substitute.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/stubs/substitute.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/text_format.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/text_format.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/text_format.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/text_format.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/text_format.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/unknown_field_set.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/unknown_field_set.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/unknown_field_set.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/unknown_field_set.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/unknown_field_set.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format.h
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format_lite.cc b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.cc
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format_lite.cc
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.cc
diff --git a/third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format_lite.h b/upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/protobuf/src/google/protobuf/wire_format_lite.h
rename to upstream/opencv/3rdparty/protobuf/src/google/protobuf/wire_format_lite.h
diff --git a/third_party/opencv-5.0.0/3rdparty/readme.txt b/upstream/opencv/3rdparty/readme.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/readme.txt
rename to upstream/opencv/3rdparty/readme.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/CMakeLists.txt b/upstream/opencv/3rdparty/zlib/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/CMakeLists.txt
rename to upstream/opencv/3rdparty/zlib/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/ChangeLog b/upstream/opencv/3rdparty/zlib/ChangeLog
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/ChangeLog
rename to upstream/opencv/3rdparty/zlib/ChangeLog
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/LICENSE b/upstream/opencv/3rdparty/zlib/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/LICENSE
rename to upstream/opencv/3rdparty/zlib/LICENSE
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/README b/upstream/opencv/3rdparty/zlib/README
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/README
rename to upstream/opencv/3rdparty/zlib/README
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/adler32.c b/upstream/opencv/3rdparty/zlib/adler32.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/adler32.c
rename to upstream/opencv/3rdparty/zlib/adler32.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/compress.c b/upstream/opencv/3rdparty/zlib/compress.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/compress.c
rename to upstream/opencv/3rdparty/zlib/compress.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/crc32.c b/upstream/opencv/3rdparty/zlib/crc32.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/crc32.c
rename to upstream/opencv/3rdparty/zlib/crc32.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/crc32.h b/upstream/opencv/3rdparty/zlib/crc32.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/crc32.h
rename to upstream/opencv/3rdparty/zlib/crc32.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/deflate.c b/upstream/opencv/3rdparty/zlib/deflate.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/deflate.c
rename to upstream/opencv/3rdparty/zlib/deflate.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/deflate.h b/upstream/opencv/3rdparty/zlib/deflate.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/deflate.h
rename to upstream/opencv/3rdparty/zlib/deflate.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/gzclose.c b/upstream/opencv/3rdparty/zlib/gzclose.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/gzclose.c
rename to upstream/opencv/3rdparty/zlib/gzclose.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/gzguts.h b/upstream/opencv/3rdparty/zlib/gzguts.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/gzguts.h
rename to upstream/opencv/3rdparty/zlib/gzguts.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/gzlib.c b/upstream/opencv/3rdparty/zlib/gzlib.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/gzlib.c
rename to upstream/opencv/3rdparty/zlib/gzlib.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/gzread.c b/upstream/opencv/3rdparty/zlib/gzread.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/gzread.c
rename to upstream/opencv/3rdparty/zlib/gzread.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/gzwrite.c b/upstream/opencv/3rdparty/zlib/gzwrite.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/gzwrite.c
rename to upstream/opencv/3rdparty/zlib/gzwrite.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/infback.c b/upstream/opencv/3rdparty/zlib/infback.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/infback.c
rename to upstream/opencv/3rdparty/zlib/infback.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inffast.c b/upstream/opencv/3rdparty/zlib/inffast.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inffast.c
rename to upstream/opencv/3rdparty/zlib/inffast.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inffast.h b/upstream/opencv/3rdparty/zlib/inffast.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inffast.h
rename to upstream/opencv/3rdparty/zlib/inffast.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inffixed.h b/upstream/opencv/3rdparty/zlib/inffixed.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inffixed.h
rename to upstream/opencv/3rdparty/zlib/inffixed.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inflate.c b/upstream/opencv/3rdparty/zlib/inflate.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inflate.c
rename to upstream/opencv/3rdparty/zlib/inflate.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inflate.h b/upstream/opencv/3rdparty/zlib/inflate.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inflate.h
rename to upstream/opencv/3rdparty/zlib/inflate.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inftrees.c b/upstream/opencv/3rdparty/zlib/inftrees.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inftrees.c
rename to upstream/opencv/3rdparty/zlib/inftrees.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/inftrees.h b/upstream/opencv/3rdparty/zlib/inftrees.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/inftrees.h
rename to upstream/opencv/3rdparty/zlib/inftrees.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/patches/20190330-ununitialized-use-state-check.diff b/upstream/opencv/3rdparty/zlib/patches/20190330-ununitialized-use-state-check.diff
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/patches/20190330-ununitialized-use-state-check.diff
rename to upstream/opencv/3rdparty/zlib/patches/20190330-ununitialized-use-state-check.diff
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/patches/20260409-warnings-fix.diff b/upstream/opencv/3rdparty/zlib/patches/20260409-warnings-fix.diff
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/patches/20260409-warnings-fix.diff
rename to upstream/opencv/3rdparty/zlib/patches/20260409-warnings-fix.diff
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/trees.c b/upstream/opencv/3rdparty/zlib/trees.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/trees.c
rename to upstream/opencv/3rdparty/zlib/trees.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/trees.h b/upstream/opencv/3rdparty/zlib/trees.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/trees.h
rename to upstream/opencv/3rdparty/zlib/trees.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/uncompr.c b/upstream/opencv/3rdparty/zlib/uncompr.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/uncompr.c
rename to upstream/opencv/3rdparty/zlib/uncompr.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/zconf.h.in b/upstream/opencv/3rdparty/zlib/zconf.h.in
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/zconf.h.in
rename to upstream/opencv/3rdparty/zlib/zconf.h.in
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/zlib.h b/upstream/opencv/3rdparty/zlib/zlib.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/zlib.h
rename to upstream/opencv/3rdparty/zlib/zlib.h
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/zutil.c b/upstream/opencv/3rdparty/zlib/zutil.c
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/zutil.c
rename to upstream/opencv/3rdparty/zlib/zutil.c
diff --git a/third_party/opencv-5.0.0/3rdparty/zlib/zutil.h b/upstream/opencv/3rdparty/zlib/zutil.h
similarity index 100%
rename from third_party/opencv-5.0.0/3rdparty/zlib/zutil.h
rename to upstream/opencv/3rdparty/zlib/zutil.h
diff --git a/third_party/opencv-5.0.0/COPYRIGHT b/upstream/opencv/COPYRIGHT
similarity index 100%
rename from third_party/opencv-5.0.0/COPYRIGHT
rename to upstream/opencv/COPYRIGHT
diff --git a/third_party/opencv-5.0.0/LICENSE b/upstream/opencv/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/LICENSE
rename to upstream/opencv/LICENSE
diff --git a/third_party/opencv-5.0.0/README.md b/upstream/opencv/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/README.md
rename to upstream/opencv/README.md
diff --git a/third_party/opencv-5.0.0/include/CMakeLists.txt b/upstream/opencv/include/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/include/CMakeLists.txt
rename to upstream/opencv/include/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/include/opencv2/opencv.hpp b/upstream/opencv/include/opencv2/opencv.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/include/opencv2/opencv.hpp
rename to upstream/opencv/include/opencv2/opencv.hpp
diff --git a/upstream/opencv/modules/calib/CMakeLists.txt b/upstream/opencv/modules/calib/CMakeLists.txt
new file mode 100644
index 0000000..234e48b
--- /dev/null
+++ b/upstream/opencv/modules/calib/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(the_description "Camera Calibration and 3D Reconstruction")
+
+set(debug_modules "")
+if(DEBUG_opencv_calib)
+  list(APPEND debug_modules opencv_highgui)
+endif()
+ocv_define_module(calib opencv_imgproc opencv_objdetect opencv_flann opencv_geometry opencv_stereo ${debug_modules}
+    WRAP java objc python js
+)
diff --git a/upstream/opencv/modules/calib/doc/calib.bib b/upstream/opencv/modules/calib/doc/calib.bib
new file mode 100644
index 0000000..9646154
--- /dev/null
+++ b/upstream/opencv/modules/calib/doc/calib.bib
@@ -0,0 +1,12 @@
+@inproceedings{strobl2011iccv,
+  title={More accurate pinhole camera calibration with imperfect planar target},
+  author={Strobl, Klaus H. and Hirzinger, Gerd},
+  booktitle={2011 IEEE International Conference on Computer Vision (ICCV)},
+  pages={1068-1075},
+  month={Nov},
+  year={2011},
+  address={Barcelona, Spain},
+  publisher={IEEE},
+  url={https://elib.dlr.de/71888/1/strobl_2011iccv.pdf},
+  doi={10.1109/ICCVW.2011.6130369}
+}
diff --git a/upstream/opencv/modules/calib/doc/pics/checkerboard_radon.png b/upstream/opencv/modules/calib/doc/pics/checkerboard_radon.png
new file mode 100644
index 0000000..63902f7
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/checkerboard_radon.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/distortion_examples.png b/upstream/opencv/modules/calib/doc/pics/distortion_examples.png
new file mode 100644
index 0000000..f04de94
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/distortion_examples.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/distortion_examples2.png b/upstream/opencv/modules/calib/doc/pics/distortion_examples2.png
new file mode 100644
index 0000000..d1910b1
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/distortion_examples2.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/fisheye_undistorted.jpg b/upstream/opencv/modules/calib/doc/pics/fisheye_undistorted.jpg
new file mode 100644
index 0000000..bfdc9af
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/fisheye_undistorted.jpg differ
diff --git a/upstream/opencv/modules/calib/doc/pics/hand-eye_figure.png b/upstream/opencv/modules/calib/doc/pics/hand-eye_figure.png
new file mode 100644
index 0000000..0d53be4
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/hand-eye_figure.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/multiview_calib.png b/upstream/opencv/modules/calib/doc/pics/multiview_calib.png
new file mode 100644
index 0000000..6fb488c
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/multiview_calib.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/pinhole_camera_model.png b/upstream/opencv/modules/calib/doc/pics/pinhole_camera_model.png
new file mode 100644
index 0000000..67415fe
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/pinhole_camera_model.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/register_pair.png b/upstream/opencv/modules/calib/doc/pics/register_pair.png
new file mode 100644
index 0000000..f1e2377
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/register_pair.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/robot-world_hand-eye_figure.png b/upstream/opencv/modules/calib/doc/pics/robot-world_hand-eye_figure.png
new file mode 100644
index 0000000..26f5eca
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/robot-world_hand-eye_figure.png differ
diff --git a/upstream/opencv/modules/calib/doc/pics/stereo_undistort.jpg b/upstream/opencv/modules/calib/doc/pics/stereo_undistort.jpg
new file mode 100644
index 0000000..9079739
Binary files /dev/null and b/upstream/opencv/modules/calib/doc/pics/stereo_undistort.jpg differ
diff --git a/upstream/opencv/modules/calib/include/opencv2/calib.hpp b/upstream/opencv/modules/calib/include/opencv2/calib.hpp
new file mode 100644
index 0000000..176c321
--- /dev/null
+++ b/upstream/opencv/modules/calib/include/opencv2/calib.hpp
@@ -0,0 +1,1526 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_CALIB_HPP
+#define OPENCV_CALIB_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/types.hpp"
+#include "opencv2/core/affine.hpp"
+
+/**
+  @defgroup calib Camera Calibration
+
+The functions in this section use a so-called pinhole camera model. The view of a scene
+is obtained by projecting a scene's 3D point \f$P_w\f$ into the image plane using a perspective
+transformation which forms the corresponding pixel \f$p\f$. Both \f$P_w\f$ and \f$p\f$ are
+represented in homogeneous coordinates, i.e. as 3D and 2D homogeneous vector respectively. You will
+find a brief introduction to projective geometry, homogeneous vectors and homogeneous
+transformations at the end of this section's introduction. For more succinct notation, we often drop
+the 'homogeneous' and say vector instead of homogeneous vector.
+
+The distortion-free projective transformation given by a  pinhole camera model is shown below.
+
+\f[s \; p = A \begin{bmatrix} R|t \end{bmatrix} P_w,\f]
+
+where \f$P_w\f$ is a 3D point expressed with respect to the world coordinate system,
+\f$p\f$ is a 2D pixel in the image plane, \f$A\f$ is the camera intrinsic matrix,
+\f$R\f$ and \f$t\f$ are the rotation and translation that describe the change of coordinates from
+world to camera coordinate systems (or camera frame) and \f$s\f$ is the projective transformation's
+arbitrary scaling and not part of the camera model.
+
+The camera intrinsic matrix \f$A\f$ (notation used as in @cite Zhang2000 and also generally notated
+as \f$K\f$) projects 3D points given in the camera coordinate system to 2D pixel coordinates, i.e.
+
+\f[p = A P_c.\f]
+
+The camera intrinsic matrix \f$A\f$ is composed of the focal lengths \f$f_x\f$ and \f$f_y\f$, which are
+expressed in pixel units, and the principal point \f$(c_x, c_y)\f$, that is usually close to the
+image center:
+
+\f[A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1},\f]
+
+and thus
+
+\f[s \vecthree{u}{v}{1} = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1} \vecthree{X_c}{Y_c}{Z_c}.\f]
+
+The matrix of intrinsic parameters does not depend on the scene viewed. So, once estimated, it can
+be re-used as long as the focal length is fixed (in case of a zoom lens). Thus, if an image from the
+camera is scaled by a factor, all of these parameters need to be scaled (multiplied/divided,
+respectively) by the same factor.
+
+The joint rotation-translation matrix \f$[R|t]\f$ is the matrix product of a projective
+transformation and a homogeneous transformation. The 3-by-4 projective transformation maps 3D points
+represented in camera coordinates to 2D points in the image plane and represented in normalized
+camera coordinates \f$x' = X_c / Z_c\f$ and \f$y' = Y_c / Z_c\f$:
+
+\f[Z_c \begin{bmatrix}
+x' \\
+y' \\
+1
+\end{bmatrix} = \begin{bmatrix}
+1 & 0 & 0 & 0 \\
+0 & 1 & 0 & 0 \\
+0 & 0 & 1 & 0
+\end{bmatrix}
+\begin{bmatrix}
+X_c \\
+Y_c \\
+Z_c \\
+1
+\end{bmatrix}.\f]
+
+The homogeneous transformation is encoded by the extrinsic parameters \f$R\f$ and \f$t\f$ and
+represents the change of basis from world coordinate system \f$w\f$ to the camera coordinate sytem
+\f$c\f$. Thus, given the representation of the point \f$P\f$ in world coordinates, \f$P_w\f$, we
+obtain \f$P\f$'s representation in the camera coordinate system, \f$P_c\f$, by
+
+\f[P_c = \begin{bmatrix}
+R & t \\
+0 & 1
+\end{bmatrix} P_w,\f]
+
+This homogeneous transformation is composed out of \f$R\f$, a 3-by-3 rotation matrix, and \f$t\f$, a
+3-by-1 translation vector:
+
+\f[\begin{bmatrix}
+R & t \\
+0 & 1
+\end{bmatrix} = \begin{bmatrix}
+r_{11} & r_{12} & r_{13} & t_x \\
+r_{21} & r_{22} & r_{23} & t_y \\
+r_{31} & r_{32} & r_{33} & t_z \\
+0 & 0 & 0 & 1
+\end{bmatrix},
+\f]
+
+and therefore
+
+\f[\begin{bmatrix}
+X_c \\
+Y_c \\
+Z_c \\
+1
+\end{bmatrix} = \begin{bmatrix}
+r_{11} & r_{12} & r_{13} & t_x \\
+r_{21} & r_{22} & r_{23} & t_y \\
+r_{31} & r_{32} & r_{33} & t_z \\
+0 & 0 & 0 & 1
+\end{bmatrix}
+\begin{bmatrix}
+X_w \\
+Y_w \\
+Z_w \\
+1
+\end{bmatrix}.\f]
+
+Combining the projective transformation and the homogeneous transformation, we obtain the projective
+transformation that maps 3D points in world coordinates into 2D points in the image plane and in
+normalized camera coordinates:
+
+\f[Z_c \begin{bmatrix}
+x' \\
+y' \\
+1
+\end{bmatrix} = \begin{bmatrix} R|t \end{bmatrix} \begin{bmatrix}
+X_w \\
+Y_w \\
+Z_w \\
+1
+\end{bmatrix} = \begin{bmatrix}
+r_{11} & r_{12} & r_{13} & t_x \\
+r_{21} & r_{22} & r_{23} & t_y \\
+r_{31} & r_{32} & r_{33} & t_z
+\end{bmatrix}
+\begin{bmatrix}
+X_w \\
+Y_w \\
+Z_w \\
+1
+\end{bmatrix},\f]
+
+with \f$x' = X_c / Z_c\f$ and \f$y' = Y_c / Z_c\f$. Putting the equations for instrincs and extrinsics together, we can write out
+\f$s \; p = A \begin{bmatrix} R|t \end{bmatrix} P_w\f$ as
+
+\f[s \vecthree{u}{v}{1} = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}
+\begin{bmatrix}
+r_{11} & r_{12} & r_{13} & t_x \\
+r_{21} & r_{22} & r_{23} & t_y \\
+r_{31} & r_{32} & r_{33} & t_z
+\end{bmatrix}
+\begin{bmatrix}
+X_w \\
+Y_w \\
+Z_w \\
+1
+\end{bmatrix}.\f]
+
+If \f$Z_c \ne 0\f$, the transformation above is equivalent to the following,
+
+\f[\begin{bmatrix}
+u \\
+v
+\end{bmatrix} = \begin{bmatrix}
+f_x X_c/Z_c + c_x \\
+f_y Y_c/Z_c + c_y
+\end{bmatrix}\f]
+
+with
+
+\f[\vecthree{X_c}{Y_c}{Z_c} = \begin{bmatrix}
+R|t
+\end{bmatrix} \begin{bmatrix}
+X_w \\
+Y_w \\
+Z_w \\
+1
+\end{bmatrix}.\f]
+
+The following figure illustrates the pinhole camera model.
+
+![Pinhole camera model](pics/pinhole_camera_model.png) { width=70% }
+
+Real lenses usually have some distortion, mostly radial distortion, and slight tangential distortion.
+So, the above model is extended as:
+
+\f[\begin{bmatrix}
+u \\
+v
+\end{bmatrix} = \begin{bmatrix}
+f_x x'' + c_x \\
+f_y y'' + c_y
+\end{bmatrix}\f]
+
+where
+
+\f[\begin{bmatrix}
+x'' \\
+y''
+\end{bmatrix} = \begin{bmatrix}
+x' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + 2 p_1 x' y' + p_2(r^2 + 2 x'^2) + s_1 r^2 + s_2 r^4 \\
+y' \frac{1 + k_1 r^2 + k_2 r^4 + k_3 r^6}{1 + k_4 r^2 + k_5 r^4 + k_6 r^6} + p_1 (r^2 + 2 y'^2) + 2 p_2 x' y' + s_3 r^2 + s_4 r^4 \\
+\end{bmatrix}\f]
+
+with
+
+\f[r^2 = x'^2 + y'^2\f]
+
+and
+
+\f[\begin{bmatrix}
+x'\\
+y'
+\end{bmatrix} = \begin{bmatrix}
+X_c/Z_c \\
+Y_c/Z_c
+\end{bmatrix},\f]
+
+if \f$Z_c \ne 0\f$.
+
+The distortion parameters are the radial coefficients \f$k_1\f$, \f$k_2\f$, \f$k_3\f$, \f$k_4\f$, \f$k_5\f$, and \f$k_6\f$
+,\f$p_1\f$ and \f$p_2\f$ are the tangential distortion coefficients, and \f$s_1\f$, \f$s_2\f$, \f$s_3\f$, and \f$s_4\f$,
+are the thin prism distortion coefficients. Higher-order coefficients are not considered in OpenCV.
+
+The next figures show two common types of radial distortion: barrel distortion
+(\f$ 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 \f$ monotonically decreasing)
+and pincushion distortion (\f$ 1 + k_1 r^2 + k_2 r^4 + k_3 r^6 \f$ monotonically increasing).
+Radial distortion is always monotonic for real lenses,
+and if the estimator produces a non-monotonic result,
+this should be considered a calibration failure.
+More generally, radial distortion must be monotonic and the distortion function must be bijective.
+A failed estimation result may look deceptively good near the image center
+but will work poorly in e.g. AR/SFM applications.
+The optimization method used in OpenCV camera calibration does not include these constraints as
+the framework does not support the required integer programming and polynomial inequalities.
+See [issue #15992](https://github.com/opencv/opencv/issues/15992) for additional information.
+
+![](pics/distortion_examples.png)
+![](pics/distortion_examples2.png)
+
+In some cases, the image sensor may be tilted in order to focus an oblique plane in front of the
+camera (Scheimpflug principle). This can be useful for particle image velocimetry (PIV) or
+triangulation with a laser fan. The tilt causes a perspective distortion of \f$x''\f$ and
+\f$y''\f$. This distortion can be modeled in the following way, see e.g. @cite Louhichi07.
+
+\f[\begin{bmatrix}
+u \\
+v
+\end{bmatrix} = \begin{bmatrix}
+f_x x''' + c_x \\
+f_y y''' + c_y
+\end{bmatrix},\f]
+
+where
+
+\f[s\vecthree{x'''}{y'''}{1} =
+\vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}(\tau_x, \tau_y)}
+{0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)}
+{0}{0}{1} R(\tau_x, \tau_y) \vecthree{x''}{y''}{1}\f]
+
+and the matrix \f$R(\tau_x, \tau_y)\f$ is defined by two rotations with angular parameter
+\f$\tau_x\f$ and \f$\tau_y\f$, respectively,
+
+\f[
+R(\tau_x, \tau_y) =
+\vecthreethree{\cos(\tau_y)}{0}{-\sin(\tau_y)}{0}{1}{0}{\sin(\tau_y)}{0}{\cos(\tau_y)}
+\vecthreethree{1}{0}{0}{0}{\cos(\tau_x)}{\sin(\tau_x)}{0}{-\sin(\tau_x)}{\cos(\tau_x)} =
+\vecthreethree{\cos(\tau_y)}{\sin(\tau_y)\sin(\tau_x)}{-\sin(\tau_y)\cos(\tau_x)}
+{0}{\cos(\tau_x)}{\sin(\tau_x)}
+{\sin(\tau_y)}{-\cos(\tau_y)\sin(\tau_x)}{\cos(\tau_y)\cos(\tau_x)}.
+\f]
+
+In the functions below the coefficients are passed or returned as
+
+\f[(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]]]])\f]
+
+vector. That is, if the vector contains four elements, it means that \f$k_3=0\f$ . The distortion
+coefficients do not depend on the scene viewed. Thus, they also belong to the intrinsic camera
+parameters. And they remain the same regardless of the captured image resolution. If, for example, a
+camera has been calibrated on images of 320 x 240 resolution, absolutely the same distortion
+coefficients can be used for 640 x 480 images from the same camera while \f$f_x\f$, \f$f_y\f$,
+\f$c_x\f$, and \f$c_y\f$ need to be scaled appropriately.
+
+The functions below use the above model to do the following:
+
+-   Project 3D points to the image plane given intrinsic and extrinsic parameters.
+-   Compute extrinsic parameters given intrinsic parameters, a few 3D points, and their
+projections.
+-   Estimate intrinsic and extrinsic camera parameters from several views of a known calibration
+pattern (every view is described by several 3D-2D point correspondences).
+-   Estimate the relative position and orientation of the stereo camera "heads" and compute the
+*rectification* transformation that makes the camera optical axes parallel.
+
+<B> Homogeneous Coordinates </B><br>
+Homogeneous Coordinates are a system of coordinates that are used in projective geometry. Their use
+allows to represent points at infinity by finite coordinates and simplifies formulas when compared
+to the cartesian counterparts, e.g. they have the advantage that affine transformations can be
+expressed as linear homogeneous transformation.
+
+One obtains the homogeneous vector \f$P_h\f$ by appending a 1 along an n-dimensional cartesian
+vector \f$P\f$ e.g. for a 3D cartesian vector the mapping \f$P \rightarrow P_h\f$ is:
+
+\f[\begin{bmatrix}
+X \\
+Y \\
+Z
+\end{bmatrix} \rightarrow \begin{bmatrix}
+X \\
+Y \\
+Z \\
+1
+\end{bmatrix}.\f]
+
+For the inverse mapping \f$P_h \rightarrow P\f$, one divides all elements of the homogeneous vector
+by its last element, e.g. for a 3D homogeneous vector one gets its 2D cartesian counterpart by:
+
+\f[\begin{bmatrix}
+X \\
+Y \\
+W
+\end{bmatrix} \rightarrow \begin{bmatrix}
+X / W \\
+Y / W
+\end{bmatrix},\f]
+
+if \f$W \ne 0\f$.
+
+Due to this mapping, all multiples \f$k P_h\f$, for \f$k \ne 0\f$, of a homogeneous point represent
+the same point \f$P_h\f$. An intuitive understanding of this property is that under a projective
+transformation, all multiples of \f$P_h\f$ are mapped to the same point. This is the physical
+observation one does for pinhole cameras, as all points along a ray through the camera's pinhole are
+projected to the same image point, e.g. all points along the red ray in the image of the pinhole
+camera model above would be mapped to the same image coordinate. This property is also the source
+for the scale ambiguity s in the equation of the pinhole camera model.
+
+As mentioned, by using homogeneous coordinates we can express any change of basis parameterized by
+\f$R\f$ and \f$t\f$ as a linear transformation, e.g. for the change of basis from coordinate system
+0 to coordinate system 1 becomes:
+
+\f[P_1 = R P_0 + t \rightarrow P_{h_1} = \begin{bmatrix}
+R & t \\
+0 & 1
+\end{bmatrix} P_{h_0}.\f]
+
+<B> Homogeneous Transformations, Object frame / Camera frame </B><br>
+Change of basis or computing the 3D coordinates from one frame to another frame can be achieved easily using
+the following notation:
+\f[
+\mathbf{X}_c = \hspace{0.2em}
+{}^{c}\mathbf{T}_o \hspace{0.2em} \mathbf{X}_o
+\f]
+\f[
+\begin{bmatrix}
+X_c \\
+Y_c \\
+Z_c \\
+1
+\end{bmatrix} =
+\begin{bmatrix}
+{}^{c}\mathbf{R}_o & {}^{c}\mathbf{t}_o \\
+0_{1 \times 3} & 1
+\end{bmatrix}
+\begin{bmatrix}
+X_o \\
+Y_o \\
+Z_o \\
+1
+\end{bmatrix}
+\f]
+For a 3D points (\f$ \mathbf{X}_o \f$) expressed in the object frame, the homogeneous transformation matrix
+\f$ {}^{c}\mathbf{T}_o \f$ allows computing the corresponding coordinate (\f$ \mathbf{X}_c \f$) in the camera frame.
+This transformation matrix is composed of a 3x3 rotation matrix \f$ {}^{c}\mathbf{R}_o \f$ and a 3x1 translation vector
+\f$ {}^{c}\mathbf{t}_o \f$.
+The 3x1 translation vector \f$ {}^{c}\mathbf{t}_o \f$ is the position of the object frame in the camera frame and the
+3x3 rotation matrix \f$ {}^{c}\mathbf{R}_o \f$ the orientation of the object frame in the camera frame.
+With this simple notation, it is easy to chain the transformations. For instance, to compute the 3D coordinates of a point
+expressed in the object frame in the world frame can be done with:
+\f[
+\mathbf{X}_w = \hspace{0.2em}
+{}^{w}\mathbf{T}_c \hspace{0.2em} {}^{c}\mathbf{T}_o \hspace{0.2em}
+\mathbf{X}_o =
+{}^{w}\mathbf{T}_o \hspace{0.2em} \mathbf{X}_o
+\f]
+Similarly, computing the inverse transformation can be done with:
+\f[
+\mathbf{X}_o = \hspace{0.2em}
+{}^{o}\mathbf{T}_c \hspace{0.2em} \mathbf{X}_c =
+\left( {}^{c}\mathbf{T}_o \right)^{-1} \hspace{0.2em} \mathbf{X}_c
+\f]
+The inverse of an homogeneous transformation matrix is then:
+\f[
+{}^{o}\mathbf{T}_c = \left( {}^{c}\mathbf{T}_o \right)^{-1} =
+\begin{bmatrix}
+{}^{c}\mathbf{R}^{\top}_o & - \hspace{0.2em} {}^{c}\mathbf{R}^{\top}_o \hspace{0.2em} {}^{c}\mathbf{t}_o \\
+0_{1 \times 3} & 1
+\end{bmatrix}
+\f]
+One can note that the inverse of a 3x3 rotation matrix is directly its matrix transpose.
+![Perspective projection, from object to camera frame](pics/pinhole_homogeneous_transformation.png)
+This figure summarizes the whole process. The object pose returned for instance by the @ref solvePnP function
+or pose from fiducial marker detection is this \f$ {}^{c}\mathbf{T}_o \f$ transformation.
+The camera intrinsic matrix \f$ \mathbf{K} \f$ allows projecting the 3D point expressed in the camera frame onto the image plane
+assuming a perspective projection model (pinhole camera model). Image coordinates extracted from classical image processing functions
+assume a (u,v) top-left coordinates frame.
+\note
+- for an online video course on this topic, see for instance:
+  - ["3.3.1. Homogeneous Transformation Matrices", Modern Robotics, Kevin M. Lynch and Frank C. Park](https://modernrobotics.northwestern.edu/nu-gm-book-resource/3-3-1-homogeneous-transformation-matrices/)
+- the 3x3 rotation matrix is composed of 9 values but describes a 3 dof transformation
+- some additional properties of the 3x3 rotation matrix are:
+  - \f$ \mathrm{det} \left( \mathbf{R} \right) = 1 \f$
+  - \f$ \mathbf{R} \mathbf{R}^{\top} = \mathbf{R}^{\top} \mathbf{R} = \mathrm{I}_{3 \times 3} \f$
+  - interpolating rotation can be done using the [Slerp (spherical linear interpolation)](https://en.wikipedia.org/wiki/Slerp) method
+- quick conversions between the different rotation formalisms can be done using this [online tool](https://www.andre-gaschler.com/rotationconverter/)
+<B> Intrinsic parameters from camera lens specifications </B><br>
+When dealing with industrial cameras, the camera intrinsic matrix or more precisely \f$ \left(f_x, f_y \right) \f$
+can be deduced, approximated from the camera specifications:
+\f[
+f_x = \frac{f_{\text{mm}}}{\text{pixel_size_in_mm}} = \frac{f_{\text{mm}}}{\text{sensor_size_in_mm} / \text{nb_pixels}}
+\f]
+In a same way, the physical focal length can be deduced from the angular field of view:
+\f[
+f_{\text{mm}} = \frac{\text{sensor_size_in_mm}}{2 \times \tan{\frac{\text{fov}}{2}}}
+\f]
+This latter conversion can be useful when using a rendering software to mimic a physical camera device.
+
+@note
+    -    See also #calibrationMatrixValues
+
+<B> Additional references, notes </B><br>
+@note
+    -   Many functions in this module take a camera intrinsic matrix as an input parameter. Although all
+        functions assume the same structure of this parameter, they may name it differently. The
+        parameter's description, however, will be clear in that a camera intrinsic matrix with the structure
+        shown above is required.
+    -   A calibration sample for 3 cameras in a horizontal position can be found at
+        opencv_source_code/samples/cpp/3calibration.cpp
+    -   A calibration sample based on a sequence of images can be found at
+        opencv_source_code/samples/cpp/calibration.cpp
+    -   A calibration sample in order to do 3D reconstruction can be found at
+        opencv_source_code/samples/cpp/build3dmodel.cpp
+    -   A calibration example on stereo calibration can be found at
+        opencv_source_code/samples/cpp/stereo_calib.cpp
+    -   A calibration example on stereo matching can be found at
+        opencv_source_code/samples/cpp/stereo_match.cpp
+    -   (Python) A camera calibration sample can be found at
+        opencv_source_code/samples/python/calibrate.py
+
+  @{
+    @defgroup calib3d_fisheye Fisheye camera model
+
+    Definitions: Let P be a point in 3D of coordinates X in the world reference frame (stored in the
+    matrix X) The coordinate vector of P in the camera reference frame is:
+
+    \f[Xc = R X + T\f]
+
+    where R is the rotation matrix corresponding to the rotation vector om: R = rodrigues(om); call x, y
+    and z the 3 coordinates of Xc:
+
+    \f[\begin{array}{l} x = Xc_1 \\ y = Xc_2 \\ z = Xc_3 \end{array} \f]
+
+    The pinhole projection coordinates of P is [a; b] where
+
+    \f[\begin{array}{l} a = x / z \ and \ b = y / z \\ r^2 = a^2 + b^2 \\ \theta = atan(r) \end{array} \f]
+
+    Fisheye distortion:
+
+    \f[\theta_d = \theta (1 + k_1 \theta^2 + k_2 \theta^4 + k_3 \theta^6 + k_4 \theta^8)\f]
+
+    The distorted point coordinates are [x'; y'] where
+
+    \f[\begin{array}{l} x' = (\theta_d / r) a \\ y' = (\theta_d / r) b \end{array} \f]
+
+    Finally, conversion into pixel coordinates: The final pixel coordinates vector [u; v] where:
+
+    \f[\begin{array}{l} u = f_x (x' + \alpha y') + c_x \\
+    v = f_y y' + c_y \end{array} \f]
+
+    Summary:
+    Generic camera model @cite Kannala2006 with perspective projection and without distortion correction
+
+  @}
+ */
+
+namespace cv {
+
+//! @addtogroup calib
+//! @{
+
+#define CALIB_NINTRINSIC 18 //!< Maximal size of camera internal parameters (initrinsics) vector
+
+enum CameraModel {
+    CALIB_MODEL_PINHOLE = 0, //!< Pinhole camera model
+    CALIB_MODEL_FISHEYE = 1, //!< Fisheye camera model
+};
+
+enum { CALIB_USE_INTRINSIC_GUESS = 0x00001, //!< Use user provided intrinsics as initial point for optimization.
+       CALIB_FIX_ASPECT_RATIO    = 0x00002, //!< Use with CALIB_USE_INTRINSIC_GUESS. The ratio fx/fy stays the same as in the input cameraMatrix.
+       CALIB_FIX_PRINCIPAL_POINT = 0x00004, //!< The principal point (cx, cy) stays the same as in the input camera matrix. Image center is used as principal point, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_ZERO_TANGENT_DIST   = 0x00008, //!< For pinhole model only. Tangential distortion coefficients \f$(p_1, p_2)\f$ are set to zeros and stay zero.
+       CALIB_FIX_FOCAL_LENGTH    = 0x00010, //!< Use with CALIB_USE_INTRINSIC_GUESS. The focal length (fx, fy) stays the same as in the input cameraMatrix.
+       CALIB_FIX_K1              = 0x00020, //!< The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_FIX_K2              = 0x00040, //!< The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_FIX_K3              = 0x00080, //!< The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_FIX_K4              = 0x00800, //!< The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_FIX_K5              = 0x01000, //!< For pinhole model only. The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_FIX_K6              = 0x02000, //!< For pinhole model only. The corresponding distortion coefficient is not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_RATIONAL_MODEL      = 0x04000, //!< For pinhole model only. Use rational distortion model with coefficients k4..k6.
+       CALIB_THIN_PRISM_MODEL    = 0x08000, //!< For pinhole model only. Use thin prism distortion model with coefficients s1..s4.
+       CALIB_FIX_S1_S2_S3_S4     = 0x10000, //!< For pinhole model only. The thin prism distortion coefficients are not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_TILTED_MODEL        = 0x40000, //!< For pinhole model only. Coefficients tauX and tauY are enabled in camera matrix.
+       CALIB_FIX_TAUX_TAUY       = 0x80000, //!< For pinhole model only. The tauX and tauY coefficients are not changed during the optimization. 0 value is used, if CALIB_USE_INTRINSIC_GUESS is not set.
+       CALIB_USE_QR              = 0x100000, //!< Use QR instead of SVD decomposition for solving. Faster but potentially less precise
+       CALIB_FIX_TANGENT_DIST    = 0x200000, //!< For pinhole model only. Tangential distortion coefficients (p1,p2) are set to zeros and stay zero.
+       // only for stereo
+       CALIB_FIX_INTRINSIC       = 0x00100, //!< For stereo and milti-camera calibration only. Do not optimize cameras intrinsics
+       CALIB_SAME_FOCAL_LENGTH   = 0x00200, //!< For stereo calibration only. Use the same focal length for cameras in pair.
+       // for stereo rectification
+       CALIB_ZERO_DISPARITY      = 0x00400, //!< Deprecated synonim of @ref STEREO_ZERO_DISPARITY. See @ref stereoRectify.
+       CALIB_USE_LU              = (1 << 17), //!< use LU instead of SVD decomposition for solving. much faster but potentially less precise
+       CALIB_DISABLE_SCHUR_COMPLEMENT = (1 << 18),  //!< disable Schur complement (use Bouguet calibration engine)
+       CALIB_USE_EXTRINSIC_GUESS = (1 << 22), //!< For stereo and multi-view calibration. Use user provided extrinsics (R, T) as initial point for optimization
+       // fisheye only flags
+       CALIB_RECOMPUTE_EXTRINSIC = (1 << 23), //!< For fisheye model only. Recompute board position on each calibration iteration
+       CALIB_CHECK_COND          = (1 << 24), //!< For fisheye model only. Check SVD decomposition quality for each frame during extrinsics estimation
+       CALIB_FIX_SKEW            = (1 << 25), //!< For fisheye model only. Skew coefficient (alpha) is set to zero and stay zero.
+       CALIB_STEREO_REGISTRATION = (1 << 26)  //!< For multiview calibration only. Use stereo correspondence approach for initial extrinsics guess. Limitation: all cameras should have the same type.
+     };
+
+enum HandEyeCalibrationMethod
+{
+    CALIB_HAND_EYE_TSAI         = 0, //!< A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration @cite Tsai89
+    CALIB_HAND_EYE_PARK         = 1, //!< Robot Sensor Calibration: Solving AX = XB on the Euclidean Group @cite Park94
+    CALIB_HAND_EYE_HORAUD       = 2, //!< Hand-eye Calibration @cite Horaud95
+    CALIB_HAND_EYE_ANDREFF      = 3, //!< On-line Hand-Eye Calibration @cite Andreff99
+    CALIB_HAND_EYE_DANIILIDIS   = 4  //!< Hand-Eye Calibration Using Dual Quaternions @cite Daniilidis98
+};
+
+enum RobotWorldHandEyeCalibrationMethod
+{
+    CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0, //!< Solving the robot-world/hand-eye calibration problem using the kronecker product @cite Shah2013SolvingTR
+    CALIB_ROBOT_WORLD_HAND_EYE_LI   = 1  //!< Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product @cite Li2010SimultaneousRA
+};
+
+/** @brief Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
+
+@param objectPoints Vector of vectors of the calibration pattern points in the calibration pattern
+coordinate space. In the old interface all the per-view vectors are concatenated. See
+#calibrateCamera for details.
+@param imagePoints Vector of vectors of the projections of the calibration pattern points. In the
+old interface all the per-view vectors are concatenated.
+@param imageSize Image size in pixels used to initialize the principal point.
+@param aspectRatio If it is zero or negative, both \f$f_x\f$ and \f$f_y\f$ are estimated independently.
+Otherwise, \f$f_x = f_y \cdot \texttt{aspectRatio}\f$ .
+
+The function estimates and returns an initial camera intrinsic matrix for the camera calibration process.
+Currently, the function only supports planar calibration patterns, which are patterns where each
+object point has z-coordinate =0.
+ */
+CV_EXPORTS_W Mat initCameraMatrix2D( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints,
+                                     Size imageSize, double aspectRatio = 1.0 );
+
+/** @brief Finds the camera intrinsic and extrinsic parameters from several views of a calibration
+pattern.
+
+@param objectPoints In the new interface it is a vector of vectors of calibration pattern points in
+the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer
+vector contains as many elements as the number of pattern views. If the same calibration pattern
+is shown in each view and it is fully visible, all the vectors will be the same. Although, it is
+possible to use partially occluded patterns or even different patterns in different views. Then,
+the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's
+XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig.
+In the old interface all the vectors of object points from different views are concatenated
+together.
+@param imagePoints In the new interface it is a vector of vectors of the projections of calibration
+pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and
+objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal,
+respectively. In the old interface all the vectors of object points from different views are
+concatenated together.
+@param imageSize Size of the image used only to initialize the camera intrinsic matrix.
+@param cameraMatrix Input/output 3x3 floating-point camera intrinsic matrix
+\f$\cameramatrix{A}\f$ . If @ref CALIB_USE_INTRINSIC_GUESS
+and/or @ref CALIB_FIX_ASPECT_RATIO, @ref CALIB_FIX_PRINCIPAL_POINT or @ref CALIB_FIX_FOCAL_LENGTH
+are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.
+@param distCoeffs Input/output vector of distortion coefficients
+\f$\distcoeffs\f$.
+@param rvecs Output vector of rotation vectors (@ref Rodrigues ) estimated for each pattern view
+(e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding
+i-th translation vector (see the next output parameter description) brings the calibration pattern
+from the object coordinate space (in which object points are specified) to the camera coordinate
+space. In more technical terms, the tuple of the i-th rotation and translation vector performs
+a change of basis from object coordinate space to camera coordinate space. Due to its duality, this
+tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate
+space.
+@param tvecs Output vector of translation vectors estimated for each pattern view, see parameter
+description above.
+@param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic
+parameters. Order of deviations values:
+\f$(f_x, f_y, c_x, c_y, 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)\f$ If one of parameters is not estimated, it's deviation is equals to zero.
+@param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic
+parameters. Order of deviations values: \f$(R_0, T_0, \dotsc , R_{M - 1}, T_{M - 1})\f$ where M is
+the number of pattern views. \f$R_i, T_i\f$ are concatenated 1x3 vectors.
+ @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
+@param flags Different flags that may be zero or a combination of the following values:
+-   @ref CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of
+fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
+center ( imageSize is used), and focal distances are computed in a least-squares fashion.
+Note, that if intrinsic parameters are known, there is no need to use this function just to
+estimate extrinsic parameters. Use @ref solvePnP instead.
+-   @ref CALIB_DISABLE_SCHUR_COMPLEMENT Disable Schur complement and use the Bouguet calibration engine (@cite Zhang2000, @cite BouguetMCT).
+-   @ref CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global
+optimization. It stays at the center or at a different location specified when
+ @ref CALIB_USE_INTRINSIC_GUESS is set too.
+-   @ref CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The
+ratio fx/fy stays the same as in the input cameraMatrix . When
+ @ref CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are
+ignored, only their ratio is computed and used further.
+-   @ref CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients \f$(p_1, p_2)\f$ are set
+to zeros and stay zero.
+-   @ref CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if
+ @ref CALIB_USE_INTRINSIC_GUESS is set.
+-   @ref CALIB_FIX_K1,..., @ref CALIB_FIX_K6 The corresponding radial distortion
+coefficient is not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is
+set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+-   @ref CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the
+backward compatibility, this extra flag should be explicitly specified to make the
+calibration function use the rational model and return 8 coefficients or more.
+-   @ref CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
+backward compatibility, this extra flag should be explicitly specified to make the
+calibration function use the thin prism model and return 12 coefficients or more.
+-   @ref CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
+the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
+supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+-   @ref CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
+backward compatibility, this extra flag should be explicitly specified to make the
+calibration function use the tilted sensor model and return 14 coefficients.
+-   @ref CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
+the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
+supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+@param criteria Termination criteria for the iterative optimization algorithm.
+
+@return the overall RMS re-projection error.
+
+The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
+views. By default, the optimization follows a sparse bundle adjustment formulation with Schur
+complement; see @cite Triggs2000_bundle_adjustment and @cite Lourakis2009_sba for background. Use
+@ref CALIB_DISABLE_SCHUR_COMPLEMENT to switch to the Bouguet calibration engine. The coordinates of 3D object
+points and their corresponding 2D projections in each view must be specified. That may be achieved
+by using an object with known geometry and easily detectable feature points. Such an object is
+called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as
+a calibration rig (see @ref findChessboardCorners). Currently, initialization of intrinsic
+parameters (when @ref CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration
+patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also
+be used as long as initial cameraMatrix is provided.
+
+The algorithm performs the following steps:
+
+-   Compute the initial intrinsic parameters (the option only available for planar calibration
+    patterns) or read them from the input parameters. The distortion coefficients are all set to
+    zeros initially unless some of CALIB_FIX_K? are specified.
+
+-   Estimate the initial camera pose as if the intrinsic parameters have been already known. This is
+    done using @ref solvePnP .
+
+-   Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error,
+    that is, the total sum of squared distances between the observed feature points imagePoints and
+    the projected (using the current estimates for camera parameters and the poses) object points
+    objectPoints. See @ref projectPoints for details.
+
+-   In practice, robust acquisition is essential for stable results: use multiple board poses with
+    significant tilt, avoid collecting all views at a single working distance, span the expected
+    working-distance range (a larger board with larger squares can help for longer distances).
+
+@note
+    If you use a non-square (i.e. non-N-by-N) grid and @ref findChessboardCorners for calibration,
+    and @ref calibrateCamera returns bad values (zero distortion coefficients, \f$c_x\f$ and
+    \f$c_y\f$ very far from the image center, and/or large differences between \f$f_x\f$ and
+    \f$f_y\f$ (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols)
+    instead of using patternSize=cvSize(cols,rows) in @ref findChessboardCorners.
+
+@note
+    The function may throw exceptions, if unsupported combination of parameters is provided or
+    the system is underconstrained.
+
+@sa
+   calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate,
+   undistort
+ */
+CV_EXPORTS_AS(calibrateCameraExtended) double calibrateCamera( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints, Size imageSize,
+                                     InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     OutputArray stdDeviationsIntrinsics,
+                                     OutputArray stdDeviationsExtrinsics,
+                                     OutputArray perViewErrors,
+                                     int flags = 0, TermCriteria criteria = TermCriteria(
+                                        TermCriteria::COUNT + TermCriteria::EPS, 500, DBL_EPSILON) );
+
+/** @overload */
+CV_EXPORTS_W double calibrateCamera( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints, Size imageSize,
+                                     InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     int flags = 0, TermCriteria criteria = TermCriteria(
+                                        TermCriteria::COUNT + TermCriteria::EPS, 500, DBL_EPSILON) );
+
+/** @brief Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
+
+This function is an extension of #calibrateCamera with the method of releasing object which was
+proposed in @cite strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar
+targets (calibration plates), this method can dramatically improve the precision of the estimated
+camera parameters. Both the object-releasing method and standard method are supported by this
+function. Use the parameter **iFixedPoint** for method selection. In the internal implementation,
+#calibrateCamera is a wrapper for this function.
+
+@param objectPoints Vector of vectors of calibration pattern points in the calibration pattern
+coordinate space. See #calibrateCamera for details. If the method of releasing object to be used,
+the identical calibration board must be used in each view and it must be fully visible, and all
+objectPoints[i] must be the same and all points should be roughly close to a plane. **The calibration
+target has to be rigid, or at least static if the camera (rather than the calibration target) is
+shifted for grabbing images.**
+@param imagePoints Vector of vectors of the projections of calibration pattern points. See
+#calibrateCamera for details.
+@param imageSize Size of the image used only to initialize the intrinsic camera matrix.
+@param iFixedPoint The index of the 3D object point in objectPoints[0] to be fixed. It also acts as
+a switch for calibration method selection. If object-releasing method to be used, pass in the
+parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will
+make standard calibration method selected. Usually the top-right corner point of the calibration
+board grid is recommended to be fixed when object-releasing method being utilized. According to
+\cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front
+and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and
+newObjPoints are only possible if coordinates of these three fixed points are accurate enough.
+@param cameraMatrix Output 3x3 floating-point camera matrix. See #calibrateCamera for details.
+@param distCoeffs Output vector of distortion coefficients. See #calibrateCamera for details.
+@param rvecs Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera
+for details.
+@param tvecs Output vector of translation vectors estimated for each pattern view.
+@param newObjPoints The updated output vector of calibration pattern points. The coordinates might
+be scaled based on three fixed points. The returned coordinates are accurate only if the above
+mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter
+is ignored with standard calibration method.
+@param stdDeviationsIntrinsics Output vector of standard deviations estimated for intrinsic parameters.
+See #calibrateCamera for details.
+@param stdDeviationsExtrinsics Output vector of standard deviations estimated for extrinsic parameters.
+See #calibrateCamera for details.
+@param stdDeviationsObjPoints Output vector of standard deviations estimated for refined coordinates
+of calibration pattern points. It has the same size and order as objectPoints[0] vector. This
+parameter is ignored with standard calibration method.
+ @param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
+@param flags Different flags that may be zero or a combination of some predefined values. See
+#calibrateCamera for details. If the method of releasing object is used, the calibration time may
+be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially
+less precise and less stable in some rare cases.
+@param criteria Termination criteria for the iterative optimization algorithm.
+
+@return the overall RMS re-projection error.
+
+The function estimates the intrinsic camera parameters and extrinsic parameters for each of the
+views. The object-releasing extension follows @cite strobl2011iccv and uses the same optimization
+core as #calibrateCamera. See #calibrateCamera for other detailed explanations.
+@sa
+   calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort
+ */
+CV_EXPORTS_AS(calibrateCameraROExtended) double calibrateCameraRO( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint,
+                                     InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     OutputArray newObjPoints,
+                                     OutputArray stdDeviationsIntrinsics,
+                                     OutputArray stdDeviationsExtrinsics,
+                                     OutputArray stdDeviationsObjPoints,
+                                     OutputArray perViewErrors,
+                                     int flags = 0, TermCriteria criteria = TermCriteria(
+                                        TermCriteria::COUNT + TermCriteria::EPS, 500, DBL_EPSILON) );
+
+/** @overload */
+CV_EXPORTS_W double calibrateCameraRO( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint,
+                                     InputOutputArray cameraMatrix, InputOutputArray distCoeffs,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     OutputArray newObjPoints,
+                                     int flags = 0, TermCriteria criteria = TermCriteria(
+                                        TermCriteria::COUNT + TermCriteria::EPS, 500, DBL_EPSILON) );
+
+/** @brief Calibrates a stereo camera set up. This function finds the intrinsic parameters
+for each of the two cameras and the extrinsic parameters between the two cameras.
+
+@param objectPoints Vector of vectors of the calibration pattern points. The same structure as
+in @ref calibrateCamera. For each pattern view, both cameras need to see the same object
+points. Therefore, objectPoints.size(), imagePoints1.size(), and imagePoints2.size() need to be
+equal as well as objectPoints[i].size(), imagePoints1[i].size(), and imagePoints2[i].size() need to
+be equal for each i.
+@param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
+observed by the first camera. The same structure as in @ref calibrateCamera.
+@param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
+observed by the second camera. The same structure as in @ref calibrateCamera.
+@param cameraMatrix1 Input/output camera intrinsic matrix for the first camera, the same as in
+@ref calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
+@param distCoeffs1 Input/output vector of distortion coefficients, the same as in
+@ref calibrateCamera.
+@param cameraMatrix2 Input/output second camera intrinsic matrix for the second camera. See description for
+cameraMatrix1.
+@param distCoeffs2 Input/output lens distortion coefficients for the second camera. See
+description for distCoeffs1.
+@param imageSize Size of the image used only to initialize the camera intrinsic matrices.
+@param R Output rotation matrix. Together with the translation vector T, this matrix brings
+points given in the first camera's coordinate system to points in the second camera's
+coordinate system. In more technical terms, the tuple of R and T performs a change of basis
+from the first camera's coordinate system to the second camera's coordinate system. Due to its
+duality, this tuple is equivalent to the position of the first camera with respect to the
+second camera coordinate system.
+@param T Output translation vector, see description above.
+@param E Output essential matrix.
+@param F Output fundamental matrix.
+@param rvecs Output vector of rotation vectors ( @ref Rodrigues ) estimated for each pattern view in the
+coordinate system of the first camera of the stereo pair (e.g. std::vector<cv::Mat>). More in detail, each
+i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter
+description) brings the calibration pattern from the object coordinate space (in which object points are
+specified) to the camera coordinate space of the first camera of the stereo pair. In more technical terms,
+the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space
+to camera coordinate space of the first camera of the stereo pair.
+@param tvecs Output vector of translation vectors estimated for each pattern view, see parameter description
+of previous output parameter ( rvecs ).
+@param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
+@param flags Different flags that may be zero or a combination of the following values:
+-   @ref CALIB_FIX_INTRINSIC Fix cameraMatrix? and distCoeffs? so that only R, T, E, and F
+matrices are estimated.
+-   @ref CALIB_USE_INTRINSIC_GUESS Optimize some or all of the intrinsic parameters
+according to the specified flags. Initial values are provided by the user.
+-   @ref CALIB_USE_EXTRINSIC_GUESS R and T contain valid initial values that are optimized further.
+Otherwise R and T are initialized to the median value of the pattern views (each dimension separately).
+-   @ref CALIB_FIX_PRINCIPAL_POINT Fix the principal points during the optimization.
+-   @ref CALIB_FIX_FOCAL_LENGTH Fix \f$f^{(j)}_x\f$ and \f$f^{(j)}_y\f$ .
+-   @ref CALIB_FIX_ASPECT_RATIO Optimize \f$f^{(j)}_y\f$ . Fix the ratio \f$f^{(j)}_x/f^{(j)}_y\f$
+.
+-   @ref CALIB_SAME_FOCAL_LENGTH Enforce \f$f^{(0)}_x=f^{(1)}_x\f$ and \f$f^{(0)}_y=f^{(1)}_y\f$ .
+-   @ref CALIB_ZERO_TANGENT_DIST Set tangential distortion coefficients for each camera to
+zeros and fix there.
+-   @ref CALIB_FIX_K1,..., @ref CALIB_FIX_K6 Do not change the corresponding radial
+distortion coefficient during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set,
+the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+-   @ref CALIB_RATIONAL_MODEL Enable coefficients k4, k5, and k6. To provide the backward
+compatibility, this extra flag should be explicitly specified to make the calibration
+function use the rational model and return 8 coefficients. If the flag is not set, the
+function computes and returns only 5 distortion coefficients.
+-   @ref CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the
+backward compatibility, this extra flag should be explicitly specified to make the
+calibration function use the thin prism model and return 12 coefficients. If the flag is not
+set, the function computes and returns only 5 distortion coefficients.
+-   @ref CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during
+the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
+supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+-   @ref CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the
+backward compatibility, this extra flag should be explicitly specified to make the
+calibration function use the tilted sensor model and return 14 coefficients. If the flag is not
+set, the function computes and returns only 5 distortion coefficients.
+-   @ref CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during
+the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the
+supplied distCoeffs matrix is used. Otherwise, it is set to 0.
+@param criteria Termination criteria for the iterative optimization algorithm.
+
+The function estimates the transformation between two cameras making a stereo pair. If one computes
+the poses of an object relative to the first camera and to the second camera,
+( \f$R_1\f$,\f$T_1\f$ ) and (\f$R_2\f$,\f$T_2\f$), respectively, for a stereo camera where the
+relative position and orientation between the two cameras are fixed, then those poses definitely
+relate to each other. This means, if the relative position and orientation (\f$R\f$,\f$T\f$) of the
+two cameras is known, it is possible to compute (\f$R_2\f$,\f$T_2\f$) when (\f$R_1\f$,\f$T_1\f$) is
+given. This is what the described function does. It computes (\f$R\f$,\f$T\f$) such that:
+
+\f[R_2=R R_1\f]
+\f[T_2=R T_1 + T.\f]
+
+Therefore, one can compute the coordinate representation of a 3D point for the second camera's
+coordinate system when given the point's coordinate representation in the first camera's coordinate
+system:
+
+\f[\begin{bmatrix}
+X_2 \\
+Y_2 \\
+Z_2 \\
+1
+\end{bmatrix} = \begin{bmatrix}
+R & T \\
+0 & 1
+\end{bmatrix} \begin{bmatrix}
+X_1 \\
+Y_1 \\
+Z_1 \\
+1
+\end{bmatrix}.\f]
+
+
+Optionally, it computes the essential matrix E:
+
+\f[E= \vecthreethree{0}{-T_2}{T_1}{T_2}{0}{-T_0}{-T_1}{T_0}{0} R\f]
+
+where \f$T_i\f$ are components of the translation vector \f$T\f$ : \f$T=[T_0, T_1, T_2]^T\f$ .
+And the function can also compute the fundamental matrix F:
+
+\f[F = cameraMatrix2^{-T}\cdot E \cdot cameraMatrix1^{-1}\f]
+
+Besides the stereo-related information, the function can also perform a full calibration of each of
+the two cameras. However, due to the high dimensionality of the parameter space and noise in the
+input data, the function can diverge from the correct solution. If the intrinsic parameters can be
+estimated with high accuracy for each of the cameras individually (for example, using
+#calibrateCamera ), you are recommended to do so and then pass @ref CALIB_FIX_INTRINSIC flag to the
+function along with the computed intrinsic parameters. Otherwise, if all the parameters are
+estimated at once, it makes sense to restrict some parameters, for example, pass
+ @ref CALIB_SAME_FOCAL_LENGTH and @ref CALIB_ZERO_TANGENT_DIST flags, which is usually a
+reasonable assumption.
+
+Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
+points in all the available views from both cameras. The function returns the final value of the
+re-projection error.
+ */
+CV_EXPORTS_AS(stereoCalibrateExtended) double stereoCalibrate( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                     InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
+                                     InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
+                                     Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     OutputArray perViewErrors, int flags = CALIB_FIX_INTRINSIC,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) );
+
+/// @overload
+CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                     InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
+                                     InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
+                                     Size imageSize, OutputArray R,OutputArray T, OutputArray E, OutputArray F,
+                                     int flags = CALIB_FIX_INTRINSIC,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) );
+
+/// @overload
+CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,
+                                     InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                     InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1,
+                                     InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2,
+                                     Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F,
+                                     OutputArray perViewErrors, int flags = CALIB_FIX_INTRINSIC,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) );
+
+/** @brief Calibrates a camera pair set up. This function finds the extrinsic parameters between the two cameras.
+
+@param objectPoints1 Vector of vectors of the calibration pattern points for camera 1.
+A similar structure as objectPoints in @ref calibrateCamera and for each pattern view,
+both cameras do not need to see the same object points. objectPoints1.size(), imagePoints1.size()
+nees to be equal,as well as objectPoints1[i].size(), imagePoints1[i].size() need to be equal for each i.
+@param objectPoints2 Vector of vectors of the calibration pattern points for camera 2.
+A similar structure as objectPoints1. objectPoints2.size(), and imagePoints2.size() nees to be equal,
+as well as objectPoints2[i].size(), imagePoints2[i].size() need to be equal for each i.
+However, objectPoints1[i].size() and objectPoints2[i].size() are not required to be equal.
+@param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
+observed by the first camera. The same structure as in @ref calibrateCamera.
+@param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
+observed by the second camera. The same structure as in @ref calibrateCamera.
+@param cameraMatrix1 Input/output camera intrinsic matrix for the first camera, the same as in
+@ref calibrateCamera. Furthermore, for the stereo case, additional flags may be used, see below.
+@param distCoeffs1 Input/output vector of distortion coefficients, the same as in
+@ref calibrateCamera.
+@param cameraModel1 Flag reflecting the type of model for camera 1 (pinhole / fisheye):
+- @ref CALIB_MODEL_PINHOLE pinhole camera model
+- @ref CALIB_MODEL_FISHEYE fisheye camera model
+@param cameraMatrix2 Input/output second camera intrinsic matrix for the second camera.
+See description for cameraMatrix1.
+@param distCoeffs2 Input/output lens distortion coefficients for the second camera. See
+description for distCoeffs1.
+@param cameraModel2 Flag reflecting the type of model for camera 2 (pinhole / fisheye).
+See description for cameraModel1.
+@param R Output rotation matrix. Together with the translation vector T, this matrix brings
+points given in the first camera's coordinate system to points in the second camera's
+coordinate system. In more technical terms, the tuple of R and T performs a change of basis
+from the first camera's coordinate system to the second camera's coordinate system. Due to its
+duality, this tuple is equivalent to the position of the first camera with respect to the
+second camera coordinate system.
+@param T Output translation vector, see description above.
+@param E Output essential matrix.
+@param F Output fundamental matrix.
+@param rvecs Output vector of rotation vectors ( @ref Rodrigues ) estimated for each pattern view in the
+coordinate system of the first camera of the stereo pair (e.g. std::vector<cv::Mat>). More in detail, each
+i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter
+description) brings the calibration pattern from the object coordinate space (in which object points are
+specified) to the camera coordinate space of the first camera of the stereo pair. In more technical terms,
+the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space
+to the camera coordinate space of the first camera of the stereo pair.
+@param tvecs Output vector of translation vectors estimated for each pattern view, see parameter description
+of previous output parameter ( rvecs ).
+@param perViewErrors Output vector of the RMS re-projection error estimated for each pattern view.
+@param flags Different flags that may be zero or a combination of the following values:
+-   @ref CALIB_USE_EXTRINSIC_GUESS R and T contain valid initial values that are optimized further.
+@param criteria Termination criteria for the iterative optimization algorithm.
+
+The function estimates the transformation between two cameras similar to stereo pair calibration.
+The principle follows closely to @ref stereoCalibrate. To understand the problem of estimating the
+relative pose between a camera pair, please refer to the description there. The difference for
+this function is that, camera intrinsics are not optimized and two cameras are not required
+to have overlapping fields of view as long as they are observing the same calibration target
+and the absolute positions of each object point are known.
+![](pics/register_pair.png)
+The above illustration shows an example where such a case may become relevant.
+Additionally, it supports a camera pair with the mixed model (pinhole / fisheye).
+Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
+points in all the available views from both cameras.
+@return the final value of the re-projection error.
+
+@sa calibrateCamera, stereoCalibrate
+ */
+CV_EXPORTS_AS(registerCamerasExtended) double registerCameras( InputArrayOfArrays objectPoints1,
+                                     InputArrayOfArrays objectPoints2,
+                                     InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                     InputArray cameraMatrix1, InputArray distCoeffs1,
+                                     CameraModel cameraModel1,
+                                     InputArray cameraMatrix2, InputArray distCoeffs2,
+                                     CameraModel cameraModel2,
+                                     InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F,
+                                     OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                     OutputArray perViewErrors,
+                                     int flags = 0,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) );
+
+/// @overload
+CV_EXPORTS_W double registerCameras( InputArrayOfArrays objectPoints1,
+                                     InputArrayOfArrays objectPoints2,
+                                     InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                     InputArray cameraMatrix1, InputArray distCoeffs1,
+                                     CameraModel cameraModel1,
+                                     InputArray cameraMatrix2, InputArray distCoeffs2,
+                                     CameraModel cameraModel2,
+                                     InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F,
+                                     OutputArray perViewErrors,
+                                     int flags = 0,
+                                     TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 100, 1e-6) );
+
+/** @brief Estimates intrinsics and extrinsics (camera pose) for multi-camera system a.k.a multiview calibration.
+
+@param[in] objPoints Calibration pattern object points. Expected shape: NUM_FRAMES x NUM_POINTS x 3. Supported data type: CV_32F.
+@param[in] imagePoints Detected pattern points on camera images. Expected shape: NUM_CAMERAS x NUM_FRAMES x NUM_POINTS x 2.
+This function supports partial observation of the calibration pattern.
+To enable this, set the unobserved image points to be invalid points (eg. (-1., -1.)).
+@param[in] imageSize Images resolution array for each camera.
+@param[in] detectionMask Pattern detection mask. Each value defines if i-camera observes the calibration pattern in j-th frame.
+Expected size: NUM_CAMERAS x NUM_FRAMES. Expected type: CV_8U.
+@param[in] models indicates camera models for each camera: cv::CALIB_MODEL_PINHOLE or cv::CALIB_MODEL_PINHOLE.
+Current implementation does not support mix of different camera models. Expected type: CV_8U.
+@param[in] flagsForIntrinsics Flags used for each camera intrinsics calibration.
+Use per-camera call and the `useIntrinsicsGuess` flag to get custom intrinsics calibration for each camera.
+@param[in] flags Common multiview calibration flags. cv::CALIB_USE_INTRINSIC_GUESS and cv::CALIB_USE_EXTRINSIC_GUESS are supported.
+See @ref CALIB_USE_INTRINSIC_GUESS and other `CALIB_` constants. Expected shape: NUM_CAMERAS x 1. Supported data type: CV_32S.
+@param[out] Rs Rotation vectors relative to camera 0, where Rs[0] = 0. Output size: NUM_CAMERAS x 3 x 3.
+@param[out] Ts Estimated translation vectors relative to camera 0, where Ts[0] = 0. Output size: NUM_CAMERAS x 3 x 1.
+@param[out] rvecs0 Estimated rotation vectors for camera 0. Output size: NUM_FRAMES x 3 x 1 (may contain null Mat, if the frame is not valid). See @ref Rodrigues.
+@param[out] tvecs0 Translation vectors for camera 0. Output size: NUM_FRAMES x 3 x 1. (may contain null Mat, if the frame is not valid).
+@param[out] Ks Estimated floating-point camera intrinsic matrix. Output size: NUM_CAMERAS x 3 x 3.
+@param[out] distortions Distortion coefficients. Output size: NUM_CAMERAS x NUM_PARAMS.
+@param[out] perFrameErrors RMSE value for each visible frame, (-1 for non-visible). Output size: NUM_CAMERAS x NUM_FRAMES.
+@param[out] initializationPairs Pairs with camera indices that were used for initial pairwise stereo calibration.
+@param[in] criteria Termination criteria for the iterative optimization algorithm.
+
+Output size: (NUM_CAMERAS-1) x 2.
+
+@ref tutorial_multiview_camera_calibration provides a detailed tutorial of using this function. Please refer to it for more information.
+
+Multiview calibration usually requires several cameras to observe the same calibration pattern simultaneously.
+The fundamental assumption is that relative camera poses are fixed,
+and then for each frame, only the absolute camera pose for a single camera is needed to fix the camera pose for the multiple cameras
+
+![multiview calibration](pics/multiview_calib.png)
+The above illustration shows an example setting for multiview camera calibration.
+
+For each frame, suppose the absolute camera pose for camera \f$i\f$ is \f$R_i, t_i\f$,
+and the relative camera pose between camera \f$i\f$ and camera \f$j\f$ is \f$R_{ij}, t_{ij}\f$.
+Suppose \f$R_1, t_1\f$, and \f$R_{1i}\f$ for any \f$i\not=1\f$ are known, then its pose can be calculated by
+\f[ R_i = R_{1i} R_1\f]
+\f[ t_i = R_{1i} t_1 + t_{1i}\f]
+
+Since the relative pose between two cameras can be calculated by
+\f[ R_{ij} = R_j R_i^\top \f]
+\f[ t_{ij} = -R_{ij} t_i + R_j \f]
+
+This implies that any other relative pose of the form \f$R_{ij}, i\not=1\f$ is redundant.
+Given this, the total number of poses to determine is (NUM_CAMERAS-1) and NUM_FRAMES.
+This serves as the foundation of this function.
+
+Similarly to #calibrateCamera, the function minimizes the total re-projection error for all the
+points in all the available views from all cameras.
+
+@return Overall RMS re-projection error over detectionMask.
+
+@sa findChessboardCorners, findCirclesGrid, calibrateCamera, fisheye::calibrate, registerCameras
+*/
+
+CV_EXPORTS_AS(calibrateMultiviewExtended) double calibrateMultiview (
+        InputArrayOfArrays objPoints, const std::vector<std::vector<Mat>> &imagePoints,
+        const std::vector<cv::Size>& imageSize, InputArray detectionMask, InputArray models,
+        InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions,
+        InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts,
+        OutputArray initializationPairs, OutputArrayOfArrays rvecs0,
+        OutputArrayOfArrays tvecs0, OutputArray perFrameErrors,
+        InputArray flagsForIntrinsics=noArray(), int flags = 0,
+        TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
+
+/// @overload
+CV_EXPORTS_W double calibrateMultiview (
+        InputArrayOfArrays objPoints, const std::vector<std::vector<Mat>> &imagePoints,
+        const std::vector<cv::Size>& imageSize, InputArray detectionMask, InputArray models,
+        InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions,
+        InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts,
+        InputArray flagsForIntrinsics=noArray(), int flags = 0,
+        TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
+
+
+/** @brief Computes Hand-Eye calibration: \f$_{}^{g}\textrm{T}_c\f$
+
+@param[in] R_gripper2base Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$).
+This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
+for all the transformations from gripper frame to robot base frame.
+@param[in] t_gripper2base Translation part extracted from the homogeneous matrix that transforms a point
+expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$).
+This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
+from gripper frame to robot base frame.
+@param[in] R_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$).
+This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
+for all the transformations from calibration target frame to camera frame.
+@param[in] t_target2cam Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$).
+This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
+from calibration target frame to camera frame.
+@param[out] R_cam2gripper Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).
+@param[out] t_cam2gripper Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
+expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).
+@param[in] method One of the implemented Hand-Eye calibration method, see cv::HandEyeCalibrationMethod
+
+The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the
+rotation then the translation (separable solutions) and the following methods are implemented:
+  - R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
+  - F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
+  - R. Horaud, F. Dornaika Hand-Eye Calibration \cite Horaud95
+
+Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
+with the following implemented methods:
+  - N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration \cite Andreff99
+  - K. Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98
+
+The following picture describes the Hand-Eye calibration problem where the transformation between a camera ("eye")
+mounted on a robot gripper ("hand") has to be estimated. This configuration is called eye-in-hand.
+
+The eye-to-hand configuration consists in a static camera observing a calibration pattern mounted on the robot
+end-effector. The transformation from the camera to the robot base frame can then be estimated by inputting
+the suitable transformations to the function, see below.
+
+![](pics/hand-eye_figure.png)
+
+The calibration procedure is the following:
+  - a static calibration pattern is used to estimate the transformation between the target frame
+  and the camera frame
+  - the robot gripper is moved in order to acquire several poses
+  - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
+  instance the robot kinematics
+\f[
+    \begin{bmatrix}
+    X_b\\
+    Y_b\\
+    Z_b\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_g\\
+    Y_g\\
+    Z_g\\
+    1
+    \end{bmatrix}
+\f]
+  - for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using
+  for instance a pose estimation method (PnP) from 2D-3D point correspondences
+\f[
+    \begin{bmatrix}
+    X_c\\
+    Y_c\\
+    Z_c\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_t\\
+    Y_t\\
+    Z_t\\
+    1
+    \end{bmatrix}
+\f]
+
+The Hand-Eye calibration procedure returns the following homogeneous transformation
+\f[
+    \begin{bmatrix}
+    X_g\\
+    Y_g\\
+    Z_g\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_c\\
+    Y_c\\
+    Z_c\\
+    1
+    \end{bmatrix}
+\f]
+
+This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\f$ equation:
+  - for an eye-in-hand configuration
+\f[
+    \begin{align*}
+    ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
+    \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
+
+    (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &=
+    \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
+
+    \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
+    \end{align*}
+\f]
+
+  - for an eye-to-hand configuration
+\f[
+    \begin{align*}
+    ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &=
+    \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\
+
+    (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &=
+    \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\
+
+    \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\
+    \end{align*}
+\f]
+
+\note
+Additional information can be found on this [website](http://campar.in.tum.de/Chair/HandEyeCalibration).
+\note
+A minimum of 2 motions with non parallel rotation axes are necessary to determine the hand-eye transformation.
+So at least 3 different poses are required, but it is strongly recommended to use many more poses.
+
+ */
+CV_EXPORTS void calibrateHandEye( InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base,
+                                    InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam,
+                                    OutputArray R_cam2gripper, OutputArray t_cam2gripper,
+                                    HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI );
+
+/** @brief Computes Robot-World/Hand-Eye calibration: \f$_{}^{w}\textrm{T}_b\f$ and \f$_{}^{c}\textrm{T}_g\f$
+
+@param[in] R_world2cam Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$).
+This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
+for all the transformations from world frame to the camera frame.
+@param[in] t_world2cam Translation part extracted from the homogeneous matrix that transforms a point
+expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$).
+This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
+from world frame to the camera frame.
+@param[in] R_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$).
+This is a vector (`vector<Mat>`) that contains the rotation, `(3x3)` rotation matrices or `(3x1)` rotation vectors,
+for all the transformations from robot base frame to the gripper frame.
+@param[in] t_base2gripper Rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$).
+This is a vector (`vector<Mat>`) that contains the `(3x1)` translation vectors for all the transformations
+from robot base frame to the gripper frame.
+@param[out] R_base2world Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).
+@param[out] t_base2world Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
+expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).
+@param[out] R_gripper2cam Estimated `(3x3)` rotation part extracted from the homogeneous matrix that transforms a point
+expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).
+@param[out] t_gripper2cam Estimated `(3x1)` translation part extracted from the homogeneous matrix that transforms a point
+expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).
+@param[in] method One of the implemented Robot-World/Hand-Eye calibration method, see cv::RobotWorldHandEyeCalibrationMethod
+
+The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the
+rotation then the translation (separable solutions):
+  - M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR
+
+Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions),
+with the following implemented method:
+  - A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product \cite Li2010SimultaneousRA
+
+The following picture describes the Robot-World/Hand-Eye calibration problem where the transformations between a robot and a world frame
+and between a robot gripper ("hand") and a camera ("eye") mounted at the robot end-effector have to be estimated.
+
+![](pics/robot-world_hand-eye_figure.png)
+
+The calibration procedure is the following:
+  - a static calibration pattern is used to estimate the transformation between the target frame
+  and the camera frame
+  - the robot gripper is moved in order to acquire several poses
+  - for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for
+  instance the robot kinematics
+\f[
+    \begin{bmatrix}
+    X_g\\
+    Y_g\\
+    Z_g\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_b\\
+    Y_b\\
+    Z_b\\
+    1
+    \end{bmatrix}
+\f]
+  - for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using
+  for instance a pose estimation method (PnP) from 2D-3D point correspondences
+\f[
+    \begin{bmatrix}
+    X_c\\
+    Y_c\\
+    Z_c\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_w\\
+    Y_w\\
+    Z_w\\
+    1
+    \end{bmatrix}
+\f]
+
+The Robot-World/Hand-Eye calibration procedure returns the following homogeneous transformations
+\f[
+    \begin{bmatrix}
+    X_w\\
+    Y_w\\
+    Z_w\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_b\\
+    Y_b\\
+    Z_b\\
+    1
+    \end{bmatrix}
+\f]
+\f[
+    \begin{bmatrix}
+    X_c\\
+    Y_c\\
+    Z_c\\
+    1
+    \end{bmatrix}
+    =
+    \begin{bmatrix}
+    _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\
+    0_{1 \times 3} & 1
+    \end{bmatrix}
+    \begin{bmatrix}
+    X_g\\
+    Y_g\\
+    Z_g\\
+    1
+    \end{bmatrix}
+\f]
+
+This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\f$ equation, with:
+  - \f$\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\f$
+  - \f$\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\f$
+  - \f$\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\f$
+  - \f$\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\f$
+
+\note
+At least 3 measurements are required (input vectors size must be greater or equal to 3).
+
+ */
+CV_EXPORTS void calibrateRobotWorldHandEye( InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam,
+                                              InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper,
+                                              OutputArray R_base2world, OutputArray t_base2world,
+                                              OutputArray R_gripper2cam, OutputArray t_gripper2cam,
+                                              RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH );
+
+/** @brief The methods in this namespace use a so-called fisheye camera model.
+  @ingroup calib3d_fisheye
+*/
+namespace fisheye
+{
+//! @addtogroup calib3d_fisheye
+//! @{
+
+// For backward compatibility only!
+// Use unified Pinhole and Fisheye model calibration flags
+using cv::CALIB_USE_INTRINSIC_GUESS;
+using cv::CALIB_RECOMPUTE_EXTRINSIC;
+using cv::CALIB_CHECK_COND;
+using cv::CALIB_FIX_SKEW;
+using cv::CALIB_FIX_K1;
+using cv::CALIB_FIX_K2;
+using cv::CALIB_FIX_K3;
+using cv::CALIB_FIX_K4;
+using cv::CALIB_FIX_INTRINSIC;
+using cv::CALIB_FIX_PRINCIPAL_POINT;
+using cv::CALIB_ZERO_DISPARITY;
+using cv::CALIB_FIX_FOCAL_LENGTH;
+
+/** @brief Performs camera calibration
+
+@param objectPoints vector of vectors of calibration pattern points in the calibration pattern
+coordinate space.
+@param imagePoints vector of vectors of the projections of calibration pattern points.
+imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to
+objectPoints[i].size() for each i.
+@param image_size Size of the image used only to initialize the camera intrinsic matrix.
+@param K Output 3x3 floating-point camera intrinsic matrix
+\f$\cameramatrix{A}\f$ . If
+@ref cv::CALIB_USE_INTRINSIC_GUESS is specified, some or all of fx, fy, cx, cy must be
+initialized before calling the function.
+@param D Output vector of distortion coefficients \f$\distcoeffsfisheye\f$.
+@param rvecs Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view.
+That is, each k-th rotation vector together with the corresponding k-th translation vector (see
+the next output parameter description) brings the calibration pattern from the model coordinate
+space (in which object points are specified) to the world coordinate space, that is, a real
+position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).
+@param tvecs Output vector of translation vectors estimated for each pattern view.
+@param flags Different flags that may be zero or a combination of the following values:
+-   @ref cv::CALIB_USE_INTRINSIC_GUESS  cameraMatrix contains valid initial values of
+fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
+center ( imageSize is used), and focal distances are computed in a least-squares fashion.
+-   @ref cv::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
+of intrinsic optimization.
+-   @ref cv::CALIB_CHECK_COND  The functions will check validity of condition number.
+-   @ref cv::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
+-   @ref cv::CALIB_FIX_K1,..., @ref cv::CALIB_FIX_K4 Selected distortion coefficients
+are set to zeros and stay zero.
+-   @ref cv::CALIB_FIX_PRINCIPAL_POINT  The principal point is not changed during the global
+optimization. It stays at the center or at a different location specified when @ref cv::CALIB_USE_INTRINSIC_GUESS is set too.
+-   @ref cv::CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global
+optimization. It is the \f$max(width,height)/\pi\f$ or the provided \f$f_x\f$, \f$f_y\f$ when @ref cv::CALIB_USE_INTRINSIC_GUESS is set too.
+@param criteria Termination criteria for the iterative optimization algorithm.
+ */
+CV_EXPORTS_W double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
+    InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags = 0,
+        TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
+
+/** @brief Performs stereo calibration
+
+@param objectPoints Vector of vectors of the calibration pattern points.
+@param imagePoints1 Vector of vectors of the projections of the calibration pattern points,
+observed by the first camera.
+@param imagePoints2 Vector of vectors of the projections of the calibration pattern points,
+observed by the second camera.
+@param K1 Input/output first camera intrinsic matrix:
+\f$\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}\f$ , \f$j = 0,\, 1\f$ . If
+any of @ref cv::CALIB_USE_INTRINSIC_GUESS , @ref cv::CALIB_FIX_INTRINSIC are specified,
+some or all of the matrix components must be initialized.
+@param D1 Input/output vector of distortion coefficients \f$\distcoeffsfisheye\f$ of 4 elements.
+@param K2 Input/output second camera intrinsic matrix. The parameter is similar to K1 .
+@param D2 Input/output lens distortion coefficients for the second camera. The parameter is
+similar to D1 .
+@param imageSize Size of the image used only to initialize camera intrinsic matrix.
+@param R Output rotation matrix between the 1st and the 2nd camera coordinate systems.
+@param T Output translation vector between the coordinate systems of the cameras.
+@param rvecs Output vector of rotation vectors ( @ref Rodrigues ) estimated for each pattern view in the
+coordinate system of the first camera of the stereo pair (e.g. std::vector<cv::Mat>). More in detail, each
+i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter
+description) brings the calibration pattern from the object coordinate space (in which object points are
+specified) to the camera coordinate space of the first camera of the stereo pair. In more technical terms,
+the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space
+to camera coordinate space of the first camera of the stereo pair.
+@param tvecs Output vector of translation vectors estimated for each pattern view, see parameter description
+of previous output parameter ( rvecs ).
+@param flags Different flags that may be zero or a combination of the following values:
+-   @ref cv::CALIB_FIX_INTRINSIC  Fix K1, K2? and D1, D2? so that only R, T matrices
+are estimated.
+-   @ref cv::CALIB_USE_INTRINSIC_GUESS  K1, K2 contains valid initial values of
+fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image
+center (imageSize is used), and focal distances are computed in a least-squares fashion.
+-   @ref cv::CALIB_RECOMPUTE_EXTRINSIC  Extrinsic will be recomputed after each iteration
+of intrinsic optimization.
+-   @ref cv::CALIB_CHECK_COND  The functions will check validity of condition number.
+-   @ref cv::CALIB_FIX_SKEW  Skew coefficient (alpha) is set to zero and stay zero.
+-   @ref cv::CALIB_FIX_K1,..., @ref cv::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay
+zero.
+@param criteria Termination criteria for the iterative optimization algorithm.
+ */
+CV_EXPORTS_W double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                    InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
+                                    OutputArray R, OutputArray T, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags = CALIB_FIX_INTRINSIC,
+                                    TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
+
+/// @overload
+CV_EXPORTS_W double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                    InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
+                                    OutputArray R, OutputArray T, int flags = CALIB_FIX_INTRINSIC,
+                                    TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));
+
+//! @} calib3d_fisheye
+} //end namespace fisheye
+} //end namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/calib/include/opencv2/calib3d.hpp b/upstream/opencv/modules/calib/include/opencv2/calib3d.hpp
new file mode 100644
index 0000000..5ee2c31
--- /dev/null
+++ b/upstream/opencv/modules/calib/include/opencv2/calib3d.hpp
@@ -0,0 +1,14 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// this is the header for backward compatibility with OpenCV 4.x and earlier versions
+
+#ifndef OPENCV_CALIB3D_HPP
+#define OPENCV_CALIB3D_HPP
+
+#include "opencv2/geometry.hpp"
+#include "opencv2/stereo.hpp"
+#include "opencv2/calib.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/calib/include/opencv2/calib3d/calib3d.hpp b/upstream/opencv/modules/calib/include/opencv2/calib3d/calib3d.hpp
new file mode 100644
index 0000000..d68ea19
--- /dev/null
+++ b/upstream/opencv/modules/calib/include/opencv2/calib3d/calib3d.hpp
@@ -0,0 +1,12 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// this is the header for backward compatibility with OpenCV 4.x and earlier versions
+
+#ifndef OPENCV_CALIB3D_CALIB3D_HPP
+#define OPENCV_CALIB3D_CALIB3D_HPP
+
+#include "opencv2/calib3d.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/calib/src/calibration.cpp b/upstream/opencv/modules/calib/src/calibration.cpp
new file mode 100644
index 0000000..034581c
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/calibration.cpp
@@ -0,0 +1,3354 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "distortion_model.hpp"
+#include <stdio.h>
+#include <iterator>
+#include <iostream>
+
+/*
+    This program implements Levenberg-Marquardt optimization using Schur complement to calibrate cameras.
+    It implements many speedups over the original implemntation.
+    The techniques used here are primarily based upon the following papers:
+    [1] "Bundle Adjustment -- A Modern Synthesis", Triggs et al., 1999
+    [2] "SBA: A Software Package for Generic Sparse Bundle Adjustment", Lourakis and Argyros, 2000
+*/
+
+namespace {
+
+class SchurLMSolver
+{
+public:
+    enum State { STARTED, CALC_J, CHECK_ERR, DONE };
+
+    SchurLMSolver()
+        : currentError(0)
+        , state(STARTED)
+        , NINTRINSIC(18)
+        , nimages(0)
+        , n_global(0)
+        , lambdaLg10(-3)
+        , iters(0)
+        , prevErrNorm(DBL_MAX)
+        , solveMethod(cv::DECOMP_EIG)
+    {
+    }
+
+    void init(int _nimages, int _NINTRINSIC, int nObjPoints,
+              cv::TermCriteria _criteria)
+    {
+        nimages = _nimages;
+        NINTRINSIC = _NINTRINSIC;
+        n_global = NINTRINSIC + nObjPoints * 3;
+        criteria = _criteria;
+
+        U.create(n_global, n_global, CV_64F);
+        ea.create(n_global, 1, CV_64F);
+        deltaGlobal.create(n_global, 1, CV_64F);
+
+        V.resize(nimages);
+        V_inv.resize(nimages);
+        W.resize(nimages);
+        eb.resize(nimages);
+        deltaLocal.resize(nimages);
+
+        for (int i = 0; i < nimages; i++)
+        {
+            V[i].create(6, 6, CV_64F);
+            V_inv[i].create(6, 6, CV_64F);
+            W[i].create(n_global, 6, CV_64F);
+            eb[i].create(6, 1, CV_64F);
+            deltaLocal[i].create(6, 1, CV_64F);
+        }
+
+        state = STARTED;
+        iters = 0;
+        lambdaLg10 = -3;
+        prevErrNorm = DBL_MAX;
+        solveMethod = cv::DECOMP_EIG;
+    }
+
+    void reset()
+    {
+        U.setTo(0);
+        ea.setTo(0);
+        currentError = 0;
+        for (int i = 0; i < nimages; i++)
+        {
+            V[i].setTo(0);
+            W[i].setTo(0);
+            eb[i].setTo(0);
+        }
+    }
+
+    bool step(const cv::Mat& mask)
+    {
+        const double LOG10 = std::log(10.0);
+        double lambda = std::exp(lambdaLg10 * LOG10);
+
+        // Invert V[i] blocks with regularization
+        for (int i = 0; i < nimages; i++)
+        {
+            cv::Mat V_reg = V[i].clone();
+            V_reg.diag() *= (1.0 + lambda);
+            if (solveMethod == cv::DECOMP_QR)
+            {
+                cv::Mat I = cv::Mat::eye(6, 6, CV_64F);
+                if (!cv::solve(V_reg, I, V_inv[i], solveMethod) ||
+                    !cv::checkRange(V_inv[i]))
+                {
+                    clearUpdates();
+                    return false;
+                }
+            }
+            else
+            {
+                if (cv::invert(V_reg, V_inv[i], solveMethod) == 0.0 ||
+                    !cv::checkRange(V_inv[i]))
+                {
+                    clearUpdates();
+                    return false;
+                }
+            }
+        }
+
+        // Form Schur complement S and reduced RHS e
+        cv::Mat S = U.clone();
+        S.diag() *= (1.0 + lambda);
+        cv::Mat e = ea.clone();
+
+        for (int i = 0; i < nimages; i++)
+        {
+            cv::Mat WtVinv = W[i] * V_inv[i];
+            S -= WtVinv * W[i].t();
+            e -= WtVinv * eb[i];
+        }
+
+        // Extract active submatrix using mask
+        std::vector<uchar> mask_global(n_global);
+        const uchar* mask_ptr = mask.ptr<uchar>();
+        std::copy(mask_ptr, mask_ptr + NINTRINSIC, mask_global.begin());
+        if (n_global > NINTRINSIC)
+        {
+            // Object points parameters follow intrinsic parameters in the global update vector
+            std::copy(mask_ptr + NINTRINSIC + nimages * 6,
+                      mask_ptr + NINTRINSIC + nimages * 6 + (n_global - NINTRINSIC),
+                      mask_global.begin() + NINTRINSIC);
+        }
+
+        int nactive = 0;
+        for (int i = 0; i < n_global; i++)
+            if (mask_global[i]) nactive++;
+
+        if (nactive == 0)
+        {
+            clearUpdates();
+            return true;
+        }
+
+        cv::Mat S_sub(nactive, nactive, CV_64F);
+        cv::Mat e_sub(nactive, 1, CV_64F);
+
+        int ii = 0;
+        for (int i = 0; i < n_global; i++)
+        {
+            if (!mask_global[i]) continue;
+            e_sub.at<double>(ii) = e.at<double>(i);
+            int jj = 0;
+            for (int j = 0; j < n_global; j++)
+            {
+                if (!mask_global[j]) continue;
+                S_sub.at<double>(ii, jj) = S.at<double>(i, j);
+                jj++;
+            }
+            ii++;
+        }
+
+        // Solve the reduced system
+        cv::Mat delta_sub;
+        if (!cv::solve(S_sub, e_sub, delta_sub, solveMethod) ||
+            !cv::checkRange(delta_sub))
+        {
+            clearUpdates();
+            return false;
+        }
+
+        // Distribute the solution into the full update vector
+        deltaGlobal.setTo(0);
+        int j = 0;
+        for (int i = 0; i < n_global; i++)
+        {
+            if (mask_global[i])
+                deltaGlobal.at<double>(i) = delta_sub.at<double>(j++);
+        }
+
+        // Back-substitute to find the update for extrinsic parameters
+        for (int i = 0; i < nimages; i++)
+        {
+            deltaLocal[i] = V_inv[i] * (eb[i] - W[i].t() * deltaGlobal);
+        }
+        return true;
+    }
+
+    bool iterate(double errNorm, bool& needsJacobian)
+    {
+        needsJacobian = false;
+
+        if (state == DONE)
+        {
+            return false;
+        }
+
+        if (state == STARTED)
+        {
+            state = CALC_J;
+            needsJacobian = true;
+            return true;
+        }
+
+        if (state == CALC_J)
+        {
+            prevErrNorm = errNorm;
+            state = CHECK_ERR;
+            return true;
+        }
+
+        // state == CHECK_ERR
+        if (errNorm > prevErrNorm)
+        {
+            // Reject step
+            if (++lambdaLg10 <= 16)
+            {
+                // Re-solve with higher lambda, DON'T recompute Jacobian
+                return true;
+            }
+            // Lambda exhausted
+        }
+
+        // Accept step
+        lambdaLg10 = std::max(lambdaLg10 - 1, -16);
+        prevErrNorm = errNorm;
+
+        if (++iters >= criteria.maxCount)
+        {
+            state = DONE;
+            return false;
+        }
+
+        state = CALC_J;
+        needsJacobian = true;
+        return true;
+    }
+
+    cv::Mat getGlobalUpdate() const { return deltaGlobal; }
+    cv::Mat getLocalUpdate(int i) const { return deltaLocal[i]; }
+    void setSolveMethod(int method) { solveMethod = method; }
+
+    cv::Mat U;
+    std::vector<cv::Mat> V;
+    std::vector<cv::Mat> W;
+    cv::Mat ea;
+    std::vector<cv::Mat> eb;
+    double currentError;
+
+    State state;
+    int NINTRINSIC;
+    int nimages;
+    int n_global;
+    int lambdaLg10;
+
+private:
+    void clearUpdates()
+    {
+        deltaGlobal.setTo(0);
+        for (int i = 0; i < nimages; i++)
+            deltaLocal[i].setTo(0);
+    }
+
+    int iters;
+    double prevErrNorm;
+    cv::TermCriteria criteria;
+    int solveMethod;
+
+    std::vector<cv::Mat> V_inv;
+    cv::Mat deltaGlobal;
+    std::vector<cv::Mat> deltaLocal;
+};
+
+class JAccumulator : public cv::ParallelLoopBody
+{
+public:
+    JAccumulator(SchurLMSolver& _solver,
+                 const cv::Mat& _matM, const cv::Mat& _m, const cv::Mat& _npoints,
+                 const cv::Mat& _param, int _flags, double _aspectRatio,
+                 int _NINTRINSIC, bool _releaseObject, int _maxPoints,
+                 cv::Mutex& _globalMutex)
+        : solver(_solver), matM(_matM), m(_m), npoints(_npoints),
+          param(_param), flags(_flags), aspectRatio(_aspectRatio),
+          NINTRINSIC(_NINTRINSIC), releaseObject(_releaseObject),
+          maxPoints(_maxPoints), globalMutex(_globalMutex) {}
+
+    void operator()(const cv::Range& range) const CV_OVERRIDE
+    {
+        int nimages_total = npoints.checkVector(1, CV_32S);
+        int so = NINTRINSIC + nimages_total * 6;
+
+        double fx = param.at<double>(0), fy = param.at<double>(1);
+        double cx = param.at<double>(2), cy = param.at<double>(3);
+        cv::Matx33d intrin(fx, 0, cx, 0, fy, cy, 0, 0, 1);
+        cv::Mat dist = param.rowRange(4, 4 + 14);
+
+        cv::Mat JiBuf(maxPoints * 2, NINTRINSIC, CV_64F);
+        cv::Mat JeBuf(maxPoints * 2, 6, CV_64F);
+        cv::Mat JoBuf;
+        if (releaseObject)
+            JoBuf.create(maxPoints * 2, maxPoints * 3, CV_64F);
+        cv::Mat errBuf(maxPoints * 2, 1, CV_64F);
+
+        int pos = 0;
+        for (int i = 0; i < range.start; i++)
+            pos += npoints.at<int>(i);
+
+        double localErr = 0;
+
+        for (int i = range.start; i < range.end; i++)
+        {
+            int ni = npoints.at<int>(i);
+            int si = NINTRINSIC + i * 6;
+
+            cv::Mat _ri = param.rowRange(si, si + 3);
+            cv::Mat _ti = param.rowRange(si + 3, si + 6);
+
+            cv::Mat _Mi = matM.colRange(pos, pos + ni);
+            if (releaseObject)
+            {
+                _Mi = param.rowRange(so, so + ni * 3);
+                _Mi = _Mi.reshape(3, 1);
+            }
+            cv::Mat _mi = m.colRange(pos, pos + ni);
+
+            // Buffers for derivatives
+            cv::Mat Ji = JiBuf.rowRange(0, ni * 2);
+            Ji.setTo(0);
+            cv::Mat Je = JeBuf.rowRange(0, ni * 2);
+            Je.setTo(0);
+            cv::Mat Jo;
+            if (releaseObject)
+            {
+                Jo = JoBuf.rowRange(0, ni * 2).colRange(0, ni * 3);
+                Jo.setTo(0);
+            }
+            cv::Mat err = errBuf.rowRange(0, ni * 2);
+            cv::Mat _mp = err.reshape(2, 1);
+
+            cv::Mat _dpdr, _dpdt, _dpdf, _dpdc, _dpdk, _dpdo;
+
+            // Allocate contiguous buffers for Jacobians
+            _dpdr.create(ni * 2, 3, CV_64F);
+            _dpdt.create(ni * 2, 3, CV_64F);
+            _dpdk.create(ni * 2, NINTRINSIC - 4, CV_64F);
+
+            if (!(flags & cv::CALIB_FIX_FOCAL_LENGTH))
+                _dpdf.create(ni * 2, 2, CV_64F);
+            if (!(flags & cv::CALIB_FIX_PRINCIPAL_POINT))
+                _dpdc.create(ni * 2, 2, CV_64F);
+            if (releaseObject)
+                _dpdo.create(ni * 2, ni * 3, CV_64F);
+
+            cv::projectPoints(_Mi, _ri, _ti, intrin, dist, _mp,
+                              _dpdr, _dpdt,
+                              _dpdf.empty() ? cv::noArray() : _dpdf,
+                              _dpdc.empty() ? cv::noArray() : _dpdc,
+                              _dpdk,
+                              _dpdo.empty() ? cv::noArray() : _dpdo,
+                              (flags & cv::CALIB_FIX_ASPECT_RATIO) ? aspectRatio : 0.);
+
+            // Copy Jacobians from projectPoints buffers to solver blocks
+            _dpdr.copyTo(Je.colRange(0, 3));
+            _dpdt.copyTo(Je.colRange(3, 6));
+
+            if (!_dpdf.empty())
+            {
+                if (flags & cv::CALIB_FIX_ASPECT_RATIO)
+                {
+                    cv::Mat dpdf_fx = _dpdf.col(0);
+                    cv::Mat dpdf_fy = _dpdf.col(1);
+                    cv::scaleAdd(dpdf_fx, aspectRatio, dpdf_fy, dpdf_fy);
+                }
+                _dpdf.copyTo(Ji.colRange(0, 2));
+            }
+            if (!_dpdc.empty())
+                _dpdc.copyTo(Ji.colRange(2, 4));
+
+            _dpdk.copyTo(Ji.colRange(4, NINTRINSIC));
+
+            if (!_dpdo.empty())
+                _dpdo.copyTo(Jo);
+
+            cv::subtract(_mp, _mi, _mp);
+            localErr += cv::norm(err, cv::NORM_L2SQR);
+
+            // Accumulate V and eb blocks (per-image)
+            solver.V[i] = Je.t() * Je;
+            solver.eb[i] = Je.t() * err;
+            cv::Mat JitJe = Ji.t() * Je;
+            JitJe.copyTo(solver.W[i].rowRange(0, NINTRINSIC));
+
+            if (releaseObject)
+            {
+                cv::Mat JotJe = Jo.t() * Je;
+                JotJe.copyTo(solver.W[i].rowRange(NINTRINSIC, NINTRINSIC + Jo.cols));
+            }
+
+            // Accumulate U and ea blocks (shared parameters)
+            {
+                cv::AutoLock lock(globalMutex);
+                solver.U(cv::Rect(0, 0, NINTRINSIC, NINTRINSIC)) += Ji.t() * Ji;
+                solver.ea.rowRange(0, NINTRINSIC) += Ji.t() * err;
+
+                if (releaseObject)
+                {
+                    cv::Mat JitJo = Ji.t() * Jo;
+                    solver.U(cv::Rect(NINTRINSIC, 0, Jo.cols, NINTRINSIC)) += JitJo;
+                    solver.U(cv::Rect(0, NINTRINSIC, NINTRINSIC, Jo.cols)) += JitJo.t();
+                    solver.U(cv::Rect(NINTRINSIC, NINTRINSIC, Jo.cols, Jo.cols)) += Jo.t() * Jo;
+                    solver.ea.rowRange(NINTRINSIC, NINTRINSIC + Jo.cols) += Jo.t() * err;
+                }
+
+                solver.currentError += localErr;
+            }
+
+            pos += ni;
+            localErr = 0;
+        }
+    }
+
+private:
+    SchurLMSolver& solver;
+    const cv::Mat& matM;
+    const cv::Mat& m;
+    const cv::Mat& npoints;
+    const cv::Mat& param;
+    int flags;
+    double aspectRatio;
+    int NINTRINSIC;
+    bool releaseObject;
+    int maxPoints;
+    cv::Mutex& globalMutex;
+};
+
+} // anonymous namespace
+
+
+/*
+    This is straight-forward port v3 of Matlab calibration engine by Jean-Yves Bouguet
+    that is (in a large extent) based on the paper:
+    Z. Zhang. "A flexible new technique for camera calibration".
+    IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
+    The 1st initial port was done by Valery Mosyagin.
+*/
+
+namespace cv {
+
+static void initIntrinsicParams2D( const Mat& objectPoints,
+                         const Mat& imagePoints, const Mat& npoints,
+                         Size imageSize, OutputArray cameraMatrix,
+                         double aspectRatio )
+{
+    CV_Assert(npoints.type() == CV_32SC1 && (npoints.rows == 1 || npoints.cols == 1) && npoints.isContinuous());
+    int nimages = npoints.rows + npoints.cols - 1;
+
+    CV_Assert( objectPoints.type() == CV_32FC3 ||
+               objectPoints.type() == CV_64FC3 );
+    CV_Assert( imagePoints.type() == CV_32FC2 ||
+               imagePoints.type() == CV_64FC2 );
+
+    if( objectPoints.rows != 1 || imagePoints.rows != 1 )
+        CV_Error( cv::Error::StsBadSize, "object points and image points must be a single-row matrices" );
+
+    Mat_<double> matA(2*nimages, 2);
+    Mat_<double> matb(2*nimages, 1, CV_64F );
+    double fx, fy, cx, cy;
+    cx = (!imageSize.width ) ? 0.5 : (imageSize.width - 1)*0.5;
+    cy = (!imageSize.height) ? 0.5 : (imageSize.height - 1)*0.5;
+
+    // extract vanishing points in order to obtain initial value for the focal length
+    int pos = 0;
+    for(int i = 0; i < nimages; i++ )
+    {
+        int ni = npoints.at<int>(i);
+        Mat matM = objectPoints.colRange(pos, pos + ni);
+        Mat _m = imagePoints.colRange(pos, pos + ni);
+        pos += ni;
+
+        Matx33d H;
+        Mat matH0 = findHomography(matM, _m);
+        CV_Assert(matH0.size() == Size(3, 3));
+        matH0.convertTo(H, CV_64F);
+
+        H(0, 0) -= H(2, 0)*cx; H(0, 1) -= H(2, 1)*cx; H(0, 2) -= H(2, 2)*cx;
+        H(1, 0) -= H(2, 0)*cy; H(1, 1) -= H(2, 1)*cy; H(1, 2) -= H(2, 2)*cy;
+
+        Vec3d h, v, d1, d2;
+        Vec4d n;
+        for(int j = 0; j < 3; j++ )
+        {
+            double t0 = H(j, 0), t1 = H(j, 1);
+            h[j] = t0; v[j] = t1;
+            d1[j] = (t0 + t1)*0.5;
+            d2[j] = (t0 - t1)*0.5;
+            n[0] += t0*t0; n[1] += t1*t1;
+            n[2] += d1[j]*d1[j]; n[3] += d2[j]*d2[j];
+        }
+
+        for(int j = 0; j < 4; j++ )
+            n[j] = 1./std::sqrt(n[j]);
+
+        for(int j = 0; j < 3; j++ )
+        {
+            h[j] *= n[0]; v[j] *= n[1];
+            d1[j] *= n[2]; d2[j] *= n[3];
+        }
+
+        matA(i*2+0, 0) = h[0]*v[0];   matA(i*2+0, 1) = h[1]*v[1];
+        matA(i*2+1, 0) = d1[0]*d2[0]; matA(i*2+1, 1) = d1[1]*d2[1];
+        matb(i*2+0) = -h[2]*v[2];
+        matb(i*2+1) = -d1[2]*d2[2];
+    }
+
+    Vec2d f;
+    solve(matA, matb, f, DECOMP_NORMAL + DECOMP_SVD);
+    fx = std::sqrt(fabs(1./f[0]));
+    fy = std::sqrt(fabs(1./f[1]));
+    if( aspectRatio != 0 )
+    {
+        double tf = (fx + fy)/(aspectRatio + 1.);
+        fx = aspectRatio*tf;
+        fy = tf;
+    }
+    Matx33d(fx,  0, cx,
+             0, fy, cy,
+             0,  0,  1).copyTo(cameraMatrix);
+}
+
+static void subMatrix(const Mat& src, Mat& dst,
+                      const std::vector<uchar>& cols,
+                      const std::vector<uchar>& rows)
+{
+    CV_Assert(src.type() == CV_64F && dst.type() == CV_64F);
+    int m = (int)rows.size(), n = (int)cols.size();
+    int i1 = 0, j1 = 0;
+    for(int i = 0; i < m; i++)
+    {
+        if(rows[i])
+        {
+            const double* srcptr = src.ptr<double>(i);
+            double* dstptr = dst.ptr<double>(i1++);
+
+            if(n > 0)
+            {
+                const uchar* colsdata = cols.data();
+                for(int j = j1 = 0; j < n; j++)
+                {
+                    if(colsdata[j])
+                        dstptr[j1++] = srcptr[j];
+                }
+            }
+        }
+    }
+}
+
+/*
+ T his is straight-forward port v3 of Matlab calibration engine by Jean-Yves Bouguet                *
+ that is (in a large extent) based on the paper:
+ Z. Zhang. "A flexible new technique for camera calibration".
+ IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
+ The 1st initial port was done by Valery Mosyagin.
+ */
+static double calibrateCameraInternalBouguet( const Mat& objectPoints,
+                                              const Mat& imagePoints, const Mat& npoints,
+                                              Size imageSize, int iFixedPoint, Mat& cameraMatrix, Mat& distCoeffs,
+                                              Mat rvecs, Mat tvecs, Mat newObjPoints, Mat stdDevs,
+                                              Mat perViewErr, int flags, const TermCriteria& termCrit )
+{
+    int NINTRINSIC = CALIB_NINTRINSIC;
+
+    double aspectRatio = 0.;
+    int nimages = npoints.checkVector(1, CV_32S);
+    CV_Assert(nimages >= 1);
+    int ndistCoeffs = (int)distCoeffs.total();
+    bool releaseObject = iFixedPoint > 0 && iFixedPoint < npoints.at<int>(0) - 1;
+
+    // 0. check the parameters & allocate buffers
+    if( imageSize.width <= 0 || imageSize.height <= 0 )
+        CV_Error( cv::Error::StsOutOfRange, "image width and height must be positive" );
+
+    if(flags & CALIB_TILTED_MODEL)
+    {
+        //when the tilted sensor model is used the distortion coefficients matrix must have 14 parameters
+        if (ndistCoeffs != 14)
+            CV_Error( cv::Error::StsBadArg, "The tilted sensor model must have 14 parameters in the distortion matrix" );
+    }
+    else
+    {
+        //when the thin prism model is used the distortion coefficients matrix must have 12 parameters
+        if(flags & CALIB_THIN_PRISM_MODEL)
+            if (ndistCoeffs != 12)
+                CV_Error( cv::Error::StsBadArg, "Thin prism model must have 12 parameters in the distortion matrix" );
+    }
+
+    if( !rvecs.empty() )
+    {
+        int cn = rvecs.channels();
+        CV_Assert(rvecs.depth() == CV_32F || rvecs.depth() == CV_64F);
+        CV_Assert((rvecs.rows == nimages && (rvecs.cols*cn == 3 || rvecs.cols*cn == 3)) ||
+                  (rvecs.rows == 1 && rvecs.cols == nimages && cn == 3));
+    }
+
+    if( !tvecs.empty() )
+    {
+        int cn = tvecs.channels();
+        CV_Assert(tvecs.depth() == CV_32F || tvecs.depth() == CV_64F);
+        CV_Assert((tvecs.rows == nimages && tvecs.cols*cn == 3) ||
+                  (tvecs.rows == 1 && tvecs.cols == nimages && cn == 3));
+    }
+
+    CV_Assert(cameraMatrix.type() == CV_32F || cameraMatrix.type() == CV_64F);
+    CV_Assert(cameraMatrix.rows == 3 && cameraMatrix.cols == 3);
+
+    CV_Assert(distCoeffs.type() == CV_32F || distCoeffs.type() == CV_64F);
+    CV_Assert(distCoeffs.rows == 1 || distCoeffs.cols == 1);
+    CV_Assert(ndistCoeffs == 4 || ndistCoeffs == 5 || ndistCoeffs == 8 ||
+              ndistCoeffs == 12 || ndistCoeffs == 14);
+
+    int total = 0, maxPoints = 0;
+    for(int i = 0; i < nimages; i++ )
+    {
+        int ni = npoints.at<int>(i);
+        if( ni < 4 )
+        {
+            CV_Error_( cv::Error::StsOutOfRange, ("The number of points in the view #%d is < 4", i));
+        }
+        maxPoints = MAX( maxPoints, ni );
+        total += ni;
+    }
+
+    if( !newObjPoints.empty() )
+    {
+        int cn = newObjPoints.channels();
+        CV_Assert(newObjPoints.depth() == CV_32F || newObjPoints.depth() == CV_64F);
+        CV_Assert((newObjPoints.rows == maxPoints && newObjPoints.cols*cn == 3) ||
+                  (newObjPoints.rows == 1 && newObjPoints.cols == maxPoints && cn == 3));
+    }
+
+    if( !stdDevs.empty() )
+    {
+        int cn = stdDevs.channels();
+        CV_Assert(stdDevs.depth() == CV_32F || stdDevs.depth() == CV_64F);
+        int nstddev = nimages*6 + NINTRINSIC + (releaseObject ? maxPoints*3 : 0);
+
+        CV_Assert((stdDevs.rows == nstddev && stdDevs.cols*cn == 1) ||
+                  (stdDevs.rows == 1 && stdDevs.cols == nstddev && cn == 1));
+    }
+
+    Mat matM( 1, total, CV_64FC3 );
+    Mat _m( 1, total, CV_64FC2 );
+    Mat allErrors(1, total, CV_64FC2);
+
+    if(objectPoints.channels() == 3)
+        objectPoints.convertTo(matM, CV_64F);
+    else
+        convertPointsToHomogeneous(objectPoints, matM, CV_64F);
+
+    if(imagePoints.channels() == 2)
+        imagePoints.convertTo(_m, CV_64F);
+    else
+        convertPointsFromHomogeneous(imagePoints, _m, CV_64F);
+
+    int nparams = NINTRINSIC + nimages*6;
+    if( releaseObject )
+        nparams += maxPoints * 3;
+
+    std::vector<double> k(14, 0.0);
+    Mat _k( distCoeffs.rows, distCoeffs.cols, CV_64F, k.data());
+    if( distCoeffs.total() < 8 )
+    {
+        if( distCoeffs.total() < 5 )
+            flags |= CALIB_FIX_K3;
+        flags |= CALIB_FIX_K4 | CALIB_FIX_K5 | CALIB_FIX_K6;
+    }
+    const double minValidAspectRatio = 0.01;
+    const double maxValidAspectRatio = 100.0;
+
+    Matx33d A;
+    cameraMatrix.convertTo(A, CV_64F);
+
+    // 1. initialize intrinsic parameters & LM solver
+    if( flags & CALIB_USE_INTRINSIC_GUESS )
+    {
+        if( A(0, 0) <= 0 || A(1, 1) <= 0 )
+            CV_Error( cv::Error::StsOutOfRange, "Focal length (fx and fy) must be positive" );
+        if( A(0, 2) < 0 || A(0, 2) >= imageSize.width ||
+            A(1, 2) < 0 || A(1, 2) >= imageSize.height )
+            CV_Error( cv::Error::StsOutOfRange, "Principal point must be within the image" );
+        if( fabs(A(0, 1)) > 1e-5 )
+            CV_Error( cv::Error::StsOutOfRange, "Non-zero skew is not supported by the function" );
+        if( fabs(A(1, 0)) > 1e-5 || fabs(A(2, 0)) > 1e-5 ||
+            fabs(A(2, 1)) > 1e-5 || fabs(A(2,2)-1) > 1e-5 )
+            CV_Error( cv::Error::StsOutOfRange,
+                "The intrinsic matrix must have [fx 0 cx; 0 fy cy; 0 0 1] shape" );
+        A(0, 1) = A(1, 0) = A(2, 0) = A(2, 1) = 0.;
+        A(2, 2) = 1.;
+
+        if( flags & CALIB_FIX_ASPECT_RATIO )
+        {
+            aspectRatio = A(0, 0)/A(1, 1);
+
+            if( aspectRatio < minValidAspectRatio || aspectRatio > maxValidAspectRatio )
+                CV_Error( cv::Error::StsOutOfRange,
+                    "The specified aspect ratio (= cameraMatrix[0][0] / cameraMatrix[1][1]) is incorrect" );
+        }
+        distCoeffs.convertTo(_k, CV_64F);
+    }
+    else
+    {
+        Scalar mean, sdv;
+        meanStdDev(matM, mean, sdv);
+        if( fabs(mean[2]) > 1e-5 || fabs(sdv[2]) > 1e-5 )
+            CV_Error( cv::Error::StsBadArg,
+            "For non-planar calibration rigs the initial intrinsic matrix must be specified" );
+        for(int i = 0; i < total; i++ )
+            matM.at<Point3d>(i).z = 0.;
+
+        if( flags & CALIB_FIX_ASPECT_RATIO )
+        {
+            aspectRatio = A(0, 0);
+            aspectRatio /= A(1, 1);
+            if( aspectRatio < minValidAspectRatio || aspectRatio > maxValidAspectRatio )
+                CV_Error( cv::Error::StsOutOfRange,
+                    "The specified aspect ratio (= cameraMatrix[0][0] / cameraMatrix[1][1]) is incorrect" );
+        }
+        initIntrinsicParams2D( matM, _m, npoints, imageSize, A, aspectRatio );
+    }
+
+    //std::cout << "A0: " << A << std::endl;
+    //std::cout << "dist0:" << _k << std::endl;
+
+    std::vector<double> param(nparams, 0.0);
+    Mat paramM = Mat(param, false).reshape(1, nparams);
+    std::vector<uchar> mask(nparams, (uchar)1);
+
+    int solveMethod = DECOMP_EIG;
+
+    if(flags & CALIB_USE_LU) {
+        solveMethod = DECOMP_LU;
+    }
+    else if(flags & CALIB_USE_QR) {
+        solveMethod = DECOMP_QR;
+    }
+
+    param[0] = A(0, 0); param[1] = A(1, 1); param[2] = A(0, 2); param[3] = A(1, 2);
+    std::copy(k.begin(), k.end(), param.begin() + 4);
+
+    if(flags & CALIB_FIX_ASPECT_RATIO)
+        mask[0] = 0;
+    if( flags & CALIB_FIX_FOCAL_LENGTH )
+        mask[0] = mask[1] = 0;
+    if( flags & CALIB_FIX_PRINCIPAL_POINT )
+        mask[2] = mask[3] = 0;
+    if( flags & CALIB_ZERO_TANGENT_DIST )
+    {
+        param[6] = param[7] = 0;
+        mask[6] = mask[7] = 0;
+    }
+    if( !(flags & CALIB_RATIONAL_MODEL) )
+        flags |= CALIB_FIX_K4 + CALIB_FIX_K5 + CALIB_FIX_K6;
+    if( !(flags & CALIB_THIN_PRISM_MODEL))
+        flags |= CALIB_FIX_S1_S2_S3_S4;
+    if( !(flags & CALIB_TILTED_MODEL))
+        flags |= CALIB_FIX_TAUX_TAUY;
+
+    mask[ 4] = !(flags & CALIB_FIX_K1);
+    mask[ 5] = !(flags & CALIB_FIX_K2);
+    if( flags & CALIB_FIX_TANGENT_DIST )
+        mask[6]  = mask[7]  = 0;
+    mask[ 8] = !(flags & CALIB_FIX_K3);
+    mask[ 9] = !(flags & CALIB_FIX_K4);
+    mask[10] = !(flags & CALIB_FIX_K5);
+    mask[11] = !(flags & CALIB_FIX_K6);
+
+    if(flags & CALIB_FIX_S1_S2_S3_S4)
+    {
+        mask[12] = 0;
+        mask[13] = 0;
+        mask[14] = 0;
+        mask[15] = 0;
+    }
+    if(flags & CALIB_FIX_TAUX_TAUY)
+        mask[16] = mask[17] = 0;
+
+    if(releaseObject)
+    {
+        // copy object points
+        int s = NINTRINSIC + nimages * 6;
+
+        std::copy( matM.ptr<double>(), matM.ptr<double>( 0, maxPoints - 1 ) + 3,
+                   param.begin() + NINTRINSIC + nimages * 6 );
+
+        // fix points
+        mask[s + 0] = 0;
+        mask[s + 1] = 0;
+        mask[s + 2] = 0;
+        mask[s + iFixedPoint * 3 + 0] = 0;
+        mask[s + iFixedPoint * 3 + 1] = 0;
+        mask[s + iFixedPoint * 3 + 2] = 0;
+        mask[nparams - 1] = 0;
+    }
+
+    int nparams_nz = countNonZero(mask);
+
+    if (nparams_nz >= 2 * total)
+        CV_Error_(Error::StsBadArg,
+                  ("There should be less vars to optimize (having %d) than the number of residuals (%d = 2 per point)", nparams_nz, 2 * total));
+
+    // 2. initialize extrinsic parameters
+    for(int i = 0, pos = 0; i < nimages; i++ )
+    {
+        int ni = npoints.at<int>(i);
+
+        int s = NINTRINSIC + i*6;
+        Mat _ri = paramM.rowRange(s, s + 3);
+        Mat _ti = paramM.rowRange(s + 3, s + 6);
+
+        Mat _Mi = matM.colRange(pos, pos + ni);
+        Mat _mi = _m.colRange(pos, pos + ni);
+
+        solvePnP(_Mi, _mi, A, _k, _ri, _ti, false);
+
+        pos += ni;
+    }
+
+    //std::cout << "single camera calib. param before LM: " << param0.t() << "\n";
+    //std::cout << "single camera calib. mask: " << mask0.t() << "\n";
+
+    // 3. run the optimization
+
+    Mat errBuf( maxPoints*2, 1, CV_64FC1 );
+    Mat JiBuf ( maxPoints*2, NINTRINSIC, CV_64FC1, Scalar(0));
+    Mat JeBuf ( maxPoints*2, 6, CV_64FC1 );
+    Mat JoBuf;
+    if (releaseObject)
+        JoBuf = Mat( maxPoints*2, maxPoints*3, CV_64FC1);
+
+    auto cameraCalcJErr = [&, npoints, nimages, flags, releaseObject, nparams, maxPoints, NINTRINSIC]
+                          (InputOutputArray _param, OutputArray _JtErr, OutputArray _JtJ, double& errnorm) -> bool
+    {
+        bool optimizeObjPoints = releaseObject;
+
+        Mat_<double> param_m = _param.getMat();
+        param_m = param_m.reshape(1, max(param_m.rows, param_m.cols));
+
+        if( flags & CALIB_FIX_ASPECT_RATIO )
+        {
+            param_m(0) = param_m(1)*aspectRatio;
+        }
+
+        double fx = param_m(0), fy = param_m(1), cx = param_m(2), cy = param_m(3);
+        Matx33d intrin(fx,  0, cx,
+                        0, fy, cy,
+                        0,  0,  1);
+        Mat dist = param_m.rowRange(4, 4+14);
+
+        bool calcJ = !_JtErr.empty() && !_JtJ.empty();
+        Mat JtErr, JtJ;
+        if (calcJ)
+        {
+            JtErr = _JtErr.getMat();
+            JtJ   = _JtJ.getMat();
+            JtJ.setZero();
+            JtErr.setZero();
+        }
+
+        double reprojErr = 0;
+
+        int so = NINTRINSIC + nimages * 6;
+        int pos = 0;
+        for( int i = 0; i < nimages; i++ )
+        {
+            int si = NINTRINSIC + i * 6;
+
+            int ni = npoints.at<int>(i);
+            Mat _ri = param_m.rowRange(si, si + 3);
+            Mat _ti = param_m.rowRange(si + 3, si + 6);
+
+            Mat _Mi = matM.colRange(pos, pos + ni);
+            if( optimizeObjPoints )
+            {
+                _Mi = param_m.rowRange(so, so + ni * 3);
+                _Mi = _Mi.reshape(3, 1);
+            }
+            Mat _mi = _m.colRange(pos, pos + ni);
+            Mat _me = allErrors.colRange(pos, pos + ni);
+
+            Mat Jo;
+            if (optimizeObjPoints)
+                Jo = JoBuf(Range(0, ni*2), Range(0, ni*3));
+
+            Mat Je  = JeBuf.rowRange(0, ni*2);
+            Mat Ji  = JiBuf.rowRange(0, ni*2);
+            Mat err = errBuf.rowRange(0, ni*2);
+            Mat _mp = err.reshape(2, 1);
+
+            if( calcJ )
+            {
+                Mat _dpdr = Je.colRange(0, 3);
+                Mat _dpdt = Je.colRange(3, 6);
+                Mat _dpdf = (flags & CALIB_FIX_FOCAL_LENGTH) ? Mat() : Ji.colRange(0, 2);
+                Mat _dpdc = (flags & CALIB_FIX_PRINCIPAL_POINT) ? Mat() : Ji.colRange(2, 4);
+                Mat _dpdk = Ji.colRange(4, NINTRINSIC);
+                Mat _dpdo = Jo.empty() ? Mat() : Jo.colRange(0, ni * 3);
+
+                projectPoints(_Mi, _ri, _ti, intrin, dist, _mp, _dpdr, _dpdt,
+                              (_dpdf.empty() ? noArray() : _dpdf),
+                              (_dpdc.empty() ? noArray() : _dpdc),
+                              _dpdk, (_dpdo.empty() ? noArray() : _dpdo),
+                              (flags & CALIB_FIX_ASPECT_RATIO) ? aspectRatio : 0.);
+            }
+            else
+                projectPoints( _Mi, _ri, _ti, intrin, dist, _mp);
+
+            subtract( _mp, _mi, _mp );
+            _mp.copyTo(_me);
+
+            if( calcJ )
+            {
+                // see HZ: (A6.14) for details on the structure of the Jacobian
+                JtJ(Rect(0, 0, NINTRINSIC, NINTRINSIC)) += Ji.t() * Ji;
+                JtJ(Rect(si, si, 6, 6)) = Je.t() * Je;
+                JtJ(Rect(si,  0, 6, NINTRINSIC)) = Ji.t() * Je;
+                if( optimizeObjPoints )
+                {
+                    JtJ(Rect(so, 0, maxPoints * 3, NINTRINSIC)) += Ji.t() * Jo;
+                    JtJ(Rect(so, si, maxPoints * 3, 6)) += Je.t() * Jo;
+                    JtJ(Rect(so, so, maxPoints * 3, maxPoints * 3)) += Jo.t() * Jo;
+                }
+
+                JtErr.rowRange(0, NINTRINSIC) += Ji.t() * err;
+                JtErr.rowRange(si, si + 6) = Je.t() * err;
+                if( optimizeObjPoints )
+                {
+                    JtErr.rowRange(so, nparams) += Jo.t() * err;
+                }
+            }
+
+            double viewErr = norm(err, NORM_L2SQR);
+            if( !perViewErr.empty() )
+                perViewErr.at<double>(i) = std::sqrt(viewErr / ni);
+
+            reprojErr += viewErr;
+            pos += ni;
+        }
+
+        errnorm = reprojErr;
+        return true;
+    };
+
+    LevMarq solver(param, cameraCalcJErr,
+                   LevMarq::Settings()
+                   .setMaxIterations((unsigned int)termCrit.maxCount)
+                   .setStepNormTolerance(termCrit.epsilon)
+                   .setSmallEnergyTolerance(termCrit.epsilon * termCrit.epsilon),
+                   mask, MatrixType::AUTO, VariableType::LINEAR, /* LtoR */ false, solveMethod);
+    // geodesic is not supported for normal callbacks
+    solver.optimize();
+
+    // If solver failed or last LM iteration was not successful,
+    // then the last calculated perViewErr can be wrong & should be recalculated
+    Mat JtErr, JtJ, JtJinv, JtJN;
+    double reprojErr = 0;
+    if (!stdDevs.empty())
+    {
+        JtErr = Mat(nparams, 1, CV_64F);
+        JtJ = Mat(nparams, nparams, CV_64F);
+        JtErr.setZero();
+        JtJ.setZero();
+    }
+
+    cameraCalcJErr(param, JtErr, JtJ, reprojErr);
+
+    if (!stdDevs.empty())
+    {
+        JtJN.create(nparams_nz, nparams_nz, CV_64F);
+
+        subMatrix(JtJ, JtJN, mask, mask);
+        completeSymm(JtJN, false);
+        //TODO: try DECOMP_CHOLESKY maybe?
+        cv::invert(JtJN, JtJinv, DECOMP_EIG);
+        // an explanation of that denominator correction can be found here:
+        // R. Hartley, A. Zisserman, Multiple View Geometry in Computer Vision, 2004, section 5.1.3, page 134
+        // see the discussion for more details: https://github.com/opencv/opencv/pull/22992
+        double sigma2 = norm(allErrors, NORM_L2SQR) / (2 * total - nparams_nz);
+        int j = 0;
+        for ( int s = 0; s < nparams; s++ )
+        {
+            stdDevs.at<double>(s) = mask[s] ? std::sqrt(JtJinv.at<double>(j, j) * sigma2) : 0.0;
+            if( mask[s] )
+                j++;
+        }
+    }
+
+    // 4. store the results
+    A = Matx33d(param[0], 0, param[2], 0, param[1], param[3], 0, 0, 1);
+    A.convertTo(cameraMatrix, cameraMatrix.type());
+    _k = Mat(distCoeffs.size(), CV_64F, param.data() + 4);
+    _k.convertTo(distCoeffs, distCoeffs.type());
+
+    if( !newObjPoints.empty() && releaseObject )
+    {
+        int s = NINTRINSIC + nimages * 6;
+        Mat _Mi = paramM.rowRange(s, s + maxPoints * 3);
+        _Mi.reshape(3, 1).convertTo(newObjPoints, newObjPoints.type());
+    }
+
+    for(int i = 0; i < nimages; i++ )
+    {
+        if( !rvecs.empty() )
+        {
+            Mat src = Mat(3, 1, CV_64F, param.data() + NINTRINSIC + i*6);
+            if( rvecs.rows == nimages && rvecs.cols*rvecs.channels() == 9 )
+            {
+                Mat dst(3, 3, rvecs.depth(), rvecs.ptr(i));
+                Rodrigues(src, A);
+                A.convertTo(dst, dst.type());
+            }
+            else
+            {
+                Mat dst(3, 1, rvecs.depth(), rvecs.rows == 1 ?
+                    rvecs.data + i*rvecs.elemSize() : rvecs.ptr(i));
+                src.convertTo(dst, dst.type());
+            }
+        }
+        if( !tvecs.empty() )
+        {
+            Mat src(3, 1, CV_64F, param.data() + NINTRINSIC + i*6 + 3);
+            Mat dst(3, 1, tvecs.depth(), tvecs.rows == 1 ?
+                    tvecs.data + i*tvecs.elemSize() : tvecs.ptr(i));
+            src.convertTo(dst, dst.type());
+        }
+    }
+
+    return std::sqrt(reprojErr/total);
+}
+
+static double calibrateCameraInternalSchur( const Mat& objectPoints,
+                                       const Mat& imagePoints, const Mat& npoints,
+                                       Size imageSize, int iFixedPoint, Mat& cameraMatrix, Mat& distCoeffs,
+                                       Mat rvecs, Mat tvecs, Mat newObjPoints, Mat stdDevs,
+                                       Mat perViewErr, int flags, const TermCriteria& termCrit )
+{
+    int NINTRINSIC = CALIB_NINTRINSIC;
+    double reprojErr = 0;
+
+    double aspectRatio = 0.;
+    int nimages = npoints.checkVector(1, CV_32S);
+    CV_Assert(nimages >= 1);
+    int ndistCoeffs = (int)distCoeffs.total();
+    bool releaseObject = iFixedPoint > 0 && iFixedPoint < npoints.at<int>(0) - 1;
+
+    // 0. check the parameters & allocate buffers
+    if (imageSize.width <= 0 || imageSize.height <= 0)
+    {
+        CV_Error(cv::Error::StsOutOfRange, "image width and height must be positive");
+    }
+
+    if (flags & CALIB_TILTED_MODEL)
+    {
+        // when the tilted sensor model is used the distortion coefficients matrix must have 14 parameters
+        if (ndistCoeffs != 14)
+        {
+            CV_Error(cv::Error::StsBadArg, "The tilted sensor model must have 14 parameters");
+        }
+    }
+    else
+    {
+        // when the thin prism model is used the distortion coefficients matrix must have 12 parameters
+        if (flags & CALIB_THIN_PRISM_MODEL)
+        {
+            if (ndistCoeffs != 12)
+            {
+                CV_Error(cv::Error::StsBadArg, "Thin prism model must have 12 parameters");
+            }
+        }
+    }
+
+    if (!rvecs.empty())
+    {
+        int cn = rvecs.channels();
+        CV_Assert(rvecs.depth() == CV_32F || rvecs.depth() == CV_64F);
+        CV_Assert((rvecs.rows == nimages && (rvecs.cols * cn == 3)) ||
+                  (rvecs.rows == 1 && rvecs.cols == nimages && cn == 3));
+    }
+
+    if (!tvecs.empty())
+    {
+        int cn = tvecs.channels();
+        CV_Assert(tvecs.depth() == CV_32F || tvecs.depth() == CV_64F);
+        CV_Assert((tvecs.rows == nimages && tvecs.cols * cn == 3) ||
+                  (tvecs.rows == 1 && tvecs.cols == nimages && cn == 3));
+    }
+
+    CV_Assert(cameraMatrix.type() == CV_32F || cameraMatrix.type() == CV_64F);
+    CV_Assert(cameraMatrix.rows == 3 && cameraMatrix.cols == 3);
+
+    CV_Assert(distCoeffs.type() == CV_32F || distCoeffs.type() == CV_64F);
+    CV_Assert(distCoeffs.rows == 1 || distCoeffs.cols == 1);
+    CV_Assert(ndistCoeffs == 4 || ndistCoeffs == 5 || ndistCoeffs == 8 ||
+              ndistCoeffs == 12 || ndistCoeffs == 14);
+
+    int total = 0, maxPoints = 0;
+    for(int i = 0; i < nimages; i++ )
+    {
+        int ni = npoints.at<int>(i);
+        if( ni < 4 )
+        {
+            CV_Error_( cv::Error::StsOutOfRange, ("The number of points in the view #%d is < 4", i));
+        }
+        maxPoints = MAX( maxPoints, ni );
+        total += ni;
+    }
+
+    if( !newObjPoints.empty() )
+    {
+        int cn = newObjPoints.channels();
+        CV_Assert(newObjPoints.depth() == CV_32F || newObjPoints.depth() == CV_64F);
+        CV_Assert((newObjPoints.rows == maxPoints && newObjPoints.cols*cn == 3) ||
+                  (newObjPoints.rows == 1 && newObjPoints.cols == maxPoints && cn == 3));
+    }
+
+    if( !stdDevs.empty() )
+    {
+        int cn = stdDevs.channels();
+        CV_Assert(stdDevs.depth() == CV_32F || stdDevs.depth() == CV_64F);
+        int nstddev = nimages*6 + NINTRINSIC + (releaseObject ? maxPoints*3 : 0);
+
+        CV_Assert((stdDevs.rows == nstddev && stdDevs.cols*cn == 1) ||
+                  (stdDevs.rows == 1 && stdDevs.cols == nstddev && cn == 1));
+    }
+
+    Mat matM( 1, total, CV_64FC3 );
+    Mat _m( 1, total, CV_64FC2 );
+    Mat allErrors(1, total, CV_64FC2);
+
+    if (objectPoints.channels() == 3)
+    {
+        objectPoints.convertTo(matM, CV_64F);
+    }else
+    {
+        convertPointsToHomogeneous(objectPoints, matM);
+        matM.convertTo(matM, CV_64F);
+    }
+
+    if (imagePoints.channels() == 2)
+    {
+        imagePoints.convertTo(_m, CV_64F);
+    }else
+    {
+        convertPointsFromHomogeneous(imagePoints, _m);
+        _m.convertTo(_m, CV_64F);
+    }
+
+    int nparams = NINTRINSIC + nimages*6;
+    if( releaseObject )
+        nparams += maxPoints * 3;
+
+    std::vector<double> k(14, 0.0);
+    Mat _k( distCoeffs.rows, distCoeffs.cols, CV_64F, k.data());
+    if( distCoeffs.total() < 8 )
+    {
+        if( distCoeffs.total() < 5 )
+            flags |= CALIB_FIX_K3;
+        flags |= CALIB_FIX_K4 | CALIB_FIX_K5 | CALIB_FIX_K6;
+    }
+    const double minValidAspectRatio = 0.01;
+    const double maxValidAspectRatio = 100.0;
+
+    Matx33d A;
+    cameraMatrix.convertTo(A, CV_64F);
+
+    // 1. initialize intrinsic parameters & LM solver
+    if( flags & CALIB_USE_INTRINSIC_GUESS )
+    {
+        if( A(0, 0) <= 0 || A(1, 1) <= 0 )
+            CV_Error( cv::Error::StsOutOfRange, "Focal length (fx and fy) must be positive" );
+        if( A(0, 2) < 0 || A(0, 2) >= imageSize.width ||
+            A(1, 2) < 0 || A(1, 2) >= imageSize.height )
+            CV_Error( cv::Error::StsOutOfRange, "Principal point must be within the image" );
+        if( fabs(A(0, 1)) > 1e-5 )
+            CV_Error( cv::Error::StsOutOfRange, "Non-zero skew is not supported by the function" );
+        if( fabs(A(1, 0)) > 1e-5 || fabs(A(2, 0)) > 1e-5 ||
+            fabs(A(2, 1)) > 1e-5 || fabs(A(2,2)-1) > 1e-5 )
+            CV_Error( cv::Error::StsOutOfRange,
+                "The intrinsic matrix must have [fx 0 cx; 0 fy cy; 0 0 1] shape" );
+        A(0, 1) = A(1, 0) = A(2, 0) = A(2, 1) = 0.;
+        A(2, 2) = 1.;
+
+        if (flags & CALIB_FIX_ASPECT_RATIO)
+        {
+            aspectRatio = A(0, 0) / A(1, 1);
+            if (aspectRatio < minValidAspectRatio || aspectRatio > maxValidAspectRatio)
+            {
+                CV_Error(cv::Error::StsOutOfRange,
+                    "The specified aspect ratio (= cameraMatrix[0][0] / cameraMatrix[1][1]) is incorrect");
+            }
+        }
+        distCoeffs.convertTo(_k, CV_64F);
+    }else
+    {
+        Scalar mean, sdv;
+        meanStdDev(matM, mean, sdv);
+        if (fabs(mean[2]) > 1e-5 || fabs(sdv[2]) > 1e-5)
+        {
+            CV_Error(cv::Error::StsBadArg,
+            "For non-planar calibration rigs the initial intrinsic matrix must be specified");
+        }
+        for (int i = 0; i < total; i++)
+        {
+            matM.at<Point3d>(i).z = 0.;
+        }
+
+        if (flags & CALIB_FIX_ASPECT_RATIO)
+        {
+            aspectRatio = A(0, 0);
+            aspectRatio /= A(1, 1);
+            if (aspectRatio < minValidAspectRatio || aspectRatio > maxValidAspectRatio)
+            {
+                CV_Error(cv::Error::StsOutOfRange,
+                    "The specified aspect ratio (= cameraMatrix[0][0] / cameraMatrix[1][1]) is incorrect");
+            }
+        }
+        initIntrinsicParams2D(matM, _m, npoints, imageSize, A, aspectRatio);
+    }
+
+    SchurLMSolver solver;
+    solver.init(nimages, NINTRINSIC, releaseObject ? maxPoints : 0, termCrit);
+    if (flags & CALIB_USE_LU)
+        solver.setSolveMethod(cv::DECOMP_LU);
+    else if (flags & CALIB_USE_QR)
+        solver.setSolveMethod(cv::DECOMP_QR);
+
+    Mat_<double> param_m(nparams, 1);
+    std::vector<uchar> mask_vec(nparams, 1);
+
+    param_m(0) = A(0, 0); param_m(1) = A(1, 1); param_m(2) = A(0, 2); param_m(3) = A(1, 2);
+    for (int i = 0; i < 14; i++)
+        param_m(4 + i) = k[i];
+
+    if (flags & CALIB_FIX_ASPECT_RATIO)
+        mask_vec[0] = 0;
+    if (flags & CALIB_FIX_FOCAL_LENGTH)
+        mask_vec[0] = mask_vec[1] = 0;
+    if (flags & CALIB_FIX_PRINCIPAL_POINT)
+        mask_vec[2] = mask_vec[3] = 0;
+    if (flags & CALIB_ZERO_TANGENT_DIST)
+    {
+        param_m(6) = param_m(7) = 0;
+        mask_vec[6] = mask_vec[7] = 0;
+    }
+    if (!(flags & CALIB_RATIONAL_MODEL))
+        flags |= CALIB_FIX_K4 + CALIB_FIX_K5 + CALIB_FIX_K6;
+    if (!(flags & CALIB_THIN_PRISM_MODEL))
+        flags |= CALIB_FIX_S1_S2_S3_S4;
+    if (!(flags & CALIB_TILTED_MODEL))
+        flags |= CALIB_FIX_TAUX_TAUY;
+
+    mask_vec[4] = !(flags & CALIB_FIX_K1);
+    mask_vec[5] = !(flags & CALIB_FIX_K2);
+    if (flags & CALIB_FIX_TANGENT_DIST)
+        mask_vec[6] = mask_vec[7] = 0;
+    mask_vec[8] = !(flags & CALIB_FIX_K3);
+    mask_vec[9] = !(flags & CALIB_FIX_K4);
+    mask_vec[10] = !(flags & CALIB_FIX_K5);
+    mask_vec[11] = !(flags & CALIB_FIX_K6);
+
+    if (flags & CALIB_FIX_S1_S2_S3_S4)
+    {
+        mask_vec[12] = 0;
+        mask_vec[13] = 0;
+        mask_vec[14] = 0;
+        mask_vec[15] = 0;
+    }
+
+    if (flags & CALIB_USE_INTRINSIC_GUESS)
+    {
+        CV_Assert(nparams == NINTRINSIC + nimages * 6);
+    }
+
+    if (flags & CALIB_FIX_ASPECT_RATIO)
+    {
+        mask_vec[0] = 0;
+        if (aspectRatio <= 0)
+            CV_Error(Error::StsBadArg, "CALIB_FIX_ASPECT_RATIO is set but aspectRatio is not positive");
+    }
+
+    if (flags & CALIB_FIX_TAUX_TAUY)
+    {
+        mask_vec[16] = mask_vec[17] = 0;
+    }
+
+    if (releaseObject)
+    {
+        int s = NINTRINSIC + nimages * 6;
+        std::copy(matM.ptr<double>(), matM.ptr<double>(0, maxPoints - 1) + 3,
+                  param_m.ptr<double>() + s);
+        mask_vec[s + 0] = 0;
+        mask_vec[s + 1] = 0;
+        mask_vec[s + 2] = 0;
+        mask_vec[s + iFixedPoint * 3 + 0] = 0;
+        mask_vec[s + iFixedPoint * 3 + 1] = 0;
+        mask_vec[s + iFixedPoint * 3 + 2] = 0;
+        mask_vec[nparams - 1] = 0;
+    }
+
+    Mat mask(mask_vec);
+    int nparams_nz = countNonZero(mask);
+
+    if (nparams_nz >= 2 * total)
+    {
+        CV_Error_(Error::StsBadArg,
+                  ("There should be less vars to optimize (having %d) than the "
+                   "number of residuals (%d = 2 per point)", nparams_nz, 2 * total));
+    }
+
+    // 2. initialize extrinsic parameters
+    for(int i = 0, pos = 0; i < nimages; i++ )
+    {
+        int ni = npoints.at<int>(i);
+
+        int s = NINTRINSIC + i*6;
+        Mat _ri = param_m.rowRange(s, s + 3);
+        Mat _ti = param_m.rowRange(s + 3, s + 6);
+
+        Mat _Mi = matM.colRange(pos, pos + ni);
+        Mat _mi = _m.colRange(pos, pos + ni);
+
+        solvePnP(_Mi, _mi, A, _k, _ri, _ti, false);
+
+        pos += ni;
+    }
+
+    // 3. run the optimization
+    Mat_<double> prev_param = param_m.clone();
+    Mutex globalMutex;
+
+    // Compute initial error
+    Mat allErrorsBuf(1, total, CV_64FC2);
+    reprojErr = 0;
+    int so = NINTRINSIC + nimages * 6;
+    int pos = 0;
+    for (int i = 0; i < nimages; i++)
+    {
+        int ni = npoints.at<int>(i);
+        int si = NINTRINSIC + i * 6;
+
+        Mat _ri = param_m.rowRange(si, si + 3);
+        Mat _ti = param_m.rowRange(si + 3, si + 6);
+
+        Mat _Mi = matM.colRange(pos, pos + ni);
+        if (releaseObject)
+        {
+            _Mi = param_m.rowRange(so, so + ni * 3);
+            _Mi = _Mi.reshape(3, 1);
+        }
+        Mat _mi = _m.colRange(pos, pos + ni);
+        Mat _me = allErrorsBuf.colRange(pos, pos + ni);
+
+        double fx = param_m(0), fy = param_m(1), cx = param_m(2), cy = param_m(3);
+        if (flags & CALIB_FIX_ASPECT_RATIO)
+            fx = fy * aspectRatio;
+        Matx33d intrin(fx, 0, cx, 0, fy, cy, 0, 0, 1);
+        Mat dist = param_m.rowRange(4, 4 + 14);
+
+        projectPoints(_Mi, _ri, _ti, intrin, dist, _me);
+        subtract(_me, _mi, _me);
+
+        reprojErr += norm(_me, NORM_L2SQR);
+        pos += ni;
+    }
+
+    bool recomputeFinalErrors = (termCrit.maxCount == 0);
+    bool jacobianAtCurrentParams = false;
+    if (termCrit.maxCount > 0)
+    {
+        const auto computeStep = [&solver, &mask]()
+        {
+            for (;;)
+            {
+                if (solver.step(mask))
+                    return true;
+                if (++solver.lambdaLg10 > 16)
+                    return false;
+            }
+        };
+
+        solver.reset();
+
+        parallel_for_(Range(0, nimages),
+                      JAccumulator(solver, matM, _m, npoints, param_m,
+                                   flags, aspectRatio, NINTRINSIC,
+                                   releaseObject, maxPoints, globalMutex));
+        jacobianAtCurrentParams = true;
+        // JAccumulator acc(solver, matM, _m, npoints, param_m,
+        //                         flags, aspectRatio, NINTRINSIC,
+        //                         releaseObject, maxPoints, globalMutex);
+        // acc(Range(0, nimages));
+        double prevErr = reprojErr;
+        if (!computeStep())
+        {
+            recomputeFinalErrors = true;
+        }
+        else
+        {
+            // Apply the initial step
+            param_m.copyTo(prev_param);
+            // 1. Global parameters (Intrinsics + Objects)
+            for (int kk = 0; kk < NINTRINSIC; kk++)
+                param_m(kk) -= solver.getGlobalUpdate().at<double>(kk);
+
+            if (releaseObject)
+            {
+                 int param_obj_start = NINTRINSIC + nimages * 6;
+                 int num_obj_params = solver.n_global - NINTRINSIC;
+                 for (int kk = 0; kk < num_obj_params; kk++)
+                     param_m(param_obj_start + kk) -= solver.getGlobalUpdate().at<double>(NINTRINSIC + kk);
+            }
+            for (int i = 0; i < nimages; i++)
+            {
+                int si = NINTRINSIC + i * 6;
+                for (int kk = 0; kk < 6; kk++)
+                    param_m(si + kk) -= solver.getLocalUpdate(i).at<double>(kk);
+            }
+        }
+        jacobianAtCurrentParams = false;
+        for (int iter = 0; !recomputeFinalErrors && iter < termCrit.maxCount; iter++)
+        {
+            if (flags & CALIB_FIX_ASPECT_RATIO)
+            {
+                param_m(0) = param_m(1) * aspectRatio;
+            }
+
+            reprojErr = 0;
+            int pos_iter = 0;
+            for (int i = 0; i < nimages; i++)
+            {
+                int ni = npoints.at<int>(i);
+                int si = NINTRINSIC + i * 6;
+
+                Mat _ri = param_m.rowRange(si, si + 3);
+                Mat _ti = param_m.rowRange(si + 3, si + 6);
+
+                Mat _Mi = matM.colRange(pos_iter, pos_iter + ni);
+                if (releaseObject)
+                {
+                    _Mi = param_m.rowRange(so, so + ni * 3).reshape(3, 1);
+                }
+                Mat _mi = _m.colRange(pos_iter, pos_iter + ni);
+                Mat _me = allErrorsBuf.colRange(pos_iter, pos_iter + ni);
+
+                double fx = param_m(0), fy = param_m(1), cx = param_m(2), cy = param_m(3);
+                Matx33d intrin(fx, 0, cx, 0, fy, cy, 0, 0, 1);
+                Mat dist = param_m.rowRange(4, 4 + 14);
+
+                projectPoints(_Mi, _ri, _ti, intrin, dist, _me);
+                subtract(_me, _mi, _me);
+
+                double viewErr = norm(_me, NORM_L2SQR);
+                if (!perViewErr.empty())
+                {
+                    perViewErr.at<double>(i) = std::sqrt(viewErr / ni);
+                }
+                reprojErr += viewErr;
+                pos_iter += ni;
+            }
+
+            // Accept or reject the step
+            if (reprojErr < prevErr)
+            {
+                // Step accepted
+                solver.lambdaLg10 = std::max(solver.lambdaLg10 - 1, -16);
+                prevErr = reprojErr;
+
+                // Check convergence BEFORE saving new prev_param
+                double paramChange = norm(param_m, prev_param, NORM_L2) /
+                                     (norm(prev_param, NORM_L2) + DBL_EPSILON);
+                param_m.copyTo(prev_param);
+                if (paramChange < termCrit.epsilon)
+                {
+                    break;
+                }
+
+                // Compute new Jacobian at new position
+                solver.reset();
+                parallel_for_(Range(0, nimages),
+                              JAccumulator(solver, matM, _m, npoints, param_m,
+                                           flags, aspectRatio, NINTRINSIC,
+                                           releaseObject, maxPoints, globalMutex));
+                jacobianAtCurrentParams = true;
+            }
+            else
+            {
+                // Step rejected, increase lambda and recompute step
+                if (++solver.lambdaLg10 > 16)
+                {
+                    // Lambda exhausted, restore best params
+                    prev_param.copyTo(param_m);
+                    recomputeFinalErrors = true;
+                    break;
+                }
+
+                // Revert params
+                prev_param.copyTo(param_m);
+            }
+
+            // Compute step (possibly with new lambda)
+            if (!computeStep())
+            {
+                prev_param.copyTo(param_m);
+                recomputeFinalErrors = true;
+                break;
+            }
+
+            // Apply step. Update layouts:
+            // deltaGlobal: [Intrinsics (0..NINTRINSIC-1) | Object points (NINTRINSIC..n_global-1)]
+            // param_m: [Intrinsics | Extrinsic parameters | Object points]
+
+            // Apply Intrinsics update
+            for (int kk = 0; kk < NINTRINSIC; kk++)
+            {
+                param_m(kk) -= solver.getGlobalUpdate().at<double>(kk);
+            }
+
+            // Apply Objects update (if any)
+            if (releaseObject)
+            {
+                 int param_obj_start = NINTRINSIC + nimages * 6;
+                 int num_obj_params = solver.n_global - NINTRINSIC;
+                 for (int kk = 0; kk < num_obj_params; kk++)
+                 {
+                     param_m(param_obj_start + kk) -= solver.getGlobalUpdate().at<double>(NINTRINSIC + kk);
+                 }
+            }
+
+            // Apply Local parameters (Extrinsics)
+            for (int i = 0; i < nimages; i++)
+            {
+                int si = NINTRINSIC + i * 6;
+                for (int kk = 0; kk < 6; kk++)
+                    param_m(si + kk) -= solver.getLocalUpdate(i).at<double>(kk);
+            }
+            jacobianAtCurrentParams = false;
+        }
+        if (!recomputeFinalErrors)
+        {
+            prev_param.copyTo(param_m);
+            recomputeFinalErrors = true;
+        }
+    }
+
+    if (flags & CALIB_FIX_ASPECT_RATIO)
+    {
+        param_m(0) = param_m(1) * aspectRatio;
+    }
+
+    Mat finalErrorsBuf;
+    if (recomputeFinalErrors)
+    {
+        Mat* errorsPtr = &allErrorsBuf;
+        if (!stdDevs.empty())
+        {
+            finalErrorsBuf.create(1, total, CV_64FC2);
+            errorsPtr = &finalErrorsBuf;
+        }
+
+        Mat& errors = *errorsPtr;
+        reprojErr = 0;
+        pos = 0;
+        for (int i = 0; i < nimages; i++)
+        {
+            int ni = npoints.at<int>(i);
+            int si = NINTRINSIC + i * 6;
+
+            Mat _ri = param_m.rowRange(si, si + 3);
+            Mat _ti = param_m.rowRange(si + 3, si + 6);
+
+            Mat _Mi = matM.colRange(pos, pos + ni);
+            if (releaseObject)
+            {
+                _Mi = param_m.rowRange(so, so + ni * 3).reshape(3, 1);
+            }
+            Mat _mi = _m.colRange(pos, pos + ni);
+            Mat _me = errors.colRange(pos, pos + ni);
+
+            double fx = param_m(0), fy = param_m(1), cx = param_m(2), cy = param_m(3);
+            Matx33d intrin(fx, 0, cx, 0, fy, cy, 0, 0, 1);
+            Mat dist = param_m.rowRange(4, 4 + 14);
+
+            projectPoints(_Mi, _ri, _ti, intrin, dist, _me);
+            subtract(_me, _mi, _me);
+
+            double viewErr = norm(_me, NORM_L2SQR);
+            if (!perViewErr.empty())
+            {
+                perViewErr.at<double>(i) = std::sqrt(viewErr / ni);
+            }
+            reprojErr += viewErr;
+            pos += ni;
+        }
+    }
+
+    if (!stdDevs.empty())
+    {
+        if (!jacobianAtCurrentParams)
+        {
+            solver.reset();
+            parallel_for_(Range(0, nimages),
+                          JAccumulator(solver, matM, _m, npoints, param_m,
+                                       flags, aspectRatio, NINTRINSIC,
+                                       releaseObject, maxPoints, globalMutex));
+            jacobianAtCurrentParams = true;
+        }
+        Mat JtJ = Mat::zeros(nparams, nparams, CV_64F);
+
+        // Manual copy for U to avoid assertion
+        Mat srcU = solver.U(Rect(0, 0, NINTRINSIC, NINTRINSIC));
+        Mat dstU = JtJ(Rect(0, 0, NINTRINSIC, NINTRINSIC));
+        for(int r=0; r<srcU.rows; r++) {
+            const double* sptr = srcU.ptr<double>(r);
+            double* dptr = dstU.ptr<double>(r);
+            for(int c=0; c<srcU.cols; c++) dptr[c] = sptr[c];
+        }
+
+        for (int i = 0; i < nimages; i++)
+        {
+            int si = NINTRINSIC + i * 6;
+            // Manual copy for V[i]
+            Mat srcV = solver.V[i];
+            Mat dstV = JtJ(Rect(si, si, 6, 6));
+            for(int r=0; r<srcV.rows; r++) {
+                const double* sptr = srcV.ptr<double>(r);
+                double* dptr = dstV.ptr<double>(r);
+                for(int c=0; c<srcV.cols; c++) dptr[c] = sptr[c];
+            }
+
+            Mat srcW = solver.W[i].rowRange(0, NINTRINSIC);
+            Mat dstJ = JtJ(Rect(si, 0, 6, NINTRINSIC));
+
+            // Manual copy for W part
+            srcW.copyTo(dstJ);
+        }
+
+        if (releaseObject)
+        {
+            int obj_start = NINTRINSIC + nimages * 6;
+
+            // Manual copy for U (extended) parts
+            // Top-right block
+            Mat srcU_tr = solver.U(Rect(NINTRINSIC, 0, maxPoints * 3, NINTRINSIC));
+            Mat dstU_tr = JtJ(Rect(obj_start, 0, maxPoints * 3, NINTRINSIC));
+            srcU_tr.copyTo(dstU_tr);
+
+            // Bottom-right block
+            Mat srcU_br = solver.U(Rect(NINTRINSIC, NINTRINSIC, maxPoints * 3, maxPoints * 3));
+            Mat dstU_br = JtJ(Rect(obj_start, obj_start, maxPoints * 3, maxPoints * 3));
+            srcU_br.copyTo(dstU_br);
+
+            for (int i = 0; i < nimages; i++)
+            {
+                int si = NINTRINSIC + i * 6;
+                // Manual copy for W extended part
+                Mat srcW_ext = solver.W[i].rowRange(NINTRINSIC, solver.W[i].rows);
+                Mat dstJ_ext = JtJ(Rect(obj_start, si, maxPoints * 3, 6));
+                cv::transpose(srcW_ext, dstJ_ext);
+            }
+        }
+
+        completeSymm(JtJ, false);
+
+        Mat JtJinv, JtJN;
+        JtJN.create(nparams_nz, nparams_nz, CV_64F);
+        std::vector<uchar> mask_copy(mask.ptr<uchar>(), mask.ptr<uchar>() + nparams);
+        subMatrix(JtJ, JtJN, mask_copy, mask_copy);
+        completeSymm(JtJN, false);
+        cv::invert(JtJN, JtJinv, DECOMP_SVD);
+
+        int nErrors = 2 * total - nparams_nz;
+        const Mat& errorsForStats = finalErrorsBuf.empty() ? allErrorsBuf : finalErrorsBuf;
+        double sigma2 = norm(errorsForStats, NORM_L2SQR) / nErrors;
+
+        int j = 0;
+        for (int s = 0; s < nparams; s++)
+        {
+            stdDevs.at<double>(s) = mask.at<uchar>(s) ?
+                std::sqrt(JtJinv.at<double>(j, j) * sigma2) : 0.0;
+            if (mask.at<uchar>(s))
+            {
+                j++;
+            }
+        }
+    }
+
+    // Store optimization results
+    A = Matx33d(param_m(0), 0, param_m(2), 0, param_m(1), param_m(3), 0, 0, 1);
+    Mat(A).convertTo(cameraMatrix, cameraMatrix.type());
+
+    _k = Mat(distCoeffs.size(), CV_64F, param_m.ptr<double>() + 4);
+    _k.convertTo(distCoeffs, distCoeffs.type());
+
+
+    if (!newObjPoints.empty() && releaseObject)
+    {
+        int s = NINTRINSIC + nimages * 6;
+        Mat _Mi = param_m.rowRange(s, s + maxPoints * 3);
+        _Mi.reshape(3, 1).convertTo(newObjPoints, newObjPoints.type());
+
+    }
+    for (int i = 0; i < nimages; i++)
+    {
+        if (!rvecs.empty())
+        {
+            Mat src = param_m.rowRange(NINTRINSIC + i * 6, NINTRINSIC + i * 6 + 3);
+            if (rvecs.rows == nimages && rvecs.cols * rvecs.channels() == 9)
+            {
+                Mat dst(3, 3, rvecs.depth(), rvecs.ptr(i));
+                Rodrigues(src, A);
+                Mat(A).convertTo(dst, dst.type());
+            }
+            else
+            {
+                Mat dst(3, 1, rvecs.depth(), rvecs.rows == 1 ?
+                    rvecs.data + i * rvecs.elemSize() : rvecs.ptr(i));
+                src.convertTo(dst, dst.type());
+            }
+        }
+        if (!tvecs.empty())
+        {
+            Mat src = param_m.rowRange(NINTRINSIC + i * 6 + 3, NINTRINSIC + i * 6 + 6);
+            Mat dst(3, 1, tvecs.depth(), tvecs.rows == 1 ?
+                    tvecs.data + i * tvecs.elemSize() : tvecs.ptr(i));
+            src.convertTo(dst, dst.type());
+        }
+    }
+    return std::sqrt(reprojErr/total);
+}
+
+//////////////////////////////// Stereo Calibration ///////////////////////////////////
+
+static double stereoCalibrateImpl(
+        const Mat& _objectPoints, const Mat& _imagePoints1,
+        const Mat& _imagePoints2, const Mat& _npoints,
+        Mat& _cameraMatrix1, Mat& _distCoeffs1,
+        Mat& _cameraMatrix2, Mat& _distCoeffs2,
+        Size imageSize, Mat matR, Mat matT,
+        Mat matE, Mat matF,
+        Mat rvecs, Mat tvecs,
+        Mat perViewErr, int flags,
+        TermCriteria termCrit )
+{
+    int NINTRINSIC = CALIB_NINTRINSIC;
+
+    // initial camera intrinsicss
+    Vec<double, 14> distInitial[2];
+    Matx33d A[2];
+    int pointsTotal = 0, maxPoints = 0, nparams;
+    bool recomputeIntrinsics = false;
+    double aspectRatio[2] = {0, 0};
+
+    CV_Assert( _imagePoints1.type() == _imagePoints2.type() &&
+               _imagePoints1.depth() == _objectPoints.depth() );
+
+    CV_Assert( (_npoints.cols == 1 || _npoints.rows == 1) &&
+                _npoints.type() == CV_32S );
+
+    int nimages = (int)_npoints.total();
+    for(int i = 0; i < nimages; i++ )
+    {
+        int ni = _npoints.at<int>(i);
+        maxPoints = std::max(maxPoints, ni);
+        pointsTotal += ni;
+    }
+
+    Mat objectPoints;
+    Mat imagePoints[2];
+    _objectPoints.convertTo(objectPoints, CV_64F);
+    objectPoints = objectPoints.reshape(3, 1);
+
+    if( !rvecs.empty() )
+    {
+        int cn = rvecs.channels();
+        int depth = rvecs.depth();
+        if( (depth != CV_32F && depth != CV_64F) ||
+            ((rvecs.rows != nimages || (rvecs.cols*cn != 3 && rvecs.cols*cn != 9)) &&
+             (rvecs.rows != 1 || rvecs.cols != nimages || cn != 3)) )
+            CV_Error( cv::Error::StsBadArg, "the output array of rotation vectors must be 3-channel "
+                "1xn or nx1 array or 1-channel nx3 or nx9 array, where n is the number of views" );
+    }
+    if( !tvecs.empty() )
+    {
+        int cn = tvecs.channels();
+        int depth = tvecs.depth();
+        if( (depth != CV_32F && depth != CV_64F) ||
+            ((tvecs.rows != nimages || tvecs.cols*cn != 3) &&
+             (tvecs.rows != 1 || tvecs.cols != nimages || cn != 3)) )
+            CV_Error( cv::Error::StsBadArg, "the output array of translation vectors must be 3-channel "
+                "1xn or nx1 array or 1-channel nx3 array, where n is the number of views" );
+    }
+
+    for(int k = 0; k < 2; k++ )
+    {
+        const Mat& points = k == 0 ? _imagePoints1 : _imagePoints2;
+        const Mat& cameraMatrix = k == 0 ? _cameraMatrix1 : _cameraMatrix2;
+        const Mat& distCoeffs = k == 0 ? _distCoeffs1 : _distCoeffs2;
+
+        int depth = points.depth();
+        int cn = points.channels();
+        CV_Assert( (depth == CV_32F || depth == CV_64F) &&
+                   ((points.rows == pointsTotal && points.cols*cn == 2) ||
+                   (points.rows == 1 && points.cols == pointsTotal && cn == 2)));
+
+        A[k] = Matx33d::eye();
+
+        points.convertTo(imagePoints[k], CV_64F);
+        imagePoints[k] = imagePoints[k].reshape(2, 1);
+
+        if( flags & ( CALIB_FIX_INTRINSIC | CALIB_USE_INTRINSIC_GUESS |
+                      CALIB_FIX_ASPECT_RATIO | CALIB_FIX_FOCAL_LENGTH ) )
+            cameraMatrix.convertTo(A[k], CV_64F);
+
+        if( flags & ( CALIB_FIX_INTRINSIC | CALIB_USE_INTRINSIC_GUESS |
+                      CALIB_FIX_K1 | CALIB_FIX_K2 | CALIB_FIX_K3 | CALIB_FIX_K4 | CALIB_FIX_K5 | CALIB_FIX_K6 |
+                      CALIB_FIX_TANGENT_DIST) )
+        {
+            Mat tdist( distCoeffs.size(), CV_MAKETYPE(CV_64F, distCoeffs.channels()), distInitial[k].val);
+            distCoeffs.convertTo(tdist, CV_64F);
+        }
+
+        if( !(flags & (CALIB_FIX_INTRINSIC | CALIB_USE_INTRINSIC_GUESS)))
+        {
+            Mat mIntr(A[k], /* copyData = */ false);
+            Mat mDist(distInitial[k], /* copyData = */ false);
+            if( flags & CALIB_DISABLE_SCHUR_COMPLEMENT )
+                calibrateCameraInternalBouguet(objectPoints, imagePoints[k],
+                                               _npoints, imageSize, 0, mIntr, mDist,
+                                               Mat(), Mat(), Mat(), Mat(), Mat(), flags, termCrit);
+            else
+                calibrateCameraInternalSchur(objectPoints, imagePoints[k],
+                                             _npoints, imageSize, 0, mIntr, mDist,
+                                             Mat(), Mat(), Mat(), Mat(), Mat(), flags, termCrit);
+        }
+    }
+
+    if( flags & CALIB_SAME_FOCAL_LENGTH )
+    {
+        A[0](0, 0) = A[1](0, 0) = (A[0](0, 0) + A[1](0, 0))*0.5;
+        A[0](0, 2) = A[1](0, 2) = (A[0](0, 2) + A[1](0, 2))*0.5;
+        A[0](1, 1) = A[1](1, 1) = (A[0](1, 1) + A[1](1, 1))*0.5;
+        A[0](1, 2) = A[1](1, 2) = (A[0](1, 2) + A[1](1, 2))*0.5;
+    }
+
+    if( flags & CALIB_FIX_ASPECT_RATIO )
+    {
+        for(int k = 0; k < 2; k++ )
+            aspectRatio[k] = A[k](0, 0) / A[k](1, 1);
+    }
+
+    recomputeIntrinsics = (flags & CALIB_FIX_INTRINSIC) == 0;
+
+    // we optimize for the inter-camera R(3),t(3), then, optionally,
+    // for intrinisic parameters of each camera ((fx,fy,cx,cy,k1,k2,p1,p2) ~ 8 parameters).
+    // Param mapping is:
+    // - from 0 next 6: stereo pair Rt, from 6+i*6 next 6: Rt for each ith camera of nimages,
+    // - from 6*(nimages+1) next NINTRINSICS: intrinsics for 1st camera: fx, fy, cx, cy, 14 x dist
+    // - next NINTRINSICS: the same for for 2nd camera
+    nparams = 6*(nimages+1) + (recomputeIntrinsics ? NINTRINSIC*2 : 0);
+
+    std::vector<uchar> mask(nparams, (uchar)1);
+
+    std::vector<double> param(nparams, 0.);
+
+    if( recomputeIntrinsics )
+    {
+        size_t idx = nparams - NINTRINSIC*2;
+        if( !(flags & CALIB_RATIONAL_MODEL) )
+            flags |= CALIB_FIX_K4 | CALIB_FIX_K5 | CALIB_FIX_K6;
+        if( !(flags & CALIB_THIN_PRISM_MODEL) )
+            flags |= CALIB_FIX_S1_S2_S3_S4;
+        if( !(flags & CALIB_TILTED_MODEL) )
+            flags |= CALIB_FIX_TAUX_TAUY;
+        if( flags & CALIB_FIX_ASPECT_RATIO )
+            mask[idx + 0] = mask[idx + NINTRINSIC] = 0;
+        if ( flags & CALIB_SAME_FOCAL_LENGTH)
+            mask[idx + NINTRINSIC] = mask[idx + NINTRINSIC + 1] = 0;
+        if( flags & CALIB_FIX_FOCAL_LENGTH )
+            mask[idx + 0] = mask[idx + 1] = mask[idx + NINTRINSIC] = mask[idx + NINTRINSIC+1] = 0;
+        if( flags & CALIB_FIX_PRINCIPAL_POINT )
+            mask[idx + 2] = mask[idx + 3] = mask[idx + NINTRINSIC+2] = mask[idx + NINTRINSIC+3] = 0;
+        if( flags & (CALIB_ZERO_TANGENT_DIST|CALIB_FIX_TANGENT_DIST) )
+            mask[idx + 6] = mask[idx + 7] = mask[idx + NINTRINSIC+6] = mask[idx + NINTRINSIC+7] = 0;
+        if( flags & CALIB_FIX_K1 )
+            mask[idx + 4] = mask[idx + NINTRINSIC+4] = 0;
+        if( flags & CALIB_FIX_K2 )
+            mask[idx + 5] = mask[idx + NINTRINSIC+5] = 0;
+        if( flags & CALIB_FIX_K3 )
+            mask[idx + 8] = mask[idx + NINTRINSIC+8] = 0;
+        if( flags & CALIB_FIX_K4 )
+            mask[idx + 9] = mask[idx + NINTRINSIC+9] = 0;
+        if( flags & CALIB_FIX_K5 )
+            mask[idx + 10] = mask[idx + NINTRINSIC+10] = 0;
+        if( flags & CALIB_FIX_K6 )
+            mask[idx + 11] = mask[idx + NINTRINSIC+11] = 0;
+        if( flags & CALIB_FIX_S1_S2_S3_S4 )
+        {
+            mask[idx + 12] = mask[idx + NINTRINSIC+12] = 0;
+            mask[idx + 13] = mask[idx + NINTRINSIC+13] = 0;
+            mask[idx + 14] = mask[idx + NINTRINSIC+14] = 0;
+            mask[idx + 15] = mask[idx + NINTRINSIC+15] = 0;
+        }
+        if( flags & CALIB_FIX_TAUX_TAUY )
+        {
+            mask[idx + 16] = mask[idx + NINTRINSIC+16] = 0;
+            mask[idx + 17] = mask[idx + NINTRINSIC+17] = 0;
+        }
+    }
+
+    // storage for initial [om(R){i}|t{i}] (in order to compute the median for each component)
+    std::vector<double> rtsort(nimages*6);
+    /*
+       Compute initial estimate of pose
+       For each image, compute:
+          R(om) is the rotation matrix of om
+          om(R) is the rotation vector of R
+          R_ref = R(om_right) * R(om_left)'
+          T_ref_list = [T_ref_list; T_right - R_ref * T_left]
+          om_ref_list = {om_ref_list; om(R_ref)]
+       om = median(om_ref_list)
+       T = median(T_ref_list)
+    */
+    int pos = 0;
+    for(int i = 0; i < nimages; i++ )
+    {
+        int ni = _npoints.at<int>(i);
+        Mat objpt_i = objectPoints.colRange(pos, pos + ni);
+        Matx33d R[2];
+        Vec3d rv, T[2];
+        for(int k = 0; k < 2; k++ )
+        {
+            Mat imgpt_ik = imagePoints[k].colRange(pos, pos + ni);
+            solvePnP(objpt_i, imgpt_ik, A[k], distInitial[k], rv, T[k], false, SOLVEPNP_ITERATIVE );
+            Rodrigues(rv, R[k]);
+
+            if( k == 0 )
+            {
+                // save initial om_left and T_left
+                param[(i+1)*6 + 0] = rv[0];
+                param[(i+1)*6 + 1] = rv[1];
+                param[(i+1)*6 + 2] = rv[2];
+                param[(i+1)*6 + 3] = T[0][0];
+                param[(i+1)*6 + 4] = T[0][1];
+                param[(i+1)*6 + 5] = T[0][2];
+            }
+        }
+        R[0] = R[1]*R[0].t();
+        T[1] -= R[0]*T[0];
+
+        Rodrigues(R[0], rv);
+
+        rtsort[i + nimages*0] = rv[0];
+        rtsort[i + nimages*1] = rv[1];
+        rtsort[i + nimages*2] = rv[2];
+        rtsort[i + nimages*3] = T[1][0];
+        rtsort[i + nimages*4] = T[1][1];
+        rtsort[i + nimages*5] = T[1][2];
+
+        pos += ni;
+    }
+
+    if(flags & CALIB_USE_EXTRINSIC_GUESS)
+    {
+        Vec3d R, T;
+        matT.convertTo(T, CV_64F);
+
+        if( matR.rows == 3 && matR.cols == 3 )
+            Rodrigues(matR, R);
+        else
+            matR.convertTo(R, CV_64F);
+
+        param[0] = R[0];
+        param[1] = R[1];
+        param[2] = R[2];
+        param[3] = T[0];
+        param[4] = T[1];
+        param[5] = T[2];
+    }
+    else
+    {
+        // find the medians and save the first 6 parameters
+        for(int i = 0; i < 6; i++ )
+        {
+            size_t idx = i*nimages;
+            std::nth_element(rtsort.begin() + idx,
+                             rtsort.begin() + idx + nimages/2,
+                             rtsort.begin() + idx + nimages);
+            double h = rtsort[idx + nimages/2];
+            param[i] = (nimages % 2 == 0) ? (h + rtsort[idx + nimages/2 - 1]) * 0.5 : h;
+        }
+    }
+
+    if( recomputeIntrinsics )
+    {
+        for(int k = 0; k < 2; k++ )
+        {
+            size_t idx = (nimages+1)*6 + k*NINTRINSIC;
+            if( flags & CALIB_ZERO_TANGENT_DIST )
+                distInitial[k][2] = distInitial[k][3] = 0;
+            param[idx +  0] = A[k](0, 0); param[idx + 1] = A[k](1, 1); param[idx + 2] = A[k](0, 2); param[idx + 3] = A[k](1, 2);
+            for (int i = 0; i < 14; i++)
+            {
+                param[idx + 4 + i] = distInitial[k][i];
+            }
+        }
+    }
+
+    // Preallocated place for callback calculations
+    Mat errBuf( maxPoints*2, 1, CV_64F );
+    Mat JeBuf( maxPoints*2, 6, CV_64F );
+    Mat J_LRBuf( maxPoints*2, 6, CV_64F );
+    Mat JiBuf( maxPoints*2, NINTRINSIC, CV_64F, Scalar(0) );
+
+    auto lmcallback = [&, recomputeIntrinsics, nimages, flags, NINTRINSIC, _npoints]
+                      (InputOutputArray _param, OutputArray JtErr_, OutputArray JtJ_, double& errnorm)
+    {
+        Mat_<double> param_m = _param.getMat();
+        Vec3d om_LR(param_m(0), param_m(1), param_m(2));
+        Vec3d T_LR(param_m(3), param_m(4), param_m(5));
+        Vec3d om[2], T[2];
+        Matx33d dr3dr1, dr3dr2, dt3dr2, dt3dt1, dt3dt2;
+        Matx33d intrin[2];
+        std::vector< std::vector<double> > distCoeffs(2, std::vector<double>(14, 0.0));
+
+        double reprojErr = 0;
+
+        if( recomputeIntrinsics )
+        {
+            int idx = (nimages+1)*6;
+
+            if( flags & CALIB_SAME_FOCAL_LENGTH )
+            {
+                param_m(idx + NINTRINSIC  ) = param_m(idx + 0);
+                param_m(idx + NINTRINSIC+1) = param_m(idx + 1);
+            }
+            if( flags & CALIB_FIX_ASPECT_RATIO )
+            {
+                param_m(idx + 0)          = aspectRatio[0]*param_m(idx + 1             );
+                param_m(idx + NINTRINSIC) = aspectRatio[1]*param_m(idx + 1 + NINTRINSIC);
+            }
+            for(int k = 0; k < 2; k++ )
+            {
+                double fx = param_m(idx + k*NINTRINSIC+0), fy = param_m(idx + k*NINTRINSIC+1);
+                double cx = param_m(idx + k*NINTRINSIC+2), cy = param_m(idx + k*NINTRINSIC+3);
+                intrin[k] = Matx33d(fx,  0, cx,
+                                     0, fy, cy,
+                                     0,  0,  1);
+                for(int j = 0; j < 14; j++)
+                    distCoeffs[k][j] = param_m(idx + k*NINTRINSIC+4+j);
+            }
+        }
+        else
+        {
+            for (int k = 0; k < 2; k++)
+            {
+                intrin[k] = A[k];
+                for(int j = 0; j < 14; j++)
+                    distCoeffs[k][j] = distInitial[k][j];
+            }
+        }
+
+        int ptPos = 0;
+        for(int i = 0; i < nimages; i++ )
+        {
+            int ni = _npoints.at<int>(i);
+
+            int idx = (i+1)*6;
+            om[0] = Vec3d(param_m(idx + 0), param_m(idx + 1), param_m(idx + 2));
+            T[0]  = Vec3d(param_m(idx + 3), param_m(idx + 4), param_m(idx + 5));
+
+            if( JtJ_.needed() || JtErr_.needed() )
+                composeRT( om[0], T[0], om_LR, T_LR, om[1], T[1], dr3dr1, noArray(),
+                           dr3dr2, noArray(), noArray(), dt3dt1, dt3dr2, dt3dt2 );
+            else
+                composeRT( om[0], T[0], om_LR, T_LR, om[1], T[1] );
+
+            Mat objpt_i = objectPoints(Range::all(), Range(ptPos, ptPos + ni));
+            Mat err  = errBuf (Range(0, ni*2), Range::all());
+            Mat Je   = JeBuf  (Range(0, ni*2), Range::all());
+            Mat J_LR = J_LRBuf(Range(0, ni*2), Range::all());
+            Mat Ji   = JiBuf  (Range(0, ni*2), Range::all());
+
+            Mat tmpImagePoints = err.reshape(2, 1);
+            Mat dpdf = Ji.colRange(0, 2);
+            Mat dpdc = Ji.colRange(2, 4);
+            Mat dpdk = Ji.colRange(4, NINTRINSIC);
+            Mat dpdrot = Je.colRange(0, 3);
+            Mat dpdt = Je.colRange(3, 6);
+
+            for(int k = 0; k < 2; k++ )
+            {
+                Mat imgpt_ik = imagePoints[k](Range::all(), Range(ptPos, ptPos + ni));
+
+                if( JtJ_.needed() || JtErr_.needed() )
+                    projectPoints(objpt_i, om[k], T[k], intrin[k], distCoeffs[k],
+                                  tmpImagePoints, dpdrot, dpdt, dpdf, dpdc, dpdk, noArray(),
+                                  (flags & CALIB_FIX_ASPECT_RATIO) ? aspectRatio[k] : 0.);
+                else
+                    projectPoints(objpt_i, om[k], T[k], intrin[k], distCoeffs[k], tmpImagePoints);
+                subtract( tmpImagePoints, imgpt_ik, tmpImagePoints );
+
+                if( JtJ_.needed() )
+                {
+                    Mat JtErr = JtErr_.getMat();
+                    Mat JtJ = JtJ_.getMat();
+                    int iofs = (nimages+1)*6 + k*NINTRINSIC, eofs = (i+1)*6;
+                    assert( JtJ_.needed() && JtErr_.needed() );
+
+                    if( k == 1 )
+                    {
+                        // d(err_{x|y}R) ~ de3
+                        // convert de3/{dr3,dt3} => de3{dr1,dt1} & de3{dr2,dt2}
+                        for(int p = 0; p < ni*2; p++ )
+                        {
+                            Matx13d de3dr3, de3dt3, de3dr2, de3dt2, de3dr1, de3dt1;
+                            for(int j = 0; j < 3; j++)
+                                de3dr3(j) = Je.at<double>(p, j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dt3(j) = Je.at<double>(p, 3+j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dr2(j) = J_LR.at<double>(p, j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dt2(j) = J_LR.at<double>(p, 3+j);
+
+                            de3dr1 = de3dr3 * dr3dr1;
+                            de3dt1 = de3dt3 * dt3dt1;
+                            de3dr2  = de3dr3 * dr3dr2 + de3dt3 * dt3dr2;
+                            de3dt2  = de3dt3 * dt3dt2;
+
+                            for(int j = 0; j < 3; j++)
+                                Je.at<double>(p, j) = de3dr1(j);
+
+                            for(int j = 0; j < 3; j++)
+                                Je.at<double>(p, 3+j) = de3dt1(j);
+
+                            for(int j = 0; j < 3; j++)
+                                J_LR.at<double>(p, j) = de3dr2(j);
+
+                            for(int j = 0; j < 3; j++)
+                                J_LR.at<double>(p, 3+j) = de3dt2(j);
+                        }
+
+                        JtJ(Rect(0, 0, 6, 6)) += J_LR.t()*J_LR;
+                        JtJ(Rect(eofs, 0, 6, 6)) = J_LR.t()*Je;
+                        JtErr.rowRange(0, 6) += J_LR.t()*err;
+                    }
+
+                    JtJ(Rect(eofs, eofs, 6, 6)) += Je.t()*Je;
+                    JtErr.rowRange(eofs, eofs + 6) += Je.t()*err;
+
+                    if( recomputeIntrinsics )
+                    {
+                        JtJ(Rect(iofs, iofs, NINTRINSIC, NINTRINSIC)) += Ji.t()*Ji;
+                        JtJ(Rect(iofs, eofs, NINTRINSIC, 6)) += Je.t()*Ji;
+                        if( k == 1 )
+                        {
+                            JtJ(Rect(iofs, 0, NINTRINSIC, 6)) += J_LR.t()*Ji;
+                        }
+                        JtErr.rowRange(iofs, iofs + NINTRINSIC) += Ji.t()*err;
+                    }
+                }
+
+                double viewErr = norm(err, NORM_L2SQR);
+                if(!perViewErr.empty())
+                    perViewErr.at<double>(i, k) = std::sqrt(viewErr/ni);
+                reprojErr += viewErr;
+            }
+
+            ptPos += ni;
+        }
+        errnorm = reprojErr;
+        return true;
+    };
+
+    double reprojErr = 0;
+    if (countNonZero(mask))
+    {
+        LevMarq solver(param, lmcallback,
+                       LevMarq::Settings()
+                       .setMaxIterations((unsigned int)termCrit.maxCount)
+                       .setStepNormTolerance(termCrit.epsilon)
+                       .setSmallEnergyTolerance(termCrit.epsilon * termCrit.epsilon),
+                       mask);
+        // geodesic not supported for normal callbacks
+        LevMarq::Report r = solver.optimize();
+
+        // If solver failed, then the last calculated perViewErr can be wrong & should be recalculated
+        if (!r.found && !perViewErr.empty())
+        {
+            lmcallback(param, noArray(), noArray(), reprojErr);
+        }
+
+        reprojErr = r.energy;
+    }
+
+    // Extract optimized params from the param vector
+
+    Vec3d om_LR(param[0], param[1], param[2]);
+    Vec3d T_LR(param[3], param[4], param[5]);
+    Matx33d R_LR;
+    Rodrigues( om_LR, R_LR );
+    if( matR.rows == 1 || matR.cols == 1 )
+        om_LR.convertTo(matR, matR.depth());
+    else
+        R_LR.convertTo(matR, matR.depth());
+    T_LR.convertTo(matT, matT.depth());
+
+    if( recomputeIntrinsics )
+    {
+        for(int k = 0; k < 2; k++ )
+        {
+            size_t idx = (nimages+1)*6 + k*NINTRINSIC;
+            A[k] = Matx33d(param[idx + 0], 0, param[idx + 2], 0, param[idx + 1], param[idx + 3], 0, 0, 1);
+
+            Mat& cameraMatrix = k == 0 ? _cameraMatrix1 : _cameraMatrix2;
+            Mat& distCoeffs = k == 0 ? _distCoeffs1 : _distCoeffs2;
+            A[k].convertTo(cameraMatrix, cameraMatrix.depth());
+
+            std::vector<double> vdist(14);
+            for(int j = 0; j < 14; j++)
+                vdist[j] = param[idx + 4 + j];
+
+            Mat tdist( distCoeffs.size(), CV_MAKETYPE(CV_64F, distCoeffs.channels()), vdist.data());
+            tdist.convertTo(distCoeffs, distCoeffs.depth());
+        }
+    }
+
+    if( !matE.empty() || !matF.empty() )
+    {
+        Matx33d Tx(0, -T_LR[2], T_LR[1],
+                   T_LR[2], 0, -T_LR[0],
+                  -T_LR[1], T_LR[0], 0);
+        Matx33d E = Tx*R_LR;
+        if( !matE.empty() )
+            E.convertTo(matE, matE.depth());
+        if( !matF.empty())
+        {
+            Matx33d iA0 = A[0].inv(), iA1 = A[1].inv();
+            Matx33d F = iA1.t() * E * iA0;
+            F.convertTo(matF, matF.depth(), fabs(F(2,2)) > 0 ? 1./F(2,2) : 1.);
+        }
+    }
+
+    Mat r1d = rvecs.empty() ? Mat() : rvecs.reshape(1, nimages);
+    Mat t1d = tvecs.empty() ? Mat() : tvecs.reshape(1, nimages);
+    for(int i = 0; i < nimages; i++ )
+    {
+        int idx = (i + 1) * 6;
+
+        if( !rvecs.empty() )
+        {
+            Vec3d srcR(param[idx + 0], param[idx + 1], param[idx + 2]);
+            if( rvecs.rows * rvecs.cols * rvecs.channels() == nimages * 9 )
+            {
+                Matx33d rod;
+                Rodrigues(srcR, rod);
+                rod.convertTo(r1d.row(i).reshape(1, 3), rvecs.depth());
+            }
+            else if (rvecs.rows * rvecs.cols * rvecs.channels() == nimages * 3 )
+            {
+                Mat(Mat(srcR).t()).convertTo(r1d.row(i), rvecs.depth());
+            }
+        }
+        if( !tvecs.empty() )
+        {
+            Vec3d srcT(param[idx + 3], param[idx + 4], param[idx + 5]);
+            Mat(Mat(srcT).t()).convertTo(t1d.row(i), tvecs.depth());
+        }
+    }
+
+    return std::sqrt(reprojErr/(pointsTotal*2));
+}
+
+static double registerCamerasImpl(
+        const Mat& _objectPoints1, const Mat& _objectPoints2,
+        const Mat& _imagePoints1, const Mat& _imagePoints2,
+        const Mat& _npoints1, const Mat& _npoints2,
+        const Mat& _cameraMatrix1, const Mat& _distCoeffs1, CameraModel cameraModel1,
+        const Mat& _cameraMatrix2, const Mat& _distCoeffs2, CameraModel cameraModel2,
+        Mat matR, Mat matT,
+        Mat matE, Mat matF,
+        Mat rvecs, Mat tvecs,
+        Mat perViewErr, int flags,
+        TermCriteria termCrit )
+{
+    Matx33d A[2];
+    std::vector<Mat> tdists(2);
+    int pointsTotal[2], maxPoints = 0, nparams;
+    pointsTotal[0] = 0;
+    pointsTotal[1] = 0;
+
+    CV_Assert( _imagePoints1.type() == _imagePoints2.type() &&
+               _imagePoints1.depth() == _objectPoints1.depth() &&
+               _imagePoints2.depth() == _objectPoints2.depth() );
+
+    CV_Assert( (_npoints1.cols == 1 || _npoints1.rows == 1) &&
+                _npoints1.type() == CV_32S );
+    CV_Assert( (_npoints2.cols == 1 || _npoints2.rows == 1) &&
+                _npoints2.type() == CV_32S );
+
+    Mat _npoints[2];
+    _npoints[0] = _npoints1;
+    _npoints[1] = _npoints2;
+
+    int nimages = (int)_npoints[0].total();
+    for(int i = 0; i < nimages; i++ )
+    {
+        for (int k = 0; k < 2; k++) {
+            int ni = _npoints[k].at<int>(i);
+            maxPoints = std::max(maxPoints, ni);
+            pointsTotal[k] += ni;
+        }
+    }
+
+    Mat objectPoints[2];
+    Mat imagePoints[2];
+    _objectPoints1.convertTo(objectPoints[0], CV_64F);
+    _objectPoints2.convertTo(objectPoints[1], CV_64F);
+    objectPoints[0] = objectPoints[0].reshape(3, 1);
+    objectPoints[1] = objectPoints[1].reshape(3, 1);
+
+    if( !rvecs.empty() )
+    {
+        int cn = rvecs.channels();
+        int depth = rvecs.depth();
+        CV_Assert(depth == CV_32F || depth == CV_64F);
+        if(((rvecs.rows != nimages || (rvecs.cols*cn != 3 && rvecs.cols*cn != 9)) &&
+             (rvecs.rows != 1 || rvecs.cols != nimages || cn != 3)) )
+            CV_Error( cv::Error::StsBadArg, "the output array of rotation vectors must be 3-channel "
+                "1xn or nx1 array or 1-channel nx3 or nx9 array, where n is the number of views" );
+    }
+    if( !tvecs.empty() )
+    {
+        int cn = tvecs.channels();
+        int depth = tvecs.depth();
+        CV_Assert(depth == CV_32F || depth == CV_64F);
+        if(((tvecs.rows != nimages || tvecs.cols*cn != 3) &&
+             (tvecs.rows != 1 || tvecs.cols != nimages || cn != 3)) )
+            CV_Error( cv::Error::StsBadArg, "the output array of translation vectors must be 3-channel "
+                "1xn or nx1 array or 1-channel nx3 array, where n is the number of views" );
+    }
+
+    CameraModel cameraModels[2] = {cameraModel1, cameraModel2};
+    for(int k = 0; k < 2; k++ )
+    {
+        const Mat& points = k == 0 ? _imagePoints1 : _imagePoints2;
+        const Mat& cameraMatrix = k == 0 ? _cameraMatrix1 : _cameraMatrix2;
+        const Mat& distCoeffs = k == 0 ? _distCoeffs1 : _distCoeffs2;
+
+        int depth = points.depth();
+        int cn = points.channels();
+        CV_Assert( (depth == CV_32F || depth == CV_64F) &&
+                   ((points.rows == pointsTotal[k] && points.cols*cn == 2) ||
+                   (points.rows == 1 && points.cols == pointsTotal[k] && cn == 2)));
+
+        points.convertTo(imagePoints[k], CV_64F);
+        imagePoints[k] = imagePoints[k].reshape(2, 1);
+
+        cameraMatrix.convertTo(A[k], CV_64F);
+        distCoeffs.convertTo(tdists[k], CV_64F);
+    }
+
+    // we optimize for the inter-camera R(3),t(3)
+    // Param mapping is:
+    // - from 0 next 6: stereo pair Rt, from 6+i*6 next 6: Rt for each ith camera of nimages,
+    nparams = 6*(nimages+1);
+    std::vector<double> param(nparams, 0.);
+
+    // storage for initial [om(R){i}|t{i}] (in order to compute the median for each component)
+    std::vector<double> rtsort(nimages*6);
+    /*
+       Compute initial estimate of pose
+       For each image, compute:
+          R(om) is the rotation matrix of om
+          om(R) is the rotation vector of R
+          R_ref = R(om_right) * R(om_left)'
+          T_ref_list = [T_ref_list; T_right - R_ref * T_left]
+          om_ref_list = {om_ref_list; om(R_ref)]
+       om = median(om_ref_list)
+       T = median(T_ref_list)
+    */
+    int pos[2];
+    pos[0] = 0;
+    pos[1] = 0;
+    for(int i = 0; i < nimages; i++ )
+    {
+        Matx33d R[2];
+        Vec3d rv, T[2];
+        for(int k = 0; k < 2; k++ )
+        {
+            int ni = _npoints[k].at<int>(i);
+
+            Mat objpt_i = objectPoints[k].colRange(pos[k], pos[k] + ni);
+            Mat imgpt_ik = imagePoints[k].colRange(pos[k], pos[k] + ni);
+            if (cameraModels[k] == CALIB_MODEL_PINHOLE)
+                solvePnP(objpt_i, imgpt_ik, A[k], tdists[k], rv, T[k], false, SOLVEPNP_ITERATIVE );
+            else if (cameraModels[k] == CALIB_MODEL_FISHEYE)
+                fisheye::solvePnP(objpt_i, imgpt_ik, A[k], tdists[k], rv, T[k], false, SOLVEPNP_ITERATIVE );
+            else
+                CV_Error(cv::Error::StsBadArg, cv::format("Camera type %d is not supported", cameraModels[k]));
+
+            Rodrigues(rv, R[k]);
+
+            if( k == 0 )
+            {
+                // save initial om_left and T_left
+                param[(i+1)*6 + 0] = rv[0];
+                param[(i+1)*6 + 1] = rv[1];
+                param[(i+1)*6 + 2] = rv[2];
+                param[(i+1)*6 + 3] = T[0][0];
+                param[(i+1)*6 + 4] = T[0][1];
+                param[(i+1)*6 + 5] = T[0][2];
+            }
+            pos[k] += ni;
+        }
+
+        R[0] = R[1]*R[0].t();
+        T[1] -= R[0]*T[0];
+
+        Rodrigues(R[0], rv);
+
+        rtsort[i + nimages*0] = rv[0];
+        rtsort[i + nimages*1] = rv[1];
+        rtsort[i + nimages*2] = rv[2];
+        rtsort[i + nimages*3] = T[1][0];
+        rtsort[i + nimages*4] = T[1][1];
+        rtsort[i + nimages*5] = T[1][2];
+    }
+
+    if(flags & CALIB_USE_EXTRINSIC_GUESS)
+    {
+        Vec3d R, T;
+        matT.convertTo(T, CV_64F);
+
+        if( matR.rows == 3 && matR.cols == 3 )
+            Rodrigues(matR, R);
+        else
+        {
+            CV_Assert(matR.total() == 3);
+            matR.convertTo(R, CV_64F);
+        }
+
+        param[0] = R[0];
+        param[1] = R[1];
+        param[2] = R[2];
+        param[3] = T[0];
+        param[4] = T[1];
+        param[5] = T[2];
+    }
+    else
+    {
+        // find the medians and save the first 6 parameters
+        for(int i = 0; i < 6; i++ )
+        {
+            size_t idx = i*nimages;
+            std::nth_element(rtsort.begin() + idx,
+                             rtsort.begin() + idx + nimages/2,
+                             rtsort.begin() + idx + nimages);
+            double h = rtsort[idx + nimages/2];
+            param[i] = (nimages % 2 == 0) ? (h + rtsort[idx + nimages/2 - 1]) * 0.5 : h;
+        }
+    }
+
+    // Preallocated place for callback calculations
+    Mat errBuf( maxPoints*2, 1, CV_64F );
+    Mat JeBuf( maxPoints*2, 6, CV_64F );
+    Mat J_LRBuf( maxPoints*2, 6, CV_64F );
+
+    // auto lmcallback = [&, nimages, cameraModels, _npoints]
+    auto lmcallback = [&, nimages]
+                      (InputOutputArray _param, OutputArray JtErr_, OutputArray JtJ_, double& errnorm)
+    {
+        Mat_<double> param_m = _param.getMat();
+        Vec3d om_LR(param_m(0), param_m(1), param_m(2));
+        Vec3d T_LR(param_m(3), param_m(4), param_m(5));
+        Vec3d om[2], T[2];
+        Matx33d dr3dr1, dr3dr2, dt3dr2, dt3dt1, dt3dt2;
+        double reprojErr = 0;
+
+        int ptPos[2];
+        ptPos[0] = 0;
+        ptPos[1] = 0;
+        for(int i = 0; i < nimages; i++ )
+        {
+            int idx = (i+1)*6;
+            om[0] = Vec3d(param_m(idx + 0), param_m(idx + 1), param_m(idx + 2));
+            T[0]  = Vec3d(param_m(idx + 3), param_m(idx + 4), param_m(idx + 5));
+
+            if( JtJ_.needed() || JtErr_.needed() )
+                composeRT( om[0], T[0], om_LR, T_LR, om[1], T[1], dr3dr1, noArray(),
+                           dr3dr2, noArray(), noArray(), dt3dt1, dt3dr2, dt3dt2 );
+            else
+                composeRT( om[0], T[0], om_LR, T_LR, om[1], T[1] );
+
+            for(int k = 0; k < 2; k++ )
+            {
+                int ni = _npoints[k].at<int>(i);
+                Mat objpt_i = objectPoints[k](Range::all(), Range(ptPos[k], ptPos[k] + ni));
+                Mat err  = errBuf (Range(0, ni*2), Range::all());
+                Mat Je   = JeBuf  (Range(0, ni*2), Range::all());
+                Mat J_LR = J_LRBuf(Range(0, ni*2), Range::all());
+
+                Mat tmpImagePoints = err.reshape(2, 1);
+                Mat dpdrot = Je.colRange(0, 3);
+                Mat dpdt = Je.colRange(3, 6);
+
+                Mat imgpt_ik = imagePoints[k](Range::all(), Range(ptPos[k], ptPos[k] + ni));
+
+                if (cameraModels[k] == CALIB_MODEL_PINHOLE) {
+                    if( JtJ_.needed() || JtErr_.needed() )
+                        projectPoints(objpt_i, om[k], T[k], A[k], tdists[k],
+                                    tmpImagePoints, dpdrot, dpdt, noArray(), noArray(), noArray(), noArray(), 0.);
+                    else
+                        projectPoints(objpt_i, om[k], T[k], A[k], tdists[k], tmpImagePoints);
+                } else if (cameraModels[k] == CALIB_MODEL_FISHEYE) {
+                    if( JtJ_.needed() || JtErr_.needed() ) {
+                        Mat jacobian; // of size num_points*2  x  15 (2 + 2+ 4 + 3 + 3 + 1 ; // f, c, k, om, T, alpha)
+                        fisheye::projectPoints(objpt_i, tmpImagePoints, om[k], T[k], A[k], tdists[k], 0, jacobian);
+                        jacobian.colRange(8, 11).copyTo(dpdrot);
+                        jacobian.colRange(11,14).copyTo(dpdt);
+                    } else
+                        fisheye::projectPoints(objpt_i, tmpImagePoints, om[k], T[k], A[k], tdists[k]);
+                }
+
+                subtract( tmpImagePoints, imgpt_ik, tmpImagePoints );
+
+                if( JtJ_.needed() )
+                {
+                    Mat JtErr = JtErr_.getMat();
+                    Mat JtJ = JtJ_.getMat();
+                    int eofs = (i+1)*6;
+                    assert( JtJ_.needed() && JtErr_.needed() );
+
+                    if( k == 1 )
+                    {
+                        // d(err_{x|y}R) ~ de3
+                        // convert de3/{dr3,dt3} => de3{dr1,dt1} & de3{dr2,dt2}
+                        for(int p = 0; p < ni*2; p++ )
+                        {
+                            Matx13d de3dr3, de3dt3, de3dr2, de3dt2, de3dr1, de3dt1;
+                            for(int j = 0; j < 3; j++)
+                                de3dr3(j) = Je.at<double>(p, j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dt3(j) = Je.at<double>(p, 3+j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dr2(j) = J_LR.at<double>(p, j);
+
+                            for(int j = 0; j < 3; j++)
+                                de3dt2(j) = J_LR.at<double>(p, 3+j);
+
+                            de3dr1 = de3dr3 * dr3dr1;
+                            de3dt1 = de3dt3 * dt3dt1;
+                            de3dr2  = de3dr3 * dr3dr2 + de3dt3 * dt3dr2;
+                            de3dt2  = de3dt3 * dt3dt2;
+
+                            for(int j = 0; j < 3; j++)
+                                Je.at<double>(p, j) = de3dr1(j);
+
+                            for(int j = 0; j < 3; j++)
+                                Je.at<double>(p, 3+j) = de3dt1(j);
+
+                            for(int j = 0; j < 3; j++)
+                                J_LR.at<double>(p, j) = de3dr2(j);
+
+                            for(int j = 0; j < 3; j++)
+                                J_LR.at<double>(p, 3+j) = de3dt2(j);
+                        }
+
+                        JtJ(Rect(0, 0, 6, 6)) += J_LR.t()*J_LR;
+                        JtJ(Rect(eofs, 0, 6, 6)) = J_LR.t()*Je;
+                        JtErr.rowRange(0, 6) += J_LR.t()*err;
+                    }
+
+                    JtJ(Rect(eofs, eofs, 6, 6)) += Je.t()*Je;
+                    JtErr.rowRange(eofs, eofs + 6) += Je.t()*err;
+                }
+
+                double viewErr = norm(err, NORM_L2SQR);
+                if(!perViewErr.empty())
+                    perViewErr.at<double>(i, k) = std::sqrt(viewErr/ni);
+                reprojErr += viewErr;
+                ptPos[k] += ni;
+            }
+        }
+
+        errnorm = reprojErr;
+        return true;
+    };
+
+    double reprojErr = 0;
+    LevMarq solver(param, lmcallback,
+                   LevMarq::Settings()
+                    .setMaxIterations((unsigned int)termCrit.maxCount)
+                    .setStepNormTolerance(termCrit.epsilon)
+                    .setSmallEnergyTolerance(termCrit.epsilon * termCrit.epsilon));
+    // geodesic not supported for normal callbacks
+    LevMarq::Report r = solver.optimize();
+
+    // If solver failed, then the last calculated perViewErr can be wrong & should be recalculated
+    if (!r.found && !perViewErr.empty())
+    {
+        lmcallback(param, noArray(), noArray(), reprojErr);
+    }
+
+    reprojErr = r.energy;
+
+    // Extract optimized params from the param vector
+
+    Vec3d om_LR(param[0], param[1], param[2]);
+    Vec3d T_LR(param[3], param[4], param[5]);
+    Matx33d R_LR;
+    Rodrigues( om_LR, R_LR );
+    if( matR.rows == 1 || matR.cols == 1 )
+        om_LR.convertTo(matR, matR.depth());
+    else
+        R_LR.convertTo(matR, matR.depth());
+    T_LR.convertTo(matT, matT.depth());
+
+    if( !matE.empty() || !matF.empty() )
+    {
+        Matx33d Tx(0, -T_LR[2], T_LR[1],
+                   T_LR[2], 0, -T_LR[0],
+                  -T_LR[1], T_LR[0], 0);
+        Matx33d E = Tx*R_LR;
+        if( !matE.empty() )
+            E.convertTo(matE, matE.depth());
+        if( !matF.empty())
+        {
+            Matx33d iA0 = A[0].inv(), iA1 = A[1].inv();
+            Matx33d F = iA1.t() * E * iA0;
+            F.convertTo(matF, matF.depth(), fabs(F(2,2)) > 0 ? 1./F(2,2) : 1.);
+        }
+    }
+
+    Mat r1d = rvecs.empty() ? Mat() : rvecs.reshape(1, nimages);
+    Mat t1d = tvecs.empty() ? Mat() : tvecs.reshape(1, nimages);
+    for(int i = 0; i < nimages; i++ )
+    {
+        int idx = (i + 1) * 6;
+
+        if( !rvecs.empty() )
+        {
+            Vec3d srcR(param[idx + 0], param[idx + 1], param[idx + 2]);
+            if( rvecs.rows * rvecs.cols * rvecs.channels() == nimages * 9 )
+            {
+                Matx33d rod;
+                Rodrigues(srcR, rod);
+                rod.convertTo(r1d.row(i).reshape(1, 3), rvecs.depth());
+            }
+            else if (rvecs.rows * rvecs.cols * rvecs.channels() == nimages * 3 )
+            {
+                Mat(Mat(srcR).t()).convertTo(r1d.row(i), rvecs.depth());
+            }
+        }
+        if( !tvecs.empty() )
+        {
+            Vec3d srcT(param[idx + 3], param[idx + 4], param[idx + 5]);
+            Mat(Mat(srcT).t()).convertTo(t1d.row(i), tvecs.depth());
+        }
+    }
+
+    return std::sqrt(reprojErr/(pointsTotal[0] + pointsTotal[1]));
+}
+
+static void collectCalibrationData( InputArrayOfArrays objectPoints,
+                                    InputArrayOfArrays imagePoints1,
+                                    InputArrayOfArrays imagePoints2,
+                                    int iFixedPoint,
+                                    OutputArray objPt, OutputArray imgPt1, OutputArray imgPt2,
+                                    OutputArray npoints )
+{
+    int nimages = (int)objectPoints.total();
+    int total = 0;
+    CV_Assert(nimages > 0);
+    CV_CheckEQ(nimages, (int)imagePoints1.total(), "");
+    if (!imagePoints2.empty())
+    {
+        CV_CheckEQ(nimages, (int)imagePoints2.total(), "");
+        CV_Assert(imgPt2.needed());
+    }
+
+    for (int i = 0; i < nimages; i++)
+    {
+        Mat objectPoint = objectPoints.getMat(i);
+        if (objectPoint.empty())
+            CV_Error(cv::Error::StsBadSize, "objectPoints should not contain empty vector of vectors of points");
+        int numberOfObjectPoints = objectPoint.checkVector(3, CV_32F);
+        if (numberOfObjectPoints <= 0)
+            CV_Error(cv::Error::StsUnsupportedFormat, "objectPoints should contain vector of vectors of points of type Point3f");
+
+        Mat imagePoint1 = imagePoints1.getMat(i);
+        if (imagePoint1.empty())
+            CV_Error(cv::Error::StsBadSize, "imagePoints1 should not contain empty vector of vectors of points");
+        int numberOfImagePoints = imagePoint1.checkVector(2, CV_32F);
+        if (numberOfImagePoints <= 0)
+            CV_Error(cv::Error::StsUnsupportedFormat, "imagePoints1 should contain vector of vectors of points of type Point2f");
+        CV_CheckEQ(numberOfObjectPoints, numberOfImagePoints, "Number of object and image points must be equal");
+
+        total += numberOfObjectPoints;
+    }
+
+    npoints.create(1, (int)nimages, CV_32S);
+    objPt.create(1, (int)total, CV_32FC3);
+    imgPt1.create(1, (int)total, CV_32FC2);
+    Point2f* imgPtData2 = 0;
+
+    Mat imgPt1Mat = imgPt1.getMat();
+    if (!imagePoints2.empty())
+    {
+        imgPt2.create(1, (int)total, CV_32FC2);
+        imgPtData2 = imgPt2.getMat().ptr<Point2f>();
+    }
+
+    Mat nPointsMat = npoints.getMat();
+    Mat objPtMat = objPt.getMat();
+    Point3f* objPtData = objPtMat.ptr<Point3f>();
+    Point2f* imgPtData1 = imgPt1.getMat().ptr<Point2f>();
+
+    for (int i = 0, j = 0; i < nimages; i++)
+    {
+        Mat objpt = objectPoints.getMat(i);
+        Mat imgpt1 = imagePoints1.getMat(i);
+        int numberOfObjectPoints = objpt.checkVector(3, CV_32F);
+        nPointsMat.at<int>(i) = numberOfObjectPoints;
+        for (int n = 0; n < numberOfObjectPoints; ++n)
+        {
+            objPtData[j + n] = objpt.ptr<Point3f>()[n];
+            imgPtData1[j + n] = imgpt1.ptr<Point2f>()[n];
+        }
+
+        if (imgPtData2)
+        {
+            Mat imgpt2 = imagePoints2.getMat(i);
+            int numberOfImage2Points = imgpt2.checkVector(2, CV_32F);
+            CV_CheckEQ(numberOfObjectPoints, numberOfImage2Points, "Number of object and image(2) points must be equal");
+            for (int n = 0; n < numberOfImage2Points; ++n)
+            {
+                imgPtData2[j + n] = imgpt2.ptr<Point2f>()[n];
+            }
+        }
+
+        j += numberOfObjectPoints;
+    }
+
+    int ni = nPointsMat.at<int>(0);
+    bool releaseObject = iFixedPoint > 0 && iFixedPoint < ni - 1;
+    // check object points. If not qualified, report errors.
+    if( releaseObject )
+    {
+        for (int i = 1; i < nimages; i++)
+        {
+            if( nPointsMat.at<int>(i) != ni )
+            {
+                CV_Error( cv::Error::StsBadArg, "All objectPoints[i].size() should be equal when "
+                                        "object-releasing method is requested." );
+            }
+            Mat ocmp = objPtMat.colRange(ni * i, ni * i + ni) != objPtMat.colRange(0, ni);
+            ocmp = ocmp.reshape(1);
+            if( countNonZero(ocmp) )
+            {
+                CV_Error( cv::Error::StsBadArg, "All objectPoints[i] should be identical when object-releasing"
+                                        " method is requested." );
+            }
+        }
+    }
+}
+
+static void collectCalibrationData( InputArrayOfArrays objectPoints,
+                                    InputArrayOfArrays imagePoints1,
+                                    InputArrayOfArrays imagePoints2,
+                                    OutputArray objPt, OutputArray imgPtMat1, OutputArray imgPtMat2,
+                                    OutputArray npoints )
+{
+    collectCalibrationData( objectPoints, imagePoints1, imagePoints2, -1, objPt, imgPtMat1,
+                            imgPtMat2, npoints );
+}
+
+static Mat prepareCameraMatrix(Mat& cameraMatrix0, int rtype, int flags)
+{
+    Mat cameraMatrix = Mat::eye(3, 3, rtype);
+    if( cameraMatrix0.size() == cameraMatrix.size() )
+        cameraMatrix0.convertTo(cameraMatrix, rtype);
+    else if( flags & CALIB_USE_INTRINSIC_GUESS )
+        CV_Error(Error::StsBadArg, "CALIB_USE_INTRINSIC_GUESS flag is set, but the camera matrix is not 3x3");
+    return cameraMatrix;
+}
+
+Mat initCameraMatrix2D( InputArrayOfArrays objectPoints,
+                        InputArrayOfArrays imagePoints,
+                        Size imageSize, double aspectRatio )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat objPt, imgPt, npoints, cameraMatrix;
+    collectCalibrationData( objectPoints, imagePoints, noArray(),
+                            objPt, imgPt, noArray(), npoints );
+    initIntrinsicParams2D( objPt, imgPt, npoints, imageSize, cameraMatrix, aspectRatio );
+    return cameraMatrix;
+}
+
+static Mat prepareDistCoeffs(Mat& distCoeffs0, int rtype, int outputSize)
+{
+    Size sz = distCoeffs0.size();
+    int n = sz.area();
+    if (n > 0)
+        CV_Assert(sz.width == 1 || sz.height == 1);
+    CV_Assert((int)distCoeffs0.total() <= outputSize);
+    Mat distCoeffs = Mat::zeros(sz.width == 1 ? Size(1, outputSize) : Size(outputSize, 1), rtype);
+    if( n ==  4 || n ==  5 || n ==  8 || n == 12 || n == 14 )
+    {
+        distCoeffs0.convertTo(distCoeffs(Rect(Point(), sz)), rtype);
+    }
+    return distCoeffs;
+}
+
+double calibrateCamera( InputArrayOfArrays _objectPoints,
+                        InputArrayOfArrays _imagePoints,
+                        Size imageSize, InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs,
+                        OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags, TermCriteria criteria )
+{
+    CV_INSTRUMENT_REGION();
+
+    return calibrateCamera(_objectPoints, _imagePoints, imageSize, _cameraMatrix, _distCoeffs,
+                                         _rvecs, _tvecs, noArray(), noArray(), noArray(), flags, criteria);
+}
+
+double calibrateCamera(InputArrayOfArrays _objectPoints,
+                       InputArrayOfArrays _imagePoints,
+                       Size imageSize, InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs,
+                       OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                       OutputArray stdDeviationsIntrinsics,
+                       OutputArray stdDeviationsExtrinsics,
+                       OutputArray _perViewErrors, int flags, TermCriteria criteria )
+{
+    CV_INSTRUMENT_REGION();
+
+    return calibrateCameraRO(_objectPoints, _imagePoints, imageSize, -1, _cameraMatrix, _distCoeffs,
+                             _rvecs, _tvecs, noArray(), stdDeviationsIntrinsics, stdDeviationsExtrinsics,
+                             noArray(), _perViewErrors, flags, criteria);
+}
+
+double calibrateCameraRO(InputArrayOfArrays _objectPoints,
+                         InputArrayOfArrays _imagePoints,
+                         Size imageSize, int iFixedPoint, InputOutputArray _cameraMatrix,
+                         InputOutputArray _distCoeffs,
+                         OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                         OutputArray newObjPoints,
+                         int flags, TermCriteria criteria)
+{
+    CV_INSTRUMENT_REGION();
+
+    return calibrateCameraRO(_objectPoints, _imagePoints, imageSize, iFixedPoint, _cameraMatrix,
+                             _distCoeffs, _rvecs, _tvecs, newObjPoints, noArray(), noArray(),
+                             noArray(), noArray(), flags, criteria);
+}
+
+double calibrateCameraRO(InputArrayOfArrays _objectPoints,
+                         InputArrayOfArrays _imagePoints,
+                         Size imageSize, int iFixedPoint, InputOutputArray _cameraMatrix,
+                         InputOutputArray _distCoeffs,
+                         OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                         OutputArray newObjPoints,
+                         OutputArray stdDeviationsIntrinsics,
+                         OutputArray stdDeviationsExtrinsics,
+                         OutputArray stdDeviationsObjPoints,
+                         OutputArray _perViewErrors, int flags, TermCriteria criteria )
+{
+    CV_INSTRUMENT_REGION();
+
+    int rtype = CV_64F;
+
+    CV_Assert( _cameraMatrix.needed() );
+    CV_Assert( _distCoeffs.needed() );
+
+    Mat cameraMatrix = _cameraMatrix.getMat();
+    cameraMatrix = prepareCameraMatrix(cameraMatrix, rtype, flags);
+    Mat distCoeffs = _distCoeffs.getMat();
+    distCoeffs =
+        (flags & CALIB_THIN_PRISM_MODEL) &&
+        !(flags & CALIB_TILTED_MODEL) ?
+            prepareDistCoeffs(distCoeffs, rtype, 12) :
+            prepareDistCoeffs(distCoeffs, rtype, 14);
+    if( !(flags & CALIB_RATIONAL_MODEL) &&
+    (!(flags & CALIB_THIN_PRISM_MODEL)) &&
+    (!(flags & CALIB_TILTED_MODEL)))
+        distCoeffs = distCoeffs.rows == 1 ? distCoeffs.colRange(0, 5) : distCoeffs.rowRange(0, 5);
+
+    int nimages = int(_objectPoints.total());
+    CV_Assert( nimages > 0 );
+    Mat objPt, imgPt, npoints, rvecM, tvecM, stdDeviationsM, errorsM;
+
+    bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed(),
+            stddev_needed = stdDeviationsIntrinsics.needed(), errors_needed = _perViewErrors.needed(),
+            stddev_ext_needed = stdDeviationsExtrinsics.needed();
+    bool newobj_needed = newObjPoints.needed();
+    bool stddev_obj_needed = stdDeviationsObjPoints.needed();
+
+    bool rvecs_mat_vec = _rvecs.isMatVector();
+    bool tvecs_mat_vec = _tvecs.isMatVector();
+
+    if( rvecs_needed )
+    {
+        _rvecs.create(nimages, 1, CV_64FC3);
+
+        if(rvecs_mat_vec)
+            rvecM.create(nimages, 3, CV_64F);
+        else
+            rvecM = _rvecs.getMat();
+    }
+
+    if( tvecs_needed )
+    {
+        _tvecs.create(nimages, 1, CV_64FC3);
+
+        if(tvecs_mat_vec)
+            tvecM.create(nimages, 3, CV_64F);
+        else
+            tvecM = _tvecs.getMat();
+    }
+
+    collectCalibrationData( _objectPoints, _imagePoints, noArray(), iFixedPoint,
+                            objPt, imgPt, noArray(), npoints );
+    bool releaseObject = iFixedPoint > 0 && iFixedPoint < npoints.at<int>(0) - 1;
+
+    newobj_needed = newobj_needed && releaseObject;
+    int np = npoints.at<int>( 0 );
+    Mat newObjPt;
+    if( newobj_needed ) {
+        newObjPoints.create( 1, np, CV_32FC3 );
+        newObjPt = newObjPoints.getMat();
+    }
+
+    stddev_obj_needed = stddev_obj_needed && releaseObject;
+    bool stddev_any_needed = stddev_needed || stddev_ext_needed || stddev_obj_needed;
+    if( stddev_any_needed )
+    {
+        int sz = nimages*6 + CALIB_NINTRINSIC + (releaseObject ? np * 3 : 0);
+        stdDeviationsM.create(sz, 1, CV_64F);
+    }
+
+    if( errors_needed )
+    {
+        _perViewErrors.create(nimages, 1, CV_64F);
+        errorsM = _perViewErrors.getMat();
+    }
+
+    double reprojErr = 0;
+    if( flags & CALIB_DISABLE_SCHUR_COMPLEMENT )
+    {
+        reprojErr = calibrateCameraInternalBouguet(
+            objPt, imgPt, npoints, imageSize, iFixedPoint,
+            cameraMatrix, distCoeffs,
+            rvecM, tvecM,
+            newObjPt,
+            stdDeviationsM,
+            errorsM, flags, criteria);
+    }
+    else
+    {
+        reprojErr = calibrateCameraInternalSchur(
+            objPt, imgPt, npoints, imageSize, iFixedPoint,
+            cameraMatrix, distCoeffs,
+            rvecM, tvecM,
+            newObjPt,
+            stdDeviationsM,
+            errorsM, flags, criteria);
+    }
+
+    if( stddev_needed )
+    {
+        stdDeviationsM.rowRange(0, CALIB_NINTRINSIC).copyTo(stdDeviationsIntrinsics);
+    }
+
+    if ( stddev_ext_needed )
+    {
+        int s = CALIB_NINTRINSIC;
+        stdDeviationsM.rowRange(s, s + nimages*6).copyTo(stdDeviationsExtrinsics);
+    }
+
+    if( stddev_obj_needed )
+    {
+        int s = CALIB_NINTRINSIC + nimages*6;
+        stdDeviationsM.rowRange(s, s + np*3).copyTo(stdDeviationsObjPoints);
+    }
+
+    // overly complicated and inefficient rvec/ tvec handling to support vector<Mat>
+    for(int i = 0; i < nimages; i++ )
+    {
+        if( rvecs_needed && rvecs_mat_vec)
+        {
+            _rvecs.create(3, 1, CV_64F, i, true);
+            Mat rv = _rvecs.getMat(i);
+            Mat(rvecM.row(i).t()).copyTo(rv);
+        }
+        if( tvecs_needed && tvecs_mat_vec)
+        {
+            _tvecs.create(3, 1, CV_64F, i, true);
+            Mat tv = _tvecs.getMat(i);
+            Mat(tvecM.row(i).t()).copyTo(tv);
+        }
+    }
+
+    cameraMatrix.copyTo(_cameraMatrix);
+    distCoeffs.copyTo(_distCoeffs);
+
+    return reprojErr;
+}
+
+double stereoCalibrate( InputArrayOfArrays _objectPoints,
+                        InputArrayOfArrays _imagePoints1,
+                        InputArrayOfArrays _imagePoints2,
+                        InputOutputArray _cameraMatrix1, InputOutputArray _distCoeffs1,
+                        InputOutputArray _cameraMatrix2, InputOutputArray _distCoeffs2,
+                        Size imageSize, OutputArray _Rmat, OutputArray _Tmat,
+                        OutputArray _Emat, OutputArray _Fmat, int flags,
+                        TermCriteria criteria)
+{
+    if (flags & CALIB_USE_EXTRINSIC_GUESS)
+        CV_Error(Error::StsBadFlag, "stereoCalibrate does not support CALIB_USE_EXTRINSIC_GUESS.");
+
+    Mat Rmat, Tmat;
+    double ret = stereoCalibrate(_objectPoints, _imagePoints1, _imagePoints2, _cameraMatrix1, _distCoeffs1,
+                                 _cameraMatrix2, _distCoeffs2, imageSize, Rmat, Tmat, _Emat, _Fmat,
+                                 noArray(), flags, criteria);
+    Rmat.copyTo(_Rmat);
+    Tmat.copyTo(_Tmat);
+    return ret;
+}
+
+double stereoCalibrate( InputArrayOfArrays _objectPoints,
+                        InputArrayOfArrays _imagePoints1,
+                        InputArrayOfArrays _imagePoints2,
+                        InputOutputArray _cameraMatrix1, InputOutputArray _distCoeffs1,
+                        InputOutputArray _cameraMatrix2, InputOutputArray _distCoeffs2,
+                        Size imageSize, InputOutputArray _Rmat, InputOutputArray _Tmat,
+                        OutputArray _Emat, OutputArray _Fmat,
+                        OutputArray _perViewErrors, int flags,
+                        TermCriteria criteria)
+{
+    return stereoCalibrate(_objectPoints, _imagePoints1, _imagePoints2, _cameraMatrix1, _distCoeffs1,
+                           _cameraMatrix2, _distCoeffs2, imageSize, _Rmat, _Tmat, _Emat, _Fmat,
+                           noArray(), noArray(), _perViewErrors, flags, criteria);
+}
+
+double stereoCalibrate( InputArrayOfArrays _objectPoints,
+                        InputArrayOfArrays _imagePoints1,
+                        InputArrayOfArrays _imagePoints2,
+                        InputOutputArray _cameraMatrix1, InputOutputArray _distCoeffs1,
+                        InputOutputArray _cameraMatrix2, InputOutputArray _distCoeffs2,
+                        Size imageSize, InputOutputArray _Rmat, InputOutputArray _Tmat,
+                        OutputArray _Emat, OutputArray _Fmat,
+                        OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                        OutputArray _perViewErrors, int flags,
+                        TermCriteria criteria)
+{
+    int rtype = CV_64F;
+    Mat cameraMatrix1 = _cameraMatrix1.getMat();
+    Mat cameraMatrix2 = _cameraMatrix2.getMat();
+    Mat distCoeffs1 = _distCoeffs1.getMat();
+    Mat distCoeffs2 = _distCoeffs2.getMat();
+    cameraMatrix1 = prepareCameraMatrix(cameraMatrix1, rtype, flags);
+    cameraMatrix2 = prepareCameraMatrix(cameraMatrix2, rtype, flags);
+    distCoeffs1 = prepareDistCoeffs(distCoeffs1, rtype, 14);
+    distCoeffs2 = prepareDistCoeffs(distCoeffs2, rtype, 14);
+
+    if( !(flags & CALIB_RATIONAL_MODEL) &&
+    (!(flags & CALIB_THIN_PRISM_MODEL)) &&
+    (!(flags & CALIB_TILTED_MODEL)))
+    {
+        distCoeffs1 = distCoeffs1.rows == 1 ? distCoeffs1.colRange(0, 5) : distCoeffs1.rowRange(0, 5);
+        distCoeffs2 = distCoeffs2.rows == 1 ? distCoeffs2.colRange(0, 5) : distCoeffs2.rowRange(0, 5);
+    }
+
+    if((flags & CALIB_USE_EXTRINSIC_GUESS) == 0)
+    {
+        _Rmat.create(3, 3, rtype);
+        _Tmat.create(3, 1, rtype);
+    }
+
+    int nimages = int(_objectPoints.total());
+    CV_Assert( nimages > 0 );
+
+    Mat objPt, imgPt, imgPt2, npoints, rvecLM, tvecLM;
+
+    collectCalibrationData( _objectPoints, _imagePoints1, _imagePoints2,
+                            objPt, imgPt, imgPt2, npoints );
+    Mat matR = _Rmat.getMat(), matT = _Tmat.getMat();
+
+    bool E_needed = _Emat.needed(), F_needed = _Fmat.needed();
+    bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed();
+    bool errors_needed = _perViewErrors.needed();
+
+    Mat matE, matF, matErr;
+    if( E_needed )
+    {
+        _Emat.create(3, 3, rtype);
+        matE = _Emat.getMat();
+    }
+    if( F_needed )
+    {
+        _Fmat.create(3, 3, rtype);
+        matF = _Fmat.getMat();
+    }
+
+    bool rvecs_mat_vec = _rvecs.isMatVector();
+    bool tvecs_mat_vec = _tvecs.isMatVector();
+
+    if( rvecs_needed )
+    {
+        _rvecs.create(nimages, 1, CV_64FC3);
+
+        if( rvecs_mat_vec )
+            rvecLM.create(nimages, 3, CV_64F);
+        else
+            rvecLM = _rvecs.getMat();
+    }
+    if( tvecs_needed )
+    {
+        _tvecs.create(nimages, 1, CV_64FC3);
+
+        if( tvecs_mat_vec )
+            tvecLM.create(nimages, 3, CV_64F);
+        else
+            tvecLM = _tvecs.getMat();
+    }
+
+    if( errors_needed )
+    {
+        _perViewErrors.create(nimages, 2, CV_64F);
+        matErr = _perViewErrors.getMat();
+    }
+
+    double err = stereoCalibrateImpl(objPt, imgPt, imgPt2, npoints, cameraMatrix1,
+                                     distCoeffs1, cameraMatrix2, distCoeffs2, imageSize,
+                                     matR, matT, matE, matF, rvecLM, tvecLM,
+                                     matErr, flags, criteria);
+    cameraMatrix1.copyTo(_cameraMatrix1);
+    cameraMatrix2.copyTo(_cameraMatrix2);
+    distCoeffs1.copyTo(_distCoeffs1);
+    distCoeffs2.copyTo(_distCoeffs2);
+
+    for(int i = 0; i < nimages; i++ )
+    {
+        if( rvecs_needed && rvecs_mat_vec )
+        {
+            _rvecs.create(3, 1, CV_64F, i, true);
+            Mat rv = _rvecs.getMat(i);
+            Mat(rvecLM.row(i).t()).copyTo(rv);
+        }
+        if( tvecs_needed && tvecs_mat_vec )
+        {
+            _tvecs.create(3, 1, CV_64F, i, true);
+            Mat tv = _tvecs.getMat(i);
+            Mat(tvecLM.row(i).t()).copyTo(tv);
+        }
+    }
+
+    return err;
+}
+
+double registerCameras( InputArrayOfArrays _objectPoints1,
+                        InputArrayOfArrays _objectPoints2,
+                        InputArrayOfArrays _imagePoints1,
+                        InputArrayOfArrays _imagePoints2,
+                        InputArray _cameraMatrix1, InputArray _distCoeffs1, CameraModel cameraModel1,
+                        InputArray _cameraMatrix2, InputArray _distCoeffs2, CameraModel cameraModel2,
+                        InputOutputArray _Rmat, InputOutputArray _Tmat,
+                        OutputArray _Emat, OutputArray _Fmat,
+                        OutputArray _perViewErrors, int flags,
+                        TermCriteria criteria)
+{
+    return registerCameras(_objectPoints1, _objectPoints2, _imagePoints1, _imagePoints2, _cameraMatrix1, _distCoeffs1, cameraModel1,
+                           _cameraMatrix2, _distCoeffs2, cameraModel2, _Rmat, _Tmat, _Emat, _Fmat,
+                           noArray(), noArray(), _perViewErrors, flags, criteria);
+}
+
+double registerCameras( InputArrayOfArrays _objectPoints1,
+                        InputArrayOfArrays _objectPoints2,
+                        InputArrayOfArrays _imagePoints1,
+                        InputArrayOfArrays _imagePoints2,
+                        InputArray _cameraMatrix1, InputArray _distCoeffs1, CameraModel cameraModel1,
+                        InputArray _cameraMatrix2, InputArray _distCoeffs2, CameraModel cameraModel2,
+                        InputOutputArray _Rmat, InputOutputArray _Tmat,
+                        OutputArray _Emat, OutputArray _Fmat,
+                        OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs,
+                        OutputArray _perViewErrors, int flags,
+                        TermCriteria criteria)
+{
+    // Only support fisheye camera model and pinhole camera model
+    CV_Assert(cameraModel1 == CALIB_MODEL_FISHEYE || cameraModel1 == CALIB_MODEL_PINHOLE);
+    CV_Assert(cameraModel2 == CALIB_MODEL_FISHEYE || cameraModel2 == CALIB_MODEL_PINHOLE);
+
+    // Two cameras should contain the same number of frames
+    CV_Assert(_objectPoints1.total() == _objectPoints2.total());
+
+    int rtype = CV_64F;
+    Mat cameraMatrix1 = _cameraMatrix1.getMat();
+    Mat cameraMatrix2 = _cameraMatrix2.getMat();
+    Mat distCoeffs1 = _distCoeffs1.getMat();
+    Mat distCoeffs2 = _distCoeffs2.getMat();
+    cameraMatrix1 = prepareCameraMatrix(cameraMatrix1, rtype, flags);
+    cameraMatrix2 = prepareCameraMatrix(cameraMatrix2, rtype, flags);
+
+    int paramNum1 = int(_distCoeffs1.getMat().total()), paramNum2 = int(_distCoeffs2.getMat().total());
+    distCoeffs1 = prepareDistCoeffs(distCoeffs1, rtype, paramNum1);
+    distCoeffs2 = prepareDistCoeffs(distCoeffs2, rtype, paramNum2);
+
+    if(!(flags & CALIB_USE_EXTRINSIC_GUESS))
+    {
+        _Rmat.create(3, 3, rtype);
+        _Tmat.create(3, 1, rtype);
+    }
+
+    int nimages = int(_objectPoints1.total());
+    CV_Assert( nimages > 0 );
+
+    Mat objPt1, objPt2, imgPt1, imgPt2, npoints1, npoints2, rvecLM, tvecLM;
+
+    collectCalibrationData( _objectPoints1, _imagePoints1, noArray(),
+                            objPt1, imgPt1, noArray(), npoints1 );
+    collectCalibrationData( _objectPoints2, _imagePoints2, noArray(),
+                            objPt2, imgPt2, noArray(), npoints2 );
+
+    Mat matR = _Rmat.getMat(), matT = _Tmat.getMat();
+
+    bool E_needed = _Emat.needed(), F_needed = _Fmat.needed();
+    bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed();
+    bool errors_needed = _perViewErrors.needed();
+
+    Mat matE, matF, matErr;
+    if( E_needed )
+    {
+        _Emat.create(3, 3, rtype);
+        matE = _Emat.getMat();
+    }
+    if( F_needed )
+    {
+        _Fmat.create(3, 3, rtype);
+        matF = _Fmat.getMat();
+    }
+
+    bool rvecs_mat_vec = _rvecs.isMatVector();
+    bool tvecs_mat_vec = _tvecs.isMatVector();
+
+    if( rvecs_needed )
+    {
+        _rvecs.create(nimages, 1, CV_64FC3);
+
+        if( rvecs_mat_vec )
+            rvecLM.create(nimages, 3, CV_64F);
+        else
+            rvecLM = _rvecs.getMat();
+    }
+    if( tvecs_needed )
+    {
+        _tvecs.create(nimages, 1, CV_64FC3);
+
+        if( tvecs_mat_vec )
+            tvecLM.create(nimages, 3, CV_64F);
+        else
+            tvecLM = _tvecs.getMat();
+    }
+
+    if( errors_needed )
+    {
+        _perViewErrors.create(nimages, 2, CV_64F);
+        matErr = _perViewErrors.getMat();
+    }
+
+    double err = registerCamerasImpl(objPt1, objPt2, imgPt1, imgPt2,
+                                    npoints1, npoints2,
+                                    cameraMatrix1, distCoeffs1, cameraModel1,
+                                    cameraMatrix2, distCoeffs2, cameraModel2,
+                                    matR, matT, matE, matF, rvecLM, tvecLM,
+                                    matErr, flags, criteria);
+
+    for(int i = 0; i < nimages; i++ )
+    {
+        if( rvecs_needed && rvecs_mat_vec )
+        {
+            _rvecs.create(3, 1, CV_64F, i, true);
+            Mat rv = _rvecs.getMat(i);
+            Mat(rvecLM.row(i).t()).copyTo(rv);
+        }
+        if( tvecs_needed && tvecs_mat_vec )
+        {
+            _tvecs.create(3, 1, CV_64F, i, true);
+            Mat tv = _tvecs.getMat(i);
+            Mat(tvecLM.row(i).t()).copyTo(tv);
+        }
+    }
+
+    return err;
+}
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/calib/src/calibration_handeye.cpp b/upstream/opencv/modules/calib/src/calibration_handeye.cpp
new file mode 100644
index 0000000..cf890f3
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/calibration_handeye.cpp
@@ -0,0 +1,1017 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+namespace cv {
+
+static Mat homogeneousInverse(const Mat& T)
+{
+    CV_Assert(T.rows == 4 && T.cols == 4);
+
+    Mat R = T(Rect(0, 0, 3, 3));
+    Mat t = T(Rect(3, 0, 1, 3));
+    Mat Rt = R.t();
+    Mat tinv = -Rt * t;
+    Mat Tinv = Mat::eye(4, 4, T.type());
+    Rt.copyTo(Tinv(Rect(0, 0, 3, 3)));
+    tinv.copyTo(Tinv(Rect(3, 0, 1, 3)));
+
+    return Tinv;
+}
+
+// q = rot2quatMinimal(R)
+//
+// R - 3x3 rotation matrix, or 4x4 homogeneous matrix
+// q - 3x1 unit quaternion <qx, qy, qz>
+// q = sin(theta/2) * v
+// theta - rotation angle
+// v     - unit rotation axis, |v| = 1
+// Reference: http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
+static Mat rot2quatMinimal(const Mat& R)
+{
+    CV_Assert(R.type() == CV_64FC1 && R.rows >= 3 && R.cols >= 3);
+
+    double m00 = R.at<double>(0,0), m01 = R.at<double>(0,1), m02 = R.at<double>(0,2);
+    double m10 = R.at<double>(1,0), m11 = R.at<double>(1,1), m12 = R.at<double>(1,2);
+    double m20 = R.at<double>(2,0), m21 = R.at<double>(2,1), m22 = R.at<double>(2,2);
+    double trace = m00 + m11 + m22;
+
+    double qx, qy, qz;
+    if (trace > 0) {
+        double S = sqrt(trace + 1.0) * 2; // S=4*qw
+        qx = (m21 - m12) / S;
+        qy = (m02 - m20) / S;
+        qz = (m10 - m01) / S;
+    } else if (m00 > m11 && m00 > m22) {
+        double S = sqrt(1.0 + m00 - m11 - m22) * 2; // S=4*qx
+        qx = 0.25 * S;
+        qy = (m01 + m10) / S;
+        qz = (m02 + m20) / S;
+    } else if (m11 > m22) {
+        double S = sqrt(1.0 + m11 - m00 - m22) * 2; // S=4*qy
+        qx = (m01 + m10) / S;
+        qy = 0.25 * S;
+        qz = (m12 + m21) / S;
+    } else {
+        double S = sqrt(1.0 + m22 - m00 - m11) * 2; // S=4*qz
+        qx = (m02 + m20) / S;
+        qy = (m12 + m21) / S;
+        qz = 0.25 * S;
+    }
+
+    return (Mat_<double>(3,1) << qx, qy, qz);
+}
+
+static Mat skew(const Mat& v)
+{
+    CV_Assert(v.type() == CV_64FC1 && v.rows == 3 && v.cols == 1);
+
+    double vx = v.at<double>(0,0);
+    double vy = v.at<double>(1,0);
+    double vz = v.at<double>(2,0);
+    return (Mat_<double>(3,3) << 0, -vz, vy,
+                                vz, 0, -vx,
+                                -vy, vx, 0);
+}
+
+// R = quatMinimal2rot(q)
+//
+// q - 3x1 unit quaternion <qx, qy, qz>
+// R - 3x3 rotation matrix
+// q = sin(theta/2) * v
+// theta - rotation angle
+// v     - unit rotation axis, |v| = 1
+static Mat quatMinimal2rot(const Mat& q)
+{
+    CV_Assert(q.type() == CV_64FC1 && q.rows == 3 && q.cols == 1);
+
+    Mat p = q.t()*q;
+    double w = sqrt(1 - p.at<double>(0,0));
+
+    Mat diag_p = Mat::eye(3,3,CV_64FC1)*p.at<double>(0,0);
+    return 2*q*q.t() + 2*w*skew(q) + Mat::eye(3,3,CV_64FC1) - 2*diag_p;
+}
+
+// q = rot2quat(R)
+//
+// q - 4x1 unit quaternion <qw, qx, qy, qz>
+// R - 3x3 rotation matrix
+// Reference: http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
+static Mat rot2quat(const Mat& R)
+{
+    CV_Assert(R.type() == CV_64FC1 && R.rows >= 3 && R.cols >= 3);
+
+    double m00 = R.at<double>(0,0), m01 = R.at<double>(0,1), m02 = R.at<double>(0,2);
+    double m10 = R.at<double>(1,0), m11 = R.at<double>(1,1), m12 = R.at<double>(1,2);
+    double m20 = R.at<double>(2,0), m21 = R.at<double>(2,1), m22 = R.at<double>(2,2);
+    double trace = m00 + m11 + m22;
+
+    double qw, qx, qy, qz;
+    if (trace > 0) {
+        double S = sqrt(trace + 1.0) * 2; // S=4*qw
+        qw = 0.25 * S;
+        qx = (m21 - m12) / S;
+        qy = (m02 - m20) / S;
+        qz = (m10 - m01) / S;
+    } else if (m00 > m11 && m00 > m22) {
+        double S = sqrt(1.0 + m00 - m11 - m22) * 2; // S=4*qx
+        qw = (m21 - m12) / S;
+        qx = 0.25 * S;
+        qy = (m01 + m10) / S;
+        qz = (m02 + m20) / S;
+    } else if (m11 > m22) {
+        double S = sqrt(1.0 + m11 - m00 - m22) * 2; // S=4*qy
+        qw = (m02 - m20) / S;
+        qx = (m01 + m10) / S;
+        qy = 0.25 * S;
+        qz = (m12 + m21) / S;
+    } else {
+        double S = sqrt(1.0 + m22 - m00 - m11) * 2; // S=4*qz
+        qw = (m10 - m01) / S;
+        qx = (m02 + m20) / S;
+        qy = (m12 + m21) / S;
+        qz = 0.25 * S;
+    }
+
+    return (Mat_<double>(4,1) << qw, qx, qy, qz);
+}
+
+// R = quat2rot(q)
+//
+// q - 4x1 unit quaternion <qw, qx, qy, qz>
+// R - 3x3 rotation matrix
+static Mat quat2rot(const Mat& q)
+{
+    CV_Assert(q.type() == CV_64FC1 && q.rows == 4 && q.cols == 1);
+
+    double qw = q.at<double>(0,0);
+    double qx = q.at<double>(1,0);
+    double qy = q.at<double>(2,0);
+    double qz = q.at<double>(3,0);
+
+    Mat R(3, 3, CV_64FC1);
+    R.at<double>(0, 0) = 1 - 2*qy*qy - 2*qz*qz;
+    R.at<double>(0, 1) = 2*qx*qy - 2*qz*qw;
+    R.at<double>(0, 2) = 2*qx*qz + 2*qy*qw;
+
+    R.at<double>(1, 0) = 2*qx*qy + 2*qz*qw;
+    R.at<double>(1, 1) = 1 - 2*qx*qx - 2*qz*qz;
+    R.at<double>(1, 2) = 2*qy*qz - 2*qx*qw;
+
+    R.at<double>(2, 0) = 2*qx*qz - 2*qy*qw;
+    R.at<double>(2, 1) = 2*qy*qz + 2*qx*qw;
+    R.at<double>(2, 2) = 1 - 2*qx*qx - 2*qy*qy;
+
+    return R;
+}
+
+// Kronecker product or tensor product
+// https://stackoverflow.com/a/36552682
+static Mat kron(const Mat& A, const Mat& B)
+{
+    CV_Assert(A.channels() == 1 && B.channels() == 1);
+
+    Mat1d Ad, Bd;
+    A.convertTo(Ad, CV_64F);
+    B.convertTo(Bd, CV_64F);
+
+    Mat1d Kd(Ad.rows * Bd.rows, Ad.cols * Bd.cols, 0.0);
+    for (int ra = 0; ra < Ad.rows; ra++)
+    {
+        for (int ca = 0; ca < Ad.cols; ca++)
+        {
+            Kd(Range(ra*Bd.rows, (ra + 1)*Bd.rows), Range(ca*Bd.cols, (ca + 1)*Bd.cols)) = Bd.mul(Ad(ra, ca));
+        }
+    }
+
+    Mat K;
+    Kd.convertTo(K, A.type());
+    return K;
+}
+
+// quaternion multiplication
+static Mat qmult(const Mat& s, const Mat& t)
+{
+    CV_Assert(s.type() == CV_64FC1 && t.type() == CV_64FC1);
+    CV_Assert(s.rows == 4 && s.cols == 1);
+    CV_Assert(t.rows == 4 && t.cols == 1);
+
+    double s0 = s.at<double>(0,0);
+    double s1 = s.at<double>(1,0);
+    double s2 = s.at<double>(2,0);
+    double s3 = s.at<double>(3,0);
+
+    double t0 = t.at<double>(0,0);
+    double t1 = t.at<double>(1,0);
+    double t2 = t.at<double>(2,0);
+    double t3 = t.at<double>(3,0);
+
+    Mat q(4, 1, CV_64FC1);
+    q.at<double>(0,0) = s0*t0 - s1*t1 - s2*t2 - s3*t3;
+    q.at<double>(1,0) = s0*t1 + s1*t0 + s2*t3 - s3*t2;
+    q.at<double>(2,0) = s0*t2 - s1*t3 + s2*t0 + s3*t1;
+    q.at<double>(3,0) = s0*t3 + s1*t2 - s2*t1 + s3*t0;
+
+    return q;
+}
+
+// dq = homogeneous2dualQuaternion(H)
+//
+// H  - 4x4 homogeneous transformation: [R | t; 0 0 0 | 1]
+// dq - 8x1 dual quaternion: <q (rotation part), qprime (translation part)>
+static Mat homogeneous2dualQuaternion(const Mat& H)
+{
+    CV_Assert(H.type() == CV_64FC1 && H.rows == 4 && H.cols == 4);
+
+    Mat dualq(8, 1, CV_64FC1);
+    Mat R = H(Rect(0, 0, 3, 3));
+    Mat t = H(Rect(3, 0, 1, 3));
+
+    Mat q = rot2quat(R);
+    Mat qt = Mat::zeros(4, 1, CV_64FC1);
+    t.copyTo(qt(Rect(0, 1, 1, 3)));
+    Mat qprime = 0.5 * qmult(qt, q);
+
+    q.copyTo(dualq(Rect(0, 0, 1, 4)));
+    qprime.copyTo(dualq(Rect(0, 4, 1, 4)));
+
+    return dualq;
+}
+
+// H = dualQuaternion2homogeneous(dq)
+//
+// H  - 4x4 homogeneous transformation: [R | t; 0 0 0 | 1]
+// dq - 8x1 dual quaternion: <q (rotation part), qprime (translation part)>
+static Mat dualQuaternion2homogeneous(const Mat& dualq)
+{
+    CV_Assert(dualq.type() == CV_64FC1 && dualq.rows == 8 && dualq.cols == 1);
+
+    Mat q = dualq(Rect(0, 0, 1, 4));
+    Mat qprime = dualq(Rect(0, 4, 1, 4));
+
+    Mat R = quat2rot(q);
+    q.at<double>(1,0) = -q.at<double>(1,0);
+    q.at<double>(2,0) = -q.at<double>(2,0);
+    q.at<double>(3,0) = -q.at<double>(3,0);
+
+    Mat qt = 2*qmult(qprime, q);
+    Mat t = qt(Rect(0, 1, 1, 3));
+
+    Mat H = Mat::eye(4, 4, CV_64FC1);
+    R.copyTo(H(Rect(0, 0, 3, 3)));
+    t.copyTo(H(Rect(3, 0, 1, 3)));
+
+    return H;
+}
+
+//Reference:
+//R. Y. Tsai and R. K. Lenz, "A new technique for fully autonomous and efficient 3D robotics hand/eye calibration."
+//In IEEE Transactions on Robotics and Automation, vol. 5, no. 3, pp. 345-358, June 1989.
+//C++ code converted from Zoran Lazarevic's Matlab code:
+//http://lazax.com/www.cs.columbia.edu/~laza/html/Stewart/matlab/handEye.m
+static void calibrateHandEyeTsai(const std::vector<Mat>& Hg, const std::vector<Mat>& Hc,
+                                 Mat& R_cam2gripper, Mat& t_cam2gripper)
+{
+    //Number of unique camera position pairs
+    int K = static_cast<int>((Hg.size()*Hg.size() - Hg.size()) / 2.0);
+    //Will store: skew(Pgij+Pcij)
+    Mat A(3*K, 3, CV_64FC1);
+    //Will store: Pcij - Pgij
+    Mat B(3*K, 1, CV_64FC1);
+
+    std::vector<Mat> vec_Hgij, vec_Hcij;
+    vec_Hgij.reserve(static_cast<size_t>(K));
+    vec_Hcij.reserve(static_cast<size_t>(K));
+
+    int idx = 0;
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++)
+        {
+            //Defines coordinate transformation from Gi to Gj
+            //Hgi is from Gi (gripper) to RW (robot base)
+            //Hgj is from Gj (gripper) to RW (robot base)
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i]; //eq 6
+            //Rotation axis for Rgij which is the 3D rotation from gripper coordinate frame Gi to Gj
+            Mat Pgij = 2*rot2quatMinimal(Hgij);
+
+            //Defines coordinate transformation from Ci to Cj
+            //Hci is from CW (calibration target) to Ci (camera)
+            //Hcj is from CW (calibration target) to Cj (camera)
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]); //eq 7
+            //Rotation axis for Rcij
+            Mat Pcij = 2*rot2quatMinimal(Hcij);
+
+            // Discard motions with rotation too small or too close to pi radians
+            //   The limits 1.7 and 0.3 correspond to angles less than 17 degrees or greater than 120 degrees. They are
+            //   based on verifying equation 12 from the source paper using data generated with a known hand-eye
+            //   calibration. The data contained 25 poses, so 300 motions were considered. Of these, 188 satisfied
+            //   equation 12, and the remaining 112 all had Pcij or Pgij with norms greater than 1.7. Although errors
+            //   from small rotations were not observed, it is known that these motions are less informative (see
+            //   section II.B.3, and figure 6).
+            double Pgij_norm = cv::norm(Pgij);
+            double Pcij_norm = cv::norm(Pcij);
+            if (Pgij_norm < 0.3 || Pcij_norm < 0.3 || Pgij_norm > 1.7 || Pcij_norm > 1.7) {
+                continue;
+            }
+
+            vec_Hgij.push_back(Hgij);
+            vec_Hcij.push_back(Hcij);
+
+            //Left-hand side: skew(Pgij+Pcij)
+            skew(Pgij+Pcij).copyTo(A(Rect(0, idx*3, 3, 3)));
+            //Right-hand side: Pcij - Pgij
+            Mat diff = Pcij - Pgij;
+            diff.copyTo(B(Rect(0, idx*3, 1, 3)));
+            idx++;
+        }
+    }
+
+    // insufficient data
+    if (idx < 2) {
+        CV_LOG_ERROR(NULL, "Hand-eye calibration failed! Not enough informative motions--include larger rotations.");
+        return;
+    }
+    A.resize(3*idx);
+    B.resize(3*idx);
+
+    Mat Pcg_;
+    //Rotation from camera to gripper is obtained from the set of equations:
+    //    skew(Pgij+Pcij) * Pcg_ = Pcij - Pgij    (eq 12)
+    solve(A, B, Pcg_, DECOMP_SVD);
+
+    Mat Pcg_norm = Pcg_.t() * Pcg_;
+    //Obtained non-unit quaternion is scaled back to unit value that
+    //designates camera-gripper rotation
+    Mat Pcg = 2 * Pcg_ / sqrt(1 + Pcg_norm.at<double>(0,0)); //eq 14
+
+    Mat Rcg = quatMinimal2rot(Pcg/2.0);
+
+    for (size_t i = 0; i < vec_Hgij.size(); i++)
+    {
+        //Defines coordinate transformation from Gi to Gj
+        //Hgi is from Gi (gripper) to RW (robot base)
+        //Hgj is from Gj (gripper) to RW (robot base)
+        Mat Hgij = vec_Hgij[i];
+        //Defines coordinate transformation from Ci to Cj
+        //Hci is from CW (calibration target) to Ci (camera)
+        //Hcj is from CW (calibration target) to Cj (camera)
+        Mat Hcij = vec_Hcij[i];
+
+        //Left-hand side: (Rgij - I)
+        Mat diff = Hgij(Rect(0,0,3,3)) - Mat::eye(3,3,CV_64FC1);
+        diff.copyTo(A(Rect(0, static_cast<int>(i)*3, 3, 3)));
+
+        //Right-hand side: Rcg*Tcij - Tgij
+        diff = Rcg*Hcij(Rect(3, 0, 1, 3)) - Hgij(Rect(3, 0, 1, 3));
+        diff.copyTo(B(Rect(0, static_cast<int>(i)*3, 1, 3)));
+    }
+
+    Mat Tcg;
+    //Translation from camera to gripper is obtained from the set of equations:
+    //    (Rgij - I) * Tcg = Rcg*Tcij - Tgij    (eq 15)
+    solve(A, B, Tcg, DECOMP_SVD);
+
+    R_cam2gripper = Rcg;
+    t_cam2gripper = Tcg;
+}
+
+//Reference:
+//F. Park, B. Martin, "Robot Sensor Calibration: Solving AX = XB on the Euclidean Group."
+//In IEEE Transactions on Robotics and Automation, 10(5): 717-721, 1994.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateHandEyePark(const std::vector<Mat>& Hg, const std::vector<Mat>& Hc,
+                                 Mat& R_cam2gripper, Mat& t_cam2gripper)
+{
+    Mat M = Mat::zeros(3, 3, CV_64FC1);
+
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat Rgij = Hgij(Rect(0, 0, 3, 3));
+            Mat Rcij = Hcij(Rect(0, 0, 3, 3));
+
+            Mat a, b;
+            Rodrigues(Rgij, a);
+            Rodrigues(Rcij, b);
+
+            M += b * a.t();
+        }
+    }
+
+    Mat eigenvalues, eigenvectors;
+    eigen(M.t()*M, eigenvalues, eigenvectors);
+
+    Mat v = Mat::zeros(3, 3, CV_64FC1);
+    for (int i = 0; i < 3; i++) {
+        v.at<double>(i,i) = 1.0 / sqrt(eigenvalues.at<double>(i,0));
+    }
+
+    Mat R = eigenvectors.t() * v * eigenvectors * M.t();
+    R_cam2gripper = R;
+
+    int K = static_cast<int>((Hg.size()*Hg.size() - Hg.size()) / 2.0);
+    Mat C(3*K, 3, CV_64FC1);
+    Mat d(3*K, 1, CV_64FC1);
+    Mat I3 = Mat::eye(3, 3, CV_64FC1);
+
+    int idx = 0;
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++, idx++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat Rgij = Hgij(Rect(0, 0, 3, 3));
+
+            Mat tgij = Hgij(Rect(3, 0, 1, 3));
+            Mat tcij = Hcij(Rect(3, 0, 1, 3));
+
+            Mat I_tgij = I3 - Rgij;
+            I_tgij.copyTo(C(Rect(0, 3*idx, 3, 3)));
+
+            Mat A_RB = tgij - R*tcij;
+            A_RB.copyTo(d(Rect(0, 3*idx, 1, 3)));
+        }
+    }
+
+    Mat t;
+    solve(C, d, t, DECOMP_SVD);
+    t_cam2gripper = t;
+}
+
+//Reference:
+//R. Horaud, F. Dornaika, "Hand-Eye Calibration"
+//In International Journal of Robotics Research, 14(3): 195-210, 1995.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateHandEyeHoraud(const std::vector<Mat>& Hg, const std::vector<Mat>& Hc,
+                                   Mat& R_cam2gripper, Mat& t_cam2gripper)
+{
+    Mat A = Mat::zeros(4, 4, CV_64FC1);
+
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat Rgij = Hgij(Rect(0, 0, 3, 3));
+            Mat Rcij = Hcij(Rect(0, 0, 3, 3));
+
+            Mat qgij = rot2quat(Rgij);
+            if (qgij.at<double>(0, 0) < 0) {
+                qgij *= -1;
+            }
+            double r0 = qgij.at<double>(0,0);
+            double rx = qgij.at<double>(1,0);
+            double ry = qgij.at<double>(2,0);
+            double rz = qgij.at<double>(3,0);
+
+            // Q(r) Appendix A
+            Matx44d Qvi(r0, -rx, -ry, -rz,
+                        rx,  r0, -rz,  ry,
+                        ry,  rz,  r0, -rx,
+                        rz, -ry,  rx,  r0);
+
+            Mat qcij = rot2quat(Rcij);
+            if (qcij.at<double>(0, 0) < 0) {
+                qcij *= -1;
+            }
+            r0 = qcij.at<double>(0,0);
+            rx = qcij.at<double>(1,0);
+            ry = qcij.at<double>(2,0);
+            rz = qcij.at<double>(3,0);
+
+            // W(r) Appendix A
+            Matx44d Wvi(r0, -rx, -ry, -rz,
+                        rx,  r0,  rz, -ry,
+                        ry, -rz,  r0,  rx,
+                        rz,  ry, -rx,  r0);
+
+            // Ai = (Q(vi') - W(vi))^T (Q(vi') - W(vi))
+            A += (Qvi - Wvi).t() * (Qvi - Wvi);
+        }
+    }
+
+    Mat eigenvalues, eigenvectors;
+    eigen(A, eigenvalues, eigenvectors);
+
+    Mat R = quat2rot(eigenvectors.row(3).t());
+    R_cam2gripper = R;
+
+    int K = static_cast<int>((Hg.size()*Hg.size() - Hg.size()) / 2.0);
+    Mat C(3*K, 3, CV_64FC1);
+    Mat d(3*K, 1, CV_64FC1);
+    Mat I3 = Mat::eye(3, 3, CV_64FC1);
+
+    int idx = 0;
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++, idx++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat Rgij = Hgij(Rect(0, 0, 3, 3));
+
+            Mat tgij = Hgij(Rect(3, 0, 1, 3));
+            Mat tcij = Hcij(Rect(3, 0, 1, 3));
+
+            Mat I_tgij = I3 - Rgij;
+            I_tgij.copyTo(C(Rect(0, 3*idx, 3, 3)));
+
+            Mat A_RB = tgij - R*tcij;
+            A_RB.copyTo(d(Rect(0, 3*idx, 1, 3)));
+        }
+    }
+
+    Mat t;
+    solve(C, d, t, DECOMP_SVD);
+    t_cam2gripper = t;
+}
+
+static Mat_<double> normalizeRotation(const Mat_<double>& R_)
+{
+    // Make R unit determinant
+    Mat_<double> R = R_.clone();
+    double det = determinant(R);
+    if (std::fabs(det) < FLT_EPSILON)
+    {
+        CV_Error(Error::StsNoConv, "Rotation normalization issue: determinant(R) is null");
+    }
+    R = std::cbrt(std::copysign(1, det) / std::fabs(det)) * R;
+
+    // Make R orthogonal
+    Mat w, u, vt;
+    SVDecomp(R, w, u, vt);
+    R = u*vt;
+
+    // Handle reflection case
+    if (determinant(R) < 0)
+    {
+        Matx33d diag(1.0, 0.0, 0.0,
+                     0.0, 1.0, 0.0,
+                     0.0, 0.0, -1.0);
+        R = u*diag*vt;
+    }
+
+    return R;
+}
+
+//Reference:
+//N. Andreff, R. Horaud, B. Espiau, "On-line Hand-Eye Calibration."
+//In Second International Conference on 3-D Digital Imaging and Modeling (3DIM'99), pages 430-436, 1999.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateHandEyeAndreff(const std::vector<Mat>& Hg, const std::vector<Mat>& Hc,
+                                    Mat& R_cam2gripper, Mat& t_cam2gripper)
+{
+    int K = static_cast<int>((Hg.size()*Hg.size() - Hg.size()) / 2.0);
+    Mat A(12*K, 12, CV_64FC1);
+    Mat B(12*K, 1, CV_64FC1);
+
+    Mat I9 = Mat::eye(9, 9, CV_64FC1);
+    Mat I3 = Mat::eye(3, 3, CV_64FC1);
+    Mat O9x3 = Mat::zeros(9, 3, CV_64FC1);
+    Mat O9x1 = Mat::zeros(9, 1, CV_64FC1);
+
+    int idx = 0;
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++, idx++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat Rgij = Hgij(Rect(0, 0, 3, 3));
+            Mat Rcij = Hcij(Rect(0, 0, 3, 3));
+
+            Mat tgij = Hgij(Rect(3, 0, 1, 3));
+            Mat tcij = Hcij(Rect(3, 0, 1, 3));
+
+            //Eq 10
+            Mat a00 = I9 - kron(Rgij, Rcij);
+            Mat a01 = O9x3;
+            Mat a10 = kron(I3, tcij.t());
+            Mat a11 = I3 - Rgij;
+
+            a00.copyTo(A(Rect(0, idx*12, 9, 9)));
+            a01.copyTo(A(Rect(9, idx*12, 3, 9)));
+            a10.copyTo(A(Rect(0, idx*12 + 9, 9, 3)));
+            a11.copyTo(A(Rect(9, idx*12 + 9, 3, 3)));
+
+            O9x1.copyTo(B(Rect(0, idx*12, 1, 9)));
+            tgij.copyTo(B(Rect(0, idx*12 + 9, 1, 3)));
+        }
+    }
+
+    Mat X;
+    solve(A, B, X, DECOMP_SVD);
+
+    Mat R = X(Rect(0, 0, 1, 9));
+    int newSize[] = {3, 3};
+    R = R.reshape(1, 2, newSize);
+    //Eq 15
+    R_cam2gripper = normalizeRotation(R);
+    t_cam2gripper = X(Rect(0, 9, 1, 3));
+}
+
+//Reference:
+//K. Daniilidis, "Hand-Eye Calibration Using Dual Quaternions."
+//In The International Journal of Robotics Research,18(3): 286-298, 1998.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateHandEyeDaniilidis(const std::vector<Mat>& Hg, const std::vector<Mat>& Hc,
+                                       Mat& R_cam2gripper, Mat& t_cam2gripper)
+{
+    int K = static_cast<int>((Hg.size()*Hg.size() - Hg.size()) / 2.0);
+    Mat T = Mat::zeros(6*K, 8, CV_64FC1);
+
+    int idx = 0;
+    for (size_t i = 0; i < Hg.size(); i++)
+    {
+        for (size_t j = i+1; j < Hg.size(); j++, idx++)
+        {
+            Mat Hgij = homogeneousInverse(Hg[j]) * Hg[i];
+            Mat Hcij = Hc[j] * homogeneousInverse(Hc[i]);
+
+            Mat dualqa = homogeneous2dualQuaternion(Hgij);
+            if (dualqa.at<double>(0, 0) < 0) {
+                dualqa *= -1;
+            }
+            Mat dualqb = homogeneous2dualQuaternion(Hcij);
+            if (dualqb.at<double>(0, 0) < 0) {
+                dualqb *= -1;
+            }
+
+            Mat a = dualqa(Rect(0, 1, 1, 3));
+            Mat b = dualqb(Rect(0, 1, 1, 3));
+
+            Mat aprime = dualqa(Rect(0, 5, 1, 3));
+            Mat bprime = dualqb(Rect(0, 5, 1, 3));
+
+            //Eq 31
+            Mat s00 = a - b;
+            Mat s01 = skew(a + b);
+            Mat s10 = aprime - bprime;
+            Mat s11 = skew(aprime + bprime);
+            Mat s12 = a - b;
+            Mat s13 = skew(a + b);
+
+            s00.copyTo(T(Rect(0, idx*6, 1, 3)));
+            s01.copyTo(T(Rect(1, idx*6, 3, 3)));
+            s10.copyTo(T(Rect(0, idx*6 + 3, 1, 3)));
+            s11.copyTo(T(Rect(1, idx*6 + 3, 3, 3)));
+            s12.copyTo(T(Rect(4, idx*6 + 3, 1, 3)));
+            s13.copyTo(T(Rect(5, idx*6 + 3, 3, 3)));
+        }
+    }
+
+    Mat w, u, vt;
+    SVDecomp(T, w, u, vt);
+    Mat v = vt.t();
+
+    Mat u1 = v(Rect(6, 0, 1, 4));
+    Mat v1 = v(Rect(6, 4, 1, 4));
+    Mat u2 = v(Rect(7, 0, 1, 4));
+    Mat v2 = v(Rect(7, 4, 1, 4));
+
+    //Solves Eq 34, Eq 35
+    Mat ma = u1.t()*v1;
+    Mat mb = u1.t()*v2 + u2.t()*v1;
+    Mat mc = u2.t()*v2;
+
+    double a = ma.at<double>(0,0);
+    double b = mb.at<double>(0,0);
+    double c = mc.at<double>(0,0);
+
+    double s1 = (-b + sqrt(b*b - 4*a*c)) / (2*a);
+    double s2 = (-b - sqrt(b*b - 4*a*c)) / (2*a);
+
+    Mat sol1 = s1*s1*u1.t()*u1 + 2*s1*u1.t()*u2 + u2.t()*u2;
+    Mat sol2 = s2*s2*u1.t()*u1 + 2*s2*u1.t()*u2 + u2.t()*u2;
+    double s, val;
+    if (sol1.at<double>(0,0) > sol2.at<double>(0,0))
+    {
+        s = s1;
+        val = sol1.at<double>(0,0);
+    }
+    else
+    {
+        s = s2;
+        val = sol2.at<double>(0,0);
+    }
+
+    double lambda2 = sqrt(1.0 / val);
+    double lambda1 = s * lambda2;
+
+    Mat dualq = lambda1 * v(Rect(6, 0, 1, 8)) + lambda2*v(Rect(7, 0, 1, 8));
+    Mat X = dualQuaternion2homogeneous(dualq);
+
+    Mat R = X(Rect(0, 0, 3, 3));
+    Mat t = X(Rect(3, 0, 1, 3));
+    R_cam2gripper = R;
+    t_cam2gripper = t;
+}
+
+void calibrateHandEye(InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base,
+                      InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam,
+                      OutputArray R_cam2gripper, OutputArray t_cam2gripper,
+                      HandEyeCalibrationMethod method)
+{
+    CV_Assert(R_gripper2base.isMatVector() && t_gripper2base.isMatVector() &&
+              R_target2cam.isMatVector() && t_target2cam.isMatVector());
+
+    std::vector<Mat> R_gripper2base_, t_gripper2base_;
+    R_gripper2base.getMatVector(R_gripper2base_);
+    t_gripper2base.getMatVector(t_gripper2base_);
+
+    std::vector<Mat> R_target2cam_, t_target2cam_;
+    R_target2cam.getMatVector(R_target2cam_);
+    t_target2cam.getMatVector(t_target2cam_);
+
+    CV_Assert(R_gripper2base_.size() == t_gripper2base_.size() &&
+              R_target2cam_.size() == t_target2cam_.size() &&
+              R_gripper2base_.size() == R_target2cam_.size());
+    CV_Check(R_gripper2base_.size(), R_gripper2base_.size() >= 3, "At least 3 measurements are needed");
+
+    //Notation used in Tsai paper
+    //Defines coordinate transformation from G (gripper) to RW (robot base)
+    std::vector<Mat> Hg;
+    Hg.reserve(R_gripper2base_.size());
+    for (size_t i = 0; i < R_gripper2base_.size(); i++)
+    {
+        Mat m = Mat::eye(4, 4, CV_64FC1);
+        Mat R = m(Rect(0, 0, 3, 3));
+        if(R_gripper2base_[i].size() == Size(3, 3))
+            R_gripper2base_[i].convertTo(R, CV_64F);
+        else
+        {
+            cv::Mat R_temp;
+            Rodrigues(R_gripper2base_[i], R_temp);
+            R_temp.convertTo(R, CV_64F);
+        }
+
+        Mat t = m(Rect(3, 0, 1, 3));
+        t_gripper2base_[i].convertTo(t, CV_64F);
+
+        Hg.push_back(m);
+    }
+
+    //Defines coordinate transformation from CW (calibration target) to C (camera)
+    std::vector<Mat> Hc;
+    Hc.reserve(R_target2cam_.size());
+    for (size_t i = 0; i < R_target2cam_.size(); i++)
+    {
+        Mat m = Mat::eye(4, 4, CV_64FC1);
+        Mat R = m(Rect(0, 0, 3, 3));
+        if(R_target2cam_[i].size() == Size(3, 3))
+            R_target2cam_[i].convertTo(R, CV_64F);
+        else
+        {
+            cv::Mat R_temp;
+            Rodrigues(R_target2cam_[i], R_temp);
+            R_temp.convertTo(R, CV_64F);
+        }
+
+        Mat t = m(Rect(3, 0, 1, 3));
+        t_target2cam_[i].convertTo(t, CV_64F);
+
+        Hc.push_back(m);
+    }
+
+    Mat Rcg = Mat::eye(3, 3, CV_64FC1);
+    Mat Tcg = Mat::zeros(3, 1, CV_64FC1);
+
+    switch (method)
+    {
+    case CALIB_HAND_EYE_TSAI:
+        calibrateHandEyeTsai(Hg, Hc, Rcg, Tcg);
+        break;
+
+    case CALIB_HAND_EYE_PARK:
+        calibrateHandEyePark(Hg, Hc, Rcg, Tcg);
+        break;
+
+    case CALIB_HAND_EYE_HORAUD:
+        calibrateHandEyeHoraud(Hg, Hc, Rcg, Tcg);
+        break;
+
+    case CALIB_HAND_EYE_ANDREFF:
+        calibrateHandEyeAndreff(Hg, Hc, Rcg, Tcg);
+        break;
+
+    case CALIB_HAND_EYE_DANIILIDIS:
+        calibrateHandEyeDaniilidis(Hg, Hc, Rcg, Tcg);
+        break;
+
+    default:
+        break;
+    }
+
+    Rcg.copyTo(R_cam2gripper);
+    Tcg.copyTo(t_cam2gripper);
+}
+
+//Reference:
+//M. Shah, "Solving the robot-world/hand-eye calibration problem using the kronecker product"
+//Journal of Mechanisms and Robotics, vol. 5, p. 031007, 2013.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateRobotWorldHandEyeShah(const std::vector<Mat_<double>>& cRw, const std::vector<Mat_<double>>& ctw,
+                                           const std::vector<Mat_<double>>& gRb, const std::vector<Mat_<double>>& gtb,
+                                           Matx33d& wRb, Matx31d& wtb, Matx33d& cRg, Matx31d& ctg)
+{
+    Mat_<double> T = Mat_<double>::zeros(9, 9);
+    for (size_t i = 0; i < cRw.size(); i++)
+    {
+        T += kron(gRb[i], cRw[i]);
+    }
+
+    Mat_<double> w, u, vt;
+    SVDecomp(T, w, u, vt);
+
+    Mat_<double> RX(3,3), RZ(3,3);
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            RX(j,i) = vt(0, i*3+j);
+            RZ(j,i) = u(i*3+j, 0);
+        }
+    }
+
+    wRb = normalizeRotation(RX);
+    cRg = normalizeRotation(RZ);
+    Mat_<double> Z = Mat(cRg.t()).reshape(1, 9);
+
+    const int n = static_cast<int>(cRw.size());
+    Mat_<double> A = Mat_<double>::zeros(3*n, 6);
+    Mat_<double> b = Mat_<double>::zeros(3*n, 1);
+    Mat_<double> I3 = Mat_<double>::eye(3,3);
+
+    for (int i = 0; i < n; i++)
+    {
+        Mat cRw_ = -cRw[i];
+        cRw_.copyTo(A(Range(i*3, (i+1)*3), Range(0,3)));
+        I3.copyTo(A(Range(i*3, (i+1)*3), Range(3,6)));
+
+        Mat ctw_ = ctw[i] - kron(gtb[i].t(), I3) * Z;
+        ctw_.copyTo(b(Range(i*3, (i+1)*3), Range::all()));
+    }
+
+    Mat_<double> t;
+    solve(A, b, t, DECOMP_SVD);
+
+    for (int i = 0; i < 3; i++)
+    {
+        wtb(i) = t(i);
+        ctg(i) = t(i+3);
+    }
+}
+
+//Reference:
+//A. Li, L. Wang, and D. Wu, "Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product"
+//International Journal of Physical Sciences, vol. 5, pp. 1530-1536, 2010.
+//Matlab code: http://math.loyola.edu/~mili/Calibration/
+static void calibrateRobotWorldHandEyeLi(const std::vector<Mat_<double>>& cRw, const std::vector<Mat_<double>>& ctw,
+                                         const std::vector<Mat_<double>>& gRb, const std::vector<Mat_<double>>& gtb,
+                                         Matx33d& wRb, Matx31d& wtb, Matx33d& cRg, Matx31d& ctg)
+{
+    const int n = static_cast<int>(cRw.size());
+    Mat_<double> A = Mat_<double>::zeros(12*n, 24);
+    Mat_<double> b = Mat_<double>::zeros(12*n, 1);
+    Mat_<double> I3 = Mat_<double>::eye(3,3);
+
+    for (int i = 0; i < n; i++)
+    {
+        //Eq 19
+        kron(cRw[i], I3).copyTo(A(Range(i*12, i*12 + 9), Range(0, 9)));
+        kron(-I3, gRb[i].t()).copyTo(A(Range(i*12, i*12 + 9), Range(9, 18)));
+
+        kron(I3, gtb[i].t()).copyTo(A(Range(i*12 + 9, (i+1)*12), Range(9, 18)));
+        Mat cRw_ = -cRw[i];
+        cRw_.copyTo(A(Range(i*12 + 9, (i+1)*12), Range(18, 21)));
+        I3.copyTo(A(Range(i*12 + 9, (i+1)*12), Range(21, 24)));
+
+        ctw[i].copyTo(b(Range(i*12 + 9, i*12+12), Range::all()));
+    }
+
+    Mat_<double> x;
+    solve(A, b, x, DECOMP_SVD);
+
+    Mat_<double> RX = x(Range(0,9), Range::all()).reshape(3, 3);
+    wRb = normalizeRotation(RX);
+    x(Range(18,21), Range::all()).copyTo(wtb);
+
+    Mat_<double> RZ = x(Range(9,18), Range::all()).reshape(3, 3);
+    cRg = normalizeRotation(RZ);
+    x(Range(21,24), Range::all()).copyTo(ctg);
+}
+
+void calibrateRobotWorldHandEye(InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam,
+                                InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper,
+                                OutputArray R_base2world, OutputArray t_base2world,
+                                OutputArray R_gripper2cam, OutputArray t_gripper2cam,
+                                RobotWorldHandEyeCalibrationMethod method)
+{
+    CV_Assert(R_base2gripper.isMatVector() && t_base2gripper.isMatVector() &&
+              R_world2cam.isMatVector() && t_world2cam.isMatVector());
+
+    std::vector<Mat> R_base2gripper_tmp, t_base2gripper_tmp;
+    R_base2gripper.getMatVector(R_base2gripper_tmp);
+    t_base2gripper.getMatVector(t_base2gripper_tmp);
+
+    std::vector<Mat> R_world2cam_tmp, t_world2cam_tmp;
+    R_world2cam.getMatVector(R_world2cam_tmp);
+    t_world2cam.getMatVector(t_world2cam_tmp);
+
+    CV_Assert(R_base2gripper_tmp.size() == t_base2gripper_tmp.size() &&
+              R_world2cam_tmp.size() == t_world2cam_tmp.size() &&
+              R_base2gripper_tmp.size() == R_world2cam_tmp.size());
+    CV_Check(R_base2gripper_tmp.size(), R_base2gripper_tmp.size() >= 3, "At least 3 measurements are needed");
+
+    // Convert to double
+    std::vector<Mat_<double>> R_base2gripper_, t_base2gripper_;
+    std::vector<Mat_<double>> R_world2cam_, t_world2cam_;
+
+    R_base2gripper_.reserve(R_base2gripper_tmp.size());
+    t_base2gripper_.reserve(R_base2gripper_tmp.size());
+    R_world2cam_.reserve(R_world2cam_tmp.size());
+    t_world2cam_.reserve(R_base2gripper_tmp.size());
+
+    // Convert to rotation matrix if needed
+    for (size_t i = 0; i < R_base2gripper_tmp.size(); i++)
+    {
+        {
+            Mat rot = R_base2gripper_tmp[i];
+            Mat R(3, 3, CV_64FC1);
+            if (rot.size() == Size(3,3))
+            {
+                rot.convertTo(R, CV_64F);
+                R_base2gripper_.push_back(R);
+            }
+            else
+            {
+                cv::Mat R_temp;
+                Rodrigues(rot, R_temp);
+                R_temp.convertTo(R, CV_64F);
+                R_base2gripper_.push_back(R);
+            }
+            Mat tvec = t_base2gripper_tmp[i];
+            Mat t;
+            tvec.convertTo(t, CV_64F);
+            t_base2gripper_.push_back(t);
+        }
+        {
+            Mat rot  = R_world2cam_tmp[i];
+            Mat R(3, 3, CV_64FC1);
+            if (rot.size() == Size(3,3))
+            {
+                rot.convertTo(R, CV_64F);
+                R_world2cam_.push_back(R);
+            }
+            else
+            {
+                cv::Mat R_temp;
+                Rodrigues(rot, R_temp);
+                R_temp.convertTo(R, CV_64F);
+                R_world2cam_.push_back(R);
+            }
+            Mat tvec = t_world2cam_tmp[i];
+            Mat t;
+            tvec.convertTo(t, CV_64F);
+            t_world2cam_.push_back(t);
+        }
+    }
+
+    CV_Assert(R_world2cam_.size() == t_world2cam_.size() &&
+              R_base2gripper_.size() == t_base2gripper_.size() &&
+              R_world2cam_.size() == R_base2gripper_.size());
+
+    Matx33d wRb, cRg;
+    Matx31d wtb, ctg;
+    switch (method)
+    {
+    case CALIB_ROBOT_WORLD_HAND_EYE_SHAH:
+        calibrateRobotWorldHandEyeShah(R_world2cam_, t_world2cam_, R_base2gripper_, t_base2gripper_, wRb, wtb, cRg, ctg);
+        break;
+
+    case CALIB_ROBOT_WORLD_HAND_EYE_LI:
+        calibrateRobotWorldHandEyeLi(R_world2cam_, t_world2cam_, R_base2gripper_, t_base2gripper_, wRb, wtb, cRg, ctg);
+        break;
+    }
+
+    Mat(wRb).copyTo(R_base2world);
+    Mat(wtb).copyTo(t_base2world);
+
+    Mat(cRg).copyTo(R_gripper2cam);
+    Mat(ctg).copyTo(t_gripper2cam);
+}
+
+}
diff --git a/upstream/opencv/modules/calib/src/distortion_model.hpp b/upstream/opencv/modules/calib/src/distortion_model.hpp
new file mode 100644
index 0000000..308da01
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/distortion_model.hpp
@@ -0,0 +1,123 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
+#define OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
+
+//! @cond IGNORED
+
+namespace cv {
+/**
+Computes the matrix for the projection onto a tilted image sensor
+\param tauX angular parameter rotation around x-axis
+\param tauY angular parameter rotation around y-axis
+\param matTilt if not NULL returns the matrix
+\f[
+\vecthreethree{R_{33}(\tau_x, \tau_y)}{0}{-R_{13}((\tau_x, \tau_y)}
+{0}{R_{33}(\tau_x, \tau_y)}{-R_{23}(\tau_x, \tau_y)}
+{0}{0}{1} R(\tau_x, \tau_y)
+\f]
+where
+\f[
+R(\tau_x, \tau_y) =
+\vecthreethree{\cos(\tau_y)}{0}{-\sin(\tau_y)}{0}{1}{0}{\sin(\tau_y)}{0}{\cos(\tau_y)}
+\vecthreethree{1}{0}{0}{0}{\cos(\tau_x)}{\sin(\tau_x)}{0}{-\sin(\tau_x)}{\cos(\tau_x)} =
+\vecthreethree{\cos(\tau_y)}{\sin(\tau_y)\sin(\tau_x)}{-\sin(\tau_y)\cos(\tau_x)}
+{0}{\cos(\tau_x)}{\sin(\tau_x)}
+{\sin(\tau_y)}{-\cos(\tau_y)\sin(\tau_x)}{\cos(\tau_y)\cos(\tau_x)}.
+\f]
+\param dMatTiltdTauX if not NULL it returns the derivative of matTilt with
+respect to \f$\tau_x\f$.
+\param dMatTiltdTauY if not NULL it returns the derivative of matTilt with
+respect to \f$\tau_y\f$.
+\param invMatTilt if not NULL it returns the inverse of matTilt
+**/
+template <typename FLOAT>
+void computeTiltProjectionMatrix(FLOAT tauX,
+    FLOAT tauY,
+    Matx<FLOAT, 3, 3>* matTilt = 0,
+    Matx<FLOAT, 3, 3>* dMatTiltdTauX = 0,
+    Matx<FLOAT, 3, 3>* dMatTiltdTauY = 0,
+    Matx<FLOAT, 3, 3>* invMatTilt = 0)
+{
+    FLOAT cTauX = std::cos(tauX);
+    FLOAT sTauX = std::sin(tauX);
+    FLOAT cTauY = std::cos(tauY);
+    FLOAT sTauY = std::sin(tauY);
+    Matx<FLOAT, 3, 3> matRotX = Matx<FLOAT, 3, 3>(1,0,0,0,cTauX,sTauX,0,-sTauX,cTauX);
+    Matx<FLOAT, 3, 3> matRotY = Matx<FLOAT, 3, 3>(cTauY,0,-sTauY,0,1,0,sTauY,0,cTauY);
+    Matx<FLOAT, 3, 3> matRotXY = matRotY * matRotX;
+    Matx<FLOAT, 3, 3> matProjZ = Matx<FLOAT, 3, 3>(matRotXY(2,2),0,-matRotXY(0,2),0,matRotXY(2,2),-matRotXY(1,2),0,0,1);
+    if (matTilt)
+    {
+        // Matrix for trapezoidal distortion of tilted image sensor
+        *matTilt = matProjZ * matRotXY;
+    }
+    if (dMatTiltdTauX)
+    {
+        // Derivative with respect to tauX
+        Matx<FLOAT, 3, 3> dMatRotXYdTauX = matRotY * Matx<FLOAT, 3, 3>(0,0,0,0,-sTauX,cTauX,0,-cTauX,-sTauX);
+        Matx<FLOAT, 3, 3> dMatProjZdTauX = Matx<FLOAT, 3, 3>(dMatRotXYdTauX(2,2),0,-dMatRotXYdTauX(0,2),
+          0,dMatRotXYdTauX(2,2),-dMatRotXYdTauX(1,2),0,0,0);
+        *dMatTiltdTauX = (matProjZ * dMatRotXYdTauX) + (dMatProjZdTauX * matRotXY);
+    }
+    if (dMatTiltdTauY)
+    {
+        // Derivative with respect to tauY
+        Matx<FLOAT, 3, 3> dMatRotXYdTauY = Matx<FLOAT, 3, 3>(-sTauY,0,-cTauY,0,0,0,cTauY,0,-sTauY) * matRotX;
+        Matx<FLOAT, 3, 3> dMatProjZdTauY = Matx<FLOAT, 3, 3>(dMatRotXYdTauY(2,2),0,-dMatRotXYdTauY(0,2),
+          0,dMatRotXYdTauY(2,2),-dMatRotXYdTauY(1,2),0,0,0);
+        *dMatTiltdTauY = (matProjZ * dMatRotXYdTauY) + (dMatProjZdTauY * matRotXY);
+    }
+    if (invMatTilt)
+    {
+        FLOAT inv = 1./matRotXY(2,2);
+        Matx<FLOAT, 3, 3> invMatProjZ = Matx<FLOAT, 3, 3>(inv,0,inv*matRotXY(0,2),0,inv,inv*matRotXY(1,2),0,0,1);
+        *invMatTilt = matRotXY.t()*invMatProjZ;
+    }
+}
+} // namespace detail, cv
+
+
+//! @endcond
+
+#endif // OPENCV_IMGPROC_DETAIL_DISTORTION_MODEL_HPP
diff --git a/upstream/opencv/modules/calib/src/fisheye.cpp b/upstream/opencv/modules/calib/src/fisheye.cpp
new file mode 100644
index 0000000..45d29ec
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/fisheye.cpp
@@ -0,0 +1,1050 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "fisheye.hpp"
+#include <limits>
+
+namespace cv {
+namespace {
+
+void subMatrix(const Mat& src, Mat& dst, const std::vector<uchar>& cols, const std::vector<uchar>& rows);
+
+}}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// cv::fisheye::calibrate
+
+double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,
+                                    InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                    int flags , cv::TermCriteria criteria)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!objectPoints.empty() && !imagePoints.empty() && objectPoints.total() == imagePoints.total());
+    CV_Assert(objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3);
+    CV_Assert(imagePoints.type() == CV_32FC2 || imagePoints.type() == CV_64FC2);
+    CV_Assert(K.empty() || (K.size() == Size(3,3)));
+    CV_Assert(D.empty() || (D.total() == 4));
+    CV_Assert(rvecs.empty() || (rvecs.channels() == 3));
+    CV_Assert(tvecs.empty() || (tvecs.channels() == 3));
+
+    CV_Assert((!K.empty() && !D.empty()) || !(flags & CALIB_USE_INTRINSIC_GUESS));
+
+    using namespace cv::internal;
+    //-------------------------------Initialization
+    IntrinsicParams finalParam;
+    IntrinsicParams currentParam;
+    IntrinsicParams errors;
+
+    finalParam.isEstimate[0] = flags & CALIB_FIX_FOCAL_LENGTH ? 0 : 1;
+    finalParam.isEstimate[1] = flags & CALIB_FIX_FOCAL_LENGTH ? 0 : 1;
+    finalParam.isEstimate[2] = flags & CALIB_FIX_PRINCIPAL_POINT ? 0 : 1;
+    finalParam.isEstimate[3] = flags & CALIB_FIX_PRINCIPAL_POINT ? 0 : 1;
+    finalParam.isEstimate[4] = flags & CALIB_FIX_SKEW ? 0 : 1;
+    finalParam.isEstimate[5] = flags & CALIB_FIX_K1 ? 0 : 1;
+    finalParam.isEstimate[6] = flags & CALIB_FIX_K2 ? 0 : 1;
+    finalParam.isEstimate[7] = flags & CALIB_FIX_K3 ? 0 : 1;
+    finalParam.isEstimate[8] = flags & CALIB_FIX_K4 ? 0 : 1;
+
+    const int recompute_extrinsic = flags & CALIB_RECOMPUTE_EXTRINSIC ? 1: 0;
+    const int check_cond = flags & CALIB_CHECK_COND ? 1 : 0;
+
+    const double alpha_smooth = 0.4;
+    const double thresh_cond = 1e6;
+    double change = 1;
+    Vec2d err_std;
+
+    Matx33d _K;
+    Vec4d _D;
+    if (flags & CALIB_USE_INTRINSIC_GUESS)
+    {
+        K.getMat().convertTo(_K, CV_64FC1);
+        D.getMat().convertTo(_D, CV_64FC1);
+        finalParam.Init(Vec2d(_K(0,0), _K(1, 1)),
+                        Vec2d(_K(0,2), _K(1, 2)),
+                        Vec4d(flags & CALIB_FIX_K1 ? 0 : _D[0],
+                              flags & CALIB_FIX_K2 ? 0 : _D[1],
+                              flags & CALIB_FIX_K3 ? 0 : _D[2],
+                              flags & CALIB_FIX_K4 ? 0 : _D[3]),
+                        _K(0, 1) / _K(0, 0));
+    }
+    else
+    {
+        finalParam.Init(Vec2d(max(image_size.width, image_size.height) / 2., max(image_size.width, image_size.height) / 2.),
+                        Vec2d(image_size.width  / 2.0 - 0.5, image_size.height / 2.0 - 0.5));
+    }
+
+    errors.isEstimate = finalParam.isEstimate;
+
+    std::vector<Vec3d> omc(objectPoints.total()), Tc(objectPoints.total());
+
+    CalibrateExtrinsics(objectPoints, imagePoints, finalParam, check_cond, thresh_cond, omc, Tc);
+
+
+    //-------------------------------Optimization
+    for(int iter = 0; iter < std::numeric_limits<int>::max(); ++iter)
+    {
+        if ((criteria.type == 1 && iter >= criteria.maxCount)  ||
+            (criteria.type == 2 && change <= criteria.epsilon) ||
+            (criteria.type == 3 && (change <= criteria.epsilon || iter >= criteria.maxCount)))
+            break;
+
+        double alpha_smooth2 = 1 - std::pow(1 - alpha_smooth, iter + 1.0);
+
+        Mat JJ2, ex3;
+        ComputeJacobians(objectPoints, imagePoints, finalParam, omc, Tc, check_cond,thresh_cond, JJ2, ex3);
+
+        Mat G;
+        solve(JJ2, ex3, G);
+        currentParam = finalParam + alpha_smooth2*G;
+
+        change = norm(Vec4d(currentParam.f[0], currentParam.f[1], currentParam.c[0], currentParam.c[1]) -
+                Vec4d(finalParam.f[0], finalParam.f[1], finalParam.c[0], finalParam.c[1]))
+                / norm(Vec4d(currentParam.f[0], currentParam.f[1], currentParam.c[0], currentParam.c[1]));
+
+        finalParam = currentParam;
+
+        if (recompute_extrinsic)
+        {
+            CalibrateExtrinsics(objectPoints,  imagePoints, finalParam, check_cond,
+                                    thresh_cond, omc, Tc);
+        }
+    }
+
+    //-------------------------------Validation
+    double rms;
+    EstimateUncertainties(objectPoints, imagePoints, finalParam,  omc, Tc, errors, err_std, thresh_cond,
+                              check_cond, rms);
+
+    //-------------------------------
+    _K = Matx33d(finalParam.f[0], finalParam.f[0] * finalParam.alpha, finalParam.c[0],
+            0,                    finalParam.f[1], finalParam.c[1],
+            0,                                  0,               1);
+
+    if (K.needed()) Mat(_K).convertTo(K, K.empty() ? CV_64FC1 : K.type());
+    if (D.needed()) Mat(finalParam.k).convertTo(D, D.empty() ? CV_64FC1 : D.type());
+    if (rvecs.isMatVector())
+    {
+        int N = (int)objectPoints.total();
+
+        if(rvecs.empty())
+            rvecs.create(N, 1, CV_64FC3);
+
+        if(tvecs.empty())
+            tvecs.create(N, 1, CV_64FC3);
+
+        for(int i = 0; i < N; i++ )
+        {
+            rvecs.create(3, 1, CV_64F, i, true);
+            tvecs.create(3, 1, CV_64F, i, true);
+            memcpy(rvecs.getMat(i).ptr(), omc[i].val, sizeof(Vec3d));
+            memcpy(tvecs.getMat(i).ptr(), Tc[i].val, sizeof(Vec3d));
+        }
+    }
+    else
+    {
+        if (rvecs.needed()) Mat(omc).reshape(3, (int)omc.size()).convertTo(rvecs, rvecs.empty() ? CV_64FC3 : rvecs.type());
+        if (tvecs.needed()) Mat(Tc).reshape(3, (int)Tc.size()).convertTo(tvecs, tvecs.empty() ? CV_64FC3 : tvecs.type());
+    }
+
+    return rms;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/// cv::fisheye::stereoCalibrate
+
+double cv::fisheye::stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                    InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
+                                    OutputArray R, OutputArray T, int flags, TermCriteria criteria)
+{
+    return cv::fisheye::stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T,
+                                        noArray(), noArray(), flags, criteria);
+}
+
+double cv::fisheye::stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,
+                                    InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,
+                                    OutputArray R, OutputArray T, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
+                                    int flags, TermCriteria criteria)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!objectPoints.empty() && !imagePoints1.empty() && !imagePoints2.empty());
+    CV_Assert(objectPoints.total() == imagePoints1.total() || imagePoints1.total() == imagePoints2.total());
+    CV_Assert(objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3);
+    CV_Assert(imagePoints1.type() == CV_32FC2 || imagePoints1.type() == CV_64FC2);
+    CV_Assert(imagePoints2.type() == CV_32FC2 || imagePoints2.type() == CV_64FC2);
+
+    CV_Assert(K1.empty() || (K1.size() == Size(3,3)));
+    CV_Assert(D1.empty() || (D1.total() == 4));
+    CV_Assert(K2.empty() || (K2.size() == Size(3,3)));
+    CV_Assert(D2.empty() || (D2.total() == 4));
+
+    CV_Assert((!K1.empty() && !K2.empty() && !D1.empty() && !D2.empty()) || !(flags & CALIB_FIX_INTRINSIC));
+
+    //-------------------------------Initialization
+
+    const int threshold = 50;
+    const double thresh_cond = 1e6;
+    const int check_cond = 1;
+
+    int n_points = (int)objectPoints.getMat(0).total();
+    int n_images = (int)objectPoints.total();
+
+    double change = 1;
+
+    cv::internal::IntrinsicParams intrinsicLeft;
+    cv::internal::IntrinsicParams intrinsicRight;
+
+    cv::internal::IntrinsicParams intrinsicLeft_errors;
+    cv::internal::IntrinsicParams intrinsicRight_errors;
+
+    Matx33d _K1, _K2;
+    Vec4d _D1, _D2;
+    if (!K1.empty()) K1.getMat().convertTo(_K1, CV_64FC1);
+    if (!D1.empty()) D1.getMat().convertTo(_D1, CV_64FC1);
+    if (!K2.empty()) K2.getMat().convertTo(_K2, CV_64FC1);
+    if (!D2.empty()) D2.getMat().convertTo(_D2, CV_64FC1);
+
+    std::vector<Vec3d> rvecs1(n_images), tvecs1(n_images), rvecs2(n_images), tvecs2(n_images);
+
+    if (!(flags & CALIB_FIX_INTRINSIC))
+    {
+        calibrate(objectPoints, imagePoints1, imageSize, _K1, _D1, rvecs1, tvecs1, flags, TermCriteria(3, 20, 1e-6));
+        calibrate(objectPoints, imagePoints2, imageSize, _K2, _D2, rvecs2, tvecs2, flags, TermCriteria(3, 20, 1e-6));
+    }
+
+    intrinsicLeft.Init(Vec2d(_K1(0,0), _K1(1, 1)), Vec2d(_K1(0,2), _K1(1, 2)),
+                       Vec4d(_D1[0], _D1[1], _D1[2], _D1[3]), _K1(0, 1) / _K1(0, 0));
+
+    intrinsicRight.Init(Vec2d(_K2(0,0), _K2(1, 1)), Vec2d(_K2(0,2), _K2(1, 2)),
+                        Vec4d(_D2[0], _D2[1], _D2[2], _D2[3]), _K2(0, 1) / _K2(0, 0));
+
+    if ((flags & CALIB_FIX_INTRINSIC))
+    {
+        cv::internal::CalibrateExtrinsics(objectPoints,  imagePoints1, intrinsicLeft, check_cond, thresh_cond, rvecs1, tvecs1);
+        cv::internal::CalibrateExtrinsics(objectPoints,  imagePoints2, intrinsicRight, check_cond, thresh_cond, rvecs2, tvecs2);
+    }
+
+    intrinsicLeft.isEstimate[0] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicLeft.isEstimate[1] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicLeft.isEstimate[2] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicLeft.isEstimate[3] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicLeft.isEstimate[4] = flags & (CALIB_FIX_SKEW | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicLeft.isEstimate[5] = flags & (CALIB_FIX_K1 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicLeft.isEstimate[6] = flags & (CALIB_FIX_K2 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicLeft.isEstimate[7] = flags & (CALIB_FIX_K3 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicLeft.isEstimate[8] = flags & (CALIB_FIX_K4 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+
+    intrinsicRight.isEstimate[0] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicRight.isEstimate[1] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicRight.isEstimate[2] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicRight.isEstimate[3] = flags & CALIB_FIX_INTRINSIC ? 0 : 1;
+    intrinsicRight.isEstimate[4] = flags & (CALIB_FIX_SKEW | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicRight.isEstimate[5] = flags & (CALIB_FIX_K1 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicRight.isEstimate[6] = flags & (CALIB_FIX_K2 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicRight.isEstimate[7] = flags & (CALIB_FIX_K3 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+    intrinsicRight.isEstimate[8] = flags & (CALIB_FIX_K4 | CALIB_FIX_INTRINSIC) ? 0 : 1;
+
+    intrinsicLeft_errors.isEstimate = intrinsicLeft.isEstimate;
+    intrinsicRight_errors.isEstimate = intrinsicRight.isEstimate;
+
+    std::vector<uchar> selectedParams;
+    std::vector<uchar> tmp(6 * (n_images + 1), 1);
+    selectedParams.insert(selectedParams.end(), intrinsicLeft.isEstimate.begin(), intrinsicLeft.isEstimate.end());
+    selectedParams.insert(selectedParams.end(), intrinsicRight.isEstimate.begin(), intrinsicRight.isEstimate.end());
+    selectedParams.insert(selectedParams.end(), tmp.begin(), tmp.end());
+
+    //Init values for rotation and translation between two views
+    Mat om_list(1, n_images, CV_64FC3), T_list(1, n_images, CV_64FC3);
+    Mat om_ref, R_ref, T_ref, R1, R2;
+    for (int image_idx = 0; image_idx < n_images; ++image_idx)
+    {
+        Rodrigues(rvecs1[image_idx], R1);
+        Rodrigues(rvecs2[image_idx], R2);
+        R_ref = R2 * R1.t();
+        T_ref = Mat(tvecs2[image_idx]) - R_ref * Mat(tvecs1[image_idx]);
+        Rodrigues(R_ref, om_ref);
+        om_ref.reshape(3, 1).copyTo(om_list.col(image_idx));
+        T_ref.reshape(3, 1).copyTo(T_list.col(image_idx));
+    }
+    Vec3d omcur = cv::internal::median3d(om_list);
+    Vec3d Tcur  = cv::internal::median3d(T_list);
+
+    Mat J = Mat::zeros(4 * n_points * n_images, 18 + 6 * (n_images + 1), CV_64FC1),
+            e = Mat::zeros(4 * n_points * n_images, 1, CV_64FC1), Jkk, ekk;
+
+    for(int iter = 0; ; ++iter)
+    {
+        if ((criteria.type == 1 && iter >= criteria.maxCount)  ||
+            (criteria.type == 2 && change <= criteria.epsilon) ||
+            (criteria.type == 3 && (change <= criteria.epsilon || iter >= criteria.maxCount)))
+            break;
+
+        J.create(4 * n_points * n_images, 18 + 6 * (n_images + 1), CV_64FC1);
+        e.create(4 * n_points * n_images, 1, CV_64FC1);
+        Jkk.create(4 * n_points, 18 + 6 * (n_images + 1), CV_64FC1);
+        ekk.create(4 * n_points, 1, CV_64FC1);
+
+        Mat omr, Tr, domrdomckk, domrdTckk, domrdom, domrdT, dTrdomckk, dTrdTckk, dTrdom, dTrdT;
+
+        for (int image_idx = 0; image_idx < n_images; ++image_idx)
+        {
+            Jkk = Mat::zeros(4 * n_points, 18 + 6 * (n_images + 1), CV_64FC1);
+
+            Mat object  = objectPoints.getMat(image_idx).clone();
+            Mat imageLeft  = imagePoints1.getMat(image_idx).clone();
+            Mat imageRight  = imagePoints2.getMat(image_idx).clone();
+            Mat jacobians, projected;
+
+            //left camera jacobian
+            Mat rvec = Mat(rvecs1[image_idx]);
+            Mat tvec  = Mat(tvecs1[image_idx]);
+            cv::internal::projectPoints(object, projected, rvec, tvec, intrinsicLeft, jacobians);
+            Mat pt_diff = imageLeft.reshape(1, n_points*2) -
+                          projected.reshape(1, n_points*2);
+            pt_diff.copyTo(ekk.rowRange(0, 2 * n_points));
+            jacobians.colRange(8, 11).copyTo(Jkk.colRange(24 + image_idx * 6, 27 + image_idx * 6).rowRange(0, 2 * n_points));
+            jacobians.colRange(11, 14).copyTo(Jkk.colRange(27 + image_idx * 6, 30 + image_idx * 6).rowRange(0, 2 * n_points));
+            jacobians.colRange(0, 2).copyTo(Jkk.colRange(0, 2).rowRange(0, 2 * n_points));
+            jacobians.colRange(2, 4).copyTo(Jkk.colRange(2, 4).rowRange(0, 2 * n_points));
+            jacobians.colRange(4, 8).copyTo(Jkk.colRange(5, 9).rowRange(0, 2 * n_points));
+            jacobians.col(14).copyTo(Jkk.col(4).rowRange(0, 2 * n_points));
+
+            //right camera jacobian
+            cv::internal::compose_motion(rvec, tvec, omcur, Tcur, omr, Tr, domrdomckk, domrdTckk, domrdom, domrdT, dTrdomckk, dTrdTckk, dTrdom, dTrdT);
+            rvec = Mat(rvecs2[image_idx]);
+            tvec  = Mat(tvecs2[image_idx]);
+
+            cv::internal::projectPoints(object, projected, omr, Tr, intrinsicRight, jacobians);
+
+            pt_diff = imageRight.reshape(1, n_points*2) -
+                      projected.reshape(1, n_points*2);
+            pt_diff.copyTo(ekk.rowRange(2 * n_points, 4 * n_points));
+            Mat dxrdom = jacobians.colRange(8, 11) * domrdom + jacobians.colRange(11, 14) * dTrdom;
+            Mat dxrdT = jacobians.colRange(8, 11) * domrdT + jacobians.colRange(11, 14)* dTrdT;
+            Mat dxrdomckk = jacobians.colRange(8, 11) * domrdomckk + jacobians.colRange(11, 14) * dTrdomckk;
+            Mat dxrdTckk = jacobians.colRange(8, 11) * domrdTckk + jacobians.colRange(11, 14) * dTrdTckk;
+
+            dxrdom.copyTo(Jkk.colRange(18, 21).rowRange(2 * n_points, 4 * n_points));
+            dxrdT.copyTo(Jkk.colRange(21, 24).rowRange(2 * n_points, 4 * n_points));
+            dxrdomckk.copyTo(Jkk.colRange(24 + image_idx * 6, 27 + image_idx * 6).rowRange(2 * n_points, 4 * n_points));
+            dxrdTckk.copyTo(Jkk.colRange(27 + image_idx * 6, 30 + image_idx * 6).rowRange(2 * n_points, 4 * n_points));
+            jacobians.colRange(0, 2).copyTo(Jkk.colRange(9 + 0, 9 + 2).rowRange(2 * n_points, 4 * n_points));
+            jacobians.colRange(2, 4).copyTo(Jkk.colRange(9 + 2, 9 + 4).rowRange(2 * n_points, 4 * n_points));
+            jacobians.colRange(4, 8).copyTo(Jkk.colRange(9 + 5, 9 + 9).rowRange(2 * n_points, 4 * n_points));
+            jacobians.col(14).copyTo(Jkk.col(9 + 4).rowRange(2 * n_points, 4 * n_points));
+
+            //check goodness of sterepair
+            double abs_max  = 0;
+            for (int i = 0; i < 4 * n_points; i++)
+            {
+                if (fabs(ekk.at<double>(i)) > abs_max)
+                {
+                    abs_max = fabs(ekk.at<double>(i));
+                }
+            }
+
+            CV_Assert(abs_max < threshold); // bad stereo pair
+
+            Jkk.copyTo(J.rowRange(image_idx * 4 * n_points, (image_idx + 1) * 4 * n_points));
+            ekk.copyTo(e.rowRange(image_idx * 4 * n_points, (image_idx + 1) * 4 * n_points));
+        }
+
+        Vec6d oldTom(Tcur[0], Tcur[1], Tcur[2], omcur[0], omcur[1], omcur[2]);
+
+        //update all parameters
+        cv::subMatrix(J, J, selectedParams, std::vector<uchar>(J.rows, 1));
+        int a = cv::countNonZero(intrinsicLeft.isEstimate);
+        int b = cv::countNonZero(intrinsicRight.isEstimate);
+        Mat deltas;
+        solve(J.t() * J, J.t()*e, deltas);
+        if (a > 0)
+            intrinsicLeft = intrinsicLeft + deltas.rowRange(0, a);
+        if (b > 0)
+            intrinsicRight = intrinsicRight + deltas.rowRange(a, a + b);
+        omcur = omcur + Vec3d(deltas.rowRange(a + b, a + b + 3));
+        Tcur = Tcur + Vec3d(deltas.rowRange(a + b + 3, a + b + 6));
+        for (int image_idx = 0; image_idx < n_images; ++image_idx)
+        {
+            rvecs1[image_idx] = Mat(Mat(rvecs1[image_idx]) + deltas.rowRange(a + b + 6 + image_idx * 6, a + b + 9 + image_idx * 6));
+            tvecs1[image_idx] = Mat(Mat(tvecs1[image_idx]) + deltas.rowRange(a + b + 9 + image_idx * 6, a + b + 12 + image_idx * 6));
+        }
+
+        Vec6d newTom(Tcur[0], Tcur[1], Tcur[2], omcur[0], omcur[1], omcur[2]);
+        change = cv::norm(newTom - oldTom) / cv::norm(newTom);
+    }
+
+    double rms = 0;
+    const Vec2d* ptr_e = e.ptr<Vec2d>();
+    for (size_t i = 0; i < e.total() / 2; i++)
+    {
+        rms += ptr_e[i][0] * ptr_e[i][0] + ptr_e[i][1] * ptr_e[i][1];
+    }
+
+    rms /= ((double)e.total() / 2.0);
+    rms = sqrt(rms);
+
+    _K1 = Matx33d(intrinsicLeft.f[0], intrinsicLeft.f[0] * intrinsicLeft.alpha, intrinsicLeft.c[0],
+                                   0,                       intrinsicLeft.f[1], intrinsicLeft.c[1],
+                                   0,                                        0,                 1);
+
+    _K2 = Matx33d(intrinsicRight.f[0], intrinsicRight.f[0] * intrinsicRight.alpha, intrinsicRight.c[0],
+                                    0,                        intrinsicRight.f[1], intrinsicRight.c[1],
+                                    0,                                          0,                  1);
+
+    Mat _R;
+    Rodrigues(omcur, _R);
+
+    if (K1.needed()) Mat(_K1).convertTo(K1, K1.empty() ? CV_64FC1 : K1.type());
+    if (K2.needed()) Mat(_K2).convertTo(K2, K2.empty() ? CV_64FC1 : K2.type());
+    if (D1.needed()) Mat(intrinsicLeft.k).convertTo(D1, D1.empty() ? CV_64FC1 : D1.type());
+    if (D2.needed()) Mat(intrinsicRight.k).convertTo(D2, D2.empty() ? CV_64FC1 : D2.type());
+    if (R.needed()) _R.convertTo(R, R.empty() ? CV_64FC1 : R.type());
+    if (T.needed()) Mat(Tcur).convertTo(T, T.empty() ? CV_64FC1 : T.type());
+    if (rvecs.isMatVector())
+    {
+        if(rvecs.empty())
+            rvecs.create(n_images, 1, CV_64FC3);
+
+        if(tvecs.empty())
+            tvecs.create(n_images, 1, CV_64FC3);
+
+        for(int i = 0; i < n_images; i++ )
+        {
+            rvecs.create(3, 1, CV_64F, i, true);
+            tvecs.create(3, 1, CV_64F, i, true);
+            rvecs1[i].copyTo(rvecs.getMat(i));
+            tvecs1[i].copyTo(tvecs.getMat(i));
+        }
+    }
+    else
+    {
+        if (rvecs.needed()) cv::Mat(rvecs1).convertTo(rvecs, rvecs.empty() ? CV_64FC3 : rvecs.type());
+        if (tvecs.needed()) cv::Mat(tvecs1).convertTo(tvecs, tvecs.empty() ? CV_64FC3 : tvecs.type());
+    }
+
+    return rms;
+}
+
+namespace cv{ namespace {
+void subMatrix(const Mat& src, Mat& dst, const std::vector<uchar>& cols, const std::vector<uchar>& rows)
+{
+    CV_Assert(src.channels() == 1);
+
+    int nonzeros_cols = cv::countNonZero(cols);
+    Mat tmp(src.rows, nonzeros_cols, CV_64F);
+
+    for (int i = 0, j = 0; i < (int)cols.size(); i++)
+    {
+        if (cols[i])
+        {
+            src.col(i).copyTo(tmp.col(j++));
+        }
+    }
+
+    int nonzeros_rows  = cv::countNonZero(rows);
+    dst.create(nonzeros_rows, nonzeros_cols, CV_64F);
+    for (int i = 0, j = 0; i < (int)rows.size(); i++)
+    {
+        if (rows[i])
+        {
+            tmp.row(i).copyTo(dst.row(j++));
+        }
+    }
+}
+
+}}
+
+cv::internal::IntrinsicParams::IntrinsicParams():
+    f(Vec2d::all(0)), c(Vec2d::all(0)), k(Vec4d::all(0)), alpha(0), isEstimate(9,0)
+{
+}
+
+cv::internal::IntrinsicParams::IntrinsicParams(Vec2d _f, Vec2d _c, Vec4d _k, double _alpha):
+    f(_f), c(_c), k(_k), alpha(_alpha), isEstimate(9,0)
+{
+}
+
+cv::internal::IntrinsicParams cv::internal::IntrinsicParams::operator+(const Mat& a)
+{
+    CV_Assert(a.type() == CV_64FC1);
+    IntrinsicParams tmp;
+    const double* ptr = a.ptr<double>();
+
+    int j = 0;
+    tmp.f[0]    = this->f[0]    + (isEstimate[0] ? ptr[j++] : 0);
+    tmp.f[1]    = this->f[1]    + (isEstimate[1] ? ptr[j++] : 0);
+    tmp.c[0]    = this->c[0]    + (isEstimate[2] ? ptr[j++] : 0);
+    tmp.c[1]    = this->c[1]    + (isEstimate[3] ? ptr[j++] : 0);
+    tmp.alpha   = this->alpha   + (isEstimate[4] ? ptr[j++] : 0);
+    tmp.k[0]    = this->k[0]    + (isEstimate[5] ? ptr[j++] : 0);
+    tmp.k[1]    = this->k[1]    + (isEstimate[6] ? ptr[j++] : 0);
+    tmp.k[2]    = this->k[2]    + (isEstimate[7] ? ptr[j++] : 0);
+    tmp.k[3]    = this->k[3]    + (isEstimate[8] ? ptr[j++] : 0);
+
+    tmp.isEstimate = isEstimate;
+    return tmp;
+}
+
+cv::internal::IntrinsicParams& cv::internal::IntrinsicParams::operator =(const Mat& a)
+{
+    CV_Assert(a.type() == CV_64FC1);
+    const double* ptr = a.ptr<double>();
+
+    int j = 0;
+
+    this->f[0]  = isEstimate[0] ? ptr[j++] : 0;
+    this->f[1]  = isEstimate[1] ? ptr[j++] : 0;
+    this->c[0]  = isEstimate[2] ? ptr[j++] : 0;
+    this->c[1]  = isEstimate[3] ? ptr[j++] : 0;
+    this->alpha = isEstimate[4] ? ptr[j++] : 0;
+    this->k[0]  = isEstimate[5] ? ptr[j++] : 0;
+    this->k[1]  = isEstimate[6] ? ptr[j++] : 0;
+    this->k[2]  = isEstimate[7] ? ptr[j++] : 0;
+    this->k[3]  = isEstimate[8] ? ptr[j++] : 0;
+
+    return *this;
+}
+
+void cv::internal::IntrinsicParams::Init(const Vec2d& _f, const Vec2d& _c, const Vec4d& _k, const double& _alpha)
+{
+    this->c = _c;
+    this->f = _f;
+    this->k = _k;
+    this->alpha = _alpha;
+}
+
+void cv::internal::projectPoints(cv::InputArray objectPoints, cv::OutputArray imagePoints,
+                   cv::InputArray _rvec,cv::InputArray _tvec,
+                   const IntrinsicParams& param, cv::OutputArray jacobian)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!objectPoints.empty() && (objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3));
+    Matx33d K(param.f[0], param.f[0] * param.alpha, param.c[0],
+                       0,               param.f[1], param.c[1],
+                       0,                        0,         1);
+    fisheye::projectPoints(objectPoints, imagePoints, _rvec, _tvec, K, param.k, param.alpha, jacobian);
+}
+
+void cv::internal::ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
+                            Mat&  tvec, Mat& J, const int MaxIter,
+                            const IntrinsicParams& param, const double thresh_cond)
+{
+    CV_Assert(!objectPoints.empty() && objectPoints.type() == CV_64FC3);
+    CV_Assert(!imagePoints.empty() && imagePoints.type() == CV_64FC2);
+    CV_Assert(rvec.total() > 2 && tvec.total() > 2);
+    Vec6d extrinsics(rvec.at<double>(0), rvec.at<double>(1), rvec.at<double>(2),
+                    tvec.at<double>(0), tvec.at<double>(1), tvec.at<double>(2));
+    double change = 1;
+    int iter = 0;
+
+    while (change > 1e-10 && iter < MaxIter)
+    {
+        std::vector<Point2d> x;
+        Mat jacobians;
+        projectPoints(objectPoints, x, rvec, tvec, param, jacobians);
+
+        Mat ex = imagePoints - Mat(x);
+        ex = ex.reshape(1, 2);
+
+        J = jacobians.colRange(8, 14).clone();
+
+        SVD svd(J, SVD::NO_UV);
+        double condJJ = svd.w.at<double>(0)/svd.w.at<double>(5);
+
+        if (condJJ > thresh_cond)
+            change = 0;
+        else
+        {
+            Vec6d param_innov;
+            solve(J, ex.reshape(1, (int)ex.total()), param_innov, DECOMP_SVD + DECOMP_NORMAL);
+
+            Vec6d param_up = extrinsics + param_innov;
+            change = norm(param_innov)/norm(param_up);
+            extrinsics = param_up;
+            iter = iter + 1;
+
+            rvec = Mat(Vec3d(extrinsics.val));
+            tvec = Mat(Vec3d(extrinsics.val+3));
+        }
+    }
+}
+
+cv::Mat cv::internal::ComputeHomography(Mat m, Mat M)
+{
+    CV_INSTRUMENT_REGION();
+
+    int Np = m.cols;
+
+    if (m.rows < 3)
+    {
+        vconcat(m, Mat::ones(1, Np, CV_64FC1), m);
+    }
+    if (M.rows < 3)
+    {
+        vconcat(M, Mat::ones(1, Np, CV_64FC1), M);
+    }
+
+    divide(m, Mat::ones(3, 1, CV_64FC1) * m.row(2), m);
+    divide(M, Mat::ones(3, 1, CV_64FC1) * M.row(2), M);
+
+    Mat ax = m.row(0).clone();
+    Mat ay = m.row(1).clone();
+
+    double mxx = mean(ax)[0];
+    double myy = mean(ay)[0];
+
+    ax = ax - mxx;
+    ay = ay - myy;
+
+    double scxx = mean(abs(ax))[0];
+    double scyy = mean(abs(ay))[0];
+
+    Mat Hnorm (Matx33d( 1/scxx,        0.0,     -mxx/scxx,
+                         0.0,     1/scyy,     -myy/scyy,
+                         0.0,        0.0,           1.0 ));
+
+    Mat inv_Hnorm (Matx33d( scxx,     0,   mxx,
+                                    0,  scyy,   myy,
+                                    0,     0,     1 ));
+    Mat mn =  Hnorm * m;
+
+    Mat L = Mat::zeros(2*Np, 9, CV_64FC1);
+
+    for (int i = 0; i < Np; ++i)
+    {
+        for (int j = 0; j < 3; j++)
+        {
+            L.at<double>(2 * i, j) = M.at<double>(j, i);
+            L.at<double>(2 * i + 1, j + 3) = M.at<double>(j, i);
+            L.at<double>(2 * i, j + 6) = -mn.at<double>(0,i) * M.at<double>(j, i);
+            L.at<double>(2 * i + 1, j + 6) = -mn.at<double>(1,i) * M.at<double>(j, i);
+        }
+    }
+
+    if (Np > 4) L = L.t() * L;
+    SVD svd(L);
+    Mat hh = svd.vt.row(8) / svd.vt.row(8).at<double>(8);
+    Mat Hrem = hh.reshape(1, 3);
+    Mat H = inv_Hnorm * Hrem;
+
+    if (Np > 4)
+    {
+        Mat hhv = H.reshape(1, 9)(Rect(0, 0, 1, 8)).clone();
+        for (int iter = 0; iter < 10; iter++)
+        {
+            Mat mrep = H * M;
+            Mat J = Mat::zeros(2 * Np, 8, CV_64FC1);
+            Mat MMM;
+            divide(M, Mat::ones(3, 1, CV_64FC1) * mrep(Rect(0, 2, mrep.cols, 1)), MMM);
+            divide(mrep, Mat::ones(3, 1, CV_64FC1) * mrep(Rect(0, 2, mrep.cols, 1)), mrep);
+            Mat m_err = m(Rect(0,0, m.cols, 2)) - mrep(Rect(0,0, mrep.cols, 2));
+            m_err = Mat(m_err.t()).reshape(1, m_err.cols * m_err.rows);
+            Mat MMM2, MMM3;
+            multiply(Mat::ones(3, 1, CV_64FC1) * mrep(Rect(0, 0, mrep.cols, 1)), MMM, MMM2);
+            multiply(Mat::ones(3, 1, CV_64FC1) * mrep(Rect(0, 1, mrep.cols, 1)), MMM, MMM3);
+
+            for (int i = 0; i < Np; ++i)
+            {
+                for (int j = 0; j < 3; ++j)
+                {
+                    J.at<double>(2 * i, j)         = -MMM.at<double>(j, i);
+                    J.at<double>(2 * i + 1, j + 3) = -MMM.at<double>(j, i);
+                }
+
+                for (int j = 0; j < 2; ++j)
+                {
+                    J.at<double>(2 * i, j + 6)     = MMM2.at<double>(j, i);
+                    J.at<double>(2 * i + 1, j + 6) = MMM3.at<double>(j, i);
+                }
+            }
+            divide(M, Mat::ones(3, 1, CV_64FC1) * mrep(Rect(0,2,mrep.cols,1)), MMM);
+            Mat hh_innov = (J.t() * J).inv() * (J.t()) * m_err;
+            Mat hhv_up = hhv - hh_innov;
+            Mat tmp;
+            vconcat(hhv_up, Mat::ones(1,1,CV_64FC1), tmp);
+            Mat H_up = tmp.reshape(1,3);
+            hhv = hhv_up;
+            H = H_up;
+        }
+    }
+    return H;
+}
+
+cv::Mat cv::internal::NormalizePixels(const Mat& imagePoints, const IntrinsicParams& param)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!imagePoints.empty() && imagePoints.type() == CV_64FC2);
+
+    Mat distorted((int)imagePoints.total(), 1, CV_64FC2), undistorted;
+    const Vec2d* ptr   = imagePoints.ptr<Vec2d>();
+    Vec2d* ptr_d = distorted.ptr<Vec2d>();
+    for (size_t i = 0; i < imagePoints.total(); ++i)
+    {
+        ptr_d[i] = (ptr[i] - param.c).mul(Vec2d(1.0 / param.f[0], 1.0 / param.f[1]));
+        ptr_d[i][0] -= param.alpha * ptr_d[i][1];
+    }
+    cv::fisheye::undistortPoints(distorted, undistorted, Matx33d::eye(), param.k);
+    return undistorted;
+}
+
+void cv::internal::InitExtrinsics(const Mat& _imagePoints, const Mat& _objectPoints, const IntrinsicParams& param, Mat& omckk, Mat& Tckk)
+{
+    CV_Assert(!_objectPoints.empty() && _objectPoints.type() == CV_64FC3);
+    CV_Assert(!_imagePoints.empty() && _imagePoints.type() == CV_64FC2);
+
+    Mat imagePointsNormalized = NormalizePixels(_imagePoints, param).reshape(1).t();
+    Mat objectPoints = _objectPoints.reshape(1).t();
+    Mat objectPointsMean, covObjectPoints;
+    Mat Rckk;
+    int Np = imagePointsNormalized.cols;
+    calcCovarMatrix(objectPoints, covObjectPoints, objectPointsMean, COVAR_NORMAL | COVAR_COLS);
+    SVD svd(covObjectPoints);
+    Mat R(svd.vt);
+    if (norm(R(Rect(2, 0, 1, 2))) < 1e-6)
+        R = Mat::eye(3,3, CV_64FC1);
+    if (determinant(R) < 0)
+        R = -R;
+    Mat T = -R * objectPointsMean;
+    Mat X_new = R * objectPoints + T * Mat::ones(1, Np, CV_64FC1);
+    Mat H = ComputeHomography(imagePointsNormalized, X_new(Rect(0,0,X_new.cols,2)));
+    double sc = .5 * (norm(H.col(0)) + norm(H.col(1)));
+    H = H / sc;
+    Mat u1 = H.col(0).clone();
+    double norm_u1 = norm(u1);
+    CV_Assert(fabs(norm_u1) > 0);
+    u1  = u1 / norm_u1;
+    Mat u2 = H.col(1).clone() - u1.dot(H.col(1).clone()) * u1;
+    double norm_u2 = norm(u2);
+    CV_Assert(fabs(norm_u2) > 0);
+    u2 = u2 / norm_u2;
+    Mat u3 = u1.cross(u2);
+    Mat RRR;
+    hconcat(u1, u2, RRR);
+    hconcat(RRR, u3, RRR);
+    Rodrigues(RRR, omckk);
+    Rodrigues(omckk, Rckk);
+    Tckk = H.col(2).clone();
+    Tckk = Tckk + Rckk * T;
+    Rckk = Rckk * R;
+    Rodrigues(Rckk, omckk);
+}
+
+void cv::internal::CalibrateExtrinsics(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                         const IntrinsicParams& param, const int check_cond,
+                         const double thresh_cond, InputOutputArray omc, InputOutputArray Tc)
+{
+    CV_Assert(!objectPoints.empty() && (objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3));
+    CV_Assert(!imagePoints.empty() && (imagePoints.type() == CV_32FC2 || imagePoints.type() == CV_64FC2));
+    CV_Assert(omc.type() == CV_64FC3 || Tc.type() == CV_64FC3);
+
+    if (omc.empty()) omc.create(1, (int)objectPoints.total(), CV_64FC3);
+    if (Tc.empty()) Tc.create(1, (int)objectPoints.total(), CV_64FC3);
+
+    const int maxIter = 20;
+
+    for(int image_idx = 0; image_idx < (int)imagePoints.total(); ++image_idx)
+    {
+        Mat omckk, Tckk, JJ_kk;
+        Mat image, object;
+
+        objectPoints.getMat(image_idx).convertTo(object,  CV_64FC3);
+        imagePoints.getMat (image_idx).convertTo(image, CV_64FC2);
+
+        bool imT = image.rows < image.cols;
+        bool obT = object.rows < object.cols;
+
+        InitExtrinsics(imT ? image.t() : image, obT ? object.t() : object, param, omckk, Tckk);
+
+        ComputeExtrinsicRefine(!imT ? image.t() : image, !obT ? object.t() : object, omckk, Tckk, JJ_kk, maxIter, param, thresh_cond);
+        if (check_cond)
+        {
+            SVD svd(JJ_kk, SVD::NO_UV);
+            if(svd.w.at<double>(0) / svd.w.at<double>((int)svd.w.total() - 1) > thresh_cond )
+                CV_Error( cv::Error::StsInternal, format("CALIB_CHECK_COND - Ill-conditioned matrix for input array %d",image_idx));
+        }
+        omckk.reshape(3,1).copyTo(omc.getMat().col(image_idx));
+        Tckk.reshape(3,1).copyTo(Tc.getMat().col(image_idx));
+    }
+}
+
+void cv::internal::ComputeJacobians(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                      const IntrinsicParams& param,  InputArray omc, InputArray Tc,
+                      const int& check_cond, const double& thresh_cond, Mat& JJ2, Mat& ex3)
+{
+    CV_Assert(!objectPoints.empty() && (objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3));
+    CV_Assert(!imagePoints.empty() && (imagePoints.type() == CV_32FC2 || imagePoints.type() == CV_64FC2));
+
+    CV_Assert(!omc.empty() && omc.type() == CV_64FC3);
+    CV_Assert(!Tc.empty() && Tc.type() == CV_64FC3);
+
+    int n = (int)objectPoints.total();
+
+    JJ2 = Mat::zeros(9 + 6 * n, 9 + 6 * n, CV_64FC1);
+    ex3 = Mat::zeros(9 + 6 * n, 1, CV_64FC1 );
+
+    for (int image_idx = 0; image_idx < n; ++image_idx)
+    {
+        Mat image, object;
+        objectPoints.getMat(image_idx).convertTo(object, CV_64FC3);
+        imagePoints.getMat (image_idx).convertTo(image, CV_64FC2);
+
+        bool imT = image.channels() == 1 && image.rows > image.cols;
+        Mat om(omc.getMat().col(image_idx)), T(Tc.getMat().col(image_idx));
+
+        std::vector<Point2d> x;
+        Mat jacobians;
+        projectPoints(object, x, om, T, param, jacobians);
+        Mat exkk = (imT ? image.t() : image) - Mat(x);
+
+        Mat A(jacobians.rows, 9, CV_64FC1);
+        jacobians.colRange(0, 4).copyTo(A.colRange(0, 4));
+        jacobians.col(14).copyTo(A.col(4));
+        jacobians.colRange(4, 8).copyTo(A.colRange(5, 9));
+
+        A = A.t();
+
+        Mat B = jacobians.colRange(8, 14).clone();
+        B = B.t();
+
+        JJ2(Rect(0, 0, 9, 9)) += A * A.t();
+        JJ2(Rect(9 + 6 * image_idx, 9 + 6 * image_idx, 6, 6)) = B * B.t();
+
+        JJ2(Rect(9 + 6 * image_idx, 0, 6, 9)) = A * B.t();
+        JJ2(Rect(0, 9 + 6 * image_idx, 9, 6)) = JJ2(Rect(9 + 6 * image_idx, 0, 6, 9)).t();
+
+        Mat exkk_col = exkk.reshape(1, 2 * (int)exkk.total());
+        ex3.rowRange(0, 9) += A * exkk_col;
+        ex3.rowRange(9 + 6 * image_idx, 9 + 6 * (image_idx + 1)) = B *  exkk_col;
+
+        if (check_cond)
+        {
+            Mat JJ_kk = B.t();
+            SVD svd(JJ_kk, SVD::NO_UV);
+            CV_Assert(svd.w.at<double>(0) / svd.w.at<double>(svd.w.rows - 1) < thresh_cond);
+        }
+    }
+
+    std::vector<uchar> idxs(param.isEstimate);
+    idxs.insert(idxs.end(), 6 * n, 1);
+
+    subMatrix(JJ2, JJ2, idxs, idxs);
+    subMatrix(ex3, ex3, std::vector<uchar>(1, 1), idxs);
+}
+
+void cv::internal::EstimateUncertainties(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                           const IntrinsicParams& params, InputArray omc, InputArray Tc,
+                           IntrinsicParams& errors, Vec2d& std_err, double thresh_cond, int check_cond, double& rms)
+{
+    CV_Assert(!objectPoints.empty() && (objectPoints.type() == CV_32FC3 || objectPoints.type() == CV_64FC3));
+    CV_Assert(!imagePoints.empty() && (imagePoints.type() == CV_32FC2 || imagePoints.type() == CV_64FC2));
+
+    CV_Assert(!omc.empty() && omc.type() == CV_64FC3);
+    CV_Assert(!Tc.empty() && Tc.type() == CV_64FC3);
+
+    int total_ex = 0;
+    for (int image_idx = 0; image_idx < (int)objectPoints.total(); ++image_idx)
+    {
+        total_ex += (int)objectPoints.getMat(image_idx).total();
+    }
+    Mat ex(total_ex, 1, CV_64FC2);
+    int insert_idx = 0;
+    for (int image_idx = 0; image_idx < (int)objectPoints.total(); ++image_idx)
+    {
+        Mat image, object;
+        objectPoints.getMat(image_idx).convertTo(object, CV_64FC3);
+        imagePoints.getMat (image_idx).convertTo(image, CV_64FC2);
+
+        bool imT = image.channels() == 1 && image.rows > image.cols;
+
+        Mat om(omc.getMat().col(image_idx)), T(Tc.getMat().col(image_idx));
+
+        std::vector<Point2d> x;
+        projectPoints(object, x, om, T, params, noArray());
+        Mat ex_ = (imT ? image.t() : image) - Mat(x);
+        ex_ = ex_.reshape(2, (int)ex_.total());
+        ex_.copyTo(ex.rowRange(insert_idx, insert_idx + ex_.rows));
+        insert_idx += ex_.rows;
+    }
+
+    meanStdDev(ex, noArray(), std_err);
+    std_err *= sqrt((double)ex.total()/((double)ex.total() - 1.0));
+
+    Vec<double, 1> sigma_x;
+    meanStdDev(ex.reshape(1, 1), noArray(), sigma_x);
+
+    Mat JJ2, ex3;
+    ComputeJacobians(objectPoints, imagePoints, params, omc, Tc, check_cond, thresh_cond, JJ2, ex3);
+
+    sqrt(JJ2.inv(), JJ2);
+
+    int nParams = JJ2.rows;
+    // an explanation of that denominator correction can be found here:
+    // R. Hartley, A. Zisserman, Multiple View Geometry in Computer Vision, 2004, section 5.1.3, page 134
+    // see the discussion for more details: https://github.com/opencv/opencv/pull/22992
+    sigma_x  *= sqrt(2.0 * (double)ex.total()/(2.0 * (double)ex.total() - nParams));
+
+    errors = 3 * sigma_x(0) * JJ2.diag();
+    rms = sqrt(norm(ex, NORM_L2SQR)/ex.total());
+}
+
+void cv::internal::dAB(InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
+{
+    CV_Assert(A.getMat().cols == B.getMat().rows);
+    CV_Assert(A.type() == CV_64FC1 && B.type() == CV_64FC1);
+
+    int p = A.getMat().rows;
+    int n = A.getMat().cols;
+    int q = B.getMat().cols;
+
+    dABdA.create(p * q, p * n, CV_64FC1);
+    dABdB.create(p * q, q * n, CV_64FC1);
+
+    dABdA.getMat() = Mat::zeros(p * q, p * n, CV_64FC1);
+    dABdB.getMat() = Mat::zeros(p * q, q * n, CV_64FC1);
+
+    for (int i = 0; i < q; ++i)
+    {
+        for (int j = 0; j < p; ++j)
+        {
+            int ij = j + i * p;
+            for (int k = 0; k < n; ++k)
+            {
+                int kj = j + k * p;
+                dABdA.getMat().at<double>(ij, kj) = B.getMat().at<double>(k, i);
+            }
+        }
+    }
+
+    for (int i = 0; i < q; ++i)
+    {
+        A.getMat().copyTo(dABdB.getMat().rowRange(i * p, i * p + p).colRange(i * n, i * n + n));
+    }
+}
+
+void cv::internal::JRodriguesMatlab(const Mat& src, Mat& dst)
+{
+    Mat tmp(src.cols, src.rows, src.type());
+    if (src.rows == 9)
+    {
+        Mat(src.row(0).t()).copyTo(tmp.col(0));
+        Mat(src.row(1).t()).copyTo(tmp.col(3));
+        Mat(src.row(2).t()).copyTo(tmp.col(6));
+        Mat(src.row(3).t()).copyTo(tmp.col(1));
+        Mat(src.row(4).t()).copyTo(tmp.col(4));
+        Mat(src.row(5).t()).copyTo(tmp.col(7));
+        Mat(src.row(6).t()).copyTo(tmp.col(2));
+        Mat(src.row(7).t()).copyTo(tmp.col(5));
+        Mat(src.row(8).t()).copyTo(tmp.col(8));
+    }
+    else
+    {
+        Mat(src.col(0).t()).copyTo(tmp.row(0));
+        Mat(src.col(1).t()).copyTo(tmp.row(3));
+        Mat(src.col(2).t()).copyTo(tmp.row(6));
+        Mat(src.col(3).t()).copyTo(tmp.row(1));
+        Mat(src.col(4).t()).copyTo(tmp.row(4));
+        Mat(src.col(5).t()).copyTo(tmp.row(7));
+        Mat(src.col(6).t()).copyTo(tmp.row(2));
+        Mat(src.col(7).t()).copyTo(tmp.row(5));
+        Mat(src.col(8).t()).copyTo(tmp.row(8));
+    }
+    dst = tmp.clone();
+}
+
+void cv::internal::compose_motion(InputArray _om1, InputArray _T1, InputArray _om2, InputArray _T2,
+                    Mat& om3, Mat& T3, Mat& dom3dom1, Mat& dom3dT1, Mat& dom3dom2,
+                    Mat& dom3dT2, Mat& dT3dom1, Mat& dT3dT1, Mat& dT3dom2, Mat& dT3dT2)
+{
+    Mat om1 = _om1.getMat();
+    Mat om2 = _om2.getMat();
+    Mat T1 = _T1.getMat().reshape(1, 3);
+    Mat T2 = _T2.getMat().reshape(1, 3);
+
+    //% Rotations:
+    Mat R1, R2, R3, dR1dom1(9, 3, CV_64FC1), dR2dom2;
+    Rodrigues(om1, R1, dR1dom1);
+    Rodrigues(om2, R2, dR2dom2);
+    JRodriguesMatlab(dR1dom1, dR1dom1);
+    JRodriguesMatlab(dR2dom2, dR2dom2);
+    R3 = R2 * R1;
+    Mat dR3dR2, dR3dR1;
+    dAB(R2, R1, dR3dR2, dR3dR1);
+    Mat dom3dR3;
+    Rodrigues(R3, om3, dom3dR3);
+    JRodriguesMatlab(dom3dR3, dom3dR3);
+    dom3dom1 = dom3dR3 * dR3dR1 * dR1dom1;
+    dom3dom2 = dom3dR3 * dR3dR2 * dR2dom2;
+    dom3dT1 = Mat::zeros(3, 3, CV_64FC1);
+    dom3dT2 = Mat::zeros(3, 3, CV_64FC1);
+
+    //% Translations:
+    Mat T3t = R2 * T1;
+    Mat dT3tdR2, dT3tdT1;
+    dAB(R2, T1, dT3tdR2, dT3tdT1);
+    Mat dT3tdom2 = dT3tdR2 * dR2dom2;
+    T3 = T3t + T2;
+    dT3dT1 = dT3tdT1;
+    dT3dT2 = Mat::eye(3, 3, CV_64FC1);
+    dT3dom2 = dT3tdom2;
+    dT3dom1 = Mat::zeros(3, 3, CV_64FC1);
+}
+
+double cv::internal::median(const Mat& row)
+{
+    CV_Assert(row.type() == CV_64FC1);
+    CV_Assert(!row.empty() && row.rows == 1);
+    Mat tmp = row.clone();
+    sort(tmp, tmp, 0);
+    if ((int)tmp.total() % 2) return tmp.at<double>((int)tmp.total() / 2);
+    else return 0.5 *(tmp.at<double>((int)tmp.total() / 2) + tmp.at<double>((int)tmp.total() / 2 - 1));
+}
+
+cv::Vec3d cv::internal::median3d(InputArray m)
+{
+    CV_Assert(m.depth() == CV_64F && m.getMat().rows == 1);
+    Mat M = Mat(m.getMat().t()).reshape(1).t();
+    return Vec3d(median(M.row(0)), median(M.row(1)), median(M.row(2)));
+}
diff --git a/upstream/opencv/modules/calib/src/fisheye.hpp b/upstream/opencv/modules/calib/src/fisheye.hpp
new file mode 100644
index 0000000..d46ac86
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/fisheye.hpp
@@ -0,0 +1,61 @@
+#ifndef FISHEYE_INTERNAL_H
+#define FISHEYE_INTERNAL_H
+#include "precomp.hpp"
+
+namespace cv { namespace internal {
+
+struct CV_EXPORTS IntrinsicParams
+{
+    Vec2d f;
+    Vec2d c;
+    Vec4d k;
+    double alpha;
+    std::vector<uchar> isEstimate;
+
+    IntrinsicParams();
+    IntrinsicParams(Vec2d f, Vec2d c, Vec4d k, double alpha = 0);
+    IntrinsicParams operator+(const Mat& a);
+    IntrinsicParams& operator =(const Mat& a);
+    void Init(const cv::Vec2d& f, const cv::Vec2d& c, const cv::Vec4d& k = Vec4d(0,0,0,0), const double& alpha = 0);
+};
+
+void projectPoints(cv::InputArray objectPoints, cv::OutputArray imagePoints,
+                   cv::InputArray _rvec,cv::InputArray _tvec,
+                   const IntrinsicParams& param, cv::OutputArray jacobian);
+
+void ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
+                            Mat&  tvec, Mat& J, const int MaxIter,
+                            const IntrinsicParams& param, const double thresh_cond);
+CV_EXPORTS Mat ComputeHomography(Mat m, Mat M);
+
+CV_EXPORTS Mat NormalizePixels(const Mat& imagePoints, const IntrinsicParams& param);
+
+void InitExtrinsics(const Mat& _imagePoints, const Mat& _objectPoints, const IntrinsicParams& param, Mat& omckk, Mat& Tckk);
+
+void CalibrateExtrinsics(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                         const IntrinsicParams& param, const int check_cond,
+                         const double thresh_cond, InputOutputArray omc, InputOutputArray Tc);
+
+void ComputeJacobians(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                      const IntrinsicParams& param,  InputArray omc, InputArray Tc,
+                      const int& check_cond, const double& thresh_cond, Mat& JJ2_inv, Mat& ex3);
+
+CV_EXPORTS void  EstimateUncertainties(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints,
+                           const IntrinsicParams& params, InputArray omc, InputArray Tc,
+                           IntrinsicParams& errors, Vec2d& std_err, double thresh_cond, int check_cond, double& rms);
+
+void dAB(cv::InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB);
+
+void JRodriguesMatlab(const Mat& src, Mat& dst);
+
+void compose_motion(InputArray _om1, InputArray _T1, InputArray _om2, InputArray _T2,
+                    Mat& om3, Mat& T3, Mat& dom3dom1, Mat& dom3dT1, Mat& dom3dom2,
+                    Mat& dom3dT2, Mat& dT3dom1, Mat& dT3dT1, Mat& dT3dom2, Mat& dT3dT2);
+
+double median(const Mat& row);
+
+Vec3d median3d(InputArray m);
+
+}}
+
+#endif
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/main.cpp b/upstream/opencv/modules/calib/src/main.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/main.cpp
rename to upstream/opencv/modules/calib/src/main.cpp
diff --git a/upstream/opencv/modules/calib/src/multiview_calibration.cpp b/upstream/opencv/modules/calib/src/multiview_calibration.cpp
new file mode 100644
index 0000000..5804b10
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/multiview_calibration.cpp
@@ -0,0 +1,988 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "opencv2/core/utils/logger.hpp"
+#include "opencv2/core/softfloat.hpp"
+
+namespace cv {
+namespace multiview {
+class RobustFunction : public Algorithm {
+public:
+    virtual float getError(float err) const = 0;
+};
+
+#define USE_FAST_EXP 0
+
+#if USE_FAST_EXP
+class RobustExpFunction : public RobustFunction {
+private:
+    const float over_scale, pow_23 = 1 << 23;
+public:
+    explicit RobustExpFunction (float scale_=30.0f) : over_scale(-1.442695040f /scale_) {}
+    // err > 0
+    float getError(float err) const override {
+        const float under_exp = err * over_scale;
+        if (under_exp < -20) return 0; // prevent overflow further
+        // http://www.machinedlearnings.com/2011/06/fast-approximate-logarithm-exponential.html
+        softfloat vexp = softfloat::fromRaw(static_cast<uint32_t>(pow_23 * (under_exp + 126.94269504f)));
+        return float(vexp);
+    }
+};
+#else
+class RobustExpFunction : public RobustFunction {
+private:
+    const float minvScale;
+public:
+    explicit RobustExpFunction (float scale_=30.0f) : minvScale(-1.f / scale_) {}
+    // err > 0
+    float getError(float err) const override
+    {
+        return exp(minvScale * err);
+    }
+};
+#endif
+
+static double robustWrapper (const Mat& ptsErrors, Mat& weights, const RobustFunction &fnc) {
+    Mat errs;
+    ptsErrors.convertTo(errs, CV_32F);
+    weights.create((int)ptsErrors.total()*ptsErrors.channels(), 1, CV_32FC1);
+    const Point2f * errs_ptr = errs.ptr<Point2f>();
+    float * weights_ptr = weights.ptr<float>();
+    double robust_sum_sqr_errs = 0.0;
+    for (int pt = 0; pt < (int)errs.total(); pt++) {
+        Point2f p = errs_ptr[pt];
+        float sqr_err = p.dot(p);
+        float w = fnc.getError(sqr_err);
+        weights_ptr[pt*2 + 0] = w;
+        weights_ptr[pt*2 + 1] = w;
+        robust_sum_sqr_errs += w * sqr_err;
+    }
+    return robust_sum_sqr_errs;
+}
+
+static double computeReprojectionMSE(const Mat &obj_points_, const Mat &img_points_, const Matx33d &K, const Mat &distortion,
+               const Mat &rvec, const Mat &tvec, InputArray rvec2, InputArray tvec2, int model) {
+    Mat r, t;
+    if (!rvec2.empty() && !tvec2.empty()) {
+        composeRT(rvec, tvec, rvec2, tvec2, r, t);
+    } else {
+        r = rvec; t = tvec;
+    }
+    Mat tmpImagePoints, obj_points = obj_points_, img_points = img_points_;
+    if (model == cv::CALIB_MODEL_FISHEYE) {
+        obj_points = obj_points.reshape(3); // must be 3 channels
+        fisheye::projectPoints(obj_points, tmpImagePoints, r, t, K, distortion);
+    } else if (model == cv::CALIB_MODEL_PINHOLE) {
+        projectPoints(obj_points, r, t, K, distortion, tmpImagePoints);
+    } else {
+        CV_Error(Error::StsBadArg, "Unsupported camera model!");
+    }
+
+    if (img_points.channels() != tmpImagePoints.channels())
+        img_points = img_points.reshape(tmpImagePoints.channels());
+    if (img_points.rows != tmpImagePoints.rows)
+        img_points = img_points.t();
+    subtract (tmpImagePoints, img_points, tmpImagePoints);
+    return norm(tmpImagePoints, NORM_L2SQR) / tmpImagePoints.rows;
+}
+
+static bool maximumSpanningTree (int NUM_CAMERAS, int NUM_FRAMES, const std::vector<std::vector<bool>> &detection_mask,
+          std::vector<int> &parent, std::vector<std::vector<int>> &overlap,
+          std::vector<std::vector<Vec3d>> &opt_axes,
+          const std::vector<std::vector<bool>> &is_valid_angle2pattern,
+          const std::vector<std::vector<float>> &points_area_ratio,
+          double WEIGHT_ANGLE_PATTERN, double WEIGHT_CAMERAS_ANGLES) {
+    const double THR_CAMERAS_ANGLES = 160*M_PI/180;
+    // build weights matrix
+    overlap = std::vector<std::vector<int>>(NUM_CAMERAS, std::vector<int>(NUM_CAMERAS, 0));
+    std::vector<std::vector<double>> weights(NUM_CAMERAS, std::vector<double>(NUM_CAMERAS, DBL_MIN));
+    for (int c1 = 0; c1 < NUM_CAMERAS; c1++) {
+        for (int c2 = c1+1; c2 < NUM_CAMERAS; c2++) {
+            double weight = 0;
+            int overlaps = 0;
+            for (int f = 0; f < NUM_FRAMES; f++) {
+                if (detection_mask[c1][f] && detection_mask[c2][f]) {
+                    overlaps += 1;
+                    weight += points_area_ratio[c1][f] + points_area_ratio[c2][f];
+                    weight += WEIGHT_ANGLE_PATTERN * ((int)is_valid_angle2pattern[c1][f] + (int)is_valid_angle2pattern[c2][f]);
+                    if (WEIGHT_CAMERAS_ANGLES > 0) {
+                        // angle between cameras optical axes
+                        weight += WEIGHT_CAMERAS_ANGLES * int(acos(opt_axes[c1][f].dot(opt_axes[c2][f])) < THR_CAMERAS_ANGLES);
+                    }
+                }
+            }
+            if (overlaps > 0) {
+                overlap[c1][c2] = overlap[c2][c1] = overlaps;
+                weights[c1][c2] = weights[c2][c1] = overlaps + weight;
+            }
+        }
+    }
+
+    // find maximum spanning tree using Prim's algorithm
+    std::vector<bool> visited(NUM_CAMERAS, false);
+    std::vector<double> weight(NUM_CAMERAS, DBL_MIN);
+    parent = std::vector<int>(NUM_CAMERAS, -1);
+    weight[0] = DBL_MAX;
+    for (int cam =  0; cam < NUM_CAMERAS-1; cam++) {
+        int max_weight_idx = -1;
+        auto max_weight = DBL_MIN;
+        for (int cam2 = 0; cam2 < NUM_CAMERAS; cam2++) {
+            if (!visited[cam2] && max_weight < weight[cam2]) {
+                max_weight = weight[cam2];
+                max_weight_idx = cam2;
+            }
+        }
+        if (max_weight_idx == -1)
+            return false;
+        visited[max_weight_idx] = true;
+        for (int cam2 = 0; cam2 < NUM_CAMERAS; cam2++) {
+            if (!visited[cam2] && overlap[max_weight_idx][cam2] > 0) {
+                if (weight[cam2] < weights[max_weight_idx][cam2]) {
+                    weight[cam2] = weights[max_weight_idx][cam2];
+                    parent[cam2] = max_weight_idx;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+static void imagePointsArea (const std::vector<Size> &imageSize, const std::vector<std::vector<bool>> &detection_mask_mat,
+          const std::vector<std::vector<Mat>> &imagePoints, std::vector<std::vector<float>> &points_ratio_area) {
+    const int NUM_CAMERAS = (int) imageSize.size(), NUM_FRAMES = (int)detection_mask_mat[0].size();
+    for (int c = 0; c < NUM_CAMERAS; c++) {
+        const auto img_area = (float)(imageSize[c].width * imageSize[c].height);
+        for (int f = 0; f < NUM_FRAMES; f++) {
+            if (!detection_mask_mat[c][f])
+                continue;
+            CV_Assert((imagePoints[c][f].type() == CV_32F && imagePoints[c][f].cols == 2) || imagePoints[c][f].type() == CV_32FC2);
+            std::vector<int> hull;
+            const auto img_pts = imagePoints[c][f];
+            const auto * const image_pts_ptr = (float *) img_pts.data;
+            convexHull(img_pts, hull, true/*has to be clockwise*/, false/*indices*/);
+            float area = 0;
+            int j = hull.back();
+            // http://alienryderflex.com/polygon_area/
+            for (int i : hull) {
+                area += (image_pts_ptr[j*2] + image_pts_ptr[i*2])*(image_pts_ptr[j*2+1] - image_pts_ptr[i*2+1]);
+                j = i;
+            }
+            points_ratio_area[c][f] = area*.5f / img_area;
+        }
+    }
+}
+
+static void selectPairsBFS (std::vector<std::pair<int,int>> &pairs, int NUM_CAMERAS, const std::vector<int> &parent) {
+    // find pairs using Breadth First Search graph traversing
+    // it is important to keep this order of pairs, since it is easier
+    // to find relative views wrt to 0-th camera.
+    std::vector<int> nodes = {0};
+    pairs.reserve(NUM_CAMERAS-1);
+    while (!nodes.empty()) {
+        std::vector<int> new_nodes;
+        for (int n : nodes) {
+            for (int c = 0; c < NUM_CAMERAS; c++) {
+                if (parent[c] == n) {
+                    pairs.emplace_back(std::make_pair(n, c));
+                    new_nodes.emplace_back(c);
+                }
+            }
+        }
+        nodes = new_nodes;
+    }
+}
+
+static double getScaleOfObjPoints (int NUM_PATTERN_PTS, const Mat &obj_pts, bool obj_points_in_rows) {
+    double scale_3d_pts = 0.0;
+    // compute scale of 3D points as the maximum pairwise distance
+    for (int i = 0; i < NUM_PATTERN_PTS; i++) {
+        for (int j = i+1; j < NUM_PATTERN_PTS; j++) {
+            double dist;
+            if (obj_points_in_rows) {
+                dist = norm(obj_pts.row(i)-obj_pts.row(j), NORM_L2SQR);
+            } else {
+                dist = norm(obj_pts.col(i)-obj_pts.col(j), NORM_L2SQR);
+            }
+            if (scale_3d_pts < dist) {
+                scale_3d_pts = dist;
+            }
+        }
+    }
+    return scale_3d_pts;
+}
+
+static void thresholdPatternCameraAngles (int NUM_PATTERN_PTS, double THR_PATTERN_CAMERA_ANGLES,
+        const std::vector<Mat> &objPoints_norm, const std::vector<std::vector<Vec3d>> &rvecs_all,
+        std::vector<std::vector<Vec3d>> &opt_axes, std::vector<std::vector<bool>> &is_valid_angle2pattern) {
+    const int NUM_FRAMES = (int)objPoints_norm.size(), NUM_CAMERAS = (int)rvecs_all.size();
+    is_valid_angle2pattern = std::vector<std::vector<bool>>(NUM_CAMERAS, std::vector<bool>(NUM_FRAMES, true));
+    int pattern1 = -1, pattern2 = -1, pattern3 = -1;
+    for (int f = 0; f < NUM_FRAMES; f++) {
+        double norm_normal = 0;
+        if (pattern1 == -1) {
+            // take non colinear 3 points and save them
+            for (int p1 = 0; p1 < NUM_PATTERN_PTS; p1++) {
+                for (int p2 = p1+1; p2 < NUM_PATTERN_PTS; p2++) {
+                    for (int p3 = NUM_PATTERN_PTS-1; p3 > p2; p3--) { // start from the last point
+                        Mat pattern_normal = (objPoints_norm[f].row(p2)-objPoints_norm[f].row(p1))
+                                    .cross(objPoints_norm[f].row(p3)-objPoints_norm[f].row(p1));
+                        norm_normal = norm(pattern_normal, NORM_L2SQR);
+                        if (norm_normal > 1e-6) {
+                            pattern1 = p1;
+                            pattern2 = p2;
+                            pattern3 = p3;
+                            norm_normal = sqrt(norm_normal);
+                            break;
+                        }
+                    }
+                    if (pattern1 != -1) break;
+                }
+                if (pattern1 != -1) break;
+            }
+            if (pattern1 == -1) {
+                CV_Error(Error::StsBadArg, "Pattern points are collinear!");
+            }
+        }
+        Vec3d pattern_normal = (objPoints_norm[f].row(pattern2)-objPoints_norm[f].row(pattern1)).
+                  cross(objPoints_norm[f].row(pattern3)-objPoints_norm[f].row(pattern1));
+        norm_normal = norm(pattern_normal);
+        pattern_normal /= norm_normal;
+
+        for (int c = 0; c < NUM_CAMERAS; c++) {
+            Matx33d R;
+            Rodrigues(rvecs_all[c][f], R);
+            opt_axes[c][f] = Vec3d(Mat(R.row(2)));
+            const double angle = acos(opt_axes[c][f].dot(pattern_normal));
+            is_valid_angle2pattern[c][f] = min(M_PI-angle, angle) < THR_PATTERN_CAMERA_ANGLES;
+        }
+    }
+}
+
+static void pairwiseRegistration (const std::vector<std::pair<int,int>> &pairs,
+        const cv::Mat &models, const std::vector<Mat> &objPoints_norm,
+        const std::vector<std::vector<Mat>> &imagePoints, const std::vector<std::vector<int>> &overlaps,
+        const std::vector<std::vector<bool>> &detection_mask_mat, const std::vector<Mat> &Ks,
+        const std::vector<Mat> &distortions, std::vector<Matx33d> &Rs_vec, std::vector<Vec3d> &Ts_vec,
+        Mat &intrinsic_flags, int extrinsic_flags, TermCriteria criteria) {
+    CV_UNUSED(intrinsic_flags);
+    const int NUM_FRAMES = (int)objPoints_norm.size();
+    const int NUM_CAMERAS = (int)detection_mask_mat.size();
+    std::vector<Matx33d> Rs_prior;
+    std::vector<Vec3d> Ts_prior;
+    if (extrinsic_flags & cv::CALIB_USE_EXTRINSIC_GUESS) {
+        Rs_prior.resize(NUM_CAMERAS);
+        Ts_prior.resize(NUM_CAMERAS);
+        for (int i = 0; i < NUM_CAMERAS; i++) {
+            Rs_vec[i].copyTo(Rs_prior[i]);
+            Ts_vec[i].copyTo(Ts_prior[i]);
+        }
+    }
+
+    for (const auto &pair : pairs) {
+        const int c1 = pair.first, c2 = pair.second, overlap = overlaps[c1][c2];
+        // prepare image points of two cameras and grid points
+        std::vector<Mat> image_points1, image_points2, grid_points1, grid_points2;
+        grid_points1.reserve(overlap);
+        grid_points2.reserve(overlap);
+        image_points1.reserve(overlap);
+        image_points2.reserve(overlap);
+        for (int f = 0; f < NUM_FRAMES; f++) {
+            if (detection_mask_mat[c1][f] && detection_mask_mat[c2][f]) {
+                grid_points1.emplace_back(objPoints_norm[f]);
+                grid_points2.emplace_back(objPoints_norm[f]);
+                image_points1.emplace_back(imagePoints[c1][f]);
+                image_points2.emplace_back(imagePoints[c2][f]);
+            }
+        }
+        Matx33d R;
+        Vec3d T;
+
+        if (extrinsic_flags & cv::CALIB_USE_EXTRINSIC_GUESS) {
+            R = Rs_prior[c2] * Rs_prior[c1].t();
+            T = -R * Ts_prior[c1] + Ts_prior[c2];
+        }
+
+        extrinsic_flags |= CALIB_FIX_INTRINSIC;
+        double err = registerCameras(grid_points1, grid_points2, image_points1, image_points2,
+                        Ks[c1], distortions[c1], cv::CameraModel(models.at<uchar>(c1)),
+                        Ks[c2], distortions[c2], cv::CameraModel(models.at<uchar>(c2)),
+                        R, T, noArray(), noArray(), noArray(), noArray(), noArray(),
+                        extrinsic_flags, criteria);
+        CV_LOG_INFO(NULL, "Pair " << c1 << "-" << c2 << " registration RMS " << err);
+        // R_0 = I
+        // R_ij = R_i R_j^T     =>  R_i = R_ij R_j
+        // t_ij = ti - R_ij tj  =>  t_i = t_ij + R_ij t_j
+        if (c1 == 0) {
+            Rs_vec[c2] = R;
+            Ts_vec[c2] = T;
+        } else {
+            Rs_vec[c2] = Matx33d(Mat(R * Rs_vec[c1]));
+            Ts_vec[c2] = Vec3d(Mat(T + R * Ts_vec[c1]));
+        }
+    }
+}
+
+static void pairwiseStereoCalibration (const std::vector<std::pair<int,int>> &pairs,
+        const cv::Mat &models, const std::vector<Mat> &objPoints_norm,
+        const std::vector<std::vector<Mat>> &imagePoints, const std::vector<std::vector<int>> &overlaps,
+        const std::vector<std::vector<bool>> &detection_mask_mat, const std::vector<Mat> &Ks,
+        const std::vector<Mat> &distortions, std::vector<Matx33d> &Rs_vec, std::vector<Vec3d> &Ts_vec,
+        Mat &intrinsic_flags, int extrinsic_flags, TermCriteria criteria) {
+    const int NUM_FRAMES = (int)objPoints_norm.size();
+    const int NUM_CAMERAS = (int)detection_mask_mat.size();
+    std::vector<Matx33d> Rs_prior;
+    std::vector<Vec3d> Ts_prior;
+    if (extrinsic_flags & cv::CALIB_USE_EXTRINSIC_GUESS) {
+        Rs_prior.resize(NUM_CAMERAS);
+        Ts_prior.resize(NUM_CAMERAS);
+        for (int i = 0; i < NUM_CAMERAS; i++) {
+            Rs_vec[i].copyTo(Rs_prior[i]);
+            Ts_vec[i].copyTo(Ts_prior[i]);
+        }
+    }
+
+    for (const auto &pair : pairs) {
+        const int c1 = pair.first, c2 = pair.second, overlap = overlaps[c1][c2];
+        // prepare image points of two cameras and grid points
+        std::vector<Mat> image_points1, image_points2, grid_points;
+        grid_points.reserve(overlap);
+        image_points1.reserve(overlap);
+        image_points2.reserve(overlap);
+        const bool are_fisheye_cams = models.at<uchar>(c1) == cv::CALIB_MODEL_FISHEYE &&
+                                      models.at<uchar>(c2) == cv::CALIB_MODEL_FISHEYE;
+        for (int f = 0; f < NUM_FRAMES; f++) {
+            if (detection_mask_mat[c1][f] && detection_mask_mat[c2][f]) {
+                grid_points.emplace_back((are_fisheye_cams && objPoints_norm[f].channels() != 3) ?
+                                         objPoints_norm[f].reshape(3): objPoints_norm[f]);
+                image_points1.emplace_back((are_fisheye_cams && imagePoints[c1][f].channels() != 2) ?
+                                           imagePoints[c1][f].reshape(2) : imagePoints[c1][f]);
+                image_points2.emplace_back((are_fisheye_cams && imagePoints[c2][f].channels() != 2) ?
+                                         imagePoints[c2][f].reshape(2) : imagePoints[c2][f]);
+            }
+        }
+        Matx33d R;
+        Vec3d T;
+
+        if (extrinsic_flags & cv::CALIB_USE_EXTRINSIC_GUESS) {
+            R = Rs_prior[c2] * Rs_prior[c1].t();
+            T = -R * Ts_prior[c1] + Ts_prior[c2];
+        }
+
+        // stereoCalibrate tries to overwrite distortion coefficients
+        Mat dist1 = distortions[c1].clone();
+        Mat dist2 = distortions[c2].clone();
+
+        // image size does not matter since intrinsics are used
+        if (are_fisheye_cams) {
+            extrinsic_flags |= CALIB_FIX_INTRINSIC;
+            double err = fisheye::stereoCalibrate(grid_points, image_points1, image_points2,
+                            Ks[c1], dist1,
+                            Ks[c2], dist2,
+                            Size(), R, T,
+                            extrinsic_flags, criteria);
+            CV_LOG_INFO(NULL, "Stereo pair " << c1 << "-" << c2 << " registration RMS " << err);
+        } else {
+            extrinsic_flags |= CALIB_FIX_INTRINSIC;
+            if ((intrinsic_flags.at<int>(c1) & CALIB_RATIONAL_MODEL) || (intrinsic_flags.at<int>(c2) & CALIB_RATIONAL_MODEL))
+                extrinsic_flags |= CALIB_RATIONAL_MODEL;
+            if ((intrinsic_flags.at<int>(c1) & CALIB_THIN_PRISM_MODEL) || (intrinsic_flags.at<int>(c2) & CALIB_THIN_PRISM_MODEL))
+                extrinsic_flags |= CALIB_THIN_PRISM_MODEL;
+
+            double err = stereoCalibrate(grid_points, image_points1, image_points2,
+                            Ks[c1], dist1,
+                            Ks[c2], dist2,
+                            Size(), R, T, noArray(), noArray(), noArray(),
+                            extrinsic_flags, criteria);
+            CV_LOG_INFO(NULL, "Stereo pair " << c1 << "-" << c2 << " registration RMS " << err);
+        }
+
+        // R_0 = I
+        // R_ij = R_i R_j^T     =>  R_i = R_ij R_j
+        // t_ij = ti - R_ij tj  =>  t_i = t_ij + R_ij t_j
+        if (c1 == 0) {
+            Rs_vec[c2] = R;
+            Ts_vec[c2] = T;
+        } else {
+            Rs_vec[c2] = Matx33d(Mat(R * Rs_vec[c1]));
+            Ts_vec[c2] = Vec3d(Mat(T + R * Ts_vec[c1]));
+        }
+    }
+}
+
+static void optimizeLM (std::vector<double> &param, const RobustFunction &robust_fnc, const TermCriteria &termCrit,
+         const std::vector<bool> &valid_frames, const std::vector<std::vector<bool>> &detection_mask_mat,
+         const std::vector<Mat> &objPoints_norm, const std::vector<std::vector<Mat>> &imagePoints,
+         const std::vector<Mat> &Ks, const std::vector<Mat> &distortions,
+         const Mat& models, int NUM_PATTERN_PTS) {
+    const int NUM_FRAMES = (int) objPoints_norm.size(), NUM_CAMERAS = (int)detection_mask_mat.size();
+    int iters_lm = 0, cnt_valid_frame = 0;
+    auto lmcallback = [&](InputOutputArray _param, OutputArray JtErr_, OutputArray JtJ_, double& errnorm) {
+        auto * param_p = _param.getMat().ptr<double>();
+        errnorm = 0;
+        cnt_valid_frame = 0;
+        for (int i = 0; i < NUM_FRAMES; i++ ) {
+            if (!valid_frames[i]) continue;
+            for (int k = 0; k < NUM_CAMERAS; k++ ) {
+                // Pose for camera #0 is not optimized, but it's re-projection error is taken into account
+                if (!detection_mask_mat[k][i]) continue;
+                const int cam_idx = (k-1)*6; // camera extrinsics
+                const auto * const pose_k = (k > 0)? (param_p + cam_idx) : nullptr;
+                Vec3d om_0ToK = (k > 0)? Vec3d(pose_k[0], pose_k[1], pose_k[2]) : Vec3d(0., 0., 0.), om[2];
+                Vec3d T_0ToK = (k > 0)? Vec3d(pose_k[3], pose_k[4], pose_k[5]) : Vec3d(0., 0., 0.), T[2];
+                Matx33d dr3dr1, dr3dr2, dt3dr2, dt3dt1, dt3dt2;
+
+                auto * pi = param_p + (cnt_valid_frame+NUM_CAMERAS-1)*6; // get rvecs / tvecs for frame pose
+                om[0] = Vec3d(pi[0], pi[1], pi[2]);
+                T[0] = Vec3d(pi[3], pi[4], pi[5]);
+
+                if( JtJ_.needed() || JtErr_.needed() )
+                    composeRT( om[0], T[0], om_0ToK, T_0ToK, om[1], T[1], dr3dr1, noArray(),
+                               dr3dr2, noArray(), noArray(), dt3dt1, dt3dr2, dt3dt2 );
+                else
+                    composeRT( om[0], T[0], om_0ToK, T_0ToK, om[1], T[1] );
+
+                // get object points
+                Mat objpt_i = objPoints_norm[i].reshape(3, 1);
+                objpt_i.convertTo(objpt_i, CV_64FC3);
+
+                Mat err( NUM_PATTERN_PTS*2, 1, CV_64F ), tmpImagePoints = err.reshape(2, 1);
+                Mat Je( NUM_PATTERN_PTS*2, 6, CV_64F ), J_0ToK( NUM_PATTERN_PTS*2, 6, CV_64F );
+                Mat dpdrot = Je.colRange(0, 3), dpdt = Je.colRange(3, 6); // num_points*2 x 3 each
+                // get image points
+                Mat imgpt_ik = imagePoints[k][i].reshape(2, 1);
+                imgpt_ik.convertTo(imgpt_ik, CV_64FC2);
+
+                if (models.at<uchar>(k)) {
+                    if( JtJ_.needed() || JtErr_.needed() ) {
+                        Mat jacobian; // of size num_points*2  x  15 (2 + 2 + 1 + 4 + 3 + 3; // f, c, alpha, k, om, T)
+                        fisheye::projectPoints(objpt_i, tmpImagePoints, om[1], T[1], Ks[k], distortions[k], 0, jacobian);
+                        jacobian.colRange(8,11).copyTo(dpdrot);
+                        jacobian.colRange(11,14).copyTo(dpdt);
+                    } else
+                        fisheye::projectPoints(objpt_i, tmpImagePoints, om[1], T[1], Ks[k], distortions[k]);
+                } else {
+                    if( JtJ_.needed() || JtErr_.needed() )
+                        projectPoints(objpt_i, om[1], T[1], Ks[k], distortions[k],
+                                        tmpImagePoints, dpdrot, dpdt, noArray(), noArray(), noArray(), noArray());
+                    else
+                        projectPoints(objpt_i, om[1], T[1], Ks[k], distortions[k], tmpImagePoints);
+                }
+                subtract( tmpImagePoints, imgpt_ik, tmpImagePoints);
+                Mat weights;
+                const double robust_l2_norm = multiview::robustWrapper(tmpImagePoints, weights, robust_fnc);
+                errnorm += robust_l2_norm;
+
+                if (JtJ_.needed()) {
+                    Mat JtErr = JtErr_.getMat(), JtJ = JtJ_.getMat();
+                    const int eofs = (cnt_valid_frame+NUM_CAMERAS-1)*6;
+                    assert( JtJ_.needed() && JtErr_.needed() );
+                    // JtJ : NUM_PARAMS x NUM_PARAMS, JtErr : NUM_PARAMS x 1
+                    // d(err_{x|y}R) ~ de3
+                    // convert de3/{dr3,dt3} => de3{dr1,dt1} & de3{dr2,dt2}
+
+                    Mat wd;
+                    Mat::diag(weights).convertTo(wd, CV_64F);
+                    if (k > 0) { // if not camera #0
+                        for (int p = 0; p < NUM_PATTERN_PTS * 2; p++) {
+                            Matx13d de3dr3, de3dt3, de3dr2, de3dt2, de3dr1, de3dt1;
+                            for (int j = 0; j < 3; j++)
+                                de3dr3(j) = Je.at<double>(p, j);
+
+                            for (int j = 0; j < 3; j++)
+                                de3dt3(j) = Je.at<double>(p, 3 + j);
+
+                            for (int j = 0; j < 3; j++)
+                                de3dr2(j) = J_0ToK.at<double>(p, j);
+
+                            for (int j = 0; j < 3; j++)
+                                de3dt2(j) = J_0ToK.at<double>(p, 3 + j);
+
+                            de3dr1 = de3dr3 * dr3dr1;
+                            de3dt1 = de3dt3 * dt3dt1;
+                            de3dr2 = de3dr3 * dr3dr2 + de3dt3 * dt3dr2;
+                            de3dt2 = de3dt3 * dt3dt2;
+
+                            for (int j = 0; j < 3; j++)
+                                Je.at<double>(p, j) = de3dr1(j);
+
+                            for (int j = 0; j < 3; j++)
+                                Je.at<double>(p, 3 + j) = de3dt1(j);
+
+                            for (int j = 0; j < 3; j++)
+                                J_0ToK.at<double>(p, j) = de3dr2(j);
+
+                            for (int j = 0; j < 3; j++)
+                                J_0ToK.at<double>(p, 3 + j) = de3dt2(j);
+                        }
+
+                        // 6 x (ni*2) * (ni*2 x ni*2) * (ni*2) x 6
+                        JtJ(Rect((k - 1) * 6, (k - 1) * 6, 6, 6)) += (J_0ToK.t() * wd * J_0ToK);
+                        JtJ(Rect(eofs, (k - 1) * 6, 6, 6)) = (J_0ToK.t() * wd * Je);
+                        JtErr.rowRange((k - 1) * 6, (k - 1) * 6 + 6) += (J_0ToK.t() * wd * err);
+                    }
+                    JtJ(Rect(eofs, eofs, 6, 6)) += Je.t() * wd * Je;
+                    JtErr.rowRange(eofs, eofs + 6) += Je.t() * wd * err;
+                }
+            }
+            cnt_valid_frame++;
+        }
+        iters_lm += 1;
+        return true;
+    };
+    LevMarq solver(param, lmcallback,
+       LevMarq::Settings()
+               .setMaxIterations(termCrit.maxCount)
+               .setStepNormTolerance(termCrit.epsilon)
+               .setSmallEnergyTolerance(termCrit.epsilon * termCrit.epsilon),
+           noArray()/*mask, all variables to optimize*/);
+    cv::LevMarq::Report status = solver.optimize();
+    CV_LOG_INFO(NULL, "LevMarq finished with status " << status.found << " energy " << status.energy << " after " << status.iters << " iterations");
+}
+
+static void checkConnected (const std::vector<std::vector<bool>> &detection_mask_mat) {
+    const int NUM_CAMERAS = (int)detection_mask_mat.size(), NUM_FRAMES = (int)detection_mask_mat[0].size();
+    std::vector<bool> visited(NUM_CAMERAS, false);
+    std::function<void(int)> dfs_search;
+    dfs_search = [&] (int cam) {
+        visited[cam] = true;
+        for (int cam2 = 0; cam2 < NUM_CAMERAS; cam2++) {
+            if (!visited[cam2]) {
+                for (int f = 0; f < NUM_FRAMES; f++) {
+                    if (detection_mask_mat[cam][f] && detection_mask_mat[cam2][f]) {
+                        dfs_search(cam2);
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    dfs_search(0);
+    for (int c = 0; c < NUM_CAMERAS; c++) {
+        if (! visited[c]) {
+            std::string isolated_cameras = "", visited_str = "";
+            for (int i = 0; i < NUM_CAMERAS; i++) {
+                if (!visited_str[i]) {
+                    if (isolated_cameras != "")
+                        isolated_cameras += ", ";
+                    isolated_cameras += std::to_string(i);
+                } else {
+                    if (visited_str != "")
+                        visited_str += ", ";
+                    visited_str += std::to_string(i);
+                }
+            }
+            CV_Error(Error::StsBadArg, "Isolated cameras (or components) "+isolated_cameras+" from the connected component "+visited_str+"!");
+        }
+    }
+}
+}
+
+double calibrateMultiview(
+        InputArrayOfArrays objPoints, const std::vector<std::vector<Mat>> &imagePoints,
+        const std::vector<cv::Size>& imageSize, InputArray detectionMask, InputArray models,
+        InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions,
+        InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts,
+        OutputArray initializationPairs, OutputArrayOfArrays rvecs0,
+        OutputArrayOfArrays tvecs0, OutputArray perFrameErrors,
+        InputArray flagsForIntrinsics, int flags, TermCriteria criteria) {
+    CV_CheckFalse(objPoints.empty(), "Objects points must not be empty!");
+    CV_CheckFalse(imagePoints.empty(), "Image points must not be empty!");
+    CV_CheckFalse(imageSize.empty(), "Image size per camera must not be empty!");
+    CV_CheckFalse(detectionMask.empty(), "detectionMask matrix must not be empty!");
+    CV_CheckFalse(models.empty(), "Fisheye mask must not be empty!");
+
+    Mat detection_mask_ = detectionMask.getMat();
+    Mat  models_mat = models.getMat();
+
+    CV_Assert(detection_mask_.type() == CV_8UC1 || detection_mask_.type() == CV_BoolC1);
+    CV_CheckEQ(models_mat.type(), CV_8U, "models must be of type CV_8U");
+
+    if(flags & cv::CALIB_STEREO_REGISTRATION)
+    {
+        bool is_fisheye = false;
+        bool is_pinhole = false;
+
+        for  (int i = 0; i < (int)models_mat.total(); i++) {
+            if (models_mat.at<uchar>(i) == cv::CALIB_MODEL_FISHEYE) {
+                is_fisheye = true;
+            } else if (models_mat.at<uchar>(i) == cv::CALIB_MODEL_PINHOLE) {
+                is_pinhole = true;
+            } else {
+                CV_Error(Error::StsBadArg, "Unsupported camera model");
+            }
+        }
+        CV_CheckEQ(is_fisheye && is_pinhole, false, "Mix of pinhole and fisheye cameras is not supported with CALIB_STEREO_REGISTRATION flag");
+    }
+
+    // equal number of cameras
+    CV_Assert(imageSize.size() == imagePoints.size());
+    CV_Assert(detection_mask_.rows == std::max(models.rows(), models.cols()));
+    CV_Assert(detection_mask_.rows == (int)imageSize.size());
+    CV_Assert(detection_mask_.cols == std::max(objPoints.rows(), objPoints.cols())); // equal number of frames
+    CV_Assert(Rs.isMatVector() == Ts.isMatVector());
+    if (flags & cv::CALIB_USE_INTRINSIC_GUESS) {
+        CV_Assert(Ks.isMatVector() && distortions.isMatVector());
+        CV_Assert(Ks.total() == distortions.total() && Ks.total() == imageSize.size());
+    }
+    if (flags & cv::CALIB_USE_EXTRINSIC_GUESS) {
+        CV_Assert(Rs.isMatVector() && Ts.isMatVector());
+        CV_Assert(Rs.total() == Ts.total() && Rs.total() == imageSize.size());
+    }
+    // normalize object points
+    const Mat obj_pts_0 = objPoints.getMat(0);
+    CV_Assert((obj_pts_0.type() == CV_32F && (obj_pts_0.rows == 3 || obj_pts_0.cols == 3)) ||
+              (obj_pts_0.type() == CV_32FC3 && (obj_pts_0.rows == 1 || obj_pts_0.cols == 1)));
+    const bool obj_points_in_rows = obj_pts_0.cols == 3;
+    const int NUM_CAMERAS = (int)detection_mask_.rows, NUM_FRAMES = (int)detection_mask_.cols;
+    CV_Assert((NUM_CAMERAS > 1) && (NUM_FRAMES > 0));
+    const int NUM_PATTERN_PTS = obj_points_in_rows ? obj_pts_0.rows : obj_pts_0.cols;
+    const double scale_3d_pts = multiview::getScaleOfObjPoints(NUM_PATTERN_PTS, obj_pts_0, obj_points_in_rows);
+
+    Mat flagsForIntrinsics_mat = flagsForIntrinsics.getMat();
+    if (flagsForIntrinsics_mat.empty())
+    {
+        flagsForIntrinsics_mat = Mat(Size(1, NUM_CAMERAS), CV_32SC1, cv::Scalar(0));
+    }
+
+    CV_Assert(flagsForIntrinsics_mat.total() == size_t(NUM_CAMERAS));
+    CV_CheckEQ(flagsForIntrinsics_mat.type(), CV_32S, "flagsForIntrinsics should be of type 32SC1");
+    CV_CheckEQ(flagsForIntrinsics_mat.channels(), 1, "flagsForIntrinsics should be of type 32SC1");
+
+    std::vector<Mat> objPoints_norm;
+    objPoints_norm.reserve(NUM_FRAMES);
+    for (int i = 0; i < NUM_FRAMES; i++) {
+        if (obj_points_in_rows)
+            objPoints_norm.emplace_back(objPoints.getMat(i)*(1/scale_3d_pts));
+        else
+            objPoints_norm.emplace_back(objPoints.getMat(i).t()*(1/scale_3d_pts));
+        objPoints_norm[i] = objPoints_norm[i].reshape(1);
+    }
+
+    ////////////////////////////////////////////////
+    std::vector<int> num_visible_frames_per_camera(NUM_CAMERAS);
+    std::vector<bool> valid_frames(NUM_FRAMES, false);
+    // process input and count all visible frames and points
+
+    std::vector<std::vector<bool>> detection_mask_mat(NUM_CAMERAS, std::vector<bool>(NUM_FRAMES));
+    const auto * const detection_mask_ptr = detection_mask_.data;
+    for (int c = 0; c < NUM_CAMERAS; c++) {
+        int num_visible_frames = 0;
+        for (int f = 0; f < NUM_FRAMES; f++) {
+            detection_mask_mat[c][f] = detection_mask_ptr[c*NUM_FRAMES + f] != 0;
+            if (detection_mask_mat[c][f]) {
+                num_visible_frames++;
+                valid_frames[f] = true; // if frame is visible by at least one camera then count is as a valid one
+            }
+        }
+        if (num_visible_frames == 0) {
+            CV_Error(Error::StsBadArg, "camera "+std::to_string(c)+" has no visible frames!");
+        }
+        num_visible_frames_per_camera[c] = num_visible_frames;
+    }
+
+    multiview::checkConnected(detection_mask_mat);
+
+    std::vector<std::vector<float>> points_ratio_area(NUM_CAMERAS, std::vector<float>(NUM_FRAMES));
+    multiview::imagePointsArea(imageSize, detection_mask_mat, imagePoints, points_ratio_area);
+
+    // constant threshold for angle between two camera axes in radians (=160*M_PI/180).
+    // if angle exceeds this threshold then a weight of a camera pair is lowered.
+    const double THR_PATTERN_CAMERA_ANGLES = 160*M_PI/180;
+    std::vector<std::vector<Vec3d>> rvecs_all(NUM_CAMERAS, std::vector<Vec3d>(NUM_FRAMES)),
+        tvecs_all(NUM_CAMERAS, std::vector<Vec3d>(NUM_FRAMES)),
+        opt_axes(NUM_CAMERAS, std::vector<Vec3d>(NUM_FRAMES));
+
+    std::vector<int> camera_rt_best(NUM_FRAMES, -1);
+    std::vector<double> camera_rt_errors(NUM_FRAMES, std::numeric_limits<double>::max());
+    const double WARNING_RMSE = 15.;
+    if ((flags & cv::CALIB_USE_INTRINSIC_GUESS) == 0) {
+        Ks.create(NUM_CAMERAS, 1, CV_64F);
+        distortions.create(NUM_CAMERAS, 1, CV_64F);
+
+        // calibrate each camera independently to find intrinsic parameters - K and distortion coefficients
+        parallel_for_(Range(0, NUM_CAMERAS), [&](const Range& range) {
+            for (int camera = range.start; camera < range.end; camera++) {
+                Mat K, dist;
+                Mat rvecs, tvecs;
+                std::vector<Mat> obj_points_, img_points_;
+                std::vector<double> errors_per_view;
+                obj_points_.reserve(num_visible_frames_per_camera[camera]);
+                img_points_.reserve(num_visible_frames_per_camera[camera]);
+                for (int f = 0; f < NUM_FRAMES; f++) {
+                    if (detection_mask_mat[camera][f]) {
+                        obj_points_.emplace_back((models_mat.at<uchar>(camera) == cv::CALIB_MODEL_FISHEYE && objPoints_norm[f].channels() != 3) ?
+                            objPoints_norm[f].reshape(3): objPoints_norm[f]);
+                        img_points_.emplace_back((models_mat.at<uchar>(camera) == cv::CALIB_MODEL_FISHEYE && imagePoints[camera][f].channels() != 2) ?
+                            imagePoints[camera][f].reshape(2) : imagePoints[camera][f]);
+                    }
+                }
+                double repr_err;
+                if (models_mat.at<uchar>(camera) == cv::CALIB_MODEL_FISHEYE) {
+                    repr_err = fisheye::calibrate(obj_points_, img_points_, imageSize[camera],
+                        K, dist, rvecs, tvecs, flagsForIntrinsics_mat.at<int>(camera));
+                    CV_LOG_INFO(NULL, "Camera " << camera << " intrinsics calibration RMS " << repr_err);
+                    // calibrate does not compute error per view, so compute it manually
+                    errors_per_view = std::vector<double>(obj_points_.size());
+                    for (int f = 0; f < (int) obj_points_.size(); f++) {
+                        double err2 = multiview::computeReprojectionMSE(obj_points_[f],
+                            img_points_[f], K, dist, rvecs.row(f), tvecs.row(f), noArray(), noArray(), cv::CALIB_MODEL_FISHEYE);
+                        errors_per_view[f] = sqrt(err2);
+                    }
+                } else {
+                    repr_err = calibrateCamera(obj_points_, img_points_, imageSize[camera], K, dist,
+                    rvecs, tvecs, noArray(), noArray(), errors_per_view, flagsForIntrinsics_mat.at<int>(camera));
+                    CV_LOG_INFO(NULL, "Camera " << camera << " intrinsics calibration RMS " << repr_err);
+                }
+                CV_LOG_IF_WARNING(NULL, repr_err > WARNING_RMSE, "Warning! Mean RMSE of intrinsics calibration is higher than "+std::to_string(WARNING_RMSE)+" pixels!");
+                int cnt_visible_frame = 0;
+                for (int f = 0; f < NUM_FRAMES; f++) {
+                    if (detection_mask_mat[camera][f]) {
+                        rvecs_all[camera][f] = Vec3d(Mat(3, 1, CV_64F, rvecs.row(cnt_visible_frame).data));
+                        tvecs_all[camera][f] = Vec3d(Mat(3, 1, CV_64F, tvecs.row(cnt_visible_frame).data));
+                        double err = errors_per_view[cnt_visible_frame];
+                        double err2 = err * err;
+                        if (camera_rt_errors[f] > err2) {
+                            camera_rt_errors[f] = err2;
+                            camera_rt_best[f] = camera;
+                        }
+                        cnt_visible_frame++;
+                    }
+                }
+
+                Ks.create(K.rows, K.cols, CV_64F, camera);
+                distortions.create(dist.rows, dist.cols, CV_64F, camera, true);
+                K.copyTo(Ks.getMat(camera));
+                dist.copyTo(distortions.getMat(camera));
+            }
+        });
+    } else {
+        // use PnP to compute rvecs and tvecs
+        for (int i = 0; i < NUM_FRAMES; i++) {
+            for (int k = 0; k < NUM_CAMERAS; k++) {
+                if (!detection_mask_mat[k][i]) continue;
+                Vec3d rvec, tvec;
+                solvePnP(objPoints_norm[i], imagePoints[k][i], Ks.getMat(k), distortions.getMat(k), rvec, tvec, false, SOLVEPNP_ITERATIVE);
+                rvecs_all[k][i] = rvec;
+                tvecs_all[k][i] = tvec;
+                const double err2 = multiview::computeReprojectionMSE(objPoints_norm[i], imagePoints[k][i], Ks.getMat(k), distortions.getMat(k), Mat(rvec), Mat(tvec), noArray(), noArray(), models_mat.at<uchar>(k));
+                if (camera_rt_errors[i] > err2) {
+                    camera_rt_errors[i] = err2;
+                    camera_rt_best[i] = k;
+                }
+            }
+        }
+    }
+
+    std::vector<cv::Mat> Ks_vec, distortions_vec;
+    Ks.getMatVector(Ks_vec);
+    distortions.getMatVector(distortions_vec);
+
+    std::vector<std::vector<bool>> is_valid_angle2pattern;
+    multiview::thresholdPatternCameraAngles(NUM_PATTERN_PTS, THR_PATTERN_CAMERA_ANGLES, objPoints_norm, rvecs_all, opt_axes, is_valid_angle2pattern);
+
+    std::vector<Matx33d> Rs_vec(NUM_CAMERAS);
+    std::vector<Vec3d> Ts_vec(NUM_CAMERAS);
+    Rs_vec[0] = Matx33d ::eye();
+    Ts_vec[0] = Vec3d::zeros();
+
+    std::vector<int> parent;
+    std::vector<std::vector<int>> overlaps;
+    if (! multiview::maximumSpanningTree(NUM_CAMERAS, NUM_FRAMES, detection_mask_mat, parent, overlaps, opt_axes,
+            is_valid_angle2pattern, points_ratio_area, .5, 1.0)) {
+        // failed to find suitable pairs with constraints!
+        CV_Error(Error::StsInternal, "Failed to build tree for stereo calibration.");
+    }
+
+    std::vector<std::pair<int,int>> pairs;
+    multiview::selectPairsBFS (pairs, NUM_CAMERAS, parent);
+
+    if ((int)pairs.size() != NUM_CAMERAS-1) {
+        CV_Error(Error::StsInternal, "Failed to build tree for stereo calibration. Incorrect number of pairs.");
+    }
+    if (initializationPairs.needed()) {
+        Mat pairs_mat = Mat_<int>(NUM_CAMERAS-1, 2);
+        auto * pairs_ptr = (int *) pairs_mat.data;
+        for (const auto &p : pairs) {
+            (*pairs_ptr++) = p.first;
+            (*pairs_ptr++) = p.second;
+        }
+        pairs_mat.copyTo(initializationPairs);
+    }
+
+    if(flags & cv::CALIB_STEREO_REGISTRATION) {
+        multiview::pairwiseStereoCalibration(pairs, models_mat, objPoints_norm, imagePoints,
+            overlaps, detection_mask_mat, Ks_vec, distortions_vec, Rs_vec, Ts_vec, flagsForIntrinsics_mat, 0, criteria);
+    } else {
+        multiview::pairwiseRegistration(pairs, models_mat, objPoints_norm, imagePoints,
+            overlaps, detection_mask_mat, Ks_vec, distortions_vec, Rs_vec, Ts_vec, flagsForIntrinsics_mat, 0, criteria);
+    }
+
+    const int NUM_VALID_FRAMES = countNonZero(valid_frames);
+    const int nparams = (NUM_VALID_FRAMES + NUM_CAMERAS - 1) * 6; // rvecs + tvecs (6)
+    std::vector<double> param(nparams, 0.);
+
+    // use found relative extrinsics to initialize parameters
+    for (int c = 1; c < NUM_CAMERAS; c++) {
+        Vec3d rvec;
+        Rodrigues(Rs_vec[c], rvec);
+        memcpy(&param[0]+(c-1)*6  , rvec.val, 3*sizeof(double));
+        memcpy(&param[0]+(c-1)*6+3, Ts_vec[c].val, 3*sizeof(double));
+    }
+
+    // use found rvecs / tvecs or estimate them to initialize rest of parameters
+    int cnt_valid_frame = 0;
+    for (int i = 0; i < NUM_FRAMES; i++ ) {
+        if (!valid_frames[i]) continue;
+        Vec3d rvec_0, tvec_0;
+        if (camera_rt_best[i] != 0) {
+            // convert rvecs / tvecs from k-th camera to the first one
+
+            // formulas for relative rotation / translation
+            // R = R_k R0^T       => R_k = R R_0
+            // t = t_k - R t_0    => t_k = t + R t_0
+
+            // initial camera R_0 = I, t_0 = 0 is fixed to R(rvec_0) and tvec_0
+            // R_0 = R(rvec_0)
+            // t_0 = tvec_0
+
+            // R'_k = R(rvec_k) = R_k R_0       => R_0 = R_k^T R(rvec_k)
+            // t'_k = tvec_k = t_k + R_k t_0    => t_0 = R_k^T (tvec_k - t_k)
+            const int rt_best_idx = camera_rt_best[i];
+            Matx33d R_k;
+            Rodrigues(rvecs_all[rt_best_idx][i], R_k);
+            tvec_0 = Rs_vec[rt_best_idx].t() * (tvecs_all[rt_best_idx][i] - Ts_vec[rt_best_idx]);
+            Rodrigues(Rs_vec[rt_best_idx].t() * R_k, rvec_0);
+        } else {
+            rvec_0 = rvecs_all[0][i];
+            tvec_0 = tvecs_all[0][i];
+        }
+
+        // save rvecs0 / tvecs0 parameters
+        memcpy(&param[0]+(cnt_valid_frame+NUM_CAMERAS-1)*6  , rvec_0.val, 3*sizeof(double));
+        memcpy(&param[0]+(cnt_valid_frame+NUM_CAMERAS-1)*6+3, tvec_0.val, 3*sizeof(double));
+        cnt_valid_frame++;
+    }
+
+    const float RBS_FNC_SCALE = 30;
+    multiview::RobustExpFunction robust_fnc(RBS_FNC_SCALE);
+    multiview::optimizeLM(param, robust_fnc, criteria, valid_frames, detection_mask_mat, objPoints_norm,
+                          imagePoints, Ks_vec, distortions_vec, models_mat, NUM_PATTERN_PTS);
+    const auto * const params = &param[0];
+
+    // extract extrinsics (R_i, t_i) for i = 1 ... NUM_CAMERAS:
+    const bool rt_mat_vec = Rs.isMatVector();
+    Mat rs, ts;
+    if (rt_mat_vec) {
+        Rs.create(NUM_CAMERAS, 1, CV_64F);
+        Ts.create(NUM_CAMERAS, 1, CV_64F);
+    } else {
+        rs = Mat_<double>(NUM_CAMERAS, 3);
+        ts = Mat_<double>(NUM_CAMERAS, 3);
+    }
+    for (int c = 0; c < NUM_CAMERAS; c++) {
+        Mat r_store, t_store;
+        if (rt_mat_vec) {
+            Rs.create(3, 1, CV_64F, c, true);
+            Ts.create(3, 1, CV_64F, c, true);
+            r_store = Rs.getMat(c);
+            t_store = Ts.getMat(c);
+        } else {
+            r_store = rs.row(c);
+            t_store = ts.row(c);
+        }
+        if (c == 0) {
+            memcpy(r_store.ptr(), Vec3d(0,0,0).val, 3*sizeof(double));
+            memcpy(t_store.ptr(), Vec3d(0,0,0).val, 3*sizeof(double));
+        } else {
+            memcpy(r_store.ptr(), params + (c-1)*6, 3*sizeof(double));
+            memcpy(t_store.ptr(), params + (c-1)*6+3, 3*sizeof(double)); // and de-normalize translation
+            t_store *= scale_3d_pts;
+        }
+        Mat R;
+        Rodrigues(r_store, R);
+    }
+    if (! rt_mat_vec) {
+        rs.copyTo(Rs);
+        ts.copyTo(Ts);
+    }
+    Mat rvecs0_, tvecs0_;
+    bool is_mat_vec = rvecs0.needed() && rvecs0.isMatVector();
+    if (is_mat_vec) {
+        rvecs0.create(NUM_FRAMES, 1, CV_64F);
+    } else {
+        rvecs0_ = Mat_<double>(NUM_FRAMES, 3);
+    }
+    cnt_valid_frame = 0;
+    for (int f = 0; f < NUM_FRAMES; f++) {
+        if (!valid_frames[f]) continue;
+        if (is_mat_vec)
+            rvecs0.create(3, 1, CV_64F, f, true);
+        Mat store = is_mat_vec ? rvecs0.getMat(f) : rvecs0_.row(f);
+        memcpy(store.ptr(), params + (cnt_valid_frame + NUM_CAMERAS - 1)*6, 3*sizeof(double));
+        cnt_valid_frame += 1;
+    }
+    if (!is_mat_vec && rvecs0.needed())
+        rvecs0_.copyTo(rvecs0);
+
+    is_mat_vec = tvecs0.needed() && tvecs0.isMatVector();
+    if (is_mat_vec) {
+        tvecs0.create(NUM_FRAMES, 1, CV_64F);
+    } else {
+        tvecs0_ = Mat_<double>(NUM_FRAMES, 3);
+    }
+    cnt_valid_frame = 0;
+    for (int f = 0; f < NUM_FRAMES; f++) {
+        if (!valid_frames[f]) continue;
+        if (is_mat_vec)
+            tvecs0.create(3, 1, CV_64F, f, true);
+        Mat store = is_mat_vec ? tvecs0.getMat(f) : tvecs0_.row(f);
+        memcpy(store.ptr(), params + (cnt_valid_frame + NUM_CAMERAS - 1)*6+3, 3*sizeof(double));
+        store *= scale_3d_pts;
+        cnt_valid_frame += 1;
+    }
+    if (!is_mat_vec && tvecs0.needed())
+        tvecs0_.copyTo(tvecs0);
+    double sum_errors = 0, cnt_errors = 0;
+
+    const bool rvecs_mat_vec = rvecs0.needed() && rvecs0.isMatVector(), tvecs_mat_vec = tvecs0.needed() && tvecs0.isMatVector();
+    const bool r_mat_vec = Rs.isMatVector(), t_mat_vec = Ts.isMatVector();
+    Mat errs = Mat_<double>(NUM_CAMERAS, NUM_FRAMES);
+    auto * errs_ptr = (double *) errs.data;
+    for (int c = 0; c < NUM_CAMERAS; c++) {
+        const Mat rvec = r_mat_vec ? Rs.getMat(c) : Rs.getMat().row(c).t();
+        const Mat tvec = t_mat_vec ? Ts.getMat(c) : Ts.getMat().row(c).t();
+        for (int f = 0; f < NUM_FRAMES; f++) {
+            if (detection_mask_mat[c][f]) {
+                const Mat rvec0 = rvecs_mat_vec ? rvecs0.getMat(f) : rvecs0_.row(f).t();
+                const Mat tvec0 = tvecs_mat_vec ? tvecs0.getMat(f) : tvecs0_.row(f).t();
+                const double err2 = multiview::computeReprojectionMSE(objPoints.getMat(f), imagePoints[c][f], Ks_vec[c],
+                        distortions_vec[c], rvec0, tvec0, rvec, tvec, models_mat.at<uchar>(c));
+                (*errs_ptr++) = sqrt(err2);
+                sum_errors += err2;
+                cnt_errors += 1;
+            } else (*errs_ptr++) = -1.0;
+        }
+    }
+
+    if (perFrameErrors.needed()) {
+        errs.copyTo(perFrameErrors);
+    }
+
+    return sqrt(sum_errors / cnt_errors);
+}
+
+double calibrateMultiview(
+        InputArrayOfArrays objPoints, const std::vector<std::vector<Mat>> &imagePoints,
+        const std::vector<cv::Size>& imageSize, InputArray detectionMask, InputArray models,
+        InputOutputArrayOfArrays Ks, InputOutputArrayOfArrays distortions,
+        InputOutputArrayOfArrays Rs, InputOutputArrayOfArrays Ts,
+        InputArray flagsForIntrinsics, int flags, TermCriteria criteria) {
+
+    return calibrateMultiview(objPoints, imagePoints, imageSize, detectionMask, models, Ks, distortions,
+                Rs, Ts, noArray(), noArray(), noArray(), noArray(), flagsForIntrinsics, flags, criteria);
+}
+
+
+}
diff --git a/upstream/opencv/modules/calib/src/precomp.hpp b/upstream/opencv/modules/calib/src/precomp.hpp
new file mode 100644
index 0000000..31893cf
--- /dev/null
+++ b/upstream/opencv/modules/calib/src/precomp.hpp
@@ -0,0 +1,139 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core/utility.hpp"
+
+#include "opencv2/core/private.hpp"
+
+#include "opencv2/calib.hpp"
+#include "opencv2/geometry.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features.hpp"
+
+#include "opencv2/core/ocl.hpp"
+
+#define GET_OPTIMIZED(func) (func)
+
+
+namespace cv {
+
+/**
+ * Compute the number of iterations given the confidence, outlier ratio, number
+ * of model points and the maximum iteration number.
+ *
+ * @param p confidence value
+ * @param ep outlier ratio
+ * @param modelPoints number of model points required for estimation
+ * @param maxIters maximum number of iterations
+ * @return The number of iterations according to the formula
+ * \f[
+ * \frac{\ln(1-p)}{\ln\left(1-(1-ep)^\mathrm{modelPoints}\right)}
+ * \f]
+ *
+ * If the computed number of iterations is larger than maxIters, then maxIters is returned.
+ */
+int RANSACUpdateNumIters( double p, double ep, int modelPoints, int maxIters );
+
+class CV_EXPORTS PointSetRegistrator : public Algorithm
+{
+public:
+    class CV_EXPORTS Callback
+    {
+    public:
+        virtual ~Callback() {}
+        virtual int runKernel(InputArray m1, InputArray m2, OutputArray model) const = 0;
+        virtual void computeError(InputArray m1, InputArray m2, InputArray model, OutputArray err) const = 0;
+        virtual bool checkSubset(InputArray, InputArray, int) const { return true; }
+    };
+
+    virtual void setCallback(const Ptr<PointSetRegistrator::Callback>& cb) = 0;
+    virtual bool run(InputArray m1, InputArray m2, OutputArray model, OutputArray mask) const = 0;
+};
+
+CV_EXPORTS Ptr<PointSetRegistrator> createRANSACPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                    int modelPoints, double threshold,
+                                                                    double confidence=0.99, int maxIters=1000 );
+
+CV_EXPORTS Ptr<PointSetRegistrator> createLMeDSPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                   int modelPoints, double confidence=0.99, int maxIters=1000 );
+
+template<typename T> inline int compressElems( T* ptr, const uchar* mask, int mstep, int count )
+{
+    int i, j;
+    for( i = j = 0; i < count; i++ )
+        if( mask[i*mstep] )
+        {
+            if( i > j )
+                ptr[j] = ptr[i];
+            j++;
+        }
+    return j;
+}
+
+static inline bool haveCollinearPoints( const Mat& m, int count )
+{
+    int j, k, i = count-1;
+    const Point2f* ptr = m.ptr<Point2f>();
+
+    // check that the i-th selected point does not belong
+    // to a line connecting some previously selected points
+    // also checks that points are not too close to each other
+    for( j = 0; j < i; j++ )
+    {
+        double dx1 = ptr[j].x - ptr[i].x;
+        double dy1 = ptr[j].y - ptr[i].y;
+        for( k = 0; k < j; k++ )
+        {
+            double dx2 = ptr[k].x - ptr[i].x;
+            double dy2 = ptr[k].y - ptr[i].y;
+            if( fabs(dx2*dy1 - dy2*dx1) <= FLT_EPSILON*(fabs(dx1) + fabs(dy1) + fabs(dx2) + fabs(dy2)))
+                return true;
+        }
+    }
+    return false;
+}
+
+} // namespace cv
+
+#endif
diff --git a/third_party/opencv-5.0.0/modules/core/3rdparty/SoftFloat/COPYING.txt b/upstream/opencv/modules/core/3rdparty/SoftFloat/COPYING.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/3rdparty/SoftFloat/COPYING.txt
rename to upstream/opencv/modules/core/3rdparty/SoftFloat/COPYING.txt
diff --git a/third_party/opencv-5.0.0/modules/core/CMakeLists.txt b/upstream/opencv/modules/core/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/CMakeLists.txt
rename to upstream/opencv/modules/core/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/core/cmake/parallel/detect_openmp.cmake b/upstream/opencv/modules/core/cmake/parallel/detect_openmp.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/cmake/parallel/detect_openmp.cmake
rename to upstream/opencv/modules/core/cmake/parallel/detect_openmp.cmake
diff --git a/third_party/opencv-5.0.0/modules/core/cmake/parallel/detect_tbb.cmake b/upstream/opencv/modules/core/cmake/parallel/detect_tbb.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/cmake/parallel/detect_tbb.cmake
rename to upstream/opencv/modules/core/cmake/parallel/detect_tbb.cmake
diff --git a/third_party/opencv-5.0.0/modules/core/cmake/parallel/init.cmake b/upstream/opencv/modules/core/cmake/parallel/init.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/cmake/parallel/init.cmake
rename to upstream/opencv/modules/core/cmake/parallel/init.cmake
diff --git a/third_party/opencv-5.0.0/modules/core/doc/cuda.markdown b/upstream/opencv/modules/core/doc/cuda.markdown
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/cuda.markdown
rename to upstream/opencv/modules/core/doc/cuda.markdown
diff --git a/third_party/opencv-5.0.0/modules/core/doc/intro.markdown b/upstream/opencv/modules/core/doc/intro.markdown
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/intro.markdown
rename to upstream/opencv/modules/core/doc/intro.markdown
diff --git a/third_party/opencv-5.0.0/modules/core/doc/pics/NormTypes_OneArray_1-2-INF.png b/upstream/opencv/modules/core/doc/pics/NormTypes_OneArray_1-2-INF.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/pics/NormTypes_OneArray_1-2-INF.png
rename to upstream/opencv/modules/core/doc/pics/NormTypes_OneArray_1-2-INF.png
diff --git a/third_party/opencv-5.0.0/modules/core/doc/pics/memstorage1.png b/upstream/opencv/modules/core/doc/pics/memstorage1.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/pics/memstorage1.png
rename to upstream/opencv/modules/core/doc/pics/memstorage1.png
diff --git a/third_party/opencv-5.0.0/modules/core/doc/pics/memstorage2.png b/upstream/opencv/modules/core/doc/pics/memstorage2.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/pics/memstorage2.png
rename to upstream/opencv/modules/core/doc/pics/memstorage2.png
diff --git a/third_party/opencv-5.0.0/modules/core/doc/pics/rotatedrect.png b/upstream/opencv/modules/core/doc/pics/rotatedrect.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/doc/pics/rotatedrect.png
rename to upstream/opencv/modules/core/doc/pics/rotatedrect.png
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core.hpp b/upstream/opencv/modules/core/include/opencv2/core.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core.hpp
rename to upstream/opencv/modules/core/include/opencv2/core.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/affine.hpp b/upstream/opencv/modules/core/include/opencv2/core/affine.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/affine.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/affine.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/async.hpp b/upstream/opencv/modules/core/include/opencv2/core/async.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/async.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/async.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/base.hpp b/upstream/opencv/modules/core/include/opencv2/core/base.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/base.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/base.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/bindings_utils.hpp b/upstream/opencv/modules/core/include/opencv2/core/bindings_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/bindings_utils.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/bindings_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/bufferpool.hpp b/upstream/opencv/modules/core/include/opencv2/core/bufferpool.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/bufferpool.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/bufferpool.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/check.hpp b/upstream/opencv/modules/core/include/opencv2/core/check.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/check.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/check.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/core.hpp b/upstream/opencv/modules/core/include/opencv2/core/core.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/core.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/core.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/block.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/block.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/block.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/block.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/border_interpolate.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/border_interpolate.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/border_interpolate.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/border_interpolate.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/color.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/color.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/color.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/color.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/common.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/common.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/common.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/cuda_compat.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/cuda_compat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/cuda_compat.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/cuda_compat.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/datamov_utils.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/datamov_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/datamov_utils.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/datamov_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/reduce.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/reduce.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/emulation.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/emulation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/emulation.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/emulation.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/filters.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/filters.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/filters.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/filters.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/funcattrib.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/funcattrib.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/funcattrib.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/funcattrib.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/functional.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/functional.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/functional.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/functional.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/limits.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/limits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/limits.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/limits.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/reduce.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/reduce.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/reduce.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/reduce.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/saturate_cast.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/saturate_cast.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/saturate_cast.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/saturate_cast.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/scan.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/scan.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/scan.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/scan.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/simd_functions.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/simd_functions.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/simd_functions.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/simd_functions.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/transform.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/transform.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/transform.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/transform.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/type_traits.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/type_traits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/type_traits.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/type_traits.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/utility.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/utility.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/utility.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/utility.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_distance.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/vec_distance.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_distance.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/vec_distance.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_math.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/vec_math.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_math.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/vec_math.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_traits.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/vec_traits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/vec_traits.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/vec_traits.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/warp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/warp.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp_reduce.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/warp_reduce.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp_reduce.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/warp_reduce.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda_stream_accessor.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda_stream_accessor.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda_stream_accessor.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda_stream_accessor.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda_types.hpp b/upstream/opencv/modules/core/include/opencv2/core/cuda_types.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cuda_types.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cuda_types.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cv_cpu_dispatch.h b/upstream/opencv/modules/core/include/opencv2/core/cv_cpu_dispatch.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cv_cpu_dispatch.h
rename to upstream/opencv/modules/core/include/opencv2/core/cv_cpu_dispatch.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cv_cpu_helper.h b/upstream/opencv/modules/core/include/opencv2/core/cv_cpu_helper.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cv_cpu_helper.h
rename to upstream/opencv/modules/core/include/opencv2/core/cv_cpu_helper.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvdef.h b/upstream/opencv/modules/core/include/opencv2/core/cvdef.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvdef.h
rename to upstream/opencv/modules/core/include/opencv2/core/cvdef.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd.hpp b/upstream/opencv/modules/core/include/opencv2/core/cvstd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cvstd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/cvstd.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cvstd.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd_wrapper.hpp b/upstream/opencv/modules/core/include/opencv2/core/cvstd_wrapper.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/cvstd_wrapper.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/cvstd_wrapper.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/async_promise.hpp b/upstream/opencv/modules/core/include/opencv2/core/detail/async_promise.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/async_promise.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/detail/async_promise.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp b/upstream/opencv/modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/detail/dispatch_helper.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/exception_ptr.hpp b/upstream/opencv/modules/core/include/opencv2/core/detail/exception_ptr.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/detail/exception_ptr.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/detail/exception_ptr.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/directx.hpp b/upstream/opencv/modules/core/include/opencv2/core/directx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/directx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/directx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/dualquaternion.hpp b/upstream/opencv/modules/core/include/opencv2/core/dualquaternion.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/dualquaternion.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/dualquaternion.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/dualquaternion.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/dualquaternion.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/dualquaternion.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/dualquaternion.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/eigen.hpp b/upstream/opencv/modules/core/include/opencv2/core/eigen.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/eigen.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/eigen.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/exception.hpp b/upstream/opencv/modules/core/include/opencv2/core/exception.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/exception.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/exception.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/fast_math.hpp b/upstream/opencv/modules/core/include/opencv2/core/fast_math.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/fast_math.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/fast_math.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/fwddecl.hpp b/upstream/opencv/modules/core/include/opencv2/core/fwddecl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/fwddecl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/fwddecl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/hal.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/hal.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/hal.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/hal.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/interface.h b/upstream/opencv/modules/core/include/opencv2/core/hal/interface.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/interface.h
rename to upstream/opencv/modules/core/include/opencv2/core/hal/interface.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_avx.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_avx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_avx512.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx512.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_avx512.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_avx512.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_cpp.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_cpp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_cpp.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_cpp.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_forward.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_forward.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_forward.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_forward.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_lasx.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lasx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_lasx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lasx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_legacy_ops.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_lsx.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lsx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_lsx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_lsx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_math.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_math.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_math.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_math.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_msa.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_msa.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_msa.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_msa.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_neon.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_neon.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_neon.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_neon.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv071.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_rvv_scalable.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_sse.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_sse.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_sse_em.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse_em.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_sse_em.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_sse_em.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_vsx.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_vsx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_vsx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_vsx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_wasm.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/intrin_wasm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/intrin_wasm.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/intrin_wasm.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/msa_macros.h b/upstream/opencv/modules/core/include/opencv2/core/hal/msa_macros.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/msa_macros.h
rename to upstream/opencv/modules/core/include/opencv2/core/hal/msa_macros.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp b/upstream/opencv/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/hal/simd_utils.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/llapi/llapi.h b/upstream/opencv/modules/core/include/opencv2/core/llapi/llapi.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/llapi/llapi.h
rename to upstream/opencv/modules/core/include/opencv2/core/llapi/llapi.h
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/mat.hpp b/upstream/opencv/modules/core/include/opencv2/core/mat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/mat.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/mat.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/mat.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/mat.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/mat.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/mat.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/matx.hpp b/upstream/opencv/modules/core/include/opencv2/core/matx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/matx.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/matx.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/matx.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/matx.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/matx.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/matx.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/neon_utils.hpp b/upstream/opencv/modules/core/include/opencv2/core/neon_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/neon_utils.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/neon_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/ocl.hpp b/upstream/opencv/modules/core/include/opencv2/core/ocl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/ocl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/ocl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/ocl_genbase.hpp b/upstream/opencv/modules/core/include/opencv2/core/ocl_genbase.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/ocl_genbase.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/ocl_genbase.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/ocl_defs.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/ocl_defs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/ocl_defs.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/ocl_defs.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/opencl_info.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_info.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/opencl_info.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_info.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/opencl_svm.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_svm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/opencl_svm.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/opencl_svm.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clblas.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_clfft.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core_wrappers.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core_wrappers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core_wrappers.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_core_wrappers.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl_wrappers.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl_wrappers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl_wrappers.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/autogenerated/opencl_gl_wrappers.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clblas.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_clfft.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_core_wrappers.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_gl_wrappers.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_20.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_definitions.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp b/upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opencl/runtime/opencl_svm_hsa_extension.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/opengl.hpp b/upstream/opencv/modules/core/include/opencv2/core/opengl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/opengl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/opengl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/operations.hpp b/upstream/opencv/modules/core/include/opencv2/core/operations.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/operations.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/operations.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/optim.hpp b/upstream/opencv/modules/core/include/opencv2/core/optim.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/optim.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/optim.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp b/upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp b/upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/parallel_backend.hpp b/upstream/opencv/modules/core/include/opencv2/core/parallel/parallel_backend.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/parallel/parallel_backend.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/parallel/parallel_backend.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/persistence.hpp b/upstream/opencv/modules/core/include/opencv2/core/persistence.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/persistence.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/persistence.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/private.cuda.hpp b/upstream/opencv/modules/core/include/opencv2/core/private.cuda.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/private.cuda.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/private.cuda.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/private.hpp b/upstream/opencv/modules/core/include/opencv2/core/private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/private/cuda_stubs.hpp b/upstream/opencv/modules/core/include/opencv2/core/private/cuda_stubs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/private/cuda_stubs.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/private/cuda_stubs.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/private/cv_cpu_include_simd_declarations.hpp b/upstream/opencv/modules/core/include/opencv2/core/private/cv_cpu_include_simd_declarations.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/private/cv_cpu_include_simd_declarations.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/private/cv_cpu_include_simd_declarations.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/quaternion.hpp b/upstream/opencv/modules/core/include/opencv2/core/quaternion.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/quaternion.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/quaternion.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/quaternion.inl.hpp b/upstream/opencv/modules/core/include/opencv2/core/quaternion.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/quaternion.inl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/quaternion.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/saturate.hpp b/upstream/opencv/modules/core/include/opencv2/core/saturate.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/saturate.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/saturate.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/simd_intrinsics.hpp b/upstream/opencv/modules/core/include/opencv2/core/simd_intrinsics.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/simd_intrinsics.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/simd_intrinsics.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/softfloat.hpp b/upstream/opencv/modules/core/include/opencv2/core/softfloat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/softfloat.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/softfloat.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/traits.hpp b/upstream/opencv/modules/core/include/opencv2/core/traits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/traits.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/traits.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/types.hpp b/upstream/opencv/modules/core/include/opencv2/core/types.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/types.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/types.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utility.hpp b/upstream/opencv/modules/core/include/opencv2/core/utility.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utility.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utility.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/allocator_stats.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/allocator_stats.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/allocator_stats.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/buffer_area.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/buffer_area.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/buffer_area.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/buffer_area.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/configuration.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/configuration.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/configuration.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/configuration.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/filesystem.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/filesystem.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/filesystem.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/filesystem.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/filesystem.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/fp_control.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/fp_control.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/fp_control.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/fp_control.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/fp_control_utils.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/fp_control_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/fp_control_utils.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/fp_control_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/instrumentation.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/instrumentation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/instrumentation.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/instrumentation.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/lock.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/lock.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/lock.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/lock.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logger.defines.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/logger.defines.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logger.defines.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/logger.defines.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logger.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/logger.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logger.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/logger.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logtag.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/logtag.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/logtag.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/logtag.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/plugin_loader.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/plugin_loader.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/plugin_loader.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/plugin_loader.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/tls.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/tls.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/tls.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/tls.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/trace.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/trace.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/trace.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/trace.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/trace.private.hpp b/upstream/opencv/modules/core/include/opencv2/core/utils/trace.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/utils/trace.private.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/utils/trace.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/va_intel.hpp b/upstream/opencv/modules/core/include/opencv2/core/va_intel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/va_intel.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/va_intel.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/version.hpp b/upstream/opencv/modules/core/include/opencv2/core/version.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/version.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/version.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/include/opencv2/core/vsx_utils.hpp b/upstream/opencv/modules/core/include/opencv2/core/vsx_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/include/opencv2/core/vsx_utils.hpp
rename to upstream/opencv/modules/core/include/opencv2/core/vsx_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/misc/plugins/parallel_openmp/CMakeLists.txt b/upstream/opencv/modules/core/misc/plugins/parallel_openmp/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/misc/plugins/parallel_openmp/CMakeLists.txt
rename to upstream/opencv/modules/core/misc/plugins/parallel_openmp/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/core/misc/plugins/parallel_tbb/CMakeLists.txt b/upstream/opencv/modules/core/misc/plugins/parallel_tbb/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/misc/plugins/parallel_tbb/CMakeLists.txt
rename to upstream/opencv/modules/core/misc/plugins/parallel_tbb/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/core/src/algorithm.cpp b/upstream/opencv/modules/core/src/algorithm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/algorithm.cpp
rename to upstream/opencv/modules/core/src/algorithm.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/alloc.cpp b/upstream/opencv/modules/core/src/alloc.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/alloc.cpp
rename to upstream/opencv/modules/core/src/alloc.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/arithm.cpp b/upstream/opencv/modules/core/src/arithm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/arithm.cpp
rename to upstream/opencv/modules/core/src/arithm.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/arithm.dispatch.cpp b/upstream/opencv/modules/core/src/arithm.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/arithm.dispatch.cpp
rename to upstream/opencv/modules/core/src/arithm.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/arithm.simd.hpp b/upstream/opencv/modules/core/src/arithm.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/arithm.simd.hpp
rename to upstream/opencv/modules/core/src/arithm.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/arithm_ipp.hpp b/upstream/opencv/modules/core/src/arithm_ipp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/arithm_ipp.hpp
rename to upstream/opencv/modules/core/src/arithm_ipp.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/async.cpp b/upstream/opencv/modules/core/src/async.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/async.cpp
rename to upstream/opencv/modules/core/src/async.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/batch_distance.cpp b/upstream/opencv/modules/core/src/batch_distance.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/batch_distance.cpp
rename to upstream/opencv/modules/core/src/batch_distance.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/bindings_utils.cpp b/upstream/opencv/modules/core/src/bindings_utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/bindings_utils.cpp
rename to upstream/opencv/modules/core/src/bindings_utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/buffer_area.cpp b/upstream/opencv/modules/core/src/buffer_area.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/buffer_area.cpp
rename to upstream/opencv/modules/core/src/buffer_area.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/bufferpool.impl.hpp b/upstream/opencv/modules/core/src/bufferpool.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/bufferpool.impl.hpp
rename to upstream/opencv/modules/core/src/bufferpool.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/channels.cpp b/upstream/opencv/modules/core/src/channels.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/channels.cpp
rename to upstream/opencv/modules/core/src/channels.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/check.cpp b/upstream/opencv/modules/core/src/check.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/check.cpp
rename to upstream/opencv/modules/core/src/check.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/command_line_parser.cpp b/upstream/opencv/modules/core/src/command_line_parser.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/command_line_parser.cpp
rename to upstream/opencv/modules/core/src/command_line_parser.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/conjugate_gradient.cpp b/upstream/opencv/modules/core/src/conjugate_gradient.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/conjugate_gradient.cpp
rename to upstream/opencv/modules/core/src/conjugate_gradient.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/convert.dispatch.cpp b/upstream/opencv/modules/core/src/convert.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/convert.dispatch.cpp
rename to upstream/opencv/modules/core/src/convert.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/convert.hpp b/upstream/opencv/modules/core/src/convert.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/convert.hpp
rename to upstream/opencv/modules/core/src/convert.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/convert.simd.hpp b/upstream/opencv/modules/core/src/convert.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/convert.simd.hpp
rename to upstream/opencv/modules/core/src/convert.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/convert_scale.dispatch.cpp b/upstream/opencv/modules/core/src/convert_scale.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/convert_scale.dispatch.cpp
rename to upstream/opencv/modules/core/src/convert_scale.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/convert_scale.simd.hpp b/upstream/opencv/modules/core/src/convert_scale.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/convert_scale.simd.hpp
rename to upstream/opencv/modules/core/src/convert_scale.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/copy.cpp b/upstream/opencv/modules/core/src/copy.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/copy.cpp
rename to upstream/opencv/modules/core/src/copy.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/count_non_zero.dispatch.cpp b/upstream/opencv/modules/core/src/count_non_zero.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/count_non_zero.dispatch.cpp
rename to upstream/opencv/modules/core/src/count_non_zero.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/count_non_zero.simd.hpp b/upstream/opencv/modules/core/src/count_non_zero.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/count_non_zero.simd.hpp
rename to upstream/opencv/modules/core/src/count_non_zero.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda/gpu_mat.cu b/upstream/opencv/modules/core/src/cuda/gpu_mat.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda/gpu_mat.cu
rename to upstream/opencv/modules/core/src/cuda/gpu_mat.cu
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda/gpu_mat_nd.cu b/upstream/opencv/modules/core/src/cuda/gpu_mat_nd.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda/gpu_mat_nd.cu
rename to upstream/opencv/modules/core/src/cuda/gpu_mat_nd.cu
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda_gpu_mat.cpp b/upstream/opencv/modules/core/src/cuda_gpu_mat.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda_gpu_mat.cpp
rename to upstream/opencv/modules/core/src/cuda_gpu_mat.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda_gpu_mat_nd.cpp b/upstream/opencv/modules/core/src/cuda_gpu_mat_nd.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda_gpu_mat_nd.cpp
rename to upstream/opencv/modules/core/src/cuda_gpu_mat_nd.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda_host_mem.cpp b/upstream/opencv/modules/core/src/cuda_host_mem.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda_host_mem.cpp
rename to upstream/opencv/modules/core/src/cuda_host_mem.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda_info.cpp b/upstream/opencv/modules/core/src/cuda_info.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda_info.cpp
rename to upstream/opencv/modules/core/src/cuda_info.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/cuda_stream.cpp b/upstream/opencv/modules/core/src/cuda_stream.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/cuda_stream.cpp
rename to upstream/opencv/modules/core/src/cuda_stream.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/directx.cpp b/upstream/opencv/modules/core/src/directx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/directx.cpp
rename to upstream/opencv/modules/core/src/directx.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/directx.inc.hpp b/upstream/opencv/modules/core/src/directx.inc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/directx.inc.hpp
rename to upstream/opencv/modules/core/src/directx.inc.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/downhill_simplex.cpp b/upstream/opencv/modules/core/src/downhill_simplex.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/downhill_simplex.cpp
rename to upstream/opencv/modules/core/src/downhill_simplex.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/dxt.cpp b/upstream/opencv/modules/core/src/dxt.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/dxt.cpp
rename to upstream/opencv/modules/core/src/dxt.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/gl_core_3_1.cpp b/upstream/opencv/modules/core/src/gl_core_3_1.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/gl_core_3_1.cpp
rename to upstream/opencv/modules/core/src/gl_core_3_1.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/gl_core_3_1.hpp b/upstream/opencv/modules/core/src/gl_core_3_1.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/gl_core_3_1.hpp
rename to upstream/opencv/modules/core/src/gl_core_3_1.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/glob.cpp b/upstream/opencv/modules/core/src/glob.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/glob.cpp
rename to upstream/opencv/modules/core/src/glob.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/hal_internal.cpp b/upstream/opencv/modules/core/src/hal_internal.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/hal_internal.cpp
rename to upstream/opencv/modules/core/src/hal_internal.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/hal_internal.hpp b/upstream/opencv/modules/core/src/hal_internal.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/hal_internal.hpp
rename to upstream/opencv/modules/core/src/hal_internal.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/hal_replacement.hpp b/upstream/opencv/modules/core/src/hal_replacement.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/hal_replacement.hpp
rename to upstream/opencv/modules/core/src/hal_replacement.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/has_non_zero.dispatch.cpp b/upstream/opencv/modules/core/src/has_non_zero.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/has_non_zero.dispatch.cpp
rename to upstream/opencv/modules/core/src/has_non_zero.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/has_non_zero.simd.hpp b/upstream/opencv/modules/core/src/has_non_zero.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/has_non_zero.simd.hpp
rename to upstream/opencv/modules/core/src/has_non_zero.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/intel_gpu_gemm.inl.hpp b/upstream/opencv/modules/core/src/intel_gpu_gemm.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/intel_gpu_gemm.inl.hpp
rename to upstream/opencv/modules/core/src/intel_gpu_gemm.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/kmeans.cpp b/upstream/opencv/modules/core/src/kmeans.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/kmeans.cpp
rename to upstream/opencv/modules/core/src/kmeans.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/lapack.cpp b/upstream/opencv/modules/core/src/lapack.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/lapack.cpp
rename to upstream/opencv/modules/core/src/lapack.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/lda.cpp b/upstream/opencv/modules/core/src/lda.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/lda.cpp
rename to upstream/opencv/modules/core/src/lda.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/logger.cpp b/upstream/opencv/modules/core/src/logger.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/logger.cpp
rename to upstream/opencv/modules/core/src/logger.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/lpsolver.cpp b/upstream/opencv/modules/core/src/lpsolver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/lpsolver.cpp
rename to upstream/opencv/modules/core/src/lpsolver.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/lut.cpp b/upstream/opencv/modules/core/src/lut.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/lut.cpp
rename to upstream/opencv/modules/core/src/lut.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mathfuncs.cpp b/upstream/opencv/modules/core/src/mathfuncs.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mathfuncs.cpp
rename to upstream/opencv/modules/core/src/mathfuncs.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mathfuncs.hpp b/upstream/opencv/modules/core/src/mathfuncs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mathfuncs.hpp
rename to upstream/opencv/modules/core/src/mathfuncs.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mathfuncs_core.dispatch.cpp b/upstream/opencv/modules/core/src/mathfuncs_core.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mathfuncs_core.dispatch.cpp
rename to upstream/opencv/modules/core/src/mathfuncs_core.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mathfuncs_core.simd.hpp b/upstream/opencv/modules/core/src/mathfuncs_core.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mathfuncs_core.simd.hpp
rename to upstream/opencv/modules/core/src/mathfuncs_core.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matmul.dispatch.cpp b/upstream/opencv/modules/core/src/matmul.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matmul.dispatch.cpp
rename to upstream/opencv/modules/core/src/matmul.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matmul.simd.hpp b/upstream/opencv/modules/core/src/matmul.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matmul.simd.hpp
rename to upstream/opencv/modules/core/src/matmul.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix.cpp b/upstream/opencv/modules/core/src/matrix.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix.cpp
rename to upstream/opencv/modules/core/src/matrix.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_decomp.cpp b/upstream/opencv/modules/core/src/matrix_decomp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_decomp.cpp
rename to upstream/opencv/modules/core/src/matrix_decomp.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_expressions.cpp b/upstream/opencv/modules/core/src/matrix_expressions.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_expressions.cpp
rename to upstream/opencv/modules/core/src/matrix_expressions.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_iterator.cpp b/upstream/opencv/modules/core/src/matrix_iterator.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_iterator.cpp
rename to upstream/opencv/modules/core/src/matrix_iterator.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_operations.cpp b/upstream/opencv/modules/core/src/matrix_operations.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_operations.cpp
rename to upstream/opencv/modules/core/src/matrix_operations.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_sparse.cpp b/upstream/opencv/modules/core/src/matrix_sparse.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_sparse.cpp
rename to upstream/opencv/modules/core/src/matrix_sparse.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_transform.cpp b/upstream/opencv/modules/core/src/matrix_transform.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_transform.cpp
rename to upstream/opencv/modules/core/src/matrix_transform.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/matrix_wrap.cpp b/upstream/opencv/modules/core/src/matrix_wrap.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/matrix_wrap.cpp
rename to upstream/opencv/modules/core/src/matrix_wrap.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mean.dispatch.cpp b/upstream/opencv/modules/core/src/mean.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mean.dispatch.cpp
rename to upstream/opencv/modules/core/src/mean.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/mean.simd.hpp b/upstream/opencv/modules/core/src/mean.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/mean.simd.hpp
rename to upstream/opencv/modules/core/src/mean.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/merge.dispatch.cpp b/upstream/opencv/modules/core/src/merge.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/merge.dispatch.cpp
rename to upstream/opencv/modules/core/src/merge.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/merge.simd.hpp b/upstream/opencv/modules/core/src/merge.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/merge.simd.hpp
rename to upstream/opencv/modules/core/src/merge.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/minmax.dispatch.cpp b/upstream/opencv/modules/core/src/minmax.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/minmax.dispatch.cpp
rename to upstream/opencv/modules/core/src/minmax.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/minmax.simd.hpp b/upstream/opencv/modules/core/src/minmax.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/minmax.simd.hpp
rename to upstream/opencv/modules/core/src/minmax.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/nan_mask.dispatch.cpp b/upstream/opencv/modules/core/src/nan_mask.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/nan_mask.dispatch.cpp
rename to upstream/opencv/modules/core/src/nan_mask.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/nan_mask.simd.hpp b/upstream/opencv/modules/core/src/nan_mask.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/nan_mask.simd.hpp
rename to upstream/opencv/modules/core/src/nan_mask.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/norm.dispatch.cpp b/upstream/opencv/modules/core/src/norm.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/norm.dispatch.cpp
rename to upstream/opencv/modules/core/src/norm.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/norm.simd.hpp b/upstream/opencv/modules/core/src/norm.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/norm.simd.hpp
rename to upstream/opencv/modules/core/src/norm.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/ocl.cpp b/upstream/opencv/modules/core/src/ocl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/ocl.cpp
rename to upstream/opencv/modules/core/src/ocl.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/ocl_disabled.impl.hpp b/upstream/opencv/modules/core/src/ocl_disabled.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/ocl_disabled.impl.hpp
rename to upstream/opencv/modules/core/src/ocl_disabled.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/arithm.cl b/upstream/opencv/modules/core/src/opencl/arithm.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/arithm.cl
rename to upstream/opencv/modules/core/src/opencl/arithm.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/convert.cl b/upstream/opencv/modules/core/src/opencl/convert.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/convert.cl
rename to upstream/opencv/modules/core/src/opencl/convert.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/copymakeborder.cl b/upstream/opencv/modules/core/src/opencl/copymakeborder.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/copymakeborder.cl
rename to upstream/opencv/modules/core/src/opencl/copymakeborder.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/copyset.cl b/upstream/opencv/modules/core/src/opencl/copyset.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/copyset.cl
rename to upstream/opencv/modules/core/src/opencl/copyset.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/cvtclr_dx.cl b/upstream/opencv/modules/core/src/opencl/cvtclr_dx.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/cvtclr_dx.cl
rename to upstream/opencv/modules/core/src/opencl/cvtclr_dx.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/fft.cl b/upstream/opencv/modules/core/src/opencl/fft.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/fft.cl
rename to upstream/opencv/modules/core/src/opencl/fft.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/finitemask.cl b/upstream/opencv/modules/core/src/opencl/finitemask.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/finitemask.cl
rename to upstream/opencv/modules/core/src/opencl/finitemask.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/flip.cl b/upstream/opencv/modules/core/src/opencl/flip.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/flip.cl
rename to upstream/opencv/modules/core/src/opencl/flip.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/gemm.cl b/upstream/opencv/modules/core/src/opencl/gemm.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/gemm.cl
rename to upstream/opencv/modules/core/src/opencl/gemm.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/inrange.cl b/upstream/opencv/modules/core/src/opencl/inrange.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/inrange.cl
rename to upstream/opencv/modules/core/src/opencl/inrange.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/intel_gemm.cl b/upstream/opencv/modules/core/src/opencl/intel_gemm.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/intel_gemm.cl
rename to upstream/opencv/modules/core/src/opencl/intel_gemm.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/lut.cl b/upstream/opencv/modules/core/src/opencl/lut.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/lut.cl
rename to upstream/opencv/modules/core/src/opencl/lut.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/meanstddev.cl b/upstream/opencv/modules/core/src/opencl/meanstddev.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/meanstddev.cl
rename to upstream/opencv/modules/core/src/opencl/meanstddev.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/minmaxloc.cl b/upstream/opencv/modules/core/src/opencl/minmaxloc.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/minmaxloc.cl
rename to upstream/opencv/modules/core/src/opencl/minmaxloc.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/mixchannels.cl b/upstream/opencv/modules/core/src/opencl/mixchannels.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/mixchannels.cl
rename to upstream/opencv/modules/core/src/opencl/mixchannels.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/mulspectrums.cl b/upstream/opencv/modules/core/src/opencl/mulspectrums.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/mulspectrums.cl
rename to upstream/opencv/modules/core/src/opencl/mulspectrums.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/normalize.cl b/upstream/opencv/modules/core/src/opencl/normalize.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/normalize.cl
rename to upstream/opencv/modules/core/src/opencl/normalize.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/reduce.cl b/upstream/opencv/modules/core/src/opencl/reduce.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/reduce.cl
rename to upstream/opencv/modules/core/src/opencl/reduce.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/reduce2.cl b/upstream/opencv/modules/core/src/opencl/reduce2.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/reduce2.cl
rename to upstream/opencv/modules/core/src/opencl/reduce2.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/repeat.cl b/upstream/opencv/modules/core/src/opencl/repeat.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/repeat.cl
rename to upstream/opencv/modules/core/src/opencl/repeat.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_clblas_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_clfft_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_core_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_core_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_core_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_core_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_core_static_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_core_static_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_core_static_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_core_static_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_gl_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_gl_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_gl_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_gl_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_gl_static_impl.hpp b/upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_gl_static_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/autogenerated/opencl_gl_static_impl.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/autogenerated/opencl_gl_static_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/common.py b/upstream/opencv/modules/core/src/opencl/runtime/generator/common.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/common.py
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/common.py
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list b/upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_clblas_functions.list
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list b/upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_clfft_functions.list
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_core_functions.list b/upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_core_functions.list
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_core_functions.list
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_core_functions.list
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_gl_functions.list b/upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_gl_functions.list
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/filter/opencl_gl_functions.list
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/filter/opencl_gl_functions.list
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/generate.sh b/upstream/opencv/modules/core/src/opencl/runtime/generator/generate.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/generate.sh
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/generate.sh
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_cl.py b/upstream/opencv/modules/core/src/opencl/runtime/generator/parser_cl.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_cl.py
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/parser_cl.py
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_clblas.py b/upstream/opencv/modules/core/src/opencl/runtime/generator/parser_clblas.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_clblas.py
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/parser_clblas.py
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_clfft.py b/upstream/opencv/modules/core/src/opencl/runtime/generator/parser_clfft.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/parser_clfft.py
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/parser_clfft.py
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clblas.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clblas_impl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clfft.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_clfft_impl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core_impl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core_impl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core_impl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core_impl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core_wrappers.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core_wrappers.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_core_wrappers.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_core_wrappers.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl_impl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl_impl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl_impl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl_impl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl_wrappers.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl_wrappers.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/opencl_gl_wrappers.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/opencl_gl_wrappers.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/static_impl.hpp.in b/upstream/opencv/modules/core/src/opencl/runtime/generator/template/static_impl.hpp.in
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/generator/template/static_impl.hpp.in
rename to upstream/opencv/modules/core/src/opencl/runtime/generator/template/static_impl.hpp.in
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_clblas.cpp b/upstream/opencv/modules/core/src/opencl/runtime/opencl_clblas.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_clblas.cpp
rename to upstream/opencv/modules/core/src/opencl/runtime/opencl_clblas.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_clfft.cpp b/upstream/opencv/modules/core/src/opencl/runtime/opencl_clfft.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_clfft.cpp
rename to upstream/opencv/modules/core/src/opencl/runtime/opencl_clfft.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_core.cpp b/upstream/opencv/modules/core/src/opencl/runtime/opencl_core.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/opencl_core.cpp
rename to upstream/opencv/modules/core/src/opencl/runtime/opencl_core.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/runtime/runtime_common.hpp b/upstream/opencv/modules/core/src/opencl/runtime/runtime_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/runtime/runtime_common.hpp
rename to upstream/opencv/modules/core/src/opencl/runtime/runtime_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/set_identity.cl b/upstream/opencv/modules/core/src/opencl/set_identity.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/set_identity.cl
rename to upstream/opencv/modules/core/src/opencl/set_identity.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/split_merge.cl b/upstream/opencv/modules/core/src/opencl/split_merge.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/split_merge.cl
rename to upstream/opencv/modules/core/src/opencl/split_merge.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opencl/transpose.cl b/upstream/opencv/modules/core/src/opencl/transpose.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opencl/transpose.cl
rename to upstream/opencv/modules/core/src/opencl/transpose.cl
diff --git a/third_party/opencv-5.0.0/modules/core/src/opengl.cpp b/upstream/opencv/modules/core/src/opengl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/opengl.cpp
rename to upstream/opencv/modules/core/src/opengl.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/out.cpp b/upstream/opencv/modules/core/src/out.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/out.cpp
rename to upstream/opencv/modules/core/src/out.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel.cpp b/upstream/opencv/modules/core/src/parallel.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel.cpp
rename to upstream/opencv/modules/core/src/parallel.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/factory_parallel.hpp b/upstream/opencv/modules/core/src/parallel/factory_parallel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/factory_parallel.hpp
rename to upstream/opencv/modules/core/src/parallel/factory_parallel.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/parallel.cpp b/upstream/opencv/modules/core/src/parallel/parallel.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/parallel.cpp
rename to upstream/opencv/modules/core/src/parallel/parallel.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/parallel.hpp b/upstream/opencv/modules/core/src/parallel/parallel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/parallel.hpp
rename to upstream/opencv/modules/core/src/parallel/parallel.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/parallel_openmp.cpp b/upstream/opencv/modules/core/src/parallel/parallel_openmp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/parallel_openmp.cpp
rename to upstream/opencv/modules/core/src/parallel/parallel_openmp.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/parallel_tbb.cpp b/upstream/opencv/modules/core/src/parallel/parallel_tbb.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/parallel_tbb.cpp
rename to upstream/opencv/modules/core/src/parallel/parallel_tbb.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/plugin_parallel_api.hpp b/upstream/opencv/modules/core/src/parallel/plugin_parallel_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/plugin_parallel_api.hpp
rename to upstream/opencv/modules/core/src/parallel/plugin_parallel_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/plugin_parallel_wrapper.impl.hpp b/upstream/opencv/modules/core/src/parallel/plugin_parallel_wrapper.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/plugin_parallel_wrapper.impl.hpp
rename to upstream/opencv/modules/core/src/parallel/plugin_parallel_wrapper.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/registry_parallel.hpp b/upstream/opencv/modules/core/src/parallel/registry_parallel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/registry_parallel.hpp
rename to upstream/opencv/modules/core/src/parallel/registry_parallel.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel/registry_parallel.impl.hpp b/upstream/opencv/modules/core/src/parallel/registry_parallel.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel/registry_parallel.impl.hpp
rename to upstream/opencv/modules/core/src/parallel/registry_parallel.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel_impl.cpp b/upstream/opencv/modules/core/src/parallel_impl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel_impl.cpp
rename to upstream/opencv/modules/core/src/parallel_impl.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/parallel_impl.hpp b/upstream/opencv/modules/core/src/parallel_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/parallel_impl.hpp
rename to upstream/opencv/modules/core/src/parallel_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/pca.cpp b/upstream/opencv/modules/core/src/pca.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/pca.cpp
rename to upstream/opencv/modules/core/src/pca.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence.cpp b/upstream/opencv/modules/core/src/persistence.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence.cpp
rename to upstream/opencv/modules/core/src/persistence.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence.hpp b/upstream/opencv/modules/core/src/persistence.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence.hpp
rename to upstream/opencv/modules/core/src/persistence.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_base64_encoding.cpp b/upstream/opencv/modules/core/src/persistence_base64_encoding.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_base64_encoding.cpp
rename to upstream/opencv/modules/core/src/persistence_base64_encoding.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_base64_encoding.hpp b/upstream/opencv/modules/core/src/persistence_base64_encoding.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_base64_encoding.hpp
rename to upstream/opencv/modules/core/src/persistence_base64_encoding.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_impl.hpp b/upstream/opencv/modules/core/src/persistence_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_impl.hpp
rename to upstream/opencv/modules/core/src/persistence_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_json.cpp b/upstream/opencv/modules/core/src/persistence_json.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_json.cpp
rename to upstream/opencv/modules/core/src/persistence_json.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_types.cpp b/upstream/opencv/modules/core/src/persistence_types.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_types.cpp
rename to upstream/opencv/modules/core/src/persistence_types.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_xml.cpp b/upstream/opencv/modules/core/src/persistence_xml.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_xml.cpp
rename to upstream/opencv/modules/core/src/persistence_xml.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/persistence_yml.cpp b/upstream/opencv/modules/core/src/persistence_yml.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/persistence_yml.cpp
rename to upstream/opencv/modules/core/src/persistence_yml.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/precomp.hpp b/upstream/opencv/modules/core/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/precomp.hpp
rename to upstream/opencv/modules/core/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/rand.cpp b/upstream/opencv/modules/core/src/rand.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/rand.cpp
rename to upstream/opencv/modules/core/src/rand.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/reduce.dispatch.cpp b/upstream/opencv/modules/core/src/reduce.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/reduce.dispatch.cpp
rename to upstream/opencv/modules/core/src/reduce.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/reduce.simd.hpp b/upstream/opencv/modules/core/src/reduce.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/reduce.simd.hpp
rename to upstream/opencv/modules/core/src/reduce.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/softfloat.cpp b/upstream/opencv/modules/core/src/softfloat.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/softfloat.cpp
rename to upstream/opencv/modules/core/src/softfloat.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/split.dispatch.cpp b/upstream/opencv/modules/core/src/split.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/split.dispatch.cpp
rename to upstream/opencv/modules/core/src/split.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/split.simd.hpp b/upstream/opencv/modules/core/src/split.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/split.simd.hpp
rename to upstream/opencv/modules/core/src/split.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/stat.dispatch.cpp b/upstream/opencv/modules/core/src/stat.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/stat.dispatch.cpp
rename to upstream/opencv/modules/core/src/stat.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/stat.hpp b/upstream/opencv/modules/core/src/stat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/stat.hpp
rename to upstream/opencv/modules/core/src/stat.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/stat.simd.hpp b/upstream/opencv/modules/core/src/stat.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/stat.simd.hpp
rename to upstream/opencv/modules/core/src/stat.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/stl.cpp b/upstream/opencv/modules/core/src/stl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/stl.cpp
rename to upstream/opencv/modules/core/src/stl.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/sum.dispatch.cpp b/upstream/opencv/modules/core/src/sum.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/sum.dispatch.cpp
rename to upstream/opencv/modules/core/src/sum.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/sum.simd.hpp b/upstream/opencv/modules/core/src/sum.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/sum.simd.hpp
rename to upstream/opencv/modules/core/src/sum.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/system.cpp b/upstream/opencv/modules/core/src/system.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/system.cpp
rename to upstream/opencv/modules/core/src/system.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/tables.cpp b/upstream/opencv/modules/core/src/tables.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/tables.cpp
rename to upstream/opencv/modules/core/src/tables.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/trace.cpp b/upstream/opencv/modules/core/src/trace.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/trace.cpp
rename to upstream/opencv/modules/core/src/trace.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/transpose.simd.hpp b/upstream/opencv/modules/core/src/transpose.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/transpose.simd.hpp
rename to upstream/opencv/modules/core/src/transpose.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/types.cpp b/upstream/opencv/modules/core/src/types.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/types.cpp
rename to upstream/opencv/modules/core/src/types.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/umatrix.cpp b/upstream/opencv/modules/core/src/umatrix.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/umatrix.cpp
rename to upstream/opencv/modules/core/src/umatrix.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/umatrix.hpp b/upstream/opencv/modules/core/src/umatrix.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/umatrix.hpp
rename to upstream/opencv/modules/core/src/umatrix.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/datafile.cpp b/upstream/opencv/modules/core/src/utils/datafile.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/datafile.cpp
rename to upstream/opencv/modules/core/src/utils/datafile.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/filesystem.cpp b/upstream/opencv/modules/core/src/utils/filesystem.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/filesystem.cpp
rename to upstream/opencv/modules/core/src/utils/filesystem.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/logtagconfig.hpp b/upstream/opencv/modules/core/src/utils/logtagconfig.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/logtagconfig.hpp
rename to upstream/opencv/modules/core/src/utils/logtagconfig.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/logtagconfigparser.cpp b/upstream/opencv/modules/core/src/utils/logtagconfigparser.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/logtagconfigparser.cpp
rename to upstream/opencv/modules/core/src/utils/logtagconfigparser.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/logtagconfigparser.hpp b/upstream/opencv/modules/core/src/utils/logtagconfigparser.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/logtagconfigparser.hpp
rename to upstream/opencv/modules/core/src/utils/logtagconfigparser.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/logtagmanager.cpp b/upstream/opencv/modules/core/src/utils/logtagmanager.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/logtagmanager.cpp
rename to upstream/opencv/modules/core/src/utils/logtagmanager.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/logtagmanager.hpp b/upstream/opencv/modules/core/src/utils/logtagmanager.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/logtagmanager.hpp
rename to upstream/opencv/modules/core/src/utils/logtagmanager.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/plugin_loader.impl.hpp b/upstream/opencv/modules/core/src/utils/plugin_loader.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/plugin_loader.impl.hpp
rename to upstream/opencv/modules/core/src/utils/plugin_loader.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/utils/samples.cpp b/upstream/opencv/modules/core/src/utils/samples.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/utils/samples.cpp
rename to upstream/opencv/modules/core/src/utils/samples.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/va_intel.cpp b/upstream/opencv/modules/core/src/va_intel.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/va_intel.cpp
rename to upstream/opencv/modules/core/src/va_intel.cpp
diff --git a/third_party/opencv-5.0.0/modules/core/src/va_wrapper.impl.hpp b/upstream/opencv/modules/core/src/va_wrapper.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/core/src/va_wrapper.impl.hpp
rename to upstream/opencv/modules/core/src/va_wrapper.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/CMakeLists.txt b/upstream/opencv/modules/dnn/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/CMakeLists.txt
rename to upstream/opencv/modules/dnn/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/dnn/cmake/hooks/INIT_MODULE_SOURCES_opencv_dnn.cmake b/upstream/opencv/modules/dnn/cmake/hooks/INIT_MODULE_SOURCES_opencv_dnn.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/cmake/hooks/INIT_MODULE_SOURCES_opencv_dnn.cmake
rename to upstream/opencv/modules/dnn/cmake/hooks/INIT_MODULE_SOURCES_opencv_dnn.cmake
diff --git a/third_party/opencv-5.0.0/modules/dnn/cmake/init.cmake b/upstream/opencv/modules/dnn/cmake/init.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/cmake/init.cmake
rename to upstream/opencv/modules/dnn/cmake/init.cmake
diff --git a/third_party/opencv-5.0.0/modules/dnn/cmake/plugin.cmake b/upstream/opencv/modules/dnn/cmake/plugin.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/cmake/plugin.cmake
rename to upstream/opencv/modules/dnn/cmake/plugin.cmake
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/all_layers.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/all_layers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/all_layers.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/all_layers.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dict.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/dict.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dict.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/dict.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dnn.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dnn.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dnn.inl.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/dnn.inl.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/dnn.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer.details.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/layer.details.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer.details.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/layer.details.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/layer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/layer.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer_reg.private.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/layer_reg.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/layer_reg.private.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/layer_reg.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/shape_utils.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/shape_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/shape_utils.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/shape_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/utils/debug_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/utils/inference_engine.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/utils/inference_engine.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/utils/inference_engine.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/utils/inference_engine.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/version.hpp b/upstream/opencv/modules/dnn/include/opencv2/dnn/version.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/include/opencv2/dnn/version.hpp
rename to upstream/opencv/modules/dnn/include/opencv2/dnn/version.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.cc b/upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.cc
rename to upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.h b/upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/caffe/opencv-caffe.pb.h
rename to upstream/opencv/modules/dnn/misc/caffe/opencv-caffe.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/face_detector_accuracy.py b/upstream/opencv/modules/dnn/misc/face_detector_accuracy.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/face_detector_accuracy.py
rename to upstream/opencv/modules/dnn/misc/face_detector_accuracy.py
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.cc b/upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.cc
rename to upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.h b/upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/onnx/opencv-onnx.pb.h
rename to upstream/opencv/modules/dnn/misc/onnx/opencv-onnx.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/plugin/openvino/CMakeLists.txt b/upstream/opencv/modules/dnn/misc/plugin/openvino/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/plugin/openvino/CMakeLists.txt
rename to upstream/opencv/modules/dnn/misc/plugin/openvino/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/quantize_face_detector.py b/upstream/opencv/modules/dnn/misc/quantize_face_detector.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/quantize_face_detector.py
rename to upstream/opencv/modules/dnn/misc/quantize_face_detector.py
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/attr_value.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/attr_value.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/attr_value.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/attr_value.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/attr_value.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/attr_value.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/attr_value.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/attr_value.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/function.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/function.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/function.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/function.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/function.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/function.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/function.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/function.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/graph.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/graph.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/graph.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/graph.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/graph.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/graph.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/graph.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/graph.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/op_def.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/op_def.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/op_def.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/op_def.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/op_def.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/op_def.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/op_def.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/op_def.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/tensor.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/tensor.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/tensor.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/tensor.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor_shape.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/tensor_shape.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor_shape.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/tensor_shape.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor_shape.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/tensor_shape.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/tensor_shape.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/tensor_shape.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/types.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/types.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/types.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/types.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/types.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/types.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/types.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/types.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/versions.pb.cc b/upstream/opencv/modules/dnn/misc/tensorflow/versions.pb.cc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/versions.pb.cc
rename to upstream/opencv/modules/dnn/misc/tensorflow/versions.pb.cc
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/versions.pb.h b/upstream/opencv/modules/dnn/misc/tensorflow/versions.pb.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tensorflow/versions.pb.h
rename to upstream/opencv/modules/dnn/misc/tensorflow/versions.pb.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/misc/tflite/schema_generated.h b/upstream/opencv/modules/dnn/misc/tflite/schema_generated.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/misc/tflite/schema_generated.h
rename to upstream/opencv/modules/dnn/misc/tflite/schema_generated.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/backend.cpp b/upstream/opencv/modules/dnn/src/backend.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/backend.cpp
rename to upstream/opencv/modules/dnn/src/backend.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/backend.hpp b/upstream/opencv/modules/dnn/src/backend.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/backend.hpp
rename to upstream/opencv/modules/dnn/src/backend.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.cpp b/upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.cpp
rename to upstream/opencv/modules/dnn/src/caffe/caffe_io.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.hpp b/upstream/opencv/modules/dnn/src/caffe/caffe_io.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/caffe/caffe_io.hpp
rename to upstream/opencv/modules/dnn/src/caffe/caffe_io.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/caffe/glog_emulator.hpp b/upstream/opencv/modules/dnn/src/caffe/glog_emulator.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/caffe/glog_emulator.hpp
rename to upstream/opencv/modules/dnn/src/caffe/glog_emulator.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/activation_eltwise.cu b/upstream/opencv/modules/dnn/src/cuda/activation_eltwise.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/activation_eltwise.cu
rename to upstream/opencv/modules/dnn/src/cuda/activation_eltwise.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/activations.cu b/upstream/opencv/modules/dnn/src/cuda/activations.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/activations.cu
rename to upstream/opencv/modules/dnn/src/cuda/activations.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/array.hpp b/upstream/opencv/modules/dnn/src/cuda/array.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/array.hpp
rename to upstream/opencv/modules/dnn/src/cuda/array.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/atomics.hpp b/upstream/opencv/modules/dnn/src/cuda/atomics.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/atomics.hpp
rename to upstream/opencv/modules/dnn/src/cuda/atomics.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/bbox_utils.hpp b/upstream/opencv/modules/dnn/src/cuda/bbox_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/bbox_utils.hpp
rename to upstream/opencv/modules/dnn/src/cuda/bbox_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_activation.cu b/upstream/opencv/modules/dnn/src/cuda/bias_activation.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_activation.cu
rename to upstream/opencv/modules/dnn/src/cuda/bias_activation.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_activation_eltwise.cu b/upstream/opencv/modules/dnn/src/cuda/bias_activation_eltwise.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_activation_eltwise.cu
rename to upstream/opencv/modules/dnn/src/cuda/bias_activation_eltwise.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_eltwise_activation.cu b/upstream/opencv/modules/dnn/src/cuda/bias_eltwise_activation.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/bias_eltwise_activation.cu
rename to upstream/opencv/modules/dnn/src/cuda/bias_eltwise_activation.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/block_stride_range.hpp b/upstream/opencv/modules/dnn/src/cuda/block_stride_range.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/block_stride_range.hpp
rename to upstream/opencv/modules/dnn/src/cuda/block_stride_range.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/concat.cu b/upstream/opencv/modules/dnn/src/cuda/concat.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/concat.cu
rename to upstream/opencv/modules/dnn/src/cuda/concat.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/crop_and_resize.cu b/upstream/opencv/modules/dnn/src/cuda/crop_and_resize.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/crop_and_resize.cu
rename to upstream/opencv/modules/dnn/src/cuda/crop_and_resize.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/detection_output.cu b/upstream/opencv/modules/dnn/src/cuda/detection_output.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/detection_output.cu
rename to upstream/opencv/modules/dnn/src/cuda/detection_output.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/eltwise_activation.cu b/upstream/opencv/modules/dnn/src/cuda/eltwise_activation.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/eltwise_activation.cu
rename to upstream/opencv/modules/dnn/src/cuda/eltwise_activation.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/eltwise_ops.cu b/upstream/opencv/modules/dnn/src/cuda/eltwise_ops.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/eltwise_ops.cu
rename to upstream/opencv/modules/dnn/src/cuda/eltwise_ops.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/execution.hpp b/upstream/opencv/modules/dnn/src/cuda/execution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/execution.hpp
rename to upstream/opencv/modules/dnn/src/cuda/execution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/fill_copy.cu b/upstream/opencv/modules/dnn/src/cuda/fill_copy.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/fill_copy.cu
rename to upstream/opencv/modules/dnn/src/cuda/fill_copy.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/fp_conversion.cu b/upstream/opencv/modules/dnn/src/cuda/fp_conversion.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/fp_conversion.cu
rename to upstream/opencv/modules/dnn/src/cuda/fp_conversion.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/functors.hpp b/upstream/opencv/modules/dnn/src/cuda/functors.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/functors.hpp
rename to upstream/opencv/modules/dnn/src/cuda/functors.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/grid_nms.cu b/upstream/opencv/modules/dnn/src/cuda/grid_nms.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/grid_nms.cu
rename to upstream/opencv/modules/dnn/src/cuda/grid_nms.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/grid_stride_range.hpp b/upstream/opencv/modules/dnn/src/cuda/grid_stride_range.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/grid_stride_range.hpp
rename to upstream/opencv/modules/dnn/src/cuda/grid_stride_range.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/index_helpers.hpp b/upstream/opencv/modules/dnn/src/cuda/index_helpers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/index_helpers.hpp
rename to upstream/opencv/modules/dnn/src/cuda/index_helpers.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/kernel_dispatcher.hpp b/upstream/opencv/modules/dnn/src/cuda/kernel_dispatcher.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/kernel_dispatcher.hpp
rename to upstream/opencv/modules/dnn/src/cuda/kernel_dispatcher.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/limits.hpp b/upstream/opencv/modules/dnn/src/cuda/limits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/limits.hpp
rename to upstream/opencv/modules/dnn/src/cuda/limits.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/math.hpp b/upstream/opencv/modules/dnn/src/cuda/math.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/math.hpp
rename to upstream/opencv/modules/dnn/src/cuda/math.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/max_unpooling.cu b/upstream/opencv/modules/dnn/src/cuda/max_unpooling.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/max_unpooling.cu
rename to upstream/opencv/modules/dnn/src/cuda/max_unpooling.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/memory.hpp b/upstream/opencv/modules/dnn/src/cuda/memory.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/memory.hpp
rename to upstream/opencv/modules/dnn/src/cuda/memory.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/mvn.cu b/upstream/opencv/modules/dnn/src/cuda/mvn.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/mvn.cu
rename to upstream/opencv/modules/dnn/src/cuda/mvn.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/normalize.cu b/upstream/opencv/modules/dnn/src/cuda/normalize.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/normalize.cu
rename to upstream/opencv/modules/dnn/src/cuda/normalize.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/padding.cu b/upstream/opencv/modules/dnn/src/cuda/padding.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/padding.cu
rename to upstream/opencv/modules/dnn/src/cuda/padding.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/permute.cu b/upstream/opencv/modules/dnn/src/cuda/permute.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/permute.cu
rename to upstream/opencv/modules/dnn/src/cuda/permute.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/prior_box.cu b/upstream/opencv/modules/dnn/src/cuda/prior_box.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/prior_box.cu
rename to upstream/opencv/modules/dnn/src/cuda/prior_box.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/region.cu b/upstream/opencv/modules/dnn/src/cuda/region.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/region.cu
rename to upstream/opencv/modules/dnn/src/cuda/region.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/resize.cu b/upstream/opencv/modules/dnn/src/cuda/resize.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/resize.cu
rename to upstream/opencv/modules/dnn/src/cuda/resize.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/roi_pooling.cu b/upstream/opencv/modules/dnn/src/cuda/roi_pooling.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/roi_pooling.cu
rename to upstream/opencv/modules/dnn/src/cuda/roi_pooling.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/scale_shift.cu b/upstream/opencv/modules/dnn/src/cuda/scale_shift.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/scale_shift.cu
rename to upstream/opencv/modules/dnn/src/cuda/scale_shift.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/shortcut.cu b/upstream/opencv/modules/dnn/src/cuda/shortcut.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/shortcut.cu
rename to upstream/opencv/modules/dnn/src/cuda/shortcut.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/slice.cu b/upstream/opencv/modules/dnn/src/cuda/slice.cu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/slice.cu
rename to upstream/opencv/modules/dnn/src/cuda/slice.cu
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/types.hpp b/upstream/opencv/modules/dnn/src/cuda/types.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/types.hpp
rename to upstream/opencv/modules/dnn/src/cuda/types.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda/vector_traits.hpp b/upstream/opencv/modules/dnn/src/cuda/vector_traits.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda/vector_traits.hpp
rename to upstream/opencv/modules/dnn/src/cuda/vector_traits.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cublas.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cublas.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cublas.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cublas.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/activation.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/activation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/activation.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/activation.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/convolution.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/convolution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/convolution.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/convolution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/cudnn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/cudnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/cudnn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/cudnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/lrn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/lrn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/lrn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/lrn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/pooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/pooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/pooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/pooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/recurrent.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/recurrent.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/recurrent.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/recurrent.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/softmax.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/softmax.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/softmax.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/softmax.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/transform.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transform.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/transform.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transform.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/transpose_convolution.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transpose_convolution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/cudnn/transpose_convolution.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/cudnn/transpose_convolution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/error.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/error.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/error.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/error.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/event.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/event.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/event.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/event.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/memory.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/memory.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/memory.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/memory.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/nvcc_defs.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/nvcc_defs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/nvcc_defs.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/nvcc_defs.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/pointer.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/pointer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/pointer.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/pointer.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/span.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/span.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/span.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/span.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/stream.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/stream.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/stream.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/stream.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/tensor.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/tensor.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/tensor_ops.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/workspace.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/csl/workspace.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/csl/workspace.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/csl/workspace.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/cxx_utils/is_iterator.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/is_iterator.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/cxx_utils/is_iterator.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/is_iterator.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/cxx_utils/resizable_static_array.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/resizable_static_array.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/cxx_utils/resizable_static_array.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/cxx_utils/resizable_static_array.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/init.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/init.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/init.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/init.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/activation_eltwise.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activation_eltwise.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/activation_eltwise.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activation_eltwise.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/activations.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activations.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/activations.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/activations.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_activation.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_activation.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_activation_eltwise.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation_eltwise.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_activation_eltwise.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_activation_eltwise.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_eltwise_activation.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_eltwise_activation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/bias_eltwise_activation.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/bias_eltwise_activation.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/concat.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/concat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/concat.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/concat.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/crop_and_resize.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/crop_and_resize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/crop_and_resize.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/crop_and_resize.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/detection_output.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/detection_output.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/detection_output.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/detection_output.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/eltwise_activation.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_activation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/eltwise_activation.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_activation.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/eltwise_ops.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_ops.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/eltwise_ops.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/eltwise_ops.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/fill_copy.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fill_copy.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/fill_copy.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fill_copy.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/fp_conversion.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fp_conversion.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/fp_conversion.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/fp_conversion.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/grid_nms.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/grid_nms.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/grid_nms.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/grid_nms.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/max_unpooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/max_unpooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/max_unpooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/max_unpooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/mvn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/mvn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/mvn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/mvn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/normalize.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/normalize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/normalize.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/normalize.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/padding.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/padding.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/padding.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/padding.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/permute.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/permute.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/permute.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/permute.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/prior_box.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/prior_box.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/prior_box.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/prior_box.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/region.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/region.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/region.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/region.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/resize.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/resize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/resize.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/resize.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/roi_pooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/roi_pooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/roi_pooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/roi_pooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/scale_shift.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/scale_shift.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/scale_shift.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/scale_shift.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/shortcut.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/shortcut.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/shortcut.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/shortcut.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/slice.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/kernels/slice.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/kernels/slice.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/kernels/slice.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/activation.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/activation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/activation.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/activation.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/batch_norm.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/batch_norm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/batch_norm.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/batch_norm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/concat.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/concat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/concat.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/concat.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/const.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/const.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/const.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/const.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/convolution.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/convolution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/convolution.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/convolution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/crop_and_resize.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/crop_and_resize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/crop_and_resize.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/crop_and_resize.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/depth_space_ops.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/detection_output.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/detection_output.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/detection_output.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/detection_output.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/eltwise.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/eltwise.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/eltwise.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/eltwise.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/group_norm.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/group_norm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/group_norm.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/group_norm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/inner_product.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/inner_product.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/inner_product.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/inner_product.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/instance_norm.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/instance_norm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/instance_norm.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/instance_norm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/layer_norm.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/layer_norm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/layer_norm.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/layer_norm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/lrn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/lrn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/lrn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/lrn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/matmul.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/matmul.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/matmul_broadcast.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul_broadcast.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/matmul_broadcast.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/matmul_broadcast.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/max_unpooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/max_unpooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/max_unpooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/max_unpooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/mvn.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/mvn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/mvn.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/mvn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/normalize_bbox.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/normalize_bbox.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/normalize_bbox.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/normalize_bbox.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/padding.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/padding.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/padding.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/padding.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/permute.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/permute.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/permute.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/permute.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/pooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/pooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/pooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/pooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/prior_box.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/prior_box.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/prior_box.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/prior_box.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/recurrent_cells.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/recurrent_cells.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/recurrent_cells.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/recurrent_cells.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/region.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/region.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/region.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/region.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/reorg.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reorg.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/reorg.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reorg.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/reshape.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reshape.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/reshape.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/reshape.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/resize.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/resize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/resize.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/resize.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/roi_pooling.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/roi_pooling.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/roi_pooling.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/roi_pooling.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/scale_shift.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/scale_shift.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/scale_shift.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/scale_shift.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/shortcut.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shortcut.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/shortcut.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shortcut.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/shuffle_channel.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shuffle_channel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/shuffle_channel.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/shuffle_channel.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/slice.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/slice.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/slice.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/slice.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/softmax.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/softmax.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/softmax.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/softmax.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/split.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/split.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/split.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/split.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/transpose_convolution.hpp b/upstream/opencv/modules/dnn/src/cuda4dnn/primitives/transpose_convolution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/cuda4dnn/primitives/transpose_convolution.hpp
rename to upstream/opencv/modules/dnn/src/cuda4dnn/primitives/transpose_convolution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/debug_utils.cpp b/upstream/opencv/modules/dnn/src/debug_utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/debug_utils.cpp
rename to upstream/opencv/modules/dnn/src/debug_utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/dnn.cpp b/upstream/opencv/modules/dnn/src/dnn.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/dnn.cpp
rename to upstream/opencv/modules/dnn/src/dnn.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/dnn_common.hpp b/upstream/opencv/modules/dnn/src/dnn_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/dnn_common.hpp
rename to upstream/opencv/modules/dnn/src/dnn_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/dnn_params.cpp b/upstream/opencv/modules/dnn/src/dnn_params.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/dnn_params.cpp
rename to upstream/opencv/modules/dnn/src/dnn_params.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/dnn_read.cpp b/upstream/opencv/modules/dnn/src/dnn_read.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/dnn_read.cpp
rename to upstream/opencv/modules/dnn/src/dnn_read.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/dnn_utils.cpp b/upstream/opencv/modules/dnn/src/dnn_utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/dnn_utils.cpp
rename to upstream/opencv/modules/dnn/src/dnn_utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/factory.hpp b/upstream/opencv/modules/dnn/src/factory.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/factory.hpp
rename to upstream/opencv/modules/dnn/src/factory.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_block_layout.cpp b/upstream/opencv/modules/dnn/src/graph_block_layout.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_block_layout.cpp
rename to upstream/opencv/modules/dnn/src/graph_block_layout.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_buffer_allocator.cpp b/upstream/opencv/modules/dnn/src/graph_buffer_allocator.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_buffer_allocator.cpp
rename to upstream/opencv/modules/dnn/src/graph_buffer_allocator.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_const_args.cpp b/upstream/opencv/modules/dnn/src/graph_const_args.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_const_args.cpp
rename to upstream/opencv/modules/dnn/src/graph_const_args.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_const_fold.cpp b/upstream/opencv/modules/dnn/src/graph_const_fold.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_const_fold.cpp
rename to upstream/opencv/modules/dnn/src/graph_const_fold.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_attention.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_attention.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_attention.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_attention.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_basic.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_basic.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_basic.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_basic.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_matmul_to_gemm.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_matmul_to_gemm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_matmul_to_gemm.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_matmul_to_gemm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_qdq.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_qdq.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_qdq.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_qdq.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_reshape_transpose.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_reshape_transpose.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_reshape_transpose.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_reshape_transpose.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_scale_softmax.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_scale_softmax.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_scale_softmax.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_scale_softmax.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_shared_gemm.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_shared_gemm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_shared_gemm.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_shared_gemm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_transpose_matmul.cpp b/upstream/opencv/modules/dnn/src/graph_fusion_transpose_matmul.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_fusion_transpose_matmul.cpp
rename to upstream/opencv/modules/dnn/src/graph_fusion_transpose_matmul.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_simplifier.cpp b/upstream/opencv/modules/dnn/src/graph_simplifier.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_simplifier.cpp
rename to upstream/opencv/modules/dnn/src/graph_simplifier.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/graph_simplifier.hpp b/upstream/opencv/modules/dnn/src/graph_simplifier.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/graph_simplifier.hpp
rename to upstream/opencv/modules/dnn/src/graph_simplifier.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ie_ngraph.cpp b/upstream/opencv/modules/dnn/src/ie_ngraph.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ie_ngraph.cpp
rename to upstream/opencv/modules/dnn/src/ie_ngraph.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ie_ngraph.hpp b/upstream/opencv/modules/dnn/src/ie_ngraph.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ie_ngraph.hpp
rename to upstream/opencv/modules/dnn/src/ie_ngraph.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/init.cpp b/upstream/opencv/modules/dnn/src/init.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/init.cpp
rename to upstream/opencv/modules/dnn/src/init.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/batch_norm_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/batch_norm_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/batch_norm_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/batch_norm_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/conv2_int8_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/int8layers/conv2_int8_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/conv2_int8_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/int8layers/conv2_int8_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/conv2_int8_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/conv2_int8_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/conv2_int8_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/conv2_int8_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/convolution_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/convolution_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/convolution_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/convolution_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/elementwise_layers.cpp b/upstream/opencv/modules/dnn/src/int8layers/elementwise_layers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/elementwise_layers.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/elementwise_layers.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/eltwise2_int8_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/eltwise2_int8_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/eltwise2_int8_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/eltwise2_int8_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/eltwise_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/eltwise_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/eltwise_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/eltwise_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/fully_connected_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/fully_connected_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/fully_connected_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/fully_connected_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_common.hpp b/upstream/opencv/modules/dnn/src/int8layers/layers_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_common.hpp
rename to upstream/opencv/modules/dnn/src/int8layers/layers_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_common.simd.hpp b/upstream/opencv/modules/dnn/src/int8layers/layers_common.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_common.simd.hpp
rename to upstream/opencv/modules/dnn/src/int8layers/layers_common.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_rvp052.cpp b/upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_rvp052.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_rvp052.hpp b/upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/layers_rvp052.hpp
rename to upstream/opencv/modules/dnn/src/int8layers/layers_rvp052.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/matmul_int8_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/matmul_int8_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/matmul_int8_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/matmul_int8_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/pool2_int8_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/pool2_int8_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/pool2_int8_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/pool2_int8_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/pooling_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/pooling_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/pooling_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/pooling_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/quantization_utils.cpp b/upstream/opencv/modules/dnn/src/int8layers/quantization_utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/quantization_utils.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/quantization_utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/scale_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/scale_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/scale_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/scale_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/int8layers/softmax_layer.cpp b/upstream/opencv/modules/dnn/src/int8layers/softmax_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/int8layers/softmax_layer.cpp
rename to upstream/opencv/modules/dnn/src/int8layers/softmax_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/kv_cache_manager.cpp b/upstream/opencv/modules/dnn/src/kv_cache_manager.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/kv_cache_manager.cpp
rename to upstream/opencv/modules/dnn/src/kv_cache_manager.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/kv_cache_manager.hpp b/upstream/opencv/modules/dnn/src/kv_cache_manager.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/kv_cache_manager.hpp
rename to upstream/opencv/modules/dnn/src/kv_cache_manager.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layer.cpp b/upstream/opencv/modules/dnn/src/layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layer.cpp
rename to upstream/opencv/modules/dnn/src/layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layer_factory.cpp b/upstream/opencv/modules/dnn/src/layer_factory.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layer_factory.cpp
rename to upstream/opencv/modules/dnn/src/layer_factory.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layer_internals.hpp b/upstream/opencv/modules/dnn/src/layer_internals.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layer_internals.hpp
rename to upstream/opencv/modules/dnn/src/layer_internals.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/accum_layer.cpp b/upstream/opencv/modules/dnn/src/layers/accum_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/accum_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/accum_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/affinegrid_layer.cpp b/upstream/opencv/modules/dnn/src/layers/affinegrid_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/affinegrid_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/affinegrid_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/arg_layer.cpp b/upstream/opencv/modules/dnn/src/layers/arg_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/arg_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/arg_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/attention_layer.cpp b/upstream/opencv/modules/dnn/src/layers/attention_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/attention_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/attention_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/attention_onnxai_layer.cpp b/upstream/opencv/modules/dnn/src/layers/attention_onnxai_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/attention_onnxai_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/attention_onnxai_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/avgpool_layer.cpp b/upstream/opencv/modules/dnn/src/layers/avgpool_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/avgpool_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/avgpool_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/batch_norm2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/batch_norm2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/batch_norm2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/batch_norm2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/batch_norm_layer.cpp b/upstream/opencv/modules/dnn/src/layers/batch_norm_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/batch_norm_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/batch_norm_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/bitshift_layer.cpp b/upstream/opencv/modules/dnn/src/layers/bitshift_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/bitshift_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/bitshift_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/blank_layer.cpp b/upstream/opencv/modules/dnn/src/layers/blank_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/blank_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/blank_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cast2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/cast2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cast2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/cast2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cast_layer.cpp b/upstream/opencv/modules/dnn/src/layers/cast_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cast_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/cast_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/centercroppad_layer.cpp b/upstream/opencv/modules/dnn/src/layers/centercroppad_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/centercroppad_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/centercroppad_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/clip_layer.cpp b/upstream/opencv/modules/dnn/src/layers/clip_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/clip_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/clip_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/concat2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/concat2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/concat2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/concat2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/concat_layer.cpp b/upstream/opencv/modules/dnn/src/layers/concat_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/concat_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/concat_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/const_layer.cpp b/upstream/opencv/modules/dnn/src/layers/const_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/const_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/const_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/constantofshape_layer.cpp b/upstream/opencv/modules/dnn/src/layers/constantofshape_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/constantofshape_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/constantofshape_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_common.cpp b/upstream/opencv/modules/dnn/src/layers/conv2_common.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_common.cpp
rename to upstream/opencv/modules/dnn/src/layers/conv2_common.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_common.hpp b/upstream/opencv/modules/dnn/src/layers/conv2_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_common.hpp
rename to upstream/opencv/modules/dnn/src/layers/conv2_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/conv2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/conv2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/conv2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/convolution_layer.cpp b/upstream/opencv/modules/dnn/src/layers/convolution_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/convolution_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/convolution_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/convtranspose_layer.cpp b/upstream/opencv/modules/dnn/src/layers/convtranspose_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/convtranspose_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/convtranspose_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/correlation_layer.cpp b/upstream/opencv/modules/dnn/src/layers/correlation_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/correlation_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/correlation_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/activation_kernels.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/activation_kernels.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/activation_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/activation_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/activation_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_deconv.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_deconv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_deconv.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_deconv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_depthwise.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_kernels.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_kernels.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv2_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv2_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_block.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_depthwise.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.dispatch.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.dispatch.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/conv_winograd_f63.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/convolution.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/convolution.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/convolution.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/convolution.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/convolution.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_attn.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_attn.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_attn.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_attn.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_attn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.default.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_gemm_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_norm.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_norm.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_norm.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/fast_norm.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/fast_norm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/gridsample_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/gridsample_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/gridsample_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/gridsample_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_gemm.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_gemm.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_gemm.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_gemm.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_gemm.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_threading.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_threading.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/mlas_threading.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/mlas_threading.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/nary_eltwise_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/nary_eltwise_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/nary_eltwise_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/nary_eltwise_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/reduce2_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/reduce2_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/reduce2_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/reduce2_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/softmax.cpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/softmax.cpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/softmax.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/softmax.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/softmax.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/transpose_kernels.simd.hpp b/upstream/opencv/modules/dnn/src/layers/cpu_kernels/transpose_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cpu_kernels/transpose_kernels.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/cpu_kernels/transpose_kernels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/crop_and_resize_layer.cpp b/upstream/opencv/modules/dnn/src/layers/crop_and_resize_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/crop_and_resize_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/crop_and_resize_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/cumsum_layer.cpp b/upstream/opencv/modules/dnn/src/layers/cumsum_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/cumsum_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/cumsum_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/deconvolution_layer.cpp b/upstream/opencv/modules/dnn/src/layers/deconvolution_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/deconvolution_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/deconvolution_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/depth_space_ops_layer.cpp b/upstream/opencv/modules/dnn/src/layers/depth_space_ops_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/depth_space_ops_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/depth_space_ops_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/dequantizelinear_layer.cpp b/upstream/opencv/modules/dnn/src/layers/dequantizelinear_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/dequantizelinear_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/dequantizelinear_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/det_layer.cpp b/upstream/opencv/modules/dnn/src/layers/det_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/det_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/det_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/detection_output_layer.cpp b/upstream/opencv/modules/dnn/src/layers/detection_output_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/detection_output_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/detection_output_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/dft_layer.cpp b/upstream/opencv/modules/dnn/src/layers/dft_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/dft_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/dft_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/einsum_layer.cpp b/upstream/opencv/modules/dnn/src/layers/einsum_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/einsum_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/einsum_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/elementwise_layers.cpp b/upstream/opencv/modules/dnn/src/layers/elementwise_layers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/elementwise_layers.cpp
rename to upstream/opencv/modules/dnn/src/layers/elementwise_layers.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/eltwise_layer.cpp b/upstream/opencv/modules/dnn/src/layers/eltwise_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/eltwise_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/eltwise_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/expand2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/expand2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/expand2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/expand2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/expand_layer.cpp b/upstream/opencv/modules/dnn/src/layers/expand_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/expand_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/expand_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/eyelike_layer.cpp b/upstream/opencv/modules/dnn/src/layers/eyelike_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/eyelike_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/eyelike_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/flatten_layer.cpp b/upstream/opencv/modules/dnn/src/layers/flatten_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/flatten_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/flatten_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/flow_warp_layer.cpp b/upstream/opencv/modules/dnn/src/layers/flow_warp_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/flow_warp_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/flow_warp_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/fully_connected_layer.cpp b/upstream/opencv/modules/dnn/src/layers/fully_connected_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/fully_connected_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/fully_connected_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gather2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gather2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gather2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gather2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gatherND.cpp b/upstream/opencv/modules/dnn/src/layers/gatherND.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gatherND.cpp
rename to upstream/opencv/modules/dnn/src/layers/gatherND.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gather_elements_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gather_elements_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gather_elements_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gather_elements_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gather_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gather_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gather_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gather_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gemm_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gemm_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gemm_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gemm_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gridsample_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gridsample_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gridsample_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gridsample_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/group_norm_layer.cpp b/upstream/opencv/modules/dnn/src/layers/group_norm_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/group_norm_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/group_norm_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/gru_layer.cpp b/upstream/opencv/modules/dnn/src/layers/gru_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/gru_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/gru_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/hardmax.cpp b/upstream/opencv/modules/dnn/src/layers/hardmax.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/hardmax.cpp
rename to upstream/opencv/modules/dnn/src/layers/hardmax.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/if_layer.cpp b/upstream/opencv/modules/dnn/src/layers/if_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/if_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/if_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/instance_norm_layer.cpp b/upstream/opencv/modules/dnn/src/layers/instance_norm_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/instance_norm_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/instance_norm_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/is_inf_layer.cpp b/upstream/opencv/modules/dnn/src/layers/is_inf_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/is_inf_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/is_inf_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/is_nan_layer.cpp b/upstream/opencv/modules/dnn/src/layers/is_nan_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/is_nan_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/is_nan_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/layer_norm.cpp b/upstream/opencv/modules/dnn/src/layers/layer_norm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/layer_norm.cpp
rename to upstream/opencv/modules/dnn/src/layers/layer_norm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/layer_norm2.cpp b/upstream/opencv/modules/dnn/src/layers/layer_norm2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/layer_norm2.cpp
rename to upstream/opencv/modules/dnn/src/layers/layer_norm2.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.cpp b/upstream/opencv/modules/dnn/src/layers/layers_common.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.cpp
rename to upstream/opencv/modules/dnn/src/layers/layers_common.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.hpp b/upstream/opencv/modules/dnn/src/layers/layers_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.hpp
rename to upstream/opencv/modules/dnn/src/layers/layers_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.simd.hpp b/upstream/opencv/modules/dnn/src/layers/layers_common.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/layers_common.simd.hpp
rename to upstream/opencv/modules/dnn/src/layers/layers_common.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/loop_layer.cpp b/upstream/opencv/modules/dnn/src/layers/loop_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/loop_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/loop_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/lrn_layer.cpp b/upstream/opencv/modules/dnn/src/layers/lrn_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/lrn_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/lrn_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/matmul_layer.cpp b/upstream/opencv/modules/dnn/src/layers/matmul_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/matmul_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/matmul_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/max_unpooling_layer.cpp b/upstream/opencv/modules/dnn/src/layers/max_unpooling_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/max_unpooling_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/max_unpooling_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/maxpool_layer.cpp b/upstream/opencv/modules/dnn/src/layers/maxpool_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/maxpool_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/maxpool_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/mvn_layer.cpp b/upstream/opencv/modules/dnn/src/layers/mvn_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/mvn_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/mvn_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/nary_eltwise_layers.cpp b/upstream/opencv/modules/dnn/src/layers/nary_eltwise_layers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/nary_eltwise_layers.cpp
rename to upstream/opencv/modules/dnn/src/layers/nary_eltwise_layers.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/nll_loss_layer.cpp b/upstream/opencv/modules/dnn/src/layers/nll_loss_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/nll_loss_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/nll_loss_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/nonmaxsuppression_layer.cpp b/upstream/opencv/modules/dnn/src/layers/nonmaxsuppression_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/nonmaxsuppression_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/nonmaxsuppression_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/nonzero_layer.cpp b/upstream/opencv/modules/dnn/src/layers/nonzero_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/nonzero_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/nonzero_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/normalize_bbox_layer.cpp b/upstream/opencv/modules/dnn/src/layers/normalize_bbox_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/normalize_bbox_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/normalize_bbox_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/not_implemented_layer.cpp b/upstream/opencv/modules/dnn/src/layers/not_implemented_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/not_implemented_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/not_implemented_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/not_layer.cpp b/upstream/opencv/modules/dnn/src/layers/not_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/not_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/not_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/onehot_layer.cpp b/upstream/opencv/modules/dnn/src/layers/onehot_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/onehot_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/onehot_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/pad2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/pad2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/pad2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/pad2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/padding_layer.cpp b/upstream/opencv/modules/dnn/src/layers/padding_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/padding_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/padding_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/permute_layer.cpp b/upstream/opencv/modules/dnn/src/layers/permute_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/permute_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/permute_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/pooling_layer.cpp b/upstream/opencv/modules/dnn/src/layers/pooling_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/pooling_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/pooling_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/prior_box_layer.cpp b/upstream/opencv/modules/dnn/src/layers/prior_box_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/prior_box_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/prior_box_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/proposal_layer.cpp b/upstream/opencv/modules/dnn/src/layers/proposal_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/proposal_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/proposal_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/quantlizelinear_layer.cpp b/upstream/opencv/modules/dnn/src/layers/quantlizelinear_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/quantlizelinear_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/quantlizelinear_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/randomnormallike_layer.cpp b/upstream/opencv/modules/dnn/src/layers/randomnormallike_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/randomnormallike_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/randomnormallike_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/range_layer.cpp b/upstream/opencv/modules/dnn/src/layers/range_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/range_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/range_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/recurrent2_layers.cpp b/upstream/opencv/modules/dnn/src/layers/recurrent2_layers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/recurrent2_layers.cpp
rename to upstream/opencv/modules/dnn/src/layers/recurrent2_layers.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/recurrent_layers.cpp b/upstream/opencv/modules/dnn/src/layers/recurrent_layers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/recurrent_layers.cpp
rename to upstream/opencv/modules/dnn/src/layers/recurrent_layers.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/reduce2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/reduce2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/reduce2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/reduce2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/reduce_layer.cpp b/upstream/opencv/modules/dnn/src/layers/reduce_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/reduce_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/reduce_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/region_layer.cpp b/upstream/opencv/modules/dnn/src/layers/region_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/region_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/region_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/reorg_layer.cpp b/upstream/opencv/modules/dnn/src/layers/reorg_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/reorg_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/reorg_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/reshape2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/reshape2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/reshape2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/reshape2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/reshape_layer.cpp b/upstream/opencv/modules/dnn/src/layers/reshape_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/reshape_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/reshape_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/resize2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/resize2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/resize2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/resize2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/resize_layer.cpp b/upstream/opencv/modules/dnn/src/layers/resize_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/resize_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/resize_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/rms_norm.cpp b/upstream/opencv/modules/dnn/src/layers/rms_norm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/rms_norm.cpp
rename to upstream/opencv/modules/dnn/src/layers/rms_norm.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/roialign_layer.cpp b/upstream/opencv/modules/dnn/src/layers/roialign_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/roialign_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/roialign_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/rotary_embedding_layer.cpp b/upstream/opencv/modules/dnn/src/layers/rotary_embedding_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/rotary_embedding_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/rotary_embedding_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/scale_layer.cpp b/upstream/opencv/modules/dnn/src/layers/scale_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/scale_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/scale_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/scatterND_layer.cpp b/upstream/opencv/modules/dnn/src/layers/scatterND_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/scatterND_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/scatterND_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/scatter_layer.cpp b/upstream/opencv/modules/dnn/src/layers/scatter_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/scatter_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/scatter_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/sdpa_layer.cpp b/upstream/opencv/modules/dnn/src/layers/sdpa_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/sdpa_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/sdpa_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/shape_layer.cpp b/upstream/opencv/modules/dnn/src/layers/shape_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/shape_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/shape_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/shuffle_channel_layer.cpp b/upstream/opencv/modules/dnn/src/layers/shuffle_channel_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/shuffle_channel_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/shuffle_channel_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/size_layer.cpp b/upstream/opencv/modules/dnn/src/layers/size_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/size_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/size_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/slice2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/slice2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/slice2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/slice2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/slice_layer.cpp b/upstream/opencv/modules/dnn/src/layers/slice_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/slice_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/slice_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/softmax_cross_entropy_loss_layer.cpp b/upstream/opencv/modules/dnn/src/layers/softmax_cross_entropy_loss_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/softmax_cross_entropy_loss_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/softmax_cross_entropy_loss_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/softmax_layer.cpp b/upstream/opencv/modules/dnn/src/layers/softmax_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/softmax_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/softmax_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/split2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/split2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/split2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/split2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/split_layer.cpp b/upstream/opencv/modules/dnn/src/layers/split_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/split_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/split_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/squeeze_layer.cpp b/upstream/opencv/modules/dnn/src/layers/squeeze_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/squeeze_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/squeeze_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/tile2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/tile2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/tile2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/tile2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/tile_layer.cpp b/upstream/opencv/modules/dnn/src/layers/tile_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/tile_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/tile_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/topk2_layer.cpp b/upstream/opencv/modules/dnn/src/layers/topk2_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/topk2_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/topk2_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/topk_layer.cpp b/upstream/opencv/modules/dnn/src/layers/topk_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/topk_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/topk_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/transform_layout_layer.cpp b/upstream/opencv/modules/dnn/src/layers/transform_layout_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/transform_layout_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/transform_layout_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/transpose_layer.cpp b/upstream/opencv/modules/dnn/src/layers/transpose_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/transpose_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/transpose_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/trilu_layer.cpp b/upstream/opencv/modules/dnn/src/layers/trilu_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/trilu_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/trilu_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/unique_layer.cpp b/upstream/opencv/modules/dnn/src/layers/unique_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/unique_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/unique_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/unsqueeze_layer.cpp b/upstream/opencv/modules/dnn/src/layers/unsqueeze_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/unsqueeze_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/unsqueeze_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/layers/windows_layer.cpp b/upstream/opencv/modules/dnn/src/layers/windows_layer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/layers/windows_layer.cpp
rename to upstream/opencv/modules/dnn/src/layers/windows_layer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/legacy_backend.cpp b/upstream/opencv/modules/dnn/src/legacy_backend.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/legacy_backend.cpp
rename to upstream/opencv/modules/dnn/src/legacy_backend.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/legacy_backend.hpp b/upstream/opencv/modules/dnn/src/legacy_backend.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/legacy_backend.hpp
rename to upstream/opencv/modules/dnn/src/legacy_backend.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/math_utils.hpp b/upstream/opencv/modules/dnn/src/math_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/math_utils.hpp
rename to upstream/opencv/modules/dnn/src/math_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/model.cpp b/upstream/opencv/modules/dnn/src/model.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/model.cpp
rename to upstream/opencv/modules/dnn/src/model.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net.cpp b/upstream/opencv/modules/dnn/src/net.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net.cpp
rename to upstream/opencv/modules/dnn/src/net.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_cann.cpp b/upstream/opencv/modules/dnn/src/net_cann.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_cann.cpp
rename to upstream/opencv/modules/dnn/src/net_cann.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_impl.cpp b/upstream/opencv/modules/dnn/src/net_impl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_impl.cpp
rename to upstream/opencv/modules/dnn/src/net_impl.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_impl.hpp b/upstream/opencv/modules/dnn/src/net_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_impl.hpp
rename to upstream/opencv/modules/dnn/src/net_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_impl2.cpp b/upstream/opencv/modules/dnn/src/net_impl2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_impl2.cpp
rename to upstream/opencv/modules/dnn/src/net_impl2.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_impl_backend.cpp b/upstream/opencv/modules/dnn/src/net_impl_backend.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_impl_backend.cpp
rename to upstream/opencv/modules/dnn/src/net_impl_backend.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_impl_fuse.cpp b/upstream/opencv/modules/dnn/src/net_impl_fuse.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_impl_fuse.cpp
rename to upstream/opencv/modules/dnn/src/net_impl_fuse.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/net_openvino.cpp b/upstream/opencv/modules/dnn/src/net_openvino.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/net_openvino.cpp
rename to upstream/opencv/modules/dnn/src/net_openvino.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/nms.cpp b/upstream/opencv/modules/dnn/src/nms.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/nms.cpp
rename to upstream/opencv/modules/dnn/src/nms.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/nms.inl.hpp b/upstream/opencv/modules/dnn/src/nms.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/nms.inl.hpp
rename to upstream/opencv/modules/dnn/src/nms.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/common.hpp b/upstream/opencv/modules/dnn/src/ocl4dnn/include/common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/common.hpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/include/common.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/default_kernel_config.hpp b/upstream/opencv/modules/dnn/src/ocl4dnn/include/default_kernel_config.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/default_kernel_config.hpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/include/default_kernel_config.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/math_functions.hpp b/upstream/opencv/modules/dnn/src/ocl4dnn/include/math_functions.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/math_functions.hpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/include/math_functions.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/ocl4dnn.hpp b/upstream/opencv/modules/dnn/src/ocl4dnn/include/ocl4dnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/include/ocl4dnn.hpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/include/ocl4dnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/common.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/common.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/common.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/common.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/math_functions.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/math_functions.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/math_functions.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/math_functions.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_conv_spatial.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_inner_product.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_inner_product.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_inner_product.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_inner_product.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_lrn.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_lrn.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_lrn.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_lrn.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_pool.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_pool.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_pool.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_pool.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_softmax.cpp b/upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_softmax.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/ocl4dnn/src/ocl4dnn_softmax.cpp
rename to upstream/opencv/modules/dnn/src/ocl4dnn/src/ocl4dnn_softmax.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_graph_simplifier.cpp b/upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_graph_simplifier.cpp
rename to upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_graph_simplifier.hpp b/upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_graph_simplifier.hpp
rename to upstream/opencv/modules/dnn/src/onnx/onnx_graph_simplifier.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_importer.cpp b/upstream/opencv/modules/dnn/src/onnx/onnx_importer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_importer.cpp
rename to upstream/opencv/modules/dnn/src/onnx/onnx_importer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_importer2.cpp b/upstream/opencv/modules/dnn/src/onnx/onnx_importer2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/onnx/onnx_importer2.cpp
rename to upstream/opencv/modules/dnn/src/onnx/onnx_importer2.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/onnx/opencv-onnx.proto b/upstream/opencv/modules/dnn/src/onnx/opencv-onnx.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/onnx/opencv-onnx.proto
rename to upstream/opencv/modules/dnn/src/onnx/opencv-onnx.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_cann.cpp b/upstream/opencv/modules/dnn/src/op_cann.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_cann.cpp
rename to upstream/opencv/modules/dnn/src/op_cann.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_cann.hpp b/upstream/opencv/modules/dnn/src/op_cann.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_cann.hpp
rename to upstream/opencv/modules/dnn/src/op_cann.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_cuda.cpp b/upstream/opencv/modules/dnn/src/op_cuda.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_cuda.cpp
rename to upstream/opencv/modules/dnn/src/op_cuda.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_cuda.hpp b/upstream/opencv/modules/dnn/src/op_cuda.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_cuda.hpp
rename to upstream/opencv/modules/dnn/src/op_cuda.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_inf_engine.cpp b/upstream/opencv/modules/dnn/src/op_inf_engine.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_inf_engine.cpp
rename to upstream/opencv/modules/dnn/src/op_inf_engine.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_inf_engine.hpp b/upstream/opencv/modules/dnn/src/op_inf_engine.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_inf_engine.hpp
rename to upstream/opencv/modules/dnn/src/op_inf_engine.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_timvx.cpp b/upstream/opencv/modules/dnn/src/op_timvx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_timvx.cpp
rename to upstream/opencv/modules/dnn/src/op_timvx.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_timvx.hpp b/upstream/opencv/modules/dnn/src/op_timvx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_timvx.hpp
rename to upstream/opencv/modules/dnn/src/op_timvx.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_vkcom.cpp b/upstream/opencv/modules/dnn/src/op_vkcom.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_vkcom.cpp
rename to upstream/opencv/modules/dnn/src/op_vkcom.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_vkcom.hpp b/upstream/opencv/modules/dnn/src/op_vkcom.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_vkcom.hpp
rename to upstream/opencv/modules/dnn/src/op_vkcom.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_webnn.cpp b/upstream/opencv/modules/dnn/src/op_webnn.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_webnn.cpp
rename to upstream/opencv/modules/dnn/src/op_webnn.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/op_webnn.hpp b/upstream/opencv/modules/dnn/src/op_webnn.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/op_webnn.hpp
rename to upstream/opencv/modules/dnn/src/op_webnn.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/activations.cl b/upstream/opencv/modules/dnn/src/opencl/activations.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/activations.cl
rename to upstream/opencv/modules/dnn/src/opencl/activations.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/batchnorm.cl b/upstream/opencv/modules/dnn/src/opencl/batchnorm.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/batchnorm.cl
rename to upstream/opencv/modules/dnn/src/opencl/batchnorm.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/col2im.cl b/upstream/opencv/modules/dnn/src/opencl/col2im.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/col2im.cl
rename to upstream/opencv/modules/dnn/src/opencl/col2im.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/concat.cl b/upstream/opencv/modules/dnn/src/opencl/concat.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/concat.cl
rename to upstream/opencv/modules/dnn/src/opencl/concat.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/conv_layer_spatial.cl b/upstream/opencv/modules/dnn/src/opencl/conv_layer_spatial.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/conv_layer_spatial.cl
rename to upstream/opencv/modules/dnn/src/opencl/conv_layer_spatial.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/conv_spatial_helper.cl b/upstream/opencv/modules/dnn/src/opencl/conv_spatial_helper.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/conv_spatial_helper.cl
rename to upstream/opencv/modules/dnn/src/opencl/conv_spatial_helper.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/detection_output.cl b/upstream/opencv/modules/dnn/src/opencl/detection_output.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/detection_output.cl
rename to upstream/opencv/modules/dnn/src/opencl/detection_output.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/dummy.cl b/upstream/opencv/modules/dnn/src/opencl/dummy.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/dummy.cl
rename to upstream/opencv/modules/dnn/src/opencl/dummy.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/eltwise.cl b/upstream/opencv/modules/dnn/src/opencl/eltwise.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/eltwise.cl
rename to upstream/opencv/modules/dnn/src/opencl/eltwise.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/gemm_buffer.cl b/upstream/opencv/modules/dnn/src/opencl/gemm_buffer.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/gemm_buffer.cl
rename to upstream/opencv/modules/dnn/src/opencl/gemm_buffer.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/gemm_image.cl b/upstream/opencv/modules/dnn/src/opencl/gemm_image.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/gemm_image.cl
rename to upstream/opencv/modules/dnn/src/opencl/gemm_image.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/im2col.cl b/upstream/opencv/modules/dnn/src/opencl/im2col.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/im2col.cl
rename to upstream/opencv/modules/dnn/src/opencl/im2col.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/lrn.cl b/upstream/opencv/modules/dnn/src/opencl/lrn.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/lrn.cl
rename to upstream/opencv/modules/dnn/src/opencl/lrn.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/math.cl b/upstream/opencv/modules/dnn/src/opencl/math.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/math.cl
rename to upstream/opencv/modules/dnn/src/opencl/math.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/matvec_mul.cl b/upstream/opencv/modules/dnn/src/opencl/matvec_mul.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/matvec_mul.cl
rename to upstream/opencv/modules/dnn/src/opencl/matvec_mul.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/mvn.cl b/upstream/opencv/modules/dnn/src/opencl/mvn.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/mvn.cl
rename to upstream/opencv/modules/dnn/src/opencl/mvn.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/ocl4dnn_lrn.cl b/upstream/opencv/modules/dnn/src/opencl/ocl4dnn_lrn.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/ocl4dnn_lrn.cl
rename to upstream/opencv/modules/dnn/src/opencl/ocl4dnn_lrn.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/ocl4dnn_pooling.cl b/upstream/opencv/modules/dnn/src/opencl/ocl4dnn_pooling.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/ocl4dnn_pooling.cl
rename to upstream/opencv/modules/dnn/src/opencl/ocl4dnn_pooling.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/permute.cl b/upstream/opencv/modules/dnn/src/opencl/permute.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/permute.cl
rename to upstream/opencv/modules/dnn/src/opencl/permute.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/pooling.cl b/upstream/opencv/modules/dnn/src/opencl/pooling.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/pooling.cl
rename to upstream/opencv/modules/dnn/src/opencl/pooling.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/prior_box.cl b/upstream/opencv/modules/dnn/src/opencl/prior_box.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/prior_box.cl
rename to upstream/opencv/modules/dnn/src/opencl/prior_box.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/region.cl b/upstream/opencv/modules/dnn/src/opencl/region.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/region.cl
rename to upstream/opencv/modules/dnn/src/opencl/region.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/slice.cl b/upstream/opencv/modules/dnn/src/opencl/slice.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/slice.cl
rename to upstream/opencv/modules/dnn/src/opencl/slice.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/softmax.cl b/upstream/opencv/modules/dnn/src/opencl/softmax.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/softmax.cl
rename to upstream/opencv/modules/dnn/src/opencl/softmax.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/opencl/softmax_loss.cl b/upstream/opencv/modules/dnn/src/opencl/softmax_loss.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/opencl/softmax_loss.cl
rename to upstream/opencv/modules/dnn/src/opencl/softmax_loss.cl
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/plugin_api.hpp b/upstream/opencv/modules/dnn/src/plugin_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/plugin_api.hpp
rename to upstream/opencv/modules/dnn/src/plugin_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/plugin_wrapper.impl.hpp b/upstream/opencv/modules/dnn/src/plugin_wrapper.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/plugin_wrapper.impl.hpp
rename to upstream/opencv/modules/dnn/src/plugin_wrapper.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/precomp.hpp b/upstream/opencv/modules/dnn/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/precomp.hpp
rename to upstream/opencv/modules/dnn/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/registry.cpp b/upstream/opencv/modules/dnn/src/registry.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/registry.cpp
rename to upstream/opencv/modules/dnn/src/registry.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/attr_value.proto b/upstream/opencv/modules/dnn/src/tensorflow/attr_value.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/attr_value.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/attr_value.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/function.proto b/upstream/opencv/modules/dnn/src/tensorflow/function.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/function.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/function.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/graph.proto b/upstream/opencv/modules/dnn/src/tensorflow/graph.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/graph.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/graph.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/op_def.proto b/upstream/opencv/modules/dnn/src/tensorflow/op_def.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/op_def.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/op_def.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tensor.proto b/upstream/opencv/modules/dnn/src/tensorflow/tensor.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tensor.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/tensor.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tensor_shape.proto b/upstream/opencv/modules/dnn/src/tensorflow/tensor_shape.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tensor_shape.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/tensor_shape.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp b/upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp
rename to upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp b/upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp
rename to upstream/opencv/modules/dnn/src/tensorflow/tf_graph_simplifier.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_importer.cpp b/upstream/opencv/modules/dnn/src/tensorflow/tf_importer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_importer.cpp
rename to upstream/opencv/modules/dnn/src/tensorflow/tf_importer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_io.cpp b/upstream/opencv/modules/dnn/src/tensorflow/tf_io.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_io.cpp
rename to upstream/opencv/modules/dnn/src/tensorflow/tf_io.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_io.hpp b/upstream/opencv/modules/dnn/src/tensorflow/tf_io.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/tf_io.hpp
rename to upstream/opencv/modules/dnn/src/tensorflow/tf_io.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/types.proto b/upstream/opencv/modules/dnn/src/tensorflow/types.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/types.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/types.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tensorflow/versions.proto b/upstream/opencv/modules/dnn/src/tensorflow/versions.proto
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tensorflow/versions.proto
rename to upstream/opencv/modules/dnn/src/tensorflow/versions.proto
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tflite/builtin_op_data.h b/upstream/opencv/modules/dnn/src/tflite/builtin_op_data.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tflite/builtin_op_data.h
rename to upstream/opencv/modules/dnn/src/tflite/builtin_op_data.h
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tflite/schema.fbs b/upstream/opencv/modules/dnn/src/tflite/schema.fbs
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tflite/schema.fbs
rename to upstream/opencv/modules/dnn/src/tflite/schema.fbs
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tflite/tflite_importer.cpp b/upstream/opencv/modules/dnn/src/tflite/tflite_importer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tflite/tflite_importer.cpp
rename to upstream/opencv/modules/dnn/src/tflite/tflite_importer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_bpe.cpp b/upstream/opencv/modules/dnn/src/tokenizer/core_bpe.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_bpe.cpp
rename to upstream/opencv/modules/dnn/src/tokenizer/core_bpe.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_bpe.hpp b/upstream/opencv/modules/dnn/src/tokenizer/core_bpe.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_bpe.hpp
rename to upstream/opencv/modules/dnn/src/tokenizer/core_bpe.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_gemma.hpp b/upstream/opencv/modules/dnn/src/tokenizer/core_gemma.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/core_gemma.hpp
rename to upstream/opencv/modules/dnn/src/tokenizer/core_gemma.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/tokenizer.cpp b/upstream/opencv/modules/dnn/src/tokenizer/tokenizer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/tokenizer.cpp
rename to upstream/opencv/modules/dnn/src/tokenizer/tokenizer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode-data.cpp b/upstream/opencv/modules/dnn/src/tokenizer/unicode-data.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode-data.cpp
rename to upstream/opencv/modules/dnn/src/tokenizer/unicode-data.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode-data.hpp b/upstream/opencv/modules/dnn/src/tokenizer/unicode-data.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode-data.hpp
rename to upstream/opencv/modules/dnn/src/tokenizer/unicode-data.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode.cpp b/upstream/opencv/modules/dnn/src/tokenizer/unicode.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode.cpp
rename to upstream/opencv/modules/dnn/src/tokenizer/unicode.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode.hpp b/upstream/opencv/modules/dnn/src/tokenizer/unicode.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/unicode.hpp
rename to upstream/opencv/modules/dnn/src/tokenizer/unicode.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/tokenizer/utils.hpp b/upstream/opencv/modules/dnn/src/tokenizer/utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/tokenizer/utils.hpp
rename to upstream/opencv/modules/dnn/src/tokenizer/utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/buffer.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/buffer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/buffer.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/buffer.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/command.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/command.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/command.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/command.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/context.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/context.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/context.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/context.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/fence.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/fence.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/fence.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/fence.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_base.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/op_base.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_base.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/op_base.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_conv.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/op_conv.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_conv.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/op_conv.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_matmul.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/op_matmul.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_matmul.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/op_matmul.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_naryeltwise.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/op_naryeltwise.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/op_naryeltwise.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/op_naryeltwise.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/pipeline.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/pipeline.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/pipeline.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/pipeline.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/tensor.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/tensor.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/tensor.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/tensor.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/vkcom.hpp b/upstream/opencv/modules/dnn/src/vkcom/include/vkcom.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/include/vkcom.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/include/vkcom.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_1x1_fast.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_1x1_fast.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_1x1_fast.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_1x1_fast.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_1x1_fast_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_1x1_fast_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_1x1_fast_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_1x1_fast_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_3x3.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_3x3.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_3x3.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_3x3.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_3x3_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_3x3_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_3x3_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_3x3_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_depthwise_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_depthwise_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_implicit_gemm.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_implicit_gemm.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_implicit_gemm.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_implicit_gemm.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_implicit_gemm_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/conv_implicit_gemm_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/conv_implicit_gemm_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/conv_implicit_gemm_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/gemm.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/gemm.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/gemm.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/gemm.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/gemm_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/gemm_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/gemm_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/gemm_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward.comp b/upstream/opencv/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward.comp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward.comp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward.comp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward_spv.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward_spv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward_spv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/nary_eltwise_binary_forward_spv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spirv_generator.py b/upstream/opencv/modules/dnn/src/vkcom/shader/spirv_generator.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spirv_generator.py
rename to upstream/opencv/modules/dnn/src/vkcom/shader/spirv_generator.py
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spv_shader.cpp b/upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spv_shader.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spv_shader.hpp b/upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/shader/spv_shader.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/shader/spv_shader.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/buffer.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/buffer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/buffer.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/buffer.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/command.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/command.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/command.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/command.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/context.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/context.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/context.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/context.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/fence.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/fence.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/fence.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/fence.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/internal.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/internal.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/internal.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/internal.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/internal.hpp b/upstream/opencv/modules/dnn/src/vkcom/src/internal.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/internal.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/internal.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_base.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/op_base.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_base.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/op_base.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_conv.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/op_conv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_conv.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/op_conv.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_matmul.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/op_matmul.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_matmul.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/op_matmul.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_naryEltwise.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/op_naryEltwise.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/op_naryEltwise.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/op_naryEltwise.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/pipeline.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/pipeline.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/pipeline.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/pipeline.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/tensor.cpp b/upstream/opencv/modules/dnn/src/vkcom/src/tensor.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/src/tensor.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/src/tensor.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/function_list.inl.hpp b/upstream/opencv/modules/dnn/src/vkcom/vulkan/function_list.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/function_list.inl.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/vulkan/function_list.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_functions.cpp b/upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_functions.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_functions.hpp b/upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_functions.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_functions.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_loader.cpp b/upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_loader.cpp
rename to upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.cpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_loader.hpp b/upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/vkcom/vulkan/vk_loader.hpp
rename to upstream/opencv/modules/dnn/src/vkcom/vulkan/vk_loader.hpp
diff --git a/third_party/opencv-5.0.0/modules/dnn/src/webnn/README.md b/upstream/opencv/modules/dnn/src/webnn/README.md
similarity index 100%
rename from third_party/opencv-5.0.0/modules/dnn/src/webnn/README.md
rename to upstream/opencv/modules/dnn/src/webnn/README.md
diff --git a/upstream/opencv/modules/features/3rdparty/annoy/LICENSE b/upstream/opencv/modules/features/3rdparty/annoy/LICENSE
new file mode 100644
index 0000000..d5dd7b1
--- /dev/null
+++ b/upstream/opencv/modules/features/3rdparty/annoy/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2013 Spotify AB
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.
\ No newline at end of file
diff --git a/upstream/opencv/modules/features/3rdparty/annoy/annoylib.h b/upstream/opencv/modules/features/3rdparty/annoy/annoylib.h
new file mode 100644
index 0000000..0d07e86
--- /dev/null
+++ b/upstream/opencv/modules/features/3rdparty/annoy/annoylib.h
@@ -0,0 +1,1671 @@
+// Copyright (c) 2013 Spotify AB
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+
+#ifndef ANNOY_ANNOYLIB_H
+#define ANNOY_ANNOYLIB_H
+
+#include <stdio.h>
+#include <sys/stat.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stddef.h>
+
+#if defined(_MSC_VER) && _MSC_VER == 1500
+typedef unsigned char     uint8_t;
+typedef signed __int32    int32_t;
+typedef unsigned __int64  uint64_t;
+typedef signed __int64    int64_t;
+#else
+#include <stdint.h>
+#endif
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+ // a bit hacky, but override some definitions to support 64 bit
+ #define off_t int64_t
+ #define lseek_getsize(fd) _lseeki64(fd, 0, SEEK_END)
+ #ifndef NOMINMAX
+  #define NOMINMAX
+ #endif
+ #include "mman.h"
+ #include <windows.h>
+#else
+ #include <sys/mman.h>
+ #define lseek_getsize(fd) lseek(fd, 0, SEEK_END)
+#endif
+
+#include <cerrno>
+#include <string.h>
+#include <math.h>
+#include <vector>
+#include <algorithm>
+#include <queue>
+#include <limits>
+#include <map>
+
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
+#ifdef ANNOYLIB_MULTITHREADED_BUILD
+#include <thread>
+#include <mutex>
+#include <shared_mutex>
+#endif
+
+#ifdef _MSC_VER
+// Needed for Visual Studio to disable runtime checks for mempcy
+#pragma runtime_checks("s", off)
+#endif
+
+// This allows others to supply their own logger / error printer without
+// requiring Annoy to import their headers. See RcppAnnoy for a use case.
+#ifndef __ERROR_PRINTER_OVERRIDE__
+  #define annoylib_showUpdate(...) { fprintf(stderr, __VA_ARGS__ ); }
+#else
+  #define annoylib_showUpdate(...) { __ERROR_PRINTER_OVERRIDE__( __VA_ARGS__ ); }
+#endif
+
+// Portable alloc definition, cf Writing R Extensions, Section 1.6.4
+#ifdef __GNUC__
+  // Includes GCC, clang and Intel compilers
+  # undef alloca
+  # define alloca(x) __builtin_alloca((x))
+#elif defined(__sun) || defined(_AIX)
+  // this is necessary (and sufficient) for Solaris 10 and AIX 6:
+  # include <alloca.h>
+#endif
+
+// We let the v array in the Node struct take whatever space is needed, so this is a mostly insignificant number.
+// Compilers need *some* size defined for the v array, and some memory checking tools will flag for buffer overruns if this is set too low.
+#define ANNOYLIB_V_ARRAY_SIZE 65536
+
+#ifndef _MSC_VER
+#define annoylib_popcount __builtin_popcountll
+#else // See #293, #358
+#define annoylib_popcount cole_popcount
+#endif
+
+#if !defined(NO_MANUAL_VECTORIZATION) && defined(__GNUC__) && (__GNUC__ >6) && defined(__AVX512F__)  // See #402
+#define ANNOYLIB_USE_AVX512
+#elif !defined(NO_MANUAL_VECTORIZATION) && defined(__AVX__) && defined (__SSE__) && defined(__SSE2__) && defined(__SSE3__)
+#define ANNOYLIB_USE_AVX
+#else
+#endif
+
+#if defined(ANNOYLIB_USE_AVX) || defined(ANNOYLIB_USE_AVX512)
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__GNUC__)
+#include <x86intrin.h>
+#endif
+#endif
+
+#if !defined(__MINGW32__)
+#define ANNOYLIB_FTRUNCATE_SIZE(x) static_cast<int64_t>(x)
+#else
+#define ANNOYLIB_FTRUNCATE_SIZE(x) (x)
+#endif
+
+namespace cvannoy {
+
+inline void set_error_from_errno(char **error, const char* msg) {
+  annoylib_showUpdate("%s: %s (%d)\n", msg, strerror(errno), errno);
+  if (error) {
+    *error = (char *)malloc(256);  // TODO: win doesn't support snprintf
+    snprintf(*error, 255, "%s: %s (%d)", msg, strerror(errno), errno);
+  }
+}
+
+inline void set_error_from_string(char **error, const char* msg) {
+  annoylib_showUpdate("%s\n", msg);
+  if (error) {
+    *error = (char *)malloc(strlen(msg) + 1);
+    strcpy(*error, msg);
+  }
+}
+
+
+using std::vector;
+using std::pair;
+using std::numeric_limits;
+using std::make_pair;
+using std::map;
+
+inline bool remap_memory_and_truncate(void** _ptr, int _fd, size_t old_size, size_t new_size) {
+#ifdef __linux__
+    *_ptr = mremap(*_ptr, old_size, new_size, MREMAP_MAYMOVE);
+    bool ok = ftruncate(_fd, new_size) != -1;
+#else
+    munmap(*_ptr, old_size);
+    bool ok = ftruncate(_fd, ANNOYLIB_FTRUNCATE_SIZE(new_size)) != -1;
+#ifdef MAP_POPULATE
+    *_ptr = mmap(*_ptr, new_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, _fd, 0);
+#else
+    *_ptr = mmap(*_ptr, new_size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
+#endif
+#endif
+    return ok;
+}
+
+namespace {
+
+template<typename S, typename Node>
+inline Node* get_node_ptr(const void* _nodes, const size_t _s, const S i) {
+  return (Node*)((uint8_t *)_nodes + (_s * i));
+}
+
+template<typename T>
+inline T dot(const T* x, const T* y, int f) {
+  T s = 0;
+  for (int z = 0; z < f; z++) {
+    s += (*x) * (*y);
+    x++;
+    y++;
+  }
+  return s;
+}
+
+template<typename T>
+inline T manhattan_distance(const T* x, const T* y, int f) {
+  T d = 0.0;
+  for (int i = 0; i < f; i++)
+    d += fabs(x[i] - y[i]);
+  return d;
+}
+
+template<typename T>
+inline T euclidean_distance(const T* x, const T* y, int f) {
+  // Don't use dot-product: avoid catastrophic cancellation in #314.
+  T d = 0.0;
+  for (int i = 0; i < f; ++i) {
+    const T tmp=*x - *y;
+    d += tmp * tmp;
+    ++x;
+    ++y;
+  }
+  return d;
+}
+
+#ifdef ANNOYLIB_USE_AVX
+// Horizontal single sum of 256bit vector.
+inline float hsum256_ps_avx(__m256 v) {
+  const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(v, 1), _mm256_castps256_ps128(v));
+  const __m128 x64 = _mm_add_ps(x128, _mm_movehl_ps(x128, x128));
+  const __m128 x32 = _mm_add_ss(x64, _mm_shuffle_ps(x64, x64, 0x55));
+  return _mm_cvtss_f32(x32);
+}
+
+template<>
+inline float dot<float>(const float* x, const float *y, int f) {
+  float result = 0;
+  if (f > 7) {
+    __m256 d = _mm256_setzero_ps();
+    for (; f > 7; f -= 8) {
+      d = _mm256_add_ps(d, _mm256_mul_ps(_mm256_loadu_ps(x), _mm256_loadu_ps(y)));
+      x += 8;
+      y += 8;
+    }
+    // Sum all floats in dot register.
+    result += hsum256_ps_avx(d);
+  }
+  // Don't forget the remaining values.
+  for (; f > 0; f--) {
+    result += *x * *y;
+    x++;
+    y++;
+  }
+  return result;
+}
+
+template<>
+inline float manhattan_distance<float>(const float* x, const float* y, int f) {
+  float result = 0;
+  int i = f;
+  if (f > 7) {
+    __m256 manhattan = _mm256_setzero_ps();
+    __m256 minus_zero = _mm256_set1_ps(-0.0f);
+    for (; i > 7; i -= 8) {
+      const __m256 x_minus_y = _mm256_sub_ps(_mm256_loadu_ps(x), _mm256_loadu_ps(y));
+      const __m256 distance = _mm256_andnot_ps(minus_zero, x_minus_y); // Absolute value of x_minus_y (forces sign bit to zero)
+      manhattan = _mm256_add_ps(manhattan, distance);
+      x += 8;
+      y += 8;
+    }
+    // Sum all floats in manhattan register.
+    result = hsum256_ps_avx(manhattan);
+  }
+  // Don't forget the remaining values.
+  for (; i > 0; i--) {
+    result += fabsf(*x - *y);
+    x++;
+    y++;
+  }
+  return result;
+}
+
+template<>
+inline float euclidean_distance<float>(const float* x, const float* y, int f) {
+  float result=0;
+  if (f > 7) {
+    __m256 d = _mm256_setzero_ps();
+    for (; f > 7; f -= 8) {
+      const __m256 diff = _mm256_sub_ps(_mm256_loadu_ps(x), _mm256_loadu_ps(y));
+      d = _mm256_add_ps(d, _mm256_mul_ps(diff, diff)); // no support for fmadd in AVX...
+      x += 8;
+      y += 8;
+    }
+    // Sum all floats in dot register.
+    result = hsum256_ps_avx(d);
+  }
+  // Don't forget the remaining values.
+  for (; f > 0; f--) {
+    float tmp = *x - *y;
+    result += tmp * tmp;
+    x++;
+    y++;
+  }
+  return result;
+}
+
+#endif
+
+#ifdef ANNOYLIB_USE_AVX512
+template<>
+inline float dot<float>(const float* x, const float *y, int f) {
+  float result = 0;
+  if (f > 15) {
+    __m512 d = _mm512_setzero_ps();
+    for (; f > 15; f -= 16) {
+      //AVX512F includes FMA
+      d = _mm512_fmadd_ps(_mm512_loadu_ps(x), _mm512_loadu_ps(y), d);
+      x += 16;
+      y += 16;
+    }
+    // Sum all floats in dot register.
+    result += _mm512_reduce_add_ps(d);
+  }
+  // Don't forget the remaining values.
+  for (; f > 0; f--) {
+    result += *x * *y;
+    x++;
+    y++;
+  }
+  return result;
+}
+
+template<>
+inline float manhattan_distance<float>(const float* x, const float* y, int f) {
+  float result = 0;
+  int i = f;
+  if (f > 15) {
+    __m512 manhattan = _mm512_setzero_ps();
+    for (; i > 15; i -= 16) {
+      const __m512 x_minus_y = _mm512_sub_ps(_mm512_loadu_ps(x), _mm512_loadu_ps(y));
+      manhattan = _mm512_add_ps(manhattan, _mm512_abs_ps(x_minus_y));
+      x += 16;
+      y += 16;
+    }
+    // Sum all floats in manhattan register.
+    result = _mm512_reduce_add_ps(manhattan);
+  }
+  // Don't forget the remaining values.
+  for (; i > 0; i--) {
+    result += fabsf(*x - *y);
+    x++;
+    y++;
+  }
+  return result;
+}
+
+template<>
+inline float euclidean_distance<float>(const float* x, const float* y, int f) {
+  float result=0;
+  if (f > 15) {
+    __m512 d = _mm512_setzero_ps();
+    for (; f > 15; f -= 16) {
+      const __m512 diff = _mm512_sub_ps(_mm512_loadu_ps(x), _mm512_loadu_ps(y));
+      d = _mm512_fmadd_ps(diff, diff, d);
+      x += 16;
+      y += 16;
+    }
+    // Sum all floats in dot register.
+    result = _mm512_reduce_add_ps(d);
+  }
+  // Don't forget the remaining values.
+  for (; f > 0; f--) {
+    float tmp = *x - *y;
+    result += tmp * tmp;
+    x++;
+    y++;
+  }
+  return result;
+}
+
+#endif
+
+
+template<typename T, typename Random, typename Distance, typename Node>
+inline void two_means(const vector<Node*>& nodes, int f, Random& random, bool cosine, Node* p, Node* q) {
+  /*
+    This algorithm is a huge heuristic. Empirically it works really well, but I
+    can't motivate it well. The basic idea is to keep two centroids and assign
+    points to either one of them. We weight each centroid by the number of points
+    assigned to it, so to balance it.
+  */
+  static int iteration_steps = 200;
+  size_t count = nodes.size();
+
+  size_t i = random.index(count);
+  size_t j = random.index(count-1);
+  j += (j >= i); // ensure that i != j
+
+  Distance::template copy_node<T, Node>(p, nodes[i], f);
+  Distance::template copy_node<T, Node>(q, nodes[j], f);
+
+  if (cosine) { Distance::template normalize<T, Node>(p, f); Distance::template normalize<T, Node>(q, f); }
+  Distance::init_node(p, f);
+  Distance::init_node(q, f);
+
+  int ic = 1, jc = 1;
+  for (int l = 0; l < iteration_steps; l++) {
+    size_t k = random.index(count);
+    T di = ic * Distance::distance(p, nodes[k], f),
+      dj = jc * Distance::distance(q, nodes[k], f);
+    T norm = cosine ? Distance::template get_norm<T, Node>(nodes[k], f) : 1;
+    if (!(norm > T(0))) {
+      continue;
+    }
+    if (di < dj) {
+      Distance::update_mean(p, nodes[k], norm, ic, f);
+      Distance::init_node(p, f);
+      ic++;
+    } else if (dj < di) {
+      Distance::update_mean(q, nodes[k], norm, jc, f);
+      Distance::init_node(q, f);
+      jc++;
+    }
+  }
+}
+} // namespace
+
+struct Base {
+  template<typename T, typename S, typename Node>
+  static inline void preprocess(void* /*nodes*/, size_t /*_s*/, const S /*node_count*/, const int /*f*/) {
+    // Override this in specific metric structs below if you need to do any pre-processing
+    // on the entire set of nodes passed into this index.
+  }
+
+  template<typename T, typename S, typename Node>
+  static inline void postprocess(void* /*nodes*/, size_t /*_s*/, const S /*node_count*/, const int /*f*/) {
+    // Override this in specific metric structs below if you need to do any post-processing
+    // on the entire set of nodes passed into this index.
+  }
+
+  template<typename Node>
+  static inline void zero_value(Node* /*dest*/) {
+    // Initialize any fields that require sane defaults within this node.
+  }
+
+  template<typename T, typename Node>
+  static inline void copy_node(Node* dest, const Node* source, const int f) {
+    memcpy(dest->v, source->v, f * sizeof(T));
+  }
+
+  template<typename T, typename Node>
+  static inline T get_norm(Node* node, int f) {
+      return sqrt(dot(node->v, node->v, f));
+  }
+
+  template<typename T, typename Node>
+  static inline void normalize(Node* node, int f) {
+    T norm = Base::get_norm<T, Node>(node, f);
+    if (norm > 0) {
+      for (int z = 0; z < f; z++)
+        node->v[z] /= norm;
+    }
+  }
+
+  template<typename T, typename Node>
+  static inline void update_mean(Node* mean, Node* new_node, T norm, int c, int f) {
+      for (int z = 0; z < f; z++)
+        mean->v[z] = (mean->v[z] * c + new_node->v[z] / norm) / (c + 1);
+  }
+};
+
+struct Angular : Base {
+  template<typename S, typename T>
+  struct Node {
+    /*
+     * We store a binary tree where each node has two things
+     * - A vector associated with it
+     * - Two children
+     * All nodes occupy the same amount of memory
+     * All nodes with n_descendants == 1 are leaf nodes.
+     * A memory optimization is that for nodes with 2 <= n_descendants <= K,
+     * we skip the vector. Instead we store a list of all descendants. K is
+     * determined by the number of items that fits in the space of the vector.
+     * For nodes with n_descendants == 1 the vector is a data point.
+     * For nodes with n_descendants > K the vector is the normal of the split plane.
+     * Note that we can't really do sizeof(node<T>) because we cheat and allocate
+     * more memory to be able to fit the vector outside
+     */
+    S n_descendants;
+    union {
+      S children[2]; // Will possibly store more than 2
+      T norm;
+    };
+    T v[ANNOYLIB_V_ARRAY_SIZE];
+  };
+  template<typename S, typename T>
+  static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
+    // want to calculate (a/|a| - b/|b|)^2
+    // = a^2 / a^2 + b^2 / b^2 - 2ab/|a||b|
+    // = 2 - 2cos
+    T pp = x->norm ? x->norm : dot(x->v, x->v, f); // For backwards compatibility reasons, we need to fall back and compute the norm here
+    T qq = y->norm ? y->norm : dot(y->v, y->v, f);
+    T pq = dot(x->v, y->v, f);
+    T ppqq = pp * qq;
+    if (ppqq > 0) return T(2.0 - 2.0 * pq / sqrt(ppqq));
+    else return T(2.0); // cos is 0
+  }
+  template<typename S, typename T>
+  static inline T margin(const Node<S, T>* n, const T* y, int f) {
+    return dot(n->v, y, f);
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const T* y, int f, Random& random) {
+    T dot = margin(n, y, f);
+    if (dot != 0)
+      return (dot > 0);
+    else
+      return random.flip() != 0? true : false;
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const Node<S, T>* y, int f, Random& random) {
+    return side(n, y->v, f, random);
+  }
+  template<typename S, typename T, typename Random>
+  static inline void create_split(const vector<Node<S, T>*>& nodes, int f, size_t s, Random& random, Node<S, T>* n) {
+    Node<S, T>* p = (Node<S, T>*)alloca(s);
+    Node<S, T>* q = (Node<S, T>*)alloca(s);
+    two_means<T, Random, Angular, Node<S, T> >(nodes, f, random, true, p, q);
+    for (int z = 0; z < f; z++)
+      n->v[z] = p->v[z] - q->v[z];
+    Base::normalize<T, Node<S, T> >(n, f);
+  }
+  template<typename T>
+  static inline T normalized_distance(T distance) {
+    // Used when requesting distances from Python layer
+    // Turns out sometimes the squared distance is -0.0
+    // so we have to make sure it's a positive number.
+    return sqrt(std::max(distance, T(0)));
+  }
+  template<typename T>
+  static inline T pq_distance(T distance, T margin, int child_nr) {
+    if (child_nr == 0)
+      margin = -margin;
+    return std::min(distance, margin);
+  }
+  template<typename T>
+  static inline T pq_initial_value() {
+    return numeric_limits<T>::infinity();
+  }
+  template<typename S, typename T>
+  static inline void init_node(Node<S, T>* n, int f) {
+    n->norm = dot(n->v, n->v, f);
+  }
+  static const char* name() {
+    return "angular";
+  }
+};
+
+
+struct DotProduct : Angular {
+  template<typename S, typename T>
+  struct Node {
+    /*
+     * This is an extension of the Angular node with extra attributes for the DotProduct metric.
+     * It has dot_factor which is needed to reduce the task to Angular distance metric (see the preprocess method)
+     * and also a built flag that helps to compute exact dot products when an index is already built.
+     */
+    S n_descendants;
+    S children[2]; // Will possibly store more than 2
+    T dot_factor;
+    T norm;
+    bool built;
+    T v[ANNOYLIB_V_ARRAY_SIZE];
+  };
+
+  static const char* name() {
+    return "dot";
+  }
+
+  template<typename T, typename Node>
+  static inline T get_norm(Node* node, int f) {
+      return sqrt(dot(node->v, node->v, f) + node->dot_factor * node->dot_factor);
+  }
+
+  template<typename T, typename Node>
+  static inline void update_mean(Node* mean, Node* new_node, T norm, int c, int f) {
+      for (int z = 0; z < f; z++)
+        mean->v[z] = (mean->v[z] * c + new_node->v[z] / norm) / (c + 1);
+      mean->dot_factor = (mean->dot_factor * c + new_node->dot_factor / norm) / (c + 1);
+  }
+
+  template<typename S, typename T>
+  static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
+    if (x->built || y->built) {
+      // When index is already built, we don't need angular distances to retrieve NNs
+      // Thus, we can return dot product scores itself
+      return -dot(x->v, y->v, f);
+    }
+
+    // Calculated by analogy with the angular case
+    T pp = x->norm ? x->norm : dot(x->v, x->v, f) + x->dot_factor * x->dot_factor;
+    T qq = y->norm ? y->norm : dot(y->v, y->v, f) + y->dot_factor * y->dot_factor;
+    T pq = dot(x->v, y->v, f) + x->dot_factor * y->dot_factor;
+    T ppqq = pp * qq;
+
+    if (ppqq > 0) return T(2.0 - 2.0 * pq / sqrt(ppqq));
+    else return T(2.0);
+  }
+
+  template<typename Node>
+  static inline void zero_value(Node* dest) {
+    dest->dot_factor = 0;
+  }
+
+  template<typename S, typename T>
+  static inline void init_node(Node<S, T>* n, int f) {
+    n->built = false;
+    n->norm = dot(n->v, n->v, f) + n->dot_factor * n->dot_factor;
+  }
+
+  template<typename T, typename Node>
+  static inline void copy_node(Node* dest, const Node* source, const int f) {
+    memcpy(dest->v, source->v, f * sizeof(T));
+    dest->dot_factor = source->dot_factor;
+  }
+
+  template<typename S, typename T, typename Random>
+  static inline void create_split(const vector<Node<S, T>*>& nodes, int f, size_t s, Random& random, Node<S, T>* n) {
+    Node<S, T>* p = (Node<S, T>*)alloca(s);
+    Node<S, T>* q = (Node<S, T>*)alloca(s);
+    DotProduct::zero_value(p);
+    DotProduct::zero_value(q);
+    two_means<T, Random, DotProduct, Node<S, T> >(nodes, f, random, true, p, q);
+    for (int z = 0; z < f; z++)
+      n->v[z] = p->v[z] - q->v[z];
+    n->dot_factor = p->dot_factor - q->dot_factor;
+    DotProduct::normalize<T, Node<S, T> >(n, f);
+  }
+
+  template<typename T, typename Node>
+  static inline void normalize(Node* node, int f) {
+    T norm = T(sqrt(dot(node->v, node->v, f) + pow(node->dot_factor, 2)));
+    if (norm > 0) {
+      for (int z = 0; z < f; z++)
+        node->v[z] /= norm;
+      node->dot_factor /= norm;
+    }
+  }
+
+  template<typename S, typename T>
+  static inline T margin(const Node<S, T>* n, const T* y, int f) {
+    return dot(n->v, y, f);
+  }
+
+  template<typename S, typename T>
+  static inline T margin(const Node<S, T>* n, const Node<S, T>* y, int f) {
+    return dot(n->v, y->v, f) + n->dot_factor * y->dot_factor;
+  }
+
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const Node<S, T>* y, int f, Random& random) {
+    T dot = margin(n, y, f);
+    if (dot != 0)
+      return (dot > 0);
+    else
+      return random.flip() != 0? true : false;
+  }
+
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const T* y, int f, Random& random) {
+    T dot = margin(n, y, f);
+    if (dot != 0)
+      return (dot > 0);
+    else
+      return (bool)random.flip();
+  }
+
+  template<typename T>
+  static inline T normalized_distance(T distance) {
+    return -distance;
+  }
+
+  template<typename T, typename S, typename Node>
+  static inline void preprocess(void* nodes, size_t _s, const S node_count, const int f) {
+    // This uses a method from Microsoft Research for transforming inner product spaces to cosine/angular-compatible spaces.
+    // (Bachrach et al., 2014, see https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/XboxInnerProduct.pdf)
+
+    // Step one: compute the norm of each vector and store that in its extra dimension (f-1)
+    for (S i = 0; i < node_count; i++) {
+      Node* node = get_node_ptr<S, Node>(nodes, _s, i);
+      T d = dot(node->v, node->v, f);
+      T norm = d < 0 ? 0 : sqrt(d);
+      node->dot_factor = norm;
+      node->built = false;
+    }
+
+    // Step two: find the maximum norm
+    T max_norm = 0;
+    for (S i = 0; i < node_count; i++) {
+      Node* node = get_node_ptr<S, Node>(nodes, _s, i);
+      if (node->dot_factor > max_norm) {
+        max_norm = node->dot_factor;
+      }
+    }
+
+    // Step three: set each vector's extra dimension to sqrt(max_norm^2 - norm^2)
+    for (S i = 0; i < node_count; i++) {
+      Node* node = get_node_ptr<S, Node>(nodes, _s, i);
+      T node_norm = node->dot_factor;
+      T squared_norm_diff = pow(max_norm, static_cast<T>(2.0)) - pow(node_norm, static_cast<T>(2.0));
+      T dot_factor = squared_norm_diff < 0 ? 0 : sqrt(squared_norm_diff);
+
+      node->norm = pow(max_norm, static_cast<T>(2.0));
+      node->dot_factor = dot_factor;
+    }
+  }
+
+  template<typename T, typename S, typename Node>
+  static inline void postprocess(void* nodes, size_t _s, const S node_count, const int /*f*/) {
+    for (S i = 0; i < node_count; i++) {
+      Node* node = get_node_ptr<S, Node>(nodes, _s, i);
+      // When an index is built, we will remember it in index item nodes to compute distances differently
+      node->built = true;
+    }
+  }
+};
+
+struct Hamming : Base {
+  template<typename S, typename T>
+  struct Node {
+    S n_descendants;
+    S children[2];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
+  };
+
+  static const size_t max_iterations = 20;
+
+  template<typename T>
+  static inline T pq_distance(T distance, T margin, int child_nr) {
+    return distance - (margin != (unsigned int) child_nr);
+  }
+
+  template<typename T>
+  static inline T pq_initial_value() {
+    return numeric_limits<T>::max();
+  }
+  template<typename T>
+  static inline int cole_popcount(T v) {
+    // Note: Only used with MSVC 9, which lacks intrinsics and fails to
+    // calculate std::bitset::count for v > 32bit. Uses the generalized
+    // approach by Eric Cole.
+    // See https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSet64
+    v = v - ((v >> 1) & (T)~(T)0/3);
+    v = (v & (T)~(T)0/15*3) + ((v >> 2) & (T)~(T)0/15*3);
+    v = (v + (v >> 4)) & (T)~(T)0/255*15;
+    return (T)(v * ((T)~(T)0/255)) >> (sizeof(T) - 1) * 8;
+  }
+  template<typename S, typename T>
+  static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
+    size_t dist = 0;
+    for (int i = 0; i < f; i++) {
+      dist += annoylib_popcount(x->v[i] ^ y->v[i]);
+    }
+    return T(dist);
+  }
+  template<typename S, typename T>
+  static inline bool margin(const Node<S, T>* n, const T* y, int /*f*/) {
+    static const size_t n_bits = sizeof(T) * 8;
+    T chunk = n->v[0] / n_bits;
+    return (y[chunk] & (static_cast<T>(1) << (n_bits - 1 - (n->v[0] % n_bits)))) != 0;
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const T* y, int f, Random& /*random*/) {
+    return margin(n, y, f);
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const Node<S, T>* y, int f, Random& random) {
+    return side(n, y->v, f, random);
+  }
+  template<typename S, typename T, typename Random>
+  static inline void create_split(const vector<Node<S, T>*>& nodes, int f, size_t /*s*/, Random& random, Node<S, T>* n) {
+    size_t cur_size = 0;
+    size_t i = 0;
+    int dim = f * 8 * sizeof(T);
+    for (; i < max_iterations; i++) {
+      // choose random position to split at
+      n->v[0] = T(random.index(dim));
+      cur_size = 0;
+      for (typename vector<Node<S, T>*>::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
+        if (margin(n, (*it)->v, f)) {
+          cur_size++;
+        }
+      }
+      if (cur_size > 0 && cur_size < nodes.size()) {
+        break;
+      }
+    }
+    // brute-force search for splitting coordinate
+    if (i == max_iterations) {
+      int j = 0;
+      for (; j < dim; j++) {
+        n->v[0] = T(j);
+        cur_size = 0;
+        for (typename vector<Node<S, T>*>::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
+          if (margin(n, (*it)->v, f)) {
+            cur_size++;
+          }
+        }
+        if (cur_size > 0 && cur_size < nodes.size()) {
+          break;
+        }
+      }
+    }
+  }
+  template<typename T>
+  static inline T normalized_distance(T distance) {
+    return distance;
+  }
+  template<typename S, typename T>
+  static inline void init_node(Node<S, T>* /*n*/, int /*f*/) {
+  }
+  static const char* name() {
+    return "hamming";
+  }
+};
+
+
+struct Minkowski : Base {
+  template<typename S, typename T>
+  struct Node {
+    S n_descendants;
+    T a; // need an extra constant term to determine the offset of the plane
+    S children[2];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
+  };
+  template<typename S, typename T>
+  static inline T margin(const Node<S, T>* n, const T* y, int f) {
+    return n->a + dot(n->v, y, f);
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const T* y, int f, Random& random) {
+    T dot = margin(n, y, f);
+    if (dot != 0)
+      return (dot > 0);
+    else
+      return random.flip() != 0? true : false;
+  }
+  template<typename S, typename T, typename Random>
+  static inline bool side(const Node<S, T>* n, const Node<S, T>* y, int f, Random& random) {
+    return side(n, y->v, f, random);
+  }
+  template<typename T>
+  static inline T pq_distance(T distance, T margin, int child_nr) {
+    if (child_nr == 0)
+      margin = -margin;
+    return std::min(distance, margin);
+  }
+  template<typename T>
+  static inline T pq_initial_value() {
+    return numeric_limits<T>::infinity();
+  }
+};
+
+
+struct Euclidean : Minkowski {
+  template<typename S, typename T>
+  static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
+    return euclidean_distance(x->v, y->v, f);
+  }
+  template<typename S, typename T, typename Random>
+  static inline void create_split(const vector<Node<S, T>*>& nodes, int f, size_t s, Random& random, Node<S, T>* n) {
+    Node<S, T>* p = (Node<S, T>*)alloca(s);
+    Node<S, T>* q = (Node<S, T>*)alloca(s);
+    two_means<T, Random, Euclidean, Node<S, T> >(nodes, f, random, false, p, q);
+
+    for (int z = 0; z < f; z++)
+      n->v[z] = p->v[z] - q->v[z];
+    Base::normalize<T, Node<S, T> >(n, f);
+    n->a = 0.0;
+    for (int z = 0; z < f; z++)
+      n->a += -n->v[z] * (p->v[z] + q->v[z]) / 2;
+  }
+  template<typename T>
+  static inline T normalized_distance(T distance) {
+    return sqrt(std::max(distance, T(0)));
+  }
+  template<typename S, typename T>
+  static inline void init_node(Node<S, T>* /*n*/, int /*f*/) {
+  }
+  static const char* name() {
+    return "euclidean";
+  }
+
+};
+
+struct Manhattan : Minkowski {
+  template<typename S, typename T>
+  static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
+    return manhattan_distance(x->v, y->v, f);
+  }
+  template<typename S, typename T, typename Random>
+  static inline void create_split(const vector<Node<S, T>*>& nodes, int f, size_t s, Random& random, Node<S, T>* n) {
+    Node<S, T>* p = (Node<S, T>*)alloca(s);
+    Node<S, T>* q = (Node<S, T>*)alloca(s);
+    two_means<T, Random, Manhattan, Node<S, T> >(nodes, f, random, false, p, q);
+
+    for (int z = 0; z < f; z++)
+      n->v[z] = p->v[z] - q->v[z];
+    Base::normalize<T, Node<S, T> >(n, f);
+    n->a = 0.0;
+    for (int z = 0; z < f; z++)
+      n->a += -n->v[z] * (p->v[z] + q->v[z]) / 2;
+  }
+  template<typename T>
+  static inline T normalized_distance(T distance) {
+    return std::max(distance, T(0));
+  }
+  template<typename S, typename T>
+  static inline void init_node(Node<S, T>* /*n*/, int /*f*/) {
+  }
+  static const char* name() {
+    return "manhattan";
+  }
+};
+
+template<typename S, typename T, typename R = uint64_t>
+class AnnoyIndexInterface {
+ public:
+  // Note that the methods with an **error argument will allocate memory and write the pointer to that string if error is non-NULL
+  virtual ~AnnoyIndexInterface() {};
+  virtual bool add_item(S item, const T* w, char** error=NULL) = 0;
+  virtual bool build(int q, int n_threads=-1, char** error=NULL) = 0;
+  virtual bool unbuild(char** error=NULL) = 0;
+  virtual bool save(const char* filename, bool prefault=false, char** error=NULL) = 0;
+  virtual void unload() = 0;
+  virtual bool load(const char* filename, bool prefault=false, char** error=NULL) = 0;
+  virtual T get_distance(S i, S j) const = 0;
+  virtual void get_nns_by_item(S item, size_t n, int search_k, vector<S>* result, vector<T>* distances) const = 0;
+  virtual void get_nns_by_vector(const T* w, size_t n, int search_k, vector<S>* result, vector<T>* distances) const = 0;
+  virtual S get_n_items() const = 0;
+  virtual S get_n_trees() const = 0;
+  virtual S get_n_nodes(S root) const = 0;
+  virtual void verbose(bool v) = 0;
+  virtual void get_item(S item, T* v) const = 0;
+  virtual void set_seed(R q) = 0;
+  virtual bool on_disk_build(const char* filename, char** error=NULL) = 0;
+};
+
+template<typename S, typename T, typename Distance, typename Random, class ThreadedBuildPolicy>
+  class AnnoyIndex : public AnnoyIndexInterface<S, T,
+#if __cplusplus >= 201103L
+    typename std::remove_const<decltype(Random::default_seed)>::type
+#else
+    typename Random::seed_type
+#endif
+    > {
+  /*
+   * We use random projection to build a forest of binary trees of all items.
+   * Basically just split the hyperspace into two sides by a hyperplane,
+   * then recursively split each of those subtrees etc.
+   * We create a tree like this q times. The default q is determined automatically
+   * in such a way that we at most use 2x as much memory as the vectors take.
+   */
+public:
+  typedef Distance D;
+  typedef typename D::template Node<S, T> Node;
+#if __cplusplus >= 201103L
+  typedef typename std::remove_const<decltype(Random::default_seed)>::type R;
+#else
+  typedef typename Random::seed_type R;
+#endif
+
+protected:
+  const int _f;
+  size_t _s;
+  S _n_items;
+  void* _nodes; // Could either be mmapped, or point to a memory buffer that we reallocate
+  S _n_nodes;
+  S _nodes_size;
+  vector<S> _roots;
+  int _tree_idx;
+  map<int, S> _rt_order;
+  S _K;
+  R _seed;
+  bool _loaded;
+  bool _verbose;
+  int _fd;
+  bool _on_disk;
+  bool _built;
+public:
+
+   AnnoyIndex(int f) : _f(f), _seed(Random::default_seed) {
+    _s = offsetof(Node, v) + _f * sizeof(T); // Size of each node
+    _verbose = false;
+    _built = false;
+    _K = (S) (((size_t) (_s - offsetof(Node, children))) / sizeof(S)); // Max number of descendants to fit into node
+    reinitialize(); // Reset everything
+  }
+  ~AnnoyIndex() {
+    unload();
+  }
+
+  int get_f() const {
+    return _f;
+  }
+
+  bool add_item(S item, const T* w, char** error=NULL) override {
+    return add_item_impl(item, w, error);
+  }
+
+  template<typename W>
+  bool add_item_impl(S item, const W& w, char** error=NULL) {
+    if (_loaded) {
+      set_error_from_string(error, "You can't add an item to a loaded index");
+      return false;
+    }
+    _allocate_size(item + 1);
+    Node* n = _get(item);
+
+    D::zero_value(n);
+
+    n->children[0] = 0;
+    n->children[1] = 0;
+    n->n_descendants = 1;
+
+    for (int z = 0; z < _f; z++)
+      n->v[z] = w[z];
+
+    D::init_node(n, _f);
+
+    if (item >= _n_items)
+      _n_items = item + 1;
+
+    return true;
+  }
+
+  bool on_disk_build(const char* file, char** error=NULL) override {
+    _on_disk = true;
+#ifndef _MSC_VER
+    _fd = open(file, O_RDWR | O_CREAT | O_TRUNC, (int) 0600);
+#else
+    _fd = _open(file, _O_RDWR | _O_CREAT | _O_TRUNC, (int) 0600);
+#endif
+    if (_fd == -1) {
+      set_error_from_errno(error, "Unable to open");
+      _fd = 0;
+      return false;
+    }
+    _nodes_size = 1;
+    if (ftruncate(_fd, ANNOYLIB_FTRUNCATE_SIZE(_s) * ANNOYLIB_FTRUNCATE_SIZE(_nodes_size)) == -1) {
+      set_error_from_errno(error, "Unable to truncate");
+      return false;
+    }
+#ifdef MAP_POPULATE
+    _nodes = (Node*) mmap(0, _s * _nodes_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, _fd, 0);
+#else
+    _nodes = (Node*) mmap(0, _s * _nodes_size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
+#endif
+    return true;
+  }
+
+  bool build(int q, int n_threads=-1, char** error=NULL) override {
+    if (_loaded) {
+      set_error_from_string(error, "You can't build a loaded index");
+      return false;
+    }
+
+    if (_built) {
+      set_error_from_string(error, "You can't build a built index");
+      return false;
+    }
+
+    D::template preprocess<T, S, Node>(_nodes, _s, _n_items, _f);
+
+    _n_nodes = _n_items;
+
+    ThreadedBuildPolicy::template build<S, T>(this, q, n_threads);
+
+    if (q == -1) {
+      // Remove extra trees if any
+      int num_nodes = _n_nodes;
+      typename map<int, S>::reverse_iterator rit;
+      for (rit = _rt_order.rbegin(); rit != _rt_order.rend(); ++rit) {
+        S rt_idx = rit->second;
+        S num_tree_nodes = get_n_nodes(rt_idx);
+        num_nodes -= num_tree_nodes;
+
+        // the criteria of stopping building trees when tree number is not
+        // specified: _n_nodes >= 2 * _n_items
+        if (num_nodes > 2 * _n_items) {
+          auto it = std::remove(_roots.begin(), _roots.end(), rt_idx);
+          _roots.erase(it, _roots.end());
+          // _n_nodes -= num_tree_nodes;
+        }
+        else
+          break;
+      }
+    }
+
+    // Also, copy the roots into the last segment of the array
+    // This way we can load them faster without reading the whole file
+    _allocate_size(_n_nodes + (S)_roots.size());
+    for (size_t i = 0; i < _roots.size(); i++)
+      memcpy(_get(_n_nodes + (S)i), _get(_roots[i]), _s);
+    _n_nodes += S(_roots.size());
+
+    if (_verbose) annoylib_showUpdate("has %d nodes\n", _n_nodes);
+
+    if (_on_disk) {
+      if (!remap_memory_and_truncate(&_nodes, _fd,
+          static_cast<size_t>(_s) * static_cast<size_t>(_nodes_size),
+          static_cast<size_t>(_s) * static_cast<size_t>(_n_nodes))) {
+        // TODO: this probably creates an index in a corrupt state... not sure what to do
+        set_error_from_errno(error, "Unable to truncate");
+        return false;
+      }
+      _nodes_size = _n_nodes;
+    }
+
+    D::template postprocess<T, S, Node>(_nodes, _s, _n_items, _f);
+
+    _built = true;
+    return true;
+  }
+
+  bool unbuild(char** error=NULL) override {
+    if (_loaded) {
+      set_error_from_string(error, "You can't unbuild a loaded index");
+      return false;
+    }
+
+    _roots.clear();
+    _tree_idx = 0;
+    _rt_order.clear();
+    _n_nodes = _n_items;
+    _built = false;
+
+    return true;
+  }
+
+  bool save(const char* filename, bool prefault=false, char** error=NULL) override {
+    if (!_built) {
+      set_error_from_string(error, "You can't save an index that hasn't been built");
+      return false;
+    }
+    if (_on_disk) {
+      return true;
+    } else {
+      // Delete file if it already exists (See issue #335)
+#ifndef _MSC_VER
+      unlink(filename);
+#else
+      _unlink(filename);
+#endif
+
+      FILE *f = fopen(filename, "wb");
+      if (f == NULL) {
+        set_error_from_errno(error, "Unable to open");
+        return false;
+      }
+
+      if (fwrite(_nodes, _s, _n_nodes, f) != (size_t) _n_nodes) {
+        set_error_from_errno(error, "Unable to write");
+        return false;
+      }
+
+      if (fclose(f) == EOF) {
+        set_error_from_errno(error, "Unable to close");
+        return false;
+      }
+
+      unload();
+      return load(filename, prefault, error);
+    }
+  }
+
+  void reinitialize() {
+    _fd = 0;
+    _nodes = NULL;
+    _loaded = false;
+    _n_items = 0;
+    _n_nodes = 0;
+    _nodes_size = 0;
+    _on_disk = false;
+    _seed = Random::default_seed;
+    _roots.clear();
+    _tree_idx = 0;
+    _rt_order.clear();
+  }
+
+  void unload() override {
+    if (_on_disk && _fd) {
+#ifndef _MSC_VER
+      close(_fd);
+#else
+      _close(_fd);
+#endif
+      munmap(_nodes, _s * _nodes_size);
+    } else {
+      if (_fd) {
+        // we have mmapped data
+#ifndef _MSC_VER
+        close(_fd);
+#else
+        _close(_fd);
+#endif
+        munmap(_nodes, _n_nodes * _s);
+      } else if (_nodes) {
+        // We have heap allocated data
+        free(_nodes);
+      }
+    }
+    reinitialize();
+    if (_verbose) annoylib_showUpdate("unloaded\n");
+  }
+
+  bool load(const char* filename, bool prefault=false, char** error=NULL) override {
+#ifndef _MSC_VER
+    _fd = open(filename, O_RDONLY);
+#else
+    _fd = _open(filename, _O_RDONLY);
+#endif
+    if (_fd == -1) {
+      set_error_from_errno(error, "Unable to open");
+      _fd = 0;
+      return false;
+    }
+    off_t size = lseek_getsize(_fd);
+    if (size == -1) {
+      set_error_from_errno(error, "Unable to get size");
+      return false;
+    } else if (size == 0) {
+      set_error_from_errno(error, "Size of file is zero");
+      return false;
+    } else if (size % _s) {
+      // Something is fishy with this index!
+      set_error_from_errno(error, "Index size is not a multiple of vector size. Ensure you are opening using the same metric you used to create the index.");
+      return false;
+    }
+
+    int flags = MAP_SHARED;
+    if (prefault) {
+#ifdef MAP_POPULATE
+      flags |= MAP_POPULATE;
+#else
+      annoylib_showUpdate("prefault is set to true, but MAP_POPULATE is not defined on this platform");
+#endif
+    }
+    _nodes = (Node*)mmap(0, static_cast<size_t>(size), PROT_READ, flags, _fd, 0);
+    _n_nodes = (S)(size / _s);
+
+    // Find the roots by scanning the end of the file and taking the nodes with most descendants
+    _roots.clear();
+    S m = -1;
+    for (S i = _n_nodes - 1; i >= 0; i--) {
+      S k = _get(i)->n_descendants;
+      if (m == -1 || k == m) {
+        _roots.push_back(i);
+        m = k;
+      } else {
+        break;
+      }
+    }
+    // hacky fix: since the last root precedes the copy of all roots, delete it
+    if (_roots.size() > 1 && _get(_roots.front())->children[0] == _get(_roots.back())->children[0])
+      _roots.pop_back();
+    _loaded = true;
+    _built = true;
+    _n_items = m;
+    if (_verbose) annoylib_showUpdate("found %zu roots with degree %d\n", _roots.size(), m);
+    return true;
+  }
+
+  T get_distance(S i, S j) const override {
+    return D::normalized_distance(D::distance(_get(i), _get(j), _f));
+  }
+
+  void get_nns_by_item(S item, size_t n, int search_k, vector<S>* result, vector<T>* distances) const override {
+    // TODO: handle OOB
+    const Node* m = _get(item);
+    _get_all_nns(m->v, n, search_k, result, distances);
+  }
+
+  void get_nns_by_vector(const T* w, size_t n, int search_k, vector<S>* result, vector<T>* distances) const override {
+    _get_all_nns(w, n, search_k, result, distances);
+  }
+
+  S get_n_items() const override {
+    return _n_items;
+  }
+
+  S get_n_trees() const override {
+    return (S)_roots.size();
+  }
+
+  S get_n_nodes(S root) const override {
+    if (root == 0 || root < _n_items)
+      return 0;
+
+    const Node* m = _get(root);
+    return 1 + get_n_nodes(m->children[0]) + get_n_nodes(m->children[1]);
+  }
+
+  void verbose(bool v) override {
+    _verbose = v;
+  }
+
+  void get_item(S item, T* v) const override {
+    // TODO: handle OOB
+    Node* m = _get(item);
+    memcpy(v, m->v, (_f) * sizeof(T));
+  }
+
+  void set_seed(R seed) override {
+    _seed = seed;
+  }
+
+  void thread_build(int q, ThreadedBuildPolicy& threaded_build_policy) {
+    Random _random(_seed);
+
+    vector<S> thread_roots;
+    while (1) {
+      if (q == -1) {
+        threaded_build_policy.lock_n_nodes();
+        if (_n_nodes >= 2 * _n_items) {
+          threaded_build_policy.unlock_n_nodes();
+          break;
+        }
+        threaded_build_policy.unlock_n_nodes();
+      } else {
+        if (thread_roots.size() >= (size_t)q) {
+          break;
+        }
+      }
+
+      if (_verbose) annoylib_showUpdate("pass %zd...\n", thread_roots.size());
+
+      vector<S> indices;
+      threaded_build_policy.lock_shared_nodes();
+      for (S i = 0; i < _n_items; i++) {
+        if (_get(i)->n_descendants >= 1) { // Issue #223
+          indices.push_back(i);
+        }
+      }
+      threaded_build_policy.unlock_shared_nodes();
+
+      int tree_idx;
+      S root = _make_tree(indices, true, _random, tree_idx, threaded_build_policy);
+      thread_roots.push_back(root);
+
+      threaded_build_policy.lock_root_order();
+      _rt_order.insert(make_pair(tree_idx, root));
+      threaded_build_policy.unlock_root_order();
+    }
+
+    threaded_build_policy.lock_roots();
+    _roots.insert(_roots.end(), thread_roots.begin(), thread_roots.end());
+    threaded_build_policy.unlock_roots();
+  }
+
+protected:
+  void _reallocate_nodes(S n) {
+    const double reallocation_factor = 1.3;
+    S new_nodes_size = std::max(n, (S) ((_nodes_size + 1) * reallocation_factor));
+    void *old = _nodes;
+
+    if (_on_disk) {
+      if (!remap_memory_and_truncate(&_nodes, _fd,
+          static_cast<size_t>(_s) * static_cast<size_t>(_nodes_size),
+          static_cast<size_t>(_s) * static_cast<size_t>(new_nodes_size)) &&
+          _verbose)
+          annoylib_showUpdate("File truncation error\n");
+    } else {
+      _nodes = realloc(_nodes, _s * new_nodes_size);
+      memset((char *) _nodes + (_nodes_size * _s) / sizeof(char), 0, (new_nodes_size - _nodes_size) * _s);
+    }
+
+    _nodes_size = new_nodes_size;
+    if (_verbose) annoylib_showUpdate("Reallocating to %d nodes: old_address=%p, new_address=%p\n", new_nodes_size, old, _nodes);
+  }
+
+  void _allocate_size(S n, ThreadedBuildPolicy& threaded_build_policy) {
+    if (n > _nodes_size) {
+      threaded_build_policy.lock_nodes();
+      _reallocate_nodes(n);
+      threaded_build_policy.unlock_nodes();
+    }
+  }
+
+  void _allocate_size(S n) {
+    if (n > _nodes_size) {
+      _reallocate_nodes(n);
+    }
+  }
+
+  Node* _get(const S i) const {
+    return get_node_ptr<S, Node>(_nodes, _s, i);
+  }
+
+  double _split_imbalance(const vector<S>& left_indices, const vector<S>& right_indices) {
+    double ls = (float)left_indices.size();
+    double rs = (float)right_indices.size();
+    double f = ls / (ls + rs + 1e-9);  // Avoid 0/0
+    return std::max(f, 1-f);
+  }
+
+  S _make_tree(const vector<S>& indices, bool is_root, Random& _random, int& tree_idx, ThreadedBuildPolicy& threaded_build_policy) {
+    // The basic rule is that if we have <= _K items, then it's a leaf node, otherwise it's a split node.
+    // There's some regrettable complications caused by the problem that root nodes have to be "special":
+    // 1. We identify root nodes by the arguable logic that _n_items == n->n_descendants, regardless of how many descendants they actually have
+    // 2. Root nodes with only 1 child need to be a "dummy" parent
+    // 3. Due to the _n_items "hack", we need to be careful with the cases where _n_items <= _K or _n_items > _K
+    if (indices.size() == 1 && !is_root)
+      return indices[0];
+
+    if (indices.size() <= (size_t)_K && (!is_root || (size_t)_n_items <= (size_t)_K || indices.size() == 1)) {
+      threaded_build_policy.lock_n_nodes();
+      _allocate_size(_n_nodes + 1, threaded_build_policy);
+      S item = _n_nodes++;
+      threaded_build_policy.unlock_n_nodes();
+
+      threaded_build_policy.lock_shared_nodes();
+      Node* m = _get(item);
+      m->n_descendants = is_root ? _n_items : (S)indices.size();
+
+      // Using std::copy instead of a loop seems to resolve issues #3 and #13,
+      // probably because gcc 4.8 goes overboard with optimizations.
+      // Using memcpy instead of std::copy for MSVC compatibility. #235
+      // Only copy when necessary to avoid crash in MSVC 9. #293
+      if (!indices.empty())
+        memcpy(m->children, &indices[0], indices.size() * sizeof(S));
+
+      threaded_build_policy.unlock_shared_nodes();
+      return item;
+    }
+
+    // each tree gets its own seed
+    if(is_root)
+    {
+      threaded_build_policy.lock_tree_idx();
+      tree_idx = _tree_idx;
+      _random.set_seed(_seed + 3 * (_tree_idx++));
+      threaded_build_policy.unlock_tree_idx();
+    }
+
+    threaded_build_policy.lock_shared_nodes();
+    vector<Node*> children;
+    for (size_t i = 0; i < indices.size(); i++) {
+      S j = indices[i];
+      Node* n = _get(j);
+      if (n)
+        children.push_back(n);
+    }
+
+    vector<S> children_indices[2];
+    Node* m = (Node*)alloca(_s);
+
+    for (int attempt = 0; attempt < 3; attempt++) {
+      children_indices[0].clear();
+      children_indices[1].clear();
+      D::create_split(children, _f, _s, _random, m);
+
+      for (size_t i = 0; i < indices.size(); i++) {
+        S j = indices[i];
+        Node* n = _get(j);
+        if (n) {
+          bool side = D::side(m, n, _f, _random);
+          children_indices[side].push_back(j);
+        } else {
+          annoylib_showUpdate("No node for index %d?\n", j);
+        }
+      }
+
+      if (_split_imbalance(children_indices[0], children_indices[1]) < 0.95)
+        break;
+    }
+    threaded_build_policy.unlock_shared_nodes();
+
+    // If we didn't find a hyperplane, just randomize sides as a last option
+    while (_split_imbalance(children_indices[0], children_indices[1]) > 0.99) {
+      if (_verbose)
+        annoylib_showUpdate("\tNo hyperplane found (left has %zu children, right has %zu children)\n",
+          children_indices[0].size(), children_indices[1].size());
+
+      children_indices[0].clear();
+      children_indices[1].clear();
+
+      // Set the vector to 0.0
+      for (int z = 0; z < _f; z++)
+        m->v[z] = 0;
+
+      for (size_t i = 0; i < indices.size(); i++) {
+        S j = indices[i];
+        // Just randomize...
+        children_indices[_random.flip()].push_back(j);
+      }
+    }
+
+    int flip = (children_indices[0].size() > children_indices[1].size());
+
+    m->n_descendants = is_root ? _n_items : (S)indices.size();
+    for (int side = 0; side < 2; side++) {
+      // run _make_tree for the smallest child first (for cache locality)
+      m->children[side^flip] = _make_tree(children_indices[side^flip], false, _random, tree_idx, threaded_build_policy);
+    }
+
+    threaded_build_policy.lock_n_nodes();
+    _allocate_size(_n_nodes + 1, threaded_build_policy);
+    S item = _n_nodes++;
+    threaded_build_policy.unlock_n_nodes();
+
+    threaded_build_policy.lock_shared_nodes();
+    memcpy(_get(item), m, _s);
+    threaded_build_policy.unlock_shared_nodes();
+
+    return item;
+  }
+
+  void _get_all_nns(const T* v, size_t n, int search_k, vector<S>* result, vector<T>* distances) const {
+    Node* v_node = (Node *)alloca(_s);
+    D::template zero_value<Node>(v_node);
+    memcpy(v_node->v, v, sizeof(T) * _f);
+    D::init_node(v_node, _f);
+
+    std::priority_queue<pair<T, S> > q;
+
+    if (search_k == -1) {
+      search_k = int(n * _roots.size());
+    }
+
+    for (size_t i = 0; i < _roots.size(); i++) {
+      q.push(make_pair(Distance::template pq_initial_value<T>(), _roots[i]));
+    }
+
+    std::vector<S> nns;
+    while (nns.size() < (size_t)search_k && !q.empty()) {
+      const pair<T, S>& top = q.top();
+      T d = top.first;
+      S i = top.second;
+      Node* nd = _get(i);
+      q.pop();
+      if (nd->n_descendants == 1 && i < _n_items) {
+        nns.push_back(i);
+      } else if (nd->n_descendants <= _K) {
+        const S* dst = nd->children;
+        nns.insert(nns.end(), dst, &dst[nd->n_descendants]);
+      } else {
+        T margin = D::margin(nd, v, _f);
+        q.push(make_pair(D::pq_distance(d, margin, 1), static_cast<S>(nd->children[1])));
+        q.push(make_pair(D::pq_distance(d, margin, 0), static_cast<S>(nd->children[0])));
+      }
+    }
+
+    // Get distances for all items
+    // To avoid calculating distance multiple times for any items, sort by id
+    std::sort(nns.begin(), nns.end());
+    vector<pair<T, S> > nns_dist;
+    S last = -1;
+    for (size_t i = 0; i < nns.size(); i++) {
+      S j = nns[i];
+      if (j == last)
+        continue;
+      last = j;
+      if (_get(j)->n_descendants == 1)  // This is only to guard a really obscure case, #284
+        nns_dist.push_back(make_pair(D::distance(v_node, _get(j), _f), j));
+    }
+
+    size_t m = nns_dist.size();
+    size_t p = n < m ? n : m; // Return this many items
+    std::partial_sort(nns_dist.begin(), nns_dist.begin() + p, nns_dist.end());
+    for (size_t i = 0; i < p; i++) {
+      if (distances)
+        distances->push_back(D::normalized_distance(nns_dist[i].first));
+      result->push_back(nns_dist[i].second);
+    }
+  }
+};
+
+class AnnoyIndexSingleThreadedBuildPolicy {
+public:
+  template<typename S, typename T, typename D, typename Random>
+  static void build(AnnoyIndex<S, T, D, Random, AnnoyIndexSingleThreadedBuildPolicy>* annoy, int q, int /*n_threads*/) {
+    AnnoyIndexSingleThreadedBuildPolicy threaded_build_policy;
+    annoy->thread_build(q, threaded_build_policy);
+  }
+
+  void lock_n_nodes() {}
+  void unlock_n_nodes() {}
+
+  void lock_nodes() {}
+  void unlock_nodes() {}
+
+  void lock_shared_nodes() {}
+  void unlock_shared_nodes() {}
+
+  void lock_roots() {}
+  void unlock_roots() {}
+
+  void lock_tree_idx() {}
+  void unlock_tree_idx() {}
+
+  void lock_root_order() {}
+  void unlock_root_order() {}
+};
+
+#ifdef ANNOYLIB_MULTITHREADED_BUILD
+class AnnoyIndexMultiThreadedBuildPolicy {
+private:
+  std::shared_timed_mutex nodes_mutex;
+  std::mutex n_nodes_mutex;
+  std::mutex roots_mutex;
+  std::mutex tree_idx_mutex;
+  std::mutex root_order_mutex;
+
+public:
+  template<typename S, typename T, typename D, typename Random>
+  static void build(AnnoyIndex<S, T, D, Random, AnnoyIndexMultiThreadedBuildPolicy>* annoy, int q, int n_threads) {
+    AnnoyIndexMultiThreadedBuildPolicy threaded_build_policy;
+    if (n_threads == -1) {
+      // If the hardware_concurrency() value is not well defined or not computable, it returns 0.
+      // We guard against this by using at least 1 thread.
+      n_threads = std::max(1, (int)std::thread::hardware_concurrency());
+      // n_threads = 1;
+    }
+
+    vector<std::thread> threads(n_threads);
+
+    for (int thread_idx = 0; thread_idx < n_threads; thread_idx++) {
+      int trees_per_thread = q == -1 ? -1 : (int)floor((q + thread_idx) / n_threads);
+
+      threads[thread_idx] = std::thread(
+        &AnnoyIndex<S, T, D, Random, AnnoyIndexMultiThreadedBuildPolicy>::thread_build,
+        annoy,
+        trees_per_thread,
+        std::ref(threaded_build_policy)
+      );
+    }
+
+    for (auto& thread : threads) {
+      thread.join();
+    }
+  }
+
+  void lock_n_nodes() {
+    n_nodes_mutex.lock();
+  }
+  void unlock_n_nodes() {
+    n_nodes_mutex.unlock();
+  }
+
+  void lock_nodes() {
+    nodes_mutex.lock();
+  }
+  void unlock_nodes() {
+    nodes_mutex.unlock();
+  }
+
+  void lock_shared_nodes() {
+    nodes_mutex.lock_shared();
+  }
+  void unlock_shared_nodes() {
+    nodes_mutex.unlock_shared();
+  }
+
+  void lock_roots() {
+    roots_mutex.lock();
+  }
+  void unlock_roots() {
+    roots_mutex.unlock();
+  }
+
+  void lock_tree_idx() {
+    tree_idx_mutex.lock();
+  }
+  void unlock_tree_idx() {
+    tree_idx_mutex.unlock();
+  }
+
+  void lock_root_order() {
+    root_order_mutex.lock();
+  }
+  void unlock_root_order() {
+    root_order_mutex.unlock();
+  }
+};
+#endif
+
+}
+
+#endif
+// vim: tabstop=2 shiftwidth=2
diff --git a/upstream/opencv/modules/features/3rdparty/annoy/mman.h b/upstream/opencv/modules/features/3rdparty/annoy/mman.h
new file mode 100644
index 0000000..1a04e0a
--- /dev/null
+++ b/upstream/opencv/modules/features/3rdparty/annoy/mman.h
@@ -0,0 +1,264 @@
+
+// This is from https://code.google.com/p/mman-win32/
+//
+// Licensed under MIT
+
+#ifndef _MMAN_WIN32_H
+#define _MMAN_WIN32_H
+
+#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.
+#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
+#endif
+
+#include <sys/types.h>
+#include <windows.h>
+#include <memoryapi.h>
+#include <errno.h>
+#include <io.h>
+
+#define PROT_NONE       0
+#define PROT_READ       1
+#define PROT_WRITE      2
+#define PROT_EXEC       4
+
+#define MAP_FILE        0
+#define MAP_SHARED      1
+#define MAP_PRIVATE     2
+#define MAP_TYPE        0xf
+#define MAP_FIXED       0x10
+#define MAP_ANONYMOUS   0x20
+#define MAP_ANON        MAP_ANONYMOUS
+
+#define MAP_FAILED      ((void *)-1)
+
+/* Flags for msync. */
+#define MS_ASYNC        1
+#define MS_SYNC         2
+#define MS_INVALIDATE   4
+
+#ifndef FILE_MAP_EXECUTE
+#define FILE_MAP_EXECUTE    0x0020
+#endif
+
+static int __map_mman_error(const DWORD err, const int /*deferr*/)
+{
+    if (err == 0)
+        return 0;
+    //TODO: implement
+    return err;
+}
+
+static DWORD __map_mmap_prot_page(const int prot)
+{
+    DWORD protect = 0;
+
+    if (prot == PROT_NONE)
+        return protect;
+
+    if ((prot & PROT_EXEC) != 0)
+    {
+        protect = ((prot & PROT_WRITE) != 0) ?
+                    PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ;
+    }
+    else
+    {
+        protect = ((prot & PROT_WRITE) != 0) ?
+                    PAGE_READWRITE : PAGE_READONLY;
+    }
+
+    return protect;
+}
+
+static DWORD __map_mmap_prot_file(const int prot)
+{
+    DWORD desiredAccess = 0;
+
+    if (prot == PROT_NONE)
+        return desiredAccess;
+
+    if ((prot & PROT_READ) != 0)
+        desiredAccess |= FILE_MAP_READ;
+    if ((prot & PROT_WRITE) != 0)
+        desiredAccess |= FILE_MAP_WRITE;
+    if ((prot & PROT_EXEC) != 0)
+        desiredAccess |= FILE_MAP_EXECUTE;
+
+    return desiredAccess;
+}
+
+inline void* mmap(void * /*addr*/, size_t len, int prot, int flags, int fildes, off_t off)
+{
+    HANDLE fm, h;
+
+    void * map = MAP_FAILED;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4293)
+#endif
+
+    const DWORD dwFileOffsetLow = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)off : (DWORD)(off & 0xFFFFFFFFL);
+    const DWORD dwFileOffsetHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((off >> 32) & 0xFFFFFFFFL);
+    const DWORD protect = __map_mmap_prot_page(prot);
+    const DWORD desiredAccess = __map_mmap_prot_file(prot);
+
+    const off_t maxSize = off + (off_t)len;
+
+    const DWORD dwMaxSizeLow = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)maxSize : (DWORD)(maxSize & 0xFFFFFFFFL);
+    const DWORD dwMaxSizeHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((maxSize >> 32) & 0xFFFFFFFFL);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    errno = 0;
+
+    if (len == 0
+        /* Unsupported flag combinations */
+        || (flags & MAP_FIXED) != 0
+        /* Usupported protection combinations */
+        || prot == PROT_EXEC)
+    {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+
+    h = ((flags & MAP_ANONYMOUS) == 0) ?
+                    (HANDLE)_get_osfhandle(fildes) : INVALID_HANDLE_VALUE;
+
+    if ((flags & MAP_ANONYMOUS) == 0 && h == INVALID_HANDLE_VALUE)
+    {
+        errno = EBADF;
+        return MAP_FAILED;
+    }
+
+    fm = CreateFileMapping(h, NULL, protect, dwMaxSizeHigh, dwMaxSizeLow, NULL);
+
+    if (fm == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+
+    map = MapViewOfFile(fm, desiredAccess, dwFileOffsetHigh, dwFileOffsetLow, len);
+
+    CloseHandle(fm);
+
+    if (map == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+
+    return map;
+}
+
+inline int munmap(void *addr, size_t /*len*/)
+{
+    if (UnmapViewOfFile(addr))
+        return 0;
+
+    errno =  __map_mman_error(GetLastError(), EPERM);
+
+    return -1;
+}
+
+inline int mprotect(void *addr, size_t len, int prot)
+{
+    DWORD newProtect = __map_mmap_prot_page(prot);
+    DWORD oldProtect = 0;
+
+    if (VirtualProtect(addr, len, newProtect, &oldProtect))
+        return 0;
+
+    errno =  __map_mman_error(GetLastError(), EPERM);
+
+    return -1;
+}
+
+inline int msync(void *addr, size_t len, int /*flags*/)
+{
+    if (FlushViewOfFile(addr, len))
+        return 0;
+
+    errno =  __map_mman_error(GetLastError(), EPERM);
+
+    return -1;
+}
+
+#pragma region Desktop Family or OneCore Family
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
+
+WINBASEAPI
+BOOL
+WINAPI
+VirtualLock(
+    _In_ LPVOID lpAddress,
+    _In_ SIZE_T dwSize
+);
+
+WINBASEAPI
+BOOL
+WINAPI
+VirtualUnlock(
+    _In_ LPVOID lpAddress,
+    _In_ SIZE_T dwSize
+);
+
+#endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
+
+inline int mlock(const void *addr, size_t len)
+{
+    if (VirtualLock((LPVOID)addr, len))
+        return 0;
+
+    errno =  __map_mman_error(GetLastError(), EPERM);
+
+    return -1;
+}
+
+inline int munlock(const void *addr, size_t len)
+{
+    if (VirtualUnlock((LPVOID)addr, len))
+        return 0;
+
+    errno =  __map_mman_error(GetLastError(), EPERM);
+
+    return -1;
+}
+
+#if !defined(__MINGW32__)
+inline int ftruncate(const int fd, const int64_t size) {
+    if (fd < 0) {
+        errno = EBADF;
+        return -1;
+    }
+
+    HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+    LARGE_INTEGER li_start, li_size;
+    li_start.QuadPart = static_cast<int64_t>(0);
+    li_size.QuadPart = size;
+    if (SetFilePointerEx(h, li_start, NULL, FILE_CURRENT) == ~0 ||
+        SetFilePointerEx(h, li_size, NULL, FILE_BEGIN) == ~0 ||
+        !SetEndOfFile(h)) {
+        unsigned long error = GetLastError();
+        fprintf(stderr, "I/O error while truncating: %lu\n", error);
+        switch (error) {
+            case ERROR_INVALID_HANDLE:
+                errno = EBADF;
+                break;
+            default:
+                errno = EIO;
+                break;
+        }
+        return -1;
+    }
+    return 0;
+}
+#endif
+
+#endif
diff --git a/upstream/opencv/modules/features/3rdparty/mscr/chi_table.h b/upstream/opencv/modules/features/3rdparty/mscr/chi_table.h
new file mode 100644
index 0000000..c0e9bae
--- /dev/null
+++ b/upstream/opencv/modules/features/3rdparty/mscr/chi_table.h
@@ -0,0 +1,135 @@
+/*
+**
+**                           License Agreement
+**                           For chi_table.h
+**
+** Copyright (C) 2007 Per-Erik Forssen, all rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+**
+**   * Redistribution's of source code must retain the above copyright notice,
+**     this list of conditions and the following disclaimer.
+**
+**   * Redistribution's in binary form must reproduce the above copyright notice,
+**     this list of conditions and the following disclaimer in the documentation
+**     and/or other materials provided with the distribution.
+**
+**   * The name of the copyright holders may not be used to endorse or promote products
+**     derived from this software without specific prior written permission.
+**
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+**
+** Content origin: http://users.isy.liu.se/cvl/perfo/software/chi_table.h
+*/
+#define TABLE_SIZE 400
+
+static double chitab3[]={0,  0.0150057,  0.0239478,  0.0315227,
+                  0.0383427,  0.0446605,  0.0506115,  0.0562786,
+                  0.0617174,  0.0669672,  0.0720573,  0.0770099,
+                  0.081843,  0.0865705,  0.0912043,  0.0957541,
+                  0.100228,  0.104633,  0.108976,  0.113261,
+                  0.117493,  0.121676,  0.125814,  0.12991,
+                  0.133967,  0.137987,  0.141974,  0.145929,
+                  0.149853,  0.15375,  0.15762,  0.161466,
+                  0.165287,  0.169087,  0.172866,  0.176625,
+                  0.180365,  0.184088,  0.187794,  0.191483,
+                  0.195158,  0.198819,  0.202466,  0.2061,
+                  0.209722,  0.213332,  0.216932,  0.220521,
+                  0.2241,  0.22767,  0.231231,  0.234783,
+                  0.238328,  0.241865,  0.245395,  0.248918,
+                  0.252435,  0.255947,  0.259452,  0.262952,
+                  0.266448,  0.269939,  0.273425,  0.276908,
+                  0.280386,  0.283862,  0.287334,  0.290803,
+                  0.29427,  0.297734,  0.301197,  0.304657,
+                  0.308115,  0.311573,  0.315028,  0.318483,
+                  0.321937,  0.32539,  0.328843,  0.332296,
+                  0.335749,  0.339201,  0.342654,  0.346108,
+                  0.349562,  0.353017,  0.356473,  0.35993,
+                  0.363389,  0.366849,  0.37031,  0.373774,
+                  0.377239,  0.380706,  0.384176,  0.387648,
+                  0.391123,  0.3946,  0.39808,  0.401563,
+                  0.405049,  0.408539,  0.412032,  0.415528,
+                  0.419028,  0.422531,  0.426039,  0.429551,
+                  0.433066,  0.436586,  0.440111,  0.44364,
+                  0.447173,  0.450712,  0.454255,  0.457803,
+                  0.461356,  0.464915,  0.468479,  0.472049,
+                  0.475624,  0.479205,  0.482792,  0.486384,
+                  0.489983,  0.493588,  0.4972,  0.500818,
+                  0.504442,  0.508073,  0.511711,  0.515356,
+                  0.519008,  0.522667,  0.526334,  0.530008,
+                  0.533689,  0.537378,  0.541075,  0.54478,
+                  0.548492,  0.552213,  0.555942,  0.55968,
+                  0.563425,  0.56718,  0.570943,  0.574715,
+                  0.578497,  0.582287,  0.586086,  0.589895,
+                  0.593713,  0.597541,  0.601379,  0.605227,
+                  0.609084,  0.612952,  0.61683,  0.620718,
+                  0.624617,  0.628526,  0.632447,  0.636378,
+                  0.64032,  0.644274,  0.648239,  0.652215,
+                  0.656203,  0.660203,  0.664215,  0.668238,
+                  0.672274,  0.676323,  0.680384,  0.684457,
+                  0.688543,  0.692643,  0.696755,  0.700881,
+                  0.70502,  0.709172,  0.713339,  0.717519,
+                  0.721714,  0.725922,  0.730145,  0.734383,
+                  0.738636,  0.742903,  0.747185,  0.751483,
+                  0.755796,  0.760125,  0.76447,  0.768831,
+                  0.773208,  0.777601,  0.782011,  0.786438,
+                  0.790882,  0.795343,  0.799821,  0.804318,
+                  0.808831,  0.813363,  0.817913,  0.822482,
+                  0.827069,  0.831676,  0.836301,  0.840946,
+                  0.84561,  0.850295,  0.854999,  0.859724,
+                  0.864469,  0.869235,  0.874022,  0.878831,
+                  0.883661,  0.888513,  0.893387,  0.898284,
+                  0.903204,  0.908146,  0.913112,  0.918101,
+                  0.923114,  0.928152,  0.933214,  0.938301,
+                  0.943413,  0.94855,  0.953713,  0.958903,
+                  0.964119,  0.969361,  0.974631,  0.979929,
+                  0.985254,  0.990608,  0.99599,  1.0014,
+                  1.00684,  1.01231,  1.01781,  1.02335,
+                  1.02891,  1.0345,  1.04013,  1.04579,
+                  1.05148,  1.05721,  1.06296,  1.06876,
+                  1.07459,  1.08045,  1.08635,  1.09228,
+                  1.09826,  1.10427,  1.11032,  1.1164,
+                  1.12253,  1.1287,  1.1349,  1.14115,
+                  1.14744,  1.15377,  1.16015,  1.16656,
+                  1.17303,  1.17954,  1.18609,  1.19269,
+                  1.19934,  1.20603,  1.21278,  1.21958,
+                  1.22642,  1.23332,  1.24027,  1.24727,
+                  1.25433,  1.26144,  1.26861,  1.27584,
+                  1.28312,  1.29047,  1.29787,  1.30534,
+                  1.31287,  1.32046,  1.32812,  1.33585,
+                  1.34364,  1.3515,  1.35943,  1.36744,
+                  1.37551,  1.38367,  1.39189,  1.4002,
+                  1.40859,  1.41705,  1.42561,  1.43424,
+                  1.44296,  1.45177,  1.46068,  1.46967,
+                  1.47876,  1.48795,  1.49723,  1.50662,
+                  1.51611,  1.52571,  1.53541,  1.54523,
+                  1.55517,  1.56522,  1.57539,  1.58568,
+                  1.59611,  1.60666,  1.61735,  1.62817,
+                  1.63914,  1.65025,  1.66152,  1.67293,
+                  1.68451,  1.69625,  1.70815,  1.72023,
+                  1.73249,  1.74494,  1.75757,  1.77041,
+                  1.78344,  1.79669,  1.81016,  1.82385,
+                  1.83777,  1.85194,  1.86635,  1.88103,
+                  1.89598,  1.91121,  1.92674,  1.94257,
+                  1.95871,  1.97519,  1.99201,  2.0092,
+                  2.02676,  2.04471,  2.06309,  2.08189,
+                  2.10115,  2.12089,  2.14114,  2.16192,
+                  2.18326,  2.2052,  2.22777,  2.25101,
+                  2.27496,  2.29966,  2.32518,  2.35156,
+                  2.37886,  2.40717,  2.43655,  2.46709,
+                  2.49889,  2.53206,  2.56673,  2.60305,
+                  2.64117,  2.6813,  2.72367,  2.76854,
+                  2.81623,  2.86714,  2.92173,  2.98059,
+                  3.04446,  3.1143,  3.19135,  3.27731,
+                  3.37455,  3.48653,  3.61862,  3.77982,
+                  3.98692,  4.2776,  4.77167,  133.333 };
diff --git a/upstream/opencv/modules/features/3rdparty/mscr/chi_table_LICENSE.txt b/upstream/opencv/modules/features/3rdparty/mscr/chi_table_LICENSE.txt
new file mode 100644
index 0000000..66b272d
--- /dev/null
+++ b/upstream/opencv/modules/features/3rdparty/mscr/chi_table_LICENSE.txt
@@ -0,0 +1,28 @@
+                          License Agreement
+                          For chi_table.h
+
+Copyright (C) 2007 Per-Erik Forssen, all rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  * Redistribution's of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+  * Redistribution's in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * The name of the copyright holders may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall the Intel Corporation or contributors be liable for any direct,
+indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused
+and on any theory of liability, whether in contract, strict liability,
+or tort (including negligence or otherwise) arising in any way out of
+the use of this software, even if advised of the possibility of such damage.
diff --git a/upstream/opencv/modules/features/CMakeLists.txt b/upstream/opencv/modules/features/CMakeLists.txt
new file mode 100644
index 0000000..d471a92
--- /dev/null
+++ b/upstream/opencv/modules/features/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(the_description "Features Framework")
+
+ocv_add_dispatched_file(sift SSE4_1 AVX2 AVX512_SKX)
+
+set(debug_modules "")
+if(DEBUG_opencv_features)
+  list(APPEND debug_modules opencv_highgui)
+endif()
+ocv_define_module(features opencv_imgproc opencv_geometry ${debug_modules} OPTIONAL opencv_flann opencv_dnn WRAP java objc python js)
+
+ocv_install_3rdparty_licenses(mscr "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/mscr/chi_table_LICENSE.txt")
+ocv_install_3rdparty_licenses(annoylib "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/annoy/LICENSE")
diff --git a/upstream/opencv/modules/features/include/opencv2/features.hpp b/upstream/opencv/modules/features/include/opencv2/features.hpp
new file mode 100644
index 0000000..55519cc
--- /dev/null
+++ b/upstream/opencv/modules/features/include/opencv2/features.hpp
@@ -0,0 +1,1560 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_FEATURES_HPP
+#define OPENCV_FEATURES_HPP
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core.hpp"
+
+#ifdef HAVE_OPENCV_FLANN
+#include "opencv2/flann/miniflann.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+/**
+  @defgroup features Features Framework
+  @{
+    @defgroup features_main Feature Detection and Description
+    @defgroup features_match Descriptor Matchers
+
+    Matchers of keypoint descriptors in OpenCV have wrappers with a common interface that enables
+    you to easily switch between different algorithms solving the same problem. This section is
+    devoted to matching descriptors that are represented as vectors in a multidimensional space.
+    All objects that implement vector descriptor matchers inherit the DescriptorMatcher interface.
+
+    @defgroup features_draw Drawing Function of Keypoints and Matches
+
+    @defgroup feature_hal Hardware Acceleration Layer
+    @{
+        @defgroup features_hal_interface Interface
+    @}
+
+    @defgroup features_annoy Approximate Nearest Neighbors Search in Multi-Dimensional Spaces
+
+    This section documents OpenCV's interface to the Annoy. Annoy (Approximate Nearest Neighbors Oh Yeah)
+    is a library to search for points in space that are close to a given query point. It also creates
+    large read-only file-based data structures that are mmapped into memory so that many processes may
+    share the same data.
+  @}
+ */
+
+namespace cv
+{
+
+//! @addtogroup features_main
+//! @{
+
+// //! writes vector of keypoints to the file storage
+// CV_EXPORTS void write(FileStorage& fs, const String& name, const std::vector<KeyPoint>& keypoints);
+// //! reads vector of keypoints from the specified file storage node
+// CV_EXPORTS void read(const FileNode& node, CV_OUT std::vector<KeyPoint>& keypoints);
+
+/** @brief A class filters a vector of keypoints.
+
+ Because now it is difficult to provide a convenient interface for all usage scenarios of the
+ keypoints filter class, it has only several needed by now static methods.
+ */
+class CV_EXPORTS KeyPointsFilter
+{
+public:
+    KeyPointsFilter(){}
+
+    /*
+     * Remove keypoints within borderPixels of an image edge.
+     */
+    static void runByImageBorder( std::vector<KeyPoint>& keypoints, Size imageSize, int borderSize );
+    /*
+     * Remove keypoints of sizes out of range.
+     */
+    static void runByKeypointSize( std::vector<KeyPoint>& keypoints, float minSize,
+                                   float maxSize=FLT_MAX );
+    /*
+     * Remove keypoints from some image by mask for pixels of this image.
+     */
+    static void runByPixelsMask( std::vector<KeyPoint>& keypoints, const Mat& mask );
+    /*
+     * Remove objects from some image and a vector of points by mask for pixels of this image
+     */
+    static void runByPixelsMask2VectorPoint(std::vector<KeyPoint> &keypoints, std::vector<std::vector<Point> > &removeFrom, const Mat &mask);
+    /*
+     * Remove duplicated keypoints.
+     */
+    static void removeDuplicated( std::vector<KeyPoint>& keypoints );
+    /*
+     * Remove duplicated keypoints and sort the remaining keypoints
+     */
+    static void removeDuplicatedSorted( std::vector<KeyPoint>& keypoints );
+
+    /*
+     * Retain the specified number of the best keypoints (according to the response)
+     */
+    static void retainBest( std::vector<KeyPoint>& keypoints, int npoints );
+};
+
+/** @brief Determines strong corners on an image.
+
+The function finds the most prominent corners in the image or in the specified image region, as
+described in @cite Shi94
+
+-   Function calculates the corner quality measure at every source image pixel using the
+    #cornerMinEigenVal or #cornerHarris .
+-   Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are
+    retained).
+-   The corners with the minimal eigenvalue less than
+    \f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are rejected.
+-   The remaining corners are sorted by the quality measure in the descending order.
+-   Function throws away each corner for which there is a stronger corner at a distance less than
+    maxDistance.
+
+The function can be used to initialize a point-based tracker of an object.
+
+@note If the function is called with different values A and B of the parameter qualityLevel , and
+A \> B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector
+with qualityLevel=B .
+
+@param image Input 8-bit or floating-point 32-bit, single-channel image.
+@param corners Output vector of detected corners.
+@param maxCorners Maximum number of corners to return. If there are more corners than are found,
+the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set
+and all detected corners are returned.
+@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The
+parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue
+(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the
+quality measure less than the product are rejected. For example, if the best corner has the
+quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure
+less than 15 are rejected.
+@param minDistance Minimum possible Euclidean distance between the returned corners.
+@param mask Optional region of interest. If the image is not empty (it needs to have the type
+CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
+@param blockSize Size of an average block for computing a derivative covariation matrix over each
+pixel neighborhood. See cornerEigenValsAndVecs .
+@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris)
+or #cornerMinEigenVal.
+@param k Free parameter of the Harris detector.
+
+@sa  cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,
+ */
+
+CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
+                                     int maxCorners, double qualityLevel, double minDistance,
+                                     InputArray mask = noArray(), int blockSize = 3,
+                                     bool useHarrisDetector = false, double k = 0.04 );
+
+CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
+                                     int maxCorners, double qualityLevel, double minDistance,
+                                     InputArray mask, int blockSize,
+                                     int gradientSize, bool useHarrisDetector = false,
+                                     double k = 0.04 );
+
+/** @brief Same as above, but returns also quality measure of the detected corners.
+
+@param image Input 8-bit or floating-point 32-bit, single-channel image.
+@param corners Output vector of detected corners.
+@param maxCorners Maximum number of corners to return. If there are more corners than are found,
+the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set
+and all detected corners are returned.
+@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The
+parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue
+(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the
+quality measure less than the product are rejected. For example, if the best corner has the
+quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure
+less than 15 are rejected.
+@param minDistance Minimum possible Euclidean distance between the returned corners.
+@param mask Region of interest. If the image is not empty (it needs to have the type
+CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
+@param cornersQuality Output vector of quality measure of the detected corners.
+@param blockSize Size of an average block for computing a derivative covariation matrix over each
+pixel neighborhood. See cornerEigenValsAndVecs .
+@param gradientSize Aperture parameter for the Sobel operator used for derivatives computation.
+See cornerEigenValsAndVecs .
+@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris)
+or #cornerMinEigenVal.
+@param k Free parameter of the Harris detector.
+ */
+CV_EXPORTS CV_WRAP_AS(goodFeaturesToTrackWithQuality) void goodFeaturesToTrack(
+        InputArray image, OutputArray corners,
+        int maxCorners, double qualityLevel, double minDistance,
+        InputArray mask, OutputArray cornersQuality, int blockSize = 3,
+        int gradientSize = 3, bool useHarrisDetector = false, double k = 0.04);
+
+/************************************ Base Classes ************************************/
+
+/** @brief Abstract base class for 2D image feature detectors and descriptor extractors
+*/
+class CV_EXPORTS_W Feature2D : public Algorithm
+{
+public:
+    virtual ~Feature2D();
+
+    /** @brief Detects keypoints in an image (first variant) or image set (second variant).
+
+    @param image Image.
+    @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
+    of keypoints detected in images[i] .
+    @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
+    matrix with non-zero values in the region of interest.
+     */
+    CV_WRAP virtual void detect( InputArray image,
+                                 CV_OUT std::vector<KeyPoint>& keypoints,
+                                 InputArray mask=noArray() );
+
+    /** @overload
+    @param images Image set.
+    @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
+    of keypoints detected in images[i] .
+    @param masks Masks for each input image specifying where to look for keypoints (optional).
+    masks[i] is a mask for images[i].
+    */
+    CV_WRAP virtual void detect( InputArrayOfArrays images,
+                         CV_OUT std::vector<std::vector<KeyPoint> >& keypoints,
+                         InputArrayOfArrays masks=noArray() );
+
+    /** @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
+    (second variant).
+
+    @param image Image.
+    @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
+    computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
+    with several dominant orientations (for each orientation).
+    @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
+    descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
+    descriptor for keypoint j-th keypoint.
+     */
+    CV_WRAP virtual void compute( InputArray image,
+                                  CV_OUT CV_IN_OUT std::vector<KeyPoint>& keypoints,
+                                  OutputArray descriptors );
+
+    /** @overload
+
+    @param images Image set.
+    @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
+    computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
+    with several dominant orientations (for each orientation).
+    @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
+    descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
+    descriptor for keypoint j-th keypoint.
+    */
+    CV_WRAP virtual void compute( InputArrayOfArrays images,
+                          CV_OUT CV_IN_OUT std::vector<std::vector<KeyPoint> >& keypoints,
+                          OutputArrayOfArrays descriptors );
+
+    /** Detects keypoints and computes the descriptors */
+    CV_WRAP virtual void detectAndCompute( InputArray image, InputArray mask,
+                                           CV_OUT std::vector<KeyPoint>& keypoints,
+                                           OutputArray descriptors,
+                                           bool useProvidedKeypoints=false );
+
+    CV_WRAP virtual int descriptorSize() const;
+    CV_WRAP virtual int descriptorType() const;
+    CV_WRAP virtual int defaultNorm() const;
+
+    CV_WRAP void write( const String& fileName ) const;
+
+    CV_WRAP void read( const String& fileName );
+
+    virtual void write( FileStorage&) const CV_OVERRIDE;
+
+    // see corresponding cv::Algorithm method
+    CV_WRAP virtual void read( const FileNode&) CV_OVERRIDE;
+
+    //! Return true if detector object is empty
+    CV_WRAP virtual bool empty() const CV_OVERRIDE;
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+
+    // see corresponding cv::Algorithm method
+    CV_WRAP inline void write(FileStorage& fs, const String& name) const { Algorithm::write(fs, name); }
+};
+
+/** Feature detectors in OpenCV have wrappers with a common interface that enables you to easily switch
+between different algorithms solving the same problem. All objects that implement keypoint detectors
+inherit the FeatureDetector interface. */
+typedef Feature2D FeatureDetector;
+
+/** Extractors of keypoint descriptors in OpenCV have wrappers with a common interface that enables you
+to easily switch between different algorithms solving the same problem. This section is devoted to
+computing descriptors represented as vectors in a multidimensional space. All objects that implement
+the vector descriptor extractors inherit the DescriptorExtractor interface.
+ */
+typedef Feature2D DescriptorExtractor;
+
+
+/** @brief Class for implementing the wrapper which makes detectors and extractors to be affine invariant,
+described as ASIFT in @cite YM11 .
+*/
+class CV_EXPORTS_W AffineFeature : public Feature2D
+{
+public:
+    /**
+    @param backend The detector/extractor you want to use as backend.
+    @param maxTilt The highest power index of tilt factor. 5 is used in the paper as tilt sampling range n.
+    @param minTilt The lowest power index of tilt factor. 0 is used in the paper.
+    @param tiltStep Tilt sampling step \f$\delta_t\f$ in Algorithm 1 in the paper.
+    @param rotateStepBase Rotation sampling step factor b in Algorithm 1 in the paper.
+    */
+    CV_WRAP static Ptr<AffineFeature> create(const Ptr<Feature2D>& backend,
+        int maxTilt = 5, int minTilt = 0, float tiltStep = 1.4142135623730951f, float rotateStepBase = 72);
+
+    CV_WRAP virtual void setViewParams(const std::vector<float>& tilts, const std::vector<float>& rolls) = 0;
+    CV_WRAP virtual void getViewParams(std::vector<float>& tilts, std::vector<float>& rolls) const = 0;
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+typedef AffineFeature AffineFeatureDetector;
+typedef AffineFeature AffineDescriptorExtractor;
+
+
+/** @brief Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform
+(SIFT) algorithm by D. Lowe @cite Lowe04 .
+*/
+class CV_EXPORTS_W SIFT : public Feature2D
+{
+public:
+    /**
+    @param nfeatures The number of best features to retain. The features are ranked by their scores
+    (measured in SIFT algorithm as the local contrast)
+
+    @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The
+    number of octaves is computed automatically from the image resolution.
+
+    @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform
+    (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
+
+    @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When
+    nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set
+    this argument to 0.09.
+
+    @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning
+    is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are
+    filtered out (more features are retained).
+
+    @param sigma The sigma of the Gaussian applied to the input image at the octave \#0. If your image
+    is captured with a weak camera with soft lenses, you might want to reduce the number.
+
+    @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps
+    index \f$\texttt{x}\f$ to \f$\texttt{2x}\f$. This prevents localization bias. The option
+    is disabled by default.
+    */
+    CV_WRAP static Ptr<SIFT> create(int nfeatures = 0, int nOctaveLayers = 3,
+        double contrastThreshold = 0.04, double edgeThreshold = 10,
+        double sigma = 1.6, bool enable_precise_upscale = false);
+
+    /** @brief Create SIFT with specified descriptorType.
+    @param nfeatures The number of best features to retain. The features are ranked by their scores
+    (measured in SIFT algorithm as the local contrast)
+
+    @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The
+    number of octaves is computed automatically from the image resolution.
+
+    @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform
+    (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
+
+    @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When
+    nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set
+    this argument to 0.09.
+
+    @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning
+    is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are
+    filtered out (more features are retained).
+
+    @param sigma The sigma of the Gaussian applied to the input image at the octave \#0. If your image
+    is captured with a weak camera with soft lenses, you might want to reduce the number.
+
+    @param descriptorType The type of descriptors. Only CV_32F and CV_8U are supported.
+
+    @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps
+    index \f$\texttt{x}\f$ to \f$\texttt{2x}\f$. This prevents localization bias. The option
+    is disabled by default.
+    */
+    CV_WRAP static Ptr<SIFT> create(int nfeatures, int nOctaveLayers,
+        double contrastThreshold, double edgeThreshold,
+        double sigma, int descriptorType, bool enable_precise_upscale = false);
+
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+
+    CV_WRAP virtual void setNFeatures(int maxFeatures) = 0;
+    CV_WRAP virtual int getNFeatures() const = 0;
+
+    CV_WRAP virtual void setNOctaveLayers(int nOctaveLayers) = 0;
+    CV_WRAP virtual int getNOctaveLayers() const = 0;
+
+    CV_WRAP virtual void setContrastThreshold(double contrastThreshold) = 0;
+    CV_WRAP virtual double getContrastThreshold() const = 0;
+
+    CV_WRAP virtual void setEdgeThreshold(double edgeThreshold) = 0;
+    CV_WRAP virtual double getEdgeThreshold() const = 0;
+
+    CV_WRAP virtual void setSigma(double sigma) = 0;
+    CV_WRAP virtual double getSigma() const = 0;
+};
+
+typedef SIFT SiftFeatureDetector;
+typedef SIFT SiftDescriptorExtractor;
+
+
+/** @brief Class implementing the ORB (*oriented BRIEF*) keypoint detector and descriptor extractor
+
+described in @cite RRKB11 . The algorithm uses FAST in pyramids to detect stable keypoints, selects
+the strongest features using FAST or Harris response, finds their orientation using first-order
+moments and computes the descriptors using BRIEF (where the coordinates of random point pairs (or
+k-tuples) are rotated according to the measured orientation).
+ */
+class CV_EXPORTS_W ORB : public Feature2D
+{
+public:
+    enum ScoreType { HARRIS_SCORE=0, FAST_SCORE=1 };
+    static const int kBytes = 32;
+
+    /** @brief The ORB constructor
+
+    @param nfeatures The maximum number of features to retain.
+    @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical
+    pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor
+    will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor
+    will mean that to cover certain scale range you will need more pyramid levels and so the speed
+    will suffer.
+    @param nlevels The number of pyramid levels. The smallest level will have linear size equal to
+    input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).
+    @param edgeThreshold This is size of the border where the features are not detected. It should
+    roughly match the patchSize parameter.
+    @param firstLevel The level of pyramid to put source image to. Previous layers are filled
+    with upscaled source image.
+    @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The
+    default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,
+    so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3
+    random points (of course, those point coordinates are random, but they are generated from the
+    pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel
+    rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such
+    output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,
+    denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each
+    bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
+    @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features
+    (the score is written to KeyPoint::score and is used to retain best nfeatures features);
+    FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,
+    but it is a little faster to compute.
+    @param patchSize size of the patch used by the oriented BRIEF descriptor. Of course, on smaller
+    pyramid layers the perceived image area covered by a feature will be larger.
+    @param fastThreshold the fast threshold
+     */
+    CV_WRAP static Ptr<ORB> create(int nfeatures=500, float scaleFactor=1.2f, int nlevels=8, int edgeThreshold=31,
+        int firstLevel=0, int WTA_K=2, ORB::ScoreType scoreType=ORB::HARRIS_SCORE, int patchSize=31, int fastThreshold=20);
+
+    CV_WRAP virtual void setMaxFeatures(int maxFeatures) = 0;
+    CV_WRAP virtual int getMaxFeatures() const = 0;
+
+    CV_WRAP virtual void setScaleFactor(double scaleFactor) = 0;
+    CV_WRAP virtual double getScaleFactor() const = 0;
+
+    CV_WRAP virtual void setNLevels(int nlevels) = 0;
+    CV_WRAP virtual int getNLevels() const = 0;
+
+    CV_WRAP virtual void setEdgeThreshold(int edgeThreshold) = 0;
+    CV_WRAP virtual int getEdgeThreshold() const = 0;
+
+    CV_WRAP virtual void setFirstLevel(int firstLevel) = 0;
+    CV_WRAP virtual int getFirstLevel() const = 0;
+
+    CV_WRAP virtual void setWTA_K(int wta_k) = 0;
+    CV_WRAP virtual int getWTA_K() const = 0;
+
+    CV_WRAP virtual void setScoreType(ORB::ScoreType scoreType) = 0;
+    CV_WRAP virtual ORB::ScoreType getScoreType() const = 0;
+
+    CV_WRAP virtual void setPatchSize(int patchSize) = 0;
+    CV_WRAP virtual int getPatchSize() const = 0;
+
+    CV_WRAP virtual void setFastThreshold(int fastThreshold) = 0;
+    CV_WRAP virtual int getFastThreshold() const = 0;
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @example samples/python/snippets/mser.py
+An example using Maximally stable extremal region(MSER) extractor in python
+*/
+
+/** @brief Maximally stable extremal region extractor
+
+The class encapsulates all the parameters of the %MSER extraction algorithm (see [wiki
+article](http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions)).
+
+- there are two different implementation of %MSER: one for grey image, one for color image
+
+- the grey image algorithm is taken from: @cite nister2008linear ;  the paper claims to be faster
+than union-find method; it actually get 1.5~2m/s on my centrino L7200 1.2GHz laptop.
+
+- the color image algorithm is taken from: @cite forssen2007maximally ; it should be much slower
+than grey image method ( 3~4 times )
+
+- (Python) A complete example showing the use of the %MSER detector can be found at samples/python/mser.py
+*/
+class CV_EXPORTS_W MSER : public Feature2D
+{
+public:
+    /** @brief Full constructor for %MSER detector
+
+    @param delta it compares \f$(size_{i}-size_{i-delta})/size_{i-delta}\f$
+    @param min_area prune the area which smaller than minArea
+    @param max_area prune the area which bigger than maxArea
+    @param max_variation prune the area have similar size to its children
+    @param min_diversity for color image, trace back to cut off mser with diversity less than min_diversity
+    @param max_evolution  for color image, the evolution steps
+    @param area_threshold for color image, the area threshold to cause re-initialize
+    @param min_margin for color image, ignore too small margin
+    @param edge_blur_size for color image, the aperture size for edge blur
+     */
+    CV_WRAP static Ptr<MSER> create( int delta=5, int min_area=60, int max_area=14400,
+          double max_variation=0.25, double min_diversity=.2,
+          int max_evolution=200, double area_threshold=1.01,
+          double min_margin=0.003, int edge_blur_size=5 );
+
+    /** @brief Detect %MSER regions
+
+    @param image input image (8UC1, 8UC3 or 8UC4, must be greater or equal than 3x3)
+    @param msers resulting list of point sets
+    @param bboxes resulting bounding boxes
+    */
+    CV_WRAP virtual void detectRegions( InputArray image,
+                                        CV_OUT std::vector<std::vector<Point> >& msers,
+                                        CV_OUT std::vector<Rect>& bboxes ) = 0;
+
+    CV_WRAP virtual void setDelta(int delta) = 0;
+    CV_WRAP virtual int getDelta() const = 0;
+
+    CV_WRAP virtual void setMinArea(int minArea) = 0;
+    CV_WRAP virtual int getMinArea() const = 0;
+
+    CV_WRAP virtual void setMaxArea(int maxArea) = 0;
+    CV_WRAP virtual int getMaxArea() const = 0;
+
+    CV_WRAP virtual void setMaxVariation(double maxVariation) = 0;
+    CV_WRAP virtual double getMaxVariation() const = 0;
+
+    CV_WRAP virtual void setMinDiversity(double minDiversity) = 0;
+    CV_WRAP virtual double getMinDiversity() const = 0;
+
+    CV_WRAP virtual void setMaxEvolution(int maxEvolution) = 0;
+    CV_WRAP virtual int getMaxEvolution() const = 0;
+
+    CV_WRAP virtual void setAreaThreshold(double areaThreshold) = 0;
+    CV_WRAP virtual double getAreaThreshold() const = 0;
+
+    CV_WRAP virtual void setMinMargin(double min_margin) = 0;
+    CV_WRAP virtual double getMinMargin() const = 0;
+
+    CV_WRAP virtual void setEdgeBlurSize(int edge_blur_size) = 0;
+    CV_WRAP virtual int getEdgeBlurSize() const = 0;
+
+    CV_WRAP virtual void setPass2Only(bool f) = 0;
+    CV_WRAP virtual bool getPass2Only() const = 0;
+
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+
+/** @brief Wrapping class for feature detection using the FAST method.
+
+Check @ref tutorial_py_fast "the corresponding tutorial" for more details.
+ */
+class CV_EXPORTS_W FastFeatureDetector : public Feature2D
+{
+public:
+    enum DetectorType
+    {
+        TYPE_5_8 = 0, TYPE_7_12 = 1, TYPE_9_16 = 2
+    };
+    enum
+    {
+        THRESHOLD = 10000, NONMAX_SUPPRESSION=10001, FAST_N=10002
+    };
+
+
+    CV_WRAP static Ptr<FastFeatureDetector> create( int threshold=10,
+                                                    bool nonmaxSuppression=true,
+                                                    FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16 );
+
+    CV_WRAP virtual void setThreshold(int threshold) = 0;
+    CV_WRAP virtual int getThreshold() const = 0;
+
+    CV_WRAP virtual void setNonmaxSuppression(bool f) = 0;
+    CV_WRAP virtual bool getNonmaxSuppression() const = 0;
+
+    CV_WRAP virtual void setType(FastFeatureDetector::DetectorType type) = 0;
+    CV_WRAP virtual FastFeatureDetector::DetectorType getType() const = 0;
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+/** @brief Detects corners using the FAST algorithm
+
+@param image grayscale image where keypoints (corners) are detected.
+@param keypoints keypoints detected on the image.
+@param threshold threshold on difference between intensity of the central pixel and pixels of a
+circle around this pixel.
+@param nonmaxSuppression if true, non-maximum suppression is applied to detected keypoints (corners).
+@param type one of the three neighborhoods as defined in the paper:
+FastFeatureDetector::TYPE_9_16, FastFeatureDetector::TYPE_7_12,
+FastFeatureDetector::TYPE_5_8
+
+Detects corners using the FAST algorithm by @cite Rosten06 .
+
+Check @ref tutorial_py_fast "the corresponding tutorial" for more details.
+ */
+CV_EXPORTS void FAST( InputArray image, CV_OUT std::vector<KeyPoint>& keypoints,
+                      int threshold, bool nonmaxSuppression=true, FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16 );
+
+
+/** @brief Wrapping class for feature detection using the goodFeaturesToTrack function. :
+ */
+class CV_EXPORTS_W GFTTDetector : public Feature2D
+{
+public:
+    CV_WRAP static Ptr<GFTTDetector> create( int maxCorners=1000, double qualityLevel=0.01, double minDistance=1,
+                                             int blockSize=3, bool useHarrisDetector=false, double k=0.04 );
+    CV_WRAP static Ptr<GFTTDetector> create( int maxCorners, double qualityLevel, double minDistance,
+                                             int blockSize, int gradientSize, bool useHarrisDetector=false, double k=0.04 );
+    CV_WRAP virtual void setMaxFeatures(int maxFeatures) = 0;
+    CV_WRAP virtual int getMaxFeatures() const = 0;
+
+    CV_WRAP virtual void setQualityLevel(double qlevel) = 0;
+    CV_WRAP virtual double getQualityLevel() const = 0;
+
+    CV_WRAP virtual void setMinDistance(double minDistance) = 0;
+    CV_WRAP virtual double getMinDistance() const = 0;
+
+    CV_WRAP virtual void setBlockSize(int blockSize) = 0;
+    CV_WRAP virtual int getBlockSize() const = 0;
+
+    CV_WRAP virtual void setGradientSize(int gradientSize_) = 0;
+    CV_WRAP virtual int getGradientSize() = 0;
+
+    CV_WRAP virtual void setHarrisDetector(bool val) = 0;
+    CV_WRAP virtual bool getHarrisDetector() const = 0;
+
+    CV_WRAP virtual void setK(double k) = 0;
+    CV_WRAP virtual double getK() const = 0;
+
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+#if defined(HAVE_OPENCV_DNN) || defined(CV_DOXYGEN)
+
+/** @brief DISK feature detector and descriptor, based on a DNN model.
+
+DISK (Deep Image Structure and Keypoints) is a learned local-feature pipeline that produces
+keypoints and 128-D L2-normalized descriptors via a single forward pass through a fully
+convolutional network. This class wraps an ONNX export of the pre-trained DISK model through
+cv::dnn::Net and exposes it under the standard cv::Feature2D interface so it can be used as
+a drop-in alternative to SIFT/ORB.
+
+The class assumes the ONNX model has a single input named `image` taking an N×3×H×W float32
+tensor in [0, 1] (RGB channel order) and three outputs named `keypoints` (N×2), `scores` (N)
+and `descriptors` (N×128).
+ */
+class CV_EXPORTS_W DISK : public Feature2D
+{
+public:
+    /** @brief Creates a DISK detector.
+    @param modelPath Path to the DISK ONNX model.
+    @param maxKeypoints Maximum number of keypoints to return per image. The strongest
+                        responses (by network score) are kept; -1 keeps all detections.
+    @param scoreThreshold Discard keypoints with network score strictly below this value.
+    @param imageSize Target input size (width, height) fed to the network. Use Size()
+                     (the default) to fall back to the network's expected fixed input
+                     shape of 1024x1024. When overriding, both dimensions must be
+                     positive multiples of 16, since DISK downsamples by a factor of 16.
+    @param backendId DNN backend identifier (see cv::dnn::Backend); 0 = DNN_BACKEND_DEFAULT.
+    @param targetId  DNN target identifier (see cv::dnn::Target);  0 = DNN_TARGET_CPU.
+    */
+    CV_WRAP static Ptr<DISK> create(const String& modelPath,
+                                    int maxKeypoints = -1,
+                                    float scoreThreshold = 0.0f,
+                                    const Size& imageSize = Size(),
+                                    int backendId = 0,
+                                    int targetId = 0);
+
+    /** @brief Creates a DISK detector from an in-memory model buffer.
+
+    This overload loads the DISK ONNX model from a buffer instead of a file on disk. It is
+    intended for cases where the model is read from application resources (for example Android
+    assets) and is not available as a path on the filesystem.
+
+    @param bufferModel A buffer containing the contents of the DISK ONNX model.
+    @param maxKeypoints Maximum number of keypoints to return per image. The strongest
+                        responses (by network score) are kept; -1 keeps all detections.
+    @param scoreThreshold Discard keypoints with network score strictly below this value.
+    @param imageSize Target input size (width, height) fed to the network. Use Size()
+                     (the default) to fall back to the network's expected fixed input
+                     shape of 1024x1024. When overriding, both dimensions must be
+                     positive multiples of 16, since DISK downsamples by a factor of 16.
+    @param backendId DNN backend identifier (see cv::dnn::Backend); 0 = DNN_BACKEND_DEFAULT.
+    @param targetId  DNN target identifier (see cv::dnn::Target);  0 = DNN_TARGET_CPU.
+
+    @note In C++ this is an overload of @ref create. The Python/Java/Objective-C bindings expose
+          it as `createFromMemory`, because Objective-C selectors are not disambiguated by argument
+          type and would otherwise clash with the file-path @ref create.
+    */
+    CV_WRAP_AS(createFromMemory) static Ptr<DISK> create(const std::vector<uchar>& bufferModel,
+                                    int maxKeypoints = -1,
+                                    float scoreThreshold = 0.0f,
+                                    const Size& imageSize = Size(),
+                                    int backendId = 0,
+                                    int targetId = 0);
+
+    CV_WRAP virtual void setMaxKeypoints(int maxKeypoints) = 0;
+    CV_WRAP virtual int  getMaxKeypoints() const = 0;
+
+    CV_WRAP virtual void  setScoreThreshold(float threshold) = 0;
+    CV_WRAP virtual float getScoreThreshold() const = 0;
+
+    CV_WRAP virtual void setImageSize(const Size& size) = 0;
+    CV_WRAP virtual Size getImageSize() const = 0;
+
+    CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+};
+
+#endif // HAVE_OPENCV_DNN || CV_DOXYGEN
+
+/** @brief Class for extracting blobs from an image. :
+
+The class implements a simple algorithm for extracting blobs from an image:
+
+1.  Convert the source image to binary images by applying thresholding with several thresholds from
+    minThreshold (inclusive) to maxThreshold (exclusive) with distance thresholdStep between
+    neighboring thresholds.
+2.  Extract connected components from every binary image by findContours and calculate their
+    centers.
+3.  Group centers from several binary images by their coordinates. Close centers form one group that
+    corresponds to one blob, which is controlled by the minDistBetweenBlobs parameter.
+4.  From the groups, estimate final centers of blobs and their radiuses and return as locations and
+    sizes of keypoints.
+
+This class performs several filtrations of returned blobs. You should set filterBy\* to true/false
+to turn on/off corresponding filtration. Available filtrations:
+
+-   **By color**. This filter compares the intensity of a binary image at the center of a blob to
+blobColor. If they differ, the blob is filtered out. Use blobColor = 0 to extract dark blobs
+and blobColor = 255 to extract light blobs.
+-   **By area**. Extracted blobs have an area between minArea (inclusive) and maxArea (exclusive).
+-   **By circularity**. Extracted blobs have circularity
+(\f$\frac{4*\pi*Area}{perimeter * perimeter}\f$) between minCircularity (inclusive) and
+maxCircularity (exclusive).
+-   **By ratio of the minimum inertia to maximum inertia**. Extracted blobs have this ratio
+between minInertiaRatio (inclusive) and maxInertiaRatio (exclusive).
+-   **By convexity**. Extracted blobs have convexity (area / area of blob convex hull) between
+minConvexity (inclusive) and maxConvexity (exclusive).
+
+Default values of parameters are tuned to extract dark circular blobs.
+ */
+class CV_EXPORTS_W SimpleBlobDetector : public Feature2D
+{
+public:
+  struct CV_EXPORTS_W_SIMPLE Params
+  {
+      CV_WRAP Params();
+      CV_PROP_RW float thresholdStep;
+      CV_PROP_RW float minThreshold;
+      CV_PROP_RW float maxThreshold;
+      CV_PROP_RW size_t minRepeatability;
+      CV_PROP_RW float minDistBetweenBlobs;
+
+      CV_PROP_RW bool filterByColor;
+      CV_PROP_RW uchar blobColor;
+
+      CV_PROP_RW bool filterByArea;
+      CV_PROP_RW float minArea, maxArea;
+
+      CV_PROP_RW bool filterByCircularity;
+      CV_PROP_RW float minCircularity, maxCircularity;
+
+      CV_PROP_RW bool filterByInertia;
+      CV_PROP_RW float minInertiaRatio, maxInertiaRatio;
+
+      CV_PROP_RW bool filterByConvexity;
+      CV_PROP_RW float minConvexity, maxConvexity;
+
+      /** @brief Flag to enable contour collection.
+      If set to true, the detector will store the contours of the detected blobs in memory,
+      which can be retrieved after the detect() call using getBlobContours().
+      @note Default value is false.
+      */
+      CV_PROP_RW bool collectContours;
+
+      void read( const FileNode& fn );
+      void write( FileStorage& fs ) const;
+  };
+
+  CV_WRAP static Ptr<SimpleBlobDetector>
+    create(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
+
+  CV_WRAP virtual void setParams(const SimpleBlobDetector::Params& params ) = 0;
+  CV_WRAP virtual SimpleBlobDetector::Params getParams() const = 0;
+
+  CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
+
+  /** @brief Returns the contours of the blobs detected during the last call to detect().
+  @note The @ref Params::collectContours parameter must be set to true before calling
+  detect() for this method to return any data.
+  */
+  CV_WRAP virtual const std::vector<std::vector<cv::Point> >& getBlobContours() const = 0;
+};
+
+/** @brief ALIKED feature detector and descriptor extractor.
+
+ALIKED (A Lightweight Image KEYpoint Detector) is a CNN-based feature detector and descriptor
+extractor, as described in @cite Zhao23 . It produces 128-dimensional float descriptors and
+keypoints with sub-pixel accuracy.
+
+The model expects RGB input [1,3,H,W] and internally converts BGR images to RGB.
+*/
+class CV_EXPORTS_W ALIKED : public Feature2D
+{
+protected:
+    ALIKED();
+public:
+    virtual ~ALIKED();
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        CV_PROP_RW Size inputSize;              //!< Input image size for the network, default 640x640
+        CV_PROP_RW bool normalizeDescriptors;   //!< Whether to L2-normalize descriptors, default true
+        CV_PROP_RW int engine;                  //!< DNN engine type (dnn::EngineType), default ENGINE_NEW
+        CV_PROP_RW int backend;                 //!< DNN backend, default DNN_BACKEND_DEFAULT
+        CV_PROP_RW int target;                  //!< DNN target, default DNN_TARGET_CPU
+    };
+
+    /** @brief Creates ALIKED from a model file path.
+    @param modelPath Path to the ONNX model file.
+    @param params ALIKED parameters.
+    */
+    CV_WRAP static Ptr<ALIKED> create(const String& modelPath, const ALIKED::Params& params = ALIKED::Params());
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Creates ALIKED from in-memory model data.
+    @param modelData Buffer containing the model data.
+    @param params ALIKED parameters.
+    */
+    static Ptr<ALIKED> create(const std::vector<uchar>& modelData, const ALIKED::Params& params = ALIKED::Params());
+#endif
+};
+
+
+/****************************************************************************************\
+*                                      Distance                                          *
+\****************************************************************************************/
+
+template<typename T>
+struct CV_EXPORTS Accumulator
+{
+    typedef T Type;
+};
+
+template<> struct Accumulator<unsigned char>  { typedef float Type; };
+template<> struct Accumulator<unsigned short> { typedef float Type; };
+template<> struct Accumulator<char>   { typedef float Type; };
+template<> struct Accumulator<short>  { typedef float Type; };
+
+/*
+ * Squared Euclidean distance functor
+ */
+template<class T>
+struct CV_EXPORTS SL2
+{
+    static const NormTypes normType = NORM_L2SQR;
+    typedef T ValueType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    ResultType operator()( const T* a, const T* b, int size ) const
+    {
+        return normL2Sqr<ValueType, ResultType>(a, b, size);
+    }
+};
+
+/*
+ * Euclidean distance functor
+ */
+template<class T>
+struct L2
+{
+    static const NormTypes normType = NORM_L2;
+    typedef T ValueType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    ResultType operator()( const T* a, const T* b, int size ) const
+    {
+        return (ResultType)std::sqrt((double)normL2Sqr<ValueType, ResultType>(a, b, size));
+    }
+};
+
+/*
+ * Manhattan distance (city block distance) functor
+ */
+template<class T>
+struct L1
+{
+    static const NormTypes normType = NORM_L1;
+    typedef T ValueType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    ResultType operator()( const T* a, const T* b, int size ) const
+    {
+        return normL1<ValueType, ResultType>(a, b, size);
+    }
+};
+
+//! @} features_main
+
+/****************************************************************************************\
+*                                  DescriptorMatcher                                     *
+\****************************************************************************************/
+
+//! @addtogroup features_match
+//! @{
+
+/** @brief Abstract base class for matching keypoint descriptors.
+
+It has two groups of match methods: for matching descriptors of an image with another image or with
+an image set.
+ */
+class CV_EXPORTS_W DescriptorMatcher : public Algorithm
+{
+public:
+   enum MatcherType
+    {
+        FLANNBASED            = 1,
+        BRUTEFORCE            = 2,
+        BRUTEFORCE_L1         = 3,
+        BRUTEFORCE_HAMMING    = 4,
+        BRUTEFORCE_HAMMINGLUT = 5,
+        BRUTEFORCE_SL2        = 6
+    };
+
+    virtual ~DescriptorMatcher();
+
+    /** @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor
+    collection.
+
+    If the collection is not empty, the new descriptors are added to existing train descriptors.
+
+    @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same
+    train image.
+     */
+    CV_WRAP virtual void add( InputArrayOfArrays descriptors );
+
+    /** @brief Returns a constant link to the train descriptor collection trainDescCollection .
+     */
+    CV_WRAP const std::vector<Mat>& getTrainDescriptors() const;
+
+    /** @brief Clears the train descriptor collections.
+     */
+    CV_WRAP virtual void clear() CV_OVERRIDE;
+
+    /** @brief Returns true if there are no train descriptors in the both collections.
+     */
+    CV_WRAP virtual bool empty() const CV_OVERRIDE;
+
+    /** @brief Returns true if the descriptor matcher supports masking permissible matches.
+     */
+    CV_WRAP virtual bool isMaskSupported() const = 0;
+
+    /** @brief Trains a descriptor matcher
+
+    Trains a descriptor matcher (for example, the flann index). In all methods to match, the method
+    train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)
+    have an empty implementation of this method. Other matchers really train their inner structures (for
+    example, FlannBasedMatcher trains flann::Index ).
+     */
+    CV_WRAP virtual void train();
+
+    /** @brief Finds the best match for each descriptor from a query set.
+
+    @param queryDescriptors Query set of descriptors.
+    @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+    collection stored in the class object.
+    @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
+    descriptor. So, matches size may be smaller than the query descriptors count.
+    @param mask Mask specifying permissible matches between an input query and train matrices of
+    descriptors.
+
+    In the first variant of this method, the train descriptors are passed as an input argument. In the
+    second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is
+    used. Optional mask (or masks) can be passed to specify which query and training descriptors can be
+    matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if
+    mask.at\<uchar\>(i,j) is non-zero.
+     */
+    CV_WRAP void match( InputArray queryDescriptors, InputArray trainDescriptors,
+                CV_OUT std::vector<DMatch>& matches, InputArray mask=noArray() ) const;
+
+    /** @brief Finds the k best matches for each descriptor from a query set.
+
+    @param queryDescriptors Query set of descriptors.
+    @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+    collection stored in the class object.
+    @param mask Mask specifying permissible matches between an input query and train matrices of
+    descriptors.
+    @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
+    @param k Count of best matches found per each query descriptor or less if a query descriptor has
+    less than k possible matches in total.
+    @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+    false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
+    the matches vector does not contain matches for fully masked-out query descriptors.
+
+    These extended variants of DescriptorMatcher::match methods find several best matches for each query
+    descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match
+    for the details about query and train descriptors.
+     */
+    CV_WRAP void knnMatch( InputArray queryDescriptors, InputArray trainDescriptors,
+                   CV_OUT std::vector<std::vector<DMatch> >& matches, int k,
+                   InputArray mask=noArray(), bool compactResult=false ) const;
+
+    /** @brief For each query descriptor, finds the training descriptors not farther than the specified distance.
+
+    @param queryDescriptors Query set of descriptors.
+    @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
+    collection stored in the class object.
+    @param matches Found matches.
+    @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+    false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
+    the matches vector does not contain matches for fully masked-out query descriptors.
+    @param maxDistance Threshold for the distance between matched descriptors. Distance means here
+    metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
+    in Pixels)!
+    @param mask Mask specifying permissible matches between an input query and train matrices of
+    descriptors.
+
+    For each query descriptor, the methods find such training descriptors that the distance between the
+    query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are
+    returned in the distance increasing order.
+     */
+    CV_WRAP void radiusMatch( InputArray queryDescriptors, InputArray trainDescriptors,
+                      CV_OUT std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                      InputArray mask=noArray(), bool compactResult=false ) const;
+
+    /** @overload
+    @param queryDescriptors Query set of descriptors.
+    @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
+    descriptor. So, matches size may be smaller than the query descriptors count.
+    @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+    descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+    */
+    CV_WRAP void match( InputArray queryDescriptors, CV_OUT std::vector<DMatch>& matches,
+                        InputArrayOfArrays masks=noArray() );
+    /** @overload
+    @param queryDescriptors Query set of descriptors.
+    @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
+    @param k Count of best matches found per each query descriptor or less if a query descriptor has
+    less than k possible matches in total.
+    @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+    descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+    @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+    false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
+    the matches vector does not contain matches for fully masked-out query descriptors.
+    */
+    CV_WRAP void knnMatch( InputArray queryDescriptors, CV_OUT std::vector<std::vector<DMatch> >& matches, int k,
+                           InputArrayOfArrays masks=noArray(), bool compactResult=false );
+    /** @overload
+    @param queryDescriptors Query set of descriptors.
+    @param matches Found matches.
+    @param maxDistance Threshold for the distance between matched descriptors. Distance means here
+    metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
+    in Pixels)!
+    @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
+    descriptors and stored train descriptors from the i-th image trainDescCollection[i].
+    @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
+    false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
+    the matches vector does not contain matches for fully masked-out query descriptors.
+    */
+    CV_WRAP void radiusMatch( InputArray queryDescriptors, CV_OUT std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                      InputArrayOfArrays masks=noArray(), bool compactResult=false );
+
+
+    CV_WRAP void write( const String& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        write(fs);
+    }
+
+    CV_WRAP void read( const String& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        read(fs.root());
+    }
+    // Reads matcher object from a file node
+    // see corresponding cv::Algorithm method
+    CV_WRAP virtual void read( const FileNode& ) CV_OVERRIDE;
+    // Writes matcher object to a file storage
+    virtual void write( FileStorage& ) const CV_OVERRIDE;
+
+    /** @brief Clones the matcher.
+
+    @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,
+    that is, copies both parameters and train data. If emptyTrainData is true, the method creates an
+    object copy with the current parameters but with empty train data.
+     */
+    CV_WRAP CV_NODISCARD_STD virtual Ptr<DescriptorMatcher> clone( bool emptyTrainData=false ) const = 0;
+
+    /** @brief Creates a descriptor matcher of a given type with the default parameters (using default
+    constructor).
+
+    @param descriptorMatcherType Descriptor matcher type. Now the following matcher types are
+    supported:
+    -   `BruteForce` (it uses L2 )
+    -   `BruteForce-L1`
+    -   `BruteForce-Hamming`
+    -   `BruteForce-Hamming(2)`
+    -   `FlannBased`
+     */
+    CV_WRAP static Ptr<DescriptorMatcher> create( const String& descriptorMatcherType );
+
+    CV_WRAP static Ptr<DescriptorMatcher> create( const DescriptorMatcher::MatcherType& matcherType );
+
+
+    // see corresponding cv::Algorithm method
+    CV_WRAP inline void write(FileStorage& fs, const String& name) const { Algorithm::write(fs, name); }
+#if CV_VERSION_MAJOR < 5
+    inline void write(const Ptr<FileStorage>& fs, const String& name) const { CV_Assert(fs); Algorithm::write(*fs, name); }
+#endif
+
+protected:
+    /**
+     * Class to work with descriptors from several images as with one merged matrix.
+     * It is used e.g. in FlannBasedMatcher.
+     */
+    class CV_EXPORTS DescriptorCollection
+    {
+    public:
+        DescriptorCollection();
+        DescriptorCollection( const DescriptorCollection& collection );
+        virtual ~DescriptorCollection();
+
+        // Vector of matrices "descriptors" will be merged to one matrix "mergedDescriptors" here.
+        void set( const std::vector<Mat>& descriptors );
+        virtual void clear();
+
+        const Mat& getDescriptors() const;
+        Mat getDescriptor( int imgIdx, int localDescIdx ) const;
+        Mat getDescriptor( int globalDescIdx ) const;
+        void getLocalIdx( int globalDescIdx, int& imgIdx, int& localDescIdx ) const;
+
+        int size() const;
+
+    protected:
+        Mat mergedDescriptors;
+        std::vector<int> startIdxs;
+    };
+
+    //! In fact the matching is implemented only by the following two methods. These methods suppose
+    //! that the class object has been trained already. Public match methods call these methods
+    //! after calling train().
+    virtual void knnMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, int k,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) = 0;
+    virtual void radiusMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) = 0;
+
+    static bool isPossibleMatch( InputArray mask, int queryIdx, int trainIdx );
+    static bool isMaskedOut( InputArrayOfArrays masks, int queryIdx );
+
+    CV_NODISCARD_STD static Mat clone_op( Mat m ) { return m.clone(); }
+    void checkMasks( InputArrayOfArrays masks, int queryDescriptorsCount ) const;
+
+    //! Collection of descriptors from train images.
+    std::vector<Mat> trainDescCollection;
+    std::vector<UMat> utrainDescCollection;
+};
+
+/** @brief Brute-force descriptor matcher.
+
+For each descriptor in the first set, this matcher finds the closest descriptor in the second set
+by trying each one. This descriptor matcher supports masking permissible matches of descriptor
+sets.
+ */
+class CV_EXPORTS_W BFMatcher : public DescriptorMatcher
+{
+public:
+    /** @brief Brute-force matcher constructor (obsolete). Please use BFMatcher.create()
+     *
+     *
+    */
+    CV_WRAP BFMatcher( int normType=NORM_L2, bool crossCheck=false );
+
+    virtual ~BFMatcher() {}
+
+    virtual bool isMaskSupported() const CV_OVERRIDE { return true; }
+
+    /** @brief Brute-force matcher create method.
+    @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and L2 norms are
+    preferable choices for SIFT and SURF descriptors, NORM_HAMMING should be used with ORB, BRISK and
+    BRIEF, NORM_HAMMING2 should be used with ORB when WTA_K==3 or 4 (see ORB::ORB constructor
+    description).
+    @param crossCheck If it is false, this is will be default BFMatcher behaviour when it finds the k
+    nearest neighbors for each query descriptor. If crossCheck==true, then the knnMatch() method with
+    k=1 will only return pairs (i,j) such that for i-th query descriptor the j-th descriptor in the
+    matcher's collection is the nearest and vice versa, i.e. the BFMatcher will only return consistent
+    pairs. Such technique usually produces best results with minimal number of outliers when there are
+    enough matches. This is alternative to the ratio test, used by D. Lowe in SIFT paper.
+     */
+    CV_WRAP static Ptr<BFMatcher> create( int normType=NORM_L2, bool crossCheck=false ) ;
+
+    CV_NODISCARD_STD virtual Ptr<DescriptorMatcher> clone( bool emptyTrainData=false ) const CV_OVERRIDE;
+protected:
+    virtual void knnMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, int k,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) CV_OVERRIDE;
+    virtual void radiusMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) CV_OVERRIDE;
+
+    int normType;
+    bool crossCheck;
+};
+
+#if defined(HAVE_OPENCV_FLANN) || defined(CV_DOXYGEN)
+
+/** @brief Flann-based descriptor matcher.
+
+This matcher trains cv::flann::Index on a train descriptor collection and calls its nearest search
+methods to find the best matches. So, this matcher may be faster when matching a large train
+collection than the brute force matcher. FlannBasedMatcher does not support masking permissible
+matches of descriptor sets because flann::Index does not support this. :
+ */
+class CV_EXPORTS_W FlannBasedMatcher : public DescriptorMatcher
+{
+public:
+    CV_WRAP FlannBasedMatcher( const Ptr<flann::IndexParams>& indexParams=makePtr<flann::KDTreeIndexParams>(),
+                       const Ptr<flann::SearchParams>& searchParams=makePtr<flann::SearchParams>() );
+
+    virtual void add( InputArrayOfArrays descriptors ) CV_OVERRIDE;
+    virtual void clear() CV_OVERRIDE;
+
+    // Reads matcher object from a file node
+    virtual void read( const FileNode& ) CV_OVERRIDE;
+    // Writes matcher object to a file storage
+    virtual void write( FileStorage& ) const CV_OVERRIDE;
+
+    virtual void train() CV_OVERRIDE;
+    virtual bool isMaskSupported() const CV_OVERRIDE;
+
+    CV_WRAP static Ptr<FlannBasedMatcher> create();
+
+    CV_NODISCARD_STD virtual Ptr<DescriptorMatcher> clone( bool emptyTrainData=false ) const CV_OVERRIDE;
+protected:
+    static void convertToDMatches( const DescriptorCollection& descriptors,
+                                   const Mat& indices, const Mat& distances,
+                                   std::vector<std::vector<DMatch> >& matches );
+
+    virtual void knnMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, int k,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) CV_OVERRIDE;
+    virtual void radiusMatchImpl( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
+        InputArrayOfArrays masks=noArray(), bool compactResult=false ) CV_OVERRIDE;
+
+    Ptr<flann::IndexParams> indexParams;
+    Ptr<flann::SearchParams> searchParams;
+    Ptr<flann::Index> flannIndex;
+
+    DescriptorCollection mergedDescriptors;
+    int addedDescCount;
+};
+
+#endif
+
+/** @brief LightGlue feature matcher.
+
+LightGlue is a CNN-based feature matcher, as described in @cite Lindenberger23 . It takes
+keypoint locations and descriptors from two images and directly predicts match pairs. Unlike
+traditional matchers that compute descriptor distances, LightGlue uses attention mechanisms
+to produce confidence scores for each potential match pair.
+
+The matcher extends DescriptorMatcher and supports the standard match(), knnMatch(), and
+radiusMatch() interfaces. Context (keypoints and image sizes) must be provided via
+setPairInfo() before matching.
+*/
+class CV_EXPORTS_W LightGlueMatcher : public DescriptorMatcher
+{
+protected:
+    LightGlueMatcher();
+public:
+    virtual ~LightGlueMatcher();
+
+    /** @brief Creates LightGlueMatcher from a model file path.
+    @param modelPath Path to the ONNX model file.
+    @param scoreThreshold Match confidence threshold.
+    @param backend DNN backend
+    @param target DNN target
+    */
+    CV_WRAP static Ptr<LightGlueMatcher> create(const String& modelPath, float scoreThreshold = 0.0f, int backend = 0, int target = 0);
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Creates LightGlueMatcher from in-memory model data.
+    @param modelData Buffer containing the model data.
+    @param scoreThreshold Match confidence threshold.
+    @param backend DNN backend
+    @param target DNN target
+    */
+    CV_WRAP_AS(createFromMemory) static Ptr<LightGlueMatcher> create(const std::vector<uchar>& modelData, float scoreThreshold = 0.0f, int backend = 0, int target = 0);
+#endif
+
+    /** @brief Sets the keypoint and image size context for the next match() call.
+
+    This provides the spatial context that LightGlue needs in addition to descriptors.
+    Must be called before match()/knnMatch()/radiusMatch() unless using automatic context
+    from in-process ALIKED instances.
+
+    @param queryKpts Query image keypoints (Nx2 float matrix with x,y coordinates).
+    @param trainKpts Train image keypoints (Nx2 float matrix with x,y coordinates).
+    @param queryImageSize Size of the query image (width, height).
+    @param trainImageSize Size of the train image (width, height).
+    */
+    CV_WRAP virtual void setPairInfo(InputArray queryKpts, InputArray trainKpts,
+                                     Size queryImageSize = Size(), Size trainImageSize = Size()) = 0;
+
+    /** @brief Clears stored pair context information.
+    */
+    CV_WRAP virtual void clearPairInfo() = 0;
+};
+
+//! @} features_match
+
+/****************************************************************************************\
+*                                   Drawing functions                                    *
+\****************************************************************************************/
+
+//! @addtogroup features_draw
+//! @{
+
+enum struct DrawMatchesFlags
+{
+  DEFAULT = 0, //!< Output image matrix will be created (Mat::create),
+               //!< i.e. existing memory of output image may be reused.
+               //!< Two source image, matches and single keypoints will be drawn.
+               //!< For each keypoint only the center point will be drawn (without
+               //!< the circle around keypoint with keypoint size and orientation).
+  DRAW_OVER_OUTIMG = 1, //!< Output image matrix will not be created (Mat::create).
+                        //!< Matches will be drawn on existing content of output image.
+  NOT_DRAW_SINGLE_POINTS = 2, //!< Single keypoints will not be drawn.
+  DRAW_RICH_KEYPOINTS = 4 //!< For each keypoint the circle around keypoint with keypoint size and
+                          //!< orientation will be drawn.
+};
+CV_ENUM_FLAGS(DrawMatchesFlags)
+
+/** @brief Draws keypoints.
+
+@param image Source image.
+@param keypoints Keypoints from the source image.
+@param outImage Output image. Its content depends on the flags value defining what is drawn in the
+output image. See possible flags bit values below.
+@param color Color of keypoints.
+@param flags Flags setting drawing features. Possible flags bit values are defined by
+DrawMatchesFlags. See details above in drawMatches .
+
+@note
+For Python API, flags are modified as cv.DRAW_MATCHES_FLAGS_DEFAULT,
+cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS, cv.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG,
+cv.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
+ */
+CV_EXPORTS_W void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage,
+                               const Scalar& color=Scalar::all(-1), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT );
+
+/** @brief Draws the found matches of keypoints from two images.
+
+@param img1 First source image.
+@param keypoints1 Keypoints from the first source image.
+@param img2 Second source image.
+@param keypoints2 Keypoints from the second source image.
+@param matches1to2 Matches from the first image to the second one, which means that keypoints1[i]
+has a corresponding point in keypoints2[matches[i]] .
+@param outImg Output image. Its content depends on the flags value defining what is drawn in the
+output image. See possible flags bit values below.
+@param matchColor Color of matches (lines and connected keypoints). If matchColor==Scalar::all(-1)
+, the color is generated randomly.
+@param singlePointColor Color of single keypoints (circles), which means that keypoints do not
+have the matches. If singlePointColor==Scalar::all(-1) , the color is generated randomly.
+@param matchesMask Mask determining which matches are drawn. If the mask is empty, all matches are
+drawn.
+@param flags Flags setting drawing features. Possible flags bit values are defined by
+DrawMatchesFlags.
+
+This function draws matches of keypoints from two images in the output image. Match is a line
+connecting two keypoints (circles). See cv::DrawMatchesFlags.
+ */
+CV_EXPORTS_W void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                             InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<DMatch>& matches1to2, InputOutputArray outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const std::vector<char>& matchesMask=std::vector<char>(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT );
+
+/** @overload */
+CV_EXPORTS_W void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                             InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<DMatch>& matches1to2, InputOutputArray outImg,
+                             const int matchesThickness, const Scalar& matchColor=Scalar::all(-1),
+                             const Scalar& singlePointColor=Scalar::all(-1), const std::vector<char>& matchesMask=std::vector<char>(),
+                             DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT );
+
+CV_EXPORTS_AS(drawMatchesKnn) void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                             InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<std::vector<DMatch> >& matches1to2, InputOutputArray outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const std::vector<std::vector<char> >& matchesMask=std::vector<std::vector<char> >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT );
+
+//! @} features_draw
+
+/****************************************************************************************\
+*   Functions to evaluate the feature detectors and [generic] descriptor extractors      *
+\****************************************************************************************/
+
+//! @addtogroup features_main
+//! @{
+
+CV_EXPORTS void evaluateFeatureDetector( const Mat& img1, const Mat& img2, const Mat& H1to2,
+                                         std::vector<KeyPoint>* keypoints1, std::vector<KeyPoint>* keypoints2,
+                                         float& repeatability, int& correspCount,
+                                         const Ptr<FeatureDetector>& fdetector=Ptr<FeatureDetector>() );
+
+CV_EXPORTS void computeRecallPrecisionCurve( const std::vector<std::vector<DMatch> >& matches1to2,
+                                             const std::vector<std::vector<uchar> >& correctMatches1to2Mask,
+                                             std::vector<Point2f>& recallPrecisionCurve );
+
+CV_EXPORTS float getRecall( const std::vector<Point2f>& recallPrecisionCurve, float l_precision );
+CV_EXPORTS int getNearestPoint( const std::vector<Point2f>& recallPrecisionCurve, float l_precision );
+
+//! @}
+
+
+/****************************************************************************************\
+*                             Approximate Nearest Neighbors                              *
+\****************************************************************************************/
+
+//! @addtogroup features_annoy
+//! @{
+
+class CV_EXPORTS_W ANNIndex
+{
+public:
+    /** @brief Metrics used to calculate the distance between two feature vectors.
+     */
+    enum Distance
+    {
+        DIST_EUCLIDEAN,
+        DIST_MANHATTAN,
+        DIST_ANGULAR,
+        DIST_HAMMING,
+        DIST_DOTPRODUCT
+    };
+
+    virtual ~ANNIndex() = default;
+
+    /** @brief Add feature vectors to index.
+     *
+     * @param features Matrix containing the feature vectors to index. The size of the matrix is
+        num_features x feature_dimension.
+     */
+    CV_WRAP virtual void addItems(InputArray features) = 0;
+
+    /** @brief Build the index.
+     *
+     *  @param trees Number of trees in the index. If not provided, the number is determined automatically
+     *  in a way that at most 2x as much memory as the features vectors take is used.
+     */
+    CV_WRAP virtual void build(int trees=-1) = 0;
+
+    /** @brief Performs a K-nearest neighbor search for given query vector(s) using the index.
+     *
+     *  @param query The query vector(s).
+     *  @param indices Matrix that will contain the indices of the K-nearest neighbors found, optional.
+     *  @param dists Matrix that will contain the distances to the K-nearest neighbors found, optional.
+     *  @param knn Number of nearest neighbors to search for.
+     *  @param search_k The maximum number of nodes to inspect, which defaults to trees x knn if not provided.
+     */
+    CV_WRAP virtual void knnSearch(InputArray query, OutputArray indices, OutputArray dists, int knn, int search_k=-1) = 0;
+
+    /** @brief Save the index to disk and loads it. After saving, no more vectors can be added.
+     *
+     *  @param filename Filename of the index to be saved.
+     *  @param prefault If prefault is set to true, it will pre-read the entire file into memory (using mmap
+     *  with MAP_POPULATE). Default is false.
+     */
+    CV_WRAP virtual void save(const String &filename, bool prefault=false) = 0;
+
+    /** @brief Loads (mmaps) an index from disk.
+     *
+     *  @param filename Filename of the index to be loaded.
+     *  @param prefault If prefault is set to true, it will pre-read the entire file into memory (using mmap
+     *  with MAP_POPULATE). Default is false.
+     */
+    CV_WRAP virtual void load(const String &filename, bool prefault=false) = 0;
+
+    /** @brief Return the number of trees in the index.
+     */
+    CV_WRAP virtual int getTreeNumber() = 0;
+
+    /** @brief Return the number of feature vectors in the index.
+     */
+    CV_WRAP virtual int getItemNumber() = 0;
+
+    /** @brief  Prepare to build the index in the specified file instead of RAM (execute before adding
+     * items, no need to save after build)
+     *
+     *  @param filename Filename of the index to be built.
+     */
+    CV_WRAP virtual bool setOnDiskBuild(const String &filename) = 0;
+
+    /** @brief Initialize the random number generator with the given seed. Only necessary to pass this
+     *  before adding the items. Will have no effect after calling build() or load().
+     *
+     *  @param seed The given seed of the random number generator. Its value should be within the range of uint32_t.
+     */
+    CV_WRAP virtual void setSeed(int seed) = 0;
+
+    /** @brief Creates an instance of annoy index class with given parameters
+     *
+     *  @param dim The dimension of the feature vector.
+     *  @param distType Metric to calculate the distance between two feature vectors, can be DIST_EUCLIDEAN,
+        DIST_MANHATTAN, DIST_ANGULAR, DIST_HAMMING, or DIST_DOTPRODUCT.
+     */
+    CV_WRAP static Ptr<ANNIndex> create(int dim, ANNIndex::Distance distType=ANNIndex::DIST_EUCLIDEAN);
+};
+
+//! @} features_annoy
+
+} /* namespace cv */
+
+#endif
diff --git a/upstream/opencv/modules/features/include/opencv2/features/features.hpp b/upstream/opencv/modules/features/include/opencv2/features/features.hpp
new file mode 100644
index 0000000..86e075f
--- /dev/null
+++ b/upstream/opencv/modules/features/include/opencv2/features/features.hpp
@@ -0,0 +1,48 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/features.hpp"
diff --git a/upstream/opencv/modules/features/include/opencv2/features/hal/interface.h b/upstream/opencv/modules/features/include/opencv2/features/hal/interface.h
new file mode 100644
index 0000000..a6854df
--- /dev/null
+++ b/upstream/opencv/modules/features/include/opencv2/features/hal/interface.h
@@ -0,0 +1,33 @@
+#ifndef OPENCV_FEATURE2D_HAL_INTERFACE_H
+#define OPENCV_FEATURE2D_HAL_INTERFACE_H
+
+#include "opencv2/core/cvdef.h"
+//! @addtogroup features_hal_interface
+//! @{
+
+//! @name Fast feature detector types
+//! @sa cv::FastFeatureDetector
+//! @{
+#define CV_HAL_TYPE_5_8  0
+#define CV_HAL_TYPE_7_12 1
+#define CV_HAL_TYPE_9_16 2
+//! @}
+
+//! @name Key point
+//! @sa cv::KeyPoint
+//! @{
+struct CV_EXPORTS cvhalKeyPoint
+{
+    float x;
+    float y;
+    float size;
+    float angle;
+    float response;
+    int octave;
+    int class_id;
+};
+//! @}
+
+//! @}
+
+#endif
diff --git a/upstream/opencv/modules/features/include/opencv2/features2d.hpp b/upstream/opencv/modules/features/include/opencv2/features2d.hpp
new file mode 100644
index 0000000..fe26dbd
--- /dev/null
+++ b/upstream/opencv/modules/features/include/opencv2/features2d.hpp
@@ -0,0 +1,6 @@
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/features.hpp"
\ No newline at end of file
diff --git a/upstream/opencv/modules/features/src/affine_feature.cpp b/upstream/opencv/modules/features/src/affine_feature.cpp
new file mode 100644
index 0000000..798d20b
--- /dev/null
+++ b/upstream/opencv/modules/features/src/affine_feature.cpp
@@ -0,0 +1,361 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// This file is based on code issued with the following license.
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+*  Copyright (C) 2008-2013, Willow Garage Inc., all rights reserved.
+*  Copyright (C) 2013, Evgeny Toropov, all rights reserved.
+*  Third party copyrights are property of their respective owners.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * The name of the copyright holders may not be used to endorse
+*     or promote products derived from this software without specific
+*     prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/*
+ Guoshen Yu, Jean-Michel Morel, ASIFT: An Algorithm for Fully Affine
+ Invariant Comparison,  Image Processing On Line, 1 (2011), pp. 11-38.
+ https://doi.org/10.5201/ipol.2011.my-asift
+ */
+
+#include "precomp.hpp"
+#include <iostream>
+
+namespace cv {
+
+class AffineFeature_Impl CV_FINAL : public AffineFeature
+{
+public:
+    explicit AffineFeature_Impl(const Ptr<Feature2D>& backend,
+            int maxTilt, int minTilt, float tiltStep, float rotateStepBase);
+
+    int descriptorSize() const CV_OVERRIDE
+    {
+        return backend_->descriptorSize();
+    }
+
+    int descriptorType() const CV_OVERRIDE
+    {
+        return backend_->descriptorType();
+    }
+
+    int defaultNorm() const CV_OVERRIDE
+    {
+        return backend_->defaultNorm();
+    }
+
+    void detectAndCompute(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints,
+            OutputArray descriptors, bool useProvidedKeypoints=false) CV_OVERRIDE;
+
+    void setViewParams(const std::vector<float>& tilts, const std::vector<float>& rolls) CV_OVERRIDE;
+    void getViewParams(std::vector<float>& tilts, std::vector<float>& rolls) const CV_OVERRIDE;
+
+protected:
+    void splitKeypointsByView(const std::vector<KeyPoint>& keypoints_,
+            std::vector< std::vector<KeyPoint> >& keypointsByView) const;
+
+    const Ptr<Feature2D> backend_;
+    int maxTilt_;
+    int minTilt_;
+    float tiltStep_;
+    float rotateStepBase_;
+
+    // Tilt factors.
+    std::vector<float> tilts_;
+    // Roll factors.
+    std::vector<float> rolls_;
+
+private:
+    AffineFeature_Impl(const AffineFeature_Impl &); // copy disabled
+    AffineFeature_Impl& operator=(const AffineFeature_Impl &); // assign disabled
+};
+
+AffineFeature_Impl::AffineFeature_Impl(const Ptr<FeatureDetector>& backend,
+        int maxTilt, int minTilt, float tiltStep, float rotateStepBase)
+    : backend_(backend), maxTilt_(maxTilt), minTilt_(minTilt), tiltStep_(tiltStep), rotateStepBase_(rotateStepBase)
+{
+    int i = minTilt_;
+    if( i == 0 )
+    {
+        tilts_.push_back(1);
+        rolls_.push_back(0);
+        i++;
+    }
+    float tilt = 1;
+    for( ; i <= maxTilt_; i++ )
+    {
+        tilt *= tiltStep_;
+        float rotateStep = rotateStepBase_ / tilt;
+        int rollN = cvFloor(180.0f / rotateStep);
+        if( rollN * rotateStep == 180.0f )
+            rollN--;
+        for( int j = 0; j <= rollN; j++ )
+        {
+            tilts_.push_back(tilt);
+            rolls_.push_back(rotateStep * j);
+        }
+    }
+}
+
+void AffineFeature_Impl::setViewParams(const std::vector<float>& tilts,
+        const std::vector<float>& rolls)
+{
+    CV_Assert(tilts.size() == rolls.size());
+    tilts_ = tilts;
+    rolls_ = rolls;
+}
+
+void AffineFeature_Impl::getViewParams(std::vector<float>& tilts,
+        std::vector<float>& rolls) const
+{
+    tilts = tilts_;
+    rolls = rolls_;
+}
+
+void AffineFeature_Impl::splitKeypointsByView(const std::vector<KeyPoint>& keypoints_,
+        std::vector< std::vector<KeyPoint> >& keypointsByView) const
+{
+    for( size_t i = 0; i < keypoints_.size(); i++ )
+    {
+        const KeyPoint& kp = keypoints_[i];
+        CV_Assert( kp.class_id >= 0 && kp.class_id < (int)tilts_.size() );
+        keypointsByView[kp.class_id].push_back(kp);
+    }
+}
+
+class skewedDetectAndCompute : public ParallelLoopBody
+{
+public:
+    skewedDetectAndCompute(
+        const std::vector<float>& _tilts,
+        const std::vector<float>& _rolls,
+        std::vector< std::vector<KeyPoint> >& _keypointsCollection,
+        std::vector<Mat>& _descriptorCollection,
+        const Mat& _image,
+        const Mat& _mask,
+        const bool _do_keypoints,
+        const bool _do_descriptors,
+        const Ptr<Feature2D>& _backend)
+        : tilts(_tilts),
+          rolls(_rolls),
+          keypointsCollection(_keypointsCollection),
+          descriptorCollection(_descriptorCollection),
+          image(_image),
+          mask(_mask),
+          do_keypoints(_do_keypoints),
+          do_descriptors(_do_descriptors),
+          backend(_backend) {}
+
+    void operator()( const cv::Range& range ) const CV_OVERRIDE
+    {
+        CV_TRACE_FUNCTION();
+
+        const int begin = range.start;
+        const int end = range.end;
+
+        for( int a = begin; a < end; a++ )
+        {
+            Mat warpedImage, warpedMask;
+            Matx23f pose, invPose;
+            affineSkew(tilts[a], rolls[a], warpedImage, warpedMask, pose);
+            invertAffineTransform(pose, invPose);
+
+            std::vector<KeyPoint> wKeypoints;
+            Mat wDescriptors;
+            if( !do_keypoints )
+            {
+                const std::vector<KeyPoint>& keypointsInView = keypointsCollection[a];
+                if( keypointsInView.size() == 0 ) // when there are no keypoints in this affine view
+                    continue;
+
+                std::vector<Point2f> pts_, pts;
+                KeyPoint::convert(keypointsInView, pts_);
+                transform(pts_, pts, pose);
+                wKeypoints.resize(keypointsInView.size());
+                for( size_t wi = 0; wi < wKeypoints.size(); wi++ )
+                {
+                    wKeypoints[wi] = keypointsInView[wi];
+                    wKeypoints[wi].pt = pts[wi];
+                }
+            }
+            backend->detectAndCompute(warpedImage, warpedMask, wKeypoints, wDescriptors, !do_keypoints);
+            if( do_keypoints )
+            {
+                // KeyPointsFilter::runByPixelsMask( wKeypoints, warpedMask );
+                if( wKeypoints.size() == 0 )
+                {
+                    keypointsCollection[a].clear();
+                    continue;
+                }
+                std::vector<Point2f> pts_, pts;
+                KeyPoint::convert(wKeypoints, pts_);
+                transform(pts_, pts, invPose);
+
+                keypointsCollection[a].resize(wKeypoints.size());
+                for( size_t wi = 0; wi < wKeypoints.size(); wi++ )
+                {
+                    keypointsCollection[a][wi] = wKeypoints[wi];
+                    keypointsCollection[a][wi].pt = pts[wi];
+                    keypointsCollection[a][wi].class_id = a;
+                }
+            }
+            if( do_descriptors )
+                wDescriptors.copyTo(descriptorCollection[a]);
+        }
+    }
+private:
+    void affineSkew(float tilt, float phi,
+            Mat& warpedImage, Mat& warpedMask, Matx23f& pose) const
+    {
+        int h = image.size().height;
+        int w = image.size().width;
+        Mat rotImage;
+
+        Mat mask0;
+        if( mask.empty() )
+            mask0 = Mat(h, w, CV_8UC1, 255);
+        else
+            mask0 = mask;
+        pose = Matx23f(1,0,0,
+                       0,1,0);
+
+        if( phi == 0 )
+            image.copyTo(rotImage);
+        else
+        {
+            phi = phi * (float)CV_PI / 180;
+            float s = std::sin(phi);
+            float c = std::cos(phi);
+            Matx22f A(c, -s, s, c);
+            Matx<float, 4, 2> corners(0, 0, (float)w, 0, (float)w,(float)h, 0, (float)h);
+            Mat tf(corners * A.t());
+            Mat tcorners;
+            tf.convertTo(tcorners, CV_32S);
+            Rect rect = boundingRect(tcorners);
+            h = rect.height; w = rect.width;
+            pose = Matx23f(c, -s, -(float)rect.x,
+                        s,  c, -(float)rect.y);
+            warpAffine(image, rotImage, pose, Size(w, h), INTER_LINEAR, BORDER_REPLICATE, Scalar(), cv::ALGO_HINT_ACCURATE);
+        }
+        if( tilt == 1 )
+            warpedImage = rotImage;
+        else
+        {
+            float s = 0.8f * sqrt(tilt * tilt - 1);
+            GaussianBlur(rotImage, rotImage, Size(0, 0), s, 0.01);
+            resize(rotImage, warpedImage, Size(0, 0), 1.0/tilt, 1.0, INTER_NEAREST);
+            pose(0, 0) /= tilt;
+            pose(0, 1) /= tilt;
+            pose(0, 2) /= tilt;
+        }
+        if( phi != 0 || tilt != 1 )
+            warpAffine(mask0, warpedMask, pose, warpedImage.size(), INTER_NEAREST, BORDER_CONSTANT, Scalar(), cv::ALGO_HINT_ACCURATE);
+        else
+            warpedMask = mask0;
+    }
+
+
+    const std::vector<float>& tilts;
+    const std::vector<float>& rolls;
+    std::vector< std::vector<KeyPoint> >& keypointsCollection;
+    std::vector<Mat>& descriptorCollection;
+    const Mat& image;
+    const Mat& mask;
+    const bool do_keypoints;
+    const bool do_descriptors;
+    const Ptr<Feature2D>& backend;
+};
+
+void AffineFeature_Impl::detectAndCompute(InputArray _image, InputArray _mask,
+        std::vector<KeyPoint>& keypoints,
+        OutputArray _descriptors,
+        bool useProvidedKeypoints)
+{
+    CV_TRACE_FUNCTION();
+
+    bool do_keypoints = !useProvidedKeypoints;
+    bool do_descriptors = _descriptors.needed();
+    Mat image = _image.getMat(), mask = _mask.getMat();
+    Mat descriptors;
+
+    if( (!do_keypoints && !do_descriptors) || _image.empty() )
+        return;
+
+    std::vector< std::vector<KeyPoint> > keypointsCollection(tilts_.size());
+    std::vector< Mat > descriptorCollection(tilts_.size());
+
+    if( do_keypoints )
+        keypoints.clear();
+    else
+        splitKeypointsByView(keypoints, keypointsCollection);
+
+    parallel_for_(Range(0, (int)tilts_.size()), skewedDetectAndCompute(tilts_, rolls_, keypointsCollection, descriptorCollection,
+        image, mask, do_keypoints, do_descriptors, backend_));
+
+    if( do_keypoints )
+        for( size_t i = 0; i < keypointsCollection.size(); i++ )
+        {
+            const std::vector<KeyPoint>& keys = keypointsCollection[i];
+            keypoints.insert(keypoints.end(), keys.begin(), keys.end());
+        }
+
+    if( do_descriptors )
+    {
+        _descriptors.create((int)keypoints.size(), backend_->descriptorSize(), backend_->descriptorType());
+        descriptors = _descriptors.getMat();
+        int iter = 0;
+        for( size_t i = 0; i < descriptorCollection.size(); i++ )
+        {
+            const Mat& descs = descriptorCollection[i];
+            if( descs.empty() )
+                continue;
+            Mat roi(descriptors, Rect(0, iter, descriptors.cols, descs.rows));
+            descs.copyTo(roi);
+            iter += descs.rows;
+        }
+    }
+}
+
+
+Ptr<AffineFeature> AffineFeature::create(const Ptr<Feature2D>& backend,
+                                         int maxTilt, int minTilt, float tiltStep, float rotateStepBase)
+{
+    CV_Assert(minTilt < maxTilt);
+    CV_Assert(tiltStep > 0);
+    CV_Assert(rotateStepBase > 0);
+    return makePtr<AffineFeature_Impl>(backend, maxTilt, minTilt, tiltStep, rotateStepBase);
+}
+
+String AffineFeature::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".AffineFeature");
+}
+
+} // namespace
diff --git a/upstream/opencv/modules/features/src/aliked_context.hpp b/upstream/opencv/modules/features/src/aliked_context.hpp
new file mode 100644
index 0000000..54c76cd
--- /dev/null
+++ b/upstream/opencv/modules/features/src/aliked_context.hpp
@@ -0,0 +1,21 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_FEATURES_ALIKED_CONTEXT_HPP
+#define OPENCV_FEATURES_ALIKED_CONTEXT_HPP
+
+#include "opencv2/features.hpp"
+
+namespace cv
+{
+
+struct ALIKEDContext
+{
+    Mat normalizedKeypoints;  // Nx2 float, coordinates in [-1, 1]
+    Size imageSize;
+};
+
+}  // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/features/src/annoy.cpp b/upstream/opencv/modules/features/src/annoy.cpp
new file mode 100644
index 0000000..be62d9a
--- /dev/null
+++ b/upstream/opencv/modules/features/src/annoy.cpp
@@ -0,0 +1,266 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#define ANNOYLIB_MULTITHREADED_BUILD
+
+#include "precomp.hpp"
+#include "../3rdparty/annoy/annoylib.h"
+#include <opencv2/core/utils/logger.hpp>
+
+
+namespace cv
+{
+
+struct Random
+{
+    static const uint64 default_seed = 0xffffffff;
+    #if __cplusplus < 201103L
+    typedef uint64 seed_type;
+    #endif
+
+    RNG rng;
+
+    Random(uint64 seed = default_seed)
+    {
+        rng.state = seed;
+    }
+
+    inline int flip()
+    {
+        // Draw random 0 or 1
+        return rng.next() & 1;
+    }
+
+    inline size_t index(size_t n)
+    {
+        // Draw random integer between 0 and n-1 where n is at most the number of data points you have
+        return rng(unsigned(n));
+    }
+
+    inline void set_seed(uint64 seed)
+    {
+        rng.state = seed;
+    }
+};
+
+template <typename DataType, typename DistanceType>
+class ANNIndexImpl : public ANNIndex
+{
+public:
+    ANNIndexImpl(int dimension) : dim(dimension)
+    {
+        index = makePtr<::cvannoy::AnnoyIndex<int, DataType, DistanceType, Random, ::cvannoy::AnnoyIndexMultiThreadedBuildPolicy>>(dimension);
+    }
+
+    void addItems(InputArray _dataset) CV_OVERRIDE
+    {
+        CV_Assert(!_dataset.empty());
+
+        Mat features = _dataset.getMat();
+        CV_Assert(features.cols == dim);
+        CV_Assert(features.type() == cv::DataType<DataType>::type);
+
+        int num = features.rows;
+        char* msg = nullptr;
+        if (!index->add_item(0, features.ptr<DataType>(0), &msg))
+        {
+            if (msg)
+            {
+                String errorMsg = msg;
+                free(msg);
+                CV_Error(Error::StsError, errorMsg);
+            }
+            else
+            {
+                CV_Error(Error::StsError, "Fail to add an item.");
+            }
+        }
+        for (int i = 1; i < num; ++i)
+            index->add_item(i, features.ptr<DataType>(i));
+    }
+
+    void build(int trees) CV_OVERRIDE
+    {
+        if (index->get_n_items() <= 0)
+            CV_Error(Error::StsError, "No items added. Please add items before building the index.");
+
+        if (trees <= 0)
+            trees = -1;
+
+        char* msg = nullptr;
+        if (!index->build(trees, -1, &msg))
+        {
+            if (msg)
+            {
+                String errorMsg = msg;
+                free(msg);
+                CV_Error(Error::StsError, errorMsg);
+            }
+            else
+            {
+                CV_Error(Error::StsError, "Fail to build the index.");
+            }
+        }
+    }
+
+    void knnSearch(InputArray _query, OutputArray _indices, OutputArray _dists, int knn, int search_k) CV_OVERRIDE
+    {
+        CV_Assert(!_query.empty() && _query.isContinuous());
+        Mat query = _query.getMat(), indices, dists;
+        CV_Assert(query.type() == cv::DataType<DataType>::type);
+        CV_Assert(knn > 0 && knn <= index->get_n_items());
+
+        int numQuery = query.rows;
+        if (_indices.needed())
+        {
+            indices = _indices.getMat();
+            if (!indices.isContinuous() || indices.type() != CV_32S ||
+                indices.rows != numQuery || indices.cols != knn)
+            {
+                if (!indices.isContinuous())
+                    _indices.release();
+                _indices.create(numQuery, knn, CV_32S);
+                indices = _indices.getMat();
+            }
+        }
+        else
+            indices.create(numQuery, knn, CV_32S);
+
+        if (_dists.needed())
+        {
+            dists = _dists.getMat();
+            if (!dists.isContinuous() || dists.type() != cv::DataType<DataType>::type ||
+                dists.rows != numQuery || dists.cols != knn)
+            {
+                if (!_dists.isContinuous())
+                    _dists.release();
+                _dists.create(numQuery, knn, cv::DataType<DataType>::type);
+                dists = _dists.getMat();
+            }
+        }
+        else
+            dists.create(numQuery, knn, cv::DataType<DataType>::type);
+
+        auto processBatch = [&](const Range& range)
+        {
+            std::vector<int> nns;
+            std::vector<DataType> distances;
+
+            for (int i = range.start; i < range.end; ++i)
+            {
+                index->get_nns_by_vector(query.ptr<DataType>(i), knn, search_k, &nns, &distances);
+
+                std::copy(nns.begin(), nns.end(), indices.ptr<int>(i));
+                std::copy(distances.begin(), distances.end(), dists.ptr<DataType>(i));
+
+                nns.clear();
+                distances.clear();
+            }
+        };
+
+        parallel_for_(Range(0, numQuery), processBatch);
+    }
+
+    void save(const String &filename, bool prefault) CV_OVERRIDE
+    {
+        char* msg = nullptr;
+        if (!index->save(filename.c_str(), prefault, &msg))
+        {
+            if (msg)
+            {
+                String errorMsg = msg;
+                free(msg);
+                CV_Error(Error::StsError, errorMsg);
+            }
+            else
+            {
+                CV_Error(Error::StsError, "Fail to save the index.");
+            }
+        }
+    }
+
+    void load(const String &filename, bool prefault) CV_OVERRIDE
+    {
+        char* msg = nullptr;
+        if (!index->load(filename.c_str(), prefault, &msg))
+        {
+            if (msg)
+            {
+                String errorMsg = msg;
+                free(msg);
+                CV_Error(Error::StsError, errorMsg);
+            }
+            else
+            {
+                CV_Error(Error::StsError, "Fail to load the index.");
+            }
+        }
+    }
+
+    int getTreeNumber() CV_OVERRIDE
+    {
+        return index->get_n_trees();
+    }
+
+    int getItemNumber() CV_OVERRIDE
+    {
+        return index->get_n_items();
+    }
+
+    bool setOnDiskBuild(const String &filename) CV_OVERRIDE
+    {
+        char* msg = nullptr;
+        if (index->on_disk_build(filename.c_str(), &msg))
+            return true;
+        else
+        {
+            if (msg)
+            {
+                String errorMsg = msg;
+                CV_LOG_ERROR(NULL, errorMsg);
+                free(msg);
+            }
+            else
+            {
+                CV_LOG_ERROR(NULL, "Cannot set build on disk.");
+            }
+            return false;
+        }
+    }
+
+    void setSeed(int seed) CV_OVERRIDE
+    {
+        index->set_seed(static_cast<uint32_t>(seed));
+    }
+
+private:
+    int dim;
+    Ptr<::cvannoy::AnnoyIndex<int, DataType, DistanceType, Random, ::cvannoy::AnnoyIndexMultiThreadedBuildPolicy>> index;
+};
+
+Ptr<ANNIndex> ANNIndex::create(int dim, ANNIndex::Distance distType)
+{
+    switch (distType)
+    {
+        case ANNIndex::DIST_EUCLIDEAN:
+            return makePtr<ANNIndexImpl<float, ::cvannoy::Euclidean>>(dim);
+            break;
+        case ANNIndex::DIST_MANHATTAN:
+            return makePtr<ANNIndexImpl<float, ::cvannoy::Manhattan>>(dim);
+            break;
+        case ANNIndex::DIST_ANGULAR:
+            return makePtr<ANNIndexImpl<float, ::cvannoy::Angular>>(dim);
+            break;
+        case ANNIndex::DIST_HAMMING:
+            return makePtr<ANNIndexImpl<uchar, ::cvannoy::Hamming>>(dim);
+            break;
+        case ANNIndex::DIST_DOTPRODUCT:
+            return makePtr<ANNIndexImpl<float, ::cvannoy::DotProduct>>(dim);
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "Unknown/unsupported distance type");
+    }
+};
+
+}
\ No newline at end of file
diff --git a/upstream/opencv/modules/features/src/blobdetector.cpp b/upstream/opencv/modules/features/src/blobdetector.cpp
new file mode 100644
index 0000000..96229b0
--- /dev/null
+++ b/upstream/opencv/modules/features/src/blobdetector.cpp
@@ -0,0 +1,490 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <iterator>
+#include <limits>
+
+#include <opencv2/core/utils/logger.hpp>
+
+// Requires CMake flag: DEBUG_opencv_features=ON
+//#define DEBUG_BLOB_DETECTOR
+
+#ifdef DEBUG_BLOB_DETECTOR
+#include "opencv2/highgui.hpp"
+#endif
+
+namespace cv
+{
+
+class CV_EXPORTS_W SimpleBlobDetectorImpl : public SimpleBlobDetector
+{
+public:
+
+  explicit SimpleBlobDetectorImpl(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
+
+  virtual void read( const FileNode& fn ) CV_OVERRIDE;
+  virtual void write( FileStorage& fs ) const CV_OVERRIDE;
+
+  void setParams(const SimpleBlobDetector::Params& _params ) CV_OVERRIDE {
+    SimpleBlobDetectorImpl::validateParameters(_params);
+    params = _params;
+  }
+
+  SimpleBlobDetector::Params getParams() const CV_OVERRIDE { return params; }
+
+  static void validateParameters(const SimpleBlobDetector::Params& p)
+  {
+      if (p.thresholdStep <= 0)
+          CV_Error(Error::StsBadArg, "thresholdStep>0");
+
+      if (p.minThreshold > p.maxThreshold || p.minThreshold < 0)
+          CV_Error(Error::StsBadArg, "0<=minThreshold<=maxThreshold");
+
+      if (p.minDistBetweenBlobs <=0 )
+          CV_Error(Error::StsBadArg, "minDistBetweenBlobs>0");
+
+      if (p.minArea > p.maxArea || p.minArea <=0)
+          CV_Error(Error::StsBadArg, "0<minArea<=maxArea");
+
+      if (p.minCircularity > p.maxCircularity || p.minCircularity <= 0)
+          CV_Error(Error::StsBadArg, "0<minCircularity<=maxCircularity");
+
+      if (p.minInertiaRatio > p.maxInertiaRatio || p.minInertiaRatio <= 0)
+          CV_Error(Error::StsBadArg, "0<minInertiaRatio<=maxInertiaRatio");
+
+      if (p.minConvexity > p.maxConvexity || p.minConvexity <= 0)
+          CV_Error(Error::StsBadArg, "0<minConvexity<=maxConvexity");
+  }
+
+protected:
+  struct CV_EXPORTS Center
+  {
+      Point2d location;
+      double radius;
+      double confidence;
+  };
+
+  virtual void detect( InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask=noArray() ) CV_OVERRIDE;
+  virtual void findBlobs(InputArray image, InputArray binaryImage, std::vector<Center> &centers,
+                         std::vector<std::vector<Point> > &contours, std::vector<Moments> &moments) const;
+  virtual const std::vector<std::vector<Point> >& getBlobContours() const CV_OVERRIDE;
+
+  Params params;
+  std::vector<std::vector<Point> > blobContours;
+};
+
+/*
+*  SimpleBlobDetector
+*/
+SimpleBlobDetector::Params::Params()
+{
+    thresholdStep = 10;
+    minThreshold = 50;
+    maxThreshold = 220;
+    minRepeatability = 2;
+    minDistBetweenBlobs = 10;
+
+    filterByColor = true;
+    blobColor = 0;
+
+    filterByArea = true;
+    minArea = 25;
+    maxArea = 5000;
+
+    filterByCircularity = false;
+    minCircularity = 0.8f;
+    maxCircularity = std::numeric_limits<float>::max();
+
+    filterByInertia = true;
+    //minInertiaRatio = 0.6;
+    minInertiaRatio = 0.1f;
+    maxInertiaRatio = std::numeric_limits<float>::max();
+
+    filterByConvexity = true;
+    //minConvexity = 0.8;
+    minConvexity = 0.95f;
+    maxConvexity = std::numeric_limits<float>::max();
+
+    collectContours = false;
+}
+
+void SimpleBlobDetector::Params::read(const cv::FileNode& fn )
+{
+    thresholdStep = fn["thresholdStep"];
+    minThreshold = fn["minThreshold"];
+    maxThreshold = fn["maxThreshold"];
+
+    minRepeatability = (size_t)(int)fn["minRepeatability"];
+    minDistBetweenBlobs = fn["minDistBetweenBlobs"];
+
+    filterByColor = (int)fn["filterByColor"] != 0 ? true : false;
+    blobColor = (uchar)(int)fn["blobColor"];
+
+    filterByArea = (int)fn["filterByArea"] != 0 ? true : false;
+    minArea = fn["minArea"];
+    maxArea = fn["maxArea"];
+
+    filterByCircularity = (int)fn["filterByCircularity"] != 0 ? true : false;
+    minCircularity = fn["minCircularity"];
+    maxCircularity = fn["maxCircularity"];
+
+    filterByInertia = (int)fn["filterByInertia"] != 0 ? true : false;
+    minInertiaRatio = fn["minInertiaRatio"];
+    maxInertiaRatio = fn["maxInertiaRatio"];
+
+    filterByConvexity = (int)fn["filterByConvexity"] != 0 ? true : false;
+    minConvexity = fn["minConvexity"];
+    maxConvexity = fn["maxConvexity"];
+
+    collectContours = (int)fn["collectContours"] != 0 ? true : false;
+}
+
+void SimpleBlobDetector::Params::write(cv::FileStorage& fs) const
+{
+    fs << "thresholdStep" << thresholdStep;
+    fs << "minThreshold" << minThreshold;
+    fs << "maxThreshold" << maxThreshold;
+
+    fs << "minRepeatability" << (int)minRepeatability;
+    fs << "minDistBetweenBlobs" << minDistBetweenBlobs;
+
+    fs << "filterByColor" << (int)filterByColor;
+    fs << "blobColor" << (int)blobColor;
+
+    fs << "filterByArea" << (int)filterByArea;
+    fs << "minArea" << minArea;
+    fs << "maxArea" << maxArea;
+
+    fs << "filterByCircularity" << (int)filterByCircularity;
+    fs << "minCircularity" << minCircularity;
+    fs << "maxCircularity" << maxCircularity;
+
+    fs << "filterByInertia" << (int)filterByInertia;
+    fs << "minInertiaRatio" << minInertiaRatio;
+    fs << "maxInertiaRatio" << maxInertiaRatio;
+
+    fs << "filterByConvexity" << (int)filterByConvexity;
+    fs << "minConvexity" << minConvexity;
+    fs << "maxConvexity" << maxConvexity;
+
+    fs << "collectContours" << (int)collectContours;
+}
+
+SimpleBlobDetectorImpl::SimpleBlobDetectorImpl(const SimpleBlobDetector::Params &parameters) :
+params(parameters)
+{
+}
+
+void SimpleBlobDetectorImpl::read( const cv::FileNode& fn )
+{
+    SimpleBlobDetector::Params rp;
+    rp.read(fn);
+    SimpleBlobDetectorImpl::validateParameters(rp);
+    params = rp;
+}
+
+void SimpleBlobDetectorImpl::write( cv::FileStorage& fs ) const
+{
+    writeFormat(fs);
+    params.write(fs);
+}
+
+void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImage, std::vector<Center> &centers,
+                                       std::vector<std::vector<Point> > &contoursOut, std::vector<Moments> &momentss) const
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat image = _image.getMat(), binaryImage = _binaryImage.getMat();
+    CV_UNUSED(image);
+    centers.clear();
+    contoursOut.clear();
+    momentss.clear();
+
+    std::vector < std::vector<Point> > contours;
+    findContours(binaryImage, contours, RETR_LIST, CHAIN_APPROX_NONE);
+
+#ifdef DEBUG_BLOB_DETECTOR
+    Mat keypointsImage;
+    cvtColor(binaryImage, keypointsImage, COLOR_GRAY2RGB);
+
+    Mat contoursImage;
+    cvtColor(binaryImage, contoursImage, COLOR_GRAY2RGB);
+    drawContours( contoursImage, contours, -1, Scalar(0,255,0) );
+    imshow("contours", contoursImage );
+#endif
+
+    for (size_t contourIdx = 0; contourIdx < contours.size(); contourIdx++)
+    {
+        Center center;
+        center.confidence = 1;
+        Moments moms = moments(contours[contourIdx]);
+        if (params.filterByArea)
+        {
+            double area = moms.m00;
+            if (area < params.minArea || area >= params.maxArea)
+                continue;
+        }
+
+        if (params.filterByCircularity)
+        {
+            double area = moms.m00;
+            double perimeter = arcLength(contours[contourIdx], true);
+            double ratio = 4 * CV_PI * area / (perimeter * perimeter);
+            if (ratio < params.minCircularity || ratio >= params.maxCircularity)
+                continue;
+        }
+
+        if (params.filterByInertia)
+        {
+            double denominator = std::sqrt(std::pow(2 * moms.mu11, 2) + std::pow(moms.mu20 - moms.mu02, 2));
+            const double eps = 1e-2;
+            double ratio;
+            if (denominator > eps)
+            {
+                double cosmin = (moms.mu20 - moms.mu02) / denominator;
+                double sinmin = 2 * moms.mu11 / denominator;
+                double cosmax = -cosmin;
+                double sinmax = -sinmin;
+
+                double imin = 0.5 * (moms.mu20 + moms.mu02) - 0.5 * (moms.mu20 - moms.mu02) * cosmin - moms.mu11 * sinmin;
+                double imax = 0.5 * (moms.mu20 + moms.mu02) - 0.5 * (moms.mu20 - moms.mu02) * cosmax - moms.mu11 * sinmax;
+                ratio = imin / imax;
+            }
+            else
+            {
+                ratio = 1;
+            }
+
+            if (ratio < params.minInertiaRatio || ratio >= params.maxInertiaRatio)
+                continue;
+
+            center.confidence = ratio * ratio;
+        }
+
+        if (params.filterByConvexity)
+        {
+            std::vector < Point > hull;
+            convexHull(contours[contourIdx], hull);
+            double area = moms.m00;
+            double hullArea = contourArea(hull);
+            if (fabs(hullArea) < DBL_EPSILON)
+                continue;
+            double ratio = area / hullArea;
+            if (ratio < params.minConvexity || ratio >= params.maxConvexity)
+                continue;
+        }
+
+        if(moms.m00 == 0.0)
+            continue;
+        center.location = Point2d(moms.m10 / moms.m00, moms.m01 / moms.m00);
+
+        if (params.filterByColor)
+        {
+            if (binaryImage.at<uchar> (cvRound(center.location.y), cvRound(center.location.x)) != params.blobColor)
+                continue;
+        }
+
+        //compute blob radius
+        {
+            std::vector<double> dists;
+            for (size_t pointIdx = 0; pointIdx < contours[contourIdx].size(); pointIdx++)
+            {
+                Point2d pt = contours[contourIdx][pointIdx];
+                dists.push_back(norm(center.location - pt));
+            }
+            std::sort(dists.begin(), dists.end());
+            center.radius = (dists[(dists.size() - 1) / 2] + dists[dists.size() / 2]) / 2.;
+        }
+
+        centers.push_back(center);
+        if (params.collectContours)
+        {
+            contoursOut.push_back(contours[contourIdx]);
+            momentss.push_back(moms);
+        }
+
+#ifdef DEBUG_BLOB_DETECTOR
+        circle( keypointsImage, center.location, 1, Scalar(0,0,255), 1 );
+#endif
+    }
+#ifdef DEBUG_BLOB_DETECTOR
+    imshow("bk", keypointsImage );
+    waitKey();
+#endif
+}
+
+void SimpleBlobDetectorImpl::detect(InputArray image, std::vector<cv::KeyPoint>& keypoints, InputArray mask)
+{
+    CV_INSTRUMENT_REGION();
+
+    keypoints.clear();
+    blobContours.clear();
+
+    CV_Assert(params.minRepeatability != 0);
+    Mat grayscaleImage;
+    if (image.channels() == 3 || image.channels() == 4)
+        cvtColor(image, grayscaleImage, COLOR_BGR2GRAY);
+    else
+        grayscaleImage = image.getMat();
+
+    if (grayscaleImage.type() != CV_8UC1) {
+        CV_Error(Error::StsUnsupportedFormat, "Blob detector only supports 8-bit images!");
+    }
+
+    CV_CheckGT(params.thresholdStep, 0.0f, "");
+    if (params.minThreshold + params.thresholdStep >= params.maxThreshold)
+    {
+        // https://github.com/opencv/opencv/issues/6667
+        CV_LOG_ONCE_INFO(NULL, "SimpleBlobDetector: params.minDistBetweenBlobs is ignored for case with single threshold");
+        CV_CheckEQ(params.minRepeatability, 1u, "Incompatible parameters for case with single threshold");
+    }
+
+    std::vector < std::vector<Center> > centers;
+    std::vector<Moments> momentss;
+    for (double thresh = params.minThreshold; thresh < params.maxThreshold; thresh += params.thresholdStep)
+    {
+        Mat binarizedImage;
+        threshold(grayscaleImage, binarizedImage, thresh, 255, THRESH_BINARY);
+
+        std::vector < Center > curCenters;
+        std::vector<std::vector<Point> > curContours;
+        std::vector<Moments> curMomentss;
+        findBlobs(grayscaleImage, binarizedImage, curCenters, curContours, curMomentss);
+        std::vector < std::vector<Center> > newCenters;
+        std::vector<std::vector<Point> > newContours;
+        std::vector<Moments> newMomentss;
+        for (size_t i = 0; i < curCenters.size(); i++)
+        {
+            bool isNew = true;
+            for (size_t j = 0; j < centers.size(); j++)
+            {
+                double dist = norm(centers[j][ centers[j].size() / 2 ].location - curCenters[i].location);
+                isNew = dist >= params.minDistBetweenBlobs && dist >= centers[j][ centers[j].size() / 2 ].radius && dist >= curCenters[i].radius;
+                if (!isNew)
+                {
+                    centers[j].push_back(curCenters[i]);
+
+                    size_t k = centers[j].size() - 1;
+                    while( k > 0 && curCenters[i].radius < centers[j][k-1].radius )
+                    {
+                        centers[j][k] = centers[j][k-1];
+                        k--;
+                    }
+
+                    if (params.collectContours)
+                    {
+                        if (curCenters[i].confidence > centers[j][k].confidence
+                            || (curCenters[i].confidence == centers[j][k].confidence && curMomentss[i].m00 > momentss[j].m00))
+                        {
+                            blobContours[j] = curContours[i];
+                            momentss[j] = curMomentss[i];
+                        }
+                    }
+                    centers[j][k] = curCenters[i];
+
+                    break;
+                }
+            }
+            if (isNew)
+            {
+                newCenters.push_back(std::vector<Center> (1, curCenters[i]));
+                if (params.collectContours)
+                {
+                    newContours.push_back(curContours[i]);
+                    newMomentss.push_back(curMomentss[i]);
+                }
+            }
+        }
+        std::copy(newCenters.begin(), newCenters.end(), std::back_inserter(centers));
+        if (params.collectContours)
+        {
+            std::copy(newContours.begin(), newContours.end(), std::back_inserter(blobContours));
+            std::copy(newMomentss.begin(), newMomentss.end(), std::back_inserter(momentss));
+        }
+    }
+
+    for (size_t i = 0; i < centers.size(); i++)
+    {
+        if (centers[i].size() < params.minRepeatability)
+            continue;
+        Point2d sumPoint(0, 0);
+        double normalizer = 0;
+        for (size_t j = 0; j < centers[i].size(); j++)
+        {
+            sumPoint += centers[i][j].confidence * centers[i][j].location;
+            normalizer += centers[i][j].confidence;
+        }
+        sumPoint *= (1. / normalizer);
+        KeyPoint kpt(sumPoint, (float)(centers[i][centers[i].size() / 2].radius) * 2.0f);
+        keypoints.push_back(kpt);
+    }
+
+    if (!mask.empty())
+    {
+        if (params.collectContours)
+        {
+            KeyPointsFilter::runByPixelsMask2VectorPoint(keypoints, blobContours, mask.getMat());
+        }
+        else
+        {
+            KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
+        }
+    }
+}
+
+const std::vector<std::vector<Point> >& SimpleBlobDetectorImpl::getBlobContours() const {
+    return blobContours;
+}
+
+Ptr<SimpleBlobDetector> SimpleBlobDetector::create(const SimpleBlobDetector::Params& params)
+{
+    SimpleBlobDetectorImpl::validateParameters(params);
+    return makePtr<SimpleBlobDetectorImpl>(params);
+}
+
+String SimpleBlobDetector::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".SimpleBlobDetector");
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/disk.cpp b/upstream/opencv/modules/features/src/disk.cpp
new file mode 100644
index 0000000..7d652a5
--- /dev/null
+++ b/upstream/opencv/modules/features/src/disk.cpp
@@ -0,0 +1,234 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (C) 2026, BigVision LLC, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#include "precomp.hpp"
+#include "opencv2/features.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+
+#include <algorithm>
+#include <numeric>
+
+namespace cv {
+
+using namespace dnn;
+
+// Default network input size used when the user does not specify one explicitly.
+// Matches the fixed-shape standalone DISK ONNX export shipped in opencv_extra.
+static const Size kDefaultDiskInputSize = Size(1024, 1024);
+
+// DISK is a fully convolutional network with a 16x downsampling stride, so user-provided
+// input sizes must be positive multiples of 16.
+static const int kDiskStride = 16;
+
+class DISK_Impl CV_FINAL : public DISK
+{
+public:
+    DISK_Impl(const String& modelPath, int maxKeypoints, float scoreThreshold,
+              const Size& imageSize, int backendId, int targetId)
+        : maxKeypoints_(maxKeypoints),
+          scoreThreshold_(scoreThreshold),
+          imageSize_(imageSize)
+    {
+        validateImageSize(imageSize_);
+        initNet(readNetFromONNX(modelPath), backendId, targetId);
+    }
+
+    DISK_Impl(const std::vector<uchar>& bufferModel, int maxKeypoints, float scoreThreshold,
+              const Size& imageSize, int backendId, int targetId)
+        : maxKeypoints_(maxKeypoints),
+          scoreThreshold_(scoreThreshold),
+          imageSize_(imageSize)
+    {
+        validateImageSize(imageSize_);
+        initNet(readNetFromONNX(bufferModel), backendId, targetId);
+    }
+
+    void detectAndCompute(InputArray _image, InputArray _mask,
+                          std::vector<KeyPoint>& keypoints,
+                          OutputArray _descriptors,
+                          bool useProvidedKeypoints) CV_OVERRIDE
+    {
+        CV_Assert(!useProvidedKeypoints && "DISK does not support providing keypoints externally");
+
+        keypoints.clear();
+
+        Mat image = _image.getMat();
+        if (image.empty())
+        {
+            if (_descriptors.needed())
+                _descriptors.release();
+            return;
+        }
+
+        Mat mask = _mask.getMat();
+        if (!mask.empty())
+        {
+            CV_Assert(mask.type() == CV_8UC1);
+            CV_Assert(mask.size() == image.size());
+        }
+
+        const Size netSize = (imageSize_.width > 0 && imageSize_.height > 0) ? imageSize_ : kDefaultDiskInputSize;
+        const float scaleX = static_cast<float>(image.cols) / netSize.width;
+        const float scaleY = static_cast<float>(image.rows) / netSize.height;
+
+        Mat blob;
+        // 1/255 normalization, swap BGR->RGB, no mean subtraction.
+        blobFromImage(image, blob, 1.0 / 255.0, netSize, Scalar(), /*swapRB=*/true, /*crop=*/false);
+        net_.setInput(blob, "image");
+
+        const std::vector<String> outNames = {"keypoints", "scores", "descriptors"};
+        std::vector<Mat> outs;
+        net_.forward(outs, outNames);
+        CV_Assert(outs.size() == 3);
+
+        // DISK's ONNX export emits keypoints as int64 pixel coordinates, scores and
+        // descriptors as float32. Reshape each output to (N, *) for row-wise indexing.
+        Mat kptsBlob   = outs[0].reshape(1, outs[0].size[1]); // N x 2, int64
+        Mat scoresBlob = outs[1].reshape(1, outs[1].size[1]); // N x 1, float32
+        Mat descBlob   = outs[2].reshape(1, outs[2].size[1]); // N x D, float32
+
+        CV_Assert(kptsBlob.depth()   == CV_64S);
+        CV_Assert(scoresBlob.depth() == CV_32F);
+        CV_Assert(descBlob.depth()   == CV_32F);
+
+        const int numFeatures = kptsBlob.rows;
+        CV_Assert(scoresBlob.rows == numFeatures);
+        CV_Assert(descBlob.rows == numFeatures);
+
+        const int64_t* kptsData   = kptsBlob.ptr<int64_t>();
+        const float*   scoresData = scoresBlob.ptr<float>();
+
+        std::vector<int> validIndices;
+        validIndices.reserve(numFeatures);
+        keypoints.reserve(numFeatures);
+
+        for (int i = 0; i < numFeatures; ++i)
+        {
+            const float score = scoresData[i];
+            if (score <= scoreThreshold_)
+                continue;
+
+            const float x = static_cast<float>(kptsData[i * 2])     * scaleX;
+            const float y = static_cast<float>(kptsData[i * 2 + 1]) * scaleY;
+
+            if (!mask.empty())
+            {
+                const int ix = cvFloor(x);
+                const int iy = cvFloor(y);
+                if (ix < 0 || iy < 0 || ix >= mask.cols || iy >= mask.rows)
+                    continue;
+                if (mask.at<uchar>(iy, ix) == 0)
+                    continue;
+            }
+
+            keypoints.emplace_back(x, y, 1.0f, -1.0f, score);
+            validIndices.push_back(i);
+        }
+
+        if (maxKeypoints_ > 0 && static_cast<int>(keypoints.size()) > maxKeypoints_)
+        {
+            std::vector<int> order(keypoints.size());
+            std::iota(order.begin(), order.end(), 0);
+            std::partial_sort(order.begin(), order.begin() + maxKeypoints_, order.end(),
+                [&](int a, int b) { return keypoints[a].response > keypoints[b].response; });
+            order.resize(maxKeypoints_);
+
+            std::vector<KeyPoint> kept;
+            std::vector<int> keptIdx;
+            kept.reserve(maxKeypoints_);
+            keptIdx.reserve(maxKeypoints_);
+            for (int idx : order)
+            {
+                kept.push_back(keypoints[idx]);
+                keptIdx.push_back(validIndices[idx]);
+            }
+            keypoints.swap(kept);
+            validIndices.swap(keptIdx);
+        }
+
+        if (_descriptors.needed())
+        {
+            if (validIndices.empty())
+            {
+                _descriptors.release();
+                return;
+            }
+            const int dim = descBlob.cols;
+            _descriptors.create(static_cast<int>(validIndices.size()), dim, CV_32F);
+            Mat descriptors = _descriptors.getMat();
+            for (size_t i = 0; i < validIndices.size(); ++i)
+                descBlob.row(validIndices[i]).copyTo(descriptors.row(static_cast<int>(i)));
+        }
+    }
+
+    int descriptorSize() const CV_OVERRIDE { return 128; }
+    int descriptorType() const CV_OVERRIDE { return CV_32F; }
+    int defaultNorm()    const CV_OVERRIDE { return NORM_L2; }
+
+    bool empty() const CV_OVERRIDE { return net_.empty(); }
+
+    void setMaxKeypoints(int maxKeypoints) CV_OVERRIDE { maxKeypoints_ = maxKeypoints; }
+    int  getMaxKeypoints() const CV_OVERRIDE { return maxKeypoints_; }
+
+    void  setScoreThreshold(float threshold) CV_OVERRIDE { scoreThreshold_ = threshold; }
+    float getScoreThreshold() const CV_OVERRIDE { return scoreThreshold_; }
+
+    void setImageSize(const Size& size) CV_OVERRIDE
+    {
+        validateImageSize(size);
+        imageSize_ = size;
+    }
+    Size getImageSize() const CV_OVERRIDE { return imageSize_; }
+
+    String getDefaultName() const CV_OVERRIDE { return Feature2D::getDefaultName() + ".DISK"; }
+
+private:
+    void initNet(const Net& net, int backendId, int targetId)
+    {
+        net_ = net;
+        net_.setPreferableBackend(backendId);
+        net_.setPreferableTarget(targetId);
+    }
+
+    static void validateImageSize(const Size& size)
+    {
+        if (size.width == 0 && size.height == 0)
+            return; // use default
+        CV_Assert(size.width > 0 && size.height > 0);
+        CV_Assert(size.width  % kDiskStride == 0);
+        CV_Assert(size.height % kDiskStride == 0);
+    }
+
+    int    maxKeypoints_;
+    float  scoreThreshold_;
+    Size   imageSize_;
+    Net    net_;
+};
+
+Ptr<DISK> DISK::create(const String& modelPath, int maxKeypoints, float scoreThreshold,
+                       const Size& imageSize, int backendId, int targetId)
+{
+    CV_TRACE_FUNCTION();
+    return makePtr<DISK_Impl>(modelPath, maxKeypoints, scoreThreshold, imageSize, backendId, targetId);
+}
+
+Ptr<DISK> DISK::create(const std::vector<uchar>& bufferModel, int maxKeypoints, float scoreThreshold,
+                       const Size& imageSize, int backendId, int targetId)
+{
+    CV_TRACE_FUNCTION();
+    return makePtr<DISK_Impl>(bufferModel, maxKeypoints, scoreThreshold, imageSize, backendId, targetId);
+}
+
+String DISK::getDefaultName() const
+{
+    return Feature2D::getDefaultName() + ".DISK";
+}
+
+} // namespace cv
+
+#endif // HAVE_OPENCV_DNN
diff --git a/upstream/opencv/modules/features/src/draw.cpp b/upstream/opencv/modules/features/src/draw.cpp
new file mode 100644
index 0000000..86f06dc
--- /dev/null
+++ b/upstream/opencv/modules/features/src/draw.cpp
@@ -0,0 +1,279 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+const int draw_shift_bits = 4;
+const int draw_multiplier = 1 << draw_shift_bits;
+
+namespace cv
+{
+
+/*
+ * Functions to draw keypoints and matches.
+ */
+static inline void _drawKeypoint( InputOutputArray img, const KeyPoint& p, const Scalar& color, DrawMatchesFlags flags )
+{
+    CV_Assert( !img.empty() );
+    Point center( cvRound(p.pt.x * draw_multiplier), cvRound(p.pt.y * draw_multiplier) );
+
+    if( !!(flags & DrawMatchesFlags::DRAW_RICH_KEYPOINTS) )
+    {
+        int radius = cvRound(p.size/2 * draw_multiplier); // KeyPoint::size is a diameter
+
+        // draw the circles around keypoints with the keypoints size
+        circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
+
+        // draw orientation of the keypoint, if it is applicable
+        if( p.angle != -1 )
+        {
+            float srcAngleRad = p.angle*(float)CV_PI/180.f;
+            Point orient( cvRound(cos(srcAngleRad)*radius ),
+                          cvRound(sin(srcAngleRad)*radius )
+                        );
+            line( img, center, center+orient, color, 1, LINE_AA, draw_shift_bits );
+        }
+#if 0
+        else
+        {
+            // draw center with R=1
+            int radius = 1 * draw_multiplier;
+            circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
+        }
+#endif
+    }
+    else
+    {
+        // draw center with R=3
+        int radius = 3 * draw_multiplier;
+        circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
+    }
+}
+
+void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage,
+                    const Scalar& _color, DrawMatchesFlags flags )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( !(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) )
+    {
+        if (image.type() == CV_8UC3 || image.type() == CV_8UC4)
+        {
+            image.copyTo(outImage);
+        }
+        else if( image.type() == CV_8UC1 )
+        {
+            cvtColor( image, outImage, COLOR_GRAY2BGR );
+        }
+        else
+        {
+            CV_Error( Error::StsBadArg, "Incorrect type of input image: " + typeToString(image.type()) );
+        }
+    }
+
+    RNG& rng=theRNG();
+    bool isRandColor = _color == Scalar::all(-1);
+
+    CV_Assert( !outImage.empty() );
+    std::vector<KeyPoint>::const_iterator it = keypoints.begin(),
+                                     end = keypoints.end();
+    for( ; it != end; ++it )
+    {
+        Scalar color = isRandColor ? Scalar( rng(256), rng(256), rng(256), 255 ) : _color;
+        _drawKeypoint( outImage, *it, color, flags );
+    }
+}
+
+static void _prepareImage(InputArray src, const Mat& dst)
+{
+    CV_CheckType(src.type(), src.type() == CV_8UC1 || src.type() == CV_8UC3 || src.type() == CV_8UC4, "Unsupported source image");
+    CV_CheckType(dst.type(), dst.type() == CV_8UC3 || dst.type() == CV_8UC4, "Unsupported destination image");
+    const int src_cn = src.channels();
+    const int dst_cn = dst.channels();
+
+    if (src_cn == dst_cn)
+        src.copyTo(dst);
+    else if (src_cn == 1)
+        cvtColor(src, dst, dst_cn == 3 ? COLOR_GRAY2BGR : COLOR_GRAY2BGRA);
+    else if (src_cn == 3 && dst_cn == 4)
+        cvtColor(src, dst, COLOR_BGR2BGRA);
+    else if (src_cn == 4 && dst_cn == 3)
+        cvtColor(src, dst, COLOR_BGRA2BGR);
+    else
+        CV_Error(Error::StsInternal, "");
+}
+
+static void _prepareImgAndDrawKeypoints( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                                         InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                                         InputOutputArray _outImg, Mat& outImg1, Mat& outImg2,
+                                         const Scalar& singlePointColor, DrawMatchesFlags flags )
+{
+    Mat outImg;
+    Size img1size = img1.size(), img2size = img2.size();
+    Size size( img1size.width + img2size.width, MAX(img1size.height, img2size.height) );
+    if( !!(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) )
+    {
+        outImg = _outImg.getMat();
+        if( size.width > outImg.cols || size.height > outImg.rows )
+            CV_Error( Error::StsBadSize, "outImg has size less than need to draw img1 and img2 together" );
+        outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) );
+        outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) );
+    }
+    else
+    {
+        const int cn1 = img1.channels(), cn2 = img2.channels();
+        const int out_cn = std::max(3, std::max(cn1, cn2));
+        _outImg.create(size, CV_MAKETYPE(img1.depth(), out_cn));
+        outImg = _outImg.getMat();
+        outImg = Scalar::all(0);
+        outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) );
+        outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) );
+
+        _prepareImage(img1, outImg1);
+        _prepareImage(img2, outImg2);
+    }
+
+    // draw keypoints
+    if( !(flags & DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS) )
+    {
+        Mat _outImg1 = outImg( Rect(0, 0, img1size.width, img1size.height) );
+        drawKeypoints( _outImg1, keypoints1, _outImg1, singlePointColor, flags | DrawMatchesFlags::DRAW_OVER_OUTIMG );
+
+        Mat _outImg2 = outImg( Rect(img1size.width, 0, img2size.width, img2size.height) );
+        drawKeypoints( _outImg2, keypoints2, _outImg2, singlePointColor, flags | DrawMatchesFlags::DRAW_OVER_OUTIMG );
+    }
+}
+
+static inline void _drawMatch( InputOutputArray outImg, InputOutputArray outImg1, InputOutputArray outImg2 ,
+                          const KeyPoint& kp1, const KeyPoint& kp2, const Scalar& matchColor, DrawMatchesFlags flags,
+                          const int matchesThickness )
+{
+    RNG& rng = theRNG();
+    bool isRandMatchColor = matchColor == Scalar::all(-1);
+    Scalar color = isRandMatchColor ? Scalar( rng(256), rng(256), rng(256), 255 ) : matchColor;
+
+    _drawKeypoint( outImg1, kp1, color, flags );
+    _drawKeypoint( outImg2, kp2, color, flags );
+
+    Point2f pt1 = kp1.pt,
+            pt2 = kp2.pt,
+            dpt2 = Point2f( std::min(pt2.x+outImg1.size().width, float(outImg.size().width-1)), pt2.y );
+
+    line( outImg,
+          Point(cvRound(pt1.x*draw_multiplier), cvRound(pt1.y*draw_multiplier)),
+          Point(cvRound(dpt2.x*draw_multiplier), cvRound(dpt2.y*draw_multiplier)),
+          color, matchesThickness, LINE_AA, draw_shift_bits );
+}
+
+void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                  InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                  const std::vector<DMatch>& matches1to2, InputOutputArray outImg,
+                  const Scalar& matchColor, const Scalar& singlePointColor,
+                  const std::vector<char>& matchesMask, DrawMatchesFlags flags )
+{
+    drawMatches( img1, keypoints1,
+                 img2, keypoints2,
+                 matches1to2, outImg,
+                 1, matchColor,
+                 singlePointColor, matchesMask,
+                 flags);
+}
+
+void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                  InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                  const std::vector<DMatch>& matches1to2, InputOutputArray outImg,
+                  const int matchesThickness, const Scalar& matchColor,
+                  const Scalar& singlePointColor, const std::vector<char>& matchesMask,
+                  DrawMatchesFlags flags )
+{
+    if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
+        CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );
+
+    Mat outImg1, outImg2;
+    _prepareImgAndDrawKeypoints( img1, keypoints1, img2, keypoints2,
+                                 outImg, outImg1, outImg2, singlePointColor, flags );
+
+    // draw matches
+    for( size_t m = 0; m < matches1to2.size(); m++ )
+    {
+        if( matchesMask.empty() || matchesMask[m] )
+        {
+            int i1 = matches1to2[m].queryIdx;
+            int i2 = matches1to2[m].trainIdx;
+            CV_Assert(i1 >= 0 && i1 < static_cast<int>(keypoints1.size()));
+            CV_Assert(i2 >= 0 && i2 < static_cast<int>(keypoints2.size()));
+
+            const KeyPoint &kp1 = keypoints1[i1], &kp2 = keypoints2[i2];
+            _drawMatch( outImg, outImg1, outImg2, kp1, kp2, matchColor, flags, matchesThickness );
+        }
+    }
+}
+
+
+void drawMatches( InputArray img1, const std::vector<KeyPoint>& keypoints1,
+                  InputArray img2, const std::vector<KeyPoint>& keypoints2,
+                  const std::vector<std::vector<DMatch> >& matches1to2, InputOutputArray outImg,
+                  const Scalar& matchColor, const Scalar& singlePointColor,
+                  const std::vector<std::vector<char> >& matchesMask, DrawMatchesFlags flags )
+{
+    if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
+        CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );
+
+    Mat outImg1, outImg2;
+    _prepareImgAndDrawKeypoints( img1, keypoints1, img2, keypoints2,
+                                 outImg, outImg1, outImg2, singlePointColor, flags );
+
+    // draw matches
+    for( size_t i = 0; i < matches1to2.size(); i++ )
+    {
+        for( size_t j = 0; j < matches1to2[i].size(); j++ )
+        {
+            int i1 = matches1to2[i][j].queryIdx;
+            int i2 = matches1to2[i][j].trainIdx;
+            if( matchesMask.empty() || matchesMask[i][j] )
+            {
+                const KeyPoint &kp1 = keypoints1[i1], &kp2 = keypoints2[i2];
+                _drawMatch( outImg, outImg1, outImg2, kp1, kp2, matchColor, flags, 1 );
+            }
+        }
+    }
+}
+}
diff --git a/upstream/opencv/modules/features/src/dynamic.cpp b/upstream/opencv/modules/features/src/dynamic.cpp
new file mode 100644
index 0000000..1806a27
--- /dev/null
+++ b/upstream/opencv/modules/features/src/dynamic.cpp
@@ -0,0 +1,47 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+namespace cv
+{
+
+}
diff --git a/upstream/opencv/modules/features/src/evaluation.cpp b/upstream/opencv/modules/features/src/evaluation.cpp
new file mode 100644
index 0000000..281c23a
--- /dev/null
+++ b/upstream/opencv/modules/features/src/evaluation.cpp
@@ -0,0 +1,572 @@
+//*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include <limits>
+
+using namespace cv;
+
+template<typename _Tp> static int solveQuadratic(_Tp a, _Tp b, _Tp c, _Tp& x1, _Tp& x2)
+{
+    if( a == 0 )
+    {
+        if( b == 0 )
+        {
+            x1 = x2 = 0;
+            return c == 0;
+        }
+        x1 = x2 = -c/b;
+        return 1;
+    }
+
+    _Tp d = b*b - 4*a*c;
+    if( d < 0 )
+    {
+        x1 = x2 = 0;
+        return 0;
+    }
+    if( d > 0 )
+    {
+        d = std::sqrt(d);
+        double s = 1/(2*a);
+        x1 = (-b - d)*s;
+        x2 = (-b + d)*s;
+        if( x1 > x2 )
+            std::swap(x1, x2);
+        return 2;
+    }
+    x1 = x2 = -b/(2*a);
+    return 1;
+}
+
+//for android ndk
+#undef _S
+static inline Point2f applyHomography( const Mat_<double>& H, const Point2f& pt )
+{
+    double z = H(2,0)*pt.x + H(2,1)*pt.y + H(2,2);
+    if( z )
+    {
+        double w = 1./z;
+        return Point2f( (float)((H(0,0)*pt.x + H(0,1)*pt.y + H(0,2))*w), (float)((H(1,0)*pt.x + H(1,1)*pt.y + H(1,2))*w) );
+    }
+    return Point2f( std::numeric_limits<float>::max(), std::numeric_limits<float>::max() );
+}
+
+static inline void linearizeHomographyAt( const Mat_<double>& H, const Point2f& pt, Mat_<double>& A )
+{
+    A.create(2,2);
+    double p1 = H(0,0)*pt.x + H(0,1)*pt.y + H(0,2),
+           p2 = H(1,0)*pt.x + H(1,1)*pt.y + H(1,2),
+           p3 = H(2,0)*pt.x + H(2,1)*pt.y + H(2,2),
+           p3_2 = p3*p3;
+    if( p3 )
+    {
+        A(0,0) = H(0,0)/p3 - p1*H(2,0)/p3_2; // fxdx
+        A(0,1) = H(0,1)/p3 - p1*H(2,1)/p3_2; // fxdy
+
+        A(1,0) = H(1,0)/p3 - p2*H(2,0)/p3_2; // fydx
+        A(1,1) = H(1,1)/p3 - p2*H(2,1)/p3_2; // fydx
+    }
+    else
+        A.setTo(Scalar::all(std::numeric_limits<double>::max()));
+}
+
+class EllipticKeyPoint
+{
+public:
+    EllipticKeyPoint();
+    EllipticKeyPoint( const Point2f& _center, const Scalar& _ellipse );
+
+    static void convert( const std::vector<KeyPoint>& src, std::vector<EllipticKeyPoint>& dst );
+    static void convert( const std::vector<EllipticKeyPoint>& src, std::vector<KeyPoint>& dst );
+
+    static Mat_<double> getSecondMomentsMatrix( const Scalar& _ellipse );
+    Mat_<double> getSecondMomentsMatrix() const;
+
+    void calcProjection( const Mat_<double>& H, EllipticKeyPoint& projection ) const;
+    static void calcProjection( const std::vector<EllipticKeyPoint>& src, const Mat_<double>& H, std::vector<EllipticKeyPoint>& dst );
+
+    Point2f center;
+    Scalar ellipse; // 3 elements a, b, c: ax^2+2bxy+cy^2=1
+    Size_<float> axes; // half length of ellipse axes
+    Size_<float> boundingBox; // half sizes of bounding box which sides are parallel to the coordinate axes
+};
+
+EllipticKeyPoint::EllipticKeyPoint()
+{
+    *this = EllipticKeyPoint(Point2f(0,0), Scalar(1, 0, 1) );
+}
+
+EllipticKeyPoint::EllipticKeyPoint( const Point2f& _center, const Scalar& _ellipse )
+{
+    center = _center;
+    ellipse = _ellipse;
+
+    double a = ellipse[0], b = ellipse[1], c = ellipse[2];
+    double ac_b2 = a*c - b*b;
+    double x1, x2;
+    solveQuadratic(1., -(a+c), ac_b2, x1, x2);
+    axes.width = (float)(1/sqrt(x1));
+    axes.height = (float)(1/sqrt(x2));
+
+    boundingBox.width = (float)sqrt(ellipse[2]/ac_b2);
+    boundingBox.height = (float)sqrt(ellipse[0]/ac_b2);
+}
+
+Mat_<double> EllipticKeyPoint::getSecondMomentsMatrix( const Scalar& _ellipse )
+{
+    Mat_<double> M(2, 2);
+    M(0,0) = _ellipse[0];
+    M(1,0) = M(0,1) = _ellipse[1];
+    M(1,1) = _ellipse[2];
+    return M;
+}
+
+Mat_<double> EllipticKeyPoint::getSecondMomentsMatrix() const
+{
+    return getSecondMomentsMatrix(ellipse);
+}
+
+void EllipticKeyPoint::calcProjection( const Mat_<double>& H, EllipticKeyPoint& projection ) const
+{
+    Point2f dstCenter = applyHomography(H, center);
+
+    Mat_<double> invM; invert(getSecondMomentsMatrix(), invM);
+    Mat_<double> Aff; linearizeHomographyAt(H, center, Aff);
+    Mat_<double> dstM; invert(Aff*invM*Aff.t(), dstM);
+
+    projection = EllipticKeyPoint( dstCenter, Scalar(dstM(0,0), dstM(0,1), dstM(1,1)) );
+}
+
+void EllipticKeyPoint::convert( const std::vector<KeyPoint>& src, std::vector<EllipticKeyPoint>& dst )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( !src.empty() )
+    {
+        dst.resize(src.size());
+        for( size_t i = 0; i < src.size(); i++ )
+        {
+            float rad = src[i].size/2;
+            CV_Assert( rad );
+            float fac = 1.f/(rad*rad);
+            dst[i] = EllipticKeyPoint( src[i].pt, Scalar(fac, 0, fac) );
+        }
+    }
+}
+
+void EllipticKeyPoint::convert( const std::vector<EllipticKeyPoint>& src, std::vector<KeyPoint>& dst )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( !src.empty() )
+    {
+        dst.resize(src.size());
+        for( size_t i = 0; i < src.size(); i++ )
+        {
+            Size_<float> axes = src[i].axes;
+            float rad = sqrt(axes.height*axes.width);
+            dst[i] = KeyPoint(src[i].center, 2*rad );
+        }
+    }
+}
+
+void EllipticKeyPoint::calcProjection( const std::vector<EllipticKeyPoint>& src, const Mat_<double>& H, std::vector<EllipticKeyPoint>& dst )
+{
+    if( !src.empty() )
+    {
+        CV_Assert( !H.empty() && H.cols == 3 && H.rows == 3);
+        dst.resize(src.size());
+        std::vector<EllipticKeyPoint>::const_iterator srcIt = src.begin();
+        std::vector<EllipticKeyPoint>::iterator       dstIt = dst.begin();
+        for( ; srcIt != src.end() && dstIt != dst.end(); ++srcIt, ++dstIt )
+            srcIt->calcProjection(H, *dstIt);
+    }
+}
+
+static void filterEllipticKeyPointsByImageSize( std::vector<EllipticKeyPoint>& keypoints, const Size& imgSize )
+{
+    if( !keypoints.empty() )
+    {
+        std::vector<EllipticKeyPoint> filtered;
+        filtered.reserve(keypoints.size());
+        std::vector<EllipticKeyPoint>::const_iterator it = keypoints.begin();
+        for( ; it != keypoints.end(); ++it )
+        {
+            if( it->center.x + it->boundingBox.width < imgSize.width &&
+                it->center.x - it->boundingBox.width > 0 &&
+                it->center.y + it->boundingBox.height < imgSize.height &&
+                it->center.y - it->boundingBox.height > 0 )
+                filtered.push_back(*it);
+        }
+        keypoints.assign(filtered.begin(), filtered.end());
+    }
+}
+
+struct IntersectAreaCounter
+{
+    IntersectAreaCounter( float _dr, int _minx,
+                          int _miny, int _maxy,
+                          const Point2f& _diff,
+                          const Scalar& _ellipse1, const Scalar& _ellipse2 ) :
+               dr(_dr), bua(0), bna(0), minx(_minx), miny(_miny), maxy(_maxy),
+               diff(_diff), ellipse1(_ellipse1), ellipse2(_ellipse2) {}
+    IntersectAreaCounter( const IntersectAreaCounter& counter, Split )
+    {
+        *this = counter;
+        bua = 0;
+        bna = 0;
+    }
+
+    void operator()( const BlockedRange& range )
+    {
+        CV_Assert( miny < maxy );
+        CV_Assert( dr > FLT_EPSILON );
+
+        int temp_bua = bua, temp_bna = bna;
+        for( int i = range.begin(); i != range.end(); i++ )
+        {
+            float rx1 = minx + i*dr;
+            float rx2 = rx1 - diff.x;
+            for( float ry1 = (float)miny; ry1 <= (float)maxy; ry1 += dr )
+            {
+                float ry2 = ry1 - diff.y;
+                //compute the distance from the ellipse center
+                float e1 = (float)(ellipse1[0]*rx1*rx1 + 2*ellipse1[1]*rx1*ry1 + ellipse1[2]*ry1*ry1);
+                float e2 = (float)(ellipse2[0]*rx2*rx2 + 2*ellipse2[1]*rx2*ry2 + ellipse2[2]*ry2*ry2);
+                //compute the area
+                if( e1<1 && e2<1 ) temp_bna++;
+                if( e1<1 || e2<1 ) temp_bua++;
+            }
+        }
+        bua = temp_bua;
+        bna = temp_bna;
+    }
+
+    void join( IntersectAreaCounter& ac )
+    {
+        bua += ac.bua;
+        bna += ac.bna;
+    }
+
+    float dr;
+    int bua, bna;
+
+    int minx;
+    int miny, maxy;
+
+    Point2f diff;
+    Scalar ellipse1, ellipse2;
+
+};
+
+struct SIdx
+{
+    SIdx() : S(-1), i1(-1), i2(-1) {}
+    SIdx(float _S, int _i1, int _i2) : S(_S), i1(_i1), i2(_i2) {}
+    float S;
+    int i1;
+    int i2;
+
+    bool operator<(const SIdx& v) const { return S > v.S; }
+
+    struct UsedFinder
+    {
+        UsedFinder(const SIdx& _used) : used(_used) {}
+        const SIdx& used;
+        bool operator()(const SIdx& v) const { return  (v.i1 == used.i1 || v.i2 == used.i2); }
+        UsedFinder& operator=(const UsedFinder&) = delete;
+        // To avoid -Wdeprecated-copy warning, copy constructor is needed.
+        UsedFinder(const UsedFinder&) = default;
+    };
+};
+
+static void computeOneToOneMatchedOverlaps( const std::vector<EllipticKeyPoint>& keypoints1, const std::vector<EllipticKeyPoint>& keypoints2t,
+                                            bool commonPart, std::vector<SIdx>& overlaps, float minOverlap )
+{
+    CV_Assert( minOverlap >= 0.f );
+    overlaps.clear();
+    if( keypoints1.empty() || keypoints2t.empty() )
+        return;
+
+    overlaps.clear();
+    overlaps.reserve(cvRound(keypoints1.size() * keypoints2t.size() * 0.01));
+
+    for( size_t i1 = 0; i1 < keypoints1.size(); i1++ )
+    {
+        EllipticKeyPoint kp1 = keypoints1[i1];
+        float maxDist = sqrt(kp1.axes.width*kp1.axes.height),
+              fac = 30.f/maxDist;
+        if( !commonPart )
+            fac=3;
+
+        maxDist = maxDist*4;
+        fac = 1.f/(fac*fac);
+
+        EllipticKeyPoint keypoint1a = EllipticKeyPoint( kp1.center, Scalar(fac*kp1.ellipse[0], fac*kp1.ellipse[1], fac*kp1.ellipse[2]) );
+
+        for( size_t i2 = 0; i2 < keypoints2t.size(); i2++ )
+        {
+            EllipticKeyPoint kp2 = keypoints2t[i2];
+            Point2f diff = kp2.center - kp1.center;
+
+            if( norm(diff) < maxDist )
+            {
+                EllipticKeyPoint keypoint2a = EllipticKeyPoint( kp2.center, Scalar(fac*kp2.ellipse[0], fac*kp2.ellipse[1], fac*kp2.ellipse[2]) );
+                //find the largest eigenvalue
+                int maxx =  (int)ceil(( keypoint1a.boundingBox.width > (diff.x+keypoint2a.boundingBox.width)) ?
+                                     keypoint1a.boundingBox.width : (diff.x+keypoint2a.boundingBox.width));
+                int minx = (int)floor((-keypoint1a.boundingBox.width < (diff.x-keypoint2a.boundingBox.width)) ?
+                                    -keypoint1a.boundingBox.width : (diff.x-keypoint2a.boundingBox.width));
+
+                int maxy =  (int)ceil(( keypoint1a.boundingBox.height > (diff.y+keypoint2a.boundingBox.height)) ?
+                                     keypoint1a.boundingBox.height : (diff.y+keypoint2a.boundingBox.height));
+                int miny = (int)floor((-keypoint1a.boundingBox.height < (diff.y-keypoint2a.boundingBox.height)) ?
+                                    -keypoint1a.boundingBox.height : (diff.y-keypoint2a.boundingBox.height));
+                int mina = (maxx-minx) < (maxy-miny) ? (maxx-minx) : (maxy-miny) ;
+
+                //compute the area
+                float dr = (float)mina/50.f;
+                int N = (int)floor((float)(maxx - minx) / dr);
+                IntersectAreaCounter ac( dr, minx, miny, maxy, diff, keypoint1a.ellipse, keypoint2a.ellipse );
+                parallel_reduce( BlockedRange(0, N+1), ac );
+                if( ac.bna > 0 )
+                {
+                    float ov =  (float)ac.bna / (float)ac.bua;
+                    if( ov >= minOverlap )
+                        overlaps.push_back(SIdx(ov, (int)i1, (int)i2));
+                }
+            }
+        }
+    }
+
+    std::sort( overlaps.begin(), overlaps.end() );
+
+    typedef std::vector<SIdx>::iterator It;
+
+    It pos = overlaps.begin();
+    It end = overlaps.end();
+
+    while(pos != end)
+    {
+        It prev = pos++;
+        end = std::remove_if(pos, end, SIdx::UsedFinder(*prev));
+    }
+    overlaps.erase(pos, overlaps.end());
+}
+
+static void calculateRepeatability( const Mat& img1, const Mat& img2, const Mat& H1to2,
+                                    const std::vector<KeyPoint>& _keypoints1, const std::vector<KeyPoint>& _keypoints2,
+                                    float& repeatability, int& correspondencesCount,
+                                    Mat* thresholdedOverlapMask=0  )
+{
+    std::vector<EllipticKeyPoint> keypoints1, keypoints2, keypoints1t, keypoints2t;
+    EllipticKeyPoint::convert( _keypoints1, keypoints1 );
+    EllipticKeyPoint::convert( _keypoints2, keypoints2 );
+
+    // calculate projections of key points
+    EllipticKeyPoint::calcProjection( keypoints1, H1to2, keypoints1t );
+    Mat H2to1; invert(H1to2, H2to1);
+    EllipticKeyPoint::calcProjection( keypoints2, H2to1, keypoints2t );
+
+    float overlapThreshold;
+    bool ifEvaluateDetectors = thresholdedOverlapMask == 0;
+    if( ifEvaluateDetectors )
+    {
+        overlapThreshold = 1.f - 0.4f;
+
+        // remove key points from outside of the common image part
+        Size sz1 = img1.size(), sz2 = img2.size();
+        filterEllipticKeyPointsByImageSize( keypoints1, sz1 );
+        filterEllipticKeyPointsByImageSize( keypoints1t, sz2 );
+        filterEllipticKeyPointsByImageSize( keypoints2, sz2 );
+        filterEllipticKeyPointsByImageSize( keypoints2t, sz1 );
+    }
+    else
+    {
+        overlapThreshold = 1.f - 0.5f;
+
+        thresholdedOverlapMask->create( (int)keypoints1.size(), (int)keypoints2t.size(), CV_8UC1 );
+        thresholdedOverlapMask->setTo( Scalar::all(0) );
+    }
+    size_t size1 = keypoints1.size(), size2 = keypoints2t.size();
+    size_t minCount = MIN( size1, size2 );
+
+    // calculate overlap errors
+    std::vector<SIdx> overlaps;
+    computeOneToOneMatchedOverlaps( keypoints1, keypoints2t, ifEvaluateDetectors, overlaps, overlapThreshold/*min overlap*/ );
+
+    correspondencesCount = -1;
+    repeatability = -1.f;
+    if( overlaps.empty() )
+        return;
+
+    if( ifEvaluateDetectors )
+    {
+        // regions one-to-one matching
+        correspondencesCount = (int)overlaps.size();
+        repeatability = minCount ? (float)correspondencesCount / minCount : -1;
+    }
+    else
+    {
+        for( size_t i = 0; i < overlaps.size(); i++ )
+        {
+            int y = overlaps[i].i1;
+            int x = overlaps[i].i2;
+            thresholdedOverlapMask->at<uchar>(y,x) = 1;
+        }
+    }
+}
+
+void cv::evaluateFeatureDetector( const Mat& img1, const Mat& img2, const Mat& H1to2,
+                              std::vector<KeyPoint>* _keypoints1, std::vector<KeyPoint>* _keypoints2,
+                              float& repeatability, int& correspCount,
+                              const Ptr<FeatureDetector>& _fdetector )
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<FeatureDetector> fdetector(_fdetector);
+    std::vector<KeyPoint> *keypoints1, *keypoints2, buf1, buf2;
+    keypoints1 = _keypoints1 != 0 ? _keypoints1 : &buf1;
+    keypoints2 = _keypoints2 != 0 ? _keypoints2 : &buf2;
+
+    if( (keypoints1->empty() || keypoints2->empty()) && !fdetector )
+        CV_Error( Error::StsBadArg, "fdetector must not be empty when keypoints1 or keypoints2 is empty" );
+
+    if( keypoints1->empty() )
+        fdetector->detect( img1, *keypoints1 );
+    if( keypoints2->empty() )
+        fdetector->detect( img2, *keypoints2 );
+
+    calculateRepeatability( img1, img2, H1to2, *keypoints1, *keypoints2, repeatability, correspCount );
+}
+
+struct DMatchForEvaluation : public DMatch
+{
+    uchar isCorrect;
+    DMatchForEvaluation( const DMatch &dm ) : DMatch( dm ), isCorrect(0) {}
+};
+
+static inline float recall( int correctMatchCount, int correspondenceCount )
+{
+    return correspondenceCount ? (float)correctMatchCount / (float)correspondenceCount : -1;
+}
+
+static inline float precision( int correctMatchCount, int falseMatchCount )
+{
+    return correctMatchCount + falseMatchCount ? (float)correctMatchCount / (float)(correctMatchCount + falseMatchCount) : -1;
+}
+
+void cv::computeRecallPrecisionCurve( const std::vector<std::vector<DMatch> >& matches1to2,
+                                      const std::vector<std::vector<uchar> >& correctMatches1to2Mask,
+                                      std::vector<Point2f>& recallPrecisionCurve )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert( matches1to2.size() == correctMatches1to2Mask.size() );
+
+    std::vector<DMatchForEvaluation> allMatches;
+    int correspondenceCount = 0;
+    for( size_t i = 0; i < matches1to2.size(); i++ )
+    {
+        for( size_t j = 0; j < matches1to2[i].size(); j++ )
+        {
+            DMatchForEvaluation match = matches1to2[i][j];
+            match.isCorrect = correctMatches1to2Mask[i][j] ;
+            allMatches.push_back( match );
+            correspondenceCount += match.isCorrect != 0 ? 1 : 0;
+        }
+    }
+
+    std::sort( allMatches.begin(), allMatches.end() );
+
+    int correctMatchCount = 0, falseMatchCount = 0;
+    recallPrecisionCurve.resize( allMatches.size() );
+    for( size_t i = 0; i < allMatches.size(); i++ )
+    {
+        if( allMatches[i].isCorrect )
+            correctMatchCount++;
+        else
+            falseMatchCount++;
+
+        float r = recall( correctMatchCount, correspondenceCount );
+        float p =  precision( correctMatchCount, falseMatchCount );
+        recallPrecisionCurve[i] = Point2f(1-p, r);
+    }
+}
+
+float cv::getRecall( const std::vector<Point2f>& recallPrecisionCurve, float l_precision )
+{
+    CV_INSTRUMENT_REGION();
+
+    int nearestPointIndex = getNearestPoint( recallPrecisionCurve, l_precision );
+
+    float recall = -1.f;
+
+    if( nearestPointIndex >= 0 )
+        recall = recallPrecisionCurve[nearestPointIndex].y;
+
+    return recall;
+}
+
+int cv::getNearestPoint( const std::vector<Point2f>& recallPrecisionCurve, float l_precision )
+{
+    CV_INSTRUMENT_REGION();
+
+    int nearestPointIndex = -1;
+
+    if( l_precision >= 0 && l_precision <= 1 )
+    {
+        float minDiff = FLT_MAX;
+        for( size_t i = 0; i < recallPrecisionCurve.size(); i++ )
+        {
+            float curDiff = std::fabs(l_precision - recallPrecisionCurve[i].x);
+            if( curDiff <= minDiff )
+            {
+                nearestPointIndex = (int)i;
+                minDiff = curDiff;
+            }
+        }
+    }
+
+    return nearestPointIndex;
+}
diff --git a/upstream/opencv/modules/features/src/fast.avx2.cpp b/upstream/opencv/modules/features/src/fast.avx2.cpp
new file mode 100644
index 0000000..3d408a0
--- /dev/null
+++ b/upstream/opencv/modules/features/src/fast.avx2.cpp
@@ -0,0 +1,184 @@
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+The references are:
+ * Machine learning for high-speed corner detection,
+   E. Rosten and T. Drummond, ECCV 2006
+ * Faster and better: A machine learning approach to corner detection
+   E. Rosten, R. Porter and T. Drummond, PAMI, 2009
+*/
+
+#include "precomp.hpp"
+#include "fast.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+
+namespace cv
+{
+namespace opt_AVX2
+{
+
+class FAST_t_patternSize16_AVX2_Impl CV_FINAL: public FAST_t_patternSize16_AVX2
+{
+public:
+    FAST_t_patternSize16_AVX2_Impl(int _cols, int _threshold, bool _nonmax_suppression, const int* _pixel):
+                                   cols(_cols), nonmax_suppression(_nonmax_suppression), pixel(_pixel)
+    {
+        //patternSize = 16
+        t256c = (char)_threshold;
+        threshold = std::min(std::max(_threshold, 0), 255);
+    }
+
+    virtual void process(int &j, const uchar* &ptr, uchar* curr, int* cornerpos, int &ncorners) CV_OVERRIDE
+    {
+        static const __m256i delta256 = _mm256_broadcastsi128_si256(_mm_set1_epi8((char)(-128))), K16_256 = _mm256_broadcastsi128_si256(_mm_set1_epi8((char)8));
+        const __m256i t256 = _mm256_broadcastsi128_si256(_mm_set1_epi8(t256c));
+        for (; j < cols - 32 - 3; j += 32, ptr += 32)
+        {
+            __m256i m0, m1;
+            __m256i v0 = _mm256_loadu_si256((const __m256i*)ptr);
+
+            __m256i v1 = _mm256_xor_si256(_mm256_subs_epu8(v0, t256), delta256);
+            v0 = _mm256_xor_si256(_mm256_adds_epu8(v0, t256), delta256);
+
+            __m256i x0 = _mm256_sub_epi8(_mm256_loadu_si256((const __m256i*)(ptr + pixel[0])), delta256);
+            __m256i x1 = _mm256_sub_epi8(_mm256_loadu_si256((const __m256i*)(ptr + pixel[4])), delta256);
+            __m256i x2 = _mm256_sub_epi8(_mm256_loadu_si256((const __m256i*)(ptr + pixel[8])), delta256);
+            __m256i x3 = _mm256_sub_epi8(_mm256_loadu_si256((const __m256i*)(ptr + pixel[12])), delta256);
+
+            m0 = _mm256_and_si256(_mm256_cmpgt_epi8(x0, v0), _mm256_cmpgt_epi8(x1, v0));
+            m1 = _mm256_and_si256(_mm256_cmpgt_epi8(v1, x0), _mm256_cmpgt_epi8(v1, x1));
+            m0 = _mm256_or_si256(m0, _mm256_and_si256(_mm256_cmpgt_epi8(x1, v0), _mm256_cmpgt_epi8(x2, v0)));
+            m1 = _mm256_or_si256(m1, _mm256_and_si256(_mm256_cmpgt_epi8(v1, x1), _mm256_cmpgt_epi8(v1, x2)));
+            m0 = _mm256_or_si256(m0, _mm256_and_si256(_mm256_cmpgt_epi8(x2, v0), _mm256_cmpgt_epi8(x3, v0)));
+            m1 = _mm256_or_si256(m1, _mm256_and_si256(_mm256_cmpgt_epi8(v1, x2), _mm256_cmpgt_epi8(v1, x3)));
+            m0 = _mm256_or_si256(m0, _mm256_and_si256(_mm256_cmpgt_epi8(x3, v0), _mm256_cmpgt_epi8(x0, v0)));
+            m1 = _mm256_or_si256(m1, _mm256_and_si256(_mm256_cmpgt_epi8(v1, x3), _mm256_cmpgt_epi8(v1, x0)));
+            m0 = _mm256_or_si256(m0, m1);
+
+            unsigned int mask = _mm256_movemask_epi8(m0); //unsigned is important!
+            if (mask == 0){
+                continue;
+            }
+            if ((mask & 0xffff) == 0)
+            {
+                j -= 16;
+                ptr -= 16;
+                continue;
+            }
+
+            __m256i c0 = _mm256_setzero_si256(), c1 = c0, max0 = c0, max1 = c0;
+            for (int k = 0; k < 25; k++)
+            {
+                __m256i x = _mm256_xor_si256(_mm256_loadu_si256((const __m256i*)(ptr + pixel[k])), delta256);
+                m0 = _mm256_cmpgt_epi8(x, v0);
+                m1 = _mm256_cmpgt_epi8(v1, x);
+
+                c0 = _mm256_and_si256(_mm256_sub_epi8(c0, m0), m0);
+                c1 = _mm256_and_si256(_mm256_sub_epi8(c1, m1), m1);
+
+                max0 = _mm256_max_epu8(max0, c0);
+                max1 = _mm256_max_epu8(max1, c1);
+            }
+
+            max0 = _mm256_max_epu8(max0, max1);
+            unsigned int m = _mm256_movemask_epi8(_mm256_cmpgt_epi8(max0, K16_256));
+
+            for (int k = 0; m > 0 && k < 32; k++, m >>= 1)
+                if (m & 1)
+                {
+                    cornerpos[ncorners++] = j + k;
+                    if (nonmax_suppression)
+                    {
+                        short d[25];
+                        for (int q = 0; q < 25; q++)
+                            d[q] = (short)(ptr[k] - ptr[k + pixel[q]]);
+                        v_int16x8 q0 = v_setall_s16(-1000), q1 = v_setall_s16(1000);
+                        for (int q = 0; q < 16; q += 8)
+                        {
+                            v_int16x8 v0_ = v_load(d + q + 1);
+                            v_int16x8 v1_ = v_load(d + q + 2);
+                            v_int16x8 a = v_min(v0_, v1_);
+                            v_int16x8 b = v_max(v0_, v1_);
+                            v0_ = v_load(d + q + 3);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q + 4);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q + 5);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q + 6);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q + 7);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q + 8);
+                            a = v_min(a, v0_);
+                            b = v_max(b, v0_);
+                            v0_ = v_load(d + q);
+                            q0 = v_max(q0, v_min(a, v0_));
+                            q1 = v_min(q1, v_max(b, v0_));
+                            v0_ = v_load(d + q + 9);
+                            q0 = v_max(q0, v_min(a, v0_));
+                            q1 = v_min(q1, v_max(b, v0_));
+                        }
+                        q0 = v_max(q0, v_sub(v_setzero_s16(), q1));
+                        curr[j + k] = (uchar)(v_reduce_max(q0) - 1);
+                    }
+                }
+        }
+        _mm256_zeroupper();
+    }
+
+    virtual ~FAST_t_patternSize16_AVX2_Impl() CV_OVERRIDE {}
+
+private:
+    int cols;
+    char t256c;
+    int threshold;
+    bool nonmax_suppression;
+    const int* pixel;
+};
+
+Ptr<FAST_t_patternSize16_AVX2> FAST_t_patternSize16_AVX2::getImpl(int _cols, int _threshold, bool _nonmax_suppression, const int* _pixel)
+{
+    return Ptr<FAST_t_patternSize16_AVX2>(new FAST_t_patternSize16_AVX2_Impl(_cols, _threshold, _nonmax_suppression, _pixel));
+}
+
+}
+}
diff --git a/upstream/opencv/modules/features/src/fast.cpp b/upstream/opencv/modules/features/src/fast.cpp
new file mode 100644
index 0000000..b1267bb
--- /dev/null
+++ b/upstream/opencv/modules/features/src/fast.cpp
@@ -0,0 +1,583 @@
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+The references are:
+ * Machine learning for high-speed corner detection,
+   E. Rosten and T. Drummond, ECCV 2006
+ * Faster and better: A machine learning approach to corner detection
+   E. Rosten, R. Porter and T. Drummond, PAMI, 2009
+*/
+
+#include "precomp.hpp"
+#include "fast.hpp"
+#include "fast_score.hpp"
+#include "opencl_kernels_features.hpp"
+#include "hal_replacement.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/core/utils/buffer_area.private.hpp"
+
+namespace cv
+{
+
+template<int patternSize>
+void FAST_t(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression)
+{
+    Mat img = _img.getMat();
+    const int K = patternSize/2, N = patternSize + K + 1;
+    int i, j, k, pixel[25];
+    makeOffsets(pixel, (int)img.step, patternSize);
+
+#if CV_SIMD128
+    const int quarterPatternSize = patternSize/4;
+    v_uint8x16 delta = v_setall_u8(0x80), t = v_setall_u8((char)threshold), K16 = v_setall_u8((char)K);
+#if CV_TRY_AVX2
+    Ptr<opt_AVX2::FAST_t_patternSize16_AVX2> fast_t_impl_avx2;
+    if(CV_CPU_HAS_SUPPORT_AVX2)
+        fast_t_impl_avx2 = opt_AVX2::FAST_t_patternSize16_AVX2::getImpl(img.cols, threshold, nonmax_suppression, pixel);
+#endif
+
+#endif
+
+    keypoints.clear();
+
+    threshold = std::min(std::max(threshold, 0), 255);
+
+    uchar threshold_tab[512];
+    for( i = -255; i <= 255; i++ )
+        threshold_tab[i+255] = (uchar)(i < -threshold ? 1 : i > threshold ? 2 : 0);
+
+    uchar* buf[3] = { 0 };
+    int* cpbuf[3] = { 0 };
+    utils::BufferArea area;
+    for (unsigned idx = 0; idx < 3; ++idx)
+    {
+        area.allocate(buf[idx], img.cols);
+        area.allocate(cpbuf[idx], img.cols + 1);
+    }
+    area.commit();
+
+    for (unsigned idx = 0; idx < 3; ++idx)
+    {
+        memset(buf[idx], 0, img.cols);
+    }
+
+    for(i = 3; i < img.rows-2; i++)
+    {
+        const uchar* ptr = img.ptr<uchar>(i) + 3;
+        uchar* curr = buf[(i - 3)%3];
+        int* cornerpos = cpbuf[(i - 3)%3] + 1; // cornerpos[-1] is used to store a value
+        memset(curr, 0, img.cols);
+        int ncorners = 0;
+
+        if( i < img.rows - 3 )
+        {
+            j = 3;
+#if CV_SIMD128
+            {
+                if( patternSize == 16 )
+                {
+#if CV_TRY_AVX2
+                    if (fast_t_impl_avx2)
+                        fast_t_impl_avx2->process(j, ptr, curr, cornerpos, ncorners);
+#endif
+                    //vz if (j <= (img.cols - 27)) //it doesn't make sense using vectors for less than 8 elements
+                    {
+                        for (; j < img.cols - 16 - 3; j += 16, ptr += 16)
+                        {
+                            v_uint8x16 v = v_load(ptr);
+                            v_int8x16 v0 = v_reinterpret_as_s8(v_xor(v_add(v, t), delta));
+                            v_int8x16 v1 = v_reinterpret_as_s8(v_xor(v_sub(v, t), delta));
+
+                            v_int8x16 x0 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[0]), delta));
+                            v_int8x16 x1 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[quarterPatternSize]), delta));
+                            v_int8x16 x2 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[2*quarterPatternSize]), delta));
+                            v_int8x16 x3 = v_reinterpret_as_s8(v_sub_wrap(v_load(ptr + pixel[3*quarterPatternSize]), delta));
+
+                            v_int8x16 m0, m1;
+                            m0 = v_and(v_lt(v0, x0), v_lt(v0, x1));
+                            m1 = v_and(v_lt(x0, v1), v_lt(x1, v1));
+                            m0 = v_or(m0, v_and(v_lt(v0, x1), v_lt(v0, x2)));
+                            m1 = v_or(m1, v_and(v_lt(x1, v1), v_lt(x2, v1)));
+                            m0 = v_or(m0, v_and(v_lt(v0, x2), v_lt(v0, x3)));
+                            m1 = v_or(m1, v_and(v_lt(x2, v1), v_lt(x3, v1)));
+                            m0 = v_or(m0, v_and(v_lt(v0, x3), v_lt(v0, x0)));
+                            m1 = v_or(m1, v_and(v_lt(x3, v1), v_lt(x0, v1)));
+                            m0 = v_or(m0, m1);
+
+                            if( !v_check_any(m0) )
+                                continue;
+                            if( !v_check_any(v_combine_low(m0, m0)) )
+                            {
+                                j -= 8;
+                                ptr -= 8;
+                                continue;
+                            }
+
+                            v_int8x16 c0 = v_setzero_s8();
+                            v_int8x16 c1 = v_setzero_s8();
+                            v_uint8x16 max0 = v_setzero_u8();
+                            v_uint8x16 max1 = v_setzero_u8();
+                            for( k = 0; k < N; k++ )
+                            {
+                                v_int8x16 x = v_reinterpret_as_s8(v_xor(v_load((ptr + pixel[k])), delta));
+                                m0 = v_lt(v0, x);
+                                m1 = v_lt(x, v1);
+
+                                c0 = v_and(v_sub_wrap(c0, m0), m0);
+                                c1 = v_and(v_sub_wrap(c1, m1), m1);
+
+                                max0 = v_max(max0, v_reinterpret_as_u8(c0));
+                                max1 = v_max(max1, v_reinterpret_as_u8(c1));
+                            }
+
+                            max0 = v_lt(K16, v_max(max0, max1));
+                            unsigned int m = v_signmask(v_reinterpret_as_s8(max0));
+
+                            for( k = 0; m > 0 && k < 16; k++, m >>= 1 )
+                            {
+                                if( m & 1 )
+                                {
+                                    cornerpos[ncorners++] = j+k;
+                                    if(nonmax_suppression)
+                                    {
+                                        short d[25];
+                                        int _k = 0;
+                                    #if CV_ENABLE_UNROLLED
+                                        for (; _k + 4 < 25; _k += 5)
+                                        {
+                                            d[_k]     = (short)(ptr[k] - ptr[k + pixel[_k]]);
+                                            d[_k + 1] = (short)(ptr[k] - ptr[k + pixel[_k + 1]]);
+                                            d[_k + 2] = (short)(ptr[k] - ptr[k + pixel[_k + 2]]);
+                                            d[_k + 3] = (short)(ptr[k] - ptr[k + pixel[_k + 3]]);
+                                            d[_k + 4] = (short)(ptr[k] - ptr[k + pixel[_k + 4]]);
+                                        }
+                                    #else
+                                        for ( ; _k < 25; _k++)
+                                            d[_k] = (short)(ptr[k] - ptr[k + pixel[_k]]);
+                                    #endif
+
+                                        v_int16x8 a0, b0, a1, b1;
+                                        a0 = b0 = a1 = b1 = v_load(d + 8);
+                                        for(int shift = 0; shift < 8; ++shift)
+                                        {
+                                            v_int16x8 v_nms = v_load(d + shift);
+                                            a0 = v_min(a0, v_nms);
+                                            b0 = v_max(b0, v_nms);
+                                            v_nms = v_load(d + 9 + shift);
+                                            a1 = v_min(a1, v_nms);
+                                            b1 = v_max(b1, v_nms);
+                                        }
+                                        curr[j + k] = (uchar)(v_reduce_max(v_max(v_max(a0, a1), v_sub(v_setzero_s16(), v_min(b0, b1)))) - 1);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+#endif
+            for( ; j < img.cols - 3; j++, ptr++ )
+            {
+                int v = ptr[0];
+                const uchar* tab = &threshold_tab[0] - v + 255;
+                int d = tab[ptr[pixel[0]]] | tab[ptr[pixel[8]]];
+
+                if( d == 0 )
+                    continue;
+
+                d &= tab[ptr[pixel[2]]] | tab[ptr[pixel[10]]];
+                d &= tab[ptr[pixel[4]]] | tab[ptr[pixel[12]]];
+                d &= tab[ptr[pixel[6]]] | tab[ptr[pixel[14]]];
+
+                if( d == 0 )
+                    continue;
+
+                d &= tab[ptr[pixel[1]]] | tab[ptr[pixel[9]]];
+                d &= tab[ptr[pixel[3]]] | tab[ptr[pixel[11]]];
+                d &= tab[ptr[pixel[5]]] | tab[ptr[pixel[13]]];
+                d &= tab[ptr[pixel[7]]] | tab[ptr[pixel[15]]];
+
+                if( d & 1 )
+                {
+                    int vt = v - threshold, count = 0;
+
+                    for( k = 0; k < N; k++ )
+                    {
+                        int x = ptr[pixel[k]];
+                        if(x < vt)
+                        {
+                            if( ++count > K )
+                            {
+                                cornerpos[ncorners++] = j;
+                                if(nonmax_suppression)
+                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
+                                break;
+                            }
+                        }
+                        else
+                            count = 0;
+                    }
+                }
+
+                if( d & 2 )
+                {
+                    int vt = v + threshold, count = 0;
+
+                    for( k = 0; k < N; k++ )
+                    {
+                        int x = ptr[pixel[k]];
+                        if(x > vt)
+                        {
+                            if( ++count > K )
+                            {
+                                cornerpos[ncorners++] = j;
+                                if(nonmax_suppression)
+                                    curr[j] = (uchar)cornerScore<patternSize>(ptr, pixel, threshold);
+                                break;
+                            }
+                        }
+                        else
+                            count = 0;
+                    }
+                }
+            }
+        }
+
+        cornerpos[-1] = ncorners;
+
+        if( i == 3 )
+            continue;
+
+        const uchar* prev = buf[(i - 4 + 3)%3];
+        const uchar* pprev = buf[(i - 5 + 3)%3];
+        cornerpos = cpbuf[(i - 4 + 3)%3] + 1; // cornerpos[-1] is used to store a value
+        ncorners = cornerpos[-1];
+
+        for( k = 0; k < ncorners; k++ )
+        {
+            j = cornerpos[k];
+            int score = prev[j];
+            if( !nonmax_suppression ||
+               (score > prev[j+1] && score > prev[j-1] &&
+                score > pprev[j-1] && score > pprev[j] && score > pprev[j+1] &&
+                score > curr[j-1] && score > curr[j] && score > curr[j+1]) )
+            {
+                keypoints.push_back(KeyPoint((float)j, (float)(i-1), 7.f, -1, (float)score));
+            }
+        }
+    }
+}
+
+#ifdef HAVE_OPENCL
+template<typename pt>
+struct cmp_pt
+{
+    bool operator ()(const pt& a, const pt& b) const { return a.y < b.y || (a.y == b.y && a.x < b.x); }
+};
+
+static bool ocl_FAST( InputArray _img, std::vector<KeyPoint>& keypoints,
+                     int threshold, bool nonmax_suppression, int maxKeypoints )
+{
+    UMat img = _img.getUMat();
+    if( img.cols < 7 || img.rows < 7 )
+        return false;
+    size_t globalsize[] = { (size_t)img.cols-6, (size_t)img.rows-6 };
+
+    ocl::Kernel fastKptKernel("FAST_findKeypoints", ocl::features::fast_oclsrc);
+    if (fastKptKernel.empty())
+        return false;
+
+    UMat kp1(1, maxKeypoints*2+1, CV_32S);
+
+    UMat ucounter1(kp1, Rect(0,0,1,1));
+    ucounter1.setTo(Scalar::all(0));
+
+    if( !fastKptKernel.args(ocl::KernelArg::ReadOnly(img),
+                            ocl::KernelArg::PtrReadWrite(kp1),
+                            maxKeypoints, threshold).run(2, globalsize, 0, true))
+        return false;
+
+    Mat mcounter;
+    ucounter1.copyTo(mcounter);
+    int i, counter = mcounter.at<int>(0);
+    counter = std::min(counter, maxKeypoints);
+
+    keypoints.clear();
+
+    if( counter == 0 )
+        return true;
+
+    if( !nonmax_suppression )
+    {
+        Mat m;
+        kp1(Rect(0, 0, counter*2+1, 1)).copyTo(m);
+        const Point* pt = (const Point*)(m.ptr<int>() + 1);
+        for( i = 0; i < counter; i++ )
+            keypoints.push_back(KeyPoint((float)pt[i].x, (float)pt[i].y, 7.f, -1, 1.f));
+    }
+    else
+    {
+        UMat kp2(1, maxKeypoints*3+1, CV_32S);
+        UMat ucounter2 = kp2(Rect(0,0,1,1));
+        ucounter2.setTo(Scalar::all(0));
+
+        ocl::Kernel fastNMSKernel("FAST_nonmaxSupression", ocl::features::fast_oclsrc);
+        if (fastNMSKernel.empty())
+            return false;
+
+        size_t globalsize_nms[] = { (size_t)counter };
+        if( !fastNMSKernel.args(ocl::KernelArg::PtrReadOnly(kp1),
+                                ocl::KernelArg::PtrReadWrite(kp2),
+                                ocl::KernelArg::ReadOnly(img),
+                                counter, counter).run(1, globalsize_nms, 0, true))
+            return false;
+
+        Mat m2;
+        kp2(Rect(0, 0, counter*3+1, 1)).copyTo(m2);
+        Point3i* pt2 = (Point3i*)(m2.ptr<int>() + 1);
+        int newcounter = std::min(m2.at<int>(0), counter);
+
+        std::sort(pt2, pt2 + newcounter, cmp_pt<Point3i>());
+
+        for( i = 0; i < newcounter; i++ )
+            keypoints.push_back(KeyPoint((float)pt2[i].x, (float)pt2[i].y, 7.f, -1, (float)pt2[i].z));
+    }
+
+    return true;
+}
+#endif
+
+static inline int hal_FAST(cv::Mat& src, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type)
+{
+    if (threshold > 20)
+        return CV_HAL_ERROR_NOT_IMPLEMENTED;
+
+    cv::Mat scores(src.size(), src.type());
+
+    int error = cv_hal_FAST_dense(src.data, src.step, scores.data, scores.step, src.cols, src.rows, type);
+
+    if (error != CV_HAL_ERROR_OK)
+        return error;
+
+    cv::Mat suppressedScores(src.size(), src.type());
+
+    if (nonmax_suppression)
+    {
+        error = cv_hal_FAST_NMS(scores.data, scores.step, suppressedScores.data, suppressedScores.step, scores.cols, scores.rows);
+
+        if (error != CV_HAL_ERROR_OK)
+            return error;
+    }
+    else
+    {
+        suppressedScores = scores;
+    }
+
+    if (!threshold && nonmax_suppression) threshold = 1;
+
+    cv::KeyPoint kpt(0, 0, 7.f, -1, 0);
+
+    unsigned uthreshold = (unsigned) threshold;
+
+    int ofs = 3;
+
+    int stride = (int)suppressedScores.step;
+    const unsigned char* pscore = suppressedScores.data;
+
+    keypoints.clear();
+
+    for (int y = ofs; y + ofs < suppressedScores.rows; ++y)
+    {
+        kpt.pt.y = (float)(y);
+        for (int x = ofs; x + ofs < suppressedScores.cols; ++x)
+        {
+            unsigned score = pscore[y * stride + x];
+            if (score > uthreshold)
+            {
+                kpt.pt.x = (float)(x);
+                kpt.response = (nonmax_suppression != 0) ? (float)((int)score - 1) : 0.f;
+                keypoints.push_back(kpt);
+            }
+        }
+    }
+
+    return CV_HAL_ERROR_OK;
+}
+
+void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type)
+{
+    CV_INSTRUMENT_REGION();
+
+    const size_t max_fast_features = std::max(_img.total()/100, size_t(1000)); // Simple heuristic that depends on resolution.
+
+    CV_OCL_RUN(_img.isUMat() && type == FastFeatureDetector::TYPE_9_16,
+               ocl_FAST(_img, keypoints, threshold, nonmax_suppression, (int)max_fast_features));
+
+    cv::Mat img = _img.getMat();
+    CALL_HAL(fast_dense, hal_FAST, img, keypoints, threshold, nonmax_suppression, type);
+
+    size_t keypoints_count = 1;
+    keypoints.clear();
+    KeyPoint* kps = (KeyPoint*)malloc(sizeof(KeyPoint) * keypoints_count);
+    int hal_ret = cv_hal_FASTv2(img.data, img.step, img.cols, img.rows, (void**)&kps,
+                                &keypoints_count, threshold, nonmax_suppression, type, realloc);
+    if (hal_ret == CV_HAL_ERROR_OK) {
+        keypoints.assign(kps, kps + keypoints_count);
+        free(kps);
+        return;
+    } else {
+        free(kps);
+        keypoints_count = max_fast_features;
+        keypoints.clear();
+        keypoints.resize(keypoints_count);
+        CALL_HAL(fast, cv_hal_FAST, img.data, img.step, img.cols, img.rows,
+                (uchar*)(keypoints.data()), &keypoints_count, threshold, nonmax_suppression, type);
+    }
+
+    switch(type) {
+    case FastFeatureDetector::TYPE_5_8:
+        FAST_t<8>(_img, keypoints, threshold, nonmax_suppression);
+        break;
+    case FastFeatureDetector::TYPE_7_12:
+        FAST_t<12>(_img, keypoints, threshold, nonmax_suppression);
+        break;
+    case FastFeatureDetector::TYPE_9_16:
+        FAST_t<16>(_img, keypoints, threshold, nonmax_suppression);
+        break;
+    }
+}
+
+
+class FastFeatureDetector_Impl CV_FINAL : public FastFeatureDetector
+{
+public:
+    FastFeatureDetector_Impl( int _threshold, bool _nonmaxSuppression, FastFeatureDetector::DetectorType _type )
+    : threshold(_threshold), nonmaxSuppression(_nonmaxSuppression), type(_type)
+    {}
+
+    void read( const FileNode& fn) CV_OVERRIDE
+    {
+      // if node is empty, keep previous value
+      if (!fn["threshold"].empty())
+        fn["threshold"] >> threshold;
+      if (!fn["nonmaxSuppression"].empty())
+        fn["nonmaxSuppression"] >> nonmaxSuppression;
+      if (!fn["type"].empty())
+        fn["type"] >> type;
+    }
+    void write( FileStorage& fs) const CV_OVERRIDE
+    {
+      if(fs.isOpened())
+      {
+        fs << "name" << getDefaultName();
+        fs << "threshold" << threshold;
+        fs << "nonmaxSuppression" << nonmaxSuppression;
+        fs << "type" << type;
+      }
+    }
+
+    void detect( InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask ) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        if(_image.empty())
+        {
+            keypoints.clear();
+            return;
+        }
+
+        Mat mask = _mask.getMat(), grayImage;
+        UMat ugrayImage;
+        _InputArray gray = _image;
+        if( _image.type() != CV_8U )
+        {
+            _OutputArray ogray = _image.isUMat() ? _OutputArray(ugrayImage) : _OutputArray(grayImage);
+            cvtColor( _image, ogray, COLOR_BGR2GRAY );
+            gray = ogray;
+        }
+        FAST( gray, keypoints, threshold, nonmaxSuppression, type );
+        KeyPointsFilter::runByPixelsMask( keypoints, mask );
+    }
+
+    void set(int prop, double value)
+    {
+        if(prop == THRESHOLD)
+            threshold = cvRound(value);
+        else if(prop == NONMAX_SUPPRESSION)
+            nonmaxSuppression = value != 0;
+        else if(prop == FAST_N)
+            type = static_cast<FastFeatureDetector::DetectorType>(cvRound(value));
+        else
+            CV_Error(Error::StsBadArg, "");
+    }
+
+    double get(int prop) const
+    {
+        if(prop == THRESHOLD)
+            return threshold;
+        if(prop == NONMAX_SUPPRESSION)
+            return nonmaxSuppression;
+        if(prop == FAST_N)
+            return static_cast<int>(type);
+        CV_Error(Error::StsBadArg, "");
+        return 0;
+    }
+
+    void setThreshold(int threshold_) CV_OVERRIDE { threshold = threshold_; }
+    int getThreshold() const CV_OVERRIDE { return threshold; }
+
+    void setNonmaxSuppression(bool f) CV_OVERRIDE { nonmaxSuppression = f; }
+    bool getNonmaxSuppression() const CV_OVERRIDE { return nonmaxSuppression; }
+
+    void setType(FastFeatureDetector::DetectorType type_) CV_OVERRIDE{ type = type_; }
+    FastFeatureDetector::DetectorType getType() const CV_OVERRIDE{ return type; }
+
+    int threshold;
+    bool nonmaxSuppression;
+    FastFeatureDetector::DetectorType type;
+};
+
+Ptr<FastFeatureDetector> FastFeatureDetector::create( int threshold, bool nonmaxSuppression, FastFeatureDetector::DetectorType type )
+{
+    return makePtr<FastFeatureDetector_Impl>(threshold, nonmaxSuppression, type);
+}
+
+String FastFeatureDetector::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".FastFeatureDetector");
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/fast.hpp b/upstream/opencv/modules/features/src/fast.hpp
new file mode 100644
index 0000000..90b08fd
--- /dev/null
+++ b/upstream/opencv/modules/features/src/fast.hpp
@@ -0,0 +1,62 @@
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+The references are:
+ * Machine learning for high-speed corner detection,
+   E. Rosten and T. Drummond, ECCV 2006
+ * Faster and better: A machine learning approach to corner detection
+   E. Rosten, R. Porter and T. Drummond, PAMI, 2009
+*/
+
+#ifndef OPENCV_FEATURES_FAST_HPP
+#define OPENCV_FEATURES_FAST_HPP
+
+namespace cv
+{
+namespace opt_AVX2
+{
+#if CV_TRY_AVX2
+class FAST_t_patternSize16_AVX2
+{
+public:
+    static Ptr<FAST_t_patternSize16_AVX2> getImpl(int _cols, int _threshold, bool _nonmax_suppression, const int* _pixel);
+    virtual void process(int &j, const uchar* &ptr, uchar* curr, int* cornerpos, int &ncorners) = 0;
+    virtual ~FAST_t_patternSize16_AVX2() {}
+};
+#endif
+}
+}
+#endif
diff --git a/upstream/opencv/modules/features/src/fast_score.cpp b/upstream/opencv/modules/features/src/fast_score.cpp
new file mode 100644
index 0000000..0c43ad5
--- /dev/null
+++ b/upstream/opencv/modules/features/src/fast_score.cpp
@@ -0,0 +1,366 @@
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+The references are:
+ * Machine learning for high-speed corner detection,
+   E. Rosten and T. Drummond, ECCV 2006
+ * Faster and better: A machine learning approach to corner detection
+   E. Rosten, R. Porter and T. Drummond, PAMI, 2009
+*/
+
+#include "fast_score.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#define VERIFY_CORNERS 0
+
+namespace cv {
+
+void makeOffsets(int pixel[25], int rowStride, int patternSize)
+{
+    static const int offsets16[][2] =
+    {
+        {0,  3}, { 1,  3}, { 2,  2}, { 3,  1}, { 3, 0}, { 3, -1}, { 2, -2}, { 1, -3},
+        {0, -3}, {-1, -3}, {-2, -2}, {-3, -1}, {-3, 0}, {-3,  1}, {-2,  2}, {-1,  3}
+    };
+
+    static const int offsets12[][2] =
+    {
+        {0,  2}, { 1,  2}, { 2,  1}, { 2, 0}, { 2, -1}, { 1, -2},
+        {0, -2}, {-1, -2}, {-2, -1}, {-2, 0}, {-2,  1}, {-1,  2}
+    };
+
+    static const int offsets8[][2] =
+    {
+        {0,  1}, { 1,  1}, { 1, 0}, { 1, -1},
+        {0, -1}, {-1, -1}, {-1, 0}, {-1,  1}
+    };
+
+    const int (*offsets)[2] = patternSize == 16 ? offsets16 :
+                              patternSize == 12 ? offsets12 :
+                              patternSize == 8  ? offsets8  : 0;
+
+    CV_Assert(pixel && offsets);
+
+    int k = 0;
+    for( ; k < patternSize; k++ )
+        pixel[k] = offsets[k][0] + offsets[k][1] * rowStride;
+    for( ; k < 25; k++ )
+        pixel[k] = pixel[k - patternSize];
+}
+
+#if VERIFY_CORNERS
+static void testCorner(const uchar* ptr, const int pixel[], int K, int N, int threshold) {
+    // check that with the computed "threshold" the pixel is still a corner
+    // and that with the increased-by-1 "threshold" the pixel is not a corner anymore
+    for( int delta = 0; delta <= 1; delta++ )
+    {
+        int v0 = std::min(ptr[0] + threshold + delta, 255);
+        int v1 = std::max(ptr[0] - threshold - delta, 0);
+        int c0 = 0, c1 = 0;
+
+        for( int k = 0; k < N; k++ )
+        {
+            int x = ptr[pixel[k]];
+            if(x > v0)
+            {
+                if( ++c0 > K )
+                    break;
+                c1 = 0;
+            }
+            else if( x < v1 )
+            {
+                if( ++c1 > K )
+                    break;
+                c0 = 0;
+            }
+            else
+            {
+                c0 = c1 = 0;
+            }
+        }
+        CV_Assert( (delta == 0 && std::max(c0, c1) > K) ||
+                   (delta == 1 && std::max(c0, c1) <= K) );
+    }
+}
+#endif
+
+template<>
+int cornerScore<16>(const uchar* ptr, const int pixel[], int threshold)
+{
+    const int K = 8, N = K*3 + 1;
+    int k, v = ptr[0];
+    short d[N];
+    for( k = 0; k < N; k++ )
+        d[k] = (short)(v - ptr[pixel[k]]);
+
+#if CV_SIMD128
+    if (true)
+    {
+        v_int16x8 q0 = v_setall_s16(-1000), q1 = v_setall_s16(1000);
+        for (k = 0; k < 16; k += 8)
+        {
+            v_int16x8 v0 = v_load(d + k + 1);
+            v_int16x8 v1 = v_load(d + k + 2);
+            v_int16x8 a = v_min(v0, v1);
+            v_int16x8 b = v_max(v0, v1);
+            v0 = v_load(d + k + 3);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 4);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 5);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 6);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 7);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 8);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k);
+            q0 = v_max(q0, v_min(a, v0));
+            q1 = v_min(q1, v_max(b, v0));
+            v0 = v_load(d + k + 9);
+            q0 = v_max(q0, v_min(a, v0));
+            q1 = v_min(q1, v_max(b, v0));
+        }
+        q0 = v_max(q0, v_sub(v_setzero_s16(), q1));
+        threshold = v_reduce_max(q0) - 1;
+    }
+    else
+#endif
+    {
+
+        int a0 = threshold;
+        for( k = 0; k < 16; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            a = std::min(a, (int)d[k+3]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+4]);
+            a = std::min(a, (int)d[k+5]);
+            a = std::min(a, (int)d[k+6]);
+            a = std::min(a, (int)d[k+7]);
+            a = std::min(a, (int)d[k+8]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+9]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 16; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            b = std::max(b, (int)d[k+4]);
+            b = std::max(b, (int)d[k+5]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+6]);
+            b = std::max(b, (int)d[k+7]);
+            b = std::max(b, (int)d[k+8]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+9]));
+        }
+
+        threshold = -b0 - 1;
+    }
+
+#if VERIFY_CORNERS
+    testCorner(ptr, pixel, K, N, threshold);
+#endif
+    return threshold;
+}
+
+template<>
+int cornerScore<12>(const uchar* ptr, const int pixel[], int threshold)
+{
+    const int K = 6, N = K*3 + 1;
+    int k, v = ptr[0];
+    short d[N + 4];
+    for( k = 0; k < N; k++ )
+        d[k] = (short)(v - ptr[pixel[k]]);
+#if CV_SIMD128
+    for( k = 0; k < 4; k++ )
+        d[N+k] = d[k];
+#endif
+
+#if CV_SIMD128
+    if (true)
+    {
+        v_int16x8 q0 = v_setall_s16(-1000), q1 = v_setall_s16(1000);
+        for (k = 0; k < 16; k += 8)
+        {
+            v_int16x8 v0 = v_load(d + k + 1);
+            v_int16x8 v1 = v_load(d + k + 2);
+            v_int16x8 a = v_min(v0, v1);
+            v_int16x8 b = v_max(v0, v1);
+            v0 = v_load(d + k + 3);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 4);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 5);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k + 6);
+            a = v_min(a, v0);
+            b = v_max(b, v0);
+            v0 = v_load(d + k);
+            q0 = v_max(q0, v_min(a, v0));
+            q1 = v_min(q1, v_max(b, v0));
+            v0 = v_load(d + k + 7);
+            q0 = v_max(q0, v_min(a, v0));
+            q1 = v_min(q1, v_max(b, v0));
+        }
+        q0 = v_max(q0, v_sub(v_setzero_s16(), q1));
+        threshold = v_reduce_max(q0) - 1;
+    }
+    else
+#endif
+    {
+        int a0 = threshold;
+        for( k = 0; k < 12; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+3]);
+            a = std::min(a, (int)d[k+4]);
+            a = std::min(a, (int)d[k+5]);
+            a = std::min(a, (int)d[k+6]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+7]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 12; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            b = std::max(b, (int)d[k+4]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+5]);
+            b = std::max(b, (int)d[k+6]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+7]));
+        }
+
+        threshold = -b0-1;
+    }
+#if VERIFY_CORNERS
+    testCorner(ptr, pixel, K, N, threshold);
+#endif
+    return threshold;
+}
+
+template<>
+int cornerScore<8>(const uchar* ptr, const int pixel[], int threshold)
+{
+    const int K = 4, N = K * 3 + 1;
+    int k, v = ptr[0];
+    short d[N];
+    for (k = 0; k < N; k++)
+        d[k] = (short)(v - ptr[pixel[k]]);
+
+#if CV_SIMD128 \
+    && (!defined(CV_SIMD128_CPP) || (!defined(__GNUC__) || __GNUC__ != 5))  // "movdqa" bug on "v_load(d + 1)" line (Ubuntu 16.04 + GCC 5.4)
+    if (true)
+    {
+        v_int16x8 v0 = v_load(d + 1);
+        v_int16x8 v1 = v_load(d + 2);
+        v_int16x8 a = v_min(v0, v1);
+        v_int16x8 b = v_max(v0, v1);
+        v0 = v_load(d + 3);
+        a = v_min(a, v0);
+        b = v_max(b, v0);
+        v0 = v_load(d + 4);
+        a = v_min(a, v0);
+        b = v_max(b, v0);
+        v0 = v_load(d);
+        v_int16x8 q0 = v_min(a, v0);
+        v_int16x8 q1 = v_max(b, v0);
+        v0 = v_load(d + 5);
+        q0 = v_max(q0, v_min(a, v0));
+        q1 = v_min(q1, v_max(b, v0));
+        q0 = v_max(q0, v_sub(v_setzero_s16(), q1));
+        threshold = v_reduce_max(q0) - 1;
+    }
+    else
+#endif
+    {
+        int a0 = threshold;
+        for( k = 0; k < 8; k += 2 )
+        {
+            int a = std::min((int)d[k+1], (int)d[k+2]);
+            if( a <= a0 )
+                continue;
+            a = std::min(a, (int)d[k+3]);
+            a = std::min(a, (int)d[k+4]);
+            a0 = std::max(a0, std::min(a, (int)d[k]));
+            a0 = std::max(a0, std::min(a, (int)d[k+5]));
+        }
+
+        int b0 = -a0;
+        for( k = 0; k < 8; k += 2 )
+        {
+            int b = std::max((int)d[k+1], (int)d[k+2]);
+            b = std::max(b, (int)d[k+3]);
+            if( b >= b0 )
+                continue;
+            b = std::max(b, (int)d[k+4]);
+
+            b0 = std::min(b0, std::max(b, (int)d[k]));
+            b0 = std::min(b0, std::max(b, (int)d[k+5]));
+        }
+
+        threshold = -b0-1;
+    }
+
+#if VERIFY_CORNERS
+    testCorner(ptr, pixel, K, N, threshold);
+#endif
+    return threshold;
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/features/src/fast_score.hpp b/upstream/opencv/modules/features/src/fast_score.hpp
new file mode 100644
index 0000000..4884c73
--- /dev/null
+++ b/upstream/opencv/modules/features/src/fast_score.hpp
@@ -0,0 +1,62 @@
+/* This is FAST corner detector, contributed to OpenCV by the author, Edward Rosten.
+   Below is the original copyright and the references */
+
+/*
+Copyright (c) 2006, 2008 Edward Rosten
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    *Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+    *Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+    *Neither the name of the University of Cambridge nor the names of
+     its contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+The references are:
+ * Machine learning for high-speed corner detection,
+   E. Rosten and T. Drummond, ECCV 2006
+ * Faster and better: A machine learning approach to corner detection
+   E. Rosten, R. Porter and T. Drummond, PAMI, 2009
+*/
+
+#ifndef __OPENCV_FEATURES_2D_FAST_HPP__
+#define __OPENCV_FEATURES_2D_FAST_HPP__
+
+#ifdef __cplusplus
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+void makeOffsets(int pixel[25], int row_stride, int patternSize);
+
+template<int patternSize>
+int cornerScore(const uchar* ptr, const int pixel[], int threshold);
+
+}
+
+#endif
+#endif
diff --git a/upstream/opencv/modules/features/src/feature2d.cpp b/upstream/opencv/modules/features/src/feature2d.cpp
new file mode 100644
index 0000000..49fafba
--- /dev/null
+++ b/upstream/opencv/modules/features/src/feature2d.cpp
@@ -0,0 +1,224 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+using std::vector;
+
+Feature2D::~Feature2D() {}
+
+/*
+ * Detect keypoints in an image.
+ * image        The image.
+ * keypoints    The detected keypoints.
+ * mask         Mask specifying where to look for keypoints (optional). Must be a char
+ *              matrix with non-zero values in the region of interest.
+ */
+void Feature2D::detect( InputArray image,
+                        std::vector<KeyPoint>& keypoints,
+                        InputArray mask )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( image.empty() )
+    {
+        keypoints.clear();
+        return;
+    }
+    detectAndCompute(image, mask, keypoints, noArray(), false);
+}
+
+
+void Feature2D::detect( InputArrayOfArrays images,
+                        std::vector<std::vector<KeyPoint> >& keypoints,
+                        InputArrayOfArrays masks )
+{
+    CV_INSTRUMENT_REGION();
+
+    int nimages = (int)images.total();
+
+    if (!masks.empty())
+    {
+        CV_Assert(masks.total() == (size_t)nimages);
+    }
+
+    keypoints.resize(nimages);
+
+    if (images.isMatVector())
+    {
+       for (int i = 0; i < nimages; i++)
+       {
+           detect(images.getMat(i), keypoints[i], masks.empty() ? noArray() : masks.getMat(i));
+       }
+    }
+    else
+    {
+        // assume UMats
+        for (int i = 0; i < nimages; i++)
+        {
+            detect(images.getUMat(i), keypoints[i], masks.empty() ? noArray() : masks.getUMat(i));
+        }
+    }
+
+
+}
+
+/*
+ * Compute the descriptors for a set of keypoints in an image.
+ * image        The image.
+ * keypoints    The input keypoints. Keypoints for which a descriptor cannot be computed are removed.
+ * descriptors  Copmputed descriptors. Row i is the descriptor for keypoint i.
+ */
+void Feature2D::compute( InputArray image,
+                         std::vector<KeyPoint>& keypoints,
+                         OutputArray descriptors )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( image.empty() )
+    {
+        descriptors.release();
+        return;
+    }
+    detectAndCompute(image, noArray(), keypoints, descriptors, true);
+}
+
+void Feature2D::compute( InputArrayOfArrays images,
+                         std::vector<std::vector<KeyPoint> >& keypoints,
+                         OutputArrayOfArrays descriptors )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( !descriptors.needed() )
+        return;
+
+    int nimages = (int)images.total();
+
+    CV_Assert( keypoints.size() == (size_t)nimages );
+    // resize descriptors to appropriate size and compute
+    if (descriptors.isMatVector())
+    {
+        vector<Mat>& vec = *(vector<Mat>*)descriptors.getObj();
+        vec.resize(nimages);
+        for (int i = 0; i < nimages; i++)
+        {
+            compute(images.getMat(i), keypoints[i], vec[i]);
+        }
+    }
+    else if (descriptors.isUMatVector())
+    {
+        vector<UMat>& vec = *(vector<UMat>*)descriptors.getObj();
+        vec.resize(nimages);
+        for (int i = 0; i < nimages; i++)
+        {
+            compute(images.getUMat(i), keypoints[i], vec[i]);
+        }
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "descriptors must be vector<Mat> or vector<UMat>");
+    }
+}
+
+
+/* Detects keypoints and computes the descriptors */
+void Feature2D::detectAndCompute( InputArray, InputArray,
+                                  std::vector<KeyPoint>&,
+                                  OutputArray,
+                                  bool )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Error(Error::StsNotImplemented, "");
+}
+
+void Feature2D::write( const String& fileName ) const
+{
+    FileStorage fs(fileName, FileStorage::WRITE);
+    write(fs);
+}
+
+void Feature2D::read( const String& fileName )
+{
+    FileStorage fs(fileName, FileStorage::READ);
+    read(fs.root());
+}
+
+void Feature2D::write( FileStorage&) const
+{
+}
+
+void Feature2D::read( const FileNode&)
+{
+}
+
+int Feature2D::descriptorSize() const
+{
+    return 0;
+}
+
+int Feature2D::descriptorType() const
+{
+    return CV_32F;
+}
+
+int Feature2D::defaultNorm() const
+{
+    int tp = descriptorType();
+    return tp == CV_8U ? NORM_HAMMING : NORM_L2;
+}
+
+// Return true if detector object is empty
+bool Feature2D::empty() const
+{
+    return true;
+}
+
+String Feature2D::getDefaultName() const
+{
+    return "Feature2D";
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/feature2d_aliked.cpp b/upstream/opencv/modules/features/src/feature2d_aliked.cpp
new file mode 100644
index 0000000..1a80b00
--- /dev/null
+++ b/upstream/opencv/modules/features/src/feature2d_aliked.cpp
@@ -0,0 +1,186 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#include "aliked_context.hpp"
+#endif
+
+namespace cv
+{
+
+ALIKED::ALIKED() {}
+ALIKED::~ALIKED() {}
+
+ALIKED::Params::Params()
+{
+    inputSize = Size(640, 640);
+    normalizeDescriptors = true;
+#ifdef HAVE_OPENCV_DNN
+    engine = dnn::ENGINE_NEW;
+    backend = dnn::DNN_BACKEND_DEFAULT;
+    target = dnn::DNN_TARGET_CPU;
+#else
+    engine = -1;
+    backend = -1;
+    target = -1;
+#endif
+}
+
+#ifdef HAVE_OPENCV_DNN
+
+class ALIKEDImpl : public ALIKED
+{
+public:
+    ALIKEDImpl(const ALIKED::Params& _params, const String& modelPath)
+        : params(_params)
+    {
+        net = dnn::readNet(modelPath, "", "", static_cast<dnn::EngineType>(params.engine));
+        CV_Assert(!net.empty());
+        net.setPreferableBackend(params.backend);
+        net.setPreferableTarget(params.target);
+    }
+
+    ALIKEDImpl(const std::vector<uchar>& modelData, const ALIKED::Params& _params)
+        : params(_params)
+    {
+        net = dnn::readNetFromONNX(modelData);
+        CV_Assert(!net.empty());
+        net.setPreferableBackend(params.backend);
+        net.setPreferableTarget(params.target);
+    }
+
+    void detectAndCompute(InputArray image, InputArray mask,
+                          std::vector<KeyPoint>& keypoints,
+                          OutputArray descriptors,
+                          bool useProvidedKeypoints) CV_OVERRIDE;
+
+    int descriptorSize() const CV_OVERRIDE;
+    int descriptorType() const CV_OVERRIDE;
+    int defaultNorm() const CV_OVERRIDE;
+    bool empty() const CV_OVERRIDE;
+
+    const ALIKEDContext& getLastContext() const { return lastContext; }
+
+protected:
+    dnn::Net net;
+    ALIKED::Params params;
+    ALIKEDContext lastContext;
+
+    void runNetwork(InputArray image, std::vector<KeyPoint>& keypoints,
+                    Mat& descriptors, Mat& scores);
+};
+
+void ALIKEDImpl::runNetwork(InputArray _image, std::vector<KeyPoint>& keypoints,
+                             Mat& descriptors, Mat& scores)
+{
+    Mat image = _image.getMat();
+    Size inputSz = params.inputSize;
+    Size origSize = image.size();
+
+    // BGR->RGB conversion via swapRB=true
+    Mat blob = dnn::blobFromImage(image, 1.0/255.0, inputSz, Scalar(), /*swapRB=*/true, /*crop=*/false);
+
+    net.setInput(blob, "image");
+
+    std::vector<String> outNames = {"keypoints", "descriptors", "scores"};
+    std::vector<Mat> outputs;
+    net.forward(outputs, outNames);
+
+    CV_Assert(outputs.size() == 3);
+
+    // ORT engine drops the batch dimension, so outputs are:
+    //   keypoints:   [N, 2]   (not [1, N, 2])
+    //   descriptors: [N, 128] (not [1, N, 128])
+    //   scores:      [N]      (not [1, N, 1])
+    int N = outputs[0].rows;
+
+    Mat normKpts = outputs[0].reshape(0, N);   // Nx2
+    Mat desc = outputs[1].reshape(0, N);       // Nx128
+    Mat scr = outputs[2].reshape(0, N);        // Nx1
+
+    // Store normalized keypoints for LightGlue context
+    lastContext.normalizedKeypoints = normKpts.clone();
+    lastContext.imageSize = origSize;
+
+    // Convert normalized [-1,1] coordinates to pixel coordinates
+    keypoints.resize(N);
+    for (int i = 0; i < N; i++)
+    {
+        float nx = normKpts.at<float>(i, 0);
+        float ny = normKpts.at<float>(i, 1);
+        float px = (nx + 1.0f) * 0.5f * (float)origSize.width;
+        float py = (ny + 1.0f) * 0.5f * (float)origSize.height;
+        float score = scr.at<float>(i, 0);
+        keypoints[i] = KeyPoint(px, py, 1.0f, -1.0f, score, 0, -1);
+    }
+
+    // Optionally L2-normalize descriptors
+    if (params.normalizeDescriptors)
+    {
+        for (int i = 0; i < N; i++)
+        {
+            Mat row = desc.row(i);
+            normalize(row, row);
+        }
+    }
+
+    descriptors = desc;
+    scores = scr;
+}
+
+void ALIKEDImpl::detectAndCompute(InputArray image, InputArray mask,
+                                   std::vector<KeyPoint>& keypoints,
+                                   OutputArray descriptors,
+                                   bool useProvidedKeypoints)
+{
+    CV_INSTRUMENT_REGION();
+    CV_UNUSED(mask);
+    CV_UNUSED(useProvidedKeypoints);
+
+    if (image.empty())
+    {
+        keypoints.clear();
+        descriptors.release();
+        return;
+    }
+
+    Mat desc;
+    Mat sc;
+    runNetwork(image, keypoints, desc, sc);
+
+    if (descriptors.needed())
+        desc.copyTo(descriptors);
+}
+
+int ALIKEDImpl::descriptorSize() const { return 128; }
+int ALIKEDImpl::descriptorType() const { return CV_32F; }
+int ALIKEDImpl::defaultNorm() const { return NORM_L2; }
+bool ALIKEDImpl::empty() const { return net.empty(); }
+
+Ptr<ALIKED> ALIKED::create(const String& modelPath, const ALIKED::Params& params)
+{
+    return makePtr<ALIKEDImpl>(params, modelPath);
+}
+
+Ptr<ALIKED> ALIKED::create(const std::vector<uchar>& modelData, const ALIKED::Params& params)
+{
+    return makePtr<ALIKEDImpl>(modelData, params);
+}
+
+#else  // !HAVE_OPENCV_DNN
+
+Ptr<ALIKED> ALIKED::create(const String& modelPath, const ALIKED::Params& params)
+{
+    CV_UNUSED(modelPath);
+    CV_UNUSED(params);
+    CV_Error(cv::Error::StsNotImplemented,
+             "ALIKED requires OpenCV built with opencv_dnn module!");
+}
+
+#endif  // HAVE_OPENCV_DNN
+
+}  // namespace cv
diff --git a/upstream/opencv/modules/features/src/featureselect.cpp b/upstream/opencv/modules/features/src/featureselect.cpp
new file mode 100644
index 0000000..f8888e8
--- /dev/null
+++ b/upstream/opencv/modules/features/src/featureselect.cpp
@@ -0,0 +1,458 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_features.hpp"
+
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <functional>
+
+namespace cv
+{
+
+struct greaterThanPtr
+{
+    bool operator () (const float * a, const float * b) const
+    // Ensure a fully deterministic result of the sort
+    { return (*a > *b) ? true : (*a < *b) ? false : (a > b); }
+};
+
+#ifdef HAVE_OPENCL
+
+struct Corner
+{
+    float val;
+    short y;
+    short x;
+
+    bool operator < (const Corner & c) const
+    // Ensure a fully deterministic result of the sort
+    {  return (val > c.val) ? true : (val < c.val) ? false : (y > c.y) ? true : (y < c.y) ? false : (x > c.x); }
+};
+
+static bool ocl_goodFeaturesToTrack( InputArray _image, OutputArray _corners,
+                                     int maxCorners, double qualityLevel, double minDistance,
+                                     InputArray _mask, OutputArray _cornersQuality, int blockSize, int gradientSize,
+                                     bool useHarrisDetector, double harrisK)
+{
+    UMat eig, maxEigenValue;
+    if( useHarrisDetector )
+        cornerHarris( _image, eig, blockSize, gradientSize, harrisK );
+    else
+        cornerMinEigenVal( _image, eig, blockSize, gradientSize );
+
+    Size imgsize = _image.size();
+    size_t total, i, j, ncorners = 0, possibleCornersCount =
+            std::max(1024, static_cast<int>(imgsize.area() * 0.1));
+    bool haveMask = !_mask.empty();
+    UMat corners_buffer(1, (int)possibleCornersCount + 1, CV_32FC2);
+    CV_Assert(sizeof(Corner) == corners_buffer.elemSize());
+    Mat tmpCorners;
+
+    // find threshold
+    {
+        CV_Assert(eig.type() == CV_32FC1);
+        int dbsize = ocl::Device::getDefault().maxComputeUnits();
+        size_t wgs = ocl::Device::getDefault().maxWorkGroupSize();
+
+        int wgs2_aligned = 1;
+        while (wgs2_aligned < (int)wgs)
+            wgs2_aligned <<= 1;
+        wgs2_aligned >>= 1;
+
+        ocl::Kernel k("maxEigenVal", ocl::features::gftt_oclsrc,
+                      format("-D OP_MAX_EIGEN_VAL -D WGS=%d -D groupnum=%d -D WGS2_ALIGNED=%d%s",
+                             (int)wgs, dbsize, wgs2_aligned, haveMask ? " -D HAVE_MASK" : ""));
+        if (k.empty())
+            return false;
+
+        UMat mask = _mask.getUMat();
+        maxEigenValue.create(1, dbsize, CV_32FC1);
+
+        ocl::KernelArg eigarg = ocl::KernelArg::ReadOnlyNoSize(eig),
+                dbarg = ocl::KernelArg::PtrWriteOnly(maxEigenValue),
+                maskarg = ocl::KernelArg::ReadOnlyNoSize(mask),
+                cornersarg = ocl::KernelArg::PtrWriteOnly(corners_buffer);
+
+        if (haveMask)
+            k.args(eigarg, eig.cols, (int)eig.total(), dbarg, maskarg);
+        else
+            k.args(eigarg, eig.cols, (int)eig.total(), dbarg);
+
+        size_t globalsize = dbsize * wgs;
+        if (!k.run(1, &globalsize, &wgs, false))
+            return false;
+
+        ocl::Kernel k2("maxEigenValTask", ocl::features::gftt_oclsrc,
+                       format("-D OP_MAX_EIGEN_VAL -D WGS=%zu -D WGS2_ALIGNED=%d -D groupnum=%d",
+                              wgs, wgs2_aligned, dbsize));
+        if (k2.empty())
+            return false;
+
+        k2.args(dbarg, (float)qualityLevel, cornersarg);
+
+        if (!k2.runTask(false))
+            return false;
+    }
+
+    // collect list of pointers to features - put them into temporary image
+    {
+        ocl::Kernel k("findCorners", ocl::features::gftt_oclsrc,
+                      format("-D OP_FIND_CORNERS%s", haveMask ? " -D HAVE_MASK" : ""));
+        if (k.empty())
+            return false;
+
+        ocl::KernelArg eigarg = ocl::KernelArg::ReadOnlyNoSize(eig),
+                cornersarg = ocl::KernelArg::PtrWriteOnly(corners_buffer),
+                thresholdarg = ocl::KernelArg::PtrReadOnly(maxEigenValue);
+
+        if (!haveMask)
+            k.args(eigarg, cornersarg, eig.rows - 2, eig.cols - 2, thresholdarg,
+                  (int)possibleCornersCount);
+        else
+        {
+            UMat mask = _mask.getUMat();
+            k.args(eigarg, ocl::KernelArg::ReadOnlyNoSize(mask),
+                   cornersarg, eig.rows - 2, eig.cols - 2,
+                   thresholdarg, (int)possibleCornersCount);
+        }
+
+        size_t globalsize[2] = { (size_t)eig.cols - 2, (size_t)eig.rows - 2 };
+        if (!k.run(2, globalsize, NULL, false))
+            return false;
+
+        tmpCorners = corners_buffer.getMat(ACCESS_RW);
+        total = std::min<size_t>(tmpCorners.at<Vec2i>(0, 0)[0], possibleCornersCount);
+        if (total == 0)
+        {
+            _corners.release();
+            return true;
+        }
+    }
+
+    Corner* corner_ptr = tmpCorners.ptr<Corner>() + 1;
+    std::sort(corner_ptr, corner_ptr + total);
+
+    std::vector<Point2f> corners;
+    std::vector<float> cornersQuality;
+    corners.reserve(total);
+    cornersQuality.reserve(total);
+
+    if (minDistance >= 1)
+    {
+         // Partition the image into larger grids
+        int w = imgsize.width, h = imgsize.height;
+
+        const int cell_size = cvRound(minDistance);
+        const int grid_width = (w + cell_size - 1) / cell_size;
+        const int grid_height = (h + cell_size - 1) / cell_size;
+
+        std::vector<std::vector<Point2f> > grid(grid_width*grid_height);
+        minDistance *= minDistance;
+
+        for( i = 0; i < total; i++ )
+        {
+            const Corner & c = corner_ptr[i];
+            bool good = true;
+
+            int x_cell = c.x / cell_size;
+            int y_cell = c.y / cell_size;
+
+            int x1 = x_cell - 1;
+            int y1 = y_cell - 1;
+            int x2 = x_cell + 1;
+            int y2 = y_cell + 1;
+
+            // boundary check
+            x1 = std::max(0, x1);
+            y1 = std::max(0, y1);
+            x2 = std::min(grid_width - 1, x2);
+            y2 = std::min(grid_height - 1, y2);
+
+            for( int yy = y1; yy <= y2; yy++ )
+                for( int xx = x1; xx <= x2; xx++ )
+                {
+                    std::vector<Point2f> &m = grid[yy * grid_width + xx];
+
+                    if( m.size() )
+                    {
+                        for(j = 0; j < m.size(); j++)
+                        {
+                            float dx = c.x - m[j].x;
+                            float dy = c.y - m[j].y;
+
+                            if( dx*dx + dy*dy < minDistance )
+                            {
+                                good = false;
+                                goto break_out;
+                            }
+                        }
+                    }
+                }
+
+            break_out:
+
+            if (good)
+            {
+                grid[y_cell*grid_width + x_cell].push_back(Point2f((float)c.x, (float)c.y));
+
+                corners.push_back(Point2f((float)c.x, (float)c.y));
+                cornersQuality.push_back(c.val);
+                ++ncorners;
+
+                if( maxCorners > 0 && (int)ncorners == maxCorners )
+                    break;
+            }
+        }
+    }
+    else
+    {
+        for( i = 0; i < total; i++ )
+        {
+            const Corner & c = corner_ptr[i];
+
+            corners.push_back(Point2f((float)c.x, (float)c.y));
+            cornersQuality.push_back(c.val);
+            ++ncorners;
+
+            if( maxCorners > 0 && (int)ncorners == maxCorners )
+                break;
+        }
+    }
+
+    Mat(corners).reshape(2, (int)ncorners).
+        convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
+    if (_cornersQuality.needed()) {
+        Mat(cornersQuality).reshape(1, (int)ncorners).
+            convertTo(_cornersQuality, _cornersQuality.fixedType() ? _cornersQuality.type() : CV_32F);
+    }
+
+    return true;
+}
+
+#endif
+
+}
+
+void cv::goodFeaturesToTrack( InputArray image, OutputArray corners,
+                              int maxCorners, double qualityLevel, double minDistance,
+                              InputArray mask, int blockSize, bool useHarrisDetector, double k )
+{
+    return goodFeaturesToTrack(image, corners, maxCorners, qualityLevel, minDistance,
+                               mask, noArray(), blockSize, 3, useHarrisDetector, k);
+}
+
+void cv::goodFeaturesToTrack( InputArray image, OutputArray corners,
+                              int maxCorners, double qualityLevel, double minDistance,
+                              InputArray mask, int blockSize, int gradientSize, bool useHarrisDetector, double k )
+{
+    return goodFeaturesToTrack( image, corners, maxCorners, qualityLevel, minDistance,
+                                mask, noArray(), blockSize, gradientSize, useHarrisDetector, k );
+}
+
+void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
+                              int maxCorners, double qualityLevel, double minDistance,
+                              InputArray _mask, OutputArray _cornersQuality, int blockSize, int gradientSize,
+                              bool useHarrisDetector, double harrisK )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert( qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0 );
+    CV_Assert( _mask.empty() || ((_mask.type() == CV_8UC1 || _mask.type() == CV_BoolC1) && _mask.sameSize(_image)) );
+
+    CV_OCL_RUN(_image.dims() <= 2 && _image.isUMat(),
+               ocl_goodFeaturesToTrack(_image, _corners, maxCorners, qualityLevel, minDistance,
+                                       _mask, _cornersQuality, blockSize, gradientSize, useHarrisDetector, harrisK))
+
+    Mat image = _image.getMat(), eig, tmp;
+    if (image.empty())
+    {
+        _corners.release();
+        _cornersQuality.release();
+        return;
+    }
+
+    if( useHarrisDetector )
+        cornerHarris( image, eig, blockSize, gradientSize, harrisK );
+    else
+        cornerMinEigenVal( image, eig, blockSize, gradientSize );
+
+    double maxVal = 0;
+    minMaxLoc( eig, 0, &maxVal, 0, 0, _mask );
+    threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO );
+    dilate( eig, tmp, Mat());
+
+    Size imgsize = image.size();
+    std::vector<const float*> tmpCorners;
+
+    // collect list of pointers to features - put them into temporary image
+    Mat mask = _mask.getMat();
+    for( int y = 1; y < imgsize.height - 1; y++ )
+    {
+        const float* eig_data = (const float*)eig.ptr(y);
+        const float* tmp_data = (const float*)tmp.ptr(y);
+        const uchar* mask_data = mask.data ? mask.ptr(y) : 0;
+
+        for( int x = 1; x < imgsize.width - 1; x++ )
+        {
+            float val = eig_data[x];
+            if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) )
+                tmpCorners.push_back(eig_data + x);
+        }
+    }
+
+    std::vector<Point2f> corners;
+    std::vector<float> cornersQuality;
+    size_t i, j, total = tmpCorners.size(), ncorners = 0;
+
+    if (total == 0)
+    {
+        _corners.release();
+        _cornersQuality.release();
+        return;
+    }
+
+    std::sort( tmpCorners.begin(), tmpCorners.end(), greaterThanPtr() );
+
+    if (minDistance >= 1)
+    {
+         // Partition the image into larger grids
+        int w = image.cols;
+        int h = image.rows;
+
+        const int cell_size = cvRound(minDistance);
+        const int grid_width = (w + cell_size - 1) / cell_size;
+        const int grid_height = (h + cell_size - 1) / cell_size;
+
+        std::vector<std::vector<Point2f> > grid(grid_width*grid_height);
+
+        minDistance *= minDistance;
+
+        for( i = 0; i < total; i++ )
+        {
+            int ofs = (int)((const uchar*)tmpCorners[i] - eig.ptr());
+            int y = (int)(ofs / eig.step);
+            int x = (int)((ofs - y*eig.step)/sizeof(float));
+
+            bool good = true;
+
+            int x_cell = x / cell_size;
+            int y_cell = y / cell_size;
+
+            int x1 = x_cell - 1;
+            int y1 = y_cell - 1;
+            int x2 = x_cell + 1;
+            int y2 = y_cell + 1;
+
+            // boundary check
+            x1 = std::max(0, x1);
+            y1 = std::max(0, y1);
+            x2 = std::min(grid_width-1, x2);
+            y2 = std::min(grid_height-1, y2);
+
+            for( int yy = y1; yy <= y2; yy++ )
+            {
+                for( int xx = x1; xx <= x2; xx++ )
+                {
+                    std::vector <Point2f> &m = grid[yy*grid_width + xx];
+
+                    if( m.size() )
+                    {
+                        for(j = 0; j < m.size(); j++)
+                        {
+                            float dx = x - m[j].x;
+                            float dy = y - m[j].y;
+
+                            if( dx*dx + dy*dy < minDistance )
+                            {
+                                good = false;
+                                goto break_out;
+                            }
+                        }
+                    }
+                }
+            }
+
+            break_out:
+
+            if (good)
+            {
+                grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x, (float)y));
+
+                cornersQuality.push_back(*tmpCorners[i]);
+
+                corners.push_back(Point2f((float)x, (float)y));
+                ++ncorners;
+
+                if( maxCorners > 0 && (int)ncorners == maxCorners )
+                    break;
+            }
+        }
+    }
+    else
+    {
+        for( i = 0; i < total; i++ )
+        {
+            cornersQuality.push_back(*tmpCorners[i]);
+
+            int ofs = (int)((const uchar*)tmpCorners[i] - eig.ptr());
+            int y = (int)(ofs / eig.step);
+            int x = (int)((ofs - y*eig.step)/sizeof(float));
+
+            corners.push_back(Point2f((float)x, (float)y));
+            ++ncorners;
+
+            if( maxCorners > 0 && (int)ncorners == maxCorners )
+                break;
+        }
+    }
+
+    Mat(corners).reshape(2, (int)ncorners).
+        convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
+    if (_cornersQuality.needed()) {
+        Mat(cornersQuality).reshape(1, (int)ncorners).
+            convertTo(_cornersQuality, _cornersQuality.fixedType() ? _cornersQuality.type() : CV_32F);
+    }
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/features/src/gftt.cpp b/upstream/opencv/modules/features/src/gftt.cpp
new file mode 100644
index 0000000..0f98efc
--- /dev/null
+++ b/upstream/opencv/modules/features/src/gftt.cpp
@@ -0,0 +1,185 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+class GFTTDetector_Impl CV_FINAL : public GFTTDetector
+{
+public:
+    GFTTDetector_Impl( int _nfeatures, double _qualityLevel,
+                      double _minDistance, int _blockSize, int _gradientSize,
+                      bool _useHarrisDetector, double _k )
+        : nfeatures(_nfeatures), qualityLevel(_qualityLevel), minDistance(_minDistance),
+        blockSize(_blockSize), gradSize(_gradientSize), useHarrisDetector(_useHarrisDetector), k(_k)
+    {
+    }
+
+    void read( const FileNode& fn) CV_OVERRIDE
+    {
+      // if node is empty, keep previous value
+      if (!fn["nfeatures"].empty())
+        fn["nfeatures"] >> nfeatures;
+      if (!fn["qualityLevel"].empty())
+        fn["qualityLevel"] >> qualityLevel;
+      if (!fn["minDistance"].empty())
+        fn["minDistance"] >> minDistance;
+      if (!fn["blockSize"].empty())
+        fn["blockSize"] >> blockSize;
+      if (!fn["gradSize"].empty())
+        fn["gradSize"] >> gradSize;
+      if (!fn["useHarrisDetector"].empty())
+        fn["useHarrisDetector"] >> useHarrisDetector;
+      if (!fn["k"].empty())
+        fn["k"] >> k;
+    }
+    void write( FileStorage& fs) const CV_OVERRIDE
+    {
+      if(fs.isOpened())
+      {
+        fs << "name" << getDefaultName();
+        fs << "nfeatures" << nfeatures;
+        fs << "qualityLevel" << qualityLevel;
+        fs << "minDistance" << minDistance;
+        fs << "blockSize" << blockSize;
+        fs << "gradSize" << gradSize;
+        fs << "useHarrisDetector" << useHarrisDetector;
+        fs << "k" << k;
+      }
+    }
+
+    void setMaxFeatures(int maxFeatures) CV_OVERRIDE { nfeatures = maxFeatures; }
+    int getMaxFeatures() const CV_OVERRIDE { return nfeatures; }
+
+    void setQualityLevel(double qlevel) CV_OVERRIDE { qualityLevel = qlevel; }
+    double getQualityLevel() const CV_OVERRIDE { return qualityLevel; }
+
+    void setMinDistance(double minDistance_) CV_OVERRIDE { minDistance = minDistance_; }
+    double getMinDistance() const CV_OVERRIDE { return minDistance; }
+
+    void setBlockSize(int blockSize_) CV_OVERRIDE { blockSize = blockSize_; }
+    int getBlockSize() const CV_OVERRIDE { return blockSize; }
+
+    void setGradientSize(int gradientSize_) CV_OVERRIDE { gradSize = gradientSize_; }
+    int getGradientSize() CV_OVERRIDE { return gradSize; }
+
+    void setHarrisDetector(bool val) CV_OVERRIDE { useHarrisDetector = val; }
+    bool getHarrisDetector() const CV_OVERRIDE { return useHarrisDetector; }
+
+    void setK(double k_) CV_OVERRIDE { k = k_; }
+    double getK() const CV_OVERRIDE { return k; }
+
+    void detect( InputArray _image, std::vector<KeyPoint>& keypoints, InputArray _mask ) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        if(_image.empty())
+        {
+            keypoints.clear();
+            return;
+        }
+
+        std::vector<Point2f> corners;
+        std::vector<float> cornersQuality;
+
+        if (_image.isUMat())
+        {
+            UMat ugrayImage;
+            if( _image.type() != CV_8U )
+                cvtColor( _image, ugrayImage, COLOR_BGR2GRAY );
+            else
+                ugrayImage = _image.getUMat();
+
+            goodFeaturesToTrack( ugrayImage, corners, nfeatures, qualityLevel, minDistance, _mask,
+                                 cornersQuality, blockSize, gradSize, useHarrisDetector, k );
+        }
+        else
+        {
+            Mat image = _image.getMat(), grayImage = image;
+            if( image.type() != CV_8U )
+                cvtColor( image, grayImage, COLOR_BGR2GRAY );
+
+            goodFeaturesToTrack( grayImage, corners, nfeatures, qualityLevel, minDistance, _mask,
+                                 cornersQuality, blockSize, gradSize, useHarrisDetector, k );
+        }
+
+        CV_Assert(corners.size() == cornersQuality.size());
+
+        keypoints.resize(corners.size());
+        for (size_t i = 0; i < corners.size(); i++)
+            keypoints[i] = KeyPoint(corners[i], (float)blockSize, -1, cornersQuality[i]);
+
+    }
+
+    int nfeatures;
+    double qualityLevel;
+    double minDistance;
+    int blockSize;
+    int gradSize;
+    bool useHarrisDetector;
+    double k;
+};
+
+
+Ptr<GFTTDetector> GFTTDetector::create( int _nfeatures, double _qualityLevel,
+                         double _minDistance, int _blockSize, int _gradientSize,
+                         bool _useHarrisDetector, double _k )
+{
+    return makePtr<GFTTDetector_Impl>(_nfeatures, _qualityLevel,
+                                      _minDistance, _blockSize, _gradientSize, _useHarrisDetector, _k);
+}
+
+Ptr<GFTTDetector> GFTTDetector::create( int _nfeatures, double _qualityLevel,
+                         double _minDistance, int _blockSize,
+                         bool _useHarrisDetector, double _k )
+{
+    return makePtr<GFTTDetector_Impl>(_nfeatures, _qualityLevel,
+                                      _minDistance, _blockSize, 3, _useHarrisDetector, _k);
+}
+
+String GFTTDetector::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".GFTTDetector");
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/hal_replacement.hpp b/upstream/opencv/modules/features/src/hal_replacement.hpp
new file mode 100644
index 0000000..7053f93
--- /dev/null
+++ b/upstream/opencv/modules/features/src/hal_replacement.hpp
@@ -0,0 +1,161 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_FEATURES_HAL_REPLACEMENT_HPP
+#define OPENCV_FEATURES_HAL_REPLACEMENT_HPP
+
+#include "opencv2/core/hal/interface.h"
+
+#if defined(__clang__)  // clang or MSVC clang
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//! @addtogroup features_hal_interface
+//! @note Define your functions to override default implementations:
+//! @code
+//! #undef hal_add8u
+//! #define hal_add8u my_add8u
+//! @endcode
+//! @{
+/**
+   @brief Detects corners using the FAST algorithm, returns mask.
+   @param src_data Source image data
+   @param src_step Source image step
+   @param dst_data Destination mask data
+   @param dst_step Destination mask step
+   @param width Source image width
+   @param height Source image height
+   @param type FAST type
+*/
+inline int hal_ni_FAST_dense(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, cv::FastFeatureDetector::DetectorType type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+
+//! @cond IGNORED
+#define cv_hal_FAST_dense hal_ni_FAST_dense
+//! @endcond
+
+/**
+   @brief Non-maximum suppression for FAST_9_16.
+   @param src_data,src_step Source mask
+   @param dst_data,dst_step Destination mask after NMS
+   @param width,height Source mask dimensions
+*/
+inline int hal_ni_FAST_NMS(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+
+//! @cond IGNORED
+#define cv_hal_FAST_NMS hal_ni_FAST_NMS
+//! @endcond
+
+/**
+   @brief Detects corners using the FAST algorithm.
+   @param src_data Source image data
+   @param src_step Source image step
+   @param width Source image width
+   @param height Source image height
+   @param keypoints_data Pointer to keypoints
+   @param keypoints_count Count of keypoints
+   @param threshold Threshold for keypoint
+   @param nonmax_suppression Indicates if make nonmaxima suppression or not.
+   @param type FAST type
+*/
+inline int hal_ni_FAST(const uchar* src_data, size_t src_step, int width, int height, uchar* keypoints_data, size_t* keypoints_count, int threshold, bool nonmax_suppression, int /*cv::FastFeatureDetector::DetectorType*/ type) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+
+/**
+   @brief Detects corners using the FAST algorithm.
+   @param src_data Source image data
+   @param src_step Source image step
+   @param width Source image width
+   @param height Source image height
+   @param keypoints_data Pointer to keypoints
+   @param keypoints_count Count of keypoints
+   @param threshold Threshold for keypoint
+   @param nonmax_suppression Indicates if make nonmaxima suppression or not.
+   @param type FAST type
+   @param realloc_func function for reallocation
+*/
+inline int hal_ni_FASTv2(const uchar* src_data, size_t src_step, int width, int height, void** keypoints_data, size_t* keypoints_count, int threshold, bool nonmax_suppression, int /*cv::FastFeatureDetector::DetectorType*/ type, void* (*realloc_func)(void*, size_t)) { return CV_HAL_ERROR_NOT_IMPLEMENTED; }
+
+//! @cond IGNORED
+#define cv_hal_FAST hal_ni_FAST
+#define cv_hal_FASTv2 hal_ni_FASTv2
+//! @endcond
+
+//! @}
+
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#include "custom_hal.hpp"
+
+//! @cond IGNORED
+#define CALL_HAL_RET(name, fun, retval, ...) \
+    int res = __CV_EXPAND(fun(__VA_ARGS__, &retval)); \
+    if (res == CV_HAL_ERROR_OK) \
+        return retval; \
+    else if (res != CV_HAL_ERROR_NOT_IMPLEMENTED) \
+        CV_Error_(cv::Error::StsInternal, \
+            ("HAL implementation " CVAUX_STR(name) " ==> " CVAUX_STR(fun) " returned %d (0x%08x)", res, res));
+
+
+#define CALL_HAL(name, fun, ...) \
+{                                           \
+    int res = __CV_EXPAND(fun(__VA_ARGS__)); \
+    if (res == CV_HAL_ERROR_OK) \
+        return; \
+    else if (res != CV_HAL_ERROR_NOT_IMPLEMENTED) \
+        CV_Error_(cv::Error::StsInternal, \
+            ("HAL implementation " CVAUX_STR(name) " ==> " CVAUX_STR(fun) " returned %d (0x%08x)", res, res)); \
+}
+//! @endcond
+
+#endif
diff --git a/upstream/opencv/modules/features/src/keypoint.cpp b/upstream/opencv/modules/features/src/keypoint.cpp
new file mode 100644
index 0000000..aad9fe3
--- /dev/null
+++ b/upstream/opencv/modules/features/src/keypoint.cpp
@@ -0,0 +1,293 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+struct KeypointResponseGreaterThanOrEqualToThreshold
+{
+    KeypointResponseGreaterThanOrEqualToThreshold(float _value) :
+    value(_value)
+    {
+    }
+    inline bool operator()(const KeyPoint& kpt) const
+    {
+        return kpt.response >= value;
+    }
+    float value;
+};
+
+struct KeypointResponseGreater
+{
+    inline bool operator()(const KeyPoint& kp1, const KeyPoint& kp2) const
+    {
+        return kp1.response > kp2.response;
+    }
+};
+
+// takes keypoints and culls them by the response
+void KeyPointsFilter::retainBest(std::vector<KeyPoint>& keypoints, int n_points)
+{
+    //this is only necessary if the keypoints size is greater than the number of desired points.
+    if( n_points >= 0 && keypoints.size() > (size_t)n_points )
+    {
+        if (n_points==0)
+        {
+            keypoints.clear();
+            return;
+        }
+        //first use nth element to partition the keypoints into the best and worst.
+        std::nth_element(keypoints.begin(), keypoints.begin() + n_points - 1, keypoints.end(), KeypointResponseGreater());
+        //this is the boundary response, and in the case of FAST may be ambiguous
+        float ambiguous_response = keypoints[n_points - 1].response;
+        //use std::partition to grab all of the keypoints with the boundary response.
+        std::vector<KeyPoint>::const_iterator new_end =
+        std::partition(keypoints.begin() + n_points, keypoints.end(),
+                       KeypointResponseGreaterThanOrEqualToThreshold(ambiguous_response));
+        //resize the keypoints, given this new end point. nth_element and partition reordered the points inplace
+        keypoints.resize(new_end - keypoints.begin());
+    }
+}
+
+struct RoiPredicate
+{
+    RoiPredicate( const Rect& _r ) : r(_r)
+    {}
+
+    bool operator()( const KeyPoint& keyPt ) const
+    {
+        // workaround for https://github.com/opencv/opencv/issues/26016
+        // To keep its behaviour, keyPt.pt casts to Point_<int>.
+        return !r.contains( Point_<int>(keyPt.pt) );
+    }
+
+    Rect r;
+};
+
+void KeyPointsFilter::runByImageBorder( std::vector<KeyPoint>& keypoints, Size imageSize, int borderSize )
+{
+    if( borderSize > 0)
+    {
+        if (imageSize.height <= borderSize * 2 || imageSize.width <= borderSize * 2)
+            keypoints.clear();
+        else
+            keypoints.erase( std::remove_if(keypoints.begin(), keypoints.end(),
+                                       RoiPredicate(Rect(Point(borderSize, borderSize),
+                                                         Point(imageSize.width - borderSize, imageSize.height - borderSize)))),
+                             keypoints.end() );
+    }
+}
+
+struct SizePredicate
+{
+    SizePredicate( float _minSize, float _maxSize ) : minSize(_minSize), maxSize(_maxSize)
+    {}
+
+    bool operator()( const KeyPoint& keyPt ) const
+    {
+        float size = keyPt.size;
+        return (size < minSize) || (size > maxSize);
+    }
+
+    float minSize, maxSize;
+};
+
+void KeyPointsFilter::runByKeypointSize( std::vector<KeyPoint>& keypoints, float minSize, float maxSize )
+{
+    CV_Assert( minSize >= 0 );
+    CV_Assert( maxSize >= 0);
+    CV_Assert( minSize <= maxSize );
+
+    keypoints.erase( std::remove_if(keypoints.begin(), keypoints.end(), SizePredicate(minSize, maxSize)),
+                     keypoints.end() );
+}
+
+class MaskPredicate
+{
+public:
+    MaskPredicate( const Mat& _mask ) : mask(_mask) {}
+    bool operator() (const KeyPoint& key_pt) const
+    {
+        return mask.at<uchar>( (int)(key_pt.pt.y + 0.5f), (int)(key_pt.pt.x + 0.5f) ) == 0;
+    }
+    MaskPredicate& operator=(const MaskPredicate&) = delete;
+    // To avoid -Wdeprecated-copy warning, copy constructor is needed.
+    MaskPredicate(const MaskPredicate&) = default;
+
+private:
+    const Mat mask;
+};
+
+void KeyPointsFilter::runByPixelsMask( std::vector<KeyPoint>& keypoints, const Mat& mask )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( mask.empty() )
+        return;
+
+    keypoints.erase(std::remove_if(keypoints.begin(), keypoints.end(), MaskPredicate(mask)), keypoints.end());
+}
+/*
+ * Remove objects from some image and a vector by mask for pixels of this image
+ */
+template <typename T>
+void runByPixelsMask2(std::vector<KeyPoint> &keypoints, std::vector<T> &removeFrom, const Mat &mask)
+{
+    if (mask.empty())
+        return;
+
+    MaskPredicate maskPredicate(mask);
+    removeFrom.erase(std::remove_if(removeFrom.begin(), removeFrom.end(),
+                                    [&](const T &x)
+                                    {
+                                        auto index = &x - &removeFrom.front();
+                                        return maskPredicate(keypoints[index]);
+                                    }),
+                    removeFrom.end());
+    keypoints.erase(std::remove_if(keypoints.begin(), keypoints.end(), maskPredicate), keypoints.end());
+}
+void KeyPointsFilter::runByPixelsMask2VectorPoint(std::vector<KeyPoint> &keypoints, std::vector<std::vector<Point> > &removeFrom, const Mat &mask)
+{
+    runByPixelsMask2(keypoints, removeFrom, mask);
+}
+
+struct KeyPoint_LessThan
+{
+    KeyPoint_LessThan(const std::vector<KeyPoint>& _kp) : kp(&_kp) {}
+    bool operator()(int i, int j) const
+    {
+        const KeyPoint& kp1 = (*kp)[i];
+        const KeyPoint& kp2 = (*kp)[j];
+        if( kp1.pt.x != kp2.pt.x )
+            return kp1.pt.x < kp2.pt.x;
+        if( kp1.pt.y != kp2.pt.y )
+            return kp1.pt.y < kp2.pt.y;
+        if( kp1.size != kp2.size )
+            return kp1.size > kp2.size;
+        if( kp1.angle != kp2.angle )
+            return kp1.angle < kp2.angle;
+        if( kp1.response != kp2.response )
+            return kp1.response > kp2.response;
+        if( kp1.octave != kp2.octave )
+            return kp1.octave > kp2.octave;
+        if( kp1.class_id != kp2.class_id )
+            return kp1.class_id > kp2.class_id;
+
+        return i < j;
+    }
+    const std::vector<KeyPoint>* kp;
+};
+
+void KeyPointsFilter::removeDuplicated( std::vector<KeyPoint>& keypoints )
+{
+    int i, j, n = (int)keypoints.size();
+    std::vector<int> kpidx(n);
+    std::vector<uchar> mask(n, (uchar)1);
+
+    for( i = 0; i < n; i++ )
+        kpidx[i] = i;
+    std::sort(kpidx.begin(), kpidx.end(), KeyPoint_LessThan(keypoints));
+    for( i = 1, j = 0; i < n; i++ )
+    {
+        KeyPoint& kp1 = keypoints[kpidx[i]];
+        KeyPoint& kp2 = keypoints[kpidx[j]];
+        if( kp1.pt.x != kp2.pt.x || kp1.pt.y != kp2.pt.y ||
+            kp1.size != kp2.size || kp1.angle != kp2.angle )
+            j = i;
+        else
+            mask[kpidx[i]] = 0;
+    }
+
+    for( i = j = 0; i < n; i++ )
+    {
+        if( mask[i] )
+        {
+            if( i != j )
+                keypoints[j] = keypoints[i];
+            j++;
+        }
+    }
+    keypoints.resize(j);
+}
+
+struct KeyPoint12_LessThan
+{
+    bool operator()(const KeyPoint &kp1, const KeyPoint &kp2) const
+    {
+        if( kp1.pt.x != kp2.pt.x )
+            return kp1.pt.x < kp2.pt.x;
+        if( kp1.pt.y != kp2.pt.y )
+            return kp1.pt.y < kp2.pt.y;
+        if( kp1.size != kp2.size )
+            return kp1.size > kp2.size;
+        if( kp1.angle != kp2.angle )
+            return kp1.angle < kp2.angle;
+        if( kp1.response != kp2.response )
+            return kp1.response > kp2.response;
+        if( kp1.octave != kp2.octave )
+            return kp1.octave > kp2.octave;
+        return kp1.class_id > kp2.class_id;
+    }
+};
+
+void KeyPointsFilter::removeDuplicatedSorted( std::vector<KeyPoint>& keypoints )
+{
+    int i, j, n = (int)keypoints.size();
+
+    if (n < 2) return;
+
+    std::sort(keypoints.begin(), keypoints.end(), KeyPoint12_LessThan());
+
+    for( i = 0, j = 1; j < n; ++j )
+    {
+        const KeyPoint& kp1 = keypoints[i];
+        const KeyPoint& kp2 = keypoints[j];
+        if( kp1.pt.x != kp2.pt.x || kp1.pt.y != kp2.pt.y ||
+            kp1.size != kp2.size || kp1.angle != kp2.angle ) {
+            keypoints[++i] = keypoints[j];
+        }
+    }
+    keypoints.resize(i + 1);
+}
+
+}
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/main.cpp b/upstream/opencv/modules/features/src/main.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/main.cpp
rename to upstream/opencv/modules/features/src/main.cpp
diff --git a/upstream/opencv/modules/features/src/matchers.cpp b/upstream/opencv/modules/features/src/matchers.cpp
new file mode 100644
index 0000000..2223d59
--- /dev/null
+++ b/upstream/opencv/modules/features/src/matchers.cpp
@@ -0,0 +1,1604 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#ifdef HAVE_OPENCV_FLANN
+#include "opencv2/flann/miniflann.hpp"
+#endif
+#include <limits>
+#include "opencl_kernels_features.hpp"
+
+#if defined(HAVE_EIGEN) && EIGEN_WORLD_VERSION == 2
+#  if defined(_MSC_VER)
+#    pragma warning(push)
+#    pragma warning(disable:4701)  // potentially uninitialized local variable
+#    pragma warning(disable:4702)  // unreachable code
+#    pragma warning(disable:4714)  // const marked as __forceinline not inlined
+#  endif
+#  include <Eigen/Array>
+#  if defined(_MSC_VER)
+#    pragma warning(pop)
+#  endif
+#endif
+
+namespace cv
+{
+
+/////////////////////// ocl functions for BFMatcher ///////////////////////////
+
+#ifdef HAVE_OPENCL
+static void ensureSizeIsEnough(int rows, int cols, int type, UMat &m)
+{
+    if (m.type() == type && m.rows >= rows && m.cols >= cols)
+        m = m(Rect(0, 0, cols, rows));
+    else
+        m.create(rows, cols, type);
+}
+
+static bool ocl_matchSingle(InputArray query, InputArray train,
+        UMat &trainIdx, UMat *distance, int distType)
+{
+    if (query.empty() || train.empty())
+        return false;
+
+    const int query_rows = query.rows();
+    const int query_cols = query.cols();
+
+    ensureSizeIsEnough(1, query_rows, CV_32S, trainIdx);
+    if (distance)
+        ensureSizeIsEnough(1, query_rows, CV_32F, *distance);
+
+    ocl::Device devDef = ocl::Device::getDefault();
+
+    UMat uquery = query.getUMat(), utrain = train.getUMat();
+    int kercn = 1;
+    if (devDef.isIntel() &&
+        (0 == (uquery.step % 4)) && (0 == (uquery.cols % 4)) && (0 == (uquery.offset % 4)) &&
+        (0 == (utrain.step % 4)) && (0 == (utrain.cols % 4)) && (0 == (utrain.offset % 4)))
+        kercn = 4;
+
+    int block_size = 16;
+    int max_desc_len = 0;
+    bool is_cpu = devDef.type() == ocl::Device::TYPE_CPU;
+    if (query_cols <= 64)
+        max_desc_len = 64 / kercn;
+    else if (query_cols <= 128 && !is_cpu)
+        max_desc_len = 128 / kercn;
+
+    int depth = query.depth();
+    cv::String opts;
+    opts = cv::format("-D T=%s -D TN=%s -D kercn=%d %s -D DIST_TYPE=%d -D BLOCK_SIZE=%d -D MAX_DESC_LEN=%d",
+        ocl::typeToStr(depth), ocl::typeToStr(CV_MAKETYPE(depth, kercn)), kercn, depth == CV_32F ? "-D T_FLOAT" : "", distType, block_size, max_desc_len);
+    ocl::Kernel k("BruteForceMatch_Match", ocl::features::brute_force_match_oclsrc, opts);
+    if(k.empty())
+        return false;
+
+    size_t globalSize[] = {((size_t)query.size().height + block_size - 1) / block_size * block_size, (size_t)block_size};
+    size_t localSize[] = {(size_t)block_size, (size_t)block_size};
+
+    int idx = 0;
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(uquery));
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(utrain));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(trainIdx));
+    UMat dummyDist;
+    if (!distance)
+        ensureSizeIsEnough(1, query_rows, CV_32F, dummyDist);
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(distance ? *distance : dummyDist));
+    idx = k.set(idx, uquery.rows);
+    idx = k.set(idx, uquery.cols);
+    idx = k.set(idx, utrain.rows);
+    idx = k.set(idx, utrain.cols);
+    idx = k.set(idx, (int)(uquery.step / sizeof(float)));
+
+    return k.run(2, globalSize, localSize, false);
+}
+
+static bool ocl_matchConvert(const Mat &trainIdx, const Mat &distance, std::vector< std::vector<DMatch> > &matches)
+{
+    if (trainIdx.empty() || distance.empty())
+        return false;
+
+    if( (trainIdx.type() != CV_32SC1) || (distance.type() != CV_32FC1 || distance.cols != trainIdx.cols) )
+        return false;
+
+    const int nQuery = trainIdx.cols;
+
+    matches.clear();
+    matches.reserve(nQuery);
+
+    const int *trainIdx_ptr = trainIdx.ptr<int>();
+    const float *distance_ptr =  distance.ptr<float>();
+    for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx, ++trainIdx_ptr, ++distance_ptr)
+    {
+        int trainIndex = *trainIdx_ptr;
+
+        if (trainIndex == -1)
+            continue;
+
+        float dst = *distance_ptr;
+
+        DMatch m(queryIdx, trainIndex, 0, dst);
+
+        std::vector<DMatch> temp;
+        temp.push_back(m);
+        matches.push_back(temp);
+    }
+    return true;
+}
+
+static bool ocl_matchDownload(const UMat &trainIdx, const UMat &distance, std::vector< std::vector<DMatch> > &matches)
+{
+    if (trainIdx.empty() || distance.empty())
+        return false;
+
+    Mat trainIdxCPU = trainIdx.getMat(ACCESS_READ);
+    Mat distanceCPU = distance.getMat(ACCESS_READ);
+
+    return ocl_matchConvert(trainIdxCPU, distanceCPU, matches);
+}
+
+static bool ocl_knnMatchSingle(InputArray query, InputArray train, UMat &trainIdx,
+                               UMat &distance, int distType)
+{
+    if (query.empty() || train.empty())
+        return false;
+
+    const int query_rows = query.rows();
+    const int query_cols = query.cols();
+
+    ensureSizeIsEnough(1, query_rows, CV_32SC2, trainIdx);
+    ensureSizeIsEnough(1, query_rows, CV_32FC2, distance);
+
+    trainIdx.setTo(Scalar::all(-1));
+
+    ocl::Device devDef = ocl::Device::getDefault();
+
+    UMat uquery = query.getUMat(), utrain = train.getUMat();
+    int kercn = 1;
+    if (devDef.isIntel() &&
+        (0 == (uquery.step % 4)) && (0 == (uquery.cols % 4)) && (0 == (uquery.offset % 4)) &&
+        (0 == (utrain.step % 4)) && (0 == (utrain.cols % 4)) && (0 == (utrain.offset % 4)))
+        kercn = 4;
+
+    int block_size = 16;
+    int max_desc_len = 0;
+    bool is_cpu = devDef.type() == ocl::Device::TYPE_CPU;
+    if (query_cols <= 64)
+        max_desc_len = 64 / kercn;
+    else if (query_cols <= 128 && !is_cpu)
+        max_desc_len = 128 / kercn;
+
+    int depth = query.depth();
+    cv::String opts;
+    opts = cv::format("-D T=%s -D TN=%s -D kercn=%d %s -D DIST_TYPE=%d -D BLOCK_SIZE=%d -D MAX_DESC_LEN=%d",
+        ocl::typeToStr(depth), ocl::typeToStr(CV_MAKETYPE(depth, kercn)), kercn, depth == CV_32F ? "-D T_FLOAT" : "", distType, block_size, max_desc_len);
+    ocl::Kernel k("BruteForceMatch_knnMatch", ocl::features::brute_force_match_oclsrc, opts);
+    if(k.empty())
+        return false;
+
+    size_t globalSize[] = {((size_t)query_rows + block_size - 1) / block_size * block_size, (size_t)block_size};
+    size_t localSize[] = {(size_t)block_size, (size_t)block_size};
+
+    int idx = 0;
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(uquery));
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(utrain));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(trainIdx));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(distance));
+    idx = k.set(idx, uquery.rows);
+    idx = k.set(idx, uquery.cols);
+    idx = k.set(idx, utrain.rows);
+    idx = k.set(idx, utrain.cols);
+    idx = k.set(idx, (int)(uquery.step / sizeof(float)));
+
+    return k.run(2, globalSize, localSize, false);
+}
+
+static bool ocl_knnMatchConvert(const Mat &trainIdx, const Mat &distance, std::vector< std::vector<DMatch> > &matches, bool compactResult)
+{
+    if (trainIdx.empty() || distance.empty())
+        return false;
+
+    if(trainIdx.type() != CV_32SC2 && trainIdx.type() != CV_32SC1) return false;
+    if(distance.type() != CV_32FC2 && distance.type() != CV_32FC1)return false;
+    if(distance.size() != trainIdx.size()) return false;
+    if(!trainIdx.isContinuous() || !distance.isContinuous()) return false;
+
+    const int nQuery = trainIdx.type() == CV_32SC2 ? trainIdx.cols : trainIdx.rows;
+    const int k = trainIdx.type() == CV_32SC2 ? 2 : trainIdx.cols;
+
+    matches.clear();
+    matches.reserve(nQuery);
+
+    const int *trainIdx_ptr = trainIdx.ptr<int>();
+    const float *distance_ptr = distance.ptr<float>();
+
+    for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx)
+    {
+        matches.push_back(std::vector<DMatch>());
+        std::vector<DMatch> &curMatches = matches.back();
+        curMatches.reserve(k);
+
+        for (int i = 0; i < k; ++i, ++trainIdx_ptr, ++distance_ptr)
+        {
+            int trainIndex = *trainIdx_ptr;
+
+            if (trainIndex != -1)
+            {
+                float dst = *distance_ptr;
+
+                DMatch m(queryIdx, trainIndex, 0, dst);
+
+                curMatches.push_back(m);
+            }
+        }
+
+        if (compactResult && curMatches.empty())
+            matches.pop_back();
+    }
+    return true;
+}
+
+static bool ocl_knnMatchDownload(const UMat &trainIdx, const UMat &distance, std::vector< std::vector<DMatch> > &matches, bool compactResult)
+{
+    if (trainIdx.empty() || distance.empty())
+        return false;
+
+    Mat trainIdxCPU = trainIdx.getMat(ACCESS_READ);
+    Mat distanceCPU = distance.getMat(ACCESS_READ);
+
+    return ocl_knnMatchConvert(trainIdxCPU, distanceCPU, matches, compactResult);
+}
+
+static bool ocl_radiusMatchSingle(InputArray query, InputArray train,
+        UMat &trainIdx,   UMat &distance, UMat &nMatches, float maxDistance, int distType)
+{
+    if (query.empty() || train.empty())
+        return false;
+
+    const int query_rows = query.rows();
+    const int train_rows = train.rows();
+
+    ensureSizeIsEnough(1, query_rows, CV_32SC1, nMatches);
+
+    if (trainIdx.empty())
+    {
+        ensureSizeIsEnough(query_rows, std::max((train_rows / 100), 10), CV_32SC1, trainIdx);
+        ensureSizeIsEnough(query_rows, std::max((train_rows / 100), 10), CV_32FC1, distance);
+    }
+
+    nMatches.setTo(Scalar::all(0));
+
+    ocl::Device devDef = ocl::Device::getDefault();
+    UMat uquery = query.getUMat(), utrain = train.getUMat();
+    int kercn = 1;
+    if (devDef.isIntel() &&
+        (0 == (uquery.step % 4)) && (0 == (uquery.cols % 4)) && (0 == (uquery.offset % 4)) &&
+        (0 == (utrain.step % 4)) && (0 == (utrain.cols % 4)) && (0 == (utrain.offset % 4)))
+        kercn = 4;
+
+    int block_size = 16;
+    int depth = query.depth();
+    cv::String opts;
+    opts = cv::format("-D T=%s -D TN=%s -D kercn=%d %s -D DIST_TYPE=%d -D BLOCK_SIZE=%d",
+        ocl::typeToStr(depth), ocl::typeToStr(CV_MAKETYPE(depth, kercn)), kercn, depth == CV_32F ? "-D T_FLOAT" : "", distType, block_size);
+    ocl::Kernel k("BruteForceMatch_RadiusMatch", ocl::features::brute_force_match_oclsrc, opts);
+    if (k.empty())
+        return false;
+
+    size_t globalSize[] = {((size_t)train_rows + block_size - 1) / block_size * block_size, ((size_t)query_rows + block_size - 1) / block_size * block_size};
+    size_t localSize[] = {(size_t)block_size, (size_t)block_size};
+
+    int idx = 0;
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(uquery));
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(utrain));
+    idx = k.set(idx, maxDistance);
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(trainIdx));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(distance));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(nMatches));
+    idx = k.set(idx, uquery.rows);
+    idx = k.set(idx, uquery.cols);
+    idx = k.set(idx, utrain.rows);
+    idx = k.set(idx, utrain.cols);
+    idx = k.set(idx, trainIdx.cols);
+    idx = k.set(idx, (int)(uquery.step / sizeof(float)));
+    idx = k.set(idx, (int)(trainIdx.step / sizeof(int)));
+
+    return k.run(2, globalSize, localSize, false);
+}
+
+static bool ocl_radiusMatchConvert(const Mat &trainIdx, const Mat &distance, const Mat &_nMatches,
+        std::vector< std::vector<DMatch> > &matches, bool compactResult)
+{
+    if (trainIdx.empty() || distance.empty() || _nMatches.empty())
+        return false;
+
+    if( (trainIdx.type() != CV_32SC1) ||
+        (distance.type() != CV_32FC1 || distance.size() != trainIdx.size()) ||
+        (_nMatches.type() != CV_32SC1 || _nMatches.cols != trainIdx.rows) )
+        return false;
+
+    const int nQuery = trainIdx.rows;
+
+    matches.clear();
+    matches.reserve(nQuery);
+
+    const int *nMatches_ptr = _nMatches.ptr<int>();
+
+    for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx)
+    {
+        const int *trainIdx_ptr = trainIdx.ptr<int>(queryIdx);
+        const float *distance_ptr = distance.ptr<float>(queryIdx);
+
+        const int nMatches = std::min(nMatches_ptr[queryIdx], trainIdx.cols);
+
+        if (nMatches == 0)
+        {
+            if (!compactResult)
+                matches.push_back(std::vector<DMatch>());
+            continue;
+        }
+
+        matches.push_back(std::vector<DMatch>(nMatches));
+        std::vector<DMatch> &curMatches = matches.back();
+
+        for (int i = 0; i < nMatches; ++i, ++trainIdx_ptr, ++distance_ptr)
+        {
+            int trainIndex = *trainIdx_ptr;
+
+            float dst = *distance_ptr;
+
+            DMatch m(queryIdx, trainIndex, 0, dst);
+
+            curMatches[i] = m;
+        }
+
+        std::sort(curMatches.begin(), curMatches.end());
+    }
+    return true;
+}
+
+static bool ocl_radiusMatchDownload(const UMat &trainIdx, const UMat &distance, const UMat &nMatches,
+        std::vector< std::vector<DMatch> > &matches, bool compactResult)
+{
+    if (trainIdx.empty() || distance.empty() || nMatches.empty())
+        return false;
+
+    Mat trainIdxCPU = trainIdx.getMat(ACCESS_READ);
+    Mat distanceCPU = distance.getMat(ACCESS_READ);
+    Mat nMatchesCPU = nMatches.getMat(ACCESS_READ);
+
+    return ocl_radiusMatchConvert(trainIdxCPU, distanceCPU, nMatchesCPU, matches, compactResult);
+}
+#endif
+
+/****************************************************************************************\
+*                                      DescriptorMatcher                                 *
+\****************************************************************************************/
+DescriptorMatcher::DescriptorCollection::DescriptorCollection()
+{}
+
+DescriptorMatcher::DescriptorCollection::DescriptorCollection( const DescriptorCollection& collection )
+{
+    mergedDescriptors = collection.mergedDescriptors.clone();
+    std::copy( collection.startIdxs.begin(), collection.startIdxs.begin(), startIdxs.begin() );
+}
+
+DescriptorMatcher::DescriptorCollection::~DescriptorCollection()
+{}
+
+void DescriptorMatcher::DescriptorCollection::set( const std::vector<Mat>& descriptors )
+{
+    clear();
+
+    size_t imageCount = descriptors.size();
+    CV_Assert( imageCount > 0 );
+
+    startIdxs.resize( imageCount );
+
+    int dim = -1;
+    int type = -1;
+    startIdxs[0] = 0;
+    for( size_t i = 1; i < imageCount; i++ )
+    {
+        int s = 0;
+        if( !descriptors[i-1].empty() )
+        {
+            dim = descriptors[i-1].cols;
+            type = descriptors[i-1].type();
+            s = descriptors[i-1].rows;
+        }
+        startIdxs[i] = startIdxs[i-1] + s;
+    }
+    if( imageCount == 1 )
+    {
+        if( descriptors[0].empty() ) return;
+
+        dim = descriptors[0].cols;
+        type = descriptors[0].type();
+    }
+    CV_Assert( dim > 0 );
+
+    int count = startIdxs[imageCount-1] + descriptors[imageCount-1].rows;
+
+    if( count > 0 )
+    {
+        mergedDescriptors.create( count, dim, type );
+        for( size_t i = 0; i < imageCount; i++ )
+        {
+            if( !descriptors[i].empty() )
+            {
+                CV_Assert( descriptors[i].cols == dim && descriptors[i].type() == type );
+                Mat m = mergedDescriptors.rowRange( startIdxs[i], startIdxs[i] + descriptors[i].rows );
+                descriptors[i].copyTo(m);
+            }
+        }
+    }
+}
+
+void DescriptorMatcher::DescriptorCollection::clear()
+{
+    startIdxs.clear();
+    mergedDescriptors.release();
+}
+
+Mat DescriptorMatcher::DescriptorCollection::getDescriptor( int imgIdx, int localDescIdx ) const
+{
+    CV_Assert( imgIdx < (int)startIdxs.size() );
+    int globalIdx = startIdxs[imgIdx] + localDescIdx;
+    CV_Assert( globalIdx < (int)size() );
+
+    return getDescriptor( globalIdx );
+}
+
+const Mat& DescriptorMatcher::DescriptorCollection::getDescriptors() const
+{
+    return mergedDescriptors;
+}
+
+Mat DescriptorMatcher::DescriptorCollection::getDescriptor( int globalDescIdx ) const
+{
+    CV_Assert( globalDescIdx < size() );
+    return mergedDescriptors.row( globalDescIdx );
+}
+
+void DescriptorMatcher::DescriptorCollection::getLocalIdx( int globalDescIdx, int& imgIdx, int& localDescIdx ) const
+{
+    CV_Assert( (globalDescIdx>=0) && (globalDescIdx < size()) );
+    std::vector<int>::const_iterator img_it = std::upper_bound(startIdxs.begin(), startIdxs.end(), globalDescIdx);
+    --img_it;
+    imgIdx = (int)(img_it - startIdxs.begin());
+    localDescIdx = globalDescIdx - (*img_it);
+}
+
+int DescriptorMatcher::DescriptorCollection::size() const
+{
+    return mergedDescriptors.rows;
+}
+
+/*
+ * DescriptorMatcher
+ */
+static void convertMatches( const std::vector<std::vector<DMatch> >& knnMatches, std::vector<DMatch>& matches )
+{
+    matches.clear();
+    matches.reserve( knnMatches.size() );
+    for( size_t i = 0; i < knnMatches.size(); i++ )
+    {
+        CV_Assert( knnMatches[i].size() <= 1 );
+        if( !knnMatches[i].empty() )
+            matches.push_back( knnMatches[i][0] );
+    }
+}
+
+DescriptorMatcher::~DescriptorMatcher()
+{}
+
+void DescriptorMatcher::add( InputArrayOfArrays _descriptors )
+{
+    if( _descriptors.isUMatVector() )
+    {
+        std::vector<UMat> descriptors;
+        _descriptors.getUMatVector( descriptors );
+        utrainDescCollection.insert( utrainDescCollection.end(), descriptors.begin(), descriptors.end() );
+    }
+    else if( _descriptors.isUMat() )
+    {
+        std::vector<UMat> descriptors = std::vector<UMat>(1, _descriptors.getUMat());
+        utrainDescCollection.insert( utrainDescCollection.end(), descriptors.begin(), descriptors.end() );
+    }
+    else if( _descriptors.isMatVector() )
+    {
+        std::vector<Mat> descriptors;
+        _descriptors.getMatVector(descriptors);
+        trainDescCollection.insert( trainDescCollection.end(), descriptors.begin(), descriptors.end() );
+    }
+    else if( _descriptors.isMat() )
+    {
+        std::vector<Mat> descriptors = std::vector<Mat>(1, _descriptors.getMat());
+        trainDescCollection.insert( trainDescCollection.end(), descriptors.begin(), descriptors.end() );
+    }
+    else
+    {
+        CV_Assert( _descriptors.isUMat() || _descriptors.isUMatVector() || _descriptors.isMat() || _descriptors.isMatVector() );
+    }
+}
+
+const std::vector<Mat>& DescriptorMatcher::getTrainDescriptors() const
+{
+    return trainDescCollection;
+}
+
+void DescriptorMatcher::clear()
+{
+    utrainDescCollection.clear();
+    trainDescCollection.clear();
+}
+
+bool DescriptorMatcher::empty() const
+{
+    return trainDescCollection.empty() && utrainDescCollection.empty();
+}
+
+void DescriptorMatcher::train()
+{}
+
+void DescriptorMatcher::match( InputArray queryDescriptors, InputArray trainDescriptors,
+                              std::vector<DMatch>& matches, InputArray mask ) const
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<DescriptorMatcher> tempMatcher = clone(true);
+    tempMatcher->add(trainDescriptors);
+    tempMatcher->match( queryDescriptors, matches, std::vector<Mat>(1, mask.getMat()) );
+}
+
+void DescriptorMatcher::knnMatch( InputArray queryDescriptors, InputArray trainDescriptors,
+                                  std::vector<std::vector<DMatch> >& matches, int knn,
+                                  InputArray mask, bool compactResult ) const
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<DescriptorMatcher> tempMatcher = clone(true);
+    tempMatcher->add(trainDescriptors);
+    tempMatcher->knnMatch( queryDescriptors, matches, knn, std::vector<Mat>(1, mask.getMat()), compactResult );
+}
+
+void DescriptorMatcher::radiusMatch( InputArray queryDescriptors, InputArray trainDescriptors,
+                                     std::vector<std::vector<DMatch> >& matches, float maxDistance, InputArray mask,
+                                     bool compactResult ) const
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<DescriptorMatcher> tempMatcher = clone(true);
+    tempMatcher->add(trainDescriptors);
+    tempMatcher->radiusMatch( queryDescriptors, matches, maxDistance, std::vector<Mat>(1, mask.getMat()), compactResult );
+}
+
+void DescriptorMatcher::match( InputArray queryDescriptors, std::vector<DMatch>& matches, InputArrayOfArrays masks )
+{
+    CV_INSTRUMENT_REGION();
+
+    std::vector<std::vector<DMatch> > knnMatches;
+    knnMatch( queryDescriptors, knnMatches, 1, masks, true /*compactResult*/ );
+    convertMatches( knnMatches, matches );
+}
+
+void DescriptorMatcher::checkMasks( InputArrayOfArrays _masks, int queryDescriptorsCount ) const
+{
+    std::vector<Mat> masks;
+    _masks.getMatVector(masks);
+
+    if( isMaskSupported() && !masks.empty() )
+    {
+        // Check masks
+        const size_t imageCount = std::max(trainDescCollection.size(), utrainDescCollection.size() );
+        CV_Assert( masks.size() == imageCount );
+        for( size_t i = 0; i < imageCount; i++ )
+        {
+            if (masks[i].empty())
+                continue;
+            const bool hasTrainDesc = !trainDescCollection.empty() && !trainDescCollection[i].empty();
+            const bool hasUTrainDesc = !utrainDescCollection.empty() && !utrainDescCollection[i].empty();
+            if (hasTrainDesc || hasUTrainDesc)
+            {
+                const int rows = hasTrainDesc ? trainDescCollection[i].rows : utrainDescCollection[i].rows;
+                CV_Assert(masks[i].type() == CV_8UC1
+                    && masks[i].rows == queryDescriptorsCount
+                    && masks[i].cols == rows);
+            }
+        }
+    }
+}
+
+void DescriptorMatcher::knnMatch( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, int knn,
+                                  InputArrayOfArrays masks, bool compactResult )
+{
+    CV_INSTRUMENT_REGION();
+
+    if( empty() || queryDescriptors.empty() )
+        return;
+
+    CV_Assert( knn > 0 );
+
+    checkMasks( masks, queryDescriptors.size().height );
+
+    train();
+    knnMatchImpl( queryDescriptors, matches, knn, masks, compactResult );
+}
+
+void DescriptorMatcher::radiusMatch( InputArray queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                                     InputArrayOfArrays masks, bool compactResult )
+{
+    CV_INSTRUMENT_REGION();
+
+    matches.clear();
+    if( empty() || queryDescriptors.empty() )
+        return;
+
+    CV_Assert( maxDistance > std::numeric_limits<float>::epsilon() );
+
+    checkMasks( masks, queryDescriptors.size().height );
+
+    train();
+    radiusMatchImpl( queryDescriptors, matches, maxDistance, masks, compactResult );
+}
+
+void DescriptorMatcher::read( const FileNode& )
+{}
+
+void DescriptorMatcher::write( FileStorage& ) const
+{}
+
+bool DescriptorMatcher::isPossibleMatch( InputArray _mask, int queryIdx, int trainIdx )
+{
+    Mat mask = _mask.getMat();
+    return mask.empty() || mask.at<uchar>(queryIdx, trainIdx);
+}
+
+bool DescriptorMatcher::isMaskedOut( InputArrayOfArrays _masks, int queryIdx )
+{
+    std::vector<Mat> masks;
+    _masks.getMatVector(masks);
+
+    size_t outCount = 0;
+    for( size_t i = 0; i < masks.size(); i++ )
+    {
+        if( !masks[i].empty() && (countNonZero(masks[i].row(queryIdx)) == 0) )
+            outCount++;
+    }
+
+    return !masks.empty() && outCount == masks.size() ;
+}
+
+
+////////////////////////////////////////////////////// BruteForceMatcher /////////////////////////////////////////////////
+
+BFMatcher::BFMatcher( int _normType, bool _crossCheck )
+{
+    normType = _normType;
+    crossCheck = _crossCheck;
+}
+
+Ptr<BFMatcher> BFMatcher::create(int _normType, bool _crossCheck )
+{
+    return makePtr<BFMatcher>(_normType, _crossCheck);
+}
+
+Ptr<DescriptorMatcher> BFMatcher::clone( bool emptyTrainData ) const
+{
+    Ptr<BFMatcher> matcher = makePtr<BFMatcher>(normType, crossCheck);
+    if( !emptyTrainData )
+    {
+        matcher->trainDescCollection.resize(trainDescCollection.size());
+        std::transform( trainDescCollection.begin(), trainDescCollection.end(),
+                        matcher->trainDescCollection.begin(), clone_op );
+    }
+    return matcher;
+}
+
+#ifdef HAVE_OPENCL
+static bool ocl_match(InputArray query, InputArray _train, std::vector< std::vector<DMatch> > &matches, int dstType)
+{
+    UMat trainIdx, distance;
+    if (!ocl_matchSingle(query, _train, trainIdx, &distance, dstType))
+        return false;
+    if (!ocl_matchDownload(trainIdx, distance, matches))
+        return false;
+    return true;
+}
+
+static bool ocl_knnMatch(InputArray query, InputArray _train, std::vector< std::vector<DMatch> > &matches, int k, int dstType, bool compactResult)
+{
+    UMat trainIdx, distance;
+    if (k != 2)
+        return false;
+    if (!ocl_knnMatchSingle(query, _train, trainIdx, distance, dstType))
+        return false;
+    if (!ocl_knnMatchDownload(trainIdx, distance, matches, compactResult) )
+        return false;
+    return true;
+}
+
+static bool ocl_matchWithCrossCheckSinglePass(InputArray query, InputArray train,
+        std::vector< std::vector<DMatch> >& matches, int dstType)
+{
+    if (query.empty() || train.empty())
+        return false;
+
+    const int query_rows = query.rows();
+    const int train_rows = train.rows();
+
+    UMat fwdIdx, fwdDist;
+    ensureSizeIsEnough(1, query_rows, CV_32S, fwdIdx);
+    ensureSizeIsEnough(1, query_rows, CV_32F, fwdDist);
+
+    UMat revBest;
+    ensureSizeIsEnough(1, train_rows, CV_32SC2, revBest);
+    revBest.setTo(Scalar::all(-1));
+
+    ocl::Device devDef = ocl::Device::getDefault();
+
+    UMat uquery = query.getUMat(), utrain = train.getUMat();
+    int kercn = 1;
+    if (devDef.isIntel() &&
+        (0 == (uquery.step % 4)) && (0 == (uquery.cols % 4)) && (0 == (uquery.offset % 4)) &&
+        (0 == (utrain.step % 4)) && (0 == (utrain.cols % 4)) && (0 == (utrain.offset % 4)))
+        kercn = 4;
+
+    int block_size = 16;
+    int max_desc_len = 0;
+    bool is_cpu = devDef.type() == ocl::Device::TYPE_CPU;
+    if (uquery.cols <= 64)
+        max_desc_len = 64 / kercn;
+    else if (uquery.cols <= 128 && !is_cpu)
+        max_desc_len = 128 / kercn;
+
+    int depth = uquery.depth();
+    cv::String opts;
+    opts = cv::format("-D T=%s -D TN=%s -D kercn=%d %s -D DIST_TYPE=%d -D BLOCK_SIZE=%d -D MAX_DESC_LEN=%d -D HAVE_INT64_ATOMICS",
+        ocl::typeToStr(depth), ocl::typeToStr(CV_MAKETYPE(depth, kercn)), kercn, depth == CV_32F ? "-D T_FLOAT" : "", dstType, block_size, max_desc_len);
+    ocl::Kernel k("BruteForceMatch_CrossCheckMatch", ocl::features::brute_force_match_oclsrc, opts);
+    if(k.empty())
+        return false;
+
+    size_t globalSize[] = {((size_t)uquery.size().height + block_size - 1) / block_size * block_size, (size_t)block_size};
+    size_t localSize[] = {(size_t)block_size, (size_t)block_size};
+
+    int idx = 0;
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(uquery));
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(utrain));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(fwdIdx));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(fwdDist));
+    idx = k.set(idx, ocl::KernelArg::PtrWriteOnly(revBest));
+    idx = k.set(idx, uquery.rows);
+    idx = k.set(idx, uquery.cols);
+    idx = k.set(idx, utrain.rows);
+    idx = k.set(idx, utrain.cols);
+    idx = k.set(idx, (int)(uquery.step / sizeof(float)));
+
+    if (!k.run(2, globalSize, localSize, false))
+        return false;
+
+    Mat fwdIdxCPU = fwdIdx.getMat(ACCESS_READ);
+    Mat fwdDistCPU = fwdDist.getMat(ACCESS_READ);
+    Mat revBestCPU = revBest.getMat(ACCESS_READ);
+
+    if (fwdIdxCPU.empty() || fwdDistCPU.empty() || revBestCPU.empty())
+        return false;
+
+    const int* fwd = fwdIdxCPU.ptr<int>();
+    const float* dist = fwdDistCPU.ptr<float>();
+    const int* revBestData = revBestCPU.ptr<int>();
+
+    matches.clear();
+    matches.reserve(query_rows);
+
+    for (int q = 0; q < query_rows; ++q)
+    {
+        int t = fwd[q];
+        if (t >= 0 && t < train_rows)
+        {
+            uint64_t packed_val;
+            memcpy(&packed_val, &revBestData[2 * t], sizeof(uint64_t));
+            int revQueryIdx = (int)(packed_val & 0xFFFFFFFF);
+            if (revQueryIdx == q)
+            {
+                matches.push_back(std::vector<DMatch>(1, DMatch(q, t, 0, dist[q])));
+            }
+        }
+    }
+    return true;
+}
+
+static bool ocl_matchWithCrossCheck(InputArray query, InputArray train,
+        std::vector< std::vector<DMatch> >& matches, int dstType)
+{
+    if (query.empty() || train.empty())
+        return false;
+
+    ocl::Device devDef = ocl::Device::getDefault();
+
+    if (devDef.isExtensionSupported("cl_khr_int64_base_atomics"))
+    {
+        if (ocl_matchWithCrossCheckSinglePass(query, train, matches, dstType))
+            return true;
+    }
+
+    UMat fwdIdx, fwdDist;
+    if (!ocl_matchSingle(query, train, fwdIdx, &fwdDist, dstType))
+        return false;
+
+    UMat revIdx;
+    if (!ocl_matchSingle(train, query, revIdx, nullptr, dstType))
+        return false;
+
+    Mat fwdIdxCPU = fwdIdx.getMat(ACCESS_READ);
+    Mat revIdxCPU = revIdx.getMat(ACCESS_READ);
+    Mat fwdDistCPU = fwdDist.getMat(ACCESS_READ);
+
+    if (fwdIdxCPU.empty() || revIdxCPU.empty() || fwdDistCPU.empty())
+        return false;
+
+    const int nQuery = fwdIdxCPU.cols;
+    const int nTrain = revIdxCPU.cols;
+    const int* fwd  = fwdIdxCPU.ptr<int>();
+    const int* rev  = revIdxCPU.ptr<int>();
+    const float* dist = fwdDistCPU.ptr<float>();
+
+    matches.clear();
+    matches.reserve(nQuery);
+
+    for (int q = 0; q < nQuery; ++q)
+    {
+        int t = fwd[q];
+        if (t >= 0 && t < nTrain && rev[t] == q)
+        {
+            matches.push_back(std::vector<DMatch>(1, DMatch(q, t, 0, dist[q])));
+        }
+    }
+    return true;
+}
+#endif
+
+void BFMatcher::knnMatchImpl( InputArray _queryDescriptors, std::vector<std::vector<DMatch> >& matches, int knn,
+                             InputArrayOfArrays _masks, bool compactResult )
+{
+    int trainDescType = trainDescCollection.empty() ? utrainDescCollection[0].type() : trainDescCollection[0].type();
+    CV_Assert( _queryDescriptors.type() == trainDescType );
+
+    const int IMGIDX_SHIFT = 18;
+    const int IMGIDX_ONE = (1 << IMGIDX_SHIFT);
+
+    if( _queryDescriptors.empty() || (trainDescCollection.empty() && utrainDescCollection.empty()))
+    {
+        matches.clear();
+        return;
+    }
+
+    std::vector<Mat> masks;
+    _masks.getMatVector(masks);
+
+    if(!trainDescCollection.empty() && !utrainDescCollection.empty())
+    {
+        for(int i = 0; i < (int)utrainDescCollection.size(); i++)
+        {
+            Mat tempMat;
+            utrainDescCollection[i].copyTo(tempMat);
+            trainDescCollection.push_back(tempMat);
+        }
+        utrainDescCollection.clear();
+    }
+
+#ifdef HAVE_OPENCL
+    int trainDescVectorSize = trainDescCollection.empty() ? (int)utrainDescCollection.size() : (int)trainDescCollection.size();
+    Size trainDescSize = trainDescCollection.empty() ? utrainDescCollection[0].size() : trainDescCollection[0].size();
+    int trainDescOffset = trainDescCollection.empty() ? (int)utrainDescCollection[0].offset : 0;
+
+    if ( ocl::isOpenCLActivated() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
+        _queryDescriptors.type() == CV_32FC1 && _queryDescriptors.offset() == 0 && trainDescOffset == 0 &&
+        trainDescSize.width == _queryDescriptors.size().width && masks.size() == 1 && masks[0].total() == 0 )
+    {
+        if(knn == 1)
+        {
+            InputArray train = trainDescCollection.empty() ?
+                (InputArray)utrainDescCollection[0] : (InputArray)trainDescCollection[0];
+            bool oclOk = crossCheck ?
+                ocl_matchWithCrossCheck(_queryDescriptors, train, matches, normType) :
+                ocl_match(_queryDescriptors, train, matches, normType);
+            if (oclOk)
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return;
+            }
+        }
+        else
+        {
+            if(trainDescCollection.empty())
+            {
+                if(ocl_knnMatch(_queryDescriptors, utrainDescCollection[0], matches, knn, normType, compactResult) )
+                {
+                    CV_IMPL_ADD(CV_IMPL_OCL);
+                    return;
+                }
+            }
+            else
+            {
+                if(ocl_knnMatch(_queryDescriptors, trainDescCollection[0], matches, knn, normType, compactResult) )
+                {
+                    CV_IMPL_ADD(CV_IMPL_OCL);
+                    return;
+                }
+            }
+        }
+    }
+#endif
+
+    Mat queryDescriptors = _queryDescriptors.getMat();
+    if(trainDescCollection.empty() && !utrainDescCollection.empty())
+    {
+        for(int i = 0; i < (int)utrainDescCollection.size(); i++)
+        {
+            Mat tempMat;
+            utrainDescCollection[i].copyTo(tempMat);
+            trainDescCollection.push_back(tempMat);
+        }
+        utrainDescCollection.clear();
+    }
+
+    matches.reserve(queryDescriptors.rows);
+
+    Mat dist, nidx;
+
+    int iIdx, imgCount = (int)trainDescCollection.size(), update = 0;
+    int dtype = normType == NORM_HAMMING || normType == NORM_HAMMING2 ||
+        (normType == NORM_L1 && queryDescriptors.type() == CV_8U) ? CV_32S : CV_32F;
+
+    CV_Assert( (int64)imgCount*IMGIDX_ONE < INT_MAX );
+
+    for( iIdx = 0; iIdx < imgCount; iIdx++ )
+    {
+        CV_Assert( trainDescCollection[iIdx].rows < IMGIDX_ONE );
+        batchDistance(queryDescriptors, trainDescCollection[iIdx], dist, dtype, nidx,
+                      normType, knn, masks.empty() ? Mat() : masks[iIdx], update, crossCheck);
+        update += IMGIDX_ONE;
+    }
+
+    if( dtype == CV_32S )
+    {
+        Mat temp;
+        dist.convertTo(temp, CV_32F);
+        dist = temp;
+    }
+
+    for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
+    {
+        const float* distptr = dist.ptr<float>(qIdx);
+        const int* nidxptr = nidx.ptr<int>(qIdx);
+
+        matches.push_back( std::vector<DMatch>() );
+        std::vector<DMatch>& mq = matches.back();
+        mq.reserve(knn);
+
+        for( int k = 0; k < nidx.cols; k++ )
+        {
+            if( nidxptr[k] < 0 )
+                break;
+            mq.push_back( DMatch(qIdx, nidxptr[k] & (IMGIDX_ONE - 1),
+                          nidxptr[k] >> IMGIDX_SHIFT, distptr[k]) );
+        }
+
+        if( mq.empty() && compactResult )
+            matches.pop_back();
+    }
+}
+
+#ifdef HAVE_OPENCL
+static bool ocl_radiusMatch(InputArray query, InputArray _train, std::vector< std::vector<DMatch> > &matches,
+        float maxDistance, int dstType, bool compactResult)
+{
+    UMat trainIdx, distance, nMatches;
+    if (!ocl_radiusMatchSingle(query, _train, trainIdx, distance, nMatches, maxDistance, dstType))
+        return false;
+    if (!ocl_radiusMatchDownload(trainIdx, distance, nMatches, matches, compactResult))
+        return false;
+    return true;
+}
+#endif
+
+void BFMatcher::radiusMatchImpl( InputArray _queryDescriptors, std::vector<std::vector<DMatch> >& matches,
+                                float maxDistance, InputArrayOfArrays _masks, bool compactResult )
+{
+    int trainDescType = trainDescCollection.empty() ? utrainDescCollection[0].type() : trainDescCollection[0].type();
+    CV_Assert( _queryDescriptors.type() == trainDescType );
+
+    if( _queryDescriptors.empty() || (trainDescCollection.empty() && utrainDescCollection.empty()))
+    {
+        matches.clear();
+        return;
+    }
+
+    std::vector<Mat> masks;
+    _masks.getMatVector(masks);
+
+    if(!trainDescCollection.empty() && !utrainDescCollection.empty())
+    {
+        for(int i = 0; i < (int)utrainDescCollection.size(); i++)
+        {
+            Mat tempMat;
+            utrainDescCollection[i].copyTo(tempMat);
+            trainDescCollection.push_back(tempMat);
+        }
+        utrainDescCollection.clear();
+    }
+
+#ifdef HAVE_OPENCL
+    int trainDescVectorSize = trainDescCollection.empty() ? (int)utrainDescCollection.size() : (int)trainDescCollection.size();
+    Size trainDescSize = trainDescCollection.empty() ? utrainDescCollection[0].size() : trainDescCollection[0].size();
+    int trainDescOffset = trainDescCollection.empty() ? (int)utrainDescCollection[0].offset : 0;
+
+    if ( ocl::isOpenCLActivated() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
+        _queryDescriptors.type() == CV_32FC1 && _queryDescriptors.offset() == 0 && trainDescOffset == 0 &&
+        trainDescSize.width == _queryDescriptors.size().width && masks.size() == 1 && masks[0].total() == 0 )
+    {
+        if (trainDescCollection.empty())
+        {
+            if(ocl_radiusMatch(_queryDescriptors, utrainDescCollection[0], matches, maxDistance, normType, compactResult) )
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return;
+            }
+        }
+        else
+        {
+            if (ocl_radiusMatch(_queryDescriptors, trainDescCollection[0], matches, maxDistance, normType, compactResult) )
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return;
+            }
+        }
+    }
+#endif
+
+    Mat queryDescriptors = _queryDescriptors.getMat();
+    if(trainDescCollection.empty() && !utrainDescCollection.empty())
+    {
+        for(int i = 0; i < (int)utrainDescCollection.size(); i++)
+        {
+            Mat tempMat;
+            utrainDescCollection[i].copyTo(tempMat);
+            trainDescCollection.push_back(tempMat);
+        }
+        utrainDescCollection.clear();
+    }
+
+    matches.resize(queryDescriptors.rows);
+    Mat dist, distf;
+
+    int iIdx, imgCount = (int)trainDescCollection.size();
+    int dtype = normType == NORM_HAMMING || normType == NORM_HAMMING2 ||
+        (normType == NORM_L1 && queryDescriptors.type() == CV_8U) ? CV_32S : CV_32F;
+
+    for( iIdx = 0; iIdx < imgCount; iIdx++ )
+    {
+        batchDistance(queryDescriptors, trainDescCollection[iIdx], dist, dtype, noArray(),
+                      normType, 0, masks.empty() ? Mat() : masks[iIdx], 0, false);
+        if( dtype == CV_32S )
+            dist.convertTo(distf, CV_32F);
+        else
+            distf = dist;
+
+        for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
+        {
+            const float* distptr = distf.ptr<float>(qIdx);
+
+            std::vector<DMatch>& mq = matches[qIdx];
+            for( int k = 0; k < distf.cols; k++ )
+            {
+                if( distptr[k] <= maxDistance )
+                    mq.push_back( DMatch(qIdx, k, iIdx, distptr[k]) );
+            }
+        }
+    }
+
+    int qIdx0 = 0;
+    for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
+    {
+        if( matches[qIdx].empty() && compactResult )
+            continue;
+
+        if( qIdx0 < qIdx )
+            std::swap(matches[qIdx], matches[qIdx0]);
+
+        std::sort( matches[qIdx0].begin(), matches[qIdx0].end() );
+        qIdx0++;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ * Factory function for DescriptorMatcher creating
+ */
+Ptr<DescriptorMatcher> DescriptorMatcher::create( const String& descriptorMatcherType )
+{
+    Ptr<DescriptorMatcher> dm;
+#ifdef HAVE_OPENCV_FLANN
+    if( !descriptorMatcherType.compare( "FlannBased" ) )
+    {
+        dm = makePtr<FlannBasedMatcher>();
+    }
+    else
+#endif
+    if( !descriptorMatcherType.compare( "BruteForce" ) ) // L2
+    {
+        dm = makePtr<BFMatcher>(int(NORM_L2)); // anonymous enums can't be template parameters
+    }
+    else if( !descriptorMatcherType.compare( "BruteForce-SL2" ) ) // Squared L2
+    {
+        dm = makePtr<BFMatcher>(int(NORM_L2SQR));
+    }
+    else if( !descriptorMatcherType.compare( "BruteForce-L1" ) )
+    {
+        dm = makePtr<BFMatcher>(int(NORM_L1));
+    }
+    else if( !descriptorMatcherType.compare("BruteForce-Hamming") ||
+             !descriptorMatcherType.compare("BruteForce-HammingLUT") )
+    {
+        dm = makePtr<BFMatcher>(int(NORM_HAMMING));
+    }
+    else if( !descriptorMatcherType.compare("BruteForce-Hamming(2)") )
+    {
+        dm = makePtr<BFMatcher>(int(NORM_HAMMING2));
+    }
+    else
+        CV_Error( Error::StsBadArg, "Unknown matcher name" );
+
+    return dm;
+}
+
+Ptr<DescriptorMatcher> DescriptorMatcher::create( const MatcherType& matcherType )
+{
+
+
+    String name;
+
+    switch(matcherType)
+    {
+#ifdef HAVE_OPENCV_FLANN
+    case FLANNBASED:
+        name = "FlannBased";
+        break;
+#endif
+    case BRUTEFORCE:
+        name = "BruteForce";
+        break;
+    case BRUTEFORCE_L1:
+        name = "BruteForce-L1";
+        break;
+    case BRUTEFORCE_HAMMING:
+        name = "BruteForce-Hamming";
+        break;
+    case BRUTEFORCE_HAMMINGLUT:
+        name = "BruteForce-HammingLUT";
+        break;
+    case BRUTEFORCE_SL2:
+        name = "BruteForce-SL2";
+        break;
+    default:
+        CV_Error( Error::StsBadArg, "Specified descriptor matcher type is not supported." );
+        break;
+    }
+
+    return DescriptorMatcher::create(name);
+
+}
+
+#ifdef HAVE_OPENCV_FLANN
+
+/*
+ * Flann based matcher
+ */
+FlannBasedMatcher::FlannBasedMatcher( const Ptr<flann::IndexParams>& _indexParams, const Ptr<flann::SearchParams>& _searchParams )
+    : indexParams(_indexParams), searchParams(_searchParams), addedDescCount(0)
+{
+    CV_Assert( _indexParams );
+    CV_Assert( _searchParams );
+}
+
+Ptr<FlannBasedMatcher> FlannBasedMatcher::create()
+{
+    return makePtr<FlannBasedMatcher>();
+}
+
+void FlannBasedMatcher::add( InputArrayOfArrays _descriptors )
+{
+    DescriptorMatcher::add( _descriptors );
+
+    if( _descriptors.isUMatVector() )
+    {
+        std::vector<UMat> descriptors;
+        _descriptors.getUMatVector( descriptors );
+
+        for( size_t i = 0; i < descriptors.size(); i++ )
+        {
+            addedDescCount += descriptors[i].rows;
+        }
+    }
+    else if( _descriptors.isUMat() )
+    {
+        addedDescCount += _descriptors.getUMat().rows;
+    }
+    else if( _descriptors.isMatVector() )
+    {
+        std::vector<Mat> descriptors;
+        _descriptors.getMatVector(descriptors);
+        for( size_t i = 0; i < descriptors.size(); i++ )
+        {
+            addedDescCount += descriptors[i].rows;
+        }
+    }
+    else if( _descriptors.isMat() )
+    {
+        addedDescCount += _descriptors.getMat().rows;
+    }
+    else
+    {
+        CV_Assert( _descriptors.isUMat() || _descriptors.isUMatVector() || _descriptors.isMat() || _descriptors.isMatVector() );
+    }
+}
+
+void FlannBasedMatcher::clear()
+{
+    DescriptorMatcher::clear();
+
+    mergedDescriptors.clear();
+    flannIndex.release();
+
+    addedDescCount = 0;
+}
+
+void FlannBasedMatcher::train()
+{
+    CV_INSTRUMENT_REGION();
+
+    if( !flannIndex || mergedDescriptors.size() < addedDescCount )
+    {
+        // FIXIT: Workaround for 'utrainDescCollection' issue (PR #2142)
+        if (!utrainDescCollection.empty())
+        {
+            CV_Assert(trainDescCollection.size() == 0);
+            for (size_t i = 0; i < utrainDescCollection.size(); ++i)
+                trainDescCollection.push_back(utrainDescCollection[i].getMat(ACCESS_READ));
+        }
+        mergedDescriptors.set( trainDescCollection );
+        flannIndex = makePtr<flann::Index>( mergedDescriptors.getDescriptors(), *indexParams );
+    }
+}
+
+using namespace cv::flann;
+
+void FlannBasedMatcher::read( const FileNode& fn)
+{
+     if (!indexParams)
+         indexParams = makePtr<flann::IndexParams>();
+
+     FileNode ip = fn["indexParams"];
+     CV_Assert(ip.type() == FileNode::SEQ);
+
+     for(int i = 0; i < (int)ip.size(); ++i)
+     {
+        CV_Assert(ip[i].type() == FileNode::MAP);
+        String _name =  (String)ip[i]["name"];
+        FlannIndexType type = (FlannIndexType)(int)ip[i]["type"];
+        CV_CheckLE((int)type, (int)LAST_VALUE_FLANN_INDEX_TYPE, "");
+
+        switch(type)
+        {
+        case FLANN_INDEX_TYPE_8U:
+        case FLANN_INDEX_TYPE_8S:
+        case FLANN_INDEX_TYPE_16U:
+        case FLANN_INDEX_TYPE_16S:
+        case FLANN_INDEX_TYPE_32S:
+            indexParams->setInt(_name, (int) ip[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_32F:
+            indexParams->setFloat(_name, (float) ip[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_64F:
+            indexParams->setDouble(_name, (double) ip[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_STRING:
+            indexParams->setString(_name, (String) ip[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_BOOL:
+            indexParams->setBool(_name, (int) ip[i]["value"] != 0);
+            break;
+        case FLANN_INDEX_TYPE_ALGORITHM:
+            indexParams->setAlgorithm((int) ip[i]["value"]);
+            break;
+        // don't default: - compiler warning is here
+        };
+     }
+
+     if (!searchParams)
+         searchParams = makePtr<flann::SearchParams>();
+
+     FileNode sp = fn["searchParams"];
+     CV_Assert(sp.type() == FileNode::SEQ);
+
+     for(int i = 0; i < (int)sp.size(); ++i)
+     {
+        CV_Assert(sp[i].type() == FileNode::MAP);
+        String _name =  (String)sp[i]["name"];
+        FlannIndexType type = (FlannIndexType)(int)sp[i]["type"];
+        CV_CheckLE((int)type, (int)LAST_VALUE_FLANN_INDEX_TYPE, "");
+
+        switch(type)
+        {
+        case FLANN_INDEX_TYPE_8U:
+        case FLANN_INDEX_TYPE_8S:
+        case FLANN_INDEX_TYPE_16U:
+        case FLANN_INDEX_TYPE_16S:
+        case FLANN_INDEX_TYPE_32S:
+            searchParams->setInt(_name, (int) sp[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_32F:
+            searchParams->setFloat(_name, (float) sp[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_64F:
+            searchParams->setDouble(_name, (double) sp[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_STRING:
+            searchParams->setString(_name, (String) sp[i]["value"]);
+            break;
+        case FLANN_INDEX_TYPE_BOOL:
+            searchParams->setBool(_name, (int) sp[i]["value"] != 0);
+            break;
+        case FLANN_INDEX_TYPE_ALGORITHM:
+            searchParams->setAlgorithm((int) sp[i]["value"]);
+            break;
+        // don't default: - compiler warning is here
+        };
+     }
+
+    flannIndex.release();
+}
+
+void FlannBasedMatcher::write( FileStorage& fs) const
+{
+     writeFormat(fs);
+     fs << "indexParams" << "[";
+
+     if (indexParams)
+     {
+         std::vector<String> names;
+         std::vector<FlannIndexType> types;
+         std::vector<String> strValues;
+         std::vector<double> numValues;
+
+         indexParams->getAll(names, types, strValues, numValues);
+
+         for(size_t i = 0; i < names.size(); ++i)
+         {
+             fs << "{" << "name" << names[i] << "type" << types[i] << "value";
+             FlannIndexType type = (FlannIndexType)types[i];
+             if ((int)type < 0 || type > LAST_VALUE_FLANN_INDEX_TYPE)
+             {
+                 fs << (double)numValues[i];
+                 fs << "typename" << strValues[i];
+                 fs << "}";
+                 continue;
+             }
+             switch(type)
+             {
+             case FLANN_INDEX_TYPE_8U:
+                 fs << (uchar)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_8S:
+                 fs << (char)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_16U:
+                 fs << (ushort)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_16S:
+                 fs << (short)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_32S:
+             case FLANN_INDEX_TYPE_BOOL:
+             case FLANN_INDEX_TYPE_ALGORITHM:
+                 fs << (int)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_32F:
+                 fs << (float)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_64F:
+                 fs << (double)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_STRING:
+                 fs << strValues[i];
+                 break;
+             // don't default: - compiler warning is here
+             }
+             fs << "}";
+         }
+     }
+
+     fs << "]" << "searchParams" << "[";
+
+     if (searchParams)
+     {
+         std::vector<String> names;
+         std::vector<FlannIndexType> types;
+         std::vector<String> strValues;
+         std::vector<double> numValues;
+
+         searchParams->getAll(names, types, strValues, numValues);
+
+         for(size_t i = 0; i < names.size(); ++i)
+         {
+             fs << "{" << "name" << names[i] << "type" << types[i] << "value";
+             FlannIndexType type = (FlannIndexType)types[i];
+             if ((int)type < 0 || type > LAST_VALUE_FLANN_INDEX_TYPE)
+             {
+                 fs << (double)numValues[i];
+                 fs << "typename" << strValues[i];
+                 fs << "}";
+                 continue;
+             }
+             switch(type)
+             {
+             case FLANN_INDEX_TYPE_8U:
+                 fs << (uchar)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_8S:
+                 fs << (char)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_16U:
+                 fs << (ushort)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_16S:
+                 fs << (short)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_32S:
+             case FLANN_INDEX_TYPE_BOOL:
+             case FLANN_INDEX_TYPE_ALGORITHM:
+                 fs << (int)numValues[i];
+                 break;
+             case CV_32F:
+                 fs << (float)numValues[i];
+                 break;
+             case CV_64F:
+                 fs << (double)numValues[i];
+                 break;
+             case FLANN_INDEX_TYPE_STRING:
+                 fs << strValues[i];
+                 break;
+             // don't default: - compiler warning is here
+             }
+             fs << "}";
+         }
+     }
+     fs << "]";
+}
+
+bool FlannBasedMatcher::isMaskSupported() const
+{
+    return false;
+}
+
+Ptr<DescriptorMatcher> FlannBasedMatcher::clone( bool emptyTrainData ) const
+{
+    Ptr<FlannBasedMatcher> matcher = makePtr<FlannBasedMatcher>(indexParams, searchParams);
+    if( !emptyTrainData )
+    {
+        CV_Error( Error::StsNotImplemented, "deep clone functionality is not implemented, because "
+                  "Flann::Index has not copy constructor or clone method ");
+#if 0
+        //matcher->flannIndex;
+        matcher->addedDescCount = addedDescCount;
+        matcher->mergedDescriptors = DescriptorCollection( mergedDescriptors );
+        std::transform( trainDescCollection.begin(), trainDescCollection.end(),
+                        matcher->trainDescCollection.begin(), clone_op );
+#endif
+    }
+    return matcher;
+}
+
+void FlannBasedMatcher::convertToDMatches( const DescriptorCollection& collection, const Mat& indices, const Mat& dists,
+                                           std::vector<std::vector<DMatch> >& matches )
+{
+    matches.resize( indices.rows );
+    for( int i = 0; i < indices.rows; i++ )
+    {
+        for( int j = 0; j < indices.cols; j++ )
+        {
+            int idx = indices.at<int>(i, j);
+            if( idx >= 0 )
+            {
+                int imgIdx, trainIdx;
+                collection.getLocalIdx( idx, imgIdx, trainIdx );
+                float dist = 0;
+                if (dists.type() == CV_32S)
+                    dist = static_cast<float>( dists.at<int>(i,j) );
+                else
+                    dist = std::sqrt(dists.at<float>(i,j));
+                matches[i].push_back( DMatch( i, trainIdx, imgIdx, dist ) );
+            }
+        }
+    }
+}
+
+void FlannBasedMatcher::knnMatchImpl( InputArray _queryDescriptors, std::vector<std::vector<DMatch> >& matches, int knn,
+                                     InputArrayOfArrays /*masks*/, bool /*compactResult*/ )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat queryDescriptors = _queryDescriptors.getMat();
+    Mat indices( queryDescriptors.rows, knn, CV_32SC1 );
+    Mat dists( queryDescriptors.rows, knn, CV_32FC1);
+    flannIndex->knnSearch( queryDescriptors, indices, dists, knn, *searchParams );
+
+    convertToDMatches( mergedDescriptors, indices, dists, matches );
+}
+
+void FlannBasedMatcher::radiusMatchImpl( InputArray _queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                                         InputArrayOfArrays /*masks*/, bool /*compactResult*/ )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat queryDescriptors = _queryDescriptors.getMat();
+    const int count = mergedDescriptors.size(); // TODO do count as param?
+    Mat indices( queryDescriptors.rows, count, CV_32SC1, Scalar::all(-1) );
+    Mat dists( queryDescriptors.rows, count, CV_32FC1, Scalar::all(-1) );
+    for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
+    {
+        Mat queryDescriptorsRow = queryDescriptors.row(qIdx);
+        Mat indicesRow = indices.row(qIdx);
+        Mat distsRow = dists.row(qIdx);
+        flannIndex->radiusSearch( queryDescriptorsRow, indicesRow, distsRow, maxDistance*maxDistance, count, *searchParams );
+    }
+
+    convertToDMatches( mergedDescriptors, indices, dists, matches );
+}
+
+#endif
+
+}
diff --git a/upstream/opencv/modules/features/src/matchers_lightglue.cpp b/upstream/opencv/modules/features/src/matchers_lightglue.cpp
new file mode 100644
index 0000000..798c673
--- /dev/null
+++ b/upstream/opencv/modules/features/src/matchers_lightglue.cpp
@@ -0,0 +1,282 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#include "aliked_context.hpp"
+#endif
+
+namespace cv
+{
+
+LightGlueMatcher::LightGlueMatcher() {}
+LightGlueMatcher::~LightGlueMatcher() {}
+
+#ifdef HAVE_OPENCV_DNN
+
+struct LightGluePairContext
+{
+    Mat queryKeypoints;   // Nx2 float (normalized [-1,1] or pixel)
+    Mat trainKeypoints;   // Mx2 float
+    Size queryImageSize;
+    Size trainImageSize;
+    bool valid;
+
+    LightGluePairContext() : valid(false) {}
+
+    void clear()
+    {
+        queryKeypoints.release();
+        trainKeypoints.release();
+        queryImageSize = Size();
+        trainImageSize = Size();
+        valid = false;
+    }
+};
+
+class LightGlueMatcherImpl : public LightGlueMatcher
+{
+public:
+    LightGlueMatcherImpl(const String& modelPath, float _scoreThreshold, int backend, int target)
+    {
+        scoreThreshold = _scoreThreshold;
+        net = dnn::readNet(modelPath, "", "");
+        CV_Assert(!net.empty());
+        net.setPreferableBackend(backend);
+        net.setPreferableTarget(target);
+    }
+
+    LightGlueMatcherImpl(const std::vector<uchar>& modelData, float _scoreThreshold, int backend, int target)
+    {
+        scoreThreshold = _scoreThreshold;
+        net = dnn::readNetFromONNX(modelData);
+        CV_Assert(!net.empty());
+        net.setPreferableBackend(backend);
+        net.setPreferableTarget(target);
+    }
+
+    // Private constructor for clone() — shares the already-loaded network
+    LightGlueMatcherImpl(const dnn::Net& _net, float _scoreThreshold)
+        : net(_net), scoreThreshold(_scoreThreshold) {};
+
+    // DescriptorMatcher interface
+    bool isMaskSupported() const CV_OVERRIDE { return false; }
+    Ptr<DescriptorMatcher> clone(bool emptyTrainData) const CV_OVERRIDE;
+
+    // LightGlueMatcher interface
+    void setPairInfo(InputArray queryKpts, InputArray trainKpts,
+                     Size queryImageSize = Size(), Size trainImageSize = Size()) CV_OVERRIDE;
+    void clearPairInfo() CV_OVERRIDE;
+
+protected:
+    void knnMatchImpl(InputArray queryDescriptors,
+                      std::vector<std::vector<DMatch>>& matches, int k,
+                      InputArrayOfArrays masks = noArray(),
+                      bool compactResult = false) CV_OVERRIDE;
+    void radiusMatchImpl(InputArray queryDescriptors,
+                         std::vector<std::vector<DMatch>>& matches, float maxDistance,
+                         InputArrayOfArrays masks = noArray(),
+                         bool compactResult = false) CV_OVERRIDE;
+
+    void lightglueMatch(const Mat& queryDesc, const Mat& trainDesc,
+                        const Mat& queryKpts, const Mat& trainKpts,
+                        Size queryImgSize, Size trainImgSize,
+                        std::vector<DMatch>& matches);
+
+    bool resolveContext(Mat& queryKpts, Mat& trainKpts,
+                        Size& queryImgSize, Size& trainImgSize);
+
+    dnn::Net net;
+    float scoreThreshold;
+    LightGluePairContext pairContext;
+};
+
+Ptr<DescriptorMatcher> LightGlueMatcherImpl::clone(bool emptyTrainData) const
+{
+    Ptr<LightGlueMatcherImpl> m = makePtr<LightGlueMatcherImpl>(net, scoreThreshold);
+    // Always copy pairContext - it's matcher state, not train data
+    m->pairContext = pairContext;
+    if (!emptyTrainData)
+    {
+        m->trainDescCollection = trainDescCollection;
+        m->utrainDescCollection = utrainDescCollection;
+    }
+    return m;
+}
+
+void LightGlueMatcherImpl::setPairInfo(InputArray _queryKpts, InputArray _trainKpts,
+                                        Size _queryImageSize, Size _trainImageSize)
+{
+    pairContext.queryKeypoints = _queryKpts.getMat().clone();
+    pairContext.trainKeypoints = _trainKpts.getMat().clone();
+    pairContext.queryImageSize = _queryImageSize;
+    pairContext.trainImageSize = _trainImageSize;
+    pairContext.valid = true;
+}
+
+void LightGlueMatcherImpl::clearPairInfo()
+{
+    pairContext.clear();
+}
+
+bool LightGlueMatcherImpl::resolveContext(Mat& queryKpts, Mat& trainKpts,
+                                           Size& queryImgSize, Size& trainImgSize)
+{
+    if (pairContext.valid)
+    {
+        queryKpts = pairContext.queryKeypoints;
+        trainKpts = pairContext.trainKeypoints;
+        queryImgSize = pairContext.queryImageSize;
+        trainImgSize = pairContext.trainImageSize;
+        return true;
+    }
+    return false;
+}
+
+void LightGlueMatcherImpl::lightglueMatch(const Mat& queryDesc, const Mat& trainDesc,
+                                            const Mat& queryKpts, const Mat& trainKpts,
+                                            Size queryImgSize, Size trainImgSize,
+                                            std::vector<DMatch>& matches)
+{
+    int N = queryDesc.rows;
+    int M = trainDesc.rows;
+
+    // Normalize keypoints to [-1, 1] if in pixel coordinates
+    Mat kpts0 = queryKpts.clone();
+    Mat kpts1 = trainKpts.clone();
+
+    if (queryImgSize.width > 0 && queryImgSize.height > 0)
+    {
+        for (int i = 0; i < kpts0.rows; i++)
+        {
+            kpts0.at<float>(i, 0) = kpts0.at<float>(i, 0) / (float)queryImgSize.width * 2.0f - 1.0f;
+            kpts0.at<float>(i, 1) = kpts0.at<float>(i, 1) / (float)queryImgSize.height * 2.0f - 1.0f;
+        }
+    }
+    if (trainImgSize.width > 0 && trainImgSize.height > 0)
+    {
+        for (int i = 0; i < kpts1.rows; i++)
+        {
+            kpts1.at<float>(i, 0) = kpts1.at<float>(i, 0) / (float)trainImgSize.width * 2.0f - 1.0f;
+            kpts1.at<float>(i, 1) = kpts1.at<float>(i, 1) / (float)trainImgSize.height * 2.0f - 1.0f;
+        }
+    }
+
+    // Prepare blobs: [1, N, 2] and [1, N, D]
+    int descDim = queryDesc.cols;
+    int szK0[] = {1, N, 2};
+    int szK1[] = {1, M, 2};
+    int szD0[] = {1, N, descDim};
+    int szD1[] = {1, M, descDim};
+    Mat kpts0blob = kpts0.reshape(0, 3, szK0);
+    Mat kpts1blob = kpts1.reshape(0, 3, szK1);
+    Mat desc0blob = queryDesc.reshape(0, 3, szD0);
+    Mat desc1blob = trainDesc.reshape(0, 3, szD1);
+
+    net.setInput(kpts0blob, "kpts0");
+    net.setInput(kpts1blob, "kpts1");
+    net.setInput(desc0blob, "desc0");
+    net.setInput(desc1blob, "desc1");
+
+    std::vector<String> outNames = {"matches0", "mscores0"};
+    std::vector<Mat> outs;
+    net.forward(outs, outNames);
+
+    CV_Assert(outs.size() == 2);
+
+    // matches0: [M, 2] int64 - pair indices (kpt0_idx, kpt1_idx)
+    // mscores0: [M] float32 - confidence per pair
+    Mat matchesMat = outs[0];
+    Mat scoresMat = outs[1];
+
+    matches.clear();
+    int nMatches = matchesMat.rows;
+    matches.reserve(nMatches);
+
+    for (int i = 0; i < nMatches; i++)
+    {
+        int qIdx = (int)matchesMat.at<int64_t>(i, 0);
+        int tIdx = (int)matchesMat.at<int64_t>(i, 1);
+        if (qIdx >= 0 && tIdx >= 0 && qIdx < N && tIdx < M)
+        {
+            float score = scoresMat.at<float>(i);
+            if (score >= scoreThreshold)
+            {
+                matches.push_back(DMatch(qIdx, tIdx, 1.0f - score));
+            }
+        }
+    }
+}
+
+void LightGlueMatcherImpl::knnMatchImpl(InputArray _queryDescriptors,
+                                          std::vector<std::vector<DMatch>>& matches,
+                                          int k, InputArrayOfArrays, bool)
+{
+    CV_INSTRUMENT_REGION();
+
+    if (k != 1)
+        CV_Error(cv::Error::StsBadArg, "LightGlueMatcher only supports k=1");
+
+    Mat queryKpts, trainKpts;
+    Size queryImgSize, trainImgSize;
+    if (!resolveContext(queryKpts, trainKpts, queryImgSize, trainImgSize))
+    {
+        CV_Error(cv::Error::StsBadArg,
+                 "LightGlueMatcher: no valid context. Call setPairInfo() before matching.");
+    }
+
+    CV_Assert(!trainDescCollection.empty());
+    const Mat& trainDesc = trainDescCollection[0];
+    Mat queryDesc = _queryDescriptors.getMat();
+
+    std::vector<DMatch> flatMatches;
+    lightglueMatch(queryDesc, trainDesc, queryKpts, trainKpts,
+                   queryImgSize, trainImgSize, flatMatches);
+
+    matches.clear();
+    matches.resize(queryDesc.rows);
+    for (const auto& m : flatMatches)
+    {
+        matches[m.queryIdx].push_back(m);
+    }
+
+    clearPairInfo();
+}
+
+void LightGlueMatcherImpl::radiusMatchImpl(InputArray, std::vector<std::vector<DMatch>>&,
+                                             float, InputArrayOfArrays, bool)
+{
+    CV_Error(cv::Error::StsNotImplemented,
+             "radiusMatch is not supported by LightGlueMatcher. Use match() or knnMatch().");
+}
+
+Ptr<LightGlueMatcher> LightGlueMatcher::create(const String& modelPath, float scoreThreshold, int backend, int target)
+{
+    return makePtr<LightGlueMatcherImpl>(modelPath, scoreThreshold, backend, target);
+}
+
+Ptr<LightGlueMatcher> LightGlueMatcher::create(const std::vector<uchar>& modelData,
+                                               float scoreThreshold, int backend, int target)
+{
+    return makePtr<LightGlueMatcherImpl>(modelData, scoreThreshold, backend, target);
+}
+
+#else  // !HAVE_OPENCV_DNN
+
+Ptr<LightGlueMatcher> LightGlueMatcher::create(const String& modelPath,
+                                                 float scoreThreshold, int backend, int target)
+{
+    CV_UNUSED(modelPath);
+    CV_UNUSED(scoreThreshold);
+    CV_UNUSED(backend);
+    CV_UNUSED(target);
+    CV_Error(cv::Error::StsNotImplemented,
+             "LightGlueMatcher requires OpenCV built with opencv_dnn module!");
+}
+
+#endif  // HAVE_OPENCV_DNN
+
+}  // namespace cv
diff --git a/upstream/opencv/modules/features/src/mser.cpp b/upstream/opencv/modules/features/src/mser.cpp
new file mode 100644
index 0000000..9350f3d
--- /dev/null
+++ b/upstream/opencv/modules/features/src/mser.cpp
@@ -0,0 +1,1074 @@
+/* Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *     Redistributions of source code must retain the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer.
+ *     Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials
+ *     provided with the distribution.
+ *     The name of Contributor may not be used to endorse or
+ *     promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ * Copyright (C) 2009, Liu Liu All rights reserved.
+ *
+ * OpenCV functions for MSER extraction
+ *
+ * 1. there are two different implementation of MSER, one for gray image, one for color image
+ * 2. the gray image algorithm is taken from:
+ *      Linear Time Maximally Stable Extremal Regions;
+ *    the paper claims to be faster than union-find method;
+ *    it actually get 1.5~2m/s on my centrino L7200 1.2GHz laptop.
+ * 3. the color image algorithm is taken from:
+ *      Maximally Stable Colour Regions for Recognition and Match;
+ *    it should be much slower than gray image method ( 3~4 times );
+ *    the chi_table.h file is taken directly from the paper's source code:
+ *    http://users.isy.liu.se/cvl/perfo/software/chi_table.h
+ *    license (BSD-like) is located in the file: 3rdparty/mscr/chi_table_LICENSE.txt
+ * 4. though the name is *contours*, the result actually is a list of point set.
+ */
+
+#include "precomp.hpp"
+#include <limits>
+#include "../3rdparty/mscr/chi_table.h"
+
+namespace cv
+{
+
+using std::vector;
+
+class MSER_Impl CV_FINAL : public MSER
+{
+public:
+    struct Params
+    {
+        Params( int _delta=5, int _min_area=60, int _max_area=14400,
+                   double _max_variation=0.25, double _min_diversity=.2,
+                   int _max_evolution=200, double _area_threshold=1.01,
+                   double _min_margin=0.003, int _edge_blur_size=5 )
+        {
+            delta = _delta;
+            minArea = _min_area;
+            maxArea = _max_area;
+            maxVariation = _max_variation;
+            minDiversity = _min_diversity;
+            maxEvolution = _max_evolution;
+            areaThreshold = _area_threshold;
+            minMargin = _min_margin;
+            edgeBlurSize = _edge_blur_size;
+            pass2Only = false;
+        }
+
+        int delta;
+        int minArea;
+        int maxArea;
+        double maxVariation;
+        double minDiversity;
+        bool pass2Only;
+
+        int maxEvolution;
+        double areaThreshold;
+        double minMargin;
+        int edgeBlurSize;
+    };
+
+    explicit MSER_Impl(const Params& _params) : params(_params) {}
+
+    virtual ~MSER_Impl() CV_OVERRIDE {}
+
+    void read( const FileNode& fn) CV_OVERRIDE
+    {
+      // if node is empty, keep previous value
+      if (!fn["delta"].empty())
+        fn["delta"] >> params.delta;
+      if (!fn["minArea"].empty())
+        fn["minArea"] >> params.minArea;
+      if (!fn["maxArea"].empty())
+        fn["maxArea"] >> params.maxArea;
+      if (!fn["maxVariation"].empty())
+        fn["maxVariation"] >> params.maxVariation;
+      if (!fn["minDiversity"].empty())
+        fn["minDiversity"] >> params.minDiversity;
+      if (!fn["maxEvolution"].empty())
+        fn["maxEvolution"] >> params.maxEvolution;
+      if (!fn["areaThreshold"].empty())
+        fn["areaThreshold"] >> params.areaThreshold;
+      if (!fn["minMargin"].empty())
+        fn["minMargin"] >> params.minMargin;
+      if (!fn["edgeBlurSize"].empty())
+        fn["edgeBlurSize"] >> params.edgeBlurSize;
+      if (!fn["pass2Only"].empty())
+        fn["pass2Only"] >> params.pass2Only;
+    }
+    void write( FileStorage& fs) const CV_OVERRIDE
+    {
+      if(fs.isOpened())
+      {
+        fs << "name" << getDefaultName();
+        fs << "delta" << params.delta;
+        fs << "minArea" << params.minArea;
+        fs << "maxArea" << params.maxArea;
+        fs << "maxVariation" << params.maxVariation;
+        fs << "minDiversity" << params.minDiversity;
+        fs << "maxEvolution" << params.maxEvolution;
+        fs << "areaThreshold" << params.areaThreshold;
+        fs << "minMargin" << params.minMargin;
+        fs << "edgeBlurSize" << params.edgeBlurSize;
+        fs << "pass2Only" << params.pass2Only;
+      }
+    }
+
+    void setDelta(int delta) CV_OVERRIDE { params.delta = delta; }
+    int getDelta() const CV_OVERRIDE { return params.delta; }
+
+    void setMinArea(int minArea) CV_OVERRIDE { params.minArea = minArea; }
+    int getMinArea() const CV_OVERRIDE { return params.minArea; }
+
+    void setMaxArea(int maxArea) CV_OVERRIDE { params.maxArea = maxArea; }
+    int getMaxArea() const CV_OVERRIDE { return params.maxArea; }
+
+    void setMaxVariation(double maxVariation) CV_OVERRIDE { params.maxVariation = maxVariation; }
+    double getMaxVariation() const CV_OVERRIDE { return params.maxVariation; }
+
+    void setMinDiversity(double minDiversity) CV_OVERRIDE { params.minDiversity = minDiversity; }
+    double getMinDiversity() const CV_OVERRIDE { return params.minDiversity; }
+
+    void setMaxEvolution(int maxEvolution) CV_OVERRIDE { params.maxEvolution = maxEvolution; }
+    int getMaxEvolution() const CV_OVERRIDE { return params.maxEvolution; }
+
+    void setAreaThreshold(double areaThreshold) CV_OVERRIDE { params.areaThreshold = areaThreshold; }
+    double getAreaThreshold() const CV_OVERRIDE { return params.areaThreshold; }
+
+    void setMinMargin(double min_margin) CV_OVERRIDE { params.minMargin = min_margin; }
+    double getMinMargin() const CV_OVERRIDE { return params.minMargin; }
+
+    void setEdgeBlurSize(int edge_blur_size) CV_OVERRIDE { params.edgeBlurSize = edge_blur_size; }
+    int getEdgeBlurSize() const CV_OVERRIDE { return params.edgeBlurSize; }
+
+    void setPass2Only(bool f) CV_OVERRIDE { params.pass2Only = f; }
+    bool getPass2Only() const CV_OVERRIDE { return params.pass2Only; }
+
+    enum { DIR_SHIFT = 29, NEXT_MASK = ((1<<DIR_SHIFT)-1)  };
+
+    struct Pixel
+    {
+        Pixel() : val(0) {}
+        Pixel(int _val) : val(_val) {}
+
+        int getGray(const Pixel* ptr0, const uchar* imgptr0, int mask) const
+        {
+            return imgptr0[this - ptr0] ^ mask;
+        }
+        int getNext() const { return (val & NEXT_MASK); }
+        void setNext(int next) { val = (val & ~NEXT_MASK) | next; }
+
+        int getDir() const { return (int)((unsigned)val >> DIR_SHIFT); }
+        void setDir(int dir) { val = (val & NEXT_MASK) | (dir << DIR_SHIFT); }
+        bool isVisited() const { return (val & ~NEXT_MASK) != 0; }
+
+        int val;
+    };
+    typedef int PPixel;
+
+    struct WParams
+    {
+        Params p;
+        vector<vector<Point> >* msers;
+        vector<Rect>* bboxvec;
+        Pixel* pix0;
+        int step;
+    };
+
+    // the history of region grown
+    struct CompHistory
+    {
+        CompHistory()
+        {
+            parent_ = child_ = next_ = 0;
+            val = size = 0;
+            var = -1.f;
+            head = 0;
+            checked = false;
+        }
+        void updateTree( WParams& wp, CompHistory** _h0, CompHistory** _h1, bool final )
+        {
+            if( var >= 0.f )
+                return;
+            int delta = wp.p.delta;
+
+            CompHistory* h0_ = 0, *h1_ = 0;
+            CompHistory* c = child_;
+            if( size >= wp.p.minArea )
+            {
+                for( ; c != 0; c = c->next_ )
+                {
+                    if( c->var < 0.f )
+                        c->updateTree(wp, c == child_ ? &h0_ : 0, c == child_ ? &h1_ : 0, final);
+                    if( c->var < 0.f )
+                        return;
+                }
+            }
+
+            // find h0 and h1 such that:
+            //    h0->val >= h->val - delta and (h0->parent == 0 or h0->parent->val < h->val - delta)
+            //    h1->val <= h->val + delta and (h1->child == 0 or h1->child->val < h->val + delta)
+            // then we will adjust h0 and h1 as h moves towards latest
+            CompHistory* h0 = this, *h1 = h1_ && h1_->size > size ? h1_ : this;
+            if( h0_ )
+            {
+                for( h0 = h0_; h0 != this && h0->val < val - delta; h0 = h0->parent_ )
+                    ;
+            }
+            else
+            {
+                for( ; h0->child_ && h0->child_->val >= val - delta; h0 = h0->child_ )
+                    ;
+            }
+
+            for( ; h1->parent_ && h1->parent_->val <= val + delta; h1 = h1->parent_ )
+                ;
+
+            if( _h0 ) *_h0 = h0;
+            if( _h1 ) *_h1 = h1;
+
+            // when we do not well-defined ER(h->val + delta), we stop
+            // the process of computing variances unless we are at the final step
+            if( !final && !h1->parent_ && h1->val < val + delta )
+                return;
+
+            var = (float)(h1->size - h0->size)/size;
+            c = child_;
+            for( ; c != 0; c = c->next_ )
+                c->checkAndCapture(wp);
+            if( final && !parent_ )
+                checkAndCapture(wp);
+        }
+
+        void checkAndCapture( WParams& wp )
+        {
+            if( checked )
+                return;
+            checked = true;
+            if( size < wp.p.minArea || size > wp.p.maxArea || var < wp.p.minDiversity || var > wp.p.maxVariation )
+                return;
+            if( child_ )
+            {
+                CompHistory* c = child_;
+                for( ; c != 0; c = c->next_ )
+                {
+                    if( c->var >= 0.f && var > c->var )
+                        return;
+                }
+            }
+            if( var > 0.f && parent_ && parent_->var >= 0.f && var >= parent_->var )
+                return;
+            int xmin = INT_MAX, ymin = INT_MAX, xmax = INT_MIN, ymax = INT_MIN, j = 0;
+            wp.msers->push_back(vector<Point>());
+            vector<Point>& region = wp.msers->back();
+            region.resize(size);
+            const Pixel* pix0 = wp.pix0;
+            int step = wp.step;
+
+            for( PPixel pix = head; j < size; j++, pix = pix0[pix].getNext() )
+            {
+                int y = pix/step;
+                int x = pix - y*step;
+
+                xmin = std::min(xmin, x);
+                xmax = std::max(xmax, x);
+                ymin = std::min(ymin, y);
+                ymax = std::max(ymax, y);
+
+                region[j] = Point(x, y);
+            }
+
+            wp.bboxvec->push_back(Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1));
+        }
+
+        CompHistory* child_;
+        CompHistory* parent_;
+        CompHistory* next_;
+        int val;
+        int size;
+        float var;
+        PPixel head;
+        bool checked;
+    };
+
+    struct ConnectedComp
+    {
+        ConnectedComp()
+        {
+            init(0);
+        }
+
+        void init(int gray)
+        {
+            head = tail = 0;
+            history = 0;
+            size = 0;
+            gray_level = gray;
+        }
+
+        // add history chunk to a connected component
+        void growHistory(CompHistory*& hptr, WParams& wp, int new_gray_level, bool final)
+        {
+            if (new_gray_level < gray_level)
+                new_gray_level = gray_level;
+
+            CompHistory *h;
+            if (history && history->val == gray_level)
+            {
+                h = history;
+            }
+            else
+            {
+                h = hptr++;
+                h->parent_ = 0;
+                h->child_ = history;
+                h->next_ = 0;
+
+                if (history)
+                {
+                    history->parent_ = h;
+                }
+            }
+            CV_Assert(h != NULL);
+            h->val = gray_level;
+            h->size = size;
+            h->head = head;
+            h->var = FLT_MAX;
+            h->checked = true;
+            if (h->size >= wp.p.minArea)
+            {
+                h->var = -1.f;
+                h->checked = false;
+            }
+
+            gray_level = new_gray_level;
+            history = h;
+            if (history && history->val != gray_level)
+            {
+                history->updateTree(wp, 0, 0, final);
+            }
+        }
+
+        // merging two connected components
+        void merge( ConnectedComp* comp1, ConnectedComp* comp2,
+                    CompHistory*& hptr, WParams& wp )
+        {
+            if (comp1->gray_level < comp2->gray_level)
+                std::swap(comp1, comp2);
+
+            gray_level = comp1->gray_level;
+            comp1->growHistory(hptr, wp, gray_level, false);
+            comp2->growHistory(hptr, wp, gray_level, false);
+
+            if (comp1->size == 0)
+            {
+                head = comp2->head;
+                tail = comp2->tail;
+            }
+            else
+            {
+                head = comp1->head;
+                wp.pix0[comp1->tail].setNext(comp2->head);
+                tail = comp2->tail;
+            }
+
+            size = comp1->size + comp2->size;
+            history = comp1->history;
+
+            CompHistory *h1 = history->child_;
+            CompHistory *h2 = comp2->history;
+            // the child_'s size should be the large one
+            if (h1 && h1->size > h2->size)
+            {
+                // add h2 as a child only if its size is large enough
+                if(h2->size >= wp.p.minArea)
+                {
+                    h2->next_ = h1->next_;
+                    h1->next_ = h2;
+                    h2->parent_ = history;
+                }
+            }
+            else
+            {
+                history->child_ = h2;
+                h2->parent_ = history;
+                // reserve h1 as a child only if its size is large enough
+                if (h1 && h1->size >= wp.p.minArea)
+                {
+                    h2->next_ = h1;
+                }
+            }
+        }
+
+        PPixel head;
+        PPixel tail;
+        CompHistory* history;
+        int gray_level;
+        int size;
+    };
+
+    void detectRegions( InputArray image,
+                        std::vector<std::vector<Point> >& msers,
+                        std::vector<Rect>& bboxes ) CV_OVERRIDE;
+    void detect( InputArray _src, vector<KeyPoint>& keypoints, InputArray _mask ) CV_OVERRIDE;
+
+    void preprocess1( const Mat& img, int* level_size )
+    {
+        memset(level_size, 0, 256*sizeof(level_size[0]));
+
+        int i, j, cols = img.cols, rows = img.rows;
+        int step = cols;
+        pixbuf.resize(step*rows);
+        heapbuf.resize(cols*rows + 256);
+        histbuf.resize(cols*rows);
+        Pixel borderpix;
+        borderpix.setDir(5);
+
+        for( j = 0; j < step; j++ )
+        {
+            pixbuf[j] = pixbuf[j + (rows-1)*step] = borderpix;
+        }
+
+        for( i = 1; i < rows-1; i++ )
+        {
+            const uchar* imgptr = img.ptr(i);
+            Pixel* pptr = &pixbuf[i*step];
+            pptr[0] = pptr[cols-1] = borderpix;
+            for( j = 1; j < cols-1; j++ )
+            {
+                int val = imgptr[j];
+                level_size[val]++;
+                pptr[j].val = 0;
+            }
+        }
+    }
+
+    void preprocess2( const Mat& img, int* level_size )
+    {
+        int i;
+
+        for( i = 0; i < 128; i++ )
+            std::swap(level_size[i], level_size[255-i]);
+
+        if( !params.pass2Only )
+        {
+            int j, cols = img.cols, rows = img.rows;
+            int step = cols;
+            for( i = 1; i < rows-1; i++ )
+            {
+                Pixel* pptr = &pixbuf[i*step];
+                for( j = 1; j < cols-1; j++ )
+                {
+                    pptr[j].val = 0;
+                }
+            }
+        }
+    }
+
+    void pass( const Mat& img, vector<vector<Point> >& msers, vector<Rect>& bboxvec,
+              Size size, const int* level_size, int mask )
+    {
+        CompHistory* histptr = &histbuf[0];
+        int step = size.width;
+        Pixel *ptr0 = &pixbuf[0], *ptr = &ptr0[step+1];
+        const uchar* imgptr0 = img.ptr();
+        Pixel** heap[256];
+        ConnectedComp comp[257];
+        ConnectedComp* comptr = &comp[0];
+        WParams wp;
+        wp.p = params;
+        wp.msers = &msers;
+        wp.bboxvec = &bboxvec;
+        wp.pix0 = ptr0;
+        wp.step = step;
+
+        heap[0] = &heapbuf[0];
+        heap[0][0] = 0;
+
+        for( int i = 1; i < 256; i++ )
+        {
+            heap[i] = heap[i-1] + level_size[i-1] + 1;
+            heap[i][0] = 0;
+        }
+
+        comptr->gray_level = 256;
+        comptr++;
+        comptr->gray_level = ptr->getGray(ptr0, imgptr0, mask);
+        ptr->setDir(1);
+        int dir[] = { 0, 1, step, -1, -step };
+        for( ;; )
+        {
+            int curr_gray = ptr->getGray(ptr0, imgptr0, mask);
+            int nbr_idx = ptr->getDir();
+            // take tour of all the 4 directions
+            for( ; nbr_idx <= 4; nbr_idx++ )
+            {
+                // get the neighbor
+                Pixel* ptr_nbr = ptr + dir[nbr_idx];
+                if( !ptr_nbr->isVisited() )
+                {
+                    // set dir=1, next=0
+                    ptr_nbr->val = 1 << DIR_SHIFT;
+                    int nbr_gray = ptr_nbr->getGray(ptr0, imgptr0, mask);
+                    if( nbr_gray < curr_gray )
+                    {
+                        // when the value of neighbor smaller than current
+                        // push current to boundary heap and make the neighbor to be the current one
+                        // create an empty comp
+                        *(++heap[curr_gray]) = ptr;
+                        ptr->val = (nbr_idx+1) << DIR_SHIFT;
+                        ptr = ptr_nbr;
+                        comptr++;
+                        comptr->init(nbr_gray);
+                        curr_gray = nbr_gray;
+                        nbr_idx = 0;
+                        continue;
+                    }
+                    // otherwise, push the neighbor to boundary heap
+                    *(++heap[nbr_gray]) = ptr_nbr;
+                }
+            }
+
+            // set dir = nbr_idx, next = 0
+            ptr->val = nbr_idx << DIR_SHIFT;
+            int ptrofs = (int)(ptr - ptr0);
+            CV_Assert(ptrofs != 0);
+
+            // add a pixel to the pixel list
+            if( comptr->tail )
+                ptr0[comptr->tail].setNext(ptrofs);
+            else
+                comptr->head = ptrofs;
+            comptr->tail = ptrofs;
+            comptr->size++;
+            // get the next pixel from boundary heap
+            if( *heap[curr_gray] )
+            {
+                ptr = *heap[curr_gray];
+                heap[curr_gray]--;
+            }
+            else
+            {
+                for( curr_gray++; curr_gray < 256; curr_gray++ )
+                {
+                    if( *heap[curr_gray] )
+                        break;
+                }
+                if( curr_gray >= 256 )
+                    break;
+
+                ptr = *heap[curr_gray];
+                heap[curr_gray]--;
+
+                if (curr_gray < comptr[-1].gray_level)
+                {
+                    comptr->growHistory(histptr, wp, curr_gray, false);
+                    CV_DbgAssert(comptr->size == comptr->history->size);
+                }
+                else
+                {
+                    // there must one pixel with the second component's gray level in the heap,
+                    // so curr_gray is not large than the second component's gray level
+                    comptr--;
+                    CV_DbgAssert(curr_gray == comptr->gray_level);
+                    comptr->merge(comptr, comptr + 1, histptr, wp);
+                    CV_DbgAssert(curr_gray == comptr->gray_level);
+                }
+            }
+        }
+
+        for( ; comptr->gray_level != 256; comptr-- )
+        {
+            comptr->growHistory(histptr, wp, 256, true);
+        }
+    }
+
+    Mat tempsrc;
+    vector<Pixel> pixbuf;
+    vector<Pixel*> heapbuf;
+    vector<CompHistory> histbuf;
+
+    Params params;
+};
+
+/*
+
+TODO:
+the color MSER has not been completely refactored yet. We leave it mostly as-is,
+with just enough changes to convert C structures to C++ ones and
+add support for color images into MSER_Impl::detectAndLabel.
+*/
+struct MSCRNode;
+
+struct TempMSCR
+{
+    MSCRNode* head;
+    MSCRNode* tail;
+    double m; // the margin used to prune area later
+    int size;
+};
+
+struct MSCRNode
+{
+    MSCRNode* shortcut;
+    // to make the finding of root less painful
+    MSCRNode* prev;
+    MSCRNode* next;
+    // a point double-linked list
+    TempMSCR* tmsr;
+    // the temporary msr (set to NULL at every re-initialise)
+    TempMSCR* gmsr;
+    // the global msr (once set, never to NULL)
+    int index;
+    // the index of the node, at this point, it should be x at the first 16-bits, and y at the last 16-bits.
+    int rank;
+    int reinit;
+    int size, sizei;
+    double dt, di;
+    double s;
+};
+
+struct MSCREdge
+{
+    double chi;
+    MSCRNode* left;
+    MSCRNode* right;
+};
+
+static double ChiSquaredDistance( const uchar* x, const uchar* y )
+{
+    return (double)((x[0]-y[0])*(x[0]-y[0]))/(double)(x[0]+y[0]+1e-10)+
+    (double)((x[1]-y[1])*(x[1]-y[1]))/(double)(x[1]+y[1]+1e-10)+
+    (double)((x[2]-y[2])*(x[2]-y[2]))/(double)(x[2]+y[2]+1e-10);
+}
+
+static void initMSCRNode( MSCRNode* node )
+{
+    node->gmsr = node->tmsr = NULL;
+    node->reinit = 0xffff;
+    node->rank = 0;
+    node->sizei = node->size = 1;
+    node->prev = node->next = node->shortcut = node;
+}
+
+// the preprocess to get the edge list with proper gaussian blur
+static int preprocessMSER_8uC3( MSCRNode* node,
+                               MSCREdge* edge,
+                               double* total,
+                               const Mat& src,
+                               Mat& dx,
+                               Mat& dy,
+                               int Ne,
+                               int edgeBlurSize )
+{
+    int srccpt = (int)(src.step-src.cols*3);
+    const uchar* srcptr = src.ptr();
+    const uchar* lastptr = srcptr+3;
+    double* dxptr = dx.ptr<double>();
+    for ( int i = 0; i < src.rows; i++ )
+    {
+        for ( int j = 0; j < src.cols-1; j++ )
+        {
+            *dxptr = ChiSquaredDistance( srcptr, lastptr );
+            dxptr++;
+            srcptr += 3;
+            lastptr += 3;
+        }
+        srcptr += srccpt+3;
+        lastptr += srccpt+3;
+    }
+    srcptr = src.ptr();
+    lastptr = srcptr+src.step;
+    double* dyptr = dy.ptr<double>();
+    for ( int i = 0; i < src.rows-1; i++ )
+    {
+        for ( int j = 0; j < src.cols; j++ )
+        {
+            *dyptr = ChiSquaredDistance( srcptr, lastptr );
+            dyptr++;
+            srcptr += 3;
+            lastptr += 3;
+        }
+        srcptr += srccpt;
+        lastptr += srccpt;
+    }
+    // get dx and dy and blur it
+    if ( edgeBlurSize >= 1 )
+    {
+        GaussianBlur( dx, dx, Size(edgeBlurSize, edgeBlurSize), 0 );
+        GaussianBlur( dy, dy, Size(edgeBlurSize, edgeBlurSize), 0 );
+    }
+    dxptr = dx.ptr<double>();
+    dyptr = dy.ptr<double>();
+    // assian dx, dy to proper edge list and initialize mscr node
+    // the nasty code here intended to avoid extra loops
+    MSCRNode* nodeptr = node;
+    initMSCRNode( nodeptr );
+    nodeptr->index = 0;
+    *total += edge->chi = *dxptr;
+    dxptr++;
+    edge->left = nodeptr;
+    edge->right = nodeptr+1;
+    edge++;
+    nodeptr++;
+    for ( int i = 1; i < src.cols-1; i++ )
+    {
+        initMSCRNode( nodeptr );
+        nodeptr->index = i;
+        *total += edge->chi = *dxptr;
+        dxptr++;
+        edge->left = nodeptr;
+        edge->right = nodeptr+1;
+        edge++;
+        nodeptr++;
+    }
+    initMSCRNode( nodeptr );
+    nodeptr->index = src.cols-1;
+    nodeptr++;
+    for ( int i = 1; i < src.rows-1; i++ )
+    {
+        initMSCRNode( nodeptr );
+        nodeptr->index = i<<16;
+        *total += edge->chi = *dyptr;
+        dyptr++;
+        edge->left = nodeptr-src.cols;
+        edge->right = nodeptr;
+        edge++;
+        *total += edge->chi = *dxptr;
+        dxptr++;
+        edge->left = nodeptr;
+        edge->right = nodeptr+1;
+        edge++;
+        nodeptr++;
+        for ( int j = 1; j < src.cols-1; j++ )
+        {
+            initMSCRNode( nodeptr );
+            nodeptr->index = (i<<16)|j;
+            *total += edge->chi = *dyptr;
+            dyptr++;
+            edge->left = nodeptr-src.cols;
+            edge->right = nodeptr;
+            edge++;
+            *total += edge->chi = *dxptr;
+            dxptr++;
+            edge->left = nodeptr;
+            edge->right = nodeptr+1;
+            edge++;
+            nodeptr++;
+        }
+        initMSCRNode( nodeptr );
+        nodeptr->index = (i<<16)|(src.cols-1);
+        *total += edge->chi = *dyptr;
+        dyptr++;
+        edge->left = nodeptr-src.cols;
+        edge->right = nodeptr;
+        edge++;
+        nodeptr++;
+    }
+    initMSCRNode( nodeptr );
+    nodeptr->index = (src.rows-1)<<16;
+    *total += edge->chi = *dxptr;
+    dxptr++;
+    edge->left = nodeptr;
+    edge->right = nodeptr+1;
+    edge++;
+    *total += edge->chi = *dyptr;
+    dyptr++;
+    edge->left = nodeptr-src.cols;
+    edge->right = nodeptr;
+    edge++;
+    nodeptr++;
+    for ( int i = 1; i < src.cols-1; i++ )
+    {
+        initMSCRNode( nodeptr );
+        nodeptr->index = ((src.rows-1)<<16)|i;
+        *total += edge->chi = *dxptr;
+        dxptr++;
+        edge->left = nodeptr;
+        edge->right = nodeptr+1;
+        edge++;
+        *total += edge->chi = *dyptr;
+        dyptr++;
+        edge->left = nodeptr-src.cols;
+        edge->right = nodeptr;
+        edge++;
+        nodeptr++;
+    }
+    initMSCRNode( nodeptr );
+    nodeptr->index = ((src.rows-1)<<16)|(src.cols-1);
+    *total += edge->chi = *dyptr;
+    edge->left = nodeptr-src.cols;
+    edge->right = nodeptr;
+
+    return Ne;
+}
+
+class LessThanEdge
+{
+public:
+    bool operator()(const MSCREdge& a, const MSCREdge& b) const { return a.chi < b.chi; }
+};
+
+// to find the root of one region
+static MSCRNode* findMSCR( MSCRNode* x )
+{
+    MSCRNode* prev = x;
+    MSCRNode* next;
+    for ( ; ; )
+    {
+        next = x->shortcut;
+        x->shortcut = prev;
+        if ( next == x ) break;
+        prev= x;
+        x = next;
+    }
+    MSCRNode* root = x;
+    for ( ; ; )
+    {
+        prev = x->shortcut;
+        x->shortcut = root;
+        if ( prev == x ) break;
+        x = prev;
+    }
+    return root;
+}
+
+// the stable mscr should be:
+// bigger than minArea and smaller than maxArea
+// differ from its ancestor more than minDiversity
+static bool MSCRStableCheck( MSCRNode* x, const MSER_Impl::Params& params )
+{
+    if ( x->size <= params.minArea || x->size >= params.maxArea )
+        return false;
+    if ( x->gmsr == NULL )
+        return true;
+    double div = (double)(x->size-x->gmsr->size)/(double)x->size;
+    return div > params.minDiversity;
+}
+
+static void
+extractMSER_8uC3( const Mat& src,
+                  vector<vector<Point> >& msers,
+                  vector<Rect>& bboxvec,
+                  const MSER_Impl::Params& params )
+{
+    bboxvec.clear();
+    AutoBuffer<MSCRNode> mapBuf(src.cols*src.rows);
+    MSCRNode* map = mapBuf.data();
+    int Ne = src.cols*src.rows*2-src.cols-src.rows;
+    AutoBuffer<MSCREdge> edgeBuf(Ne);
+    MSCREdge* edge = edgeBuf.data();
+    AutoBuffer<TempMSCR> mscrBuf(src.cols*src.rows);
+    TempMSCR* mscr = mscrBuf.data();
+    double emean = 0;
+    Mat dx( src.rows, src.cols-1, CV_64FC1 );
+    Mat dy( src.rows-1, src.cols, CV_64FC1 );
+    Ne = preprocessMSER_8uC3( map, edge, &emean, src, dx, dy, Ne, params.edgeBlurSize );
+    emean = emean / (double)Ne;
+    std::sort(edge, edge + Ne, LessThanEdge());
+    MSCREdge* edge_ub = edge+Ne;
+    MSCREdge* edgeptr = edge;
+    TempMSCR* mscrptr = mscr;
+    // the evolution process
+    for ( int i = 0; i < params.maxEvolution; i++ )
+    {
+        double k = (double)i/(double)params.maxEvolution*(TABLE_SIZE-1);
+        int ti = cvFloor(k);
+        double reminder = k-ti;
+        double thres = emean*(chitab3[ti]*(1-reminder)+chitab3[ti+1]*reminder);
+        // to process all the edges in the list that chi < thres
+        while ( edgeptr < edge_ub && edgeptr->chi < thres )
+        {
+            MSCRNode* lr = findMSCR( edgeptr->left );
+            MSCRNode* rr = findMSCR( edgeptr->right );
+            // get the region root (who is responsible)
+            if ( lr != rr )
+            {
+                // rank idea take from: N-tree Disjoint-Set Forests for Maximally Stable Extremal Regions
+                if ( rr->rank > lr->rank )
+                {
+                    MSCRNode* tmp;
+                    CV_SWAP( lr, rr, tmp );
+                } else if ( lr->rank == rr->rank ) {
+                    // at the same rank, we will compare the size
+                    if ( lr->size > rr->size )
+                    {
+                        MSCRNode* tmp;
+                        CV_SWAP( lr, rr, tmp );
+                    }
+                    lr->rank++;
+                }
+                rr->shortcut = lr;
+                lr->size += rr->size;
+                // join rr to the end of list lr (lr is a endless double-linked list)
+                lr->prev->next = rr;
+                lr->prev = rr->prev;
+                rr->prev->next = lr;
+                rr->prev = lr;
+                // area threshold force to reinitialize
+                if ( lr->size > (lr->size-rr->size)*params.areaThreshold )
+                {
+                    lr->sizei = lr->size;
+                    lr->reinit = i;
+                    if ( lr->tmsr != NULL )
+                    {
+                        lr->tmsr->m = lr->dt-lr->di;
+                        lr->tmsr = NULL;
+                    }
+                    lr->di = edgeptr->chi;
+                    lr->s = 1e10;
+                }
+                lr->dt = edgeptr->chi;
+                if ( i > lr->reinit )
+                {
+                    double s = (double)(lr->size-lr->sizei)/(lr->dt-lr->di);
+                    if ( s < lr->s )
+                    {
+                        // skip the first one and check stability
+                        if ( i > lr->reinit+1 && MSCRStableCheck( lr, params ) )
+                        {
+                            if ( lr->tmsr == NULL )
+                            {
+                                lr->gmsr = lr->tmsr = mscrptr;
+                                mscrptr++;
+                            }
+                            lr->tmsr->size = lr->size;
+                            lr->tmsr->head = lr;
+                            lr->tmsr->tail = lr->prev;
+                            lr->tmsr->m = 0;
+                        }
+                        lr->s = s;
+                    }
+                }
+            }
+            edgeptr++;
+        }
+        if ( edgeptr >= edge_ub )
+            break;
+    }
+    for ( TempMSCR* ptr = mscr; ptr < mscrptr; ptr++ )
+        // to prune area with margin less than minMargin
+        if ( ptr->m > params.minMargin )
+        {
+            MSCRNode* lpt = ptr->head;
+            int xmin = INT_MAX, ymin = INT_MAX, xmax = INT_MIN, ymax = INT_MIN;
+            msers.push_back(vector<Point>());
+            vector<Point>& mser = msers.back();
+
+            for ( int i = 0; i < ptr->size; i++ )
+            {
+                Point pt;
+                pt.x = (lpt->index)&0xffff;
+                pt.y = (lpt->index)>>16;
+                xmin = std::min(xmin, pt.x);
+                xmax = std::max(xmax, pt.x);
+                ymin = std::min(ymin, pt.y);
+                ymax = std::max(ymax, pt.y);
+
+                lpt = lpt->next;
+                mser.push_back(pt);
+            }
+            bboxvec.push_back(Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1));
+        }
+}
+
+void MSER_Impl::detectRegions( InputArray _src, vector<vector<Point> >& msers, vector<Rect>& bboxes )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat src = _src.getMat();
+
+    msers.clear();
+    bboxes.clear();
+
+    if( src.rows < 3 || src.cols < 3 )
+        CV_Error(Error::StsBadArg, "Input image is too small. Expected at least 3x3");
+
+    Size size = src.size();
+
+    if( src.type() == CV_8U )
+    {
+        int level_size[256];
+        if( !src.isContinuous() )
+        {
+            src.copyTo(tempsrc);
+            src = tempsrc;
+        }
+
+        // darker to brighter (MSER+)
+        preprocess1( src, level_size );
+        if( !params.pass2Only )
+            pass( src, msers, bboxes, size, level_size, 0 );
+        // brighter to darker (MSER-)
+        preprocess2( src, level_size );
+        pass( src, msers, bboxes, size, level_size, 255 );
+    }
+    else
+    {
+        CV_Assert( src.type() == CV_8UC3 || src.type() == CV_8UC4 );
+        extractMSER_8uC3( src, msers, bboxes, params );
+    }
+}
+
+void MSER_Impl::detect( InputArray _image, vector<KeyPoint>& keypoints, InputArray _mask )
+{
+    CV_INSTRUMENT_REGION();
+
+    vector<Rect> bboxes;
+    vector<vector<Point> > msers;
+    Mat mask = _mask.getMat();
+
+    detectRegions(_image, msers, bboxes);
+    int i, ncomps = (int)msers.size();
+
+    keypoints.clear();
+    for( i = 0; i < ncomps; i++ )
+    {
+        Rect r = bboxes[i];
+        // TODO check transformation from MSER region to KeyPoint
+        RotatedRect rect = fitEllipse(Mat(msers[i]));
+        float diam = std::sqrt(rect.size.height*rect.size.width);
+
+        if( diam > std::numeric_limits<float>::epsilon() && r.contains(rect.center) &&
+            (mask.empty() || mask.at<uchar>(cvRound(rect.center.y), cvRound(rect.center.x)) != 0) )
+            keypoints.push_back( KeyPoint(rect.center, diam) );
+    }
+}
+
+Ptr<MSER> MSER::create( int _delta, int _min_area, int _max_area,
+      double _max_variation, double _min_diversity,
+      int _max_evolution, double _area_threshold,
+      double _min_margin, int _edge_blur_size )
+{
+    return makePtr<MSER_Impl>(
+        MSER_Impl::Params(_delta, _min_area, _max_area,
+                          _max_variation, _min_diversity,
+                          _max_evolution, _area_threshold,
+                          _min_margin, _edge_blur_size));
+}
+
+String MSER::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".MSER");
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/opencl/brute_force_match.cl b/upstream/opencv/modules/features/src/opencl/brute_force_match.cl
new file mode 100644
index 0000000..68f2590
--- /dev/null
+++ b/upstream/opencv/modules/features/src/opencl/brute_force_match.cl
@@ -0,0 +1,694 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Nathan, liujun@multicorewareinc.com
+//    Peng Xiao, pengxiao@outlook.com
+//    Baichuan Su, baichuan@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics:enable
+#define MAX_FLOAT 3.40282e+038f
+
+#ifndef T
+#define T float
+#endif
+
+#ifndef BLOCK_SIZE
+#define BLOCK_SIZE 16
+#endif
+#ifndef MAX_DESC_LEN
+#define MAX_DESC_LEN 64
+#endif
+
+#define BLOCK_SIZE_ODD          (BLOCK_SIZE + 1)
+#ifndef SHARED_MEM_SZ
+#  if (BLOCK_SIZE < MAX_DESC_LEN)
+#    define SHARED_MEM_SZ      (kercn * (BLOCK_SIZE * MAX_DESC_LEN + BLOCK_SIZE * BLOCK_SIZE))
+#  else
+#    define SHARED_MEM_SZ      (kercn * 2 * BLOCK_SIZE_ODD * BLOCK_SIZE)
+#  endif
+#endif
+
+#ifndef DIST_TYPE
+#define DIST_TYPE 2
+#endif
+
+// dirty fix for non-template support
+#if (DIST_TYPE == 2) // L1Dist
+#   ifdef T_FLOAT
+        typedef float result_type;
+#       if (8 == kercn)
+            typedef float8 value_type;
+#           define DIST(x, y) {value_type d = fabs((x) - (y)); result += d.s0 + d.s1 + d.s2 + d.s3 + d.s4 + d.s5 + d.s6 + d.s7;}
+#       elif (4 == kercn)
+            typedef float4 value_type;
+#           define DIST(x, y) {value_type d = fabs((x) - (y)); result += d.s0 + d.s1 + d.s2 + d.s3;}
+#       else
+            typedef float value_type;
+#           define DIST(x, y) result += fabs((x) - (y))
+#       endif
+#   else
+        typedef int result_type;
+#       if (8 == kercn)
+            typedef int8 value_type;
+#           define DIST(x, y) {value_type d = abs((x) - (y)); result += d.s0 + d.s1 + d.s2 + d.s3 + d.s4 + d.s5 + d.s6 + d.s7;}
+#       elif (4 == kercn)
+            typedef int4 value_type;
+#           define DIST(x, y) {value_type d = abs((x) - (y)); result += d.s0 + d.s1 + d.s2 + d.s3;}
+#       else
+            typedef int  value_type;
+#           define DIST(x, y) result += abs((x) - (y))
+#       endif
+#   endif
+#   define DIST_RES(x) (x)
+#elif (DIST_TYPE == 4) // L2Dist
+    typedef float result_type;
+#   if (8 == kercn)
+        typedef float8 value_type;
+#       define DIST(x, y)   {value_type d = ((x) - (y)); result += dot(d.s0123, d.s0123) + dot(d.s4567, d.s4567);}
+#   elif (4 == kercn)
+        typedef float4      value_type;
+#       define DIST(x, y)   {value_type d = ((x) - (y)); result += dot(d, d);}
+#   else
+        typedef float       value_type;
+#       define DIST(x, y)   {value_type d = ((x) - (y)); result = mad(d, d, result);}
+#   endif
+#   define DIST_RES(x) sqrt(x)
+#elif (DIST_TYPE == 6) // Hamming
+#   if (8 == kercn)
+        typedef int8 value_type;
+#   elif (4 == kercn)
+        typedef int4 value_type;
+#   else
+        typedef int value_type;
+#   endif
+    typedef int result_type;
+#   define DIST(x, y) result += popcount( (x) ^ (y) )
+#   define DIST_RES(x) (x)
+#endif
+
+inline result_type reduce_block(
+    __local value_type *s_query,
+    __local value_type *s_train,
+    int lidx,
+    int lidy
+    )
+{
+    result_type result = 0;
+    #pragma unroll
+    for (int j = 0 ; j < BLOCK_SIZE ; j++)
+    {
+        DIST(s_query[lidy * BLOCK_SIZE_ODD + j], s_train[j * BLOCK_SIZE_ODD + lidx]);
+    }
+    return DIST_RES(result);
+}
+
+inline result_type reduce_block_match(
+    __local value_type *s_query,
+    __local value_type *s_train,
+    int lidx,
+    int lidy
+    )
+{
+    result_type result = 0;
+    #pragma unroll
+    for (int j = 0 ; j < BLOCK_SIZE ; j++)
+    {
+        DIST(s_query[lidy * BLOCK_SIZE_ODD + j], s_train[j * BLOCK_SIZE_ODD + lidx]);
+    }
+    return result;
+}
+
+inline result_type reduce_multi_block(
+    __local value_type *s_query,
+    __local value_type *s_train,
+    int block_index,
+    int lidx,
+    int lidy
+    )
+{
+    result_type result = 0;
+    #pragma unroll
+    for (int j = 0 ; j < BLOCK_SIZE ; j++)
+    {
+        DIST(s_query[lidy * MAX_DESC_LEN + block_index * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + lidx]);
+    }
+    return result;
+}
+
+__kernel void BruteForceMatch_Match(
+    __global T *query,
+    __global T *train,
+    __global int *bestTrainIdx,
+    __global float *bestDistance,
+    int query_rows,
+    int query_cols,
+    int train_rows,
+    int train_cols,
+    int step
+)
+{
+    const int lidx = get_local_id(0);
+    const int lidy = get_local_id(1);
+    const int groupidx = get_group_id(0);
+
+    const int queryIdx = mad24(BLOCK_SIZE, groupidx, lidy);
+    const int queryOffset = min(queryIdx, query_rows - 1) * step;
+    __global TN *query_vec = (__global TN *)(query + queryOffset);
+    query_cols /= kercn;
+
+    __local float sharebuffer[SHARED_MEM_SZ];
+    __local value_type *s_query = (__local value_type *)sharebuffer;
+
+#if 0 < MAX_DESC_LEN
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE * MAX_DESC_LEN;
+    // load the query into local memory.
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; i++)
+    {
+        const int loadx = mad24(BLOCK_SIZE, i, lidx);
+        s_query[mad24(MAX_DESC_LEN, lidy, loadx)] = loadx < query_cols ? query_vec[loadx] : 0;
+    }
+#else
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE;
+    const int s_query_i = mad24(BLOCK_SIZE_ODD, lidy, lidx);
+    const int s_train_i = mad24(BLOCK_SIZE_ODD, lidx, lidy);
+#endif
+
+    float myBestDistance = MAX_FLOAT;
+    int myBestTrainIdx = -1;
+
+    // loopUnrolledCached to find the best trainIdx and best distance.
+    for (int t = 0, endt = (train_rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; t++)
+    {
+        result_type result = 0;
+
+        const int trainOffset = min(mad24(BLOCK_SIZE, t, lidy), train_rows - 1) * step;
+        __global TN *train_vec = (__global TN *)(train + trainOffset);
+#if 0 < MAX_DESC_LEN
+        #pragma unroll
+        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; i++)
+        {
+            //load a BLOCK_SIZE * BLOCK_SIZE block into local train.
+            const int loadx = mad24(BLOCK_SIZE, i, lidx);
+            s_train[mad24(BLOCK_SIZE, lidx, lidy)] = loadx < train_cols ? train_vec[loadx] : 0;
+
+            //synchronize to make sure each elem for reduceIteration in share memory is written already.
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_multi_block(s_query, s_train, i, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#else
+        for (int i = 0, endq = (query_cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endq; i++)
+        {
+            const int loadx = mad24(i, BLOCK_SIZE, lidx);
+            //load query and train into local memory
+            if (loadx < query_cols)
+            {
+                s_query[s_query_i] = query_vec[loadx];
+                s_train[s_train_i] = train_vec[loadx];
+            }
+            else
+            {
+                s_query[s_query_i] = 0;
+                s_train[s_train_i] = 0;
+            }
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_block_match(s_query, s_train, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#endif
+        result = DIST_RES(result);
+
+        const int trainIdx = mad24(BLOCK_SIZE, t, lidx);
+
+        if (queryIdx < query_rows && trainIdx < train_rows && result < myBestDistance /*&& mask(queryIdx, trainIdx)*/)
+        {
+            myBestDistance = result;
+            myBestTrainIdx = trainIdx;
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local float *s_distance = (__local float *)sharebuffer;
+    __local int *s_trainIdx = (__local int *)(sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE);
+
+    //findBestMatch
+    s_distance += lidy * BLOCK_SIZE_ODD;
+    s_trainIdx += lidy * BLOCK_SIZE_ODD;
+    s_distance[lidx] = myBestDistance;
+    s_trainIdx[lidx] = myBestTrainIdx;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    //reduce -- now all reduce implement in each threads.
+    #pragma unroll
+    for (int k = 0 ; k < BLOCK_SIZE; k++)
+    {
+        if (myBestDistance > s_distance[k])
+        {
+            myBestDistance = s_distance[k];
+            myBestTrainIdx = s_trainIdx[k];
+        }
+    }
+
+    if (queryIdx < query_rows && lidx == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestDistance[queryIdx] = myBestDistance;
+    }
+}
+
+//radius_match
+__kernel void BruteForceMatch_RadiusMatch(
+    __global T *query,
+    __global T *train,
+    float maxDistance,
+    __global int *bestTrainIdx,
+    __global float *bestDistance,
+    __global int *nMatches,
+    int query_rows,
+    int query_cols,
+    int train_rows,
+    int train_cols,
+    int bestTrainIdx_cols,
+    int step,
+    int ostep
+)
+{
+    const int lidx = get_local_id(0);
+    const int lidy = get_local_id(1);
+    const int groupidx = get_group_id(0);
+    const int groupidy = get_group_id(1);
+
+    const int queryIdx = mad24(BLOCK_SIZE, groupidy, lidy);
+    const int queryOffset = min(queryIdx, query_rows - 1) * step;
+    __global TN *query_vec = (__global TN *)(query + queryOffset);
+
+    const int trainIdx = mad24(BLOCK_SIZE, groupidx, lidx);
+    const int trainOffset = min(mad24(BLOCK_SIZE, groupidx, lidy), train_rows - 1) * step;
+    __global TN *train_vec = (__global TN *)(train + trainOffset);
+
+    query_cols /= kercn;
+
+    __local float sharebuffer[SHARED_MEM_SZ];
+    __local value_type *s_query = (__local value_type *)sharebuffer;
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE;
+
+    result_type result = 0;
+    const int s_query_i = mad24(BLOCK_SIZE_ODD, lidy, lidx);
+    const int s_train_i = mad24(BLOCK_SIZE_ODD, lidx, lidy);
+    for (int i = 0 ; i < (query_cols + BLOCK_SIZE - 1) / BLOCK_SIZE ; ++i)
+    {
+        //load a BLOCK_SIZE * BLOCK_SIZE block into local train.
+        const int loadx = mad24(BLOCK_SIZE, i, lidx);
+
+        if (loadx < query_cols)
+        {
+            s_query[s_query_i] = query_vec[loadx];
+            s_train[s_train_i] = train_vec[loadx];
+        }
+        else
+        {
+            s_query[s_query_i] = 0;
+            s_train[s_train_i] = 0;
+        }
+
+        //synchronize to make sure each elem for reduceIteration in share memory is written already.
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        result += reduce_block(s_query, s_train, lidx, lidy);
+
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+    if (queryIdx < query_rows && trainIdx < train_rows && convert_float(result) < maxDistance)
+    {
+        int ind = atom_inc(nMatches + queryIdx);
+
+        if(ind < bestTrainIdx_cols)
+        {
+            bestTrainIdx[mad24(queryIdx, ostep, ind)] = trainIdx;
+            bestDistance[mad24(queryIdx, ostep, ind)] = result;
+        }
+    }
+}
+
+__kernel void BruteForceMatch_knnMatch(
+    __global T *query,
+    __global T *train,
+    __global int2 *bestTrainIdx,
+    __global float2 *bestDistance,
+    int query_rows,
+    int query_cols,
+    int train_rows,
+    int train_cols,
+    int step
+)
+{
+    const int lidx = get_local_id(0);
+    const int lidy = get_local_id(1);
+    const int groupidx = get_group_id(0);
+
+    const int queryIdx = mad24(BLOCK_SIZE, groupidx, lidy);
+    const int queryOffset = min(queryIdx, query_rows - 1) * step;
+    __global TN *query_vec = (__global TN *)(query + queryOffset);
+    query_cols /= kercn;
+
+    __local float sharebuffer[SHARED_MEM_SZ];
+    __local value_type *s_query = (__local value_type *)sharebuffer;
+
+#if 0 < MAX_DESC_LEN
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE * MAX_DESC_LEN;
+    // load the query into local memory.
+    #pragma unroll
+    for (int i = 0 ;  i <  MAX_DESC_LEN / BLOCK_SIZE; i ++)
+    {
+        int loadx = mad24(BLOCK_SIZE, i, lidx);
+        s_query[mad24(MAX_DESC_LEN, lidy, loadx)] = loadx < query_cols ? query_vec[loadx] : 0;
+    }
+#else
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE;
+    const int s_query_i = mad24(BLOCK_SIZE_ODD, lidy, lidx);
+    const int s_train_i = mad24(BLOCK_SIZE_ODD, lidx, lidy);
+#endif
+
+    float myBestDistance1 = MAX_FLOAT;
+    float myBestDistance2 = MAX_FLOAT;
+    int myBestTrainIdx1 = -1;
+    int myBestTrainIdx2 = -1;
+
+    for (int t = 0, endt = (train_rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt ; t++)
+    {
+        result_type result = 0;
+
+        int trainOffset = min(mad24(BLOCK_SIZE, t, lidy), train_rows - 1) * step;
+        __global TN *train_vec = (__global TN *)(train + trainOffset);
+#if 0 < MAX_DESC_LEN
+        #pragma unroll
+        for (int i = 0 ; i < MAX_DESC_LEN / BLOCK_SIZE ; i++)
+        {
+            //load a BLOCK_SIZE * BLOCK_SIZE block into local train.
+            const int loadx = mad24(BLOCK_SIZE, i, lidx);
+            s_train[mad24(BLOCK_SIZE, lidx, lidy)] = loadx < train_cols ? train_vec[loadx] : 0;
+
+            //synchronize to make sure each elem for reduceIteration in share memory is written already.
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_multi_block(s_query, s_train, i, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#else
+        for (int i = 0, endq = (query_cols + BLOCK_SIZE -1) / BLOCK_SIZE; i < endq ; i++)
+        {
+            const int loadx = mad24(BLOCK_SIZE, i, lidx);
+            //load query and train into local memory
+            if (loadx < query_cols)
+            {
+                s_query[s_query_i] = query_vec[loadx];
+                s_train[s_train_i] = train_vec[loadx];
+            }
+            else
+            {
+                s_query[s_query_i] = 0;
+                s_train[s_train_i] = 0;
+            }
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_block_match(s_query, s_train, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#endif
+        result = DIST_RES(result);
+
+        const int trainIdx = mad24(BLOCK_SIZE, t, lidx);
+
+        if (queryIdx < query_rows && trainIdx < train_rows)
+        {
+            if (result < myBestDistance1)
+            {
+                myBestDistance2 = myBestDistance1;
+                myBestTrainIdx2 = myBestTrainIdx1;
+                myBestDistance1 = result;
+                myBestTrainIdx1 = trainIdx;
+            }
+            else if (result < myBestDistance2)
+            {
+                myBestDistance2 = result;
+                myBestTrainIdx2 = trainIdx;
+            }
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local float *s_distance = (__local float *)sharebuffer;
+    __local int *s_trainIdx = (__local int *)(sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE);
+
+    // find BestMatch
+    s_distance += lidy * BLOCK_SIZE_ODD;
+    s_trainIdx += lidy * BLOCK_SIZE_ODD;
+    s_distance[lidx] = myBestDistance1;
+    s_trainIdx[lidx] = myBestTrainIdx1;
+
+    float bestDistance1 = MAX_FLOAT;
+    float bestDistance2 = MAX_FLOAT;
+    int bestTrainIdx1 = -1;
+    int bestTrainIdx2 = -1;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (lidx == 0)
+    {
+        for (int i = 0 ; i < BLOCK_SIZE ; i++)
+        {
+            float val = s_distance[i];
+            if (val < bestDistance1)
+            {
+                bestDistance2 = bestDistance1;
+                bestTrainIdx2 = bestTrainIdx1;
+
+                bestDistance1 = val;
+                bestTrainIdx1 = s_trainIdx[i];
+            }
+            else if (val < bestDistance2)
+            {
+                bestDistance2 = val;
+                bestTrainIdx2 = s_trainIdx[i];
+            }
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    s_distance[lidx] = myBestDistance2;
+    s_trainIdx[lidx] = myBestTrainIdx2;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (lidx == 0)
+    {
+        for (int i = 0 ; i < BLOCK_SIZE ; i++)
+        {
+            float val = s_distance[i];
+
+            if (val < bestDistance2)
+            {
+                bestDistance2 = val;
+                bestTrainIdx2 = s_trainIdx[i];
+            }
+        }
+    }
+
+    myBestDistance1 = bestDistance1;
+    myBestDistance2 = bestDistance2;
+
+    myBestTrainIdx1 = bestTrainIdx1;
+    myBestTrainIdx2 = bestTrainIdx2;
+
+    if (queryIdx < query_rows && lidx == 0)
+    {
+        bestTrainIdx[queryIdx] = (int2)(myBestTrainIdx1, myBestTrainIdx2);
+        bestDistance[queryIdx] = (float2)(myBestDistance1, myBestDistance2);
+    }
+}
+
+#ifdef HAVE_INT64_ATOMICS
+#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
+
+__kernel void BruteForceMatch_CrossCheckMatch(
+    __global T *query,
+    __global T *train,
+    __global int *bestTrainIdx,
+    __global float *bestDistance,
+    __global ulong *revBest,
+    int query_rows,
+    int query_cols,
+    int train_rows,
+    int train_cols,
+    int step
+)
+{
+    const int lidx = get_local_id(0);
+    const int lidy = get_local_id(1);
+    const int groupidx = get_group_id(0);
+
+    const int queryIdx = mad24(BLOCK_SIZE, groupidx, lidy);
+    const int queryOffset = min(queryIdx, query_rows - 1) * step;
+    __global TN *query_vec = (__global TN *)(query + queryOffset);
+    query_cols /= kercn;
+
+    __local float sharebuffer[SHARED_MEM_SZ];
+    __local value_type *s_query = (__local value_type *)sharebuffer;
+
+#if 0 < MAX_DESC_LEN
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE * MAX_DESC_LEN;
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; i++)
+    {
+        const int loadx = mad24(BLOCK_SIZE, i, lidx);
+        s_query[mad24(MAX_DESC_LEN, lidy, loadx)] = loadx < query_cols ? query_vec[loadx] : 0;
+    }
+#else
+    __local value_type *s_train = (__local value_type *)sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE;
+    const int s_query_i = mad24(BLOCK_SIZE_ODD, lidy, lidx);
+    const int s_train_i = mad24(BLOCK_SIZE_ODD, lidx, lidy);
+#endif
+
+    float myBestDistance = MAX_FLOAT;
+    int myBestTrainIdx = -1;
+
+    for (int t = 0, endt = (train_rows + BLOCK_SIZE - 1) / BLOCK_SIZE; t < endt; t++)
+    {
+        result_type result = 0;
+
+        const int trainOffset = min(mad24(BLOCK_SIZE, t, lidy), train_rows - 1) * step;
+        __global TN *train_vec = (__global TN *)(train + trainOffset);
+#if 0 < MAX_DESC_LEN
+        #pragma unroll
+        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; i++)
+        {
+            const int loadx = mad24(BLOCK_SIZE, i, lidx);
+            s_train[mad24(BLOCK_SIZE, lidx, lidy)] = loadx < train_cols ? train_vec[loadx] : 0;
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_multi_block(s_query, s_train, i, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#else
+        for (int i = 0, endq = (query_cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endq; i++)
+        {
+            const int loadx = mad24(BLOCK_SIZE, i, lidx);
+            if (loadx < query_cols)
+            {
+                s_query[s_query_i] = query_vec[loadx];
+                s_train[s_train_i] = train_vec[loadx];
+            }
+            else
+            {
+                s_query[s_query_i] = 0;
+                s_train[s_train_i] = 0;
+            }
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+
+            result += reduce_block_match(s_query, s_train, lidx, lidy);
+
+            barrier(CLK_LOCAL_MEM_FENCE);
+        }
+#endif
+        result = DIST_RES(result);
+
+        const int trainIdx = mad24(BLOCK_SIZE, t, lidx);
+
+        if (queryIdx < query_rows && trainIdx < train_rows)
+        {
+            if (result < myBestDistance)
+            {
+                myBestDistance = result;
+                myBestTrainIdx = trainIdx;
+            }
+
+            uint dist_bits = as_uint(result);
+            ulong packed = ((ulong)dist_bits << 32) | (ulong)queryIdx;
+            atom_min(&revBest[trainIdx], packed);
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local float *s_distance = (__local float *)sharebuffer;
+    __local int *s_trainIdx = (__local int *)(sharebuffer + BLOCK_SIZE_ODD * BLOCK_SIZE);
+
+    s_distance += lidy * BLOCK_SIZE_ODD;
+    s_trainIdx += lidy * BLOCK_SIZE_ODD;
+    s_distance[lidx] = myBestDistance;
+    s_trainIdx[lidx] = myBestTrainIdx;
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    #pragma unroll
+    for (int k = 0; k < BLOCK_SIZE; k++)
+    {
+        if (myBestDistance > s_distance[k])
+        {
+            myBestDistance = s_distance[k];
+            myBestTrainIdx = s_trainIdx[k];
+        }
+    }
+
+    if (queryIdx < query_rows && lidx == 0)
+    {
+        bestTrainIdx[queryIdx] = myBestTrainIdx;
+        bestDistance[queryIdx] = myBestDistance;
+    }
+}
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/features/src/opencl/fast.cl b/upstream/opencv/modules/features/src/opencl/fast.cl
new file mode 100644
index 0000000..84ca39a
--- /dev/null
+++ b/upstream/opencv/modules/features/src/opencl/fast.cl
@@ -0,0 +1,162 @@
+// OpenCL port of the FAST corner detector.
+// Copyright (C) 2014, Itseez Inc. See the license at http://opencv.org
+
+inline int cornerScore(__global const uchar* img, int step)
+{
+    int k, tofs, v = img[0], a0 = 0, b0;
+    int d[16];
+    #define LOAD2(idx, ofs) \
+        tofs = ofs; d[idx] = (short)(v - img[tofs]); d[idx+8] = (short)(v - img[-tofs])
+    LOAD2(0, 3);
+    LOAD2(1, -step+3);
+    LOAD2(2, -step*2+2);
+    LOAD2(3, -step*3+1);
+    LOAD2(4, -step*3);
+    LOAD2(5, -step*3-1);
+    LOAD2(6, -step*2-2);
+    LOAD2(7, -step-3);
+
+    #pragma unroll
+    for( k = 0; k < 16; k += 2 )
+    {
+        int a = min((int)d[(k+1)&15], (int)d[(k+2)&15]);
+        a = min(a, (int)d[(k+3)&15]);
+        a = min(a, (int)d[(k+4)&15]);
+        a = min(a, (int)d[(k+5)&15]);
+        a = min(a, (int)d[(k+6)&15]);
+        a = min(a, (int)d[(k+7)&15]);
+        a = min(a, (int)d[(k+8)&15]);
+        a0 = max(a0, min(a, (int)d[k&15]));
+        a0 = max(a0, min(a, (int)d[(k+9)&15]));
+    }
+
+    b0 = -a0;
+    #pragma unroll
+    for( k = 0; k < 16; k += 2 )
+    {
+        int b = max((int)d[(k+1)&15], (int)d[(k+2)&15]);
+        b = max(b, (int)d[(k+3)&15]);
+        b = max(b, (int)d[(k+4)&15]);
+        b = max(b, (int)d[(k+5)&15]);
+        b = max(b, (int)d[(k+6)&15]);
+        b = max(b, (int)d[(k+7)&15]);
+        b = max(b, (int)d[(k+8)&15]);
+
+        b0 = min(b0, max(b, (int)d[k]));
+        b0 = min(b0, max(b, (int)d[(k+9)&15]));
+    }
+
+    return -b0-1;
+}
+
+__kernel
+void FAST_findKeypoints(
+    __global const uchar * _img, int step, int img_offset,
+    int img_rows, int img_cols,
+    volatile __global int* kp_loc,
+    int max_keypoints, int threshold )
+{
+    int j = get_global_id(0) + 3;
+    int i = get_global_id(1) + 3;
+
+    if (i < img_rows - 3 && j < img_cols - 3)
+    {
+        __global const uchar* img = _img + mad24(i, step, j + img_offset);
+        int v = img[0], t0 = v - threshold, t1 = v + threshold;
+        int k, tofs, v0, v1;
+        int m0 = 0, m1 = 0;
+
+        #define UPDATE_MASK(idx, ofs) \
+            tofs = ofs; v0 = img[tofs]; v1 = img[-tofs]; \
+            m0 |= ((v0 < t0) << idx) | ((v1 < t0) << (8 + idx)); \
+            m1 |= ((v0 > t1) << idx) | ((v1 > t1) << (8 + idx))
+
+        UPDATE_MASK(0, 3);
+        if( (m0 | m1) == 0 )
+            return;
+
+        UPDATE_MASK(2, -step*2+2);
+        UPDATE_MASK(4, -step*3);
+        UPDATE_MASK(6, -step*2-2);
+
+        #define EVEN_MASK (1+4+16+64)
+
+        if( ((m0 | (m0 >> 8)) & EVEN_MASK) != EVEN_MASK &&
+            ((m1 | (m1 >> 8)) & EVEN_MASK) != EVEN_MASK )
+            return;
+
+        UPDATE_MASK(1, -step+3);
+        UPDATE_MASK(3, -step*3+1);
+        UPDATE_MASK(5, -step*3-1);
+        UPDATE_MASK(7, -step-3);
+        if( ((m0 | (m0 >> 8)) & 255) != 255 &&
+            ((m1 | (m1 >> 8)) & 255) != 255 )
+            return;
+
+        m0 |= m0 << 16;
+        m1 |= m1 << 16;
+
+        #define CHECK0(i) ((m0 & (511 << i)) == (511 << i))
+        #define CHECK1(i) ((m1 & (511 << i)) == (511 << i))
+
+        if( CHECK0(0) + CHECK0(1) + CHECK0(2) + CHECK0(3) +
+            CHECK0(4) + CHECK0(5) + CHECK0(6) + CHECK0(7) +
+            CHECK0(8) + CHECK0(9) + CHECK0(10) + CHECK0(11) +
+            CHECK0(12) + CHECK0(13) + CHECK0(14) + CHECK0(15) +
+
+            CHECK1(0) + CHECK1(1) + CHECK1(2) + CHECK1(3) +
+            CHECK1(4) + CHECK1(5) + CHECK1(6) + CHECK1(7) +
+            CHECK1(8) + CHECK1(9) + CHECK1(10) + CHECK1(11) +
+            CHECK1(12) + CHECK1(13) + CHECK1(14) + CHECK1(15) == 0 )
+            return;
+
+        {
+            int idx = atomic_inc(kp_loc);
+            if( idx < max_keypoints )
+            {
+                kp_loc[1 + 2*idx] = j;
+                kp_loc[2 + 2*idx] = i;
+            }
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+// nonmaxSupression
+
+__kernel
+void FAST_nonmaxSupression(
+    __global const int* kp_in, volatile __global int* kp_out,
+    __global const uchar * _img, int step, int img_offset,
+    int rows, int cols, int counter, int max_keypoints)
+{
+    const int idx = get_global_id(0);
+
+    if (idx < counter)
+    {
+        int x = kp_in[1 + 2*idx];
+        int y = kp_in[2 + 2*idx];
+        __global const uchar* img = _img + mad24(y, step, x + img_offset);
+
+        int s = cornerScore(img, step);
+
+        if( (x < 4 || s > cornerScore(img-1, step)) +
+            (y < 4 || s > cornerScore(img-step, step)) != 2 )
+            return;
+        if( (x >= cols - 4 || s > cornerScore(img+1, step)) +
+            (y >= rows - 4 || s > cornerScore(img+step, step)) +
+            (x < 4 || y < 4 || s > cornerScore(img-step-1, step)) +
+            (x >= cols - 4 || y < 4 || s > cornerScore(img-step+1, step)) +
+            (x < 4 || y >= rows - 4 || s > cornerScore(img+step-1, step)) +
+            (x >= cols - 4 || y >= rows - 4 || s > cornerScore(img+step+1, step)) == 6)
+        {
+            int new_idx = atomic_inc(kp_out);
+            if( new_idx < max_keypoints )
+            {
+                kp_out[1 + 3*new_idx] = x;
+                kp_out[2 + 3*new_idx] = y;
+                kp_out[3 + 3*new_idx] = s;
+            }
+        }
+    }
+}
diff --git a/upstream/opencv/modules/features/src/opencl/gftt.cl b/upstream/opencv/modules/features/src/opencl/gftt.cl
new file mode 100644
index 0000000..736802b
--- /dev/null
+++ b/upstream/opencv/modules/features/src/opencl/gftt.cl
@@ -0,0 +1,161 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Zhang Ying, zhangying913@gmail.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef OP_MAX_EIGEN_VAL
+
+__kernel void maxEigenVal(__global const uchar * srcptr, int src_step, int src_offset, int cols,
+                          int total, __global uchar * dstptr
+#ifdef HAVE_MASK
+                          , __global const uchar * maskptr, int mask_step, int mask_offset
+#endif
+                          )
+{
+    int lid = get_local_id(0);
+    int gid = get_group_id(0);
+    int  id = get_global_id(0);
+
+    __local float localmem_max[WGS2_ALIGNED];
+    float maxval = -FLT_MAX;
+
+    for (int grain = groupnum * WGS; id < total; id += grain)
+    {
+        int src_index = mad24(id / cols, src_step, mad24((id % cols), (int)sizeof(float), src_offset));
+#ifdef HAVE_MASK
+        int mask_index = mad24(id / cols, mask_step, id % cols + mask_offset);
+        if (maskptr[mask_index])
+#endif
+            maxval = max(maxval, *(__global const float *)(srcptr + src_index));
+    }
+
+    if (lid < WGS2_ALIGNED)
+        localmem_max[lid] = maxval;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (lid >= WGS2_ALIGNED && total >= WGS2_ALIGNED)
+        localmem_max[lid - WGS2_ALIGNED] = max(maxval, localmem_max[lid - WGS2_ALIGNED]);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for (int lsize = WGS2_ALIGNED >> 1; lsize > 0; lsize >>= 1)
+    {
+        if (lid < lsize)
+        {
+           int lid2 = lsize + lid;
+           localmem_max[lid] = max(localmem_max[lid], localmem_max[lid2]);
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    if (lid == 0)
+        *(__global float *)(dstptr + (int)sizeof(float) * gid) = localmem_max[0];
+}
+
+__kernel void maxEigenValTask(__global float * dst, float qualityLevel,
+                              __global int * cornersptr)
+{
+    float maxval = -FLT_MAX;
+
+    #pragma unroll
+    for (int x = 0; x < groupnum; ++x)
+        maxval = max(maxval, dst[x]);
+
+    dst[0] = maxval * qualityLevel;
+    cornersptr[0] = 0;
+}
+
+#elif OP_FIND_CORNERS
+
+#define GET_SRC_32F(_y, _x) *(__global const float *)(eigptr + (_y) * eig_step + (_x) * (int)sizeof(float) )
+
+__kernel void findCorners(__global const uchar * eigptr, int eig_step, int eig_offset,
+#ifdef HAVE_MASK
+                          __global const uchar * mask, int mask_step, int mask_offset,
+#endif
+                          __global uchar * cornersptr, int rows, int cols,
+                          __constant float * threshold, int max_corners)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    __global int* counter = (__global int*) cornersptr;
+    __global float2 * corners = (__global float2 *)(cornersptr + (int)sizeof(float2));
+
+    if (y < rows && x < cols
+#ifdef HAVE_MASK
+            && mask[mad24(y, mask_step, x + mask_offset)]
+#endif
+        )
+    {
+        ++x, ++y;
+        float val = GET_SRC_32F(y, x);
+
+        if (val > threshold[0])
+        {
+            float maxVal = val;
+            maxVal = max(GET_SRC_32F(y - 1, x - 1), maxVal);
+            maxVal = max(GET_SRC_32F(y - 1, x    ), maxVal);
+            maxVal = max(GET_SRC_32F(y - 1, x + 1), maxVal);
+
+            maxVal = max(GET_SRC_32F(y    , x - 1), maxVal);
+            maxVal = max(GET_SRC_32F(y    , x + 1), maxVal);
+
+            maxVal = max(GET_SRC_32F(y + 1, x - 1), maxVal);
+            maxVal = max(GET_SRC_32F(y + 1, x    ), maxVal);
+            maxVal = max(GET_SRC_32F(y + 1, x + 1), maxVal);
+
+            if (val == maxVal)
+            {
+                int ind = atomic_inc(counter);
+                if (ind < max_corners)
+                {
+                    // pack and store eigenvalue and its coordinates
+                    corners[ind].x = val;
+                    corners[ind].y = as_float(y | (x << 16));
+                }
+            }
+        }
+    }
+}
+
+#endif
diff --git a/upstream/opencv/modules/features/src/opencl/orb.cl b/upstream/opencv/modules/features/src/opencl/orb.cl
new file mode 100644
index 0000000..3beb43a
--- /dev/null
+++ b/upstream/opencv/modules/features/src/opencl/orb.cl
@@ -0,0 +1,254 @@
+// OpenCL port of the ORB feature detector and descriptor extractor
+// Copyright (C) 2014, Itseez Inc. See the license at http://opencv.org
+//
+// The original code has been contributed by Peter Andreas Entschev, peter@entschev.com
+
+#define LAYERINFO_SIZE 1
+#define LAYERINFO_OFS 0
+#define KEYPOINT_SIZE 3
+#define ORIENTED_KEYPOINT_SIZE 4
+#define KEYPOINT_X 0
+#define KEYPOINT_Y 1
+#define KEYPOINT_Z 2
+#define KEYPOINT_ANGLE 3
+
+/////////////////////////////////////////////////////////////
+
+#ifdef ORB_RESPONSES
+
+__kernel void
+ORB_HarrisResponses(__global const uchar* imgbuf, int imgstep, int imgoffset0,
+                    __global const int* layerinfo, __global const int* keypoints,
+                    __global float* responses, int nkeypoints )
+{
+    int idx = get_global_id(0);
+    if( idx < nkeypoints )
+    {
+        __global const int* kpt = keypoints + idx*KEYPOINT_SIZE;
+        __global const int* layer = layerinfo + kpt[KEYPOINT_Z]*LAYERINFO_SIZE;
+        __global const uchar* img = imgbuf + imgoffset0 + layer[LAYERINFO_OFS] +
+            (kpt[KEYPOINT_Y] - blockSize/2)*imgstep + (kpt[KEYPOINT_X] - blockSize/2);
+
+        int i, j;
+        int a = 0, b = 0, c = 0;
+        for( i = 0; i < blockSize; i++, img += imgstep-blockSize )
+        {
+            for( j = 0; j < blockSize; j++, img++ )
+            {
+                int Ix = (img[1] - img[-1])*2 + img[-imgstep+1] - img[-imgstep-1] + img[imgstep+1] - img[imgstep-1];
+                int Iy = (img[imgstep] - img[-imgstep])*2 + img[imgstep-1] - img[-imgstep-1] + img[imgstep+1] - img[-imgstep+1];
+                a += Ix*Ix;
+                b += Iy*Iy;
+                c += Ix*Iy;
+            }
+        }
+        responses[idx] = ((float)a * b - (float)c * c - HARRIS_K * (float)(a + b) * (a + b))*scale_sq_sq;
+    }
+}
+
+#endif
+
+/////////////////////////////////////////////////////////////
+
+#ifdef ORB_ANGLES
+
+#define _DBL_EPSILON 2.2204460492503131e-16f
+#define atan2_p1 (0.9997878412794807f*57.29577951308232f)
+#define atan2_p3 (-0.3258083974640975f*57.29577951308232f)
+#define atan2_p5 (0.1555786518463281f*57.29577951308232f)
+#define atan2_p7 (-0.04432655554792128f*57.29577951308232f)
+
+inline float fastAtan2( float y, float x )
+{
+    float ax = fabs(x), ay = fabs(y);
+    float a, c, c2;
+    if( ax >= ay )
+    {
+        c = ay/(ax + _DBL_EPSILON);
+        c2 = c*c;
+        a = (((atan2_p7*c2 + atan2_p5)*c2 + atan2_p3)*c2 + atan2_p1)*c;
+    }
+    else
+    {
+        c = ax/(ay + _DBL_EPSILON);
+        c2 = c*c;
+        a = 90.f - (((atan2_p7*c2 + atan2_p5)*c2 + atan2_p3)*c2 + atan2_p1)*c;
+    }
+    if( x < 0 )
+        a = 180.f - a;
+    if( y < 0 )
+        a = 360.f - a;
+    return a;
+}
+
+
+__kernel void
+ORB_ICAngle(__global const uchar* imgbuf, int imgstep, int imgoffset0,
+            __global const int* layerinfo, __global const int* keypoints,
+            __global float* responses, const __global int* u_max,
+            int nkeypoints, int half_k )
+{
+    int idx = get_global_id(0);
+    if( idx < nkeypoints )
+    {
+        __global const int* kpt = keypoints + idx*KEYPOINT_SIZE;
+
+        __global const int* layer = layerinfo + kpt[KEYPOINT_Z]*LAYERINFO_SIZE;
+        __global const uchar* center = imgbuf + imgoffset0 + layer[LAYERINFO_OFS] +
+            kpt[KEYPOINT_Y]*imgstep + kpt[KEYPOINT_X];
+
+        int u, v, m_01 = 0, m_10 = 0;
+
+        // Treat the center line differently, v=0
+        for( u = -half_k; u <= half_k; u++ )
+            m_10 += u * center[u];
+
+        // Go line by line in the circular patch
+        for( v = 1; v <= half_k; v++ )
+        {
+            // Proceed over the two lines
+            int v_sum = 0;
+            int d = u_max[v];
+            for( u = -d; u <= d; u++ )
+            {
+                int val_plus = center[u + v*imgstep], val_minus = center[u - v*imgstep];
+                v_sum += (val_plus - val_minus);
+                m_10 += u * (val_plus + val_minus);
+            }
+            m_01 += v * v_sum;
+        }
+
+        // we do not use OpenCL's atan2 intrinsic,
+        // because we want to get _exactly_ the same results as the CPU version
+        responses[idx] = fastAtan2((float)m_01, (float)m_10);
+    }
+}
+
+#endif
+
+/////////////////////////////////////////////////////////////
+
+#ifdef ORB_DESCRIPTORS
+
+__kernel void
+ORB_computeDescriptor(__global const uchar* imgbuf, int imgstep, int imgoffset0,
+                      __global const int* layerinfo, __global const int* keypoints,
+                      __global uchar* _desc, const __global int* pattern,
+                      int nkeypoints, int dsize )
+{
+    int idx = get_global_id(0);
+    if( idx < nkeypoints )
+    {
+        int i;
+        __global const int* kpt = keypoints + idx*ORIENTED_KEYPOINT_SIZE;
+
+        __global const int* layer = layerinfo + kpt[KEYPOINT_Z]*LAYERINFO_SIZE;
+        __global const uchar* center = imgbuf + imgoffset0 + layer[LAYERINFO_OFS] +
+                                kpt[KEYPOINT_Y]*imgstep + kpt[KEYPOINT_X];
+        float angle = as_float(kpt[KEYPOINT_ANGLE]);
+        angle *= 0.01745329251994329547f;
+
+        float cosa;
+        float sina = sincos(angle, &cosa);
+
+        __global uchar* desc = _desc + idx*dsize;
+
+        #define GET_VALUE(idx) \
+            center[mad24(convert_int_rte(pattern[(idx)*2] * sina + pattern[(idx)*2+1] * cosa), imgstep, \
+                        convert_int_rte(pattern[(idx)*2] * cosa - pattern[(idx)*2+1] * sina))]
+
+        for( i = 0; i < dsize; i++ )
+        {
+            int val;
+        #if WTA_K == 2
+            int t0, t1;
+
+            t0 = GET_VALUE(0); t1 = GET_VALUE(1);
+            val = t0 < t1;
+
+            t0 = GET_VALUE(2); t1 = GET_VALUE(3);
+            val |= (t0 < t1) << 1;
+
+            t0 = GET_VALUE(4); t1 = GET_VALUE(5);
+            val |= (t0 < t1) << 2;
+
+            t0 = GET_VALUE(6); t1 = GET_VALUE(7);
+            val |= (t0 < t1) << 3;
+
+            t0 = GET_VALUE(8); t1 = GET_VALUE(9);
+            val |= (t0 < t1) << 4;
+
+            t0 = GET_VALUE(10); t1 = GET_VALUE(11);
+            val |= (t0 < t1) << 5;
+
+            t0 = GET_VALUE(12); t1 = GET_VALUE(13);
+            val |= (t0 < t1) << 6;
+
+            t0 = GET_VALUE(14); t1 = GET_VALUE(15);
+            val |= (t0 < t1) << 7;
+
+            pattern += 16*2;
+
+        #elif WTA_K == 3
+            int t0, t1, t2;
+
+            t0 = GET_VALUE(0); t1 = GET_VALUE(1); t2 = GET_VALUE(2);
+            val = t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0);
+
+            t0 = GET_VALUE(3); t1 = GET_VALUE(4); t2 = GET_VALUE(5);
+            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 2;
+
+            t0 = GET_VALUE(6); t1 = GET_VALUE(7); t2 = GET_VALUE(8);
+            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 4;
+
+            t0 = GET_VALUE(9); t1 = GET_VALUE(10); t2 = GET_VALUE(11);
+            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 6;
+
+            pattern += 12*2;
+
+        #elif WTA_K == 4
+            int t0, t1, t2, t3, k;
+            int a, b;
+
+            t0 = GET_VALUE(0); t1 = GET_VALUE(1);
+            t2 = GET_VALUE(2); t3 = GET_VALUE(3);
+            a = 0, b = 2;
+            if( t1 > t0 ) t0 = t1, a = 1;
+            if( t3 > t2 ) t2 = t3, b = 3;
+            k = t0 > t2 ? a : b;
+            val = k;
+
+            t0 = GET_VALUE(4); t1 = GET_VALUE(5);
+            t2 = GET_VALUE(6); t3 = GET_VALUE(7);
+            a = 0, b = 2;
+            if( t1 > t0 ) t0 = t1, a = 1;
+            if( t3 > t2 ) t2 = t3, b = 3;
+            k = t0 > t2 ? a : b;
+            val |= k << 2;
+
+            t0 = GET_VALUE(8); t1 = GET_VALUE(9);
+            t2 = GET_VALUE(10); t3 = GET_VALUE(11);
+            a = 0, b = 2;
+            if( t1 > t0 ) t0 = t1, a = 1;
+            if( t3 > t2 ) t2 = t3, b = 3;
+            k = t0 > t2 ? a : b;
+            val |= k << 4;
+
+            t0 = GET_VALUE(12); t1 = GET_VALUE(13);
+            t2 = GET_VALUE(14); t3 = GET_VALUE(15);
+            a = 0, b = 2;
+            if( t1 > t0 ) t0 = t1, a = 1;
+            if( t3 > t2 ) t2 = t3, b = 3;
+            k = t0 > t2 ? a : b;
+            val |= k << 6;
+
+            pattern += 16*2;
+        #else
+            #error "unknown/undefined WTA_K value; should be 2, 3 or 4"
+        #endif
+            desc[i] = (uchar)val;
+        }
+    }
+}
+
+#endif
diff --git a/upstream/opencv/modules/features/src/orb.cpp b/upstream/opencv/modules/features/src/orb.cpp
new file mode 100644
index 0000000..b9dd44f
--- /dev/null
+++ b/upstream/opencv/modules/features/src/orb.cpp
@@ -0,0 +1,1279 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/** Authors: Ethan Rublee, Vincent Rabaud, Gary Bradski */
+
+#include "precomp.hpp"
+#include "opencl_kernels_features.hpp"
+#include <iterator>
+
+#ifndef CV_IMPL_ADD
+#define CV_IMPL_ADD(x)
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace cv
+{
+
+const float HARRIS_K = 0.04f;
+
+template<typename _Tp> inline void copyVectorToUMat(const std::vector<_Tp>& v, OutputArray um)
+{
+    if(v.empty())
+        um.release();
+    else
+        Mat(1, (int)(v.size()*sizeof(v[0])), CV_8U, (void*)&v[0]).copyTo(um);
+}
+
+#ifdef HAVE_OPENCL
+static bool
+ocl_HarrisResponses(const UMat& imgbuf,
+                    const UMat& layerinfo,
+                    const UMat& keypoints,
+                    UMat& responses,
+                    int nkeypoints, int blockSize, float harris_k)
+{
+    size_t globalSize[] = {(size_t)nkeypoints};
+
+    float scale = 1.f/((1 << 2) * blockSize * 255.f);
+    float scale_sq_sq = scale * scale * scale * scale;
+
+    ocl::Kernel hr_ker("ORB_HarrisResponses", ocl::features::orb_oclsrc,
+                format("-D ORB_RESPONSES -D blockSize=%d -D scale_sq_sq=%.12ef -D HARRIS_K=%.12ff", blockSize, scale_sq_sq, harris_k));
+    if( hr_ker.empty() )
+        return false;
+
+    return hr_ker.args(ocl::KernelArg::ReadOnlyNoSize(imgbuf),
+                ocl::KernelArg::PtrReadOnly(layerinfo),
+                ocl::KernelArg::PtrReadOnly(keypoints),
+                ocl::KernelArg::PtrWriteOnly(responses),
+                nkeypoints).run(1, globalSize, 0, true);
+}
+
+static bool
+ocl_ICAngles(const UMat& imgbuf, const UMat& layerinfo,
+             const UMat& keypoints, UMat& responses,
+             const UMat& umax, int nkeypoints, int half_k)
+{
+    size_t globalSize[] = {(size_t)nkeypoints};
+
+    ocl::Kernel icangle_ker("ORB_ICAngle", ocl::features::orb_oclsrc, "-D ORB_ANGLES");
+    if( icangle_ker.empty() )
+        return false;
+
+    return icangle_ker.args(ocl::KernelArg::ReadOnlyNoSize(imgbuf),
+                ocl::KernelArg::PtrReadOnly(layerinfo),
+                ocl::KernelArg::PtrReadOnly(keypoints),
+                ocl::KernelArg::PtrWriteOnly(responses),
+                ocl::KernelArg::PtrReadOnly(umax),
+                nkeypoints, half_k).run(1, globalSize, 0, true);
+}
+
+
+static bool
+ocl_computeOrbDescriptors(const UMat& imgbuf, const UMat& layerInfo,
+                          const UMat& keypoints, UMat& desc, const UMat& pattern,
+                          int nkeypoints, int dsize, int wta_k)
+{
+    size_t globalSize[] = {(size_t)nkeypoints};
+
+    ocl::Kernel desc_ker("ORB_computeDescriptor", ocl::features::orb_oclsrc,
+                         format("-D ORB_DESCRIPTORS -D WTA_K=%d", wta_k));
+    if( desc_ker.empty() )
+        return false;
+
+    return desc_ker.args(ocl::KernelArg::ReadOnlyNoSize(imgbuf),
+                         ocl::KernelArg::PtrReadOnly(layerInfo),
+                         ocl::KernelArg::PtrReadOnly(keypoints),
+                         ocl::KernelArg::PtrWriteOnly(desc),
+                         ocl::KernelArg::PtrReadOnly(pattern),
+                         nkeypoints, dsize).run(1, globalSize, 0, true);
+}
+#endif
+
+/**
+ * Function that computes the Harris responses in a
+ * blockSize x blockSize patch at given points in the image
+ */
+static void
+HarrisResponses(const Mat& img, const std::vector<Rect>& layerinfo,
+                std::vector<KeyPoint>& pts, int blockSize, float harris_k)
+{
+    CV_CheckTypeEQ(img.type(), CV_8UC1, "");
+    CV_CheckGT(blockSize, 0, "");
+    CV_CheckLE(blockSize*blockSize, 2048, "");
+
+    size_t ptidx, ptsize = pts.size();
+
+    const uchar* ptr00 = img.ptr<uchar>();
+    size_t size_t_step = img.step;
+    CV_CheckLE(size_t_step * blockSize + blockSize + 1, (size_t)INT_MAX, "");  // ofs computation, step+1
+    int step = static_cast<int>(size_t_step);
+
+    int r = blockSize/2;
+
+    float scale = 1.f/((1 << 2) * blockSize * 255.f);
+    float scale_sq_sq = scale * scale * scale * scale;
+
+    AutoBuffer<int> ofsbuf(blockSize*blockSize);
+    int* ofs = ofsbuf.data();
+    for( int i = 0; i < blockSize; i++ )
+        for( int j = 0; j < blockSize; j++ )
+            ofs[i*blockSize + j] = (int)(i*step + j);
+
+    for( ptidx = 0; ptidx < ptsize; ptidx++ )
+    {
+        int x0 = cvRound(pts[ptidx].pt.x);
+        int y0 = cvRound(pts[ptidx].pt.y);
+        int z = pts[ptidx].octave;
+
+        const uchar* ptr0 = ptr00 + (y0 - r + layerinfo[z].y)*size_t_step + (x0 - r + layerinfo[z].x);
+        int a = 0, b = 0, c = 0;
+
+        for( int k = 0; k < blockSize*blockSize; k++ )
+        {
+            const uchar* ptr = ptr0 + ofs[k];
+            int Ix = (ptr[1] - ptr[-1])*2 + (ptr[-step+1] - ptr[-step-1]) + (ptr[step+1] - ptr[step-1]);
+            int Iy = (ptr[step] - ptr[-step])*2 + (ptr[step-1] - ptr[-step-1]) + (ptr[step+1] - ptr[-step+1]);
+            a += Ix*Ix;
+            b += Iy*Iy;
+            c += Ix*Iy;
+        }
+        pts[ptidx].response = ((float)a * b - (float)c * c -
+                               harris_k * ((float)a + b) * ((float)a + b))*scale_sq_sq;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void ICAngles(const Mat& img, const std::vector<Rect>& layerinfo,
+                     std::vector<KeyPoint>& pts, const std::vector<int> & u_max, int half_k)
+{
+    int step = (int)img.step1();
+    size_t ptidx, ptsize = pts.size();
+
+    for( ptidx = 0; ptidx < ptsize; ptidx++ )
+    {
+        const Rect& layer = layerinfo[pts[ptidx].octave];
+        const uchar* center = &img.at<uchar>(cvRound(pts[ptidx].pt.y) + layer.y, cvRound(pts[ptidx].pt.x) + layer.x);
+
+        int m_01 = 0, m_10 = 0;
+
+        // Treat the center line differently, v=0
+        for (int u = -half_k; u <= half_k; ++u)
+            m_10 += u * center[u];
+
+        // Go line by line in the circular patch
+        for (int v = 1; v <= half_k; ++v)
+        {
+            // Proceed over the two lines
+            int v_sum = 0;
+            int d = u_max[v];
+            for (int u = -d; u <= d; ++u)
+            {
+                int val_plus = center[u + v*step], val_minus = center[u - v*step];
+                v_sum += (val_plus - val_minus);
+                m_10 += u * (val_plus + val_minus);
+            }
+            m_01 += v * v_sum;
+        }
+
+        pts[ptidx].angle = fastAtan2((float)m_01, (float)m_10);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void
+computeOrbDescriptors( const Mat& imagePyramid, const std::vector<Rect>& layerInfo,
+                       const std::vector<float>& layerScale, std::vector<KeyPoint>& keypoints,
+                       Mat& descriptors, const std::vector<Point>& _pattern, int dsize, int wta_k )
+{
+    int step = (int)imagePyramid.step;
+    int j, i, nkeypoints = (int)keypoints.size();
+
+    for( j = 0; j < nkeypoints; j++ )
+    {
+        const KeyPoint& kpt = keypoints[j];
+        const Rect& layer = layerInfo[kpt.octave];
+        float scale = 1.f/layerScale[kpt.octave];
+        float angle = kpt.angle;
+
+        angle *= (float)(CV_PI/180.f);
+        float a = (float)cos(angle), b = (float)sin(angle);
+
+        const uchar* center = &imagePyramid.at<uchar>(cvRound(kpt.pt.y*scale) + layer.y,
+                                                      cvRound(kpt.pt.x*scale) + layer.x);
+        float x, y;
+        int ix, iy;
+        const Point* pattern = &_pattern[0];
+        uchar* desc = descriptors.ptr<uchar>(j);
+
+    #if 1
+        #define GET_VALUE(idx) \
+               (x = pattern[idx].x*a - pattern[idx].y*b, \
+                y = pattern[idx].x*b + pattern[idx].y*a, \
+                ix = cvRound(x), \
+                iy = cvRound(y), \
+                *(center + iy*step + ix) )
+    #else
+        #define GET_VALUE(idx) \
+            (x = pattern[idx].x*a - pattern[idx].y*b, \
+            y = pattern[idx].x*b + pattern[idx].y*a, \
+            ix = cvFloor(x), iy = cvFloor(y), \
+            x -= ix, y -= iy, \
+            cvRound(center[iy*step + ix]*(1-x)*(1-y) + center[(iy+1)*step + ix]*(1-x)*y + \
+                    center[iy*step + ix+1]*x*(1-y) + center[(iy+1)*step + ix+1]*x*y))
+    #endif
+
+        if( wta_k == 2 )
+        {
+            for (i = 0; i < dsize; ++i, pattern += 16)
+            {
+                int t0, t1, val;
+                t0 = GET_VALUE(0); t1 = GET_VALUE(1);
+                val = t0 < t1;
+                t0 = GET_VALUE(2); t1 = GET_VALUE(3);
+                val |= (t0 < t1) << 1;
+                t0 = GET_VALUE(4); t1 = GET_VALUE(5);
+                val |= (t0 < t1) << 2;
+                t0 = GET_VALUE(6); t1 = GET_VALUE(7);
+                val |= (t0 < t1) << 3;
+                t0 = GET_VALUE(8); t1 = GET_VALUE(9);
+                val |= (t0 < t1) << 4;
+                t0 = GET_VALUE(10); t1 = GET_VALUE(11);
+                val |= (t0 < t1) << 5;
+                t0 = GET_VALUE(12); t1 = GET_VALUE(13);
+                val |= (t0 < t1) << 6;
+                t0 = GET_VALUE(14); t1 = GET_VALUE(15);
+                val |= (t0 < t1) << 7;
+
+                desc[i] = (uchar)val;
+            }
+        }
+        else if( wta_k == 3 )
+        {
+            for (i = 0; i < dsize; ++i, pattern += 12)
+            {
+                int t0, t1, t2, val;
+                t0 = GET_VALUE(0); t1 = GET_VALUE(1); t2 = GET_VALUE(2);
+                val = t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0);
+
+                t0 = GET_VALUE(3); t1 = GET_VALUE(4); t2 = GET_VALUE(5);
+                val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 2;
+
+                t0 = GET_VALUE(6); t1 = GET_VALUE(7); t2 = GET_VALUE(8);
+                val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 4;
+
+                t0 = GET_VALUE(9); t1 = GET_VALUE(10); t2 = GET_VALUE(11);
+                val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 6;
+
+                desc[i] = (uchar)val;
+            }
+        }
+        else if( wta_k == 4 )
+        {
+            for (i = 0; i < dsize; ++i, pattern += 16)
+            {
+                int t0, t1, t2, t3, u, v, k, val;
+                t0 = GET_VALUE(0); t1 = GET_VALUE(1);
+                t2 = GET_VALUE(2); t3 = GET_VALUE(3);
+                u = 0, v = 2;
+                if( t1 > t0 ) t0 = t1, u = 1;
+                if( t3 > t2 ) t2 = t3, v = 3;
+                k = t0 > t2 ? u : v;
+                val = k;
+
+                t0 = GET_VALUE(4); t1 = GET_VALUE(5);
+                t2 = GET_VALUE(6); t3 = GET_VALUE(7);
+                u = 0, v = 2;
+                if( t1 > t0 ) t0 = t1, u = 1;
+                if( t3 > t2 ) t2 = t3, v = 3;
+                k = t0 > t2 ? u : v;
+                val |= k << 2;
+
+                t0 = GET_VALUE(8); t1 = GET_VALUE(9);
+                t2 = GET_VALUE(10); t3 = GET_VALUE(11);
+                u = 0, v = 2;
+                if( t1 > t0 ) t0 = t1, u = 1;
+                if( t3 > t2 ) t2 = t3, v = 3;
+                k = t0 > t2 ? u : v;
+                val |= k << 4;
+
+                t0 = GET_VALUE(12); t1 = GET_VALUE(13);
+                t2 = GET_VALUE(14); t3 = GET_VALUE(15);
+                u = 0, v = 2;
+                if( t1 > t0 ) t0 = t1, u = 1;
+                if( t3 > t2 ) t2 = t3, v = 3;
+                k = t0 > t2 ? u : v;
+                val |= k << 6;
+
+                desc[i] = (uchar)val;
+            }
+        }
+        else
+            CV_Error( Error::StsBadSize, "Wrong wta_k. It can be only 2, 3 or 4." );
+        #undef GET_VALUE
+    }
+}
+
+
+static void initializeOrbPattern( const Point* pattern0, std::vector<Point>& pattern, int ntuples, int tupleSize, int poolSize )
+{
+    RNG rng(0x12345678);
+    int i, k, k1;
+    pattern.resize(ntuples*tupleSize);
+
+    for( i = 0; i < ntuples; i++ )
+    {
+        for( k = 0; k < tupleSize; k++ )
+        {
+            for(;;)
+            {
+                int idx = rng.uniform(0, poolSize);
+                Point pt = pattern0[idx];
+                for( k1 = 0; k1 < k; k1++ )
+                    if( pattern[tupleSize*i + k1] == pt )
+                        break;
+                if( k1 == k )
+                {
+                    pattern[tupleSize*i + k] = pt;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+static int bit_pattern_31_[256*4] =
+{
+    8,-3, 9,5/*mean (0), correlation (0)*/,
+    4,2, 7,-12/*mean (1.12461e-05), correlation (0.0437584)*/,
+    -11,9, -8,2/*mean (3.37382e-05), correlation (0.0617409)*/,
+    7,-12, 12,-13/*mean (5.62303e-05), correlation (0.0636977)*/,
+    2,-13, 2,12/*mean (0.000134953), correlation (0.085099)*/,
+    1,-7, 1,6/*mean (0.000528565), correlation (0.0857175)*/,
+    -2,-10, -2,-4/*mean (0.0188821), correlation (0.0985774)*/,
+    -13,-13, -11,-8/*mean (0.0363135), correlation (0.0899616)*/,
+    -13,-3, -12,-9/*mean (0.121806), correlation (0.099849)*/,
+    10,4, 11,9/*mean (0.122065), correlation (0.093285)*/,
+    -13,-8, -8,-9/*mean (0.162787), correlation (0.0942748)*/,
+    -11,7, -9,12/*mean (0.21561), correlation (0.0974438)*/,
+    7,7, 12,6/*mean (0.160583), correlation (0.130064)*/,
+    -4,-5, -3,0/*mean (0.228171), correlation (0.132998)*/,
+    -13,2, -12,-3/*mean (0.00997526), correlation (0.145926)*/,
+    -9,0, -7,5/*mean (0.198234), correlation (0.143636)*/,
+    12,-6, 12,-1/*mean (0.0676226), correlation (0.16689)*/,
+    -3,6, -2,12/*mean (0.166847), correlation (0.171682)*/,
+    -6,-13, -4,-8/*mean (0.101215), correlation (0.179716)*/,
+    11,-13, 12,-8/*mean (0.200641), correlation (0.192279)*/,
+    4,7, 5,1/*mean (0.205106), correlation (0.186848)*/,
+    5,-3, 10,-3/*mean (0.234908), correlation (0.192319)*/,
+    3,-7, 6,12/*mean (0.0709964), correlation (0.210872)*/,
+    -8,-7, -6,-2/*mean (0.0939834), correlation (0.212589)*/,
+    -2,11, -1,-10/*mean (0.127778), correlation (0.20866)*/,
+    -13,12, -8,10/*mean (0.14783), correlation (0.206356)*/,
+    -7,3, -5,-3/*mean (0.182141), correlation (0.198942)*/,
+    -4,2, -3,7/*mean (0.188237), correlation (0.21384)*/,
+    -10,-12, -6,11/*mean (0.14865), correlation (0.23571)*/,
+    5,-12, 6,-7/*mean (0.222312), correlation (0.23324)*/,
+    5,-6, 7,-1/*mean (0.229082), correlation (0.23389)*/,
+    1,0, 4,-5/*mean (0.241577), correlation (0.215286)*/,
+    9,11, 11,-13/*mean (0.00338507), correlation (0.251373)*/,
+    4,7, 4,12/*mean (0.131005), correlation (0.257622)*/,
+    2,-1, 4,4/*mean (0.152755), correlation (0.255205)*/,
+    -4,-12, -2,7/*mean (0.182771), correlation (0.244867)*/,
+    -8,-5, -7,-10/*mean (0.186898), correlation (0.23901)*/,
+    4,11, 9,12/*mean (0.226226), correlation (0.258255)*/,
+    0,-8, 1,-13/*mean (0.0897886), correlation (0.274827)*/,
+    -13,-2, -8,2/*mean (0.148774), correlation (0.28065)*/,
+    -3,-2, -2,3/*mean (0.153048), correlation (0.283063)*/,
+    -6,9, -4,-9/*mean (0.169523), correlation (0.278248)*/,
+    8,12, 10,7/*mean (0.225337), correlation (0.282851)*/,
+    0,9, 1,3/*mean (0.226687), correlation (0.278734)*/,
+    7,-5, 11,-10/*mean (0.00693882), correlation (0.305161)*/,
+    -13,-6, -11,0/*mean (0.0227283), correlation (0.300181)*/,
+    10,7, 12,1/*mean (0.125517), correlation (0.31089)*/,
+    -6,-3, -6,12/*mean (0.131748), correlation (0.312779)*/,
+    10,-9, 12,-4/*mean (0.144827), correlation (0.292797)*/,
+    -13,8, -8,-12/*mean (0.149202), correlation (0.308918)*/,
+    -13,0, -8,-4/*mean (0.160909), correlation (0.310013)*/,
+    3,3, 7,8/*mean (0.177755), correlation (0.309394)*/,
+    5,7, 10,-7/*mean (0.212337), correlation (0.310315)*/,
+    -1,7, 1,-12/*mean (0.214429), correlation (0.311933)*/,
+    3,-10, 5,6/*mean (0.235807), correlation (0.313104)*/,
+    2,-4, 3,-10/*mean (0.00494827), correlation (0.344948)*/,
+    -13,0, -13,5/*mean (0.0549145), correlation (0.344675)*/,
+    -13,-7, -12,12/*mean (0.103385), correlation (0.342715)*/,
+    -13,3, -11,8/*mean (0.134222), correlation (0.322922)*/,
+    -7,12, -4,7/*mean (0.153284), correlation (0.337061)*/,
+    6,-10, 12,8/*mean (0.154881), correlation (0.329257)*/,
+    -9,-1, -7,-6/*mean (0.200967), correlation (0.33312)*/,
+    -2,-5, 0,12/*mean (0.201518), correlation (0.340635)*/,
+    -12,5, -7,5/*mean (0.207805), correlation (0.335631)*/,
+    3,-10, 8,-13/*mean (0.224438), correlation (0.34504)*/,
+    -7,-7, -4,5/*mean (0.239361), correlation (0.338053)*/,
+    -3,-2, -1,-7/*mean (0.240744), correlation (0.344322)*/,
+    2,9, 5,-11/*mean (0.242949), correlation (0.34145)*/,
+    -11,-13, -5,-13/*mean (0.244028), correlation (0.336861)*/,
+    -1,6, 0,-1/*mean (0.247571), correlation (0.343684)*/,
+    5,-3, 5,2/*mean (0.000697256), correlation (0.357265)*/,
+    -4,-13, -4,12/*mean (0.00213675), correlation (0.373827)*/,
+    -9,-6, -9,6/*mean (0.0126856), correlation (0.373938)*/,
+    -12,-10, -8,-4/*mean (0.0152497), correlation (0.364237)*/,
+    10,2, 12,-3/*mean (0.0299933), correlation (0.345292)*/,
+    7,12, 12,12/*mean (0.0307242), correlation (0.366299)*/,
+    -7,-13, -6,5/*mean (0.0534975), correlation (0.368357)*/,
+    -4,9, -3,4/*mean (0.099865), correlation (0.372276)*/,
+    7,-1, 12,2/*mean (0.117083), correlation (0.364529)*/,
+    -7,6, -5,1/*mean (0.126125), correlation (0.369606)*/,
+    -13,11, -12,5/*mean (0.130364), correlation (0.358502)*/,
+    -3,7, -2,-6/*mean (0.131691), correlation (0.375531)*/,
+    7,-8, 12,-7/*mean (0.160166), correlation (0.379508)*/,
+    -13,-7, -11,-12/*mean (0.167848), correlation (0.353343)*/,
+    1,-3, 12,12/*mean (0.183378), correlation (0.371916)*/,
+    2,-6, 3,0/*mean (0.228711), correlation (0.371761)*/,
+    -4,3, -2,-13/*mean (0.247211), correlation (0.364063)*/,
+    -1,-13, 1,9/*mean (0.249325), correlation (0.378139)*/,
+    7,1, 8,-6/*mean (0.000652272), correlation (0.411682)*/,
+    1,-1, 3,12/*mean (0.00248538), correlation (0.392988)*/,
+    9,1, 12,6/*mean (0.0206815), correlation (0.386106)*/,
+    -1,-9, -1,3/*mean (0.0364485), correlation (0.410752)*/,
+    -13,-13, -10,5/*mean (0.0376068), correlation (0.398374)*/,
+    7,7, 10,12/*mean (0.0424202), correlation (0.405663)*/,
+    12,-5, 12,9/*mean (0.0942645), correlation (0.410422)*/,
+    6,3, 7,11/*mean (0.1074), correlation (0.413224)*/,
+    5,-13, 6,10/*mean (0.109256), correlation (0.408646)*/,
+    2,-12, 2,3/*mean (0.131691), correlation (0.416076)*/,
+    3,8, 4,-6/*mean (0.165081), correlation (0.417569)*/,
+    2,6, 12,-13/*mean (0.171874), correlation (0.408471)*/,
+    9,-12, 10,3/*mean (0.175146), correlation (0.41296)*/,
+    -8,4, -7,9/*mean (0.183682), correlation (0.402956)*/,
+    -11,12, -4,-6/*mean (0.184672), correlation (0.416125)*/,
+    1,12, 2,-8/*mean (0.191487), correlation (0.386696)*/,
+    6,-9, 7,-4/*mean (0.192668), correlation (0.394771)*/,
+    2,3, 3,-2/*mean (0.200157), correlation (0.408303)*/,
+    6,3, 11,0/*mean (0.204588), correlation (0.411762)*/,
+    3,-3, 8,-8/*mean (0.205904), correlation (0.416294)*/,
+    7,8, 9,3/*mean (0.213237), correlation (0.409306)*/,
+    -11,-5, -6,-4/*mean (0.243444), correlation (0.395069)*/,
+    -10,11, -5,10/*mean (0.247672), correlation (0.413392)*/,
+    -5,-8, -3,12/*mean (0.24774), correlation (0.411416)*/,
+    -10,5, -9,0/*mean (0.00213675), correlation (0.454003)*/,
+    8,-1, 12,-6/*mean (0.0293635), correlation (0.455368)*/,
+    4,-6, 6,-11/*mean (0.0404971), correlation (0.457393)*/,
+    -10,12, -8,7/*mean (0.0481107), correlation (0.448364)*/,
+    4,-2, 6,7/*mean (0.050641), correlation (0.455019)*/,
+    -2,0, -2,12/*mean (0.0525978), correlation (0.44338)*/,
+    -5,-8, -5,2/*mean (0.0629667), correlation (0.457096)*/,
+    7,-6, 10,12/*mean (0.0653846), correlation (0.445623)*/,
+    -9,-13, -8,-8/*mean (0.0858749), correlation (0.449789)*/,
+    -5,-13, -5,-2/*mean (0.122402), correlation (0.450201)*/,
+    8,-8, 9,-13/*mean (0.125416), correlation (0.453224)*/,
+    -9,-11, -9,0/*mean (0.130128), correlation (0.458724)*/,
+    1,-8, 1,-2/*mean (0.132467), correlation (0.440133)*/,
+    7,-4, 9,1/*mean (0.132692), correlation (0.454)*/,
+    -2,1, -1,-4/*mean (0.135695), correlation (0.455739)*/,
+    11,-6, 12,-11/*mean (0.142904), correlation (0.446114)*/,
+    -12,-9, -6,4/*mean (0.146165), correlation (0.451473)*/,
+    3,7, 7,12/*mean (0.147627), correlation (0.456643)*/,
+    5,5, 10,8/*mean (0.152901), correlation (0.455036)*/,
+    0,-4, 2,8/*mean (0.167083), correlation (0.459315)*/,
+    -9,12, -5,-13/*mean (0.173234), correlation (0.454706)*/,
+    0,7, 2,12/*mean (0.18312), correlation (0.433855)*/,
+    -1,2, 1,7/*mean (0.185504), correlation (0.443838)*/,
+    5,11, 7,-9/*mean (0.185706), correlation (0.451123)*/,
+    3,5, 6,-8/*mean (0.188968), correlation (0.455808)*/,
+    -13,-4, -8,9/*mean (0.191667), correlation (0.459128)*/,
+    -5,9, -3,-3/*mean (0.193196), correlation (0.458364)*/,
+    -4,-7, -3,-12/*mean (0.196536), correlation (0.455782)*/,
+    6,5, 8,0/*mean (0.1972), correlation (0.450481)*/,
+    -7,6, -6,12/*mean (0.199438), correlation (0.458156)*/,
+    -13,6, -5,-2/*mean (0.211224), correlation (0.449548)*/,
+    1,-10, 3,10/*mean (0.211718), correlation (0.440606)*/,
+    4,1, 8,-4/*mean (0.213034), correlation (0.443177)*/,
+    -2,-2, 2,-13/*mean (0.234334), correlation (0.455304)*/,
+    2,-12, 12,12/*mean (0.235684), correlation (0.443436)*/,
+    -2,-13, 0,-6/*mean (0.237674), correlation (0.452525)*/,
+    4,1, 9,3/*mean (0.23962), correlation (0.444824)*/,
+    -6,-10, -3,-5/*mean (0.248459), correlation (0.439621)*/,
+    -3,-13, -1,1/*mean (0.249505), correlation (0.456666)*/,
+    7,5, 12,-11/*mean (0.00119208), correlation (0.495466)*/,
+    4,-2, 5,-7/*mean (0.00372245), correlation (0.484214)*/,
+    -13,9, -9,-5/*mean (0.00741116), correlation (0.499854)*/,
+    7,1, 8,6/*mean (0.0208952), correlation (0.499773)*/,
+    7,-8, 7,6/*mean (0.0220085), correlation (0.501609)*/,
+    -7,-4, -7,1/*mean (0.0233806), correlation (0.496568)*/,
+    -8,11, -7,-8/*mean (0.0236505), correlation (0.489719)*/,
+    -13,6, -12,-8/*mean (0.0268781), correlation (0.503487)*/,
+    2,4, 3,9/*mean (0.0323324), correlation (0.501938)*/,
+    10,-5, 12,3/*mean (0.0399235), correlation (0.494029)*/,
+    -6,-5, -6,7/*mean (0.0420153), correlation (0.486579)*/,
+    8,-3, 9,-8/*mean (0.0548021), correlation (0.484237)*/,
+    2,-12, 2,8/*mean (0.0616622), correlation (0.496642)*/,
+    -11,-2, -10,3/*mean (0.0627755), correlation (0.498563)*/,
+    -12,-13, -7,-9/*mean (0.0829622), correlation (0.495491)*/,
+    -11,0, -10,-5/*mean (0.0843342), correlation (0.487146)*/,
+    5,-3, 11,8/*mean (0.0929937), correlation (0.502315)*/,
+    -2,-13, -1,12/*mean (0.113327), correlation (0.48941)*/,
+    -1,-8, 0,9/*mean (0.132119), correlation (0.467268)*/,
+    -13,-11, -12,-5/*mean (0.136269), correlation (0.498771)*/,
+    -10,-2, -10,11/*mean (0.142173), correlation (0.498714)*/,
+    -3,9, -2,-13/*mean (0.144141), correlation (0.491973)*/,
+    2,-3, 3,2/*mean (0.14892), correlation (0.500782)*/,
+    -9,-13, -4,0/*mean (0.150371), correlation (0.498211)*/,
+    -4,6, -3,-10/*mean (0.152159), correlation (0.495547)*/,
+    -4,12, -2,-7/*mean (0.156152), correlation (0.496925)*/,
+    -6,-11, -4,9/*mean (0.15749), correlation (0.499222)*/,
+    6,-3, 6,11/*mean (0.159211), correlation (0.503821)*/,
+    -13,11, -5,5/*mean (0.162427), correlation (0.501907)*/,
+    11,11, 12,6/*mean (0.16652), correlation (0.497632)*/,
+    7,-5, 12,-2/*mean (0.169141), correlation (0.484474)*/,
+    -1,12, 0,7/*mean (0.169456), correlation (0.495339)*/,
+    -4,-8, -3,-2/*mean (0.171457), correlation (0.487251)*/,
+    -7,1, -6,7/*mean (0.175), correlation (0.500024)*/,
+    -13,-12, -8,-13/*mean (0.175866), correlation (0.497523)*/,
+    -7,-2, -6,-8/*mean (0.178273), correlation (0.501854)*/,
+    -8,5, -6,-9/*mean (0.181107), correlation (0.494888)*/,
+    -5,-1, -4,5/*mean (0.190227), correlation (0.482557)*/,
+    -13,7, -8,10/*mean (0.196739), correlation (0.496503)*/,
+    1,5, 5,-13/*mean (0.19973), correlation (0.499759)*/,
+    1,0, 10,-13/*mean (0.204465), correlation (0.49873)*/,
+    9,12, 10,-1/*mean (0.209334), correlation (0.49063)*/,
+    5,-8, 10,-9/*mean (0.211134), correlation (0.503011)*/,
+    -1,11, 1,-13/*mean (0.212), correlation (0.499414)*/,
+    -9,-3, -6,2/*mean (0.212168), correlation (0.480739)*/,
+    -1,-10, 1,12/*mean (0.212731), correlation (0.502523)*/,
+    -13,1, -8,-10/*mean (0.21327), correlation (0.489786)*/,
+    8,-11, 10,-6/*mean (0.214159), correlation (0.488246)*/,
+    2,-13, 3,-6/*mean (0.216993), correlation (0.50287)*/,
+    7,-13, 12,-9/*mean (0.223639), correlation (0.470502)*/,
+    -10,-10, -5,-7/*mean (0.224089), correlation (0.500852)*/,
+    -10,-8, -8,-13/*mean (0.228666), correlation (0.502629)*/,
+    4,-6, 8,5/*mean (0.22906), correlation (0.498305)*/,
+    3,12, 8,-13/*mean (0.233378), correlation (0.503825)*/,
+    -4,2, -3,-3/*mean (0.234323), correlation (0.476692)*/,
+    5,-13, 10,-12/*mean (0.236392), correlation (0.475462)*/,
+    4,-13, 5,-1/*mean (0.236842), correlation (0.504132)*/,
+    -9,9, -4,3/*mean (0.236977), correlation (0.497739)*/,
+    0,3, 3,-9/*mean (0.24314), correlation (0.499398)*/,
+    -12,1, -6,1/*mean (0.243297), correlation (0.489447)*/,
+    3,2, 4,-8/*mean (0.00155196), correlation (0.553496)*/,
+    -10,-10, -10,9/*mean (0.00239541), correlation (0.54297)*/,
+    8,-13, 12,12/*mean (0.0034413), correlation (0.544361)*/,
+    -8,-12, -6,-5/*mean (0.003565), correlation (0.551225)*/,
+    2,2, 3,7/*mean (0.00835583), correlation (0.55285)*/,
+    10,6, 11,-8/*mean (0.00885065), correlation (0.540913)*/,
+    6,8, 8,-12/*mean (0.0101552), correlation (0.551085)*/,
+    -7,10, -6,5/*mean (0.0102227), correlation (0.533635)*/,
+    -3,-9, -3,9/*mean (0.0110211), correlation (0.543121)*/,
+    -1,-13, -1,5/*mean (0.0113473), correlation (0.550173)*/,
+    -3,-7, -3,4/*mean (0.0140913), correlation (0.554774)*/,
+    -8,-2, -8,3/*mean (0.017049), correlation (0.55461)*/,
+    4,2, 12,12/*mean (0.01778), correlation (0.546921)*/,
+    2,-5, 3,11/*mean (0.0224022), correlation (0.549667)*/,
+    6,-9, 11,-13/*mean (0.029161), correlation (0.546295)*/,
+    3,-1, 7,12/*mean (0.0303081), correlation (0.548599)*/,
+    11,-1, 12,4/*mean (0.0355151), correlation (0.523943)*/,
+    -3,0, -3,6/*mean (0.0417904), correlation (0.543395)*/,
+    4,-11, 4,12/*mean (0.0487292), correlation (0.542818)*/,
+    2,-4, 2,1/*mean (0.0575124), correlation (0.554888)*/,
+    -10,-6, -8,1/*mean (0.0594242), correlation (0.544026)*/,
+    -13,7, -11,1/*mean (0.0597391), correlation (0.550524)*/,
+    -13,12, -11,-13/*mean (0.0608974), correlation (0.55383)*/,
+    6,0, 11,-13/*mean (0.065126), correlation (0.552006)*/,
+    0,-1, 1,4/*mean (0.074224), correlation (0.546372)*/,
+    -13,3, -9,-2/*mean (0.0808592), correlation (0.554875)*/,
+    -9,8, -6,-3/*mean (0.0883378), correlation (0.551178)*/,
+    -13,-6, -8,-2/*mean (0.0901035), correlation (0.548446)*/,
+    5,-9, 8,10/*mean (0.0949843), correlation (0.554694)*/,
+    2,7, 3,-9/*mean (0.0994152), correlation (0.550979)*/,
+    -1,-6, -1,-1/*mean (0.10045), correlation (0.552714)*/,
+    9,5, 11,-2/*mean (0.100686), correlation (0.552594)*/,
+    11,-3, 12,-8/*mean (0.101091), correlation (0.532394)*/,
+    3,0, 3,5/*mean (0.101147), correlation (0.525576)*/,
+    -1,4, 0,10/*mean (0.105263), correlation (0.531498)*/,
+    3,-6, 4,5/*mean (0.110785), correlation (0.540491)*/,
+    -13,0, -10,5/*mean (0.112798), correlation (0.536582)*/,
+    5,8, 12,11/*mean (0.114181), correlation (0.555793)*/,
+    8,9, 9,-6/*mean (0.117431), correlation (0.553763)*/,
+    7,-4, 8,-12/*mean (0.118522), correlation (0.553452)*/,
+    -10,4, -10,9/*mean (0.12094), correlation (0.554785)*/,
+    7,3, 12,4/*mean (0.122582), correlation (0.555825)*/,
+    9,-7, 10,-2/*mean (0.124978), correlation (0.549846)*/,
+    7,0, 12,-2/*mean (0.127002), correlation (0.537452)*/,
+    -1,-6, 0,-11/*mean (0.127148), correlation (0.547401)*/
+};
+
+
+static void makeRandomPattern(int patchSize, Point* pattern, int npoints)
+{
+    RNG rng(0x34985739); // we always start with a fixed seed,
+                         // to make patterns the same on each run
+    for( int i = 0; i < npoints; i++ )
+    {
+        pattern[i].x = rng.uniform(-patchSize/2, patchSize/2+1);
+        pattern[i].y = rng.uniform(-patchSize/2, patchSize/2+1);
+    }
+}
+
+
+static inline float getScale(int level, int firstLevel, double scaleFactor)
+{
+    return (float)std::pow(scaleFactor, (double)(level - firstLevel));
+}
+
+
+class ORB_Impl CV_FINAL : public ORB
+{
+public:
+    explicit ORB_Impl(int _nfeatures, float _scaleFactor, int _nlevels, int _edgeThreshold,
+             int _firstLevel, int _WTA_K, ORB::ScoreType _scoreType, int _patchSize, int _fastThreshold) :
+        nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels),
+        edgeThreshold(_edgeThreshold), firstLevel(_firstLevel), wta_k(_WTA_K),
+        scoreType(_scoreType), patchSize(_patchSize), fastThreshold(_fastThreshold)
+    {}
+
+    void read( const FileNode& fn) CV_OVERRIDE;
+    void write( FileStorage& fs) const CV_OVERRIDE;
+
+    void setMaxFeatures(int maxFeatures) CV_OVERRIDE { nfeatures = maxFeatures; }
+    int getMaxFeatures() const CV_OVERRIDE { return nfeatures; }
+
+    void setScaleFactor(double scaleFactor_) CV_OVERRIDE { scaleFactor = scaleFactor_; }
+    double getScaleFactor() const CV_OVERRIDE { return scaleFactor; }
+
+    void setNLevels(int nlevels_) CV_OVERRIDE { nlevels = nlevels_; }
+    int getNLevels() const CV_OVERRIDE { return nlevels; }
+
+    void setEdgeThreshold(int edgeThreshold_) CV_OVERRIDE { edgeThreshold = edgeThreshold_; }
+    int getEdgeThreshold() const CV_OVERRIDE { return edgeThreshold; }
+
+    void setFirstLevel(int firstLevel_) CV_OVERRIDE { CV_Assert(firstLevel_ >= 0);  firstLevel = firstLevel_; }
+    int getFirstLevel() const CV_OVERRIDE { return firstLevel; }
+
+    void setWTA_K(int wta_k_) CV_OVERRIDE { wta_k = wta_k_; }
+    int getWTA_K() const CV_OVERRIDE { return wta_k; }
+
+    void setScoreType(ORB::ScoreType scoreType_) CV_OVERRIDE{ scoreType = scoreType_; }
+    ORB::ScoreType getScoreType() const CV_OVERRIDE{ return scoreType; }
+
+    void setPatchSize(int patchSize_) CV_OVERRIDE { patchSize = patchSize_; }
+    int getPatchSize() const CV_OVERRIDE { return patchSize; }
+
+    void setFastThreshold(int fastThreshold_) CV_OVERRIDE { fastThreshold = fastThreshold_; }
+    int getFastThreshold() const CV_OVERRIDE { return fastThreshold; }
+
+    // returns the descriptor size in bytes
+    int descriptorSize() const CV_OVERRIDE;
+    // returns the descriptor type
+    int descriptorType() const CV_OVERRIDE;
+    // returns the default norm type
+    int defaultNorm() const CV_OVERRIDE;
+
+    // Compute the ORB_Impl features and descriptors on an image
+    void detectAndCompute( InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints,
+                     OutputArray descriptors, bool useProvidedKeypoints=false ) CV_OVERRIDE;
+
+protected:
+
+    int nfeatures;
+    double scaleFactor;
+    int nlevels;
+    int edgeThreshold;
+    int firstLevel;
+    int wta_k;
+    ORB::ScoreType scoreType;
+    int patchSize;
+    int fastThreshold;
+};
+
+void ORB_Impl::read( const FileNode& fn)
+{
+  // if node is empty, keep previous value
+  if (!fn["nfeatures"].empty())
+    fn["nfeatures"] >> nfeatures;
+  if (!fn["scaleFactor"].empty())
+    fn["scaleFactor"] >> scaleFactor;
+  if (!fn["nlevels"].empty())
+    fn["nlevels"] >> nlevels;
+  if (!fn["edgeThreshold"].empty())
+    fn["edgeThreshold"] >> edgeThreshold;
+  if (!fn["firstLevel"].empty())
+    fn["firstLevel"] >> firstLevel;
+  if (!fn["wta_k"].empty())
+    fn["wta_k"] >> wta_k;
+  if (!fn["scoreType"].empty())
+    fn["scoreType"] >> scoreType;
+  if (!fn["patchSize"].empty())
+    fn["patchSize"] >> patchSize;
+  if (!fn["fastThreshold"].empty())
+    fn["fastThreshold"] >> fastThreshold;
+}
+void ORB_Impl::write( FileStorage& fs) const
+{
+  if(fs.isOpened())
+  {
+    fs << "name" << getDefaultName();
+    fs << "nfeatures" << nfeatures;
+    fs << "scaleFactor" << scaleFactor;
+    fs << "nlevels" << nlevels;
+    fs << "edgeThreshold" << edgeThreshold;
+    fs << "firstLevel" << firstLevel;
+    fs << "wta_k" << wta_k;
+    fs << "scoreType" << scoreType;
+    fs << "patchSize" << patchSize;
+    fs << "fastThreshold" << fastThreshold;
+  }
+}
+
+int ORB_Impl::descriptorSize() const
+{
+    return kBytes;
+}
+
+int ORB_Impl::descriptorType() const
+{
+    return CV_8U;
+}
+
+int ORB_Impl::defaultNorm() const
+{
+    switch (wta_k)
+    {
+    case 2:
+        return NORM_HAMMING;
+    case 3:
+    case 4:
+        return NORM_HAMMING2;
+    default:
+        return -1;
+    }
+}
+
+#ifdef HAVE_OPENCL
+static void uploadORBKeypoints(const std::vector<KeyPoint>& src, std::vector<Vec3i>& buf, OutputArray dst)
+{
+    size_t i, n = src.size();
+    buf.resize(std::max(buf.size(), n));
+    for( i = 0; i < n; i++ )
+        buf[i] = Vec3i(cvRound(src[i].pt.x), cvRound(src[i].pt.y), src[i].octave);
+    copyVectorToUMat(buf, dst);
+}
+
+typedef union if32_t
+{
+    int i;
+    float f;
+}
+if32_t;
+
+static void uploadORBKeypoints(const std::vector<KeyPoint>& src,
+                               const std::vector<float>& layerScale,
+                               std::vector<Vec4i>& buf, OutputArray dst)
+{
+    size_t i, n = src.size();
+    buf.resize(std::max(buf.size(), n));
+    for( i = 0; i < n; i++ )
+    {
+        int z = src[i].octave;
+        float scale = 1.f/layerScale[z];
+        if32_t angle;
+        angle.f = src[i].angle;
+        buf[i] = Vec4i(cvRound(src[i].pt.x*scale), cvRound(src[i].pt.y*scale), z, angle.i);
+    }
+    copyVectorToUMat(buf, dst);
+}
+#endif
+
+/** Compute the ORB_Impl keypoints on an image
+ * @param image_pyramid the image pyramid to compute the features and descriptors on
+ * @param mask_pyramid the masks to apply at every level
+ * @param keypoints the resulting keypoints, clustered per level
+ */
+static void computeKeyPoints(const Mat& imagePyramid,
+                             const UMat& uimagePyramid,
+                             const Mat& maskPyramid,
+                             const std::vector<Rect>& layerInfo,
+                             const UMat& ulayerInfo,
+                             const std::vector<float>& layerScale,
+                             std::vector<KeyPoint>& allKeypoints,
+                             int nfeatures, double scaleFactor,
+                             int edgeThreshold, int patchSize, ORB::ScoreType scoreType,
+                             bool useOCL, int fastThreshold  )
+{
+#ifndef HAVE_OPENCL
+    CV_UNUSED(uimagePyramid);CV_UNUSED(ulayerInfo);CV_UNUSED(useOCL);
+#endif
+
+    int i, nkeypoints, level, nlevels = (int)layerInfo.size();
+    std::vector<int> nfeaturesPerLevel(nlevels);
+
+    // fill the extractors and descriptors for the corresponding scales
+    float factor = (float)(1.0 / scaleFactor);
+    float ndesiredFeaturesPerScale = nfeatures*(1 - factor)/(1 - (float)std::pow((double)factor, (double)nlevels));
+
+    int sumFeatures = 0;
+    for( level = 0; level < nlevels-1; level++ )
+    {
+        nfeaturesPerLevel[level] = cvRound(ndesiredFeaturesPerScale);
+        sumFeatures += nfeaturesPerLevel[level];
+        ndesiredFeaturesPerScale *= factor;
+    }
+    nfeaturesPerLevel[nlevels-1] = std::max(nfeatures - sumFeatures, 0);
+
+    // Make sure we forget about what is too close to the boundary
+    //edge_threshold_ = std::max(edge_threshold_, patch_size_/2 + kKernelWidth / 2 + 2);
+
+    // pre-compute the end of a row in a circular patch
+    int halfPatchSize = patchSize / 2;
+    std::vector<int> umax(halfPatchSize + 2);
+
+    int v, v0, vmax = cvFloor(halfPatchSize * std::sqrt(2.f) / 2 + 1);
+    int vmin = cvCeil(halfPatchSize * std::sqrt(2.f) / 2);
+    for (v = 0; v <= vmax; ++v)
+        umax[v] = cvRound(std::sqrt((double)halfPatchSize * halfPatchSize - v * v));
+
+    // Make sure we are symmetric
+    for (v = halfPatchSize, v0 = 0; v >= vmin; --v)
+    {
+        while (umax[v0] == umax[v0 + 1])
+            ++v0;
+        umax[v] = v0;
+        ++v0;
+    }
+
+    allKeypoints.clear();
+    std::vector<KeyPoint> keypoints;
+    std::vector<int> counters(nlevels);
+    keypoints.reserve(nfeaturesPerLevel[0]*2);
+
+    for( level = 0; level < nlevels; level++ )
+    {
+        int featuresNum = nfeaturesPerLevel[level];
+        Mat img = imagePyramid(layerInfo[level]);
+        Mat mask = maskPyramid.empty() ? Mat() : maskPyramid(layerInfo[level]);
+
+        // Detect FAST features, 20 is a good threshold
+        {
+        Ptr<FastFeatureDetector> fd = FastFeatureDetector::create(fastThreshold, true);
+        fd->detect(img, keypoints, mask);
+        }
+
+        // Remove keypoints very close to the border
+        KeyPointsFilter::runByImageBorder(keypoints, img.size(), edgeThreshold);
+
+        // Keep more points than necessary as FAST does not give amazing corners
+        KeyPointsFilter::retainBest(keypoints, scoreType == ORB_Impl::HARRIS_SCORE ? 2 * featuresNum : featuresNum);
+
+        nkeypoints = (int)keypoints.size();
+        counters[level] = nkeypoints;
+
+        float sf = layerScale[level];
+        for( i = 0; i < nkeypoints; i++ )
+        {
+            keypoints[i].octave = level;
+            keypoints[i].size = patchSize*sf;
+        }
+
+        std::copy(keypoints.begin(), keypoints.end(), std::back_inserter(allKeypoints));
+    }
+
+    std::vector<Vec3i> ukeypoints_buf;
+
+    nkeypoints = (int)allKeypoints.size();
+    if(nkeypoints == 0)
+    {
+        return;
+    }
+    Mat responses;
+    UMat ukeypoints, uresponses(1, nkeypoints, CV_32F);
+
+    // Select best features using the Harris cornerness (better scoring than FAST)
+    if( scoreType == ORB_Impl::HARRIS_SCORE )
+    {
+#ifdef HAVE_OPENCL
+        if( useOCL )
+        {
+            uploadORBKeypoints(allKeypoints, ukeypoints_buf, ukeypoints);
+            useOCL = ocl_HarrisResponses( uimagePyramid, ulayerInfo, ukeypoints,
+                                          uresponses, nkeypoints, 7, HARRIS_K );
+            if( useOCL )
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                uresponses.copyTo(responses);
+                for( i = 0; i < nkeypoints; i++ )
+                    allKeypoints[i].response = responses.at<float>(i);
+            }
+        }
+
+        if( !useOCL )
+#endif
+            HarrisResponses(imagePyramid, layerInfo, allKeypoints, 7, HARRIS_K);
+
+        std::vector<KeyPoint> newAllKeypoints;
+        newAllKeypoints.reserve(nfeaturesPerLevel[0]*nlevels);
+
+        int offset = 0;
+        for( level = 0; level < nlevels; level++ )
+        {
+            int featuresNum = nfeaturesPerLevel[level];
+            nkeypoints = counters[level];
+            keypoints.resize(nkeypoints);
+            std::copy(allKeypoints.begin() + offset,
+                      allKeypoints.begin() + offset + nkeypoints,
+                      keypoints.begin());
+            offset += nkeypoints;
+
+            //cull to the final desired level, using the new Harris scores.
+            KeyPointsFilter::retainBest(keypoints, featuresNum);
+
+            std::copy(keypoints.begin(), keypoints.end(), std::back_inserter(newAllKeypoints));
+        }
+        std::swap(allKeypoints, newAllKeypoints);
+    }
+
+    nkeypoints = (int)allKeypoints.size();
+
+#ifdef HAVE_OPENCL
+    if( useOCL )
+    {
+        UMat uumax;
+        if( useOCL )
+            copyVectorToUMat(umax, uumax);
+
+        uploadORBKeypoints(allKeypoints, ukeypoints_buf, ukeypoints);
+        useOCL = ocl_ICAngles(uimagePyramid, ulayerInfo, ukeypoints, uresponses, uumax,
+                              nkeypoints, halfPatchSize);
+
+        if( useOCL )
+        {
+            CV_IMPL_ADD(CV_IMPL_OCL);
+            uresponses.copyTo(responses);
+            for( i = 0; i < nkeypoints; i++ )
+                allKeypoints[i].angle = responses.at<float>(i);
+        }
+    }
+
+    if( !useOCL )
+#endif
+    {
+        ICAngles(imagePyramid, layerInfo, allKeypoints, umax, halfPatchSize);
+    }
+
+    for( i = 0; i < nkeypoints; i++ )
+    {
+        float scale = layerScale[allKeypoints[i].octave];
+        allKeypoints[i].pt *= scale;
+    }
+}
+
+
+/** Compute the ORB_Impl features and descriptors on an image
+ * @param img the image to compute the features and descriptors on
+ * @param mask the mask to apply
+ * @param keypoints the resulting keypoints
+ * @param descriptors the resulting descriptors
+ * @param do_keypoints if true, the keypoints are computed, otherwise used as an input
+ * @param do_descriptors if true, also computes the descriptors
+ */
+void ORB_Impl::detectAndCompute( InputArray _image, InputArray _mask,
+                                 std::vector<KeyPoint>& keypoints,
+                                 OutputArray _descriptors, bool useProvidedKeypoints )
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(patchSize >= 2);
+
+    bool do_keypoints = !useProvidedKeypoints;
+    bool do_descriptors = _descriptors.needed();
+
+    if( (!do_keypoints && !do_descriptors) || _image.empty() )
+        return;
+
+    //ROI handling
+    const int HARRIS_BLOCK_SIZE = 9;
+    int halfPatchSize = patchSize / 2;
+    // sqrt(2.0) is for handling patch rotation
+    int descPatchSize = cvCeil(halfPatchSize*sqrt(2.0));
+    int border = std::max(edgeThreshold, std::max(descPatchSize, HARRIS_BLOCK_SIZE/2))+1;
+
+#ifdef HAVE_OPENCL
+    bool useOCL = ocl::isOpenCLActivated() && OCL_FORCE_CHECK(_image.isUMat() || _descriptors.isUMat());
+#else
+    bool useOCL = false;
+#endif
+
+    Mat image = _image.getMat(), mask;
+    if (!_mask.empty())
+    {
+        threshold(_mask, mask, 0, 255, THRESH_BINARY);
+    }
+    if( image.type() != CV_8UC1 )
+        cvtColor(_image, image, COLOR_BGR2GRAY);
+
+    int i, level, nLevels = this->nlevels, nkeypoints = (int)keypoints.size();
+    bool sortedByLevel = true;
+
+    if( !do_keypoints )
+    {
+        // if we have pre-computed keypoints, they may use more levels than it is set in parameters
+        // !!!TODO!!! implement more correct method, independent from the used keypoint detector.
+        // Namely, the detector should provide correct size of each keypoint. Based on the keypoint size
+        // and the algorithm used (i.e. BRIEF, running on 31x31 patches) we should compute the approximate
+        // scale-factor that we need to apply. Then we should cluster all the computed scale-factors and
+        // for each cluster compute the corresponding image.
+        //
+        // In short, ultimately the descriptor should
+        // ignore octave parameter and deal only with the keypoint size.
+        nLevels = 0;
+        for( i = 0; i < nkeypoints; i++ )
+        {
+            level = keypoints[i].octave;
+            CV_Assert(level >= 0);
+            if( i > 0 && level < keypoints[i-1].octave )
+                sortedByLevel = false;
+            nLevels = std::max(nLevels, level);
+        }
+        nLevels++;
+    }
+
+    std::vector<Rect> layerInfo(nLevels);
+    std::vector<int> layerOfs(nLevels);
+    std::vector<float> layerScale(nLevels);
+    Mat imagePyramid, maskPyramid;
+    UMat uimagePyramid, ulayerInfo;
+
+    float level0_inv_scale = 1.0f / getScale(0, firstLevel, scaleFactor);
+    size_t level0_width = (size_t)cvRound(image.cols * level0_inv_scale);
+    size_t level0_height = (size_t)cvRound(image.rows * level0_inv_scale);
+    Size bufSize((int)alignSize(level0_width + border*2, 16), 0);  // TODO change alignment to 64
+
+    int level_dy = (int)level0_height + border*2;
+    Point level_ofs(0, 0);
+
+    for( level = 0; level < nLevels; level++ )
+    {
+        float scale = getScale(level, firstLevel, scaleFactor);
+        layerScale[level] = scale;
+        float inv_scale = 1.0f / scale;
+        Size sz(cvRound(image.cols * inv_scale), cvRound(image.rows * inv_scale));
+        Size wholeSize(sz.width + border*2, sz.height + border*2);
+        if( level_ofs.x + wholeSize.width > bufSize.width )
+        {
+            level_ofs = Point(0, level_ofs.y + level_dy);
+            level_dy = wholeSize.height;
+        }
+
+        Rect linfo(level_ofs.x + border, level_ofs.y + border, sz.width, sz.height);
+        layerInfo[level] = linfo;
+        layerOfs[level] = linfo.y*bufSize.width + linfo.x;
+        level_ofs.x += wholeSize.width;
+    }
+    bufSize.height = level_ofs.y + level_dy;
+
+    imagePyramid.create(bufSize, CV_8U);
+    if( !mask.empty() )
+        maskPyramid.create(bufSize, CV_8U);
+
+    Mat prevImg = image, prevMask = mask;
+
+    // Pre-compute the scale pyramids
+    for (level = 0; level < nLevels; ++level)
+    {
+        Rect linfo = layerInfo[level];
+        Size sz(linfo.width, linfo.height);
+        Size wholeSize(sz.width + border*2, sz.height + border*2);
+        Rect wholeLinfo = Rect(linfo.x - border, linfo.y - border, wholeSize.width, wholeSize.height);
+        Mat extImg = imagePyramid(wholeLinfo), extMask;
+        Mat currImg = extImg(Rect(border, border, sz.width, sz.height)), currMask;
+
+        if( !mask.empty() )
+        {
+            extMask = maskPyramid(wholeLinfo);
+            currMask = extMask(Rect(border, border, sz.width, sz.height));
+        }
+
+        // Compute the resized image
+        if( level != firstLevel )
+        {
+            resize(prevImg, currImg, sz, 0, 0, INTER_LINEAR_EXACT);
+            if( !mask.empty() )
+            {
+                resize(prevMask, currMask, sz, 0, 0, INTER_LINEAR_EXACT);
+                if( level > firstLevel )
+                    threshold(currMask, currMask, 254, 0, THRESH_TOZERO);
+            }
+
+            copyMakeBorder(currImg, extImg, border, border, border, border,
+                           BORDER_REFLECT_101 + BORDER_ISOLATED);
+            if (!mask.empty())
+                copyMakeBorder(currMask, extMask, border, border, border, border,
+                               BORDER_CONSTANT+BORDER_ISOLATED);
+        }
+        else
+        {
+            copyMakeBorder(image, extImg, border, border, border, border,
+                           BORDER_REFLECT_101);
+            if( !mask.empty() )
+                copyMakeBorder(mask, extMask, border, border, border, border,
+                               BORDER_CONSTANT+BORDER_ISOLATED);
+        }
+        if (level > firstLevel)
+        {
+            prevImg = currImg;
+            prevMask = currMask;
+        }
+    }
+
+    if( useOCL )
+        copyVectorToUMat(layerOfs, ulayerInfo);
+
+    if( do_keypoints )
+    {
+        if( useOCL )
+            imagePyramid.copyTo(uimagePyramid);
+
+        // Get keypoints, those will be far enough from the border that no check will be required for the descriptor
+        computeKeyPoints(imagePyramid, uimagePyramid, maskPyramid,
+                         layerInfo, ulayerInfo, layerScale, keypoints,
+                         nfeatures, scaleFactor, edgeThreshold, patchSize, scoreType, useOCL, fastThreshold);
+    }
+    else
+    {
+        KeyPointsFilter::runByImageBorder(keypoints, image.size(), edgeThreshold);
+
+        if( !sortedByLevel )
+        {
+            std::vector<std::vector<KeyPoint> > allKeypoints(nLevels);
+            nkeypoints = (int)keypoints.size();
+            for( i = 0; i < nkeypoints; i++ )
+            {
+                level = keypoints[i].octave;
+                CV_Assert(0 <= level);
+                allKeypoints[level].push_back(keypoints[i]);
+            }
+            keypoints.clear();
+            for( level = 0; level < nLevels; level++ )
+                std::copy(allKeypoints[level].begin(), allKeypoints[level].end(), std::back_inserter(keypoints));
+        }
+    }
+
+    if( do_descriptors )
+    {
+        int dsize = descriptorSize();
+
+        nkeypoints = (int)keypoints.size();
+        if( nkeypoints == 0 )
+        {
+            _descriptors.release();
+            return;
+        }
+
+        _descriptors.create(nkeypoints, dsize, CV_8U);
+        std::vector<Point> pattern;
+
+        const int npoints = 512;
+        Point patternbuf[npoints];
+        const Point* pattern0 = (const Point*)bit_pattern_31_;
+
+        if( patchSize != 31 )
+        {
+            pattern0 = patternbuf;
+            makeRandomPattern(patchSize, patternbuf, npoints);
+        }
+
+        CV_Assert( wta_k == 2 || wta_k == 3 || wta_k == 4 );
+
+        if( wta_k == 2 )
+            std::copy(pattern0, pattern0 + npoints, std::back_inserter(pattern));
+        else
+        {
+            int ntuples = descriptorSize()*4;
+            initializeOrbPattern(pattern0, pattern, ntuples, wta_k, npoints);
+        }
+
+        for( level = 0; level < nLevels; level++ )
+        {
+            // preprocess the resized image
+            Mat workingMat = imagePyramid(layerInfo[level]);
+
+            //boxFilter(working_mat, working_mat, working_mat.depth(), Size(5,5), Point(-1,-1), true, BORDER_REFLECT_101);
+            GaussianBlur(workingMat, workingMat, Size(7, 7), 2, 2, BORDER_REFLECT_101);
+        }
+
+#ifdef HAVE_OPENCL
+        if( useOCL )
+        {
+            imagePyramid.copyTo(uimagePyramid);
+            std::vector<Vec4i> kptbuf;
+            UMat ukeypoints, upattern;
+            copyVectorToUMat(pattern, upattern);
+            uploadORBKeypoints(keypoints, layerScale, kptbuf, ukeypoints);
+
+            UMat udescriptors = _descriptors.getUMat();
+            useOCL = ocl_computeOrbDescriptors(uimagePyramid, ulayerInfo,
+                                               ukeypoints, udescriptors, upattern,
+                                               nkeypoints, dsize, wta_k);
+            if(useOCL)
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+            }
+        }
+
+        if( !useOCL )
+#endif
+        {
+            Mat descriptors = _descriptors.getMat();
+            computeOrbDescriptors(imagePyramid, layerInfo, layerScale,
+                                  keypoints, descriptors, pattern, dsize, wta_k);
+        }
+    }
+}
+
+Ptr<ORB> ORB::create(int nfeatures, float scaleFactor, int nlevels, int edgeThreshold,
+           int firstLevel, int wta_k, ORB::ScoreType scoreType, int patchSize, int fastThreshold)
+{
+    CV_Assert(firstLevel >= 0);
+    return makePtr<ORB_Impl>(nfeatures, scaleFactor, nlevels, edgeThreshold,
+                             firstLevel, wta_k, scoreType, patchSize, fastThreshold);
+}
+
+String ORB::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".ORB");
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/precomp.hpp b/upstream/opencv/modules/features/src/precomp.hpp
new file mode 100644
index 0000000..6c0b6ec
--- /dev/null
+++ b/upstream/opencv/modules/features/src/precomp.hpp
@@ -0,0 +1,61 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/features.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/geometry.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/hal/hal.hpp"
+
+#include <algorithm>
+
+#endif
diff --git a/upstream/opencv/modules/features/src/sift.dispatch.cpp b/upstream/opencv/modules/features/src/sift.dispatch.cpp
new file mode 100644
index 0000000..3f4a7ce
--- /dev/null
+++ b/upstream/opencv/modules/features/src/sift.dispatch.cpp
@@ -0,0 +1,622 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+
+/**********************************************************************************************\
+ Implementation of SIFT is based on the code from http://blogs.oregonstate.edu/hess/code/sift/
+ Below is the original copyright.
+ Patent US6711293 expired in March 2020.
+
+//    Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+//    All rights reserved.
+
+//    The following patent has been issued for methods embodied in this
+//    software: "Method and apparatus for identifying scale invariant features
+//    in an image and use of same for locating an object in an image," David
+//    G. Lowe, US Patent 6,711,293 (March 23, 2004). Provisional application
+//    filed March 8, 1999. Assignee: The University of British Columbia. For
+//    further details, contact David Lowe (lowe@cs.ubc.ca) or the
+//    University-Industry Liaison Office of the University of British
+//    Columbia.
+
+//    Note that restrictions imposed by this patent (and possibly others)
+//    exist independently of and may be in conflict with the freedoms granted
+//    in this license, which refers to copyright of the program, not patents
+//    for any methods that it implements.  Both copyright and patent law must
+//    be obeyed to legally use and redistribute this program and it is not the
+//    purpose of this license to induce you to infringe any patents or other
+//    property right claims or to contest validity of any such claims.  If you
+//    redistribute or use the program, then this license merely protects you
+//    from committing copyright infringement.  It does not protect you from
+//    committing patent infringement.  So, before you do anything with this
+//    program, make sure that you have permission to do so not merely in terms
+//    of copyright, but also in terms of patent law.
+
+//    Please note that this license is not to be understood as a guarantee
+//    either.  If you use the program according to this license, but in
+//    conflict with patent law, it does not mean that the licensor will refund
+//    you for any losses that you incur if you are sued for your patent
+//    infringement.
+
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
+//    met:
+//        * Redistributions of source code must retain the above copyright and
+//          patent notices, this list of conditions and the following
+//          disclaimer.
+//        * Redistributions in binary form must reproduce the above copyright
+//          notice, this list of conditions and the following disclaimer in
+//          the documentation and/or other materials provided with the
+//          distribution.
+//        * Neither the name of Oregon State University nor the names of its
+//          contributors may be used to endorse or promote products derived
+//          from this software without specific prior written permission.
+
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+//    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+//    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\**********************************************************************************************/
+
+#include "precomp.hpp"
+#include <opencv2/core/hal/hal.hpp>
+#include <opencv2/core/utils/tls.hpp>
+#include <opencv2/core/utils/logger.hpp>
+
+#include "sift.simd.hpp"
+#include "sift.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content
+
+namespace cv {
+
+/*!
+ SIFT implementation.
+
+ The class implements SIFT algorithm by D. Lowe.
+ */
+class SIFT_Impl : public SIFT
+{
+public:
+    explicit SIFT_Impl( int nfeatures = 0, int nOctaveLayers = 3,
+                          double contrastThreshold = 0.04, double edgeThreshold = 10,
+                          double sigma = 1.6, int descriptorType = CV_32F,
+                          bool enable_precise_upscale = true );
+
+    //! returns the descriptor size in floats (128)
+    int descriptorSize() const CV_OVERRIDE;
+
+    //! returns the descriptor type
+    int descriptorType() const CV_OVERRIDE;
+
+    //! returns the default norm type
+    int defaultNorm() const CV_OVERRIDE;
+
+    //! finds the keypoints and computes descriptors for them using SIFT algorithm.
+    //! Optionally it can compute descriptors for the user-provided keypoints
+    void detectAndCompute(InputArray img, InputArray mask,
+                    std::vector<KeyPoint>& keypoints,
+                    OutputArray descriptors,
+                    bool useProvidedKeypoints = false) CV_OVERRIDE;
+
+    void buildGaussianPyramid( const Mat& base, std::vector<Mat>& pyr, int nOctaves ) const;
+    void buildDoGPyramid( const std::vector<Mat>& pyr, std::vector<Mat>& dogpyr ) const;
+    void findScaleSpaceExtrema( const std::vector<Mat>& gauss_pyr, const std::vector<Mat>& dog_pyr,
+                               std::vector<KeyPoint>& keypoints ) const;
+
+    void read( const FileNode& fn) CV_OVERRIDE;
+    void write( FileStorage& fs) const CV_OVERRIDE;
+
+    void setNFeatures(int maxFeatures) CV_OVERRIDE { nfeatures = maxFeatures; }
+    int getNFeatures() const CV_OVERRIDE { return nfeatures; }
+
+    void setNOctaveLayers(int nOctaveLayers_) CV_OVERRIDE { nOctaveLayers = nOctaveLayers_; }
+    int getNOctaveLayers() const CV_OVERRIDE { return nOctaveLayers; }
+
+    void setContrastThreshold(double contrastThreshold_) CV_OVERRIDE  { contrastThreshold = contrastThreshold_; }
+    double getContrastThreshold() const CV_OVERRIDE { return contrastThreshold; }
+
+    void setEdgeThreshold(double edgeThreshold_) CV_OVERRIDE  { edgeThreshold = edgeThreshold_; }
+    double getEdgeThreshold() const CV_OVERRIDE { return edgeThreshold; }
+
+    void setSigma(double sigma_) CV_OVERRIDE  { sigma = sigma_; }
+    double getSigma() const CV_OVERRIDE { return sigma; }
+
+protected:
+    CV_PROP_RW int nfeatures;
+    CV_PROP_RW int nOctaveLayers;
+    CV_PROP_RW double contrastThreshold;
+    CV_PROP_RW double edgeThreshold;
+    CV_PROP_RW double sigma;
+    CV_PROP_RW int descriptor_type;
+    CV_PROP_RW bool enable_precise_upscale;
+};
+
+Ptr<SIFT> SIFT::create( int _nfeatures, int _nOctaveLayers,
+                     double _contrastThreshold, double _edgeThreshold, double _sigma, bool enable_precise_upscale )
+{
+    CV_TRACE_FUNCTION();
+
+    return makePtr<SIFT_Impl>(_nfeatures, _nOctaveLayers, _contrastThreshold, _edgeThreshold, _sigma, CV_32F, enable_precise_upscale);
+}
+
+Ptr<SIFT> SIFT::create( int _nfeatures, int _nOctaveLayers,
+                     double _contrastThreshold, double _edgeThreshold, double _sigma, int _descriptorType, bool enable_precise_upscale )
+{
+    CV_TRACE_FUNCTION();
+
+    // SIFT descriptor supports 32bit floating point and 8bit unsigned int.
+    CV_Assert(_descriptorType == CV_32F || _descriptorType == CV_8U);
+    return makePtr<SIFT_Impl>(_nfeatures, _nOctaveLayers, _contrastThreshold, _edgeThreshold, _sigma, _descriptorType, enable_precise_upscale);
+}
+
+String SIFT::getDefaultName() const
+{
+    return (Feature2D::getDefaultName() + ".SIFT");
+}
+
+static inline void
+unpackOctave(const KeyPoint& kpt, int& octave, int& layer, float& scale)
+{
+    octave = kpt.octave & 255;
+    layer = (kpt.octave >> 8) & 255;
+    octave = octave < 128 ? octave : (-128 | octave);
+    scale = octave >= 0 ? 1.f/(1 << octave) : (float)(1 << -octave);
+}
+
+static Mat createInitialImage( const Mat& img, bool doubleImageSize, float sigma, bool enable_precise_upscale )
+{
+    CV_TRACE_FUNCTION();
+
+    Mat gray, gray_fpt;
+    if( img.channels() == 3 || img.channels() == 4 )
+    {
+        cvtColor(img, gray, COLOR_BGR2GRAY);
+        gray.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);
+    }
+    else
+        img.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);
+
+    float sig_diff;
+
+    if( doubleImageSize )
+    {
+        sig_diff = sqrtf( std::max(sigma * sigma - SIFT_INIT_SIGMA * SIFT_INIT_SIGMA * 4, 0.01f) );
+
+        Mat dbl;
+        if (enable_precise_upscale) {
+            dbl.create(Size(gray_fpt.cols*2, gray_fpt.rows*2), gray_fpt.type());
+            Mat H = Mat::zeros(2, 3, CV_32F);
+            H.at<float>(0, 0) = 0.5f;
+            H.at<float>(1, 1) = 0.5f;
+
+            cv::warpAffine(gray_fpt, dbl, H, dbl.size(), INTER_LINEAR | WARP_INVERSE_MAP, BORDER_REFLECT);
+        } else {
+#if DoG_TYPE_SHORT
+            resize(gray_fpt, dbl, Size(gray_fpt.cols*2, gray_fpt.rows*2), 0, 0, INTER_LINEAR_EXACT);
+#else
+            resize(gray_fpt, dbl, Size(gray_fpt.cols*2, gray_fpt.rows*2), 0, 0, INTER_LINEAR);
+#endif
+        }
+        Mat result;
+        GaussianBlur(dbl, result, Size(), sig_diff, sig_diff);
+        return result;
+    }
+    else
+    {
+        sig_diff = sqrtf( std::max(sigma * sigma - SIFT_INIT_SIGMA * SIFT_INIT_SIGMA, 0.01f) );
+        Mat result;
+        GaussianBlur(gray_fpt, result, Size(), sig_diff, sig_diff);
+        return result;
+    }
+}
+
+
+void SIFT_Impl::buildGaussianPyramid( const Mat& base, std::vector<Mat>& pyr, int nOctaves ) const
+{
+    CV_TRACE_FUNCTION();
+
+    std::vector<double> sig(nOctaveLayers + 3);
+    pyr.resize(nOctaves*(nOctaveLayers + 3));
+
+    // precompute Gaussian sigmas using the following formula:
+    //  \sigma_{total}^2 = \sigma_{i}^2 + \sigma_{i-1}^2
+    sig[0] = sigma;
+    double k = std::pow( 2, 1. / nOctaveLayers );
+    for( int i = 1; i < nOctaveLayers + 3; i++ )
+    {
+        double sig_prev = (double)std::pow(k, i-1)*sigma;
+        double sig_total = sig_prev*k;
+        sig[i] = std::sqrt(sig_total*sig_total - sig_prev*sig_prev);
+    }
+
+    for( int o = 0; o < nOctaves; o++ )
+    {
+        for( int i = 0; i < nOctaveLayers + 3; i++ )
+        {
+            Mat& dst = pyr[o*(nOctaveLayers + 3) + i];
+            if( o == 0  &&  i == 0 )
+                dst = base;
+            // base of new octave is halved image from end of previous octave
+            else if( i == 0 )
+            {
+                const Mat& src = pyr[(o-1)*(nOctaveLayers + 3) + nOctaveLayers];
+                resize(src, dst, Size(src.cols/2, src.rows/2),
+                       0, 0, INTER_NEAREST);
+            }
+            else
+            {
+                const Mat& src = pyr[o*(nOctaveLayers + 3) + i-1];
+                GaussianBlur(src, dst, Size(), sig[i], sig[i]);
+            }
+        }
+    }
+}
+
+
+class buildDoGPyramidComputer : public ParallelLoopBody
+{
+public:
+    buildDoGPyramidComputer(
+        int _nOctaveLayers,
+        const std::vector<Mat>& _gpyr,
+        std::vector<Mat>& _dogpyr)
+        : nOctaveLayers(_nOctaveLayers),
+          gpyr(_gpyr),
+          dogpyr(_dogpyr) { }
+
+    void operator()( const cv::Range& range ) const CV_OVERRIDE
+    {
+        CV_TRACE_FUNCTION();
+
+        const int begin = range.start;
+        const int end = range.end;
+
+        for( int a = begin; a < end; a++ )
+        {
+            const int o = a / (nOctaveLayers + 2);
+            const int i = a % (nOctaveLayers + 2);
+
+            const Mat& src1 = gpyr[o*(nOctaveLayers + 3) + i];
+            const Mat& src2 = gpyr[o*(nOctaveLayers + 3) + i + 1];
+            Mat& dst = dogpyr[o*(nOctaveLayers + 2) + i];
+            subtract(src2, src1, dst, noArray(), DataType<sift_wt>::type);
+        }
+    }
+
+private:
+    int nOctaveLayers;
+    const std::vector<Mat>& gpyr;
+    std::vector<Mat>& dogpyr;
+};
+
+void SIFT_Impl::buildDoGPyramid( const std::vector<Mat>& gpyr, std::vector<Mat>& dogpyr ) const
+{
+    CV_TRACE_FUNCTION();
+
+    int nOctaves = (int)gpyr.size()/(nOctaveLayers + 3);
+    dogpyr.resize( nOctaves*(nOctaveLayers + 2) );
+
+    parallel_for_(Range(0, nOctaves * (nOctaveLayers + 2)), buildDoGPyramidComputer(nOctaveLayers, gpyr, dogpyr));
+}
+
+class findScaleSpaceExtremaComputer : public ParallelLoopBody
+{
+public:
+    findScaleSpaceExtremaComputer(
+        int _o,
+        int _i,
+        int _threshold,
+        int _idx,
+        int _step,
+        int _cols,
+        int _nOctaveLayers,
+        double _contrastThreshold,
+        double _edgeThreshold,
+        double _sigma,
+        const std::vector<Mat>& _gauss_pyr,
+        const std::vector<Mat>& _dog_pyr,
+        TLSData<std::vector<KeyPoint> > &_tls_kpts_struct)
+
+        : o(_o),
+          i(_i),
+          threshold(_threshold),
+          idx(_idx),
+          step(_step),
+          cols(_cols),
+          nOctaveLayers(_nOctaveLayers),
+          contrastThreshold(_contrastThreshold),
+          edgeThreshold(_edgeThreshold),
+          sigma(_sigma),
+          gauss_pyr(_gauss_pyr),
+          dog_pyr(_dog_pyr),
+          tls_kpts_struct(_tls_kpts_struct) { }
+    void operator()( const cv::Range& range ) const CV_OVERRIDE
+    {
+        CV_TRACE_FUNCTION();
+
+        std::vector<KeyPoint>& kpts = tls_kpts_struct.getRef();
+
+        CV_CPU_DISPATCH(findScaleSpaceExtrema, (o, i, threshold, idx, step, cols, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, gauss_pyr, dog_pyr, kpts, range),
+            CV_CPU_DISPATCH_MODES_ALL);
+    }
+private:
+    int o, i;
+    int threshold;
+    int idx, step, cols;
+    int nOctaveLayers;
+    double contrastThreshold;
+    double edgeThreshold;
+    double sigma;
+    const std::vector<Mat>& gauss_pyr;
+    const std::vector<Mat>& dog_pyr;
+    TLSData<std::vector<KeyPoint> > &tls_kpts_struct;
+};
+
+//
+// Detects features at extrema in DoG scale space.  Bad features are discarded
+// based on contrast and ratio of principal curvatures.
+void SIFT_Impl::findScaleSpaceExtrema( const std::vector<Mat>& gauss_pyr, const std::vector<Mat>& dog_pyr,
+                                  std::vector<KeyPoint>& keypoints ) const
+{
+    CV_TRACE_FUNCTION();
+
+    const int nOctaves = (int)gauss_pyr.size()/(nOctaveLayers + 3);
+    const int threshold = cvFloor(0.5 * contrastThreshold / nOctaveLayers * 255 * SIFT_FIXPT_SCALE);
+
+    keypoints.clear();
+    TLSDataAccumulator<std::vector<KeyPoint> > tls_kpts_struct;
+
+    for( int o = 0; o < nOctaves; o++ )
+        for( int i = 1; i <= nOctaveLayers; i++ )
+        {
+            const int idx = o*(nOctaveLayers+2)+i;
+            const Mat& img = dog_pyr[idx];
+            const int step = (int)img.step1();
+            const int rows = img.rows, cols = img.cols;
+
+            parallel_for_(Range(SIFT_IMG_BORDER, rows-SIFT_IMG_BORDER),
+                findScaleSpaceExtremaComputer(
+                    o, i, threshold, idx, step, cols,
+                    nOctaveLayers,
+                    contrastThreshold,
+                    edgeThreshold,
+                    sigma,
+                    gauss_pyr, dog_pyr, tls_kpts_struct));
+        }
+
+    std::vector<std::vector<KeyPoint>*> kpt_vecs;
+    tls_kpts_struct.gather(kpt_vecs);
+    for (size_t i = 0; i < kpt_vecs.size(); ++i) {
+        keypoints.insert(keypoints.end(), kpt_vecs[i]->begin(), kpt_vecs[i]->end());
+    }
+}
+
+
+static
+void calcSIFTDescriptor(
+        const Mat& img, Point2f ptf, float ori, float scl,
+        int d, int n, Mat& dst, int row
+)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_CPU_DISPATCH(calcSIFTDescriptor, (img, ptf, ori, scl, d, n, dst, row),
+        CV_CPU_DISPATCH_MODES_ALL);
+}
+
+class calcDescriptorsComputer : public ParallelLoopBody
+{
+public:
+    calcDescriptorsComputer(const std::vector<Mat>& _gpyr,
+                            const std::vector<KeyPoint>& _keypoints,
+                            Mat& _descriptors,
+                            int _nOctaveLayers,
+                            int _firstOctave)
+        : gpyr(_gpyr),
+          keypoints(_keypoints),
+          descriptors(_descriptors),
+          nOctaveLayers(_nOctaveLayers),
+          firstOctave(_firstOctave) { }
+
+    void operator()( const cv::Range& range ) const CV_OVERRIDE
+    {
+        CV_TRACE_FUNCTION();
+
+        const int begin = range.start;
+        const int end = range.end;
+
+        static const int d = SIFT_DESCR_WIDTH, n = SIFT_DESCR_HIST_BINS;
+
+        for ( int i = begin; i<end; i++ )
+        {
+            KeyPoint kpt = keypoints[i];
+            int octave, layer;
+            float scale;
+            unpackOctave(kpt, octave, layer, scale);
+            CV_Assert(octave >= firstOctave && layer <= nOctaveLayers+2);
+            float size=kpt.size*scale;
+            Point2f ptf(kpt.pt.x*scale, kpt.pt.y*scale);
+            const Mat& img = gpyr[(octave - firstOctave)*(nOctaveLayers + 3) + layer];
+
+            float angle = 360.f - kpt.angle;
+            if(std::abs(angle - 360.f) < FLT_EPSILON)
+                angle = 0.f;
+            calcSIFTDescriptor(img, ptf, angle, size*0.5f, d, n, descriptors, i);
+        }
+    }
+private:
+    const std::vector<Mat>& gpyr;
+    const std::vector<KeyPoint>& keypoints;
+    Mat& descriptors;
+    int nOctaveLayers;
+    int firstOctave;
+};
+
+static void calcDescriptors(const std::vector<Mat>& gpyr, const std::vector<KeyPoint>& keypoints,
+                            Mat& descriptors, int nOctaveLayers, int firstOctave )
+{
+    CV_TRACE_FUNCTION();
+    parallel_for_(Range(0, static_cast<int>(keypoints.size())), calcDescriptorsComputer(gpyr, keypoints, descriptors, nOctaveLayers, firstOctave));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+SIFT_Impl::SIFT_Impl( int _nfeatures, int _nOctaveLayers,
+           double _contrastThreshold, double _edgeThreshold, double _sigma, int _descriptorType, bool _enable_precise_upscale)
+    : nfeatures(_nfeatures), nOctaveLayers(_nOctaveLayers),
+    contrastThreshold(_contrastThreshold), edgeThreshold(_edgeThreshold), sigma(_sigma), descriptor_type(_descriptorType),
+    enable_precise_upscale(_enable_precise_upscale)
+{
+    if (!enable_precise_upscale) {
+        CV_LOG_ONCE_INFO(NULL, "precise upscale disabled, this is now deprecated as it was found to induce a location bias");
+    }
+}
+
+int SIFT_Impl::descriptorSize() const
+{
+    return SIFT_DESCR_WIDTH*SIFT_DESCR_WIDTH*SIFT_DESCR_HIST_BINS;
+}
+
+int SIFT_Impl::descriptorType() const
+{
+    return descriptor_type;
+}
+
+int SIFT_Impl::defaultNorm() const
+{
+    return NORM_L2;
+}
+
+
+void SIFT_Impl::detectAndCompute(InputArray _image, InputArray _mask,
+                      std::vector<KeyPoint>& keypoints,
+                      OutputArray _descriptors,
+                      bool useProvidedKeypoints)
+{
+    CV_TRACE_FUNCTION();
+
+    int firstOctave = -1, actualNOctaves = 0, actualNLayers = 0;
+    Mat image = _image.getMat(), mask = _mask.getMat();
+
+    if( image.empty() || image.depth() != CV_8U )
+        CV_Error( Error::StsBadArg, "image is empty or has incorrect depth (!=CV_8U)" );
+
+    if( !mask.empty() && mask.type() != CV_8UC1 )
+        CV_Error( Error::StsBadArg, "mask has incorrect type (!=CV_8UC1)" );
+
+    if( useProvidedKeypoints )
+    {
+        firstOctave = 0;
+        int maxOctave = INT_MIN;
+        for( size_t i = 0; i < keypoints.size(); i++ )
+        {
+            int octave, layer;
+            float scale;
+            unpackOctave(keypoints[i], octave, layer, scale);
+            firstOctave = std::min(firstOctave, octave);
+            maxOctave = std::max(maxOctave, octave);
+            actualNLayers = std::max(actualNLayers, layer-2);
+        }
+
+        firstOctave = std::min(firstOctave, 0);
+        CV_Assert( firstOctave >= -1 && actualNLayers <= nOctaveLayers );
+        actualNOctaves = maxOctave - firstOctave + 1;
+    }
+
+    Mat base = createInitialImage(image, firstOctave < 0, (float)sigma, enable_precise_upscale);
+    std::vector<Mat> gpyr;
+    int nOctaves = actualNOctaves > 0 ? actualNOctaves : cvRound(std::log( (double)std::min( base.cols, base.rows ) ) / std::log(2.) - 2) - firstOctave;
+
+    //double t, tf = getTickFrequency();
+    //t = (double)getTickCount();
+    buildGaussianPyramid(base, gpyr, nOctaves);
+
+    //t = (double)getTickCount() - t;
+    //printf("pyramid construction time: %g\n", t*1000./tf);
+
+    if( !useProvidedKeypoints )
+    {
+        std::vector<Mat> dogpyr;
+        buildDoGPyramid(gpyr, dogpyr);
+        //t = (double)getTickCount();
+        findScaleSpaceExtrema(gpyr, dogpyr, keypoints);
+        KeyPointsFilter::removeDuplicatedSorted( keypoints );
+
+        if( nfeatures > 0 )
+            KeyPointsFilter::retainBest(keypoints, nfeatures);
+        //t = (double)getTickCount() - t;
+        //printf("keypoint detection time: %g\n", t*1000./tf);
+
+        if( firstOctave < 0 )
+            for( size_t i = 0; i < keypoints.size(); i++ )
+            {
+                KeyPoint& kpt = keypoints[i];
+                float scale = 1.f/(float)(1 << -firstOctave);
+                kpt.octave = (kpt.octave & ~255) | ((kpt.octave + firstOctave) & 255);
+                kpt.pt *= scale;
+                kpt.size *= scale;
+            }
+
+        if( !mask.empty() )
+            KeyPointsFilter::runByPixelsMask( keypoints, mask );
+    }
+    else
+    {
+        // filter keypoints by mask
+        //KeyPointsFilter::runByPixelsMask( keypoints, mask );
+    }
+
+    if( _descriptors.needed() )
+    {
+        //t = (double)getTickCount();
+        int dsize = descriptorSize();
+        _descriptors.create((int)keypoints.size(), dsize, descriptor_type);
+
+        Mat descriptors = _descriptors.getMat();
+        calcDescriptors(gpyr, keypoints, descriptors, nOctaveLayers, firstOctave);
+        //t = (double)getTickCount() - t;
+        //printf("descriptor extraction time: %g\n", t*1000./tf);
+    }
+}
+
+void SIFT_Impl::read( const FileNode& fn)
+{
+  // if node is empty, keep previous value
+  if (!fn["nfeatures"].empty())
+    fn["nfeatures"] >> nfeatures;
+  if (!fn["nOctaveLayers"].empty())
+    fn["nOctaveLayers"] >> nOctaveLayers;
+  if (!fn["contrastThreshold"].empty())
+    fn["contrastThreshold"] >> contrastThreshold;
+  if (!fn["edgeThreshold"].empty())
+    fn["edgeThreshold"] >> edgeThreshold;
+  if (!fn["sigma"].empty())
+    fn["sigma"] >> sigma;
+  if (!fn["descriptorType"].empty())
+    fn["descriptorType"] >> descriptor_type;
+}
+void SIFT_Impl::write( FileStorage& fs) const
+{
+  if(fs.isOpened())
+  {
+    fs << "name" << getDefaultName();
+    fs << "nfeatures" << nfeatures;
+    fs << "nOctaveLayers" << nOctaveLayers;
+    fs << "contrastThreshold" << contrastThreshold;
+    fs << "edgeThreshold" << edgeThreshold;
+    fs << "sigma" << sigma;
+    fs << "descriptorType" << descriptor_type;
+  }
+}
+
+}
diff --git a/upstream/opencv/modules/features/src/sift.simd.hpp b/upstream/opencv/modules/features/src/sift.simd.hpp
new file mode 100644
index 0000000..d4e13d2
--- /dev/null
+++ b/upstream/opencv/modules/features/src/sift.simd.hpp
@@ -0,0 +1,1036 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+
+/**********************************************************************************************\
+ Implementation of SIFT is based on the code from http://blogs.oregonstate.edu/hess/code/sift/
+ Below is the original copyright.
+ Patent US6711293 expired in March 2020.
+
+//    Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+//    All rights reserved.
+
+//    The following patent has been issued for methods embodied in this
+//    software: "Method and apparatus for identifying scale invariant features
+//    in an image and use of same for locating an object in an image," David
+//    G. Lowe, US Patent 6,711,293 (March 23, 2004). Provisional application
+//    filed March 8, 1999. Assignee: The University of British Columbia. For
+//    further details, contact David Lowe (lowe@cs.ubc.ca) or the
+//    University-Industry Liaison Office of the University of British
+//    Columbia.
+
+//    Note that restrictions imposed by this patent (and possibly others)
+//    exist independently of and may be in conflict with the freedoms granted
+//    in this license, which refers to copyright of the program, not patents
+//    for any methods that it implements.  Both copyright and patent law must
+//    be obeyed to legally use and redistribute this program and it is not the
+//    purpose of this license to induce you to infringe any patents or other
+//    property right claims or to contest validity of any such claims.  If you
+//    redistribute or use the program, then this license merely protects you
+//    from committing copyright infringement.  It does not protect you from
+//    committing patent infringement.  So, before you do anything with this
+//    program, make sure that you have permission to do so not merely in terms
+//    of copyright, but also in terms of patent law.
+
+//    Please note that this license is not to be understood as a guarantee
+//    either.  If you use the program according to this license, but in
+//    conflict with patent law, it does not mean that the licensor will refund
+//    you for any losses that you incur if you are sued for your patent
+//    infringement.
+
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
+//    met:
+//        * Redistributions of source code must retain the above copyright and
+//          patent notices, this list of conditions and the following
+//          disclaimer.
+//        * Redistributions in binary form must reproduce the above copyright
+//          notice, this list of conditions and the following disclaimer in
+//          the documentation and/or other materials provided with the
+//          distribution.
+//        * Neither the name of Oregon State University nor the names of its
+//          contributors may be used to endorse or promote products derived
+//          from this software without specific prior written permission.
+
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+//    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+//    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\**********************************************************************************************/
+
+#include "precomp.hpp"
+
+#include <opencv2/core/hal/hal.hpp>
+#include "opencv2/core/hal/intrin.hpp"
+#include <opencv2/core/utils/buffer_area.private.hpp>
+
+namespace cv {
+
+#if !defined(CV_CPU_DISPATCH_MODE) || !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY)
+/******************************* Defs and macros *****************************/
+
+// default width of descriptor histogram array
+static const int SIFT_DESCR_WIDTH = 4;
+
+// default number of bins per histogram in descriptor array
+static const int SIFT_DESCR_HIST_BINS = 8;
+
+// assumed gaussian blur for input image
+static const float SIFT_INIT_SIGMA = 0.5f;
+
+// width of border in which to ignore keypoints
+static const int SIFT_IMG_BORDER = 5;
+
+// maximum steps of keypoint interpolation before failure
+static const int SIFT_MAX_INTERP_STEPS = 5;
+
+// default number of bins in histogram for orientation assignment
+static const int SIFT_ORI_HIST_BINS = 36;
+
+// determines gaussian sigma for orientation assignment
+static const float SIFT_ORI_SIG_FCTR = 1.5f;
+
+// determines the radius of the region used in orientation assignment
+static const float SIFT_ORI_RADIUS = 4.5f; // 3 * SIFT_ORI_SIG_FCTR;
+
+// orientation magnitude relative to max that results in new feature
+static const float SIFT_ORI_PEAK_RATIO = 0.8f;
+
+// determines the size of a single descriptor orientation histogram
+static const float SIFT_DESCR_SCL_FCTR = 3.f;
+
+// threshold on magnitude of elements of descriptor vector
+static const float SIFT_DESCR_MAG_THR = 0.2f;
+
+// factor used to convert floating-point descriptor to unsigned char
+static const float SIFT_INT_DESCR_FCTR = 512.f;
+
+#define DoG_TYPE_SHORT 0
+#if DoG_TYPE_SHORT
+// intermediate type used for DoG pyramids
+typedef short sift_wt;
+static const int SIFT_FIXPT_SCALE = 48;
+#else
+// intermediate type used for DoG pyramids
+typedef float sift_wt;
+static const int SIFT_FIXPT_SCALE = 1;
+#endif
+
+#endif  // definitions and macros
+
+
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+void findScaleSpaceExtrema(
+    int octave,
+    int layer,
+    int threshold,
+    int idx,
+    int step,
+    int cols,
+    int nOctaveLayers,
+    double contrastThreshold,
+    double edgeThreshold,
+    double sigma,
+    const std::vector<Mat>& gauss_pyr,
+    const std::vector<Mat>& dog_pyr,
+    std::vector<KeyPoint>& kpts,
+    const cv::Range& range);
+
+void calcSIFTDescriptor(
+        const Mat& img, Point2f ptf, float ori, float scl,
+        const int d, const int n, Mat& dst, int row
+);
+
+
+#ifndef CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+// Computes a gradient orientation histogram at a specified pixel
+static
+float calcOrientationHist(
+        const Mat& img, Point pt, int radius,
+        float sigma, float* hist, int n
+)
+{
+    CV_TRACE_FUNCTION();
+
+    int i, j, k, len = (radius*2+1)*(radius*2+1);
+
+    float expf_scale = -1.f/(2.f * sigma * sigma);
+
+    cv::utils::BufferArea area;
+    float *X = 0, *Y = 0, *Mag, *Ori = 0, *W = 0, *temphist = 0;
+    area.allocate(X, len, CV_SIMD_WIDTH);
+    area.allocate(Y, len, CV_SIMD_WIDTH);
+    area.allocate(Ori, len, CV_SIMD_WIDTH);
+    area.allocate(W, len, CV_SIMD_WIDTH);
+    area.allocate(temphist, n+4, CV_SIMD_WIDTH);
+    area.commit();
+    temphist += 2;
+    Mag = X;
+
+    for( i = 0; i < n; i++ )
+        temphist[i] = 0.f;
+
+    for( i = -radius, k = 0; i <= radius; i++ )
+    {
+        int y = pt.y + i;
+        if( y <= 0 || y >= img.rows - 1 )
+            continue;
+        for( j = -radius; j <= radius; j++ )
+        {
+            int x = pt.x + j;
+            if( x <= 0 || x >= img.cols - 1 )
+                continue;
+
+            float dx = (float)(img.at<sift_wt>(y, x+1) - img.at<sift_wt>(y, x-1));
+            float dy = (float)(img.at<sift_wt>(y-1, x) - img.at<sift_wt>(y+1, x));
+
+            X[k] = dx; Y[k] = dy; W[k] = (i*i + j*j)*expf_scale;
+            k++;
+        }
+    }
+
+    len = k;
+
+    // compute gradient values, orientations and the weights over the pixel neighborhood
+    cv::hal::exp32f(W, W, len);
+    cv::hal::fastAtan2(Y, X, Ori, len, true);
+    cv::hal::magnitude32f(X, Y, Mag, len);
+
+    k = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    const int vecsize = VTraits<v_float32>::vlanes();
+    v_float32 nd360 = vx_setall_f32(n/360.f);
+    v_int32 __n = vx_setall_s32(n);
+    int CV_DECL_ALIGNED(CV_SIMD_WIDTH) bin_buf[VTraits<v_float32>::max_nlanes];
+    float CV_DECL_ALIGNED(CV_SIMD_WIDTH) w_mul_mag_buf[VTraits<v_float32>::max_nlanes];
+
+    for( ; k <= len - vecsize; k += vecsize )
+    {
+        v_float32 w = vx_load_aligned( W + k );
+        v_float32 mag = vx_load_aligned( Mag + k );
+        v_float32 ori = vx_load_aligned( Ori + k );
+        v_int32 bin = v_round( v_mul(nd360, ori) );
+
+        bin = v_select(v_ge(bin, __n), v_sub(bin, __n), bin);
+        bin = v_select(v_lt(bin, vx_setzero_s32()), v_add(bin, __n), bin);
+
+        w = v_mul(w, mag);
+        v_store_aligned(bin_buf, bin);
+        v_store_aligned(w_mul_mag_buf, w);
+        for(int vi = 0; vi < vecsize; vi++)
+        {
+            temphist[bin_buf[vi]] += w_mul_mag_buf[vi];
+        }
+    }
+#endif
+    for( ; k < len; k++ )
+    {
+        int bin = cvRound((n/360.f)*Ori[k]);
+        if( bin >= n )
+            bin -= n;
+        if( bin < 0 )
+            bin += n;
+        temphist[bin] += W[k]*Mag[k];
+    }
+
+    // smooth the histogram
+    temphist[-1] = temphist[n-1];
+    temphist[-2] = temphist[n-2];
+    temphist[n] = temphist[0];
+    temphist[n+1] = temphist[1];
+
+    i = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    v_float32 d_1_16 = vx_setall_f32(1.f/16.f);
+    v_float32 d_4_16 = vx_setall_f32(4.f/16.f);
+    v_float32 d_6_16 = vx_setall_f32(6.f/16.f);
+    for( ; i <= n - VTraits<v_float32>::vlanes(); i += VTraits<v_float32>::vlanes() )
+    {
+        v_float32 tn2 = vx_load_aligned(temphist + i-2);
+        v_float32 tn1 = vx_load(temphist + i-1);
+        v_float32 t0 = vx_load(temphist + i);
+        v_float32 t1 = vx_load(temphist + i+1);
+        v_float32 t2 = vx_load(temphist + i+2);
+        v_float32 _hist = v_fma(v_add(tn2, t2), d_1_16,
+            v_fma(v_add(tn1, t1), d_4_16, v_mul(t0, d_6_16)));
+        v_store(hist + i, _hist);
+    }
+#endif
+    for( ; i < n; i++ )
+    {
+        hist[i] = (temphist[i-2] + temphist[i+2])*(1.f/16.f) +
+            (temphist[i-1] + temphist[i+1])*(4.f/16.f) +
+            temphist[i]*(6.f/16.f);
+    }
+
+    float maxval = hist[0];
+    for( i = 1; i < n; i++ )
+        maxval = std::max(maxval, hist[i]);
+
+    return maxval;
+}
+
+
+//
+// Interpolates a scale-space extremum's location and scale to subpixel
+// accuracy to form an image feature. Rejects features with low contrast.
+// Based on Section 4 of Lowe's paper.
+static
+bool adjustLocalExtrema(
+        const std::vector<Mat>& dog_pyr, KeyPoint& kpt, int octv,
+        int& layer, int& r, int& c, int nOctaveLayers,
+        float contrastThreshold, float edgeThreshold, float sigma
+)
+{
+    CV_TRACE_FUNCTION();
+
+    const float img_scale = 1.f/(255*SIFT_FIXPT_SCALE);
+    const float deriv_scale = img_scale*0.5f;
+    const float second_deriv_scale = img_scale;
+    const float cross_deriv_scale = img_scale*0.25f;
+
+    float xi=0, xr=0, xc=0, contr=0;
+    int i = 0;
+
+    for( ; i < SIFT_MAX_INTERP_STEPS; i++ )
+    {
+        int idx = octv*(nOctaveLayers+2) + layer;
+        const Mat& img = dog_pyr[idx];
+        const Mat& prev = dog_pyr[idx-1];
+        const Mat& next = dog_pyr[idx+1];
+
+        Vec3f dD((img.at<sift_wt>(r, c+1) - img.at<sift_wt>(r, c-1))*deriv_scale,
+                 (img.at<sift_wt>(r+1, c) - img.at<sift_wt>(r-1, c))*deriv_scale,
+                 (next.at<sift_wt>(r, c) - prev.at<sift_wt>(r, c))*deriv_scale);
+
+        float v2 = (float)img.at<sift_wt>(r, c)*2;
+        float dxx = (img.at<sift_wt>(r, c+1) + img.at<sift_wt>(r, c-1) - v2)*second_deriv_scale;
+        float dyy = (img.at<sift_wt>(r+1, c) + img.at<sift_wt>(r-1, c) - v2)*second_deriv_scale;
+        float dss = (next.at<sift_wt>(r, c) + prev.at<sift_wt>(r, c) - v2)*second_deriv_scale;
+        float dxy = (img.at<sift_wt>(r+1, c+1) - img.at<sift_wt>(r+1, c-1) -
+                     img.at<sift_wt>(r-1, c+1) + img.at<sift_wt>(r-1, c-1))*cross_deriv_scale;
+        float dxs = (next.at<sift_wt>(r, c+1) - next.at<sift_wt>(r, c-1) -
+                     prev.at<sift_wt>(r, c+1) + prev.at<sift_wt>(r, c-1))*cross_deriv_scale;
+        float dys = (next.at<sift_wt>(r+1, c) - next.at<sift_wt>(r-1, c) -
+                     prev.at<sift_wt>(r+1, c) + prev.at<sift_wt>(r-1, c))*cross_deriv_scale;
+
+        Matx33f H(dxx, dxy, dxs,
+                  dxy, dyy, dys,
+                  dxs, dys, dss);
+
+        Vec3f X = H.solve(dD, DECOMP_LU);
+
+        xi = -X[2];
+        xr = -X[1];
+        xc = -X[0];
+
+        if( std::abs(xi) < 0.5f && std::abs(xr) < 0.5f && std::abs(xc) < 0.5f )
+            break;
+
+        if( std::abs(xi) > (float)(INT_MAX/3) ||
+            std::abs(xr) > (float)(INT_MAX/3) ||
+            std::abs(xc) > (float)(INT_MAX/3) )
+            return false;
+
+        c += cvRound(xc);
+        r += cvRound(xr);
+        layer += cvRound(xi);
+
+        if( layer < 1 || layer > nOctaveLayers ||
+            c < SIFT_IMG_BORDER || c >= img.cols - SIFT_IMG_BORDER  ||
+            r < SIFT_IMG_BORDER || r >= img.rows - SIFT_IMG_BORDER )
+            return false;
+    }
+
+    // ensure convergence of interpolation
+    if( i >= SIFT_MAX_INTERP_STEPS )
+        return false;
+
+    {
+        int idx = octv*(nOctaveLayers+2) + layer;
+        const Mat& img = dog_pyr[idx];
+        const Mat& prev = dog_pyr[idx-1];
+        const Mat& next = dog_pyr[idx+1];
+        Matx31f dD((img.at<sift_wt>(r, c+1) - img.at<sift_wt>(r, c-1))*deriv_scale,
+                   (img.at<sift_wt>(r+1, c) - img.at<sift_wt>(r-1, c))*deriv_scale,
+                   (next.at<sift_wt>(r, c) - prev.at<sift_wt>(r, c))*deriv_scale);
+        float t = dD.dot(Matx31f(xc, xr, xi));
+
+        contr = img.at<sift_wt>(r, c)*img_scale + t * 0.5f;
+        if( std::abs( contr ) * nOctaveLayers < contrastThreshold )
+            return false;
+
+        // principal curvatures are computed using the trace and det of Hessian
+        float v2 = img.at<sift_wt>(r, c)*2.f;
+        float dxx = (img.at<sift_wt>(r, c+1) + img.at<sift_wt>(r, c-1) - v2)*second_deriv_scale;
+        float dyy = (img.at<sift_wt>(r+1, c) + img.at<sift_wt>(r-1, c) - v2)*second_deriv_scale;
+        float dxy = (img.at<sift_wt>(r+1, c+1) - img.at<sift_wt>(r+1, c-1) -
+                     img.at<sift_wt>(r-1, c+1) + img.at<sift_wt>(r-1, c-1)) * cross_deriv_scale;
+        float tr = dxx + dyy;
+        float det = dxx * dyy - dxy * dxy;
+
+        if( det <= 0 || tr*tr*edgeThreshold >= (edgeThreshold + 1)*(edgeThreshold + 1)*det )
+            return false;
+    }
+
+    kpt.pt.x = (c + xc) * (1 << octv);
+    kpt.pt.y = (r + xr) * (1 << octv);
+    kpt.octave = octv + (layer << 8) + (cvRound((xi + 0.5)*255) << 16);
+    kpt.size = sigma*powf(2.f, (layer + xi) / nOctaveLayers)*(1 << octv)*2;
+    kpt.response = std::abs(contr);
+
+    return true;
+}
+
+namespace {
+
+class findScaleSpaceExtremaT
+{
+public:
+    findScaleSpaceExtremaT(
+        int _o,
+        int _i,
+        int _threshold,
+        int _idx,
+        int _step,
+        int _cols,
+        int _nOctaveLayers,
+        double _contrastThreshold,
+        double _edgeThreshold,
+        double _sigma,
+        const std::vector<Mat>& _gauss_pyr,
+        const std::vector<Mat>& _dog_pyr,
+        std::vector<KeyPoint>& kpts)
+
+        : o(_o),
+          i(_i),
+          threshold(_threshold),
+          idx(_idx),
+          step(_step),
+          cols(_cols),
+          nOctaveLayers(_nOctaveLayers),
+          contrastThreshold(_contrastThreshold),
+          edgeThreshold(_edgeThreshold),
+          sigma(_sigma),
+          gauss_pyr(_gauss_pyr),
+          dog_pyr(_dog_pyr),
+          kpts_(kpts)
+    {
+        // nothing
+    }
+    void process(const cv::Range& range)
+    {
+        CV_TRACE_FUNCTION();
+
+        const int begin = range.start;
+        const int end = range.end;
+
+        static const int n = SIFT_ORI_HIST_BINS;
+        float CV_DECL_ALIGNED(CV_SIMD_WIDTH) hist[n];
+
+        const Mat& img = dog_pyr[idx];
+        const Mat& prev = dog_pyr[idx-1];
+        const Mat& next = dog_pyr[idx+1];
+
+        for( int r = begin; r < end; r++)
+        {
+            const sift_wt* currptr = img.ptr<sift_wt>(r);
+            const sift_wt* prevptr = prev.ptr<sift_wt>(r);
+            const sift_wt* nextptr = next.ptr<sift_wt>(r);
+            int c = SIFT_IMG_BORDER;
+
+#if (CV_SIMD || CV_SIMD_SCALABLE) && !(DoG_TYPE_SHORT)
+            const int vecsize = VTraits<v_float32>::vlanes();
+            for( ; c <= cols-SIFT_IMG_BORDER - vecsize; c += vecsize)
+            {
+                v_float32 val = vx_load(&currptr[c]);
+                v_float32 _00,_01,_02;
+                v_float32 _10,    _12;
+                v_float32 _20,_21,_22;
+
+                v_float32 vmin,vmax;
+
+
+                v_float32 cond = v_gt(v_abs(val), vx_setall_f32((float)this->threshold));
+                if (!v_check_any(cond))
+                {
+                    continue;
+                }
+
+                _00 = vx_load(&currptr[c-step-1]); _01 = vx_load(&currptr[c-step]); _02 = vx_load(&currptr[c-step+1]);
+                _10 = vx_load(&currptr[c     -1]);                                  _12 = vx_load(&currptr[c     +1]);
+                _20 = vx_load(&currptr[c+step-1]); _21 = vx_load(&currptr[c+step]); _22 = vx_load(&currptr[c+step+1]);
+
+                vmax = v_max(v_max(v_max(_00,_01),v_max(_02,_10)),v_max(v_max(_12,_20),v_max(_21,_22)));
+                vmin = v_min(v_min(v_min(_00,_01),v_min(_02,_10)),v_min(v_min(_12,_20),v_min(_21,_22)));
+
+                v_float32 condp = v_and(v_and(cond, v_gt(val, vx_setall_f32(0))), v_ge(val, vmax));
+                v_float32 condm = v_and(v_and(cond, v_lt(val, vx_setall_f32(0))), v_le(val, vmin));
+
+                cond = v_or(condp, condm);
+                if (!v_check_any(cond))
+                {
+                    continue;
+                }
+
+                _00 = vx_load(&prevptr[c-step-1]); _01 = vx_load(&prevptr[c-step]); _02 = vx_load(&prevptr[c-step+1]);
+                _10 = vx_load(&prevptr[c     -1]);                                  _12 = vx_load(&prevptr[c     +1]);
+                _20 = vx_load(&prevptr[c+step-1]); _21 = vx_load(&prevptr[c+step]); _22 = vx_load(&prevptr[c+step+1]);
+
+                vmax = v_max(v_max(v_max(_00,_01),v_max(_02,_10)),v_max(v_max(_12,_20),v_max(_21,_22)));
+                vmin = v_min(v_min(v_min(_00,_01),v_min(_02,_10)),v_min(v_min(_12,_20),v_min(_21,_22)));
+
+                condp = v_and(condp, v_ge(val, vmax));
+                condm = v_and(condm, v_le(val, vmin));
+
+                cond = v_or(condp, condm);
+                if (!v_check_any(cond))
+                {
+                    continue;
+                }
+
+                v_float32 _11p = vx_load(&prevptr[c]);
+                v_float32 _11n = vx_load(&nextptr[c]);
+
+                v_float32 max_middle = v_max(_11n,_11p);
+                v_float32 min_middle = v_min(_11n,_11p);
+
+                _00 = vx_load(&nextptr[c-step-1]); _01 = vx_load(&nextptr[c-step]); _02 = vx_load(&nextptr[c-step+1]);
+                _10 = vx_load(&nextptr[c     -1]);                                  _12 = vx_load(&nextptr[c     +1]);
+                _20 = vx_load(&nextptr[c+step-1]); _21 = vx_load(&nextptr[c+step]); _22 = vx_load(&nextptr[c+step+1]);
+
+                vmax = v_max(v_max(v_max(_00,_01),v_max(_02,_10)),v_max(v_max(_12,_20),v_max(_21,_22)));
+                vmin = v_min(v_min(v_min(_00,_01),v_min(_02,_10)),v_min(v_min(_12,_20),v_min(_21,_22)));
+
+                condp = v_and(condp, v_ge(val, v_max(vmax, max_middle)));
+                condm = v_and(condm, v_le(val, v_min(vmin, min_middle)));
+
+                cond = v_or(condp, condm);
+                if (!v_check_any(cond))
+                {
+                    continue;
+                }
+
+                int mask = v_signmask(cond);
+                for (int k = 0; k<vecsize;k++)
+                {
+                    if ((mask & (1<<k)) == 0)
+                        continue;
+
+                    CV_TRACE_REGION("pixel_candidate_simd");
+
+                    KeyPoint kpt;
+                    int r1 = r, c1 = c+k, layer = i;
+                    if( !adjustLocalExtrema(dog_pyr, kpt, o, layer, r1, c1,
+                                            nOctaveLayers, (float)contrastThreshold,
+                                            (float)edgeThreshold, (float)sigma) )
+                        continue;
+                    float scl_octv = kpt.size*0.5f/(1 << o);
+                    float omax = calcOrientationHist(gauss_pyr[o*(nOctaveLayers+3) + layer],
+                                                     Point(c1, r1),
+                                                     cvRound(SIFT_ORI_RADIUS * scl_octv),
+                                                     SIFT_ORI_SIG_FCTR * scl_octv,
+                                                     hist, n);
+                    float mag_thr = (float)(omax * SIFT_ORI_PEAK_RATIO);
+                    for( int j = 0; j < n; j++ )
+                    {
+                        int l = j > 0 ? j - 1 : n - 1;
+                        int r2 = j < n-1 ? j + 1 : 0;
+
+                        if( hist[j] > hist[l]  &&  hist[j] > hist[r2]  &&  hist[j] >= mag_thr )
+                        {
+                            float bin = j + 0.5f * (hist[l]-hist[r2]) / (hist[l] - 2*hist[j] + hist[r2]);
+                            bin = bin < 0 ? n + bin : bin >= n ? bin - n : bin;
+                            kpt.angle = 360.f - (float)((360.f/n) * bin);
+                            if(std::abs(kpt.angle - 360.f) < FLT_EPSILON)
+                                kpt.angle = 0.f;
+
+                            kpts_.push_back(kpt);
+                        }
+                    }
+                }
+            }
+
+#endif //CV_SIMD && !(DoG_TYPE_SHORT)
+
+            // vector loop reminder, better predictibility and less branch density
+            for( ; c < cols-SIFT_IMG_BORDER; c++)
+            {
+                sift_wt val = currptr[c];
+                if (std::abs(val) <= threshold)
+                    continue;
+
+                sift_wt _00,_01,_02;
+                sift_wt _10,    _12;
+                sift_wt _20,_21,_22;
+                _00 = currptr[c-step-1]; _01 = currptr[c-step]; _02 = currptr[c-step+1];
+                _10 = currptr[c     -1];                        _12 = currptr[c     +1];
+                _20 = currptr[c+step-1]; _21 = currptr[c+step]; _22 = currptr[c+step+1];
+
+                bool calculate = false;
+                if (val > 0)
+                {
+                    sift_wt vmax = std::max(std::max(std::max(_00,_01),std::max(_02,_10)),std::max(std::max(_12,_20),std::max(_21,_22)));
+                    if (val >= vmax)
+                    {
+                        _00 = prevptr[c-step-1]; _01 = prevptr[c-step]; _02 = prevptr[c-step+1];
+                        _10 = prevptr[c     -1];                        _12 = prevptr[c     +1];
+                        _20 = prevptr[c+step-1]; _21 = prevptr[c+step]; _22 = prevptr[c+step+1];
+                        vmax = std::max(std::max(std::max(_00,_01),std::max(_02,_10)),std::max(std::max(_12,_20),std::max(_21,_22)));
+                        if (val >= vmax)
+                        {
+                            _00 = nextptr[c-step-1]; _01 = nextptr[c-step]; _02 = nextptr[c-step+1];
+                            _10 = nextptr[c     -1];                        _12 = nextptr[c     +1];
+                            _20 = nextptr[c+step-1]; _21 = nextptr[c+step]; _22 = nextptr[c+step+1];
+                            vmax = std::max(std::max(std::max(_00,_01),std::max(_02,_10)),std::max(std::max(_12,_20),std::max(_21,_22)));
+                            if (val >= vmax)
+                            {
+                                sift_wt _11p = prevptr[c], _11n = nextptr[c];
+                                calculate = (val >= std::max(_11p,_11n));
+                            }
+                        }
+                    }
+
+                } else  { // val can't be zero here (first abs took care of zero), must be negative
+                    sift_wt vmin = std::min(std::min(std::min(_00,_01),std::min(_02,_10)),std::min(std::min(_12,_20),std::min(_21,_22)));
+                    if (val <= vmin)
+                    {
+                        _00 = prevptr[c-step-1]; _01 = prevptr[c-step]; _02 = prevptr[c-step+1];
+                        _10 = prevptr[c     -1];                        _12 = prevptr[c     +1];
+                        _20 = prevptr[c+step-1]; _21 = prevptr[c+step]; _22 = prevptr[c+step+1];
+                        vmin = std::min(std::min(std::min(_00,_01),std::min(_02,_10)),std::min(std::min(_12,_20),std::min(_21,_22)));
+                        if (val <= vmin)
+                        {
+                            _00 = nextptr[c-step-1]; _01 = nextptr[c-step]; _02 = nextptr[c-step+1];
+                            _10 = nextptr[c     -1];                        _12 = nextptr[c     +1];
+                            _20 = nextptr[c+step-1]; _21 = nextptr[c+step]; _22 = nextptr[c+step+1];
+                            vmin = std::min(std::min(std::min(_00,_01),std::min(_02,_10)),std::min(std::min(_12,_20),std::min(_21,_22)));
+                            if (val <= vmin)
+                            {
+                                sift_wt _11p = prevptr[c], _11n = nextptr[c];
+                                calculate = (val <= std::min(_11p,_11n));
+                            }
+                        }
+                    }
+                }
+
+                if (calculate)
+                {
+                    CV_TRACE_REGION("pixel_candidate");
+
+                    KeyPoint kpt;
+                    int r1 = r, c1 = c, layer = i;
+                    if( !adjustLocalExtrema(dog_pyr, kpt, o, layer, r1, c1,
+                                            nOctaveLayers, (float)contrastThreshold,
+                                            (float)edgeThreshold, (float)sigma) )
+                        continue;
+                    float scl_octv = kpt.size*0.5f/(1 << o);
+                    float omax = calcOrientationHist(gauss_pyr[o*(nOctaveLayers+3) + layer],
+                                                     Point(c1, r1),
+                                                     cvRound(SIFT_ORI_RADIUS * scl_octv),
+                                                     SIFT_ORI_SIG_FCTR * scl_octv,
+                                                     hist, n);
+                    float mag_thr = (float)(omax * SIFT_ORI_PEAK_RATIO);
+                    for( int j = 0; j < n; j++ )
+                    {
+                        int l = j > 0 ? j - 1 : n - 1;
+                        int r2 = j < n-1 ? j + 1 : 0;
+
+                        if( hist[j] > hist[l]  &&  hist[j] > hist[r2]  &&  hist[j] >= mag_thr )
+                        {
+                            float bin = j + 0.5f * (hist[l]-hist[r2]) / (hist[l] - 2*hist[j] + hist[r2]);
+                            bin = bin < 0 ? n + bin : bin >= n ? bin - n : bin;
+                            kpt.angle = 360.f - (float)((360.f/n) * bin);
+                            if(std::abs(kpt.angle - 360.f) < FLT_EPSILON)
+                                kpt.angle = 0.f;
+
+                            kpts_.push_back(kpt);
+                        }
+                    }
+                }
+            }
+        }
+    }
+private:
+    int o, i;
+    int threshold;
+    int idx, step, cols;
+    int nOctaveLayers;
+    double contrastThreshold;
+    double edgeThreshold;
+    double sigma;
+    const std::vector<Mat>& gauss_pyr;
+    const std::vector<Mat>& dog_pyr;
+    std::vector<KeyPoint>& kpts_;
+};
+
+}  // namespace
+
+
+void findScaleSpaceExtrema(
+    int octave,
+    int layer,
+    int threshold,
+    int idx,
+    int step,
+    int cols,
+    int nOctaveLayers,
+    double contrastThreshold,
+    double edgeThreshold,
+    double sigma,
+    const std::vector<Mat>& gauss_pyr,
+    const std::vector<Mat>& dog_pyr,
+    std::vector<KeyPoint>& kpts,
+    const cv::Range& range)
+{
+    CV_TRACE_FUNCTION();
+
+    findScaleSpaceExtremaT(octave, layer, threshold, idx,
+            step, cols,
+            nOctaveLayers, contrastThreshold, edgeThreshold, sigma,
+            gauss_pyr, dog_pyr,
+            kpts)
+        .process(range);
+}
+
+void calcSIFTDescriptor(
+        const Mat& img, Point2f ptf, float ori, float scl,
+        const int d, const int n, Mat& dstMat, int row
+)
+{
+    CV_TRACE_FUNCTION();
+
+    Point pt(cvRound(ptf.x), cvRound(ptf.y));
+    float cos_t = cosf(ori*(float)(CV_PI/180));
+    float sin_t = sinf(ori*(float)(CV_PI/180));
+    float bins_per_rad = n / 360.f;
+    float exp_scale = -1.f/(d * d * 0.5f);
+    float hist_width = SIFT_DESCR_SCL_FCTR * scl;
+    int radius = cvRound(hist_width * 1.4142135623730951f * (d + 1) * 0.5f);
+    // Clip the radius to the diagonal of the image to avoid autobuffer too large exception
+    radius = std::min(radius, (int)std::sqrt(((double) img.cols)*img.cols + ((double) img.rows)*img.rows));
+    cos_t /= hist_width;
+    sin_t /= hist_width;
+
+    int i, j, k;
+    const int len = (radius*2+1)*(radius*2+1);
+    const int len_hist = (d+2)*(d+2)*(n+2);
+    const int len_ddn = d * d * n;
+    int rows = img.rows, cols = img.cols;
+
+    cv::utils::BufferArea area;
+    float *X = 0, *Y = 0, *Mag, *Ori = 0, *W = 0, *RBin = 0, *CBin = 0, *hist = 0, *rawDst = 0;
+    area.allocate(X, len, CV_SIMD_WIDTH);
+    area.allocate(Y, len, CV_SIMD_WIDTH);
+    area.allocate(Ori, len, CV_SIMD_WIDTH);
+    area.allocate(W, len, CV_SIMD_WIDTH);
+    area.allocate(RBin, len, CV_SIMD_WIDTH);
+    area.allocate(CBin, len, CV_SIMD_WIDTH);
+    area.allocate(hist, len_hist, CV_SIMD_WIDTH);
+    area.allocate(rawDst, len_ddn, CV_SIMD_WIDTH);
+    area.commit();
+    Mag = Y;
+
+    for( i = 0; i < d+2; i++ )
+    {
+        for( j = 0; j < d+2; j++ )
+            for( k = 0; k < n+2; k++ )
+                hist[(i*(d+2) + j)*(n+2) + k] = 0.;
+    }
+
+    for( i = -radius, k = 0; i <= radius; i++ )
+        for( j = -radius; j <= radius; j++ )
+        {
+            // Calculate sample's histogram array coords rotated relative to ori.
+            // Subtract 0.5 so samples that fall e.g. in the center of row 1 (i.e.
+            // r_rot = 1.5) have full weight placed in row 1 after interpolation.
+            float c_rot = j * cos_t - i * sin_t;
+            float r_rot = j * sin_t + i * cos_t;
+            float rbin = r_rot + d/2 - 0.5f;
+            float cbin = c_rot + d/2 - 0.5f;
+            int r = pt.y + i, c = pt.x + j;
+
+            if( rbin > -1 && rbin < d && cbin > -1 && cbin < d &&
+                r > 0 && r < rows - 1 && c > 0 && c < cols - 1 )
+            {
+                float dx = (float)(img.at<sift_wt>(r, c+1) - img.at<sift_wt>(r, c-1));
+                float dy = (float)(img.at<sift_wt>(r-1, c) - img.at<sift_wt>(r+1, c));
+                X[k] = dx; Y[k] = dy; RBin[k] = rbin; CBin[k] = cbin;
+                W[k] = (c_rot * c_rot + r_rot * r_rot)*exp_scale;
+                k++;
+            }
+        }
+
+    const int len_left = k;
+    cv::hal::fastAtan2(Y, X, Ori, len_left, true);
+    cv::hal::magnitude32f(X, Y, Mag, len_left);
+    cv::hal::exp32f(W, W, len_left);
+
+    k = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    {
+        const int vecsize = VTraits<v_float32>::vlanes();
+        int CV_DECL_ALIGNED(CV_SIMD_WIDTH) idx_buf[VTraits<v_float32>::max_nlanes];
+        float CV_DECL_ALIGNED(CV_SIMD_WIDTH) rco_buf[8*VTraits<v_float32>::max_nlanes];
+        const v_float32 __ori  = vx_setall_f32(ori);
+        const v_float32 __bins_per_rad = vx_setall_f32(bins_per_rad);
+        const v_int32 __n = vx_setall_s32(n);
+        const v_int32 __1 = vx_setall_s32(1);
+        const v_int32 __d_plus_2 = vx_setall_s32(d+2);
+        const v_int32 __n_plus_2 = vx_setall_s32(n+2);
+        for( ; k <= len_left - vecsize; k += vecsize )
+        {
+            v_float32 rbin = vx_load_aligned(RBin + k);
+            v_float32 cbin = vx_load_aligned(CBin + k);
+            v_float32 obin = v_mul(v_sub(vx_load_aligned(Ori + k), __ori), __bins_per_rad);
+            v_float32 mag = v_mul(vx_load_aligned(Mag + k), vx_load_aligned(W + k));
+
+            v_int32 r0 = v_floor(rbin);
+            v_int32 c0 = v_floor(cbin);
+            v_int32 o0 = v_floor(obin);
+            rbin = v_sub(rbin, v_cvt_f32(r0));
+            cbin = v_sub(cbin, v_cvt_f32(c0));
+            obin = v_sub(obin, v_cvt_f32(o0));
+
+            o0 = v_select(v_lt(o0, vx_setzero_s32()), v_add(o0, __n), o0);
+            o0 = v_select(v_ge(o0, __n), v_sub(o0, __n), o0);
+
+            v_float32 v_r1 = v_mul(mag, rbin), v_r0 = v_sub(mag, v_r1);
+            v_float32 v_rc11 = v_mul(v_r1, cbin), v_rc10 = v_sub(v_r1, v_rc11);
+            v_float32 v_rc01 = v_mul(v_r0, cbin), v_rc00 = v_sub(v_r0, v_rc01);
+            v_float32 v_rco111 = v_mul(v_rc11, obin), v_rco110 = v_sub(v_rc11, v_rco111);
+            v_float32 v_rco101 = v_mul(v_rc10, obin), v_rco100 = v_sub(v_rc10, v_rco101);
+            v_float32 v_rco011 = v_mul(v_rc01, obin), v_rco010 = v_sub(v_rc01, v_rco011);
+            v_float32 v_rco001 = v_mul(v_rc00, obin), v_rco000 = v_sub(v_rc00, v_rco001);
+
+            v_int32 idx = v_muladd(v_muladd(v_add(r0, __1), __d_plus_2, v_add(c0, __1)), __n_plus_2, o0);
+            v_store_aligned(idx_buf, idx);
+
+            v_store_aligned(rco_buf,           v_rco000);
+            v_store_aligned(rco_buf+vecsize,   v_rco001);
+            v_store_aligned(rco_buf+vecsize*2, v_rco010);
+            v_store_aligned(rco_buf+vecsize*3, v_rco011);
+            v_store_aligned(rco_buf+vecsize*4, v_rco100);
+            v_store_aligned(rco_buf+vecsize*5, v_rco101);
+            v_store_aligned(rco_buf+vecsize*6, v_rco110);
+            v_store_aligned(rco_buf+vecsize*7, v_rco111);
+
+            for(int id = 0; id < vecsize; id++)
+            {
+                hist[idx_buf[id]] += rco_buf[id];
+                hist[idx_buf[id]+1] += rco_buf[vecsize + id];
+                hist[idx_buf[id]+(n+2)] += rco_buf[2*vecsize + id];
+                hist[idx_buf[id]+(n+3)] += rco_buf[3*vecsize + id];
+                hist[idx_buf[id]+(d+2)*(n+2)] += rco_buf[4*vecsize + id];
+                hist[idx_buf[id]+(d+2)*(n+2)+1] += rco_buf[5*vecsize + id];
+                hist[idx_buf[id]+(d+3)*(n+2)] += rco_buf[6*vecsize + id];
+                hist[idx_buf[id]+(d+3)*(n+2)+1] += rco_buf[7*vecsize + id];
+            }
+        }
+    }
+#endif
+    for( ; k < len_left; k++ )
+    {
+        float rbin = RBin[k], cbin = CBin[k];
+        float obin = (Ori[k] - ori)*bins_per_rad;
+        float mag = Mag[k]*W[k];
+
+        int r0 = cvFloor( rbin );
+        int c0 = cvFloor( cbin );
+        int o0 = cvFloor( obin );
+        rbin -= r0;
+        cbin -= c0;
+        obin -= o0;
+
+        if( o0 < 0 )
+            o0 += n;
+        if( o0 >= n )
+            o0 -= n;
+
+        // histogram update using tri-linear interpolation
+        float v_r1 = mag*rbin, v_r0 = mag - v_r1;
+        float v_rc11 = v_r1*cbin, v_rc10 = v_r1 - v_rc11;
+        float v_rc01 = v_r0*cbin, v_rc00 = v_r0 - v_rc01;
+        float v_rco111 = v_rc11*obin, v_rco110 = v_rc11 - v_rco111;
+        float v_rco101 = v_rc10*obin, v_rco100 = v_rc10 - v_rco101;
+        float v_rco011 = v_rc01*obin, v_rco010 = v_rc01 - v_rco011;
+        float v_rco001 = v_rc00*obin, v_rco000 = v_rc00 - v_rco001;
+
+        int idx = ((r0+1)*(d+2) + c0+1)*(n+2) + o0;
+        hist[idx] += v_rco000;
+        hist[idx+1] += v_rco001;
+        hist[idx+(n+2)] += v_rco010;
+        hist[idx+(n+3)] += v_rco011;
+        hist[idx+(d+2)*(n+2)] += v_rco100;
+        hist[idx+(d+2)*(n+2)+1] += v_rco101;
+        hist[idx+(d+3)*(n+2)] += v_rco110;
+        hist[idx+(d+3)*(n+2)+1] += v_rco111;
+    }
+
+    // finalize histogram, since the orientation histograms are circular
+    for( i = 0; i < d; i++ )
+        for( j = 0; j < d; j++ )
+        {
+            int idx = ((i+1)*(d+2) + (j+1))*(n+2);
+            hist[idx] += hist[idx+n];
+            hist[idx+1] += hist[idx+n+1];
+            for( k = 0; k < n; k++ )
+                rawDst[(i*d + j)*n + k] = hist[idx+k];
+        }
+    // copy histogram to the descriptor,
+    // apply hysteresis thresholding
+    // and scale the result, so that it can be easily converted
+    // to byte array
+    float nrm2 = 0;
+    k = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    {
+        v_float32 __nrm2 = vx_setzero_f32();
+        v_float32 __rawDst;
+        for( ; k <= len_ddn - VTraits<v_float32>::vlanes(); k += VTraits<v_float32>::vlanes() )
+        {
+            __rawDst = vx_load_aligned(rawDst + k);
+            __nrm2 = v_fma(__rawDst, __rawDst, __nrm2);
+        }
+        nrm2 = (float)v_reduce_sum(__nrm2);
+    }
+#endif
+    for( ; k < len_ddn; k++ )
+        nrm2 += rawDst[k]*rawDst[k];
+
+    const float thr = std::sqrt(nrm2)*SIFT_DESCR_MAG_THR;
+
+    i = 0, nrm2 = 0;
+#if 0 //CV_AVX2
+    // This code cannot be enabled because it sums nrm2 in a different order,
+    // thus producing slightly different results
+    {
+        float CV_DECL_ALIGNED(CV_SIMD_WIDTH) nrm2_buf[8];
+        __m256 __dst;
+        __m256 __nrm2 = _mm256_setzero_ps();
+        __m256 __thr = _mm256_set1_ps(thr);
+        for( ; i <= len_ddn - 8; i += 8 )
+        {
+            __dst = _mm256_loadu_ps(&rawDst[i]);
+            __dst = _mm256_min_ps(__dst, __thr);
+            _mm256_storeu_ps(&rawDst[i], __dst);
+#if CV_FMA3
+            __nrm2 = _mm256_fmadd_ps(__dst, __dst, __nrm2);
+#else
+            __nrm2 = _mm256_add_ps(__nrm2, _mm256_mul_ps(__dst, __dst));
+#endif
+        }
+        _mm256_store_ps(nrm2_buf, __nrm2);
+        nrm2 = nrm2_buf[0] + nrm2_buf[1] + nrm2_buf[2] + nrm2_buf[3] +
+               nrm2_buf[4] + nrm2_buf[5] + nrm2_buf[6] + nrm2_buf[7];
+    }
+#endif
+    for( ; i < len_ddn; i++ )
+    {
+        float val = std::min(rawDst[i], thr);
+        rawDst[i] = val;
+        nrm2 += val*val;
+    }
+    nrm2 = SIFT_INT_DESCR_FCTR/std::max(std::sqrt(nrm2), FLT_EPSILON);
+
+#if 1
+    k = 0;
+if( dstMat.type() == CV_32F )
+{
+    float* dst = dstMat.ptr<float>(row);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    v_float32 __dst;
+    v_float32 __min = vx_setzero_f32();
+    v_float32 __max = vx_setall_f32(255.0f); // max of uchar
+    v_float32 __nrm2 = vx_setall_f32(nrm2);
+    for( k = 0; k <= len_ddn - VTraits<v_float32>::vlanes(); k += VTraits<v_float32>::vlanes() )
+    {
+        __dst = vx_load_aligned(rawDst + k);
+        __dst = v_min(v_max(v_cvt_f32(v_round(v_mul(__dst, __nrm2))), __min), __max);
+        v_store(dst + k, __dst);
+    }
+#endif
+#if defined(__GNUC__) && __GNUC__ >= 9
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggressive-loop-optimizations"  // iteration XX invokes undefined behavior
+#endif
+    for( ; k < len_ddn; k++ )
+    {
+        dst[k] = saturate_cast<uchar>(rawDst[k]*nrm2);
+    }
+#if defined(__GNUC__) && __GNUC__ >= 9
+#pragma GCC diagnostic pop
+#endif
+}
+else // CV_8U
+{
+    uint8_t* dst = dstMat.ptr<uint8_t>(row);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    v_float32 __dst0, __dst1;
+    v_uint16 __pack01;
+    v_float32 __nrm2 = vx_setall_f32(nrm2);
+    for( k = 0; k <= len_ddn - VTraits<v_float32>::vlanes() * 2; k += VTraits<v_float32>::vlanes() * 2 )
+    {
+        __dst0 = vx_load_aligned(rawDst + k);
+        __dst1 = vx_load_aligned(rawDst + k + VTraits<v_float32>::vlanes());
+
+        __pack01 = v_pack_u(v_round(v_mul(__dst0, __nrm2)), v_round(v_mul(__dst1, __nrm2)));
+        v_pack_store(dst + k, __pack01);
+    }
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 9
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggressive-loop-optimizations"  // iteration XX invokes undefined behavior
+#endif
+    for( ; k < len_ddn; k++ )
+    {
+        dst[k] = saturate_cast<uchar>(rawDst[k]*nrm2);
+    }
+#if defined(__GNUC__) && __GNUC__ >= 9
+#pragma GCC diagnostic pop
+#endif
+}
+#else
+    float nrm1 = 0;
+    for( k = 0; k < len_ddn; k++ )
+    {
+        rawDst[k] *= nrm2;
+        nrm1 += rawDst[k];
+    }
+    nrm1 = 1.f/std::max(nrm1, FLT_EPSILON);
+    if( dstMat.type() == CV_32F )
+    {
+        float *dst = dstMat.ptr<float>(row);
+        for( k = 0; k < len_ddn; k++ )
+        {
+            dst[k] = std::sqrt(rawDst[k] * nrm1);
+        }
+    }
+    else // CV_8U
+    {
+        uint8_t *dst = dstMat.ptr<uint8_t>(row);
+        for( k = 0; k < len_ddn; k++ )
+        {
+            dst[k] = saturate_cast<uchar>(std::sqrt(rawDst[k] * nrm1)*SIFT_INT_DESCR_FCTR);
+        }
+    }
+#endif
+}
+
+#endif
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+} // namespace
diff --git a/third_party/opencv-5.0.0/modules/flann/CMakeLists.txt b/upstream/opencv/modules/flann/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/CMakeLists.txt
rename to upstream/opencv/modules/flann/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann.hpp b/upstream/opencv/modules/flann/include/opencv2/flann.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann.hpp
rename to upstream/opencv/modules/flann/include/opencv2/flann.hpp
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/all_indices.h b/upstream/opencv/modules/flann/include/opencv2/flann/all_indices.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/all_indices.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/all_indices.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/allocator.h b/upstream/opencv/modules/flann/include/opencv2/flann/allocator.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/allocator.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/allocator.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/any.h b/upstream/opencv/modules/flann/include/opencv2/flann/any.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/any.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/any.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/autotuned_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/autotuned_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/autotuned_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/autotuned_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/composite_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/composite_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/composite_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/composite_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/config.h b/upstream/opencv/modules/flann/include/opencv2/flann/config.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/config.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/config.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/defines.h b/upstream/opencv/modules/flann/include/opencv2/flann/defines.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/defines.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/defines.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dist.h b/upstream/opencv/modules/flann/include/opencv2/flann/dist.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dist.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/dist.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dummy.h b/upstream/opencv/modules/flann/include/opencv2/flann/dummy.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dummy.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/dummy.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dynamic_bitset.h b/upstream/opencv/modules/flann/include/opencv2/flann/dynamic_bitset.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/dynamic_bitset.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/dynamic_bitset.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/flann.hpp b/upstream/opencv/modules/flann/include/opencv2/flann/flann.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/flann.hpp
rename to upstream/opencv/modules/flann/include/opencv2/flann/flann.hpp
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/flann_base.hpp b/upstream/opencv/modules/flann/include/opencv2/flann/flann_base.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/flann_base.hpp
rename to upstream/opencv/modules/flann/include/opencv2/flann/flann_base.hpp
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/general.h b/upstream/opencv/modules/flann/include/opencv2/flann/general.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/general.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/general.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/ground_truth.h b/upstream/opencv/modules/flann/include/opencv2/flann/ground_truth.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/ground_truth.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/ground_truth.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/heap.h b/upstream/opencv/modules/flann/include/opencv2/flann/heap.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/heap.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/heap.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/index_testing.h b/upstream/opencv/modules/flann/include/opencv2/flann/index_testing.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/index_testing.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/index_testing.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kdtree_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/kdtree_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kdtree_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/kdtree_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kdtree_single_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/kdtree_single_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kdtree_single_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/kdtree_single_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kmeans_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/kmeans_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/kmeans_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/kmeans_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/linear_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/linear_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/linear_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/linear_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/logger.h b/upstream/opencv/modules/flann/include/opencv2/flann/logger.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/logger.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/logger.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/lsh_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/lsh_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/lsh_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/lsh_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/lsh_table.h b/upstream/opencv/modules/flann/include/opencv2/flann/lsh_table.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/lsh_table.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/lsh_table.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/matrix.h b/upstream/opencv/modules/flann/include/opencv2/flann/matrix.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/matrix.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/matrix.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/miniflann.hpp b/upstream/opencv/modules/flann/include/opencv2/flann/miniflann.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/miniflann.hpp
rename to upstream/opencv/modules/flann/include/opencv2/flann/miniflann.hpp
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/nn_index.h b/upstream/opencv/modules/flann/include/opencv2/flann/nn_index.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/nn_index.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/nn_index.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/object_factory.h b/upstream/opencv/modules/flann/include/opencv2/flann/object_factory.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/object_factory.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/object_factory.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/params.h b/upstream/opencv/modules/flann/include/opencv2/flann/params.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/params.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/params.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/random.h b/upstream/opencv/modules/flann/include/opencv2/flann/random.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/random.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/random.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/result_set.h b/upstream/opencv/modules/flann/include/opencv2/flann/result_set.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/result_set.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/result_set.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/sampling.h b/upstream/opencv/modules/flann/include/opencv2/flann/sampling.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/sampling.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/sampling.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/saving.h b/upstream/opencv/modules/flann/include/opencv2/flann/saving.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/saving.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/saving.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/simplex_downhill.h b/upstream/opencv/modules/flann/include/opencv2/flann/simplex_downhill.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/simplex_downhill.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/simplex_downhill.h
diff --git a/third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/timer.h b/upstream/opencv/modules/flann/include/opencv2/flann/timer.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/include/opencv2/flann/timer.h
rename to upstream/opencv/modules/flann/include/opencv2/flann/timer.h
diff --git a/third_party/opencv-5.0.0/modules/flann/src/flann.cpp b/upstream/opencv/modules/flann/src/flann.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/src/flann.cpp
rename to upstream/opencv/modules/flann/src/flann.cpp
diff --git a/third_party/opencv-5.0.0/modules/flann/src/miniflann.cpp b/upstream/opencv/modules/flann/src/miniflann.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/src/miniflann.cpp
rename to upstream/opencv/modules/flann/src/miniflann.cpp
diff --git a/third_party/opencv-5.0.0/modules/flann/src/precomp.hpp b/upstream/opencv/modules/flann/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/flann/src/precomp.hpp
rename to upstream/opencv/modules/flann/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/CMakeLists.txt b/upstream/opencv/modules/geometry/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/CMakeLists.txt
rename to upstream/opencv/modules/geometry/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/geometry/doc/geometry.bib b/upstream/opencv/modules/geometry/doc/geometry.bib
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/doc/geometry.bib
rename to upstream/opencv/modules/geometry/doc/geometry.bib
diff --git a/third_party/opencv-5.0.0/modules/geometry/doc/pics/pinhole_homogeneous_transformation.jpg b/upstream/opencv/modules/geometry/doc/pics/pinhole_homogeneous_transformation.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/doc/pics/pinhole_homogeneous_transformation.jpg
rename to upstream/opencv/modules/geometry/doc/pics/pinhole_homogeneous_transformation.jpg
diff --git a/third_party/opencv-5.0.0/modules/geometry/doc/solvePnP.markdown b/upstream/opencv/modules/geometry/doc/solvePnP.markdown
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/doc/solvePnP.markdown
rename to upstream/opencv/modules/geometry/doc/solvePnP.markdown
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/2d.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/2d.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/2d.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/2d.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/3d.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/3d.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/3d.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/3d.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/detail/gcgraph.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/detail/optimizer.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/detail/optimizer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/detail/optimizer.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/detail/optimizer.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/mst.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/mst.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/mst.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/mst.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/segment.hpp b/upstream/opencv/modules/geometry/include/opencv2/geometry/segment.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/include/opencv2/geometry/segment.hpp
rename to upstream/opencv/modules/geometry/include/opencv2/geometry/segment.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ap3p.cpp b/upstream/opencv/modules/geometry/src/ap3p.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ap3p.cpp
rename to upstream/opencv/modules/geometry/src/ap3p.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ap3p.h b/upstream/opencv/modules/geometry/src/ap3p.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ap3p.h
rename to upstream/opencv/modules/geometry/src/ap3p.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/approx.cpp b/upstream/opencv/modules/geometry/src/approx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/approx.cpp
rename to upstream/opencv/modules/geometry/src/approx.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/calibration_base.cpp b/upstream/opencv/modules/geometry/src/calibration_base.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/calibration_base.cpp
rename to upstream/opencv/modules/geometry/src/calibration_base.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/convhull.cpp b/upstream/opencv/modules/geometry/src/convhull.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/convhull.cpp
rename to upstream/opencv/modules/geometry/src/convhull.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/distortion_model.hpp b/upstream/opencv/modules/geometry/src/distortion_model.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/distortion_model.hpp
rename to upstream/opencv/modules/geometry/src/distortion_model.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/epnp.cpp b/upstream/opencv/modules/geometry/src/epnp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/epnp.cpp
rename to upstream/opencv/modules/geometry/src/epnp.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/epnp.h b/upstream/opencv/modules/geometry/src/epnp.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/epnp.h
rename to upstream/opencv/modules/geometry/src/epnp.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/fisheye.cpp b/upstream/opencv/modules/geometry/src/fisheye.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/fisheye.cpp
rename to upstream/opencv/modules/geometry/src/fisheye.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/five-point.cpp b/upstream/opencv/modules/geometry/src/five-point.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/five-point.cpp
rename to upstream/opencv/modules/geometry/src/five-point.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/fundam.cpp b/upstream/opencv/modules/geometry/src/fundam.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/fundam.cpp
rename to upstream/opencv/modules/geometry/src/fundam.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/geometry.cpp b/upstream/opencv/modules/geometry/src/geometry.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/geometry.cpp
rename to upstream/opencv/modules/geometry/src/geometry.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/hal_replacement.hpp b/upstream/opencv/modules/geometry/src/hal_replacement.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/hal_replacement.hpp
rename to upstream/opencv/modules/geometry/src/hal_replacement.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/homography_decomp.cpp b/upstream/opencv/modules/geometry/src/homography_decomp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/homography_decomp.cpp
rename to upstream/opencv/modules/geometry/src/homography_decomp.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/intersection.cpp b/upstream/opencv/modules/geometry/src/intersection.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/intersection.cpp
rename to upstream/opencv/modules/geometry/src/intersection.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ippe.cpp b/upstream/opencv/modules/geometry/src/ippe.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ippe.cpp
rename to upstream/opencv/modules/geometry/src/ippe.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ippe.hpp b/upstream/opencv/modules/geometry/src/ippe.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ippe.hpp
rename to upstream/opencv/modules/geometry/src/ippe.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/levmarq.cpp b/upstream/opencv/modules/geometry/src/levmarq.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/levmarq.cpp
rename to upstream/opencv/modules/geometry/src/levmarq.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/linefit.cpp b/upstream/opencv/modules/geometry/src/linefit.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/linefit.cpp
rename to upstream/opencv/modules/geometry/src/linefit.cpp
diff --git a/upstream/opencv/modules/geometry/src/main.cpp b/upstream/opencv/modules/geometry/src/main.cpp
new file mode 100644
index 0000000..127f86b
--- /dev/null
+++ b/upstream/opencv/modules/geometry/src/main.cpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//
+// Library initialization file
+//
+
+#include "precomp.hpp"
+
+IPP_INITIALIZER_AUTO
+
+/* End of file. */
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/matchcontours.cpp b/upstream/opencv/modules/geometry/src/matchcontours.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/matchcontours.cpp
rename to upstream/opencv/modules/geometry/src/matchcontours.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/min_enclosing_convex_polygon.cpp b/upstream/opencv/modules/geometry/src/min_enclosing_convex_polygon.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/min_enclosing_convex_polygon.cpp
rename to upstream/opencv/modules/geometry/src/min_enclosing_convex_polygon.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/min_enclosing_triangle.cpp b/upstream/opencv/modules/geometry/src/min_enclosing_triangle.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/min_enclosing_triangle.cpp
rename to upstream/opencv/modules/geometry/src/min_enclosing_triangle.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/moments.cpp b/upstream/opencv/modules/geometry/src/moments.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/moments.cpp
rename to upstream/opencv/modules/geometry/src/moments.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/mst.cpp b/upstream/opencv/modules/geometry/src/mst.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/mst.cpp
rename to upstream/opencv/modules/geometry/src/mst.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/opencl/moments.cl b/upstream/opencv/modules/geometry/src/opencl/moments.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/opencl/moments.cl
rename to upstream/opencv/modules/geometry/src/opencl/moments.cl
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/p3p.cpp b/upstream/opencv/modules/geometry/src/p3p.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/p3p.cpp
rename to upstream/opencv/modules/geometry/src/p3p.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/p3p.h b/upstream/opencv/modules/geometry/src/p3p.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/p3p.h
rename to upstream/opencv/modules/geometry/src/p3p.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/pcc.h b/upstream/opencv/modules/geometry/src/pcc.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/pcc.h
rename to upstream/opencv/modules/geometry/src/pcc.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/pinhole.cpp b/upstream/opencv/modules/geometry/src/pinhole.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/pinhole.cpp
rename to upstream/opencv/modules/geometry/src/pinhole.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/polynom_solver.cpp b/upstream/opencv/modules/geometry/src/polynom_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/polynom_solver.cpp
rename to upstream/opencv/modules/geometry/src/polynom_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/polynom_solver.h b/upstream/opencv/modules/geometry/src/polynom_solver.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/polynom_solver.h
rename to upstream/opencv/modules/geometry/src/polynom_solver.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/precomp.hpp b/upstream/opencv/modules/geometry/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/precomp.hpp
rename to upstream/opencv/modules/geometry/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/normal_estimation.cpp b/upstream/opencv/modules/geometry/src/ptcloud/normal_estimation.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/normal_estimation.cpp
rename to upstream/opencv/modules/geometry/src/ptcloud/normal_estimation.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_utils.cpp b/upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_utils.cpp
rename to upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_utils.hpp b/upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_utils.hpp
rename to upstream/opencv/modules/geometry/src/ptcloud/ptcloud_utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_wrapper.hpp b/upstream/opencv/modules/geometry/src/ptcloud/ptcloud_wrapper.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/ptcloud_wrapper.hpp
rename to upstream/opencv/modules/geometry/src/ptcloud/ptcloud_wrapper.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/region_growing_3d.cpp b/upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/region_growing_3d.cpp
rename to upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/region_growing_3d.hpp b/upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/region_growing_3d.hpp
rename to upstream/opencv/modules/geometry/src/ptcloud/region_growing_3d.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sac_segmentation.cpp b/upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sac_segmentation.cpp
rename to upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sac_segmentation.hpp b/upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sac_segmentation.hpp
rename to upstream/opencv/modules/geometry/src/ptcloud/sac_segmentation.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sampling.cpp b/upstream/opencv/modules/geometry/src/ptcloud/sampling.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptcloud/sampling.cpp
rename to upstream/opencv/modules/geometry/src/ptcloud/sampling.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/ptsetreg.cpp b/upstream/opencv/modules/geometry/src/ptsetreg.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/ptsetreg.cpp
rename to upstream/opencv/modules/geometry/src/ptsetreg.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/rho.cpp b/upstream/opencv/modules/geometry/src/rho.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/rho.cpp
rename to upstream/opencv/modules/geometry/src/rho.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/rho.h b/upstream/opencv/modules/geometry/src/rho.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/rho.h
rename to upstream/opencv/modules/geometry/src/rho.h
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/rotcalipers.cpp b/upstream/opencv/modules/geometry/src/rotcalipers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/rotcalipers.cpp
rename to upstream/opencv/modules/geometry/src/rotcalipers.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/shapedescr.cpp b/upstream/opencv/modules/geometry/src/shapedescr.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/shapedescr.cpp
rename to upstream/opencv/modules/geometry/src/shapedescr.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/solvepnp.cpp b/upstream/opencv/modules/geometry/src/solvepnp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/solvepnp.cpp
rename to upstream/opencv/modules/geometry/src/solvepnp.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/sqpnp.cpp b/upstream/opencv/modules/geometry/src/sqpnp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/sqpnp.cpp
rename to upstream/opencv/modules/geometry/src/sqpnp.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/sqpnp.hpp b/upstream/opencv/modules/geometry/src/sqpnp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/sqpnp.hpp
rename to upstream/opencv/modules/geometry/src/sqpnp.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/subdivision2d.cpp b/upstream/opencv/modules/geometry/src/subdivision2d.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/subdivision2d.cpp
rename to upstream/opencv/modules/geometry/src/subdivision2d.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/triangulate.cpp b/upstream/opencv/modules/geometry/src/triangulate.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/triangulate.cpp
rename to upstream/opencv/modules/geometry/src/triangulate.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac.hpp b/upstream/opencv/modules/geometry/src/usac.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac.hpp
rename to upstream/opencv/modules/geometry/src/usac.hpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/bundle.cpp b/upstream/opencv/modules/geometry/src/usac/bundle.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/bundle.cpp
rename to upstream/opencv/modules/geometry/src/usac/bundle.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/degeneracy.cpp b/upstream/opencv/modules/geometry/src/usac/degeneracy.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/degeneracy.cpp
rename to upstream/opencv/modules/geometry/src/usac/degeneracy.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/dls_solver.cpp b/upstream/opencv/modules/geometry/src/usac/dls_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/dls_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/dls_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/essential_solver.cpp b/upstream/opencv/modules/geometry/src/usac/essential_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/essential_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/essential_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/estimator.cpp b/upstream/opencv/modules/geometry/src/usac/estimator.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/estimator.cpp
rename to upstream/opencv/modules/geometry/src/usac/estimator.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/fundamental_solver.cpp b/upstream/opencv/modules/geometry/src/usac/fundamental_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/fundamental_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/fundamental_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/gamma_values.cpp b/upstream/opencv/modules/geometry/src/usac/gamma_values.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/gamma_values.cpp
rename to upstream/opencv/modules/geometry/src/usac/gamma_values.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/homography_solver.cpp b/upstream/opencv/modules/geometry/src/usac/homography_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/homography_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/homography_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/local_optimization.cpp b/upstream/opencv/modules/geometry/src/usac/local_optimization.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/local_optimization.cpp
rename to upstream/opencv/modules/geometry/src/usac/local_optimization.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/plane_solver.cpp b/upstream/opencv/modules/geometry/src/usac/plane_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/plane_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/plane_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/pnp_solver.cpp b/upstream/opencv/modules/geometry/src/usac/pnp_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/pnp_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/pnp_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/quality.cpp b/upstream/opencv/modules/geometry/src/usac/quality.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/quality.cpp
rename to upstream/opencv/modules/geometry/src/usac/quality.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/ransac_solvers.cpp b/upstream/opencv/modules/geometry/src/usac/ransac_solvers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/ransac_solvers.cpp
rename to upstream/opencv/modules/geometry/src/usac/ransac_solvers.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/sampler.cpp b/upstream/opencv/modules/geometry/src/usac/sampler.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/sampler.cpp
rename to upstream/opencv/modules/geometry/src/usac/sampler.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/sphere_solver.cpp b/upstream/opencv/modules/geometry/src/usac/sphere_solver.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/sphere_solver.cpp
rename to upstream/opencv/modules/geometry/src/usac/sphere_solver.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/termination.cpp b/upstream/opencv/modules/geometry/src/usac/termination.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/termination.cpp
rename to upstream/opencv/modules/geometry/src/usac/termination.cpp
diff --git a/third_party/opencv-5.0.0/modules/geometry/src/usac/utils.cpp b/upstream/opencv/modules/geometry/src/usac/utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/geometry/src/usac/utils.cpp
rename to upstream/opencv/modules/geometry/src/usac/utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/CMakeLists.txt b/upstream/opencv/modules/highgui/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/CMakeLists.txt
rename to upstream/opencv/modules/highgui/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/detect_framebuffer.cmake b/upstream/opencv/modules/highgui/cmake/detect_framebuffer.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/detect_framebuffer.cmake
rename to upstream/opencv/modules/highgui/cmake/detect_framebuffer.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/detect_gtk.cmake b/upstream/opencv/modules/highgui/cmake/detect_gtk.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/detect_gtk.cmake
rename to upstream/opencv/modules/highgui/cmake/detect_gtk.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/detect_wayland.cmake b/upstream/opencv/modules/highgui/cmake/detect_wayland.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/detect_wayland.cmake
rename to upstream/opencv/modules/highgui/cmake/detect_wayland.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/detect_win32ui.cmake b/upstream/opencv/modules/highgui/cmake/detect_win32ui.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/detect_win32ui.cmake
rename to upstream/opencv/modules/highgui/cmake/detect_win32ui.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/init.cmake b/upstream/opencv/modules/highgui/cmake/init.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/init.cmake
rename to upstream/opencv/modules/highgui/cmake/init.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/cmake/plugin.cmake b/upstream/opencv/modules/highgui/cmake/plugin.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/cmake/plugin.cmake
rename to upstream/opencv/modules/highgui/cmake/plugin.cmake
diff --git a/third_party/opencv-5.0.0/modules/highgui/doc/highgui_qt.cpp b/upstream/opencv/modules/highgui/doc/highgui_qt.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/doc/highgui_qt.cpp
rename to upstream/opencv/modules/highgui/doc/highgui_qt.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/doc/pics/qtgui.png b/upstream/opencv/modules/highgui/doc/pics/qtgui.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/doc/pics/qtgui.png
rename to upstream/opencv/modules/highgui/doc/pics/qtgui.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui.hpp b/upstream/opencv/modules/highgui/include/opencv2/highgui.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui.hpp
rename to upstream/opencv/modules/highgui/include/opencv2/highgui.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui/highgui.hpp b/upstream/opencv/modules/highgui/include/opencv2/highgui/highgui.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui/highgui.hpp
rename to upstream/opencv/modules/highgui/include/opencv2/highgui/highgui.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui/highgui_winrt.hpp b/upstream/opencv/modules/highgui/include/opencv2/highgui/highgui_winrt.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/include/opencv2/highgui/highgui_winrt.hpp
rename to upstream/opencv/modules/highgui/include/opencv2/highgui/highgui_winrt.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/misc/plugins/build_plugins.sh b/upstream/opencv/modules/highgui/misc/plugins/build_plugins.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/misc/plugins/build_plugins.sh
rename to upstream/opencv/modules/highgui/misc/plugins/build_plugins.sh
diff --git a/third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt b/upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt
rename to upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2 b/upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2
rename to upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk2
diff --git a/third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk3 b/upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk3
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk3
rename to upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/Dockerfile-ubuntu-gtk3
diff --git a/third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/build.sh b/upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/misc/plugins/plugin_gtk/build.sh
rename to upstream/opencv/modules/highgui/misc/plugins/plugin_gtk/build.sh
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/backend.cpp b/upstream/opencv/modules/highgui/src/backend.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/backend.cpp
rename to upstream/opencv/modules/highgui/src/backend.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/backend.hpp b/upstream/opencv/modules/highgui/src/backend.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/backend.hpp
rename to upstream/opencv/modules/highgui/src/backend.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/factory.hpp b/upstream/opencv/modules/highgui/src/factory.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/factory.hpp
rename to upstream/opencv/modules/highgui/src/factory.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/106.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/106.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/106.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/106.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/107.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/107.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/107.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/107.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/19.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/19.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/19.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/19.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/23.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/23.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/23.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/23.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/24.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/24.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/24.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/24.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/27.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/27.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/27.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/27.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/28.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/28.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/28.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/28.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/38.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/38.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/38.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/38.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/43.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/43.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/43.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/43.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/61.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/61.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/61.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/61.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/7.png b/upstream/opencv/modules/highgui/src/files_Qt/Material/7.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/7.png
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/7.png
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/LICENSE b/upstream/opencv/modules/highgui/src/files_Qt/Material/LICENSE
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/LICENSE
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/LICENSE
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/Readme.txt b/upstream/opencv/modules/highgui/src/files_Qt/Material/Readme.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/files_Qt/Material/Readme.txt
rename to upstream/opencv/modules/highgui/src/files_Qt/Material/Readme.txt
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/plugin_api.hpp b/upstream/opencv/modules/highgui/src/plugin_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/plugin_api.hpp
rename to upstream/opencv/modules/highgui/src/plugin_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/plugin_wrapper.impl.hpp b/upstream/opencv/modules/highgui/src/plugin_wrapper.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/plugin_wrapper.impl.hpp
rename to upstream/opencv/modules/highgui/src/plugin_wrapper.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/precomp.hpp b/upstream/opencv/modules/highgui/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/precomp.hpp
rename to upstream/opencv/modules/highgui/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/registry.hpp b/upstream/opencv/modules/highgui/src/registry.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/registry.hpp
rename to upstream/opencv/modules/highgui/src/registry.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/registry.impl.hpp b/upstream/opencv/modules/highgui/src/registry.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/registry.impl.hpp
rename to upstream/opencv/modules/highgui/src/registry.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/roiSelector.cpp b/upstream/opencv/modules/highgui/src/roiSelector.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/roiSelector.cpp
rename to upstream/opencv/modules/highgui/src/roiSelector.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window.cpp b/upstream/opencv/modules/highgui/src/window.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window.cpp
rename to upstream/opencv/modules/highgui/src/window.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_QT.cpp b/upstream/opencv/modules/highgui/src/window_QT.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_QT.cpp
rename to upstream/opencv/modules/highgui/src/window_QT.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_QT.h b/upstream/opencv/modules/highgui/src/window_QT.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_QT.h
rename to upstream/opencv/modules/highgui/src/window_QT.h
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_QT.qrc b/upstream/opencv/modules/highgui/src/window_QT.qrc
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_QT.qrc
rename to upstream/opencv/modules/highgui/src/window_QT.qrc
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_cocoa.mm b/upstream/opencv/modules/highgui/src/window_cocoa.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_cocoa.mm
rename to upstream/opencv/modules/highgui/src/window_cocoa.mm
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_framebuffer.cpp b/upstream/opencv/modules/highgui/src/window_framebuffer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_framebuffer.cpp
rename to upstream/opencv/modules/highgui/src/window_framebuffer.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_framebuffer.hpp b/upstream/opencv/modules/highgui/src/window_framebuffer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_framebuffer.hpp
rename to upstream/opencv/modules/highgui/src/window_framebuffer.hpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_gtk.cpp b/upstream/opencv/modules/highgui/src/window_gtk.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_gtk.cpp
rename to upstream/opencv/modules/highgui/src/window_gtk.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_w32.cpp b/upstream/opencv/modules/highgui/src/window_w32.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_w32.cpp
rename to upstream/opencv/modules/highgui/src/window_w32.cpp
diff --git a/third_party/opencv-5.0.0/modules/highgui/src/window_wayland.cpp b/upstream/opencv/modules/highgui/src/window_wayland.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/highgui/src/window_wayland.cpp
rename to upstream/opencv/modules/highgui/src/window_wayland.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/CMakeLists.txt b/upstream/opencv/modules/imgcodecs/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/CMakeLists.txt
rename to upstream/opencv/modules/imgcodecs/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs.hpp b/upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs.hpp
rename to upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp b/upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp
rename to upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/ios.h b/upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/ios.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/ios.h
rename to upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/ios.h
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/macosx.h b/upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/macosx.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/include/opencv2/imgcodecs/macosx.h
rename to upstream/opencv/modules/imgcodecs/include/opencv2/imgcodecs/macosx.h
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/apple_conversions.h b/upstream/opencv/modules/imgcodecs/src/apple_conversions.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/apple_conversions.h
rename to upstream/opencv/modules/imgcodecs/src/apple_conversions.h
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/apple_conversions.mm b/upstream/opencv/modules/imgcodecs/src/apple_conversions.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/apple_conversions.mm
rename to upstream/opencv/modules/imgcodecs/src/apple_conversions.mm
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/bitstrm.cpp b/upstream/opencv/modules/imgcodecs/src/bitstrm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/bitstrm.cpp
rename to upstream/opencv/modules/imgcodecs/src/bitstrm.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/bitstrm.hpp b/upstream/opencv/modules/imgcodecs/src/bitstrm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/bitstrm.hpp
rename to upstream/opencv/modules/imgcodecs/src/bitstrm.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/exif.cpp b/upstream/opencv/modules/imgcodecs/src/exif.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/exif.cpp
rename to upstream/opencv/modules/imgcodecs/src/exif.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/exif.hpp b/upstream/opencv/modules/imgcodecs/src/exif.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/exif.hpp
rename to upstream/opencv/modules/imgcodecs/src/exif.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_avif.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_avif.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_avif.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_avif.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_avif.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_avif.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_avif.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_avif.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_base.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_base.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_base.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_base.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_base.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_base.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_base.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_base.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_bmp.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_bmp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_bmp.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_bmp.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_bmp.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_bmp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_bmp.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_bmp.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_exr.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_exr.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_exr.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_exr.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_exr.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_exr.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_exr.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_exr.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdal.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gdal.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdal.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gdal.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdal.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gdal.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdal.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gdal.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdcm.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdcm.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdcm.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gdcm.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gdcm.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gif.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gif.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gif.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gif.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gif.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_gif.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_gif.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_gif.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_hdr.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_hdr.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_hdr.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_hdr.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_hdr.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_hdr.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_hdr.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_hdr.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpegxl.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpegxl.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpegxl.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_jpegxl.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_jpegxl.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pam.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pam.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pam.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pam.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pam.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pam.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pam.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pam.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pfm.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pfm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pfm.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pfm.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pfm.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pfm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pfm.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pfm.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_png.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_png.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_png.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_png.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_png.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_png.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_png.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pxm.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pxm.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pxm.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pxm.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pxm.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_pxm.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_pxm.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_pxm.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_spng.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_spng.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_spng.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_spng.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_spng.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_spng.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_spng.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_sunras.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_sunras.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_sunras.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_sunras.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_sunras.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_sunras.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_sunras.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_sunras.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_tiff.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_tiff.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_tiff.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_tiff.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_tiff.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_tiff.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_tiff.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_webp.cpp b/upstream/opencv/modules/imgcodecs/src/grfmt_webp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_webp.cpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_webp.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_webp.hpp b/upstream/opencv/modules/imgcodecs/src/grfmt_webp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmt_webp.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmt_webp.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/grfmts.hpp b/upstream/opencv/modules/imgcodecs/src/grfmts.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/grfmts.hpp
rename to upstream/opencv/modules/imgcodecs/src/grfmts.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/ios_conversions.mm b/upstream/opencv/modules/imgcodecs/src/ios_conversions.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/ios_conversions.mm
rename to upstream/opencv/modules/imgcodecs/src/ios_conversions.mm
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/loadsave.cpp b/upstream/opencv/modules/imgcodecs/src/loadsave.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/loadsave.cpp
rename to upstream/opencv/modules/imgcodecs/src/loadsave.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/macosx_conversions.mm b/upstream/opencv/modules/imgcodecs/src/macosx_conversions.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/macosx_conversions.mm
rename to upstream/opencv/modules/imgcodecs/src/macosx_conversions.mm
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/precomp.hpp b/upstream/opencv/modules/imgcodecs/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/precomp.hpp
rename to upstream/opencv/modules/imgcodecs/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/rgbe.cpp b/upstream/opencv/modules/imgcodecs/src/rgbe.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/rgbe.cpp
rename to upstream/opencv/modules/imgcodecs/src/rgbe.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/rgbe.hpp b/upstream/opencv/modules/imgcodecs/src/rgbe.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/rgbe.hpp
rename to upstream/opencv/modules/imgcodecs/src/rgbe.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/utils.cpp b/upstream/opencv/modules/imgcodecs/src/utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/utils.cpp
rename to upstream/opencv/modules/imgcodecs/src/utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgcodecs/src/utils.hpp b/upstream/opencv/modules/imgcodecs/src/utils.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgcodecs/src/utils.hpp
rename to upstream/opencv/modules/imgcodecs/src/utils.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/CMakeLists.txt b/upstream/opencv/modules/imgproc/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/CMakeLists.txt
rename to upstream/opencv/modules/imgproc/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/colors.markdown b/upstream/opencv/modules/imgproc/doc/colors.markdown
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/colors.markdown
rename to upstream/opencv/modules/imgproc/doc/colors.markdown
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/Bayer_patterns.png b/upstream/opencv/modules/imgproc/doc/pics/Bayer_patterns.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/Bayer_patterns.png
rename to upstream/opencv/modules/imgproc/doc/pics/Bayer_patterns.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/backprojectpatch.png b/upstream/opencv/modules/imgproc/doc/pics/backprojectpatch.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/backprojectpatch.png
rename to upstream/opencv/modules/imgproc/doc/pics/backprojectpatch.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/bayer.png b/upstream/opencv/modules/imgproc/doc/pics/bayer.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/bayer.png
rename to upstream/opencv/modules/imgproc/doc/pics/bayer.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/boundingrect.png b/upstream/opencv/modules/imgproc/doc/pics/boundingrect.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/boundingrect.png
rename to upstream/opencv/modules/imgproc/doc/pics/boundingrect.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/building.jpg b/upstream/opencv/modules/imgproc/doc/pics/building.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/building.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/building.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/building_lsd.png b/upstream/opencv/modules/imgproc/doc/pics/building_lsd.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/building_lsd.png
rename to upstream/opencv/modules/imgproc/doc/pics/building_lsd.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_autumn.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_autumn.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_autumn.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_autumn.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_bone.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_bone.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_bone.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_bone.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_cividis.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_cividis.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_cividis.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_cividis.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_cool.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_cool.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_cool.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_cool.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_deepgreen.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_deepgreen.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_deepgreen.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_deepgreen.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_hot.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_hot.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_hot.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_hot.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_hsv.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_hsv.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_hsv.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_hsv.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_inferno.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_inferno.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_inferno.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_inferno.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_jet.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_jet.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_jet.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_jet.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_magma.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_magma.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_magma.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_magma.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_mkpj1.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_mkpj1.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_mkpj1.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_mkpj1.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_mkpj2.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_mkpj2.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_mkpj2.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_mkpj2.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_ocean.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_ocean.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_ocean.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_ocean.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_parula.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_parula.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_parula.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_parula.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_pink.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_pink.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_pink.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_pink.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_plasma.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_plasma.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_plasma.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_plasma.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_rainbow.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_rainbow.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_rainbow.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_rainbow.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_spring.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_spring.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_spring.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_spring.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_summer.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_summer.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_summer.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_summer.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_turbo.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_turbo.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_turbo.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_turbo.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_twilight.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_twilight.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_twilight.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_twilight.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_twilight_shifted.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_twilight_shifted.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_twilight_shifted.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_twilight_shifted.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_viridis.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_viridis.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_viridis.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_viridis.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_winter.jpg b/upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_winter.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/colormaps/colorscale_winter.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/colormaps/colorscale_winter.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/contoursecarea.png b/upstream/opencv/modules/imgproc/doc/pics/contoursecarea.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/contoursecarea.png
rename to upstream/opencv/modules/imgproc/doc/pics/contoursecarea.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/cornersubpix.png b/upstream/opencv/modules/imgproc/doc/pics/cornersubpix.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/cornersubpix.png
rename to upstream/opencv/modules/imgproc/doc/pics/cornersubpix.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/defects.png b/upstream/opencv/modules/imgproc/doc/pics/defects.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/defects.png
rename to upstream/opencv/modules/imgproc/doc/pics/defects.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/delaunay_voronoi.png b/upstream/opencv/modules/imgproc/doc/pics/delaunay_voronoi.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/delaunay_voronoi.png
rename to upstream/opencv/modules/imgproc/doc/pics/delaunay_voronoi.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/ellipse.svg b/upstream/opencv/modules/imgproc/doc/pics/ellipse.svg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/ellipse.svg
rename to upstream/opencv/modules/imgproc/doc/pics/ellipse.svg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/houghp.png b/upstream/opencv/modules/imgproc/doc/pics/houghp.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/houghp.png
rename to upstream/opencv/modules/imgproc/doc/pics/houghp.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/integral.png b/upstream/opencv/modules/imgproc/doc/pics/integral.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/integral.png
rename to upstream/opencv/modules/imgproc/doc/pics/integral.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/intersection.png b/upstream/opencv/modules/imgproc/doc/pics/intersection.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/intersection.png
rename to upstream/opencv/modules/imgproc/doc/pics/intersection.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/inv_logpolar.jpg b/upstream/opencv/modules/imgproc/doc/pics/inv_logpolar.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/inv_logpolar.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/inv_logpolar.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/logpolar.jpg b/upstream/opencv/modules/imgproc/doc/pics/logpolar.jpg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/logpolar.jpg
rename to upstream/opencv/modules/imgproc/doc/pics/logpolar.jpg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/minareabox.png b/upstream/opencv/modules/imgproc/doc/pics/minareabox.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/minareabox.png
rename to upstream/opencv/modules/imgproc/doc/pics/minareabox.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/minenclosingtriangle.png b/upstream/opencv/modules/imgproc/doc/pics/minenclosingtriangle.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/minenclosingtriangle.png
rename to upstream/opencv/modules/imgproc/doc/pics/minenclosingtriangle.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/pointpolygon.png b/upstream/opencv/modules/imgproc/doc/pics/pointpolygon.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/pointpolygon.png
rename to upstream/opencv/modules/imgproc/doc/pics/pointpolygon.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/polar_remap_doc.png b/upstream/opencv/modules/imgproc/doc/pics/polar_remap_doc.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/polar_remap_doc.png
rename to upstream/opencv/modules/imgproc/doc/pics/polar_remap_doc.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/polar_remap_doc.svg b/upstream/opencv/modules/imgproc/doc/pics/polar_remap_doc.svg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/polar_remap_doc.svg
rename to upstream/opencv/modules/imgproc/doc/pics/polar_remap_doc.svg
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/quadedge.png b/upstream/opencv/modules/imgproc/doc/pics/quadedge.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/quadedge.png
rename to upstream/opencv/modules/imgproc/doc/pics/quadedge.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/subdiv.png b/upstream/opencv/modules/imgproc/doc/pics/subdiv.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/subdiv.png
rename to upstream/opencv/modules/imgproc/doc/pics/subdiv.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/doc/pics/threshold.png b/upstream/opencv/modules/imgproc/doc/pics/threshold.png
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/doc/pics/threshold.png
rename to upstream/opencv/modules/imgproc/doc/pics/threshold.png
diff --git a/third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik-Italic.ttf.gz b/upstream/opencv/modules/imgproc/fonts/Rubik-Italic.ttf.gz
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik-Italic.ttf.gz
rename to upstream/opencv/modules/imgproc/fonts/Rubik-Italic.ttf.gz
diff --git a/third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik.ttf.gz b/upstream/opencv/modules/imgproc/fonts/Rubik.ttf.gz
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik.ttf.gz
rename to upstream/opencv/modules/imgproc/fonts/Rubik.ttf.gz
diff --git a/third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik_OFL.txt b/upstream/opencv/modules/imgproc/fonts/Rubik_OFL.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/fonts/Rubik_OFL.txt
rename to upstream/opencv/modules/imgproc/fonts/Rubik_OFL.txt
diff --git a/third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc.hpp b/upstream/opencv/modules/imgproc/include/opencv2/imgproc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc.hpp
rename to upstream/opencv/modules/imgproc/include/opencv2/imgproc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/bindings.hpp b/upstream/opencv/modules/imgproc/include/opencv2/imgproc/bindings.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/bindings.hpp
rename to upstream/opencv/modules/imgproc/include/opencv2/imgproc/bindings.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/hal/hal.hpp b/upstream/opencv/modules/imgproc/include/opencv2/imgproc/hal/hal.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/hal/hal.hpp
rename to upstream/opencv/modules/imgproc/include/opencv2/imgproc/hal/hal.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/hal/interface.h b/upstream/opencv/modules/imgproc/include/opencv2/imgproc/hal/interface.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/hal/interface.h
rename to upstream/opencv/modules/imgproc/include/opencv2/imgproc/hal/interface.h
diff --git a/third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/upstream/opencv/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
rename to upstream/opencv/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/accum.cpp b/upstream/opencv/modules/imgproc/src/accum.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/accum.cpp
rename to upstream/opencv/modules/imgproc/src/accum.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/accum.dispatch.cpp b/upstream/opencv/modules/imgproc/src/accum.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/accum.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/accum.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/accum.simd.hpp b/upstream/opencv/modules/imgproc/src/accum.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/accum.simd.hpp
rename to upstream/opencv/modules/imgproc/src/accum.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/bilateral_filter.dispatch.cpp b/upstream/opencv/modules/imgproc/src/bilateral_filter.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/bilateral_filter.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/bilateral_filter.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/bilateral_filter.simd.hpp b/upstream/opencv/modules/imgproc/src/bilateral_filter.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/bilateral_filter.simd.hpp
rename to upstream/opencv/modules/imgproc/src/bilateral_filter.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/blend.cpp b/upstream/opencv/modules/imgproc/src/blend.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/blend.cpp
rename to upstream/opencv/modules/imgproc/src/blend.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/box_filter.dispatch.cpp b/upstream/opencv/modules/imgproc/src/box_filter.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/box_filter.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/box_filter.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/box_filter.simd.hpp b/upstream/opencv/modules/imgproc/src/box_filter.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/box_filter.simd.hpp
rename to upstream/opencv/modules/imgproc/src/box_filter.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/canny.cpp b/upstream/opencv/modules/imgproc/src/canny.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/canny.cpp
rename to upstream/opencv/modules/imgproc/src/canny.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest.inc.hpp b/upstream/opencv/modules/imgproc/src/ccl_bolelli_forest.inc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest.inc.hpp
rename to upstream/opencv/modules/imgproc/src/ccl_bolelli_forest.inc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_firstline.inc.hpp b/upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_firstline.inc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_firstline.inc.hpp
rename to upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_firstline.inc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_lastline.inc.hpp b/upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_lastline.inc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_lastline.inc.hpp
rename to upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_lastline.inc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_singleline.inc.hpp b/upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_singleline.inc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/ccl_bolelli_forest_singleline.inc.hpp
rename to upstream/opencv/modules/imgproc/src/ccl_bolelli_forest_singleline.inc.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/clahe.cpp b/upstream/opencv/modules/imgproc/src/clahe.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/clahe.cpp
rename to upstream/opencv/modules/imgproc/src/clahe.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color.cpp b/upstream/opencv/modules/imgproc/src/color.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color.cpp
rename to upstream/opencv/modules/imgproc/src/color.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color.hpp b/upstream/opencv/modules/imgproc/src/color.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color.hpp
rename to upstream/opencv/modules/imgproc/src/color.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color.simd_helpers.hpp b/upstream/opencv/modules/imgproc/src/color.simd_helpers.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color.simd_helpers.hpp
rename to upstream/opencv/modules/imgproc/src/color.simd_helpers.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_hsv.dispatch.cpp b/upstream/opencv/modules/imgproc/src/color_hsv.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_hsv.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/color_hsv.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_hsv.simd.hpp b/upstream/opencv/modules/imgproc/src/color_hsv.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_hsv.simd.hpp
rename to upstream/opencv/modules/imgproc/src/color_hsv.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_lab.cpp b/upstream/opencv/modules/imgproc/src/color_lab.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_lab.cpp
rename to upstream/opencv/modules/imgproc/src/color_lab.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_rgb.dispatch.cpp b/upstream/opencv/modules/imgproc/src/color_rgb.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_rgb.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/color_rgb.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_rgb.simd.hpp b/upstream/opencv/modules/imgproc/src/color_rgb.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_rgb.simd.hpp
rename to upstream/opencv/modules/imgproc/src/color_rgb.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_yuv.dispatch.cpp b/upstream/opencv/modules/imgproc/src/color_yuv.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_yuv.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/color_yuv.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/color_yuv.simd.hpp b/upstream/opencv/modules/imgproc/src/color_yuv.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/color_yuv.simd.hpp
rename to upstream/opencv/modules/imgproc/src/color_yuv.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/colormap.cpp b/upstream/opencv/modules/imgproc/src/colormap.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/colormap.cpp
rename to upstream/opencv/modules/imgproc/src/colormap.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/connectedcomponents.cpp b/upstream/opencv/modules/imgproc/src/connectedcomponents.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/connectedcomponents.cpp
rename to upstream/opencv/modules/imgproc/src/connectedcomponents.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_approx.cpp b/upstream/opencv/modules/imgproc/src/contours_approx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_approx.cpp
rename to upstream/opencv/modules/imgproc/src/contours_approx.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_blockstorage.hpp b/upstream/opencv/modules/imgproc/src/contours_blockstorage.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_blockstorage.hpp
rename to upstream/opencv/modules/imgproc/src/contours_blockstorage.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_common.cpp b/upstream/opencv/modules/imgproc/src/contours_common.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_common.cpp
rename to upstream/opencv/modules/imgproc/src/contours_common.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_common.hpp b/upstream/opencv/modules/imgproc/src/contours_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_common.hpp
rename to upstream/opencv/modules/imgproc/src/contours_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_link.cpp b/upstream/opencv/modules/imgproc/src/contours_link.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_link.cpp
rename to upstream/opencv/modules/imgproc/src/contours_link.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_new.cpp b/upstream/opencv/modules/imgproc/src/contours_new.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_new.cpp
rename to upstream/opencv/modules/imgproc/src/contours_new.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/contours_truco.cpp b/upstream/opencv/modules/imgproc/src/contours_truco.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/contours_truco.cpp
rename to upstream/opencv/modules/imgproc/src/contours_truco.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/corner.avx.cpp b/upstream/opencv/modules/imgproc/src/corner.avx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/corner.avx.cpp
rename to upstream/opencv/modules/imgproc/src/corner.avx.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/corner.cpp b/upstream/opencv/modules/imgproc/src/corner.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/corner.cpp
rename to upstream/opencv/modules/imgproc/src/corner.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/corner.hpp b/upstream/opencv/modules/imgproc/src/corner.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/corner.hpp
rename to upstream/opencv/modules/imgproc/src/corner.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/cornersubpix.cpp b/upstream/opencv/modules/imgproc/src/cornersubpix.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/cornersubpix.cpp
rename to upstream/opencv/modules/imgproc/src/cornersubpix.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/demosaicing.cpp b/upstream/opencv/modules/imgproc/src/demosaicing.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/demosaicing.cpp
rename to upstream/opencv/modules/imgproc/src/demosaicing.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/deriv.cpp b/upstream/opencv/modules/imgproc/src/deriv.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/deriv.cpp
rename to upstream/opencv/modules/imgproc/src/deriv.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/distortion_model.hpp b/upstream/opencv/modules/imgproc/src/distortion_model.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/distortion_model.hpp
rename to upstream/opencv/modules/imgproc/src/distortion_model.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/distransform.cpp b/upstream/opencv/modules/imgproc/src/distransform.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/distransform.cpp
rename to upstream/opencv/modules/imgproc/src/distransform.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/drawing.cpp b/upstream/opencv/modules/imgproc/src/drawing.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/drawing.cpp
rename to upstream/opencv/modules/imgproc/src/drawing.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/drawing_text.cpp b/upstream/opencv/modules/imgproc/src/drawing_text.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/drawing_text.cpp
rename to upstream/opencv/modules/imgproc/src/drawing_text.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/emd_new.cpp b/upstream/opencv/modules/imgproc/src/emd_new.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/emd_new.cpp
rename to upstream/opencv/modules/imgproc/src/emd_new.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/filter.dispatch.cpp b/upstream/opencv/modules/imgproc/src/filter.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/filter.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/filter.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/filter.hpp b/upstream/opencv/modules/imgproc/src/filter.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/filter.hpp
rename to upstream/opencv/modules/imgproc/src/filter.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/filter.simd.hpp b/upstream/opencv/modules/imgproc/src/filter.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/filter.simd.hpp
rename to upstream/opencv/modules/imgproc/src/filter.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/filterengine.hpp b/upstream/opencv/modules/imgproc/src/filterengine.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/filterengine.hpp
rename to upstream/opencv/modules/imgproc/src/filterengine.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/fisheye.cpp b/upstream/opencv/modules/imgproc/src/fisheye.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/fisheye.cpp
rename to upstream/opencv/modules/imgproc/src/fisheye.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/fixedpoint.inl.hpp b/upstream/opencv/modules/imgproc/src/fixedpoint.inl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/fixedpoint.inl.hpp
rename to upstream/opencv/modules/imgproc/src/fixedpoint.inl.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/floodfill.cpp b/upstream/opencv/modules/imgproc/src/floodfill.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/floodfill.cpp
rename to upstream/opencv/modules/imgproc/src/floodfill.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/gabor.cpp b/upstream/opencv/modules/imgproc/src/gabor.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/gabor.cpp
rename to upstream/opencv/modules/imgproc/src/gabor.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/generalized_hough.cpp b/upstream/opencv/modules/imgproc/src/generalized_hough.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/generalized_hough.cpp
rename to upstream/opencv/modules/imgproc/src/generalized_hough.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/grabcut.cpp b/upstream/opencv/modules/imgproc/src/grabcut.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/grabcut.cpp
rename to upstream/opencv/modules/imgproc/src/grabcut.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/hal_replacement.hpp b/upstream/opencv/modules/imgproc/src/hal_replacement.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/hal_replacement.hpp
rename to upstream/opencv/modules/imgproc/src/hal_replacement.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/histogram.cpp b/upstream/opencv/modules/imgproc/src/histogram.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/histogram.cpp
rename to upstream/opencv/modules/imgproc/src/histogram.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/hough.cpp b/upstream/opencv/modules/imgproc/src/hough.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/hough.cpp
rename to upstream/opencv/modules/imgproc/src/hough.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.avx2.cpp b/upstream/opencv/modules/imgproc/src/imgwarp.avx2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.avx2.cpp
rename to upstream/opencv/modules/imgproc/src/imgwarp.avx2.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.cpp b/upstream/opencv/modules/imgproc/src/imgwarp.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.cpp
rename to upstream/opencv/modules/imgproc/src/imgwarp.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.hpp b/upstream/opencv/modules/imgproc/src/imgwarp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.hpp
rename to upstream/opencv/modules/imgproc/src/imgwarp.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.lasx.cpp b/upstream/opencv/modules/imgproc/src/imgwarp.lasx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.lasx.cpp
rename to upstream/opencv/modules/imgproc/src/imgwarp.lasx.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.sse4_1.cpp b/upstream/opencv/modules/imgproc/src/imgwarp.sse4_1.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/imgwarp.sse4_1.cpp
rename to upstream/opencv/modules/imgproc/src/imgwarp.sse4_1.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/lsd.cpp b/upstream/opencv/modules/imgproc/src/lsd.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/lsd.cpp
rename to upstream/opencv/modules/imgproc/src/lsd.cpp
diff --git a/upstream/opencv/modules/imgproc/src/main.cpp b/upstream/opencv/modules/imgproc/src/main.cpp
new file mode 100644
index 0000000..127f86b
--- /dev/null
+++ b/upstream/opencv/modules/imgproc/src/main.cpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//
+// Library initialization file
+//
+
+#include "precomp.hpp"
+
+IPP_INITIALIZER_AUTO
+
+/* End of file. */
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/median_blur.dispatch.cpp b/upstream/opencv/modules/imgproc/src/median_blur.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/median_blur.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/median_blur.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/median_blur.simd.hpp b/upstream/opencv/modules/imgproc/src/median_blur.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/median_blur.simd.hpp
rename to upstream/opencv/modules/imgproc/src/median_blur.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/morph.dispatch.cpp b/upstream/opencv/modules/imgproc/src/morph.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/morph.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/morph.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/morph.simd.hpp b/upstream/opencv/modules/imgproc/src/morph.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/morph.simd.hpp
rename to upstream/opencv/modules/imgproc/src/morph.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/accumulate.cl b/upstream/opencv/modules/imgproc/src/opencl/accumulate.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/accumulate.cl
rename to upstream/opencv/modules/imgproc/src/opencl/accumulate.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/bilateral.cl b/upstream/opencv/modules/imgproc/src/opencl/bilateral.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/bilateral.cl
rename to upstream/opencv/modules/imgproc/src/opencl/bilateral.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/blend_linear.cl b/upstream/opencv/modules/imgproc/src/opencl/blend_linear.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/blend_linear.cl
rename to upstream/opencv/modules/imgproc/src/opencl/blend_linear.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/boxFilter.cl b/upstream/opencv/modules/imgproc/src/opencl/boxFilter.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/boxFilter.cl
rename to upstream/opencv/modules/imgproc/src/opencl/boxFilter.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/boxFilter3x3.cl b/upstream/opencv/modules/imgproc/src/opencl/boxFilter3x3.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/boxFilter3x3.cl
rename to upstream/opencv/modules/imgproc/src/opencl/boxFilter3x3.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/calc_back_project.cl b/upstream/opencv/modules/imgproc/src/opencl/calc_back_project.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/calc_back_project.cl
rename to upstream/opencv/modules/imgproc/src/opencl/calc_back_project.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/canny.cl b/upstream/opencv/modules/imgproc/src/opencl/canny.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/canny.cl
rename to upstream/opencv/modules/imgproc/src/opencl/canny.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/clahe.cl b/upstream/opencv/modules/imgproc/src/opencl/clahe.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/clahe.cl
rename to upstream/opencv/modules/imgproc/src/opencl/clahe.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_hsv.cl b/upstream/opencv/modules/imgproc/src/opencl/color_hsv.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_hsv.cl
rename to upstream/opencv/modules/imgproc/src/opencl/color_hsv.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_lab.cl b/upstream/opencv/modules/imgproc/src/opencl/color_lab.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_lab.cl
rename to upstream/opencv/modules/imgproc/src/opencl/color_lab.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_rgb.cl b/upstream/opencv/modules/imgproc/src/opencl/color_rgb.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_rgb.cl
rename to upstream/opencv/modules/imgproc/src/opencl/color_rgb.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_yuv.cl b/upstream/opencv/modules/imgproc/src/opencl/color_yuv.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/color_yuv.cl
rename to upstream/opencv/modules/imgproc/src/opencl/color_yuv.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/corner.cl b/upstream/opencv/modules/imgproc/src/opencl/corner.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/corner.cl
rename to upstream/opencv/modules/imgproc/src/opencl/corner.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/covardata.cl b/upstream/opencv/modules/imgproc/src/opencl/covardata.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/covardata.cl
rename to upstream/opencv/modules/imgproc/src/opencl/covardata.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filter2D.cl b/upstream/opencv/modules/imgproc/src/opencl/filter2D.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filter2D.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filter2D.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filter2DSmall.cl b/upstream/opencv/modules/imgproc/src/opencl/filter2DSmall.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filter2DSmall.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filter2DSmall.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSepCol.cl b/upstream/opencv/modules/imgproc/src/opencl/filterSepCol.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSepCol.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filterSepCol.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSepRow.cl b/upstream/opencv/modules/imgproc/src/opencl/filterSepRow.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSepRow.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filterSepRow.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSep_singlePass.cl b/upstream/opencv/modules/imgproc/src/opencl/filterSep_singlePass.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSep_singlePass.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filterSep_singlePass.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSmall.cl b/upstream/opencv/modules/imgproc/src/opencl/filterSmall.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/filterSmall.cl
rename to upstream/opencv/modules/imgproc/src/opencl/filterSmall.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/gaussianBlur3x3.cl b/upstream/opencv/modules/imgproc/src/opencl/gaussianBlur3x3.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/gaussianBlur3x3.cl
rename to upstream/opencv/modules/imgproc/src/opencl/gaussianBlur3x3.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/gaussianBlur5x5.cl b/upstream/opencv/modules/imgproc/src/opencl/gaussianBlur5x5.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/gaussianBlur5x5.cl
rename to upstream/opencv/modules/imgproc/src/opencl/gaussianBlur5x5.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/histogram.cl b/upstream/opencv/modules/imgproc/src/opencl/histogram.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/histogram.cl
rename to upstream/opencv/modules/imgproc/src/opencl/histogram.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/hough_lines.cl b/upstream/opencv/modules/imgproc/src/opencl/hough_lines.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/hough_lines.cl
rename to upstream/opencv/modules/imgproc/src/opencl/hough_lines.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/integral_sum.cl b/upstream/opencv/modules/imgproc/src/opencl/integral_sum.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/integral_sum.cl
rename to upstream/opencv/modules/imgproc/src/opencl/integral_sum.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/laplacian3.cl b/upstream/opencv/modules/imgproc/src/opencl/laplacian3.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/laplacian3.cl
rename to upstream/opencv/modules/imgproc/src/opencl/laplacian3.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/laplacian5.cl b/upstream/opencv/modules/imgproc/src/opencl/laplacian5.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/laplacian5.cl
rename to upstream/opencv/modules/imgproc/src/opencl/laplacian5.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/match_template.cl b/upstream/opencv/modules/imgproc/src/opencl/match_template.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/match_template.cl
rename to upstream/opencv/modules/imgproc/src/opencl/match_template.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/medianFilter.cl b/upstream/opencv/modules/imgproc/src/opencl/medianFilter.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/medianFilter.cl
rename to upstream/opencv/modules/imgproc/src/opencl/medianFilter.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/morph.cl b/upstream/opencv/modules/imgproc/src/opencl/morph.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/morph.cl
rename to upstream/opencv/modules/imgproc/src/opencl/morph.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/morph3x3.cl b/upstream/opencv/modules/imgproc/src/opencl/morph3x3.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/morph3x3.cl
rename to upstream/opencv/modules/imgproc/src/opencl/morph3x3.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/precornerdetect.cl b/upstream/opencv/modules/imgproc/src/opencl/precornerdetect.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/precornerdetect.cl
rename to upstream/opencv/modules/imgproc/src/opencl/precornerdetect.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyr_down.cl b/upstream/opencv/modules/imgproc/src/opencl/pyr_down.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyr_down.cl
rename to upstream/opencv/modules/imgproc/src/opencl/pyr_down.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyr_up.cl b/upstream/opencv/modules/imgproc/src/opencl/pyr_up.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyr_up.cl
rename to upstream/opencv/modules/imgproc/src/opencl/pyr_up.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyramid_up.cl b/upstream/opencv/modules/imgproc/src/opencl/pyramid_up.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/pyramid_up.cl
rename to upstream/opencv/modules/imgproc/src/opencl/pyramid_up.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/remap.cl b/upstream/opencv/modules/imgproc/src/opencl/remap.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/remap.cl
rename to upstream/opencv/modules/imgproc/src/opencl/remap.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/resize.cl b/upstream/opencv/modules/imgproc/src/opencl/resize.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/resize.cl
rename to upstream/opencv/modules/imgproc/src/opencl/resize.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/sepFilter3x3.cl b/upstream/opencv/modules/imgproc/src/opencl/sepFilter3x3.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/sepFilter3x3.cl
rename to upstream/opencv/modules/imgproc/src/opencl/sepFilter3x3.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/threshold.cl b/upstream/opencv/modules/imgproc/src/opencl/threshold.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/threshold.cl
rename to upstream/opencv/modules/imgproc/src/opencl/threshold.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/threshold_mask.cl b/upstream/opencv/modules/imgproc/src/opencl/threshold_mask.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/threshold_mask.cl
rename to upstream/opencv/modules/imgproc/src/opencl/threshold_mask.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_affine.cl b/upstream/opencv/modules/imgproc/src/opencl/warp_affine.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_affine.cl
rename to upstream/opencv/modules/imgproc/src/opencl/warp_affine.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_perspective.cl b/upstream/opencv/modules/imgproc/src/opencl/warp_perspective.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_perspective.cl
rename to upstream/opencv/modules/imgproc/src/opencl/warp_perspective.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_transform.cl b/upstream/opencv/modules/imgproc/src/opencl/warp_transform.cl
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/opencl/warp_transform.cl
rename to upstream/opencv/modules/imgproc/src/opencl/warp_transform.cl
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/phasecorr.cpp b/upstream/opencv/modules/imgproc/src/phasecorr.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/phasecorr.cpp
rename to upstream/opencv/modules/imgproc/src/phasecorr.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/phasecorr_iterative.cpp b/upstream/opencv/modules/imgproc/src/phasecorr_iterative.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/phasecorr_iterative.cpp
rename to upstream/opencv/modules/imgproc/src/phasecorr_iterative.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/precomp.hpp b/upstream/opencv/modules/imgproc/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/precomp.hpp
rename to upstream/opencv/modules/imgproc/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/pyramids.cpp b/upstream/opencv/modules/imgproc/src/pyramids.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/pyramids.cpp
rename to upstream/opencv/modules/imgproc/src/pyramids.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/resize.avx2.cpp b/upstream/opencv/modules/imgproc/src/resize.avx2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/resize.avx2.cpp
rename to upstream/opencv/modules/imgproc/src/resize.avx2.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/resize.cpp b/upstream/opencv/modules/imgproc/src/resize.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/resize.cpp
rename to upstream/opencv/modules/imgproc/src/resize.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/resize.hpp b/upstream/opencv/modules/imgproc/src/resize.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/resize.hpp
rename to upstream/opencv/modules/imgproc/src/resize.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/resize.lasx.cpp b/upstream/opencv/modules/imgproc/src/resize.lasx.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/resize.lasx.cpp
rename to upstream/opencv/modules/imgproc/src/resize.lasx.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/resize.sse4_1.cpp b/upstream/opencv/modules/imgproc/src/resize.sse4_1.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/resize.sse4_1.cpp
rename to upstream/opencv/modules/imgproc/src/resize.sse4_1.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/samplers.cpp b/upstream/opencv/modules/imgproc/src/samplers.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/samplers.cpp
rename to upstream/opencv/modules/imgproc/src/samplers.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/segmentation.cpp b/upstream/opencv/modules/imgproc/src/segmentation.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/segmentation.cpp
rename to upstream/opencv/modules/imgproc/src/segmentation.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/smooth.dispatch.cpp b/upstream/opencv/modules/imgproc/src/smooth.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/smooth.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/smooth.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/smooth.simd.hpp b/upstream/opencv/modules/imgproc/src/smooth.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/smooth.simd.hpp
rename to upstream/opencv/modules/imgproc/src/smooth.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/spatialgradient.cpp b/upstream/opencv/modules/imgproc/src/spatialgradient.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/spatialgradient.cpp
rename to upstream/opencv/modules/imgproc/src/spatialgradient.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/stackblur.cpp b/upstream/opencv/modules/imgproc/src/stackblur.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/stackblur.cpp
rename to upstream/opencv/modules/imgproc/src/stackblur.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/stb_truetype.cpp b/upstream/opencv/modules/imgproc/src/stb_truetype.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/stb_truetype.cpp
rename to upstream/opencv/modules/imgproc/src/stb_truetype.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/stb_truetype.hpp b/upstream/opencv/modules/imgproc/src/stb_truetype.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/stb_truetype.hpp
rename to upstream/opencv/modules/imgproc/src/stb_truetype.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.avx512_skx.hpp b/upstream/opencv/modules/imgproc/src/sumpixels.avx512_skx.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.avx512_skx.hpp
rename to upstream/opencv/modules/imgproc/src/sumpixels.avx512_skx.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.dispatch.cpp b/upstream/opencv/modules/imgproc/src/sumpixels.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/sumpixels.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.simd.hpp b/upstream/opencv/modules/imgproc/src/sumpixels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/sumpixels.simd.hpp
rename to upstream/opencv/modules/imgproc/src/sumpixels.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/tables.cpp b/upstream/opencv/modules/imgproc/src/tables.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/tables.cpp
rename to upstream/opencv/modules/imgproc/src/tables.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/templmatch.cpp b/upstream/opencv/modules/imgproc/src/templmatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/templmatch.cpp
rename to upstream/opencv/modules/imgproc/src/templmatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/thresh.cpp b/upstream/opencv/modules/imgproc/src/thresh.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/thresh.cpp
rename to upstream/opencv/modules/imgproc/src/thresh.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/undistort.dispatch.cpp b/upstream/opencv/modules/imgproc/src/undistort.dispatch.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/undistort.dispatch.cpp
rename to upstream/opencv/modules/imgproc/src/undistort.dispatch.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/undistort.simd.hpp b/upstream/opencv/modules/imgproc/src/undistort.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/undistort.simd.hpp
rename to upstream/opencv/modules/imgproc/src/undistort.simd.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/utils.cpp b/upstream/opencv/modules/imgproc/src/utils.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/utils.cpp
rename to upstream/opencv/modules/imgproc/src/utils.cpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/warp_common.hpp b/upstream/opencv/modules/imgproc/src/warp_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/warp_common.hpp
rename to upstream/opencv/modules/imgproc/src/warp_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/warp_common.scalar.hpp b/upstream/opencv/modules/imgproc/src/warp_common.scalar.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/warp_common.scalar.hpp
rename to upstream/opencv/modules/imgproc/src/warp_common.scalar.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/warp_common.vector.hpp b/upstream/opencv/modules/imgproc/src/warp_common.vector.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/warp_common.vector.hpp
rename to upstream/opencv/modules/imgproc/src/warp_common.vector.hpp
diff --git a/third_party/opencv-5.0.0/modules/imgproc/src/warp_kernels.simd.hpp b/upstream/opencv/modules/imgproc/src/warp_kernels.simd.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/imgproc/src/warp_kernels.simd.hpp
rename to upstream/opencv/modules/imgproc/src/warp_kernels.simd.hpp
diff --git a/upstream/opencv/modules/objdetect/CMakeLists.txt b/upstream/opencv/modules/objdetect/CMakeLists.txt
new file mode 100644
index 0000000..6b8c79c
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(the_description "Object Detection")
+ocv_define_module(objdetect
+    opencv_core
+    opencv_imgproc
+    opencv_features
+    opencv_geometry
+    OPTIONAL
+        opencv_dnn
+    WRAP
+        python
+        java
+        objc
+        js
+)
diff --git a/upstream/opencv/modules/objdetect/doc/objdetect.bib b/upstream/opencv/modules/objdetect/doc/objdetect.bib
new file mode 100644
index 0000000..9f7f06e
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/doc/objdetect.bib
@@ -0,0 +1,50 @@
+@article{Aruco2014,
+  author = {S. Garrido-Jurado and R. Mu\~noz-Salinas and F.J. Madrid-Cuevas and M.J. Mar\'in-Jim\'enez}
+  title = {Automatic generation and detection of highly reliable fiducial markers under occlusion},
+  year = {2014},
+  pages = {2280 - 2292},
+  journal = {Pattern Recognition},
+  volume = {47},
+  number = {6},
+  issn = {0031-3203},
+  doi = {http://dx.doi.org/10.1016/j.patcog.2014.01.005},
+  url = {http://www.sciencedirect.com/science/article/pii/S0031320314000235}
+}
+
+@inproceedings{wang2016iros,
+  author = {John Wang and Edwin Olson},
+  title = {{AprilTag} 2: Efficient and robust fiducial detection},
+  booktitle = {Proceedings of the {IEEE/RSJ} International Conference on Intelligent Robots and Systems {(IROS)}},
+  year = {2016},
+  month = {October},
+  url = {https://april.eecs.umich.edu/pdfs/wang2016iros.pdf}
+}
+
+@mastersthesis{Xiangmin2015research,
+  title={Research on Barcode Recognition Technology In a Complex Background},
+  author={Xiangmin, Wang},
+  year={2015},
+  school={Huazhong University of Science and Technology}
+}
+
+@article{bazen2002systematic,
+  title={Systematic methods for the computation of the directional fields and singular points of fingerprints},
+  author={Bazen, Asker M and Gerez, Sabih H},
+  journal={IEEE transactions on pattern analysis and machine intelligence},
+  volume={24},
+  number={7},
+  pages={905--919},
+  year={2002},
+  publisher={IEEE}
+}
+
+@article{kass1987analyzing,
+  title={Analyzing oriented patterns},
+  author={Kass, Michael and Witkin, Andrew},
+  journal={Computer vision, graphics, and image processing},
+  volume={37},
+  number={3},
+  pages={362--385},
+  year={1987},
+  publisher={Elsevier}
+}
diff --git a/upstream/opencv/modules/objdetect/doc/pics/AprilTag_corners_comparison_opencv_april.png b/upstream/opencv/modules/objdetect/doc/pics/AprilTag_corners_comparison_opencv_april.png
new file mode 100644
index 0000000..42bcff0
Binary files /dev/null and b/upstream/opencv/modules/objdetect/doc/pics/AprilTag_corners_comparison_opencv_april.png differ
diff --git a/upstream/opencv/modules/objdetect/doc/pics/AprilTag_family.png b/upstream/opencv/modules/objdetect/doc/pics/AprilTag_family.png
new file mode 100644
index 0000000..971ae93
Binary files /dev/null and b/upstream/opencv/modules/objdetect/doc/pics/AprilTag_family.png differ
diff --git a/upstream/opencv/modules/objdetect/doc/pics/ArUco_family.png b/upstream/opencv/modules/objdetect/doc/pics/ArUco_family.png
new file mode 100644
index 0000000..4dccc6c
Binary files /dev/null and b/upstream/opencv/modules/objdetect/doc/pics/ArUco_family.png differ
diff --git a/upstream/opencv/modules/objdetect/doc/pics/lena-face-detection.jpg b/upstream/opencv/modules/objdetect/doc/pics/lena-face-detection.jpg
new file mode 100644
index 0000000..d8b1e66
Binary files /dev/null and b/upstream/opencv/modules/objdetect/doc/pics/lena-face-detection.jpg differ
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect.hpp
new file mode 100644
index 0000000..6955a3a
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect.hpp
@@ -0,0 +1,597 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_OBJDETECT_HPP
+#define OPENCV_OBJDETECT_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/features.hpp"
+#include "opencv2/objdetect/aruco_detector.hpp"
+#include "opencv2/objdetect/graphical_code_detector.hpp"
+#include "opencv2/objdetect/mcc_checker_detector.hpp"
+
+/**
+@defgroup objdetect Object Detection
+
+@{
+    @defgroup objdetect_barcode Barcode detection and decoding
+    @defgroup objdetect_qrcode QRCode detection and encoding
+    @defgroup objdetect_dnn_face DNN-based face detection and recognition
+
+    Check @ref tutorial_dnn_face "the corresponding tutorial" for more details.
+
+    @defgroup objdetect_common Common functions and classes
+    @defgroup objdetect_aruco ArUco markers and boards detection for robust camera pose estimation
+    @{
+        ArUco Marker Detection
+        Square fiducial markers (also known as Augmented Reality Markers) are useful for easy,
+        fast and robust camera pose estimation.
+
+        The main functionality of ArucoDetector class is detection of markers in an image. If the markers are grouped
+        as a board, then you can try to recover the missing markers with ArucoDetector::refineDetectedMarkers().
+        ArUco markers can also be used for advanced chessboard corner finding. To do this, group the markers in the
+        CharucoBoard and find the corners of the chessboard with the CharucoDetector::detectBoard().
+
+        The implementation is based on the ArUco Library by R. Muñoz-Salinas and S. Garrido-Jurado @cite Aruco2014.
+
+        Markers can also be detected based on the AprilTag 2 @cite wang2016iros fiducial marker detection method.
+
+        @sa @cite Aruco2014
+        This code has been originally developed by Sergio Garrido-Jurado as a project
+        for Google Summer of Code 2015 (GSoC 15).
+
+        <br>
+
+        @warning In OpenCV, the order of the returned corners locations for the AprilTag family is not aligned with the ArUco one.\n
+        Note that this order is also different from the convention adopted by the official [AprilTag library](https://github.com/AprilRobotics/apriltag/).
+        ![](pics/AprilTag_corners_comparison_opencv_april.png) { width=80% }
+
+        <br>
+
+        An overview of the supported ArUco markers family is visible in the following image:
+        ![](pics/ArUco_family.png) { width=80% }
+
+        <br>
+
+        An overview of the supported AprilTag markers family is visible in the following image:
+        ![](pics/AprilTag_family.png) { width=80% }
+
+        @note The generated images (in the above picture) using @ref aruco::generateImageMarker for the AprilTag markers have been
+        rotated by 180 degree in order to match the official AprilTag images.
+        When using the @ref aruco::generateImageMarker function, it will output by default a different image from the official AprilTag convention,
+        see the [AprilRobotics/apriltag-imgs](https://github.com/AprilRobotics/apriltag-imgs) repository.
+        This is the reason why you see a different corners order between ArUco and AprilTag in the above image.
+
+        <br>
+
+        For the ArUco marker family, the recommended family is the DICT_ARUCO_MIP_36h12 one, [see](https://stackoverflow.com/a/51511558).
+        In general, a smaller marker family (e.g. `4x4` vs `6x6`) should give you a better detection rate with respect to the camera distance,
+        at the expense of having more probability to have issues with false detection or marker id decoding error.
+        The number of marker ids in a family is also something to take into account with respect to the application use case and the ability
+        to correct wrong bits during the marker id decoding process.
+
+        You can download some pregenerated MIP_36h12 ArUco marker images from:
+          - https://sourceforge.net/projects/aruco/files/
+          - or use the `samples/cpp/tutorial_code/objectDetection/create_marker.cpp` sample to generate the marker image for your
+          desired marker family (which uses the @ref aruco::generateImageMarker function)
+
+        For the AprilTag family, you can find some pregenerated marker images in the
+        [AprilRobotics/apriltag-imgs](https://github.com/AprilRobotics/apriltag-imgs) repository.
+
+        @note For accurate corners location extraction, a white border (to have a strong gradient between white and black transition) around the marker is important.
+        This is necessary to precisely extract the marker contour in difficult conditions such as bad illumination, confusing color background, etc.
+
+        <br>
+
+        There are multiple parameters which can be tweaked to improve the marker detection rate or to be adapted to your use case (e.g. image resolution).
+        Please refer to the:
+          - @ref aruco::DetectorParameters
+          - "Detector Parameters" section in the @ref tutorial_aruco_detection tutorial or in the @ref tutorial_aruco_faq page
+          - [ArUco Library Documentation](https://drive.google.com/file/d/1OiavRVYVJ-WH88sQg1LUsh8CuJZUQyrX) for additional information from the ArUco library
+
+        The corner refinement method can be changed according to the @ref aruco::CornerRefineMethod to improve the corners location accuracy
+        at the expense of more computation time.
+
+        <br>
+
+        To estimate the marker pose with respect to the camera frame, we recommend you to look at the following sources of information:
+          - @ref tutorial_aruco_detection for a tutorial about ArUco markers detection
+          - @ref _3d for some theoretical background about the pinhole camera model and the @ref calib3d_solvePnP page
+          - @ref solvePnP, @ref solvePnPGeneric, @ref solveP3P for the relevant pose estimation methods
+    @}
+
+@}
+ */
+
+namespace cv
+{
+//! @addtogroup objdetect_qrcode
+//! @{
+
+/** @brief QR code encoder. */
+class CV_EXPORTS_W QRCodeEncoder {
+protected:
+    QRCodeEncoder();  // use ::create()
+public:
+    virtual ~QRCodeEncoder();
+
+    enum EncodeMode {
+        MODE_AUTO              = -1,
+        MODE_NUMERIC           = 1, // 0b0001
+        MODE_ALPHANUMERIC      = 2, // 0b0010
+        MODE_BYTE              = 4, // 0b0100
+        MODE_ECI               = 7, // 0b0111
+        MODE_KANJI             = 8, // 0b1000
+        MODE_STRUCTURED_APPEND = 3  // 0b0011
+    };
+
+    enum CorrectionLevel {
+        CORRECT_LEVEL_L = 0,
+        CORRECT_LEVEL_M = 1,
+        CORRECT_LEVEL_Q = 2,
+        CORRECT_LEVEL_H = 3
+    };
+
+    enum ECIEncodings {
+        ECI_SHIFT_JIS = 20,
+        ECI_UTF8 = 26,
+    };
+
+    /** @brief QR code encoder parameters. */
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+
+        //! The optional version of QR code (by default - maximum possible depending on the length of the string).
+        CV_PROP_RW int version;
+
+        //! The optional level of error correction (by default - the lowest).
+        CV_PROP_RW QRCodeEncoder::CorrectionLevel correction_level;
+
+        //! The optional encoding mode - Numeric, Alphanumeric, Byte, Kanji, ECI or Structured Append.
+        CV_PROP_RW QRCodeEncoder::EncodeMode mode;
+
+        //! The optional number of QR codes to generate in Structured Append mode.
+        CV_PROP_RW int structure_number;
+    };
+
+    /** @brief Constructor
+    @param parameters QR code encoder parameters QRCodeEncoder::Params
+    */
+    static CV_WRAP
+    Ptr<QRCodeEncoder> create(const QRCodeEncoder::Params& parameters = QRCodeEncoder::Params());
+
+    /** @brief Generates QR code from input string.
+     @param encoded_info Input string to encode.
+     @param qrcode Generated QR code.
+    */
+    CV_WRAP virtual void encode(const String& encoded_info, OutputArray qrcode) = 0;
+
+    /** @brief Generates QR code from input string in Structured Append mode. The encoded message is splitting over a number of QR codes.
+     @param encoded_info Input string to encode.
+     @param qrcodes Vector of generated QR codes.
+    */
+    CV_WRAP virtual void encodeStructuredAppend(const String& encoded_info, OutputArrayOfArrays qrcodes) = 0;
+
+};
+
+/** @brief QR code detector. */
+class CV_EXPORTS_W_SIMPLE QRCodeDetector : public GraphicalCodeDetector
+{
+public:
+    CV_WRAP QRCodeDetector();
+
+    /** @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.
+     @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+    */
+    CV_WRAP QRCodeDetector& setEpsX(double epsX);
+    /** @brief sets the epsilon used during the vertical scan of QR code stop marker detection.
+     @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern
+     of the scheme 1:1:3:1:1 according to QR code standard.
+     */
+    CV_WRAP QRCodeDetector& setEpsY(double epsY);
+
+    /** @brief use markers to improve the position of the corners of the QR code
+     *
+     * alignmentMarkers using by default
+     */
+    CV_WRAP QRCodeDetector& setUseAlignmentMarkers(bool useAlignmentMarkers);
+
+    /** @brief Decodes QR code on a curved surface in image once it's found by the detect() method.
+
+     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP cv::String decodeCurved(InputArray img, InputArray points, OutputArray straight_qrcode = noArray());
+
+    /** @brief Both detects and decodes QR code on a curved surface
+
+     @param img grayscale or color (BGR) image containing QR code.
+     @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.
+     @param straight_qrcode The optional output image containing rectified and binarized QR code
+     */
+    CV_WRAP std::string detectAndDecodeCurved(InputArray img, OutputArray points=noArray(),
+                                              OutputArray straight_qrcode = noArray());
+
+    /** @brief Returns a kind of encoding for the decoded info from the latest @ref decode or @ref detectAndDecode call
+    @param codeIdx an index of the previously decoded QR code.
+                   When @ref decode or @ref detectAndDecode is used, valid value is zero.
+                   For @ref decodeMulti or @ref detectAndDecodeMulti use indices corresponding to the output order.
+    */
+    CV_WRAP QRCodeEncoder::ECIEncodings getEncoding(int codeIdx = 0);
+};
+
+/** @brief QR code detector based on Aruco markers detection code. */
+class CV_EXPORTS_W_SIMPLE QRCodeDetectorAruco : public GraphicalCodeDetector {
+public:
+    CV_WRAP QRCodeDetectorAruco();
+
+    struct CV_EXPORTS_W_SIMPLE Params {
+        CV_WRAP Params();
+
+        /** @brief The minimum allowed pixel size of a QR module in the smallest image in the image pyramid, default 4.f */
+        CV_PROP_RW float minModuleSizeInPyramid;
+
+        /** @brief The maximum allowed relative rotation for finder patterns in the same QR code, default pi/12 */
+        CV_PROP_RW float maxRotation;
+
+        /** @brief The maximum allowed relative mismatch in module sizes for finder patterns in the same QR code, default 1.75f */
+        CV_PROP_RW float maxModuleSizeMismatch;
+
+        /** @brief The maximum allowed module relative mismatch for timing pattern module, default 2.f
+         *
+         * If relative mismatch of timing pattern module more this value, penalty points will be added.
+         * If a lot of penalty points are added, QR code will be rejected. */
+        CV_PROP_RW float maxTimingPatternMismatch;
+
+        /** @brief The maximum allowed percentage of penalty points out of total pins in timing pattern, default 0.4f */
+        CV_PROP_RW float maxPenalties;
+
+        /** @brief The maximum allowed relative color mismatch in the timing pattern, default 0.2f*/
+        CV_PROP_RW float maxColorsMismatch;
+
+        /** @brief The algorithm find QR codes with almost minimum timing pattern score and minimum size, default 0.9f
+         *
+         * The QR code with the minimum "timing pattern score" and minimum "size" is selected as the best QR code.
+         * If for the current QR code "timing pattern score" * scaleTimingPatternScore < "previous timing pattern score" and "size" < "previous size", then
+         * current QR code set as the best QR code. */
+        CV_PROP_RW float scaleTimingPatternScore;
+    };
+
+    /** @brief QR code detector constructor for Aruco-based algorithm. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP explicit QRCodeDetectorAruco(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Detector parameters getter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP const QRCodeDetectorAruco::Params& getDetectorParameters() const;
+
+    /** @brief Detector parameters setter. See cv::QRCodeDetectorAruco::Params */
+    CV_WRAP QRCodeDetectorAruco& setDetectorParameters(const QRCodeDetectorAruco::Params& params);
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP const aruco::DetectorParameters& getArucoParameters() const;
+
+    /** @brief Aruco detector parameters are used to search for the finder patterns. */
+    CV_WRAP void setArucoParameters(const aruco::DetectorParameters& params);
+};
+
+enum { CALIB_CB_ADAPTIVE_THRESH = 1,
+       CALIB_CB_NORMALIZE_IMAGE = 2,
+       CALIB_CB_FILTER_QUADS    = 4,
+       CALIB_CB_FAST_CHECK      = 8,
+       CALIB_CB_EXHAUSTIVE      = 16,
+       CALIB_CB_ACCURACY        = 32,
+       CALIB_CB_LARGER          = 64,
+       CALIB_CB_MARKER          = 128,
+       CALIB_CB_PLAIN           = 256
+     };
+
+enum { CALIB_CB_SYMMETRIC_GRID  = 1,
+       CALIB_CB_ASYMMETRIC_GRID = 2,
+       CALIB_CB_CLUSTERING      = 4
+     };
+
+/** @brief Finds the positions of internal corners of the chessboard.
+
+@param image Source chessboard view. It must be an 8-bit grayscale or color image.
+@param patternSize Number of inner corners per a chessboard row and column
+( patternSize = cv::Size(points_per_row,points_per_column) = cv::Size(columns,rows) ).
+@param corners Output array of detected corners.
+@param flags Various operation flags that can be zero or a combination of the following values:
+-   @ref CALIB_CB_ADAPTIVE_THRESH Use adaptive thresholding to convert the image to black
+and white, rather than a fixed threshold level (computed from the average image brightness).
+-   @ref CALIB_CB_NORMALIZE_IMAGE Normalize the image gamma with equalizeHist before
+applying fixed or adaptive thresholding.
+-   @ref CALIB_CB_FILTER_QUADS Use additional criteria (like contour area, perimeter,
+square-like shape) to filter out false quads extracted at the contour retrieval stage.
+-   @ref CALIB_CB_FAST_CHECK Run a fast check on the image that looks for chessboard corners,
+and shortcut the call if none is found. This can drastically speed up the call in the
+degenerate condition when no chessboard is observed.
+-   @ref CALIB_CB_PLAIN All other flags are ignored. The input image is taken as is.
+No image processing is done to improve to find the checkerboard. This has the effect of speeding up the
+execution of the function but could lead to not recognizing the checkerboard if the image
+is not previously binarized in the appropriate manner.
+
+@return True if all of the corners are found and placed in a certain order (row by row,
+left to right in every row). Otherwise, if the function fails to find all the corners or reorder them,
+it returns false.
+
+The function attempts to determine whether the input image is a view of the chessboard pattern and
+locate the internal chessboard corners. For example, a regular chessboard has 8 x 8 squares and
+7 x 7 internal corners, that is, points where the black squares touch each other. The detected
+coordinates are approximate, and to determine their positions more accurately, the function
+calls #cornerSubPix. You also may use the function #cornerSubPix with different parameters if
+returned coordinates are not accurate enough.
+
+Sample usage of detecting and drawing chessboard corners: :
+@code
+    Size patternsize(8,6); //interior number of corners
+    Mat gray = ....; //source image
+    vector<Point2f> corners; //this will be filled by the detected corners
+
+    //CALIB_CB_FAST_CHECK saves a lot of time on images
+    //that do not contain any chessboard corners
+    bool patternfound = findChessboardCorners(gray, patternsize, corners,
+            CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
+            + CALIB_CB_FAST_CHECK);
+
+    if(patternfound)
+      cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),
+        TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
+
+    drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
+@endcode
+@note The function requires white space (like a square-thick border, the wider the better) around
+the board to make the detection more robust in various environments. Otherwise, if there is no
+border and the background is dark, the outer black squares cannot be segmented properly and so the
+square grouping and ordering algorithm fails.
+
+Use the `generate_pattern.py` Python script (@ref tutorial_camera_calibration_pattern)
+to create the desired checkerboard pattern.
+ */
+CV_EXPORTS_W bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners,
+                                         int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE );
+
+/** @brief Checks whether the image contains chessboard of the specific size or not.
+
+@param img Source chessboard view.
+@param size Size of the chessboard.
+
+@return Whether a chessboard was found.
+*/
+CV_EXPORTS_W bool checkChessboard(InputArray img, Size size);
+
+/** @brief Finds the positions of internal corners of the chessboard using a sector based approach.
+
+@param image Source chessboard view. It must be an 8-bit grayscale or color image.
+@param patternSize Number of inner corners per a chessboard row and column
+( patternSize = cv::Size(points_per_row,points_per_column) = cv::Size(columns,rows) ).
+@param corners Output array of detected corners.
+@param flags Various operation flags that can be zero or a combination of the following values:
+-   @ref CALIB_CB_NORMALIZE_IMAGE Normalize the image gamma with equalizeHist before detection.
+-   @ref CALIB_CB_EXHAUSTIVE Run an exhaustive search to improve detection rate.
+-   @ref CALIB_CB_ACCURACY Up sample input image to improve sub-pixel accuracy due to aliasing effects.
+-   @ref CALIB_CB_LARGER The detected pattern is allowed to be larger than patternSize (see description).
+-   @ref CALIB_CB_MARKER The detected pattern must have a marker (see description).
+This should be used if an accurate camera calibration is required.
+@param meta Optional output array of detected corners (CV_8UC1 and size = cv::Size(columns,rows)).
+Each entry stands for one corner of the pattern and can have one of the following values:
+-   0 = no meta data attached
+-   1 = left-top corner of a black cell
+-   2 = left-top corner of a white cell
+-   3 = left-top corner of a black cell with a white marker dot
+-   4 = left-top corner of a white cell with a black marker dot (pattern origin in case of markers otherwise first corner)
+
+The function is analog to #findChessboardCorners but uses a localized radon
+transformation approximated by box filters being more robust to all sort of
+noise, faster on larger images and is able to directly return the sub-pixel
+position of the internal chessboard corners. The Method is based on the paper
+@cite duda2018 "Accurate Detection and Localization of Checkerboard Corners for
+Calibration" demonstrating that the returned sub-pixel positions are more
+accurate than the one returned by cornerSubPix allowing a precise camera
+calibration for demanding applications.
+
+In the case, the flags @ref CALIB_CB_LARGER or @ref CALIB_CB_MARKER are given,
+the result can be recovered from the optional meta array. Both flags are
+helpful to use calibration patterns exceeding the field of view of the camera.
+These oversized patterns allow more accurate calibrations as corners can be
+utilized, which are as close as possible to the image borders.  For a
+consistent coordinate system across all images, the optional marker (see image
+below) can be used to move the origin of the board to the location where the
+black circle is located.
+
+@note The function requires a white boarder with roughly the same width as one
+of the checkerboard fields around the whole board to improve the detection in
+various environments. In addition, because of the localized radon
+transformation it is beneficial to use round corners for the field corners
+which are located on the outside of the board. The following figure illustrates
+a sample checkerboard optimized for the detection. However, any other checkerboard
+can be used as well.
+
+Use the `generate_pattern.py` Python script (@ref tutorial_camera_calibration_pattern)
+to create the corresponding checkerboard pattern:
+\image html pics/checkerboard_radon.png width=60%
+ */
+CV_EXPORTS_AS(findChessboardCornersSBWithMeta)
+bool findChessboardCornersSB(InputArray image,Size patternSize, OutputArray corners,
+                             int flags,OutputArray meta);
+/** @overload */
+CV_EXPORTS_W inline
+bool findChessboardCornersSB(InputArray image, Size patternSize, OutputArray corners,
+                             int flags = 0)
+{
+    return findChessboardCornersSB(image, patternSize, corners, flags, noArray());
+}
+
+/** @brief Estimates the sharpness of a detected chessboard.
+
+Image sharpness, as well as brightness, are a critical parameter for accuracte
+camera calibration. For accessing these parameters for filtering out
+problematic calibraiton images, this method calculates edge profiles by traveling from
+black to white chessboard cell centers. Based on this, the number of pixels is
+calculated required to transit from black to white. This width of the
+transition area is a good indication of how sharp the chessboard is imaged
+and should be below ~3.0 pixels.
+
+@param image Gray image used to find chessboard corners
+@param patternSize Size of a found chessboard pattern
+@param corners Corners found by #findChessboardCornersSB
+@param rise_distance Rise distance 0.8 means 10% ... 90% of the final signal strength
+@param vertical By default edge responses for horizontal lines are calculated
+@param sharpness Optional output array with a sharpness value for calculated edge responses (see description)
+
+The optional sharpness array is of type CV_32FC1 and has for each calculated
+profile one row with the following five entries:
+* 0 = x coordinate of the underlying edge in the image
+* 1 = y coordinate of the underlying edge in the image
+* 2 = width of the transition area (sharpness)
+* 3 = signal strength in the black cell (min brightness)
+* 4 = signal strength in the white cell (max brightness)
+
+@return Scalar(average sharpness, average min brightness, average max brightness,0)
+*/
+CV_EXPORTS_W Scalar estimateChessboardSharpness(InputArray image, Size patternSize, InputArray corners,
+                                                float rise_distance=0.8F,bool vertical=false,
+                                                OutputArray sharpness=noArray());
+
+
+//! finds subpixel-accurate positions of the chessboard corners
+CV_EXPORTS_W bool find4QuadCornerSubpix( InputArray img, InputOutputArray corners, Size region_size );
+
+/** @brief Renders the detected chessboard corners.
+
+@param image Destination image. It must be an 8-bit color image.
+@param patternSize Number of inner corners per a chessboard row and column
+(patternSize = cv::Size(points_per_row,points_per_column)).
+@param corners Array of detected corners, the output of #findChessboardCorners.
+@param patternWasFound Parameter indicating whether the complete board was found or not. The
+return value of #findChessboardCorners should be passed here.
+
+The function draws individual chessboard corners detected either as red circles if the board was not
+found, or as colored corners connected with lines if the board was found.
+ */
+CV_EXPORTS_W void drawChessboardCorners( InputOutputArray image, Size patternSize,
+                                         InputArray corners, bool patternWasFound );
+
+struct CV_EXPORTS_W_SIMPLE CirclesGridFinderParameters
+{
+    CV_WRAP CirclesGridFinderParameters();
+    CV_PROP_RW cv::Size2f densityNeighborhoodSize;
+    CV_PROP_RW float minDensity;
+    CV_PROP_RW int kmeansAttempts;
+    CV_PROP_RW int minDistanceToAddKeypoint;
+    CV_PROP_RW int keypointScale;
+    CV_PROP_RW float minGraphConfidence;
+    CV_PROP_RW float vertexGain;
+    CV_PROP_RW float vertexPenalty;
+    CV_PROP_RW float existingVertexGain;
+    CV_PROP_RW float edgeGain;
+    CV_PROP_RW float edgePenalty;
+    CV_PROP_RW float convexHullFactor;
+    CV_PROP_RW float minRNGEdgeSwitchDist;
+
+    enum GridType
+    {
+      SYMMETRIC_GRID, ASYMMETRIC_GRID
+    };
+    CV_PROP_RW GridType gridType;
+
+    CV_PROP_RW float squareSize; //!< Distance between two adjacent points. Used by CALIB_CB_CLUSTERING.
+    CV_PROP_RW float maxRectifiedDistance; //!< Max deviation from prediction. Used by CALIB_CB_CLUSTERING.
+};
+
+/** @brief Finds centers in the grid of circles.
+
+@param image grid view of input circles; it must be an 8-bit grayscale or color image.
+@param patternSize number of circles per row and column
+( patternSize = Size(points_per_row, points_per_column) ).
+@param centers output array of detected centers.
+@param flags various operation flags that can be one of the following values:
+-   @ref CALIB_CB_SYMMETRIC_GRID uses symmetric pattern of circles.
+-   @ref CALIB_CB_ASYMMETRIC_GRID uses asymmetric pattern of circles.
+-   @ref CALIB_CB_CLUSTERING uses a special algorithm for grid detection. It is more robust to
+perspective distortions but much more sensitive to background clutter.
+@param blobDetector feature detector that finds blobs like dark circles on light background.
+                    If `blobDetector` is NULL then `image` represents Point2f array of candidates.
+@param parameters struct for finding circles in a grid pattern.
+
+return True if all of the centers have been found and they have been placed in a certain order
+(row by row, left to right in every row). Otherwise, if the function fails to find all the corners
+or reorder them, it returns false.
+
+The function attempts to determine whether the input image contains a grid of circles. If it is, the
+function locates centers of the circles.
+
+Sample usage of detecting and drawing the centers of circles: :
+@code
+    Size patternsize(7,7); //number of centers
+    Mat gray = ...; //source image
+    vector<Point2f> centers; //this will be filled by the detected centers
+
+    bool patternfound = findCirclesGrid(gray, patternsize, centers);
+
+    drawChessboardCorners(img, patternsize, Mat(centers), patternfound);
+@endcode
+@note The function requires white space (like a square-thick border, the wider the better) around
+the board to make the detection more robust in various environments.
+ */
+CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,
+                                   OutputArray centers, int flags,
+                                   const Ptr<FeatureDetector> &blobDetector,
+                                   const CirclesGridFinderParameters& parameters);
+
+/** @overload */
+CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,
+                                   OutputArray centers, int flags = CALIB_CB_SYMMETRIC_GRID,
+                                   const Ptr<FeatureDetector> &blobDetector = cv::SimpleBlobDetector::create());
+
+//! @}
+}
+
+#include "opencv2/objdetect/face.hpp"
+#include "opencv2/objdetect/charuco_detector.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp
new file mode 100644
index 0000000..e8300c8
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_board.hpp
@@ -0,0 +1,199 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_ARUCO_BOARD_HPP
+#define OPENCV_OBJDETECT_ARUCO_BOARD_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace aruco {
+//! @addtogroup objdetect_aruco
+//! @{
+
+class Dictionary;
+
+/** @brief Board of ArUco markers
+ *
+ * A board is a set of markers in the 3D space with a common coordinate system.
+ * The common form of a board of marker is a planar (2D) board, however any 3D layout can be used.
+ * A Board object is composed by:
+ * - The object points of the marker corners, i.e. their coordinates respect to the board system.
+ * - The dictionary which indicates the type of markers of the board
+ * - The identifier of all the markers in the board.
+ */
+class CV_EXPORTS_W_SIMPLE Board {
+public:
+    /** @brief Common Board constructor
+     *
+     * @param objPoints array of object points of all the marker corners in the board
+     * @param dictionary the dictionary of markers employed for this board
+     * @param ids vector of the identifiers of the markers in the board
+     */
+    CV_WRAP Board(InputArrayOfArrays objPoints, const Dictionary& dictionary, InputArray ids);
+
+    /** @brief return the Dictionary of markers employed for this board
+     */
+    CV_WRAP const Dictionary& getDictionary() const;
+
+    /** @brief return array of object points of all the marker corners in the board.
+     *
+     * Each marker include its 4 corners in this order:
+     * -   objPoints[i][0] - left-top point of i-th marker
+     * -   objPoints[i][1] - right-top point of i-th marker
+     * -   objPoints[i][2] - right-bottom point of i-th marker
+     * -   objPoints[i][3] - left-bottom point of i-th marker
+     *
+     * Markers are placed in a certain order - row by row, left to right in every row. For M markers, the size is Mx4.
+     */
+    CV_WRAP const std::vector<std::vector<Point3f> >& getObjPoints() const;
+
+    /** @brief vector of the identifiers of the markers in the board (should be the same size as objPoints)
+     * @return vector of the identifiers of the markers
+     */
+    CV_WRAP const std::vector<int>& getIds() const;
+
+    /** @brief get coordinate of the bottom right corner of the board, is set when calling the function create()
+     */
+    CV_WRAP const Point3f& getRightBottomCorner() const;
+
+    /** @brief Given a board configuration and a set of detected markers, returns the corresponding
+     * image points and object points, can be used in solvePnP()
+     *
+     * @param detectedCorners List of detected marker corners of the board.
+     * For cv::Board and cv::GridBoard the method expects std::vector<std::vector<Point2f>> or std::vector<Mat> with Aruco marker corners.
+     * For cv::CharucoBoard the method expects std::vector<Point2f> or Mat with ChAruco corners (chess board corners matched with Aruco markers).
+     *
+     * @param detectedIds List of identifiers for each marker or charuco corner.
+     * For any Board class the method expects std::vector<int> or Mat.
+     *
+     * @param objPoints Vector of marker points in the board coordinate space.
+     * For any Board class the method expects std::vector<cv::Point3f> objectPoints or cv::Mat
+     *
+     * @param imgPoints Vector of marker points in the image coordinate space.
+     * For any Board class the method expects std::vector<cv::Point2f> objectPoints or cv::Mat
+     *
+     * @sa solvePnP
+     */
+    CV_WRAP void matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds,
+                                  OutputArray objPoints, OutputArray imgPoints) const;
+
+     /** @brief Draw a planar board
+     *
+     * @param outSize size of the output image in pixels.
+     * @param img output image with the board. The size of this image will be outSize
+     * and the board will be on the center, keeping the board proportions.
+     * @param marginSize minimum margins (in pixels) of the board in the output image
+     * @param borderBits width of the marker borders.
+     *
+     * This function return the image of the board, ready to be printed.
+     */
+    CV_WRAP void generateImage(Size outSize, OutputArray img, int marginSize = 0, int borderBits = 1) const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    Board();
+
+    struct Impl;
+protected:
+    Board(const Ptr<Impl>& impl);
+    Ptr<Impl> impl;
+};
+
+/** @brief Planar board with grid arrangement of markers
+ *
+ * More common type of board. All markers are placed in the same plane in a grid arrangement.
+ * The board image can be drawn using generateImage() method.
+ */
+class CV_EXPORTS_W_SIMPLE GridBoard : public Board {
+public:
+    /**
+     * @brief GridBoard constructor
+     *
+     * @param size number of markers in x and y directions
+     * @param markerLength marker side length (normally in meters)
+     * @param markerSeparation separation between two markers (same unit as markerLength)
+     * @param dictionary dictionary of markers indicating the type of markers
+     * @param ids set of marker ids in dictionary to use on board.
+     */
+    CV_WRAP GridBoard(const Size& size, float markerLength, float markerSeparation,
+                      const Dictionary &dictionary, InputArray ids = noArray());
+
+    CV_WRAP Size getGridSize() const;
+    CV_WRAP float getMarkerLength() const;
+    CV_WRAP float getMarkerSeparation() const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    GridBoard();
+};
+
+/**
+ * @brief ChArUco board is a planar chessboard where the markers are placed inside the white squares of a chessboard.
+ *
+ * The benefits of ChArUco boards is that they provide both, ArUco markers versatility and chessboard corner precision,
+ * which is important for calibration and pose estimation. The board image can be drawn using generateImage() method.
+ */
+class CV_EXPORTS_W_SIMPLE CharucoBoard : public Board {
+public:
+    /** @brief CharucoBoard constructor
+     *
+     * @param size number of chessboard squares in x and y directions
+     * @param squareLength squareLength chessboard square side length (normally in meters)
+     * @param markerLength marker side length (same unit than squareLength)
+     * @param dictionary dictionary of markers indicating the type of markers
+     * @param ids array of id used markers
+     * The first markers in the dictionary are used to fill the white chessboard squares.
+     */
+    CV_WRAP CharucoBoard(const Size& size, float squareLength, float markerLength,
+                         const Dictionary &dictionary, InputArray ids = noArray());
+
+    /** @brief set legacy chessboard pattern.
+     *
+     * Legacy setting creates chessboard patterns starting with a white box in the upper left corner
+     * if there is an even row count of chessboard boxes, otherwise it starts with a black box.
+     * This setting ensures compatibility to patterns created with OpenCV versions prior OpenCV 4.6.0.
+     * See https://github.com/opencv/opencv/issues/23152.
+     *
+     * Default value: false.
+     */
+    CV_WRAP void setLegacyPattern(bool legacyPattern);
+    CV_WRAP bool getLegacyPattern() const;
+
+    CV_WRAP Size getChessboardSize() const;
+    CV_WRAP float getSquareLength() const;
+    CV_WRAP float getMarkerLength() const;
+
+    /** @brief get CharucoBoard::chessboardCorners
+     */
+    CV_WRAP std::vector<Point3f> getChessboardCorners() const;
+
+    /** @brief get CharucoBoard::nearestMarkerIdx, for each charuco corner, nearest marker index in ids array
+     */
+    CV_PROP std::vector<std::vector<int> > getNearestMarkerIdx() const;
+
+    /** @brief get CharucoBoard::nearestMarkerCorners, for each charuco corner, nearest marker corner id of each marker
+     */
+    CV_PROP std::vector<std::vector<int> > getNearestMarkerCorners() const;
+
+    /** @brief check whether the ChArUco markers are collinear
+     *
+     * @param charucoIds list of identifiers for each corner in charucoCorners per frame.
+     * @return bool value, 1 (true) if detected corners form a line, 0 (false) if they do not.
+     * solvePnP, calibration functions will fail if the corners are collinear (true).
+     *
+     * The number of ids in charucoIDs should be <= the number of chessboard corners in the board.
+     * This functions checks whether the charuco corners are on a straight line (returns true, if so), or not (false).
+     * Axis parallel, as well as diagonal and other straight lines detected.  Degenerate cases:
+     * for number of charucoIDs <= 2,the function returns true.
+     */
+    CV_WRAP bool checkCharucoCornersCollinear(InputArray charucoIds) const;
+
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    CharucoBoard();
+};
+
+//! @}
+
+}
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp
new file mode 100644
index 0000000..bf15437
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp
@@ -0,0 +1,495 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
+#define OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
+
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+#include <opencv2/objdetect/aruco_board.hpp>
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+enum CornerRefineMethod{
+    CORNER_REFINE_NONE,     ///< Tag and corners detection based on the ArUco approach
+    CORNER_REFINE_SUBPIX,   ///< ArUco approach and refine the corners locations using corner subpixel accuracy
+    CORNER_REFINE_CONTOUR,  ///< ArUco approach and refine the corners locations using the contour-points line fitting
+    CORNER_REFINE_APRILTAG, ///< Tag and corners detection based on the AprilTag 2 approach @cite wang2016iros
+};
+
+static constexpr float DEFAULT_VALID_BIT_ID_THRESHOLD{0.49f};
+
+/** @brief struct DetectorParameters is used by ArucoDetector
+ */
+struct CV_EXPORTS_W_SIMPLE DetectorParameters {
+    CV_WRAP DetectorParameters() {
+        adaptiveThreshWinSizeMin = 3;
+        adaptiveThreshWinSizeMax = 23;
+        adaptiveThreshWinSizeStep = 10;
+        adaptiveThreshConstant = 7;
+        minMarkerPerimeterRate = 0.03;
+        maxMarkerPerimeterRate = 4.;
+        polygonalApproxAccuracyRate = 0.03;
+        minCornerDistanceRate = 0.05;
+        minDistanceToBorder = 3;
+        minMarkerDistanceRate = 0.125;
+        cornerRefinementMethod = (int)CORNER_REFINE_NONE;
+        cornerRefinementWinSize = 5;
+        relativeCornerRefinmentWinSize = 0.3f;
+        cornerRefinementMaxIterations = 30;
+        cornerRefinementMinAccuracy = 0.1;
+        markerBorderBits = 1;
+        perspectiveRemovePixelPerCell = 4;
+        perspectiveRemoveIgnoredMarginPerCell = 0.13;
+        maxErroneousBitsInBorderRate = 0.35;
+        minOtsuStdDev = 5.0;
+        errorCorrectionRate = 0.6;
+        aprilTagQuadDecimate = 0.0;
+        aprilTagQuadSigma = 0.0;
+        aprilTagMinClusterPixels = 5;
+        aprilTagMaxNmaxima = 10;
+        aprilTagCriticalRad = (float)(10 * CV_PI / 180);
+        aprilTagMaxLineFitMse = 10.0;
+        aprilTagMinWhiteBlackDiff = 5;
+        aprilTagDeglitch = 0;
+        detectInvertedMarker = false;
+        useAruco3Detection = false;
+        minSideLengthCanonicalImg = 32;
+        minMarkerLengthRatioOriginalImg = 0.0;
+        validBitIdThreshold = DEFAULT_VALID_BIT_ID_THRESHOLD;
+    }
+
+    /** @brief Read a new set of DetectorParameters from FileNode (use FileStorage.root()).
+     */
+    CV_WRAP bool readDetectorParameters(const FileNode& fn);
+
+    /** @brief Write a set of DetectorParameters to FileStorage
+     */
+    CV_WRAP bool writeDetectorParameters(FileStorage& fs, const String& name = String());
+
+    /// minimum window size for adaptive thresholding before finding contours (default 3).
+    CV_PROP_RW int adaptiveThreshWinSizeMin;
+
+    /// maximum window size for adaptive thresholding before finding contours (default 23).
+    CV_PROP_RW int adaptiveThreshWinSizeMax;
+
+    /// increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax during the thresholding (default 10).
+    CV_PROP_RW int adaptiveThreshWinSizeStep;
+
+    /// constant for adaptive thresholding before finding contours (default 7)
+    CV_PROP_RW double adaptiveThreshConstant;
+
+    /** @brief determine minimum perimeter for marker contour to be detected.
+     *
+     * This is defined as a rate respect to the maximum dimension of the input image (default 0.03).
+     */
+    CV_PROP_RW double minMarkerPerimeterRate;
+
+    /** @brief determine maximum perimeter for marker contour to be detected.
+     *
+     * This is defined as a rate respect to the maximum dimension of the input image (default 4.0).
+     */
+    CV_PROP_RW double maxMarkerPerimeterRate;
+
+    /// minimum accuracy during the polygonal approximation process to determine which contours are squares. (default 0.03)
+    CV_PROP_RW double polygonalApproxAccuracyRate;
+
+    /// minimum distance between corners for detected markers relative to its perimeter (default 0.05)
+    CV_PROP_RW double minCornerDistanceRate;
+
+    /// minimum distance of any corner to the image border for detected markers (in pixels) (default 3)
+    CV_PROP_RW int minDistanceToBorder;
+
+    /** @brief minimum average distance between the corners of the two markers to be grouped (default 0.125).
+     *
+     * The rate is relative to the smaller perimeter of the two markers.
+     * Two markers are grouped if average distance between the corners of the two markers is less than
+     * min(MarkerPerimeter1, MarkerPerimeter2)*minMarkerDistanceRate.
+     *
+     * default value is 0.125 because 0.125*MarkerPerimeter = (MarkerPerimeter / 4) * 0.5 = half the side of the marker.
+     *
+     * @note default value was changed from 0.05 after 4.8.1 release, because the filtering algorithm has been changed.
+     * Now a few candidates from the same group can be added to the list of candidates if they are far from each other.
+     * @sa minGroupDistance.
+     */
+    CV_PROP_RW double minMarkerDistanceRate;
+
+    /** @brief minimum average distance between the corners of the two markers in group to add them to the list of candidates
+     *
+     * The average distance between the corners of the two markers is calculated relative to its module size (default 0.21).
+     */
+    CV_PROP_RW float minGroupDistance = 0.21f;
+
+    /** @brief default value CORNER_REFINE_NONE */
+    CV_PROP_RW int cornerRefinementMethod;
+
+    /** @brief maximum window size for the corner refinement process (in pixels) (default 5).
+     *
+     * The window size may decrease if the ArUco marker is too small, check relativeCornerRefinmentWinSize.
+     * The final window size is calculated as:
+     * min(cornerRefinementWinSize, averageArucoModuleSize*relativeCornerRefinmentWinSize),
+     * where averageArucoModuleSize is average module size of ArUco marker in pixels.
+     * (ArUco marker is composed of black and white modules)
+     */
+    CV_PROP_RW int cornerRefinementWinSize;
+
+    /** @brief Dynamic window size for corner refinement relative to Aruco module size (default 0.3).
+     *
+     * The final window size is calculated as:
+     * min(cornerRefinementWinSize, averageArucoModuleSize*relativeCornerRefinmentWinSize),
+     * where averageArucoModuleSize is average module size of ArUco marker in pixels.
+     * (ArUco marker is composed of black and white modules)
+     * In the case of markers located far from each other, it may be useful to increase the value of the parameter to 0.4-0.5.
+     * In the case of markers located close to each other, it may be useful to decrease the parameter value to 0.1-0.2.
+     */
+    CV_PROP_RW float relativeCornerRefinmentWinSize;
+
+    /// maximum number of iterations for stop criteria of the corner refinement process (default 30).
+    CV_PROP_RW int cornerRefinementMaxIterations;
+
+    /// minimum error for the stop cristeria of the corner refinement process (default: 0.1)
+    CV_PROP_RW double cornerRefinementMinAccuracy;
+
+    /// number of bits of the marker border, i.e. marker border width (default 1).
+    CV_PROP_RW int markerBorderBits;
+
+    /// number of bits (per dimension) for each cell of the marker when removing the perspective (default 4).
+    CV_PROP_RW int perspectiveRemovePixelPerCell;
+
+    /** @brief width of the margin of pixels on each cell not considered for the determination of the cell bit.
+     *
+     * Represents the rate respect to the total size of the cell, i.e. perspectiveRemovePixelPerCell (default 0.13)
+     */
+    CV_PROP_RW double perspectiveRemoveIgnoredMarginPerCell;
+
+    /** @brief  maximum number of accepted erroneous bits in the border (i.e. number of allowed white bits in the border).
+     *
+     * Represented as a rate respect to the total number of bits per marker (default 0.35).
+     */
+    CV_PROP_RW double maxErroneousBitsInBorderRate;
+
+    /** @brief minimum standard deviation in pixels values during the decodification step to apply Otsu
+     * thresholding (otherwise, all the bits are set to 0 or 1 depending on mean higher than 128 or not) (default 5.0)
+     */
+    CV_PROP_RW double minOtsuStdDev;
+
+    /// error correction rate respect to the maximum error correction capability for each dictionary (default 0.6).
+    CV_PROP_RW double errorCorrectionRate;
+
+    /** @brief April :: User-configurable parameters.
+     *
+     * Detection of quads can be done on a lower-resolution image, improving speed at a cost of
+     * pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still
+     */
+    CV_PROP_RW float aprilTagQuadDecimate;
+
+    /// what Gaussian blur should be applied to the segmented image (used for quad detection?)
+    CV_PROP_RW float aprilTagQuadSigma;
+
+    // April :: Internal variables
+    /// reject quads containing too few pixels (default 5).
+    CV_PROP_RW int aprilTagMinClusterPixels;
+
+    /// how many corner candidates to consider when segmenting a group of pixels into a quad (default 10).
+    CV_PROP_RW int aprilTagMaxNmaxima;
+
+    /** @brief reject quads where pairs of edges have angles that are close to straight or close to 180 degrees.
+     *
+     * Zero means that no quads are rejected. (In radians) (default 10*PI/180)
+     */
+    CV_PROP_RW float aprilTagCriticalRad;
+
+    /// when fitting lines to the contours, what is the maximum mean squared error
+    CV_PROP_RW float aprilTagMaxLineFitMse;
+
+    /** @brief add an extra check that the white model must be (overall) brighter than the black model.
+     *
+     * When we build our model of black & white pixels, we add an extra check that the white model must be (overall)
+     * brighter than the black model. How much brighter? (in pixel values, [0,255]), (default 5)
+     */
+    CV_PROP_RW int aprilTagMinWhiteBlackDiff;
+
+    /// should the thresholded image be deglitched? Only useful for very noisy images (default 0).
+    CV_PROP_RW int aprilTagDeglitch;
+
+    /** @brief to check if there is a white marker.
+     *
+     * In order to generate a "white" marker just invert a normal marker by using a tilde, ~markerImage. (default false)
+     */
+    CV_PROP_RW bool detectInvertedMarker;
+
+    /** @brief enable the new and faster Aruco detection strategy.
+     *
+     * Proposed in the paper:
+     * Romero-Ramirez et al: Speeded up detection of squared fiducial markers (2018)
+     * https://www.researchgate.net/publication/325787310_Speeded_Up_Detection_of_Squared_Fiducial_Markers
+     */
+    CV_PROP_RW bool useAruco3Detection;
+
+    /// minimum side length of a marker in the canonical image. Latter is the binarized image in which contours are searched.
+    CV_PROP_RW int minSideLengthCanonicalImg;
+
+    /// range [0,1], eq (2) from paper. The parameter tau_i has a direct influence on the processing speed.
+    CV_PROP_RW float minMarkerLengthRatioOriginalImg;
+
+    /// range [0,1], define the acceptable threshold when comparing the detected marker to the dictionary during marker identification.
+    CV_PROP_RW float validBitIdThreshold;
+};
+
+/** @brief struct RefineParameters is used by ArucoDetector
+ */
+struct CV_EXPORTS_W_SIMPLE RefineParameters {
+    CV_WRAP RefineParameters(float minRepDistance = 10.f, float errorCorrectionRate = 3.f, bool checkAllOrders = true);
+
+
+    /** @brief Read a new set of RefineParameters from FileNode (use FileStorage.root()).
+     */
+    CV_WRAP bool readRefineParameters(const FileNode& fn);
+
+    /** @brief Write a set of RefineParameters to FileStorage
+     */
+    CV_WRAP bool writeRefineParameters(FileStorage& fs, const String& name = String());
+
+    /** @brief minRepDistance minimum distance between the corners of the rejected candidate and the reprojected marker
+    in order to consider it as a correspondence.
+     */
+    CV_PROP_RW float minRepDistance;
+
+    /** @brief errorCorrectionRate rate of allowed erroneous bits respect to the error correction capability of the used dictionary.
+     *
+     * -1 ignores the error correction step.
+     */
+    CV_PROP_RW float errorCorrectionRate;
+
+    /** @brief checkAllOrders consider the four possible corner orders in the rejectedCorners array.
+     *
+     * If it set to false, only the provided corner order is considered (default true).
+     */
+    CV_PROP_RW bool checkAllOrders;
+};
+
+/** @brief The main functionality of ArucoDetector class is detection of markers in an image with detectMarkers() method.
+ *
+ * After detecting some markers in the image, you can try to find undetected markers from this dictionary with
+ * refineDetectedMarkers() method.
+ *
+ * @see DetectorParameters, RefineParameters
+ */
+class CV_EXPORTS_W ArucoDetector : public Algorithm
+{
+public:
+    /** @brief Basic ArucoDetector constructor
+     *
+     * @param dictionary indicates the type of markers that will be searched
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP ArucoDetector(const Dictionary &dictionary = getPredefinedDictionary(cv::aruco::DICT_4X4_50),
+                          const DetectorParameters &detectorParams = DetectorParameters(),
+                          const RefineParameters& refineParams = RefineParameters());
+
+    /** @brief ArucoDetector constructor for multiple dictionaries
+     *
+     * @param dictionaries indicates the type of markers that will be searched. Empty dictionaries will throw an error.
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP ArucoDetector(const std::vector<Dictionary> &dictionaries,
+                          const DetectorParameters &detectorParams = DetectorParameters(),
+                          const RefineParameters& refineParams = RefineParameters());
+
+    /** @brief Basic marker detection
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     *
+     * Performs marker detection in the input image. Only markers included in the first specified dictionary
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkers(InputArray image, OutputArrayOfArrays corners, OutputArray ids,
+                               OutputArrayOfArrays rejectedImgPoints = noArray()) const;
+
+    /** @brief Marker detection with confidence computation
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param markersConfidence contains the normalized confidence [0;1] of the markers' detection,
+     * defined as 1 minus the normalized uncertainty (percentage of incorrect pixel detections),
+     * with 1 describing a pixel perfect detection. The confidence values are of type float
+     * (e.g. std::vector<float>)
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     *
+     * Performs marker detection in the input image. Only markers included in the first specified dictionary
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkersWithConfidence(InputArray image, OutputArrayOfArrays corners, OutputArray ids, OutputArray markersConfidence,
+                               OutputArrayOfArrays rejectedImgPoints = noArray()) const;
+
+    /** @brief Refine not detected markers based on the already detected and the board layout
+     *
+     * @param image input image
+     * @param board layout of markers in the board.
+     * @param detectedCorners vector of already detected marker corners.
+     * @param detectedIds vector of already detected marker identifiers.
+     * @param rejectedCorners vector of rejected candidates during the marker detection process.
+     * @param cameraMatrix optional input 3x3 floating-point camera matrix
+     * \f$A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\f$
+     * @param distCoeffs optional vector of distortion coefficients
+     * \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\f$ of 4, 5, 8 or 12 elements
+     * @param recoveredIdxs Optional array to returns the indexes of the recovered candidates in the
+     * original rejectedCorners array.
+     *
+     * This function tries to find markers that were not detected in the basic detecMarkers function.
+     * First, based on the current detected marker and the board layout, the function interpolates
+     * the position of the missing markers. Then it tries to find correspondence between the reprojected
+     * markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters.
+     * If camera parameters and distortion coefficients are provided, missing markers are reprojected
+     * using projectPoint function. If not, missing marker projections are interpolated using global
+     * homography, and all the marker corners in the board must have the same Z coordinate.
+     * @note This function assumes that the board only contains markers from one dictionary, so only the
+     * first configured dictionary is used. It has to match the dictionary of the board to work properly.
+     */
+    CV_WRAP void refineDetectedMarkers(InputArray image, const Board &board,
+                                       InputOutputArrayOfArrays detectedCorners,
+                                       InputOutputArray detectedIds, InputOutputArrayOfArrays rejectedCorners,
+                                       InputArray cameraMatrix = noArray(), InputArray distCoeffs = noArray(),
+                                       OutputArray recoveredIdxs = noArray()) const;
+
+    /** @brief Basic marker detection
+     *
+     * @param image input image
+     * @param corners vector of detected marker corners. For each marker, its four corners
+     * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+     * the dimensions of this array is Nx4. The order of the corners is clockwise.
+     * @param ids vector of identifiers of the detected markers. The identifier is of type int
+     * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.
+     * The identifiers have the same order than the markers in the imgPoints array.
+     * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a
+     * correct codification. Useful for debugging purposes.
+     * @param dictIndices vector of dictionary indices for each detected marker. Use getDictionaries() to get the
+     * list of corresponding dictionaries.
+     *
+     * Performs marker detection in the input image. Only markers included in the specific dictionaries
+     * are searched. For each detected marker, it returns the 2D position of its corner in the image
+     * and its corresponding identifier.
+     * Note that this function does not perform pose estimation.
+     * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort
+     * input image with corresponding camera model, if camera parameters are known
+     * @sa undistort, estimatePoseSingleMarkers,  estimatePoseBoard
+     */
+    CV_WRAP void detectMarkersMultiDict(InputArray image, OutputArrayOfArrays corners, OutputArray ids,
+                               OutputArrayOfArrays rejectedImgPoints = noArray(), OutputArray dictIndices = noArray()) const;
+
+    /** @brief Returns first dictionary from internal list used for marker detection.
+     *
+     * @return The first dictionary from the configured ArucoDetector.
+     */
+    CV_WRAP const Dictionary& getDictionary() const;
+
+    /** @brief Sets and replaces the first dictionary in internal list to be used for marker detection.
+     *
+     * @param dictionary The new dictionary that will replace the first dictionary in the internal list.
+     */
+    CV_WRAP void setDictionary(const Dictionary& dictionary);
+
+    /** @brief Returns all dictionaries currently used for marker detection as a vector.
+     *
+     * @return A std::vector<Dictionary> containing all dictionaries used by the ArucoDetector.
+     */
+    CV_WRAP std::vector<Dictionary> getDictionaries() const;
+
+    /** @brief Sets the entire collection of dictionaries to be used for marker detection, replacing any existing dictionaries.
+     *
+     * @param dictionaries A std::vector<Dictionary> containing the new set of dictionaries to be used.
+     *
+     * Configures the ArucoDetector to use the provided vector of dictionaries for marker detection.
+     * This method replaces any dictionaries that were previously set.
+     * @note Setting an empty vector of dictionaries will throw an error.
+     */
+    CV_WRAP void setDictionaries(const std::vector<Dictionary>& dictionaries);
+
+    CV_WRAP const DetectorParameters& getDetectorParameters() const;
+    CV_WRAP void setDetectorParameters(const DetectorParameters& detectorParameters);
+
+    CV_WRAP const RefineParameters& getRefineParameters() const;
+    CV_WRAP void setRefineParameters(const RefineParameters& refineParameters);
+
+    /** @brief Stores algorithm parameters in a file storage
+    */
+    virtual void write(FileStorage& fs) const override;
+
+    /** @brief simplified API for language bindings
+    */
+    CV_WRAP inline void write(FileStorage& fs, const String& name) { Algorithm::write(fs, name); }
+
+    /** @brief Reads algorithm parameters from a file storage
+    */
+    CV_WRAP virtual void read(const FileNode& fn) override;
+protected:
+    struct ArucoDetectorImpl;
+    Ptr<ArucoDetectorImpl> arucoDetectorImpl;
+};
+
+/** @brief Draw detected markers in image
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not altered.
+ * @param corners positions of marker corners on input image.
+ * (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of
+ * this array should be Nx4. The order of the corners should be clockwise.
+ * @param ids vector of identifiers for markers in markersCorners .
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one to improve visualization.
+ *
+ * Given an array of detected marker corners and its corresponding ids, this functions draws
+ * the markers in the image. The marker borders are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedMarkers(InputOutputArray image, InputArrayOfArrays corners,
+                                      InputArray ids = noArray(), Scalar borderColor = Scalar(0, 255, 0));
+
+/** @brief Generate a canonical marker image
+ *
+ * @param dictionary dictionary of markers indicating the type of markers
+ * @param id identifier of the marker that will be returned. It has to be a valid id in the specified dictionary.
+ * @param sidePixels size of the image in pixels
+ * @param img output image with the marker
+ * @param borderBits width of the marker border.
+ *
+ * This function returns a marker image in its canonical form (i.e. ready to be printed)
+ */
+CV_EXPORTS_W void generateImageMarker(const Dictionary &dictionary, int id, int sidePixels, OutputArray img,
+                                      int borderBits = 1);
+
+//! @}
+
+}
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp
new file mode 100644
index 0000000..d918e08
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp
@@ -0,0 +1,164 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_DICTIONARY_HPP
+#define OPENCV_OBJDETECT_DICTIONARY_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+
+/** @brief Dictionary is a set of unique ArUco markers of the same size
+ *
+ * `bytesList` storing as 2-dimensions Mat with 4-th channels (CV_8UC4 type was used) and contains the marker codewords where:
+ * - bytesList.rows is the dictionary size
+ * - each marker is encoded using `nbytes = ceil(markerSize*markerSize/8.)` bytes
+ * - each row contains all 4 rotations of the marker, so its length is `4*nbytes`
+ * - the byte order in the bytesList[i] row:
+ * `//bytes without rotation/bytes with rotation 1/bytes with rotation 2/bytes with rotation 3//`
+ * So `bytesList.ptr(i)[k*nbytes + j]` is the j-th byte of i-th marker, in its k-th rotation.
+ * @note Python bindings generate matrix with shape of bytesList `dictionary_size x nbytes x 4`,
+ * but it should be indexed like C++ version. Python example for j-th byte of i-th marker, in its k-th rotation:
+ * `aruco_dict.bytesList[id].ravel()[k*nbytes + j]`
+ */
+class CV_EXPORTS_W_SIMPLE Dictionary {
+
+    public:
+    CV_PROP_RW Mat bytesList;         ///< marker code information. See class description for more details
+    CV_PROP_RW int markerSize;        ///< number of bits per dimension
+    CV_PROP_RW int maxCorrectionBits; ///< maximum number of bits that can be corrected
+
+    CV_WRAP Dictionary();
+
+    /** @brief Basic ArUco dictionary constructor
+     *
+     * @param bytesList bits for all ArUco markers in dictionary see memory layout in the class description
+     * @param _markerSize ArUco marker size in units
+     * @param maxcorr maximum number of bits that can be corrected
+     */
+    CV_WRAP Dictionary(const Mat &bytesList, int _markerSize, int maxcorr = 0);
+
+    /** @brief Read a new dictionary from FileNode.
+     *
+     * Dictionary example in YAML format:\n
+     * nmarkers: 35\n
+     * markersize: 6\n
+     * maxCorrectionBits: 5\n
+     * marker_0: "101011111011111001001001101100000000"\n
+     * ...\n
+     * marker_34: "011111010000111011111110110101100101"
+     */
+    CV_WRAP bool readDictionary(const cv::FileNode& fn);
+
+    /** @brief Write a dictionary to FileStorage, format is the same as in readDictionary().
+     */
+    CV_WRAP void writeDictionary(FileStorage& fs, const String& name = String());
+
+    /** @brief Given a matrix of bits. Returns whether if marker is identified or not.
+     *
+     * Returns reference to the marker id in the dictionary (if any) and its rotation.
+     */
+    CV_WRAP bool identify(const Mat &onlyBits, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate) const;
+
+    /** @brief Given a matrix of pixel ratio raging from 0 to 1. Returns whether if marker is identified or not.
+     *
+     * Returns reference to the marker id in the dictionary (if any) and its rotation.
+     */
+    CV_WRAP bool identify(const Mat &onlyCellPixelRatio, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate, float validBitIdThreshold) const;
+
+    /** @brief Returns Hamming distance of the input bits to the specific id.
+     *
+     * If `allRotations` flag is set, the four possible marker rotations are considered
+     */
+    CV_WRAP int getDistanceToId(InputArray bits, int id, bool allRotations = true) const;
+
+    /** @brief Generate a canonical marker image
+     */
+    CV_WRAP void generateImageMarker(int id, int sidePixels, OutputArray _img, int borderBits = 1) const;
+
+
+    /** @brief Transform matrix of bits to list of bytes with 4 marker rotations
+      */
+    CV_WRAP static Mat getByteListFromBits(const Mat &bits);
+
+
+    /** @brief Transform list of bytes to matrix of bits
+      */
+    CV_WRAP static Mat getBitsFromByteList(const Mat &byteList, int markerSize, int rotationId = 0);
+
+    /** @brief Get ground truth bits float
+      */
+     CV_WRAP Mat getMarkerBits(int markerId, int rotationId = 0) const;
+};
+
+
+
+
+/** @brief Predefined markers dictionaries/sets
+ *
+ * Each dictionary indicates the number of bits and the number of markers contained
+ * - DICT_ARUCO_ORIGINAL: standard ArUco Library Markers. 1024 markers, 5x5 bits, 0 minimum
+                          distance
+ */
+enum PredefinedDictionaryType {
+    DICT_4X4_50 = 0,        ///< 4x4 bits, minimum hamming distance between any two codes = 4, 50 codes
+    DICT_4X4_100,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 100 codes
+    DICT_4X4_250,           ///< 4x4 bits, minimum hamming distance between any two codes = 3, 250 codes
+    DICT_4X4_1000,          ///< 4x4 bits, minimum hamming distance between any two codes = 2, 1000 codes
+    DICT_5X5_50,            ///< 5x5 bits, minimum hamming distance between any two codes = 8, 50 codes
+    DICT_5X5_100,           ///< 5x5 bits, minimum hamming distance between any two codes = 7, 100 codes
+    DICT_5X5_250,           ///< 5x5 bits, minimum hamming distance between any two codes = 6, 250 codes
+    DICT_5X5_1000,          ///< 5x5 bits, minimum hamming distance between any two codes = 5, 1000 codes
+    DICT_6X6_50,            ///< 6x6 bits, minimum hamming distance between any two codes = 13, 50 codes
+    DICT_6X6_100,           ///< 6x6 bits, minimum hamming distance between any two codes = 12, 100 codes
+    DICT_6X6_250,           ///< 6x6 bits, minimum hamming distance between any two codes = 11, 250 codes
+    DICT_6X6_1000,          ///< 6x6 bits, minimum hamming distance between any two codes = 9, 1000 codes
+    DICT_7X7_50,            ///< 7x7 bits, minimum hamming distance between any two codes = 19, 50 codes
+    DICT_7X7_100,           ///< 7x7 bits, minimum hamming distance between any two codes = 18, 100 codes
+    DICT_7X7_250,           ///< 7x7 bits, minimum hamming distance between any two codes = 17, 250 codes
+    DICT_7X7_1000,          ///< 7x7 bits, minimum hamming distance between any two codes = 14, 1000 codes
+    DICT_ARUCO_ORIGINAL,    ///< 6x6 bits, minimum hamming distance between any two codes = 3, 1024 codes
+    DICT_APRILTAG_16h5,     ///< 4x4 bits, minimum hamming distance between any two codes = 5, 30 codes
+    DICT_APRILTAG_25h9,     ///< 5x5 bits, minimum hamming distance between any two codes = 9, 35 codes
+    DICT_APRILTAG_36h10,    ///< 6x6 bits, minimum hamming distance between any two codes = 10, 2320 codes
+    DICT_APRILTAG_36h11,     ///< 6x6 bits, minimum hamming distance between any two codes = 11, 587 codes
+    DICT_ARUCO_MIP_36h12     ///< 6x6 bits, minimum hamming distance between any two codes = 12, 250 codes
+};
+
+
+/** @brief Returns one of the predefined dictionaries defined in PredefinedDictionaryType
+  */
+CV_EXPORTS Dictionary getPredefinedDictionary(PredefinedDictionaryType name);
+
+
+/** @brief Returns one of the predefined dictionaries referenced by DICT_*.
+  */
+CV_EXPORTS_W Dictionary getPredefinedDictionary(int dict);
+
+/** @brief Extend base dictionary by new nMarkers
+  *
+  * @param nMarkers number of markers in the dictionary
+  * @param markerSize number of bits per dimension of each markers
+  * @param baseDictionary Include the markers in this dictionary at the beginning (optional)
+  * @param randomSeed a user supplied seed for theRNG()
+  *
+  * This function creates a new dictionary composed by nMarkers markers and each markers composed
+  * by markerSize x markerSize bits. If baseDictionary is provided, its markers are directly
+  * included and the rest are generated based on them. If the size of baseDictionary is higher
+  * than nMarkers, only the first nMarkers in baseDictionary are taken and no new marker is added.
+  */
+CV_EXPORTS_W Dictionary extendDictionary(int nMarkers, int markerSize, const Dictionary &baseDictionary = Dictionary(),
+                                         int randomSeed=0);
+
+
+
+//! @}
+}
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/barcode.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/barcode.hpp
new file mode 100644
index 0000000..e1dd3f4
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/barcode.hpp
@@ -0,0 +1,117 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_OBJDETECT_BARCODE_HPP
+#define OPENCV_OBJDETECT_BARCODE_HPP
+
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect/graphical_code_detector.hpp>
+
+namespace cv {
+namespace barcode {
+
+//! @addtogroup objdetect_barcode
+//! @{
+
+class CV_EXPORTS_W_SIMPLE BarcodeDetector : public cv::GraphicalCodeDetector
+{
+public:
+    /** @brief Initialize the BarcodeDetector. Super resolution is disabled.
+    */
+    CV_WRAP BarcodeDetector();
+
+    /** @brief Initialize the BarcodeDetector with a Super Resolution model.
+     *
+     * Loads a Super Resolution DNN model in ONNX format, used to upscale small/low-quality
+     * barcode crops before decoding for better quality.
+     *
+     * @note Caffe models (`sr.prototxt` / `sr.caffemodel`) are no longer supported; convert
+     * the model to ONNX (a converted `sr.onnx` is available from
+     * https://github.com/WeChatCV/opencv_3rdparty/tree/wechat_qrcode).
+     *
+     * @param super_resolution_model_path path to a single-file ONNX Super Resolution model.
+     */
+    CV_WRAP BarcodeDetector(CV_WRAP_FILE_PATH const std::string &super_resolution_model_path);
+    ~BarcodeDetector();
+
+    /** @brief Decodes barcode in image once it's found by the detect() method.
+     *
+     * @param img grayscale or color (BGR) image containing bar code.
+     * @param points vector of rotated rectangle vertices found by detect() method (or some other algorithm).
+     * For N detected barcodes, the dimensions of this array should be [N][4].
+     * Order of four points in vector<Point2f> is bottomLeft, topLeft, topRight, bottomRight.
+     * @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+     * @param decoded_type vector strings, specifies the type of these barcodes
+     * @return true if at least one valid barcode have been found
+     */
+    CV_WRAP bool decodeWithType(InputArray img,
+                             InputArray points,
+                             CV_OUT std::vector<std::string> &decoded_info,
+                             CV_OUT std::vector<std::string> &decoded_type) const;
+
+    /** @brief Both detects and decodes barcode
+
+     * @param img grayscale or color (BGR) image containing barcode.
+     * @param decoded_info UTF8-encoded output vector of string(s) or empty vector of string if the codes cannot be decoded.
+     * @param decoded_type vector of strings, specifies the type of these barcodes
+     * @param points optional output vector of vertices of the found  barcode rectangle. Will be empty if not found.
+     * @return true if at least one valid barcode have been found
+     */
+    CV_WRAP bool detectAndDecodeWithType(InputArray img,
+                                      CV_OUT std::vector<std::string> &decoded_info,
+                                      CV_OUT std::vector<std::string> &decoded_type,
+                                      OutputArray points = noArray()) const;
+
+    /** @brief Get detector downsampling threshold.
+     *
+     * @return detector downsampling threshold
+     */
+    CV_WRAP double getDownsamplingThreshold() const;
+
+    /** @brief Set detector downsampling threshold.
+     *
+     * By default, the detect method resizes the input image to this limit if the smallest image size is is greater than the threshold.
+     * Increasing this value can improve detection accuracy and the number of results at the expense of performance.
+     * Correlates with detector scales. Setting this to a large value will disable downsampling.
+     * @param thresh downsampling limit to apply (default 512)
+     * @see setDetectorScales
+     */
+    CV_WRAP BarcodeDetector& setDownsamplingThreshold(double thresh);
+
+    /** @brief Returns detector box filter sizes.
+     *
+     * @param sizes output parameter for returning the sizes.
+     */
+    CV_WRAP void getDetectorScales(CV_OUT std::vector<float>& sizes) const;
+
+    /** @brief Set detector box filter sizes.
+     *
+     * Adjusts the value and the number of box filters used in the detect step.
+     * The filter sizes directly correlate with the expected line widths for a barcode. Corresponds to expected barcode distance.
+     * If the downsampling limit is increased, filter sizes need to be adjusted in an inversely proportional way.
+     * @param sizes box filter sizes, relative to minimum dimension of the image (default [0.01, 0.03, 0.06, 0.08])
+     */
+    CV_WRAP BarcodeDetector& setDetectorScales(const std::vector<float>& sizes);
+
+    /** @brief Get detector gradient magnitude threshold.
+     *
+     * @return detector gradient magnitude threshold.
+     */
+    CV_WRAP double getGradientThreshold() const;
+
+    /** @brief Set detector gradient magnitude threshold.
+     *
+     * Sets the coherence threshold for detected bounding boxes.
+     * Increasing this value will generate a closer fitted bounding box width and can reduce false-positives.
+     * Values between 16 and 1024 generally work, while too high of a value will remove valid detections.
+     * @param thresh gradient magnitude threshold (default 64).
+     */
+    CV_WRAP BarcodeDetector& setGradientThreshold(double thresh);
+};
+//! @}
+
+}} // cv::barcode::
+
+#endif // OPENCV_OBJDETECT_BARCODE_HPP
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/charuco_detector.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/charuco_detector.hpp
new file mode 100644
index 0000000..999874c
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/charuco_detector.hpp
@@ -0,0 +1,161 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_CHARUCO_DETECTOR_HPP
+#define OPENCV_OBJDETECT_CHARUCO_DETECTOR_HPP
+
+#include "opencv2/objdetect/aruco_detector.hpp"
+
+namespace cv {
+namespace aruco {
+
+//! @addtogroup objdetect_aruco
+//! @{
+
+struct CV_EXPORTS_W_SIMPLE CharucoParameters {
+    CV_WRAP CharucoParameters() {
+        minMarkers = 2;
+        tryRefineMarkers = false;
+        checkMarkers = true;
+    }
+    /// cameraMatrix optional 3x3 floating-point camera matrix
+    CV_PROP_RW Mat cameraMatrix;
+
+    /// distCoeffs optional vector of distortion coefficients
+    CV_PROP_RW Mat distCoeffs;
+
+    /// minMarkers number of adjacent markers that must be detected to return a charuco corner, default = 2
+    CV_PROP_RW int minMarkers;
+
+    /// try to use refine board, default false
+    CV_PROP_RW bool tryRefineMarkers;
+
+    /// run check to verify that markers belong to the same board, default true
+    CV_PROP_RW bool checkMarkers;
+};
+
+class CV_EXPORTS_W CharucoDetector : public Algorithm {
+public:
+    /** @brief Basic CharucoDetector constructor
+     *
+     * @param board ChAruco board
+     * @param charucoParams charuco detection parameters
+     * @param detectorParams marker detection parameters
+     * @param refineParams marker refine detection parameters
+     */
+    CV_WRAP CharucoDetector(const CharucoBoard& board,
+                            const CharucoParameters& charucoParams = CharucoParameters(),
+                            const DetectorParameters &detectorParams = DetectorParameters(),
+                            const RefineParameters& refineParams = RefineParameters());
+
+    CV_WRAP const CharucoBoard& getBoard() const;
+    CV_WRAP void setBoard(const CharucoBoard& board);
+
+    CV_WRAP const CharucoParameters& getCharucoParameters() const;
+    CV_WRAP void setCharucoParameters(CharucoParameters& charucoParameters);
+
+    CV_WRAP const DetectorParameters& getDetectorParameters() const;
+    CV_WRAP void setDetectorParameters(const DetectorParameters& detectorParameters);
+
+    CV_WRAP const RefineParameters& getRefineParameters() const;
+    CV_WRAP void setRefineParameters(const RefineParameters& refineParameters);
+
+    /**
+     * @brief detect aruco markers and interpolate position of ChArUco board corners
+     * @param image input image necessary for corner refinement. Note that markers are not detected and
+     * should be sent in corners and ids parameters.
+     * @param charucoCorners interpolated chessboard corners.
+     * @param charucoIds interpolated chessboard corners identifiers.
+     * @param markerCorners vector of already detected markers corners. For each marker, its four
+     * corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the
+     * dimensions of this array should be Nx4. The order of the corners should be clockwise.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     * @param markerIds list of identifiers for each marker in corners.
+     *  If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     *
+     * This function receives the detected markers and returns the 2D position of the chessboard corners
+     * from a ChArUco board using the detected Aruco markers.
+     *
+     * If markerCorners and markerCorners are empty, the detectMarkers() will run and detect aruco markers and ids.
+     *
+     * If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography.
+     * Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds.
+     * @sa findChessboardCorners
+     * @note After OpenCV 4.6.0, there was an incompatible change in the ChArUco pattern generation algorithm for even row counts.
+     * Use cv::aruco::CharucoBoard::setLegacyPattern() to ensure compatibility with patterns created using OpenCV versions prior to 4.6.0.
+     * For more information, see the issue: https://github.com/opencv/opencv/issues/23152
+     */
+    CV_WRAP void detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                             InputOutputArrayOfArrays markerCorners = noArray(),
+                             InputOutputArray markerIds = noArray()) const;
+
+    /**
+     * @brief Detect ChArUco Diamond markers
+     *
+     * @param image input image necessary for corner subpixel.
+     * @param diamondCorners output list of detected diamond corners (4 corners per diamond). The order
+     * is the same than in marker corners: top left, top right, bottom right and bottom left. Similar
+     * format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).
+     * @param diamondIds ids of the diamonds in diamondCorners. The id of each diamond is in fact of
+     * type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the
+     * diamond.
+     * @param markerCorners list of detected marker corners from detectMarkers function.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     * @param markerIds list of marker ids in markerCorners.
+     * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+     *
+     * This function detects Diamond markers from the previous detected ArUco markers. The diamonds
+     * are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters
+     * are provided, the diamond search is based on reprojection. If not, diamond search is based on
+     * homography. Homography is faster than reprojection, but less accurate.
+     */
+    CV_WRAP void detectDiamonds(InputArray image, OutputArrayOfArrays diamondCorners, OutputArray diamondIds,
+                                InputOutputArrayOfArrays markerCorners = noArray(),
+                                InputOutputArray markerIds = noArray()) const;
+protected:
+    struct CharucoDetectorImpl;
+    Ptr<CharucoDetectorImpl> charucoDetectorImpl;
+};
+
+/**
+ * @brief Draws a set of Charuco corners
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param charucoCorners vector of detected charuco corners
+ * @param charucoIds list of identifiers for each corner in charucoCorners
+ * @param cornerColor color of the square surrounding each corner
+ *
+ * This function draws a set of detected Charuco corners. If identifiers vector is provided, it also
+ * draws the id of each corner.
+ */
+CV_EXPORTS_W void drawDetectedCornersCharuco(InputOutputArray image, InputArray charucoCorners,
+                                             InputArray charucoIds = noArray(), Scalar cornerColor = Scalar(255, 0, 0));
+
+/**
+ * @brief Draw a set of detected ChArUco Diamond markers
+ *
+ * @param image input/output image. It must have 1 or 3 channels. The number of channels is not
+ * altered.
+ * @param diamondCorners positions of diamond corners in the same format returned by
+ * detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,
+ * the dimensions of this array should be Nx4. The order of the corners should be clockwise.
+ * @param diamondIds vector of identifiers for diamonds in diamondCorners, in the same format
+ * returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>).
+ * Optional, if not provided, ids are not painted.
+ * @param borderColor color of marker borders. Rest of colors (text color and first corner color)
+ * are calculated based on this one.
+ *
+ * Given an array of detected diamonds, this functions draws them in the image. The marker borders
+ * are painted and the markers identifiers if provided.
+ * Useful for debugging purposes.
+ */
+CV_EXPORTS_W void drawDetectedDiamonds(InputOutputArray image, InputArrayOfArrays diamondCorners,
+                                       InputArray diamondIds = noArray(),
+                                       Scalar borderColor = Scalar(0, 0, 255));
+
+//! @}
+
+}
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/face.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/face.hpp
new file mode 100644
index 0000000..df6539f
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/face.hpp
@@ -0,0 +1,179 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_OBJDETECT_FACE_HPP
+#define OPENCV_OBJDETECT_FACE_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+
+//! @addtogroup objdetect_dnn_face
+//! @{
+
+/** @brief DNN-based face detector
+
+model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet
+ */
+class CV_EXPORTS_W FaceDetectorYN
+{
+public:
+    virtual ~FaceDetectorYN() {}
+
+    /** @brief Set the size for the network input, which overwrites the input size of creating model. Call this method when the size of input image does not match the input size when creating model
+     *
+     * @param input_size the size of the input image
+     */
+    CV_WRAP virtual void setInputSize(const Size& input_size) = 0;
+
+    CV_WRAP virtual Size getInputSize() = 0;
+
+    /** @brief Set the score threshold to filter out bounding boxes of score less than the given value
+     *
+     * @param score_threshold threshold for filtering out bounding boxes
+     */
+    CV_WRAP virtual void setScoreThreshold(float score_threshold) = 0;
+
+    CV_WRAP virtual float getScoreThreshold() = 0;
+
+    /** @brief Set the Non-maximum-suppression threshold to suppress bounding boxes that have IoU greater than the given value
+     *
+     * @param nms_threshold threshold for NMS operation
+     */
+    CV_WRAP virtual void setNMSThreshold(float nms_threshold) = 0;
+
+    CV_WRAP virtual float getNMSThreshold() = 0;
+
+    /** @brief Set the number of bounding boxes preserved before NMS
+     *
+     * @param top_k the number of bounding boxes to preserve from top rank based on score
+     */
+    CV_WRAP virtual void setTopK(int top_k) = 0;
+
+    CV_WRAP virtual int getTopK() = 0;
+
+    /** @brief Detects faces in the input image. Following is an example output.
+
+     * ![image](pics/lena-face-detection.jpg)
+
+     *  @param image an image to detect
+     *  @param faces detection results stored in a 2D cv::Mat of shape [num_faces, 15]
+     *  - 0-1: x, y of bbox top left corner
+     *  - 2-3: width, height of bbox
+     *  - 4-5: x, y of right eye (blue point in the example image)
+     *  - 6-7: x, y of left eye (red point in the example image)
+     *  - 8-9: x, y of nose tip (green point in the example image)
+     *  - 10-11: x, y of right corner of mouth (pink point in the example image)
+     *  - 12-13: x, y of left corner of mouth (yellow point in the example image)
+     *  - 14: face score
+     */
+    CV_WRAP virtual int detect(InputArray image, OutputArray faces) = 0;
+
+    /** @brief Creates an instance of face detector class with given parameters
+     *
+     *  @param model the path to the requested model
+     *  @param config the path to the config file for compatibility, which is not requested for ONNX models
+     *  @param input_size the size of the input image
+     *  @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value
+     *  @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value
+     *  @param top_k keep top K bboxes before NMS
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceDetectorYN> create(CV_WRAP_FILE_PATH const String& model,
+                                              CV_WRAP_FILE_PATH const String& config,
+                                              const Size& input_size,
+                                              float score_threshold = 0.9f,
+                                              float nms_threshold = 0.3f,
+                                              int top_k = 5000,
+                                              int backend_id = 0,
+                                              int target_id = 0);
+
+    /** @overload
+     *
+     *  @param framework Name of origin framework
+     *  @param bufferModel A buffer with a content of binary file with weights
+     *  @param bufferConfig A buffer with a content of text file contains network configuration
+     *  @param input_size the size of the input image
+     *  @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value
+     *  @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value
+     *  @param top_k keep top K bboxes before NMS
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceDetectorYN> create(const String& framework,
+                                              const std::vector<uchar>& bufferModel,
+                                              const std::vector<uchar>& bufferConfig,
+                                              const Size& input_size,
+                                              float score_threshold = 0.9f,
+                                              float nms_threshold = 0.3f,
+                                              int top_k = 5000,
+                                              int backend_id = 0,
+                                              int target_id = 0);
+
+};
+
+/** @brief DNN-based face recognizer
+
+model download link: https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface
+ */
+class CV_EXPORTS_W FaceRecognizerSF
+{
+public:
+    virtual ~FaceRecognizerSF() {}
+
+    /** @brief Definition of distance used for calculating the distance between two face features
+     */
+    enum DisType { FR_COSINE=0, FR_NORM_L2=1 };
+
+    /** @brief Aligns detected face with the source input image and crops it
+     *  @param src_img input image
+     *  @param face_box the detected face result from the input image
+     *  @param aligned_img output aligned image
+     */
+    CV_WRAP virtual void alignCrop(InputArray src_img, InputArray face_box, OutputArray aligned_img) const = 0;
+
+    /** @brief Extracts face feature from aligned image
+     *  @param aligned_img input aligned image
+     *  @param face_feature output face feature
+     */
+    CV_WRAP virtual void feature(InputArray aligned_img, OutputArray face_feature) = 0;
+
+    /** @brief Calculates the distance between two face features
+     *  @param face_feature1 the first input feature
+     *  @param face_feature2 the second input feature of the same size and the same type as face_feature1
+     *  @param dis_type defines how to calculate the distance between two face features with optional values "FR_COSINE" or "FR_NORM_L2"
+     */
+    CV_WRAP virtual double match(InputArray face_feature1, InputArray face_feature2, int dis_type = FaceRecognizerSF::FR_COSINE) const = 0;
+
+    /** @brief Creates an instance of this class with given parameters
+     *  @param model the path of the onnx model used for face recognition
+     *  @param config the path to the config file for compatibility, which is not requested for ONNX models
+     *  @param backend_id the id of backend
+     *  @param target_id the id of target device
+     */
+    CV_WRAP static Ptr<FaceRecognizerSF> create(CV_WRAP_FILE_PATH const String& model, CV_WRAP_FILE_PATH const String& config, int backend_id = 0, int target_id = 0);
+
+    /**
+     *  @brief Creates an instance of this class from a buffer containing the model weights and configuration.
+     *  @param framework Name of the framework (ONNX, etc.)
+     *  @param bufferModel A buffer containing the binary model weights.
+     *  @param bufferConfig A buffer containing the network configuration.
+     *  @param backend_id The id of the backend.
+     *  @param target_id The id of the target device.
+     *
+     *  @return A pointer to the created instance of FaceRecognizerSF.
+     */
+    CV_WRAP static Ptr<FaceRecognizerSF> create(const String& framework,
+                                                const std::vector<uchar>& bufferModel,
+                                                const std::vector<uchar>& bufferConfig,
+                                                int backend_id = 0,
+                                                int target_id = 0);
+};
+
+//! @}
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/graphical_code_detector.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/graphical_code_detector.hpp
new file mode 100644
index 0000000..adc5237
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/graphical_code_detector.hpp
@@ -0,0 +1,96 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_HPP
+#define OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+
+//! @addtogroup objdetect_common
+//! @{
+
+class CV_EXPORTS_W_SIMPLE GraphicalCodeDetector {
+public:
+    CV_DEPRECATED_EXTERNAL  // avoid using in C++ code, will be moved to "protected" (need to fix bindings first)
+    GraphicalCodeDetector();
+
+    GraphicalCodeDetector(const GraphicalCodeDetector&) = default;
+    GraphicalCodeDetector(GraphicalCodeDetector&&) = default;
+    GraphicalCodeDetector& operator=(const GraphicalCodeDetector&) = default;
+    GraphicalCodeDetector& operator=(GraphicalCodeDetector&&) = default;
+
+    /** @brief Detects graphical code in image and returns the quadrangle containing the code.
+     @param img grayscale or color (BGR) image containing (or not) graphical code.
+     @param points Output vector of vertices of the minimum-area quadrangle containing the code.
+     */
+    CV_WRAP bool detect(InputArray img, OutputArray points) const;
+
+    /** @brief Decodes graphical code in image once it's found by the detect() method.
+
+     Returns UTF8-encoded output string or empty string if the code cannot be decoded.
+     @param img grayscale or color (BGR) image containing graphical code.
+     @param points Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_code The optional output image containing binarized code, will be empty if not found.
+     */
+    CV_WRAP std::string decode(InputArray img, InputArray points, OutputArray straight_code = noArray()) const;
+
+    /** @brief Both detects and decodes graphical code
+
+     @param img grayscale or color (BGR) image containing graphical code.
+     @param points optional output array of vertices of the found graphical code quadrangle, will be empty if not found.
+     @param straight_code The optional output image containing binarized code
+     */
+    CV_WRAP std::string detectAndDecode(InputArray img, OutputArray points = noArray(),
+                                        OutputArray straight_code = noArray()) const;
+
+
+    /** @brief Detects graphical codes in image and returns the vector of the quadrangles containing the codes.
+     @param img grayscale or color (BGR) image containing (or not) graphical codes.
+     @param points Output vector of vector of vertices of the minimum-area quadrangle containing the codes.
+     */
+    CV_WRAP bool detectMulti(InputArray img, OutputArray points) const;
+
+    /** @brief Decodes graphical codes in image once it's found by the detect() method.
+     @param img grayscale or color (BGR) image containing graphical codes.
+     @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+     @param points vector of Quadrangle vertices found by detect() method (or some other algorithm).
+     @param straight_code The optional output vector of images containing binarized codes
+     */
+    CV_WRAP bool decodeMulti(InputArray img, InputArray points, CV_OUT std::vector<std::string>& decoded_info,
+                             OutputArrayOfArrays straight_code = noArray()) const;
+
+    /** @brief Both detects and decodes graphical codes
+    @param img grayscale or color (BGR) image containing graphical codes.
+    @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.
+    @param points optional output vector of vertices of the found graphical code quadrangles. Will be empty if not found.
+    @param straight_code The optional vector of images containing binarized codes
+
+    - If there are QR codes encoded with a Structured Append mode on the image and all of them detected and decoded correctly,
+    method writes a full message to position corresponds to 0-th code in a sequence. The rest of QR codes from the same sequence
+    have empty string.
+    */
+    CV_WRAP bool detectAndDecodeMulti(InputArray img, CV_OUT std::vector<std::string>& decoded_info, OutputArray points = noArray(),
+                                      OutputArrayOfArrays straight_code = noArray()) const;
+
+#ifdef OPENCV_BINDINGS_PARSER
+    CV_WRAP_AS(detectAndDecodeBytes) NativeByteArray detectAndDecode(InputArray img, OutputArray points = noArray(),
+                                                                     OutputArray straight_code = noArray()) const;
+    CV_WRAP_AS(decodeBytes) NativeByteArray decode(InputArray img, InputArray points, OutputArray straight_code = noArray()) const;
+    CV_WRAP_AS(decodeBytesMulti) bool decodeMulti(InputArray img, InputArray points, CV_OUT std::vector<NativeByteArray>& decoded_info,
+                                                  OutputArrayOfArrays straight_code = noArray()) const;
+    CV_WRAP_AS(detectAndDecodeBytesMulti) bool detectAndDecodeMulti(InputArray img, CV_OUT std::vector<NativeByteArray>& decoded_info, OutputArray points = noArray(),
+                                                                    OutputArrayOfArrays straight_code = noArray()) const;
+#endif
+
+    struct Impl;
+protected:
+    Ptr<Impl> p;
+};
+
+//! @}
+
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp
new file mode 100644
index 0000000..267b872
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/mcc_checker_detector.hpp
@@ -0,0 +1,307 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef OPENCV_OBJDETECT_MCC_CHECKER_DETECTOR_HPP
+#define OPENCV_OBJDETECT_MCC_CHECKER_DETECTOR_HPP
+#include <opencv2/core.hpp>
+#ifdef HAVE_OPENCV_DNN
+#include <opencv2/dnn.hpp>
+#endif
+#include <opencv2/imgproc.hpp>
+
+//---------------------------------------------------------------
+// #define MCC_DEBUG
+//---------------------------------------------------------------
+
+namespace cv
+{
+namespace mcc
+{
+//! @addtogroup mcc
+//! @{
+
+/** ColorChart
+ *
+ * @brief enum to hold the type of the checker
+ */
+enum ColorChart
+{
+    MCC24 = 0, ///< Standard Macbeth Chart with 24 squares
+    SG140,     ///< DigitalSG with 140 squares
+    VINYL18,   ///< DKK color chart with 12 squares and 6 rectangle
+};
+
+/** CChecker
+ *
+ * @brief checker object
+ *
+ *     This class contains the information about the detected checkers,i.e, their
+ *     type, the corners of the chart, the color profile, the cost, centers chart,
+ *     etc.
+ */
+class CV_EXPORTS_W CChecker: public Algorithm
+{
+public:
+    CChecker() {}
+    virtual ~CChecker() {}
+    /** @brief Create a new CChecker object.
+     *
+     * @return A pointer to the implementation of the CChecker
+     */
+    CV_WRAP static Ptr<CChecker> create();
+public:
+    CV_WRAP virtual void setTarget(ColorChart _target)  = 0;
+    CV_WRAP virtual void setBox(std::vector<Point2f> _box) = 0;
+    CV_WRAP virtual void setChartsRGB(Mat _chartsRGB) = 0;
+    CV_WRAP virtual void setChartsYCbCr(Mat _chartsYCbCr) = 0;
+    CV_WRAP virtual void setCost(float _cost) = 0;
+    CV_WRAP virtual void setCenter(Point2f _center) = 0;
+
+    CV_WRAP virtual ColorChart getTarget() = 0;
+    CV_WRAP virtual std::vector<Point2f> getBox() = 0;
+
+    /** @brief Computes and returns the coordinates of the central parts of the charts modules.
+     *
+     * This method computes transformation matrix from the checkers's coordinates (`CChecker::getBox()`)
+     * and find by this the coordinates of the central parts of the charts modules.
+     * It is used in `CCheckerDetector::draw()` and in `ChartsRGB` calculation.
+     */
+    CV_WRAP virtual std::vector<Point2f> getColorCharts() = 0;
+
+    CV_WRAP virtual Mat getChartsRGB(bool getStats = true) = 0;
+    CV_WRAP virtual Mat getChartsYCbCr() = 0;
+    CV_WRAP virtual float getCost() = 0;
+    CV_WRAP virtual Point2f getCenter() = 0;
+};
+
+/** @brief struct DetectorParametersMCC is used by CCheckerDetector
+ */
+struct CV_EXPORTS_W_SIMPLE DetectorParametersMCC
+{
+    CV_WRAP DetectorParametersMCC(){
+        adaptiveThreshWinSizeMin=23;
+        adaptiveThreshWinSizeMax=153;
+        adaptiveThreshWinSizeStep=16;
+        adaptiveThreshConstant=7;
+        minContoursAreaRate=0.003;
+        minContoursArea=100;
+        confidenceThreshold=0.5;
+        minContourSolidity=0.9;
+        findCandidatesApproxPolyDPEpsMultiplier=0.05;
+        borderWidth=0;
+        B0factor=1.25f;
+        maxError=0.1f;
+        minContourPointsAllowed=4;
+        minContourLengthAllowed=100;
+        minInterContourDistance=100;
+        minInterCheckerDistance=10000;
+        minImageSize=1000;
+        minGroupSize=4;
+    }
+    /// minimum window size for adaptive thresholding before finding contours (default 23).
+    CV_PROP_RW int adaptiveThreshWinSizeMin;
+
+    /// maximum window size for adaptive thresholding before finding contours (default 153).
+    CV_PROP_RW int adaptiveThreshWinSizeMax;
+
+    /// increments from adaptiveThreshWinSizeMin to adaptiveThreshWinSizeMax during the thresholding (default 16).
+    CV_PROP_RW int adaptiveThreshWinSizeStep;
+
+    /// constant for adaptive thresholding before finding contours (default 7)
+    CV_PROP_RW double adaptiveThreshConstant;
+
+    /** @brief determine minimum area for marker contour to be detected
+     *
+     * This is defined as a rate respect to the area of the input image. Used only if neural network is used (default 0.03).
+     */
+    CV_PROP_RW double minContoursAreaRate;
+
+    /** @brief determine minimum area for marker contour to be detected
+     *
+     * This is defined as the actual area. Used only if neural network is used (default 100).
+     */
+    CV_PROP_RW double minContoursArea;
+
+    /// minimum confidence for a bounding box detected by neural network to classify as detection.(default 0.5) (0<=confidenceThreshold<=1)
+    CV_PROP_RW double confidenceThreshold;
+
+    /// minimum solidity of a contour for it be detected as a square in the chart. (default 0.9).
+    CV_PROP_RW double minContourSolidity;
+
+    /// multipler to be used in ApproxPolyDP function (default 0.05)
+    CV_PROP_RW double findCandidatesApproxPolyDPEpsMultiplier;
+
+    /// width of the padding used to pass the inital neural network detection in the succeeding system.(default 0)
+    CV_PROP_RW int borderWidth;
+
+    /// distance between two neighboring squares of the same chart as a ratio of the large dimension of a square (default 1.25).
+    CV_PROP_RW float B0factor;
+
+    /// maximum allowed error in the detection of a chart (default 0.1).
+    CV_PROP_RW float maxError;
+
+    /// minimum points in a detected contour (default 4).
+    CV_PROP_RW int minContourPointsAllowed;
+
+    /// minimum length of a contour (default 100).
+    CV_PROP_RW int minContourLengthAllowed;
+
+    /// minimum distance between two contours (default 100).
+    CV_PROP_RW int minInterContourDistance;
+
+    /// minimum distance between two checkers (default 10000).
+    CV_PROP_RW int minInterCheckerDistance;
+
+    /// minimum size of the smaller dimension of the image (default 1000).
+    CV_PROP_RW int minImageSize;
+
+    /// minimum number of squares in a chart that must be detected (default 4).
+    CV_PROP_RW int minGroupSize;
+};
+
+/** @brief A class to find the positions of the ColorCharts in the image.
+ */
+
+class CV_EXPORTS_W CCheckerDetector : public Algorithm
+{
+public:
+    /** @brief Find the ColorCharts in the given image.
+    *
+    * The found charts are not returned but instead stored in the
+    * detector, these can be accessed later on using getBestColorChecker()
+    * and getListColorChecker()
+    * @param image image in color space BGR
+    * @param regionsOfInterest regions of image to look for the chart, if
+    *                          it is empty, charts are looked for in the
+    *                          entire image
+    * @param nc number of charts in the image, if you don't know the exact
+    *           then keeping this number high helps.
+    * @return true if atleast one chart is detected otherwise false
+    */
+
+    CV_WRAP_AS(processWithROI) virtual bool
+    process(InputArray image, const std::vector<Rect> &regionsOfInterest,
+            const int nc = 1) = 0;
+
+
+    /** @brief Find the ColorCharts in the given image.
+    *
+    * Differs from the above one only in the arguments.
+    *
+    * This version searches for the chart in the full image.
+    *
+    * The found charts are not returned but instead stored in the
+    * detector, these can be accessed later on using getBestColorChecker()
+    * and getListColorChecker()
+    * @param image image in color space BGR
+    * @param nc number of charts in the image, if you don't know the exact
+    *           then keeping this number high helps.
+    * @return true if atleast one chart is detected otherwise false
+    */
+
+    CV_WRAP virtual bool
+    process(InputArray image, const int nc = 1) = 0;
+
+    /** @brief Get the best color checker. By the best it means the one
+    *         detected with the highest confidence.
+    * @return checker A single colorchecker, if atleast one colorchecker
+    *                 was detected, 'nullptr' otherwise.
+    */
+    CV_WRAP virtual Ptr<mcc::CChecker> getBestColorChecker() = 0;
+
+    /** @brief Get the list of all detected colorcheckers
+    * @return checkers vector of colorcheckers
+    */
+    CV_WRAP virtual std::vector<Ptr<CChecker>> getListColorChecker() = 0;
+
+    /** @brief Returns the implementation of the CCheckerDetector.
+    *
+    */
+    CV_WRAP static Ptr<CCheckerDetector> create();
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Set the net which will be used to find the approximate
+    *         bounding boxes for the color charts. And returns the implementation of the CCheckerDetector.
+    *
+    * It is not necessary to use this, but this usually results in
+    * better detection rate.
+    *
+    * @param net the neural network, if the network in empty, then
+    *            the function will return false.
+    */
+    CV_WRAP static Ptr<CCheckerDetector> create(const dnn::Net &net);
+#endif
+
+    /** @brief Draws the checker to the given image.
+        * @param img image in color space BGR
+        * @param checkers The checkers which will be drawn by this object.
+        * @param color The color by with which the squares of the checker
+        *         will be drawn
+        * @param thickness The thickness with which the sqaures will be
+        *         drawn
+    */
+
+    CV_WRAP virtual void draw(std::vector<Ptr<CChecker>>& checkers, InputOutputArray img, const Scalar color = CV_RGB(0,250,0), const int thickness = 2) = 0;
+
+    /** @brief Gets the reference color for chart.
+    */
+
+    CV_WRAP virtual Mat getRefColors() = 0;
+
+    /** @brief Sets the detection paramaters for mcc.
+        * @param params DetectorParametersMCC structure containing detection configuration parameters.
+    */
+
+    CV_WRAP virtual void setDetectionParams(const DetectorParametersMCC &params) = 0;
+
+    /** @brief Sets the color chart type for MCC detection.
+        * @param chartType ColorChart enum specifying the type of color chart to detect.
+    */
+
+    CV_WRAP virtual void setColorChartType(ColorChart chartType) = 0;
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Enables or disables the use of the neural network for detection.
+        * @param useDnn Boolean flag to indicate whether to use neural network (true) or not (false).
+    */
+
+    CV_WRAP virtual void setUseDnnModel(bool useDnn) = 0;
+
+    CV_WRAP virtual bool getUseDnnModel() const = 0;
+#endif
+
+    CV_WRAP virtual const DetectorParametersMCC& getDetectionParams() const = 0;
+
+    CV_WRAP virtual ColorChart getColorChartType() const = 0;
+};
+
+//! @} mcc
+} // namespace mcc
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/include/opencv2/objdetect/objdetect.hpp b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
new file mode 100644
index 0000000..3ee284f
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
@@ -0,0 +1,48 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/objdetect.hpp"
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp
new file mode 100644
index 0000000..41e6852
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.cpp
@@ -0,0 +1,1640 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+// limitation: image size must be <32768 in width and height. This is
+// because we use a fixed-point 16 bit integer representation with one
+// fractional bit.
+
+#include "../../precomp.hpp"
+#include "apriltag_quad_thresh.hpp"
+#include "unionfind.hpp"
+
+//#define APRIL_DEBUG
+#ifdef APRIL_DEBUG
+    #include "opencv2/imgcodecs.hpp"
+    #include <opencv2/imgproc.hpp>
+#endif
+
+namespace cv {
+namespace aruco {
+
+static void ptsort_(struct pt *pts, int sz); // forward delaration
+
+static inline
+void ptsort(struct pt *pts, int sz)
+{
+#define MAYBE_SWAP(arr,apos,bpos)                                   \
+        if (arr[apos].theta > arr[bpos].theta) {                        \
+            tmp = arr[apos]; arr[apos] = arr[bpos]; arr[bpos] = tmp;    \
+        };
+
+    if (sz <= 1)
+        return;
+
+    if (sz == 2) {
+        struct pt tmp;
+        MAYBE_SWAP(pts, 0, 1);
+        return;
+    }
+
+    // NB: Using less-branch-intensive sorting networks here on the
+    // hunch that it's better for performance.
+    if (sz == 3) { // 3 element bubble sort is optimal
+        struct pt tmp;
+        MAYBE_SWAP(pts, 0, 1);
+        MAYBE_SWAP(pts, 1, 2);
+        MAYBE_SWAP(pts, 0, 1);
+        return;
+    }
+
+    if (sz == 4) { // 4 element optimal sorting network.
+        struct pt tmp;
+        MAYBE_SWAP(pts, 0, 1); // sort each half, like a merge sort
+        MAYBE_SWAP(pts, 2, 3);
+        MAYBE_SWAP(pts, 0, 2); // minimum value is now at 0.
+        MAYBE_SWAP(pts, 1, 3); // maximum value is now at end.
+        MAYBE_SWAP(pts, 1, 2); // that only leaves the middle two.
+        return;
+    }
+
+    if (sz == 5) {
+        // this 9-step swap is optimal for a sorting network, but two
+        // steps slower than a generic sort.
+        struct pt tmp;
+        MAYBE_SWAP(pts, 0, 1); // sort each half (3+2), like a merge sort
+        MAYBE_SWAP(pts, 3, 4);
+        MAYBE_SWAP(pts, 1, 2);
+        MAYBE_SWAP(pts, 0, 1);
+        MAYBE_SWAP(pts, 0, 3); // minimum element now at 0
+        MAYBE_SWAP(pts, 2, 4); // maximum element now at end
+        MAYBE_SWAP(pts, 1, 2); // now resort the three elements 1-3.
+        MAYBE_SWAP(pts, 2, 3);
+        MAYBE_SWAP(pts, 1, 2);
+        return;
+    }
+
+#undef MAYBE_SWAP
+
+    ptsort_(pts, sz);
+}
+
+void ptsort_(struct pt *pts, int sz)
+{
+    // a merge sort with temp storage.
+
+    // Use stack storage if it's not too big.
+    AutoBuffer<struct pt, 1024> _tmp_stack(sz);
+    memcpy(_tmp_stack.data(), pts, sizeof(struct pt) * sz);
+
+    int asz = sz/2;
+    int bsz = sz - asz;
+
+    struct pt *as = &_tmp_stack[0];
+    struct pt *bs = &_tmp_stack[asz];
+
+    ptsort(as, asz);
+    ptsort(bs, bsz);
+
+#define MERGE(apos,bpos)                        \
+    if (as[apos].theta < bs[bpos].theta)        \
+        pts[outpos++] = as[apos++];             \
+    else                                        \
+        pts[outpos++] = bs[bpos++];
+
+    int apos = 0, bpos = 0, outpos = 0;
+    while (apos + 8 < asz && bpos + 8 < bsz) {
+        MERGE(apos,bpos); MERGE(apos,bpos); MERGE(apos,bpos); MERGE(apos,bpos);
+        MERGE(apos,bpos); MERGE(apos,bpos); MERGE(apos,bpos); MERGE(apos,bpos);
+    }
+
+    while (apos < asz && bpos < bsz) {
+        MERGE(apos,bpos);
+    }
+
+    if (apos < asz)
+        memcpy(&pts[outpos], &as[apos], (asz-apos)*sizeof(struct pt));
+    if (bpos < bsz)
+        memcpy(&pts[outpos], &bs[bpos], (bsz-bpos)*sizeof(struct pt));
+
+#undef MERGE
+}
+
+/**
+ * lfps contains *cumulative* moments for N points, with
+ * index j reflecting points [0,j] (inclusive).
+ * fit a line to the points [i0, i1] (inclusive). i0, i1 are both (0, sz)
+ * if i1 < i0, we treat this as a wrap around.
+ */
+void fit_line(struct line_fit_pt *lfps, int sz, int i0, int i1, double *lineparm, double *err, double *mse){
+    CV_Assert(i0 != i1);
+    CV_Assert(i0 >= 0 && i1 >= 0 && i0 < sz && i1 < sz);
+
+    double Mx, My, Mxx, Myy, Mxy, W;
+    int N; // how many points are included in the set?
+
+    if (i0 < i1) {
+        N = i1 - i0 + 1;
+
+        Mx  = lfps[i1].Mx;
+        My  = lfps[i1].My;
+        Mxx = lfps[i1].Mxx;
+        Mxy = lfps[i1].Mxy;
+        Myy = lfps[i1].Myy;
+        W   = lfps[i1].W;
+
+        if (i0 > 0) {
+            Mx  -= lfps[i0-1].Mx;
+            My  -= lfps[i0-1].My;
+            Mxx -= lfps[i0-1].Mxx;
+            Mxy -= lfps[i0-1].Mxy;
+            Myy -= lfps[i0-1].Myy;
+            W   -= lfps[i0-1].W;
+        }
+
+    } else {
+        // i0 > i1, e.g. [15, 2]. Wrap around.
+        CV_Assert(i0 > 0);
+
+        Mx  = lfps[sz-1].Mx   - lfps[i0-1].Mx;
+        My  = lfps[sz-1].My   - lfps[i0-1].My;
+        Mxx = lfps[sz-1].Mxx  - lfps[i0-1].Mxx;
+        Mxy = lfps[sz-1].Mxy  - lfps[i0-1].Mxy;
+        Myy = lfps[sz-1].Myy  - lfps[i0-1].Myy;
+        W   = lfps[sz-1].W    - lfps[i0-1].W;
+
+        Mx  += lfps[i1].Mx;
+        My  += lfps[i1].My;
+        Mxx += lfps[i1].Mxx;
+        Mxy += lfps[i1].Mxy;
+        Myy += lfps[i1].Myy;
+        W   += lfps[i1].W;
+
+        N = sz - i0 + i1 + 1;
+    }
+
+    CV_Assert(N >= 2);
+
+    double Ex = Mx / W;
+    double Ey = My / W;
+    double Cxx = Mxx / W - Ex*Ex;
+    double Cxy = Mxy / W - Ex*Ey;
+    double Cyy = Myy / W - Ey*Ey;
+
+    double nx, ny;
+
+    if (1) {
+        // on iOS about 5% of total CPU spent in these trig functions.
+        // 85 ms per frame on 5S, example.pnm
+        //
+        // XXX this was using the double-precision atan2. Was there a case where
+        // we needed that precision? Seems doubtful.
+        float normal_theta = float(.5f * (CV_PI / 180)) * cv::fastAtan2((float)(-2*Cxy), (float)(Cyy - Cxx));
+        nx = cosf(normal_theta);
+        ny = sinf(normal_theta);
+    } else {
+        // 73.5 ms per frame on 5S, example.pnm
+        double ty = -2*Cxy;
+        double tx = (Cyy - Cxx);
+        double mag = ty*ty + tx*tx;
+
+        if (mag == 0) {
+            nx = 1;
+            ny = 0;
+        } else {
+            float norm = sqrtf((float)(ty*ty + tx*tx));
+            tx /= norm;
+
+            // ty is now sin(2theta)
+            // tx is now cos(2theta). We want sin(theta) and cos(theta)
+
+            // due to precision err, tx could still have slightly too large magnitude.
+            if (tx > 1) {
+                ny = 0;
+                nx = 1;
+            } else if (tx < -1) {
+                ny = 1;
+                nx = 0;
+            } else {
+                // half angle formula
+                ny = sqrtf((1.0f - (float)tx)*0.5f);
+                nx = sqrtf((1.0f + (float)tx)*0.5f);
+
+                // pick a consistent branch cut
+                if (ty < 0)
+                    ny = - ny;
+            }
+        }
+    }
+
+    if (lineparm) {
+        lineparm[0] = Ex;
+        lineparm[1] = Ey;
+        lineparm[2] = nx;
+        lineparm[3] = ny;
+    }
+
+    // sum of squared errors =
+    //
+    // SUM_i ((p_x - ux)*nx + (p_y - uy)*ny)^2
+    // SUM_i  nx*nx*(p_x - ux)^2 + 2nx*ny(p_x -ux)(p_y-uy) + ny*ny*(p_y-uy)*(p_y-uy)
+    //  nx*nx*SUM_i((p_x -ux)^2) + 2nx*ny*SUM_i((p_x-ux)(p_y-uy)) + ny*ny*SUM_i((p_y-uy)^2)
+    //
+    //  nx*nx*N*Cxx + 2nx*ny*N*Cxy + ny*ny*N*Cyy
+
+    // sum of squared errors
+    if (err)
+        *err = nx*nx*N*Cxx + 2*nx*ny*N*Cxy + ny*ny*N*Cyy;
+
+    // mean squared error
+    if (mse)
+        *mse = nx*nx*Cxx + 2*nx*ny*Cxy + ny*ny*Cyy;
+}
+
+int err_compare_descending(const void *_a, const void *_b){
+    const double *a =  (const double*)_a;
+    const double *b =  (const double*)_b;
+
+    return ((*a) < (*b)) ? 1 : -1;
+}
+
+/**
+  1. Identify A) white points near a black point and B) black points near a white point.
+
+  2. Find the connected components within each of the classes above,
+  yielding clusters of "white-near-black" and
+  "black-near-white". (These two classes are kept separate). Each
+  segment has a unique id.
+
+  3. For every pair of "white-near-black" and "black-near-white"
+  clusters, find the set of points that are in one and adjacent to the
+  other. In other words, a "boundary" layer between the two
+  clusters. (This is actually performed by iterating over the pixels,
+  rather than pairs of clusters.) Critically, this helps keep nearby
+  edges from becoming connected.
+ **/
+int quad_segment_maxima(const DetectorParameters &td, int sz, struct line_fit_pt *lfps, int indices[4]){
+
+    // ksz: when fitting points, how many points on either side do we consider?
+    // (actual "kernel" width is 2ksz).
+    //
+    // This value should be about: 0.5 * (points along shortest edge).
+    //
+    // If all edges were equally-sized, that would give a value of
+    // sz/8. We make it somewhat smaller to account for tags at high
+    // aspects.
+
+    // XXX Tunable. Maybe make a multiple of JPEG block size to increase robustness
+    // to JPEG compression artifacts?
+    //int ksz = imin(20, sz / 12);
+    int ksz = 20 < (sz/12)? 20: (sz/12);
+
+    // can't fit a quad if there are too few points.
+    if (ksz < 2)
+        return 0;
+
+    //    printf("sz %5d, ksz %3d\n", sz, ksz);
+
+    std::vector<double> errs(sz);
+
+    for (int i = 0; i < sz; i++) {
+        fit_line(lfps, sz, (i + sz - ksz) % sz, (i + ksz) % sz, NULL, &errs[i], NULL);
+    }
+
+    // apply a low-pass filter to errs
+    if (1) {
+        std::vector<double> y(sz);
+
+        // how much filter to apply?
+
+        // XXX Tunable
+        double sigma = 1; // was 3
+
+        // cutoff = exp(-j*j/(2*sigma*sigma));
+        // log(cutoff) = -j*j / (2*sigma*sigma)
+        // log(cutoff)*2*sigma*sigma = -j*j;
+
+        // how big a filter should we use? We make our kernel big
+        // enough such that we represent any values larger than
+        // 'cutoff'.
+
+        // XXX Tunable (though not super useful to change)
+        double cutoff = 0.05;
+        int fsz = cvFloor(sqrt(-log(cutoff)*2*sigma*sigma)) + 1;
+        fsz = 2*fsz + 1;
+
+        // For default values of cutoff = 0.05, sigma = 3,
+        // we have fsz = 17.
+        std::vector<float> f(fsz);
+
+        for (int i = 0; i < fsz; i++) {
+            int j = i - fsz / 2;
+            f[i] = (float)exp(-j*j/(2*sigma*sigma));
+        }
+
+        for (int iy = 0; iy < sz; iy++) {
+            double acc = 0;
+
+            for (int i = 0; i < fsz; i++) {
+                acc += errs[(iy + i - fsz / 2 + sz) % sz] * f[i];
+            }
+            y[iy] = acc;
+        }
+        std::copy(y.begin(), y.end(), errs.begin());
+    }
+
+    std::vector<int> maxima(sz);
+    std::vector<double> maxima_errs(sz);
+    int nmaxima = 0;
+
+    for (int i = 0; i < sz; i++) {
+        if (errs[i] > errs[(i+1)%sz] && errs[i] > errs[(i+sz-1)%sz]) {
+            maxima[nmaxima] = i;
+            maxima_errs[nmaxima] = errs[i];
+            nmaxima++;
+        }
+    }
+    // if we didn't get at least 4 maxima, we can't fit a quad.
+    if (nmaxima < 4)
+        return 0;
+
+    // select only the best maxima if we have too many
+    int max_nmaxima = td.aprilTagMaxNmaxima;
+
+    if (nmaxima > max_nmaxima) {
+        std::vector<double> maxima_errs_copy(maxima_errs.begin(), maxima_errs.begin()+nmaxima);
+
+        // throw out all but the best handful of maxima. Sorts descending.
+        qsort(maxima_errs_copy.data(), nmaxima, sizeof(double), err_compare_descending);
+
+        double maxima_thresh = maxima_errs_copy[max_nmaxima];
+        int out = 0;
+        for (int in = 0; in < nmaxima; in++) {
+            if (maxima_errs[in] <= maxima_thresh)
+                continue;
+            maxima[out++] = maxima[in];
+        }
+        nmaxima = out;
+    }
+
+    int best_indices[4];
+    double best_error = HUGE_VALF;
+
+    double err01, err12, err23, err30;
+    double mse01, mse12, mse23, mse30;
+    double params01[4], params12[4], params23[4], params30[4];
+
+    // disallow quads where the angle is less than a critical value.
+    double max_dot = cos(td.aprilTagCriticalRad); //25*M_PI/180);
+
+    for (int m0 = 0; m0 < nmaxima - 3; m0++) {
+        int i0 = maxima[m0];
+
+        for (int m1 = m0+1; m1 < nmaxima - 2; m1++) {
+            int i1 = maxima[m1];
+
+            fit_line(lfps, sz, i0, i1, params01, &err01, &mse01);
+
+            if (mse01 > td.aprilTagMaxLineFitMse)
+                continue;
+
+            for (int m2 = m1+1; m2 < nmaxima - 1; m2++) {
+                int i2 = maxima[m2];
+
+                fit_line(lfps, sz, i1, i2, params12, &err12, &mse12);
+                if (mse12 > td.aprilTagMaxLineFitMse)
+                    continue;
+
+                double dot = params01[2]*params12[2] + params01[3]*params12[3];
+                if (fabs(dot) > max_dot)
+                    continue;
+
+                for (int m3 = m2+1; m3 < nmaxima; m3++) {
+                    int i3 = maxima[m3];
+
+                    fit_line(lfps, sz, i2, i3, params23, &err23, &mse23);
+                    if (mse23 > td.aprilTagMaxLineFitMse)
+                        continue;
+
+                    fit_line(lfps, sz, i3, i0, params30, &err30, &mse30);
+                    if (mse30 > td.aprilTagMaxLineFitMse)
+                        continue;
+
+                    double err = err01 + err12 + err23 + err30;
+                    if (err < best_error) {
+                        best_error = err;
+                        best_indices[0] = i0;
+                        best_indices[1] = i1;
+                        best_indices[2] = i2;
+                        best_indices[3] = i3;
+                    }
+                }
+            }
+        }
+    }
+
+    if (best_error == HUGE_VALF)
+        return 0;
+
+    for (int i = 0; i < 4; i++)
+        indices[i] = best_indices[i];
+
+    if (best_error / sz < td.aprilTagMaxLineFitMse)
+        return 1;
+    return 0;
+}
+
+/**
+ * returns 0 if the cluster looks bad.
+ */
+int quad_segment_agg(int sz, struct line_fit_pt *lfps, int indices[4]){
+    //int sz = zarray_size(cluster);
+
+    zmaxheap_t *heap = zmaxheap_create(sizeof(struct remove_vertex*));
+
+    // We will initially allocate sz rvs. We then have two types of
+    // iterations: some iterations that are no-ops in terms of
+    // allocations, and those that remove a vertex and allocate two
+    // more children.  This will happen at most (sz-4) times.  Thus we
+    // need: sz + 2*(sz-4) entries.
+
+    int rvalloc_pos = 0;
+    int rvalloc_size = 3*sz;
+    cv::AutoBuffer<struct remove_vertex, 0> rvalloc_(std::max(1, rvalloc_size));
+    memset(rvalloc_.data(), 0, sizeof(rvalloc_[0]) * rvalloc_.size()); // TODO Add AutoBuffer zero fill
+    struct remove_vertex *rvalloc = rvalloc_.data();
+    cv::AutoBuffer<struct segment, 0> segs_(std::max(1, sz)); // TODO Add AutoBuffer zero fill
+    memset(segs_.data(), 0, sizeof(segs_[0]) * segs_.size());
+    struct segment *segs = segs_.data();
+
+    // populate with initial entries
+    for (int i = 0; i < sz; i++) {
+        struct remove_vertex *rv = &rvalloc[rvalloc_pos++];
+        rv->i = i;
+        if (i == 0) {
+            rv->left = sz-1;
+            rv->right = 1;
+        } else {
+            rv->left  = i-1;
+            rv->right = (i+1) % sz;
+        }
+
+        fit_line(lfps, sz, rv->left, rv->right, NULL, NULL, &rv->err);
+
+        //TODO is finite CV_Assert():
+        CV_DbgAssert (!cvIsNaN(-rv->err) && "zmaxheap_add: Trying to add non-finite number to heap.  NaN's prohibited, could allow INF with testing");
+        zmaxheap_add(heap, &rv, (float)-rv->err);
+
+        segs[i].left = rv->left;
+        segs[i].right = rv->right;
+        segs[i].is_vertex = 1;
+    }
+
+    int nvertices = sz;
+
+    while (nvertices > 4) {
+        CV_Assert(rvalloc_pos < rvalloc_size);
+
+        struct remove_vertex *rv;
+        float err;
+
+        int res = zmaxheap_remove_max(heap, &rv, &err);
+        if (!res)
+            return 0;
+        CV_Assert(res);
+
+        // is this remove_vertex valid? (Or has one of the left/right
+        // vertices changes since we last looked?)
+        if (!segs[rv->i].is_vertex ||
+                !segs[rv->left].is_vertex ||
+                !segs[rv->right].is_vertex) {
+            continue;
+        }
+
+        // we now merge.
+        CV_Assert(segs[rv->i].is_vertex);
+
+        segs[rv->i].is_vertex = 0;
+        segs[rv->left].right = rv->right;
+        segs[rv->right].left = rv->left;
+
+        // create the join to the left
+        if (1) {
+            struct remove_vertex *child = &rvalloc[rvalloc_pos++];
+            child->i = rv->left;
+            child->left = segs[rv->left].left;
+            child->right = rv->right;
+
+            fit_line(lfps, sz, child->left, child->right, NULL, NULL, &child->err);
+
+            //TODO is finite CV_Assert():
+            CV_DbgAssert (!cvIsNaN(-child->err) && "zmaxheap_add: Trying to add non-finite number to heap.  NaN's prohibited, could allow INF with testing");
+            zmaxheap_add(heap, &child, (float)-child->err);
+        }
+
+        // create the join to the right
+        if (1) {
+            struct remove_vertex *child = &rvalloc[rvalloc_pos++];
+            child->i = rv->right;
+            child->left = rv->left;
+            child->right = segs[rv->right].right;
+
+            fit_line(lfps, sz, child->left, child->right, NULL, NULL, &child->err);
+
+            //TODO is finite CV_Assert():
+            CV_DbgAssert (!cvIsNaN(-child->err) && "zmaxheap_add: Trying to add non-finite number to heap.  NaN's prohibited, could allow INF with testing");
+            zmaxheap_add(heap, &child, (float)-child->err);
+        }
+
+        // we now have one less vertex
+        nvertices--;
+    }
+
+    zmaxheap_destroy(heap);
+
+    int idx = 0;
+    for (int i = 0; i < sz; i++) {
+        if (segs[i].is_vertex) {
+            indices[idx++] = i;
+        }
+    }
+
+    return 1;
+}
+
+/**
+ *  return 1 if the quad looks okay, 0 if it should be discarded
+ *  quad
+ **/
+int fit_quad(const DetectorParameters &_params, const Mat im, zarray_t *cluster, struct sQuad *quad){
+    CV_Assert(cluster != NULL);
+
+    int res = 0;
+
+    int sz = _zarray_size(cluster);
+    if (sz < 4) // can't fit a quad to less than 4 points
+        return 0;
+
+    /////////////////////////////////////////////////////////////
+    // Step 1. Sort points so they wrap around the center of the
+    // quad. We will constrain our quad fit to simply partition this
+    // ordered set into 4 groups.
+
+    // compute a bounding box so that we can order the points
+    // according to their angle WRT the center.
+    int32_t xmax = 0, xmin = INT32_MAX, ymax = 0, ymin = INT32_MAX;
+
+    for (int pidx = 0; pidx < sz; pidx++) {
+        struct pt *p;
+        _zarray_get_volatile(cluster, pidx, &p);
+
+        //(a > b) ? a : b;
+        //xmax = imax(xmax, p->x);
+        //xmin = imin(xmin, p->x);
+        //ymax = imax(ymax, p->y);
+        //ymin = imin(ymin, p->y);
+
+        xmax = xmax > p->x? xmax : p->x;
+        xmin = xmin < p->x? xmin : p->x;
+
+        ymax = ymax > p->y? ymax : p->y;
+        ymin = ymin < p->y? ymin : p->y;
+    }
+
+    // add some noise to (cx,cy) so that pixels get a more diverse set
+    // of theta estimates. This will help us remove more points.
+    // (Only helps a small amount. The actual noise values here don't
+    // matter much at all, but we want them [-1, 1]. (XXX with
+    // fixed-point, should range be bigger?)
+    double cx = (xmin + xmax) * 0.5 + 0.05118;
+    double cy = (ymin + ymax) * 0.5 + -0.028581;
+
+    double dot = 0;
+
+    for (int pidx = 0; pidx < sz; pidx++) {
+        struct pt *p;
+        _zarray_get_volatile(cluster, pidx, &p);
+
+        double dx = p->x - cx;
+        double dy = p->y - cy;
+
+        p->theta = cv::fastAtan2((float)dy, (float)dx) * (float)(CV_PI/180);
+
+        dot += dx*p->gx + dy*p->gy;
+    }
+
+    // Ensure that the black border is inside the white border.
+    if (dot < 0)
+        return 0;
+
+    // we now sort the points according to theta. This is a preparatory
+    // step for segmenting them into four lines.
+    if (1) {
+        //        zarray_sort(cluster, pt_compare_theta);
+        ptsort((struct pt*) cluster->data, sz);
+
+        // remove duplicate points. (A byproduct of our segmentation system.)
+        if (1) {
+            int outpos = 1;
+
+            struct pt *last;
+            _zarray_get_volatile(cluster, 0, &last);
+
+            for (int i = 1; i < sz; i++) {
+
+                struct pt *p;
+                _zarray_get_volatile(cluster, i, &p);
+
+                if (p->x != last->x || p->y != last->y) {
+
+                    if (i != outpos)  {
+                        struct pt *out;
+                        _zarray_get_volatile(cluster, outpos, &out);
+                        memcpy(out, p, sizeof(struct pt));
+                    }
+
+                    outpos++;
+                }
+
+                last = p;
+            }
+
+            cluster->size = outpos;
+            sz = outpos;
+        }
+
+    } else {
+        // This is a counting sort in which we retain at most one
+        // point for every bucket; the bucket index is computed from
+        // theta. Since a good quad completes a complete revolution,
+        // there's reason to think that we should get a good
+        // distribution of thetas.  We might "lose" a few points due
+        // to collisions, but this shouldn't affect quality very much.
+
+        // XXX tunable. Increase to reduce the likelihood of "losing"
+        // points due to collisions.
+        int nbuckets = 4*sz;
+
+#define ASSOC 2
+        std::vector<std::vector<struct pt> > v(nbuckets, std::vector<struct pt>(ASSOC));
+
+        // put each point into a bucket.
+        for (int i = 0; i < sz; i++) {
+            struct pt *p;
+            _zarray_get_volatile(cluster, i, &p);
+
+            CV_Assert(p->theta >= -CV_PI && p->theta <= CV_PI);
+
+            int bucket = cvFloor((nbuckets - 1) * (p->theta + CV_PI) / (2*CV_PI));
+            CV_Assert(bucket >= 0 && bucket < nbuckets);
+
+            for (int j = 0; j < ASSOC; j++) {
+                if (v[bucket][j].theta == 0) {
+                    v[bucket][j] = *p;
+                    break;
+                }
+            }
+        }
+
+        // collect the points from the buckets and put them back into the array.
+        int outsz = 0;
+        for (int i = 0; i < nbuckets; i++) {
+            for (int j = 0; j < ASSOC; j++) {
+                if (v[i][j].theta != 0) {
+                    _zarray_set(cluster, outsz, &v[i][j], NULL);
+                    outsz++;
+                }
+            }
+        }
+
+        _zarray_truncate(cluster, outsz);
+        sz = outsz;
+    }
+
+    if (sz < 4)
+        return 0;
+
+    /////////////////////////////////////////////////////////////
+    // Step 2. Precompute statistics that allow line fit queries to be
+    // efficiently computed for any contiguous range of indices.
+
+    cv::AutoBuffer<struct line_fit_pt, 64> lfps_(sz);
+    memset(lfps_.data(), 0, sizeof(lfps_[0]) * lfps_.size()); // TODO Add AutoBuffer zero fill
+    struct line_fit_pt *lfps = lfps_.data();
+
+    for (int i = 0; i < sz; i++) {
+        struct pt *p;
+        _zarray_get_volatile(cluster, i, &p);
+
+        if (i > 0) {
+            memcpy(&lfps[i], &lfps[i-1], sizeof(struct line_fit_pt));
+        }
+
+        if (0) {
+            // we now undo our fixed-point arithmetic.
+            double delta = 0.5;
+            double x = p->x * .5 + delta;
+            double y = p->y * .5 + delta;
+            double W;
+
+            for (int dy = -1; dy <= 1; dy++) {
+                int iy = cvFloor(y + dy);
+
+                if (iy < 0 || iy + 1 >= im.rows)
+                    continue;
+
+                for (int dx = -1; dx <= 1; dx++) {
+                    int ix = cvFloor(x + dx);
+
+                    if (ix < 0 || ix + 1 >= im.cols)
+                        continue;
+
+                    int grad_x = im.data[iy * im.cols + ix + 1] -
+                            im.data[iy * im.cols + ix - 1];
+
+                    int grad_y = im.data[(iy+1) * im.cols + ix] -
+                            im.data[(iy-1) * im.cols + ix];
+
+                    W = sqrtf(float(grad_x*grad_x + grad_y*grad_y)) + 1;
+
+                    //                    double fx = x + dx, fy = y + dy;
+                    double fx = ix + .5, fy = iy + .5;
+                    lfps[i].Mx  += W * fx;
+                    lfps[i].My  += W * fy;
+                    lfps[i].Mxx += W * fx * fx;
+                    lfps[i].Mxy += W * fx * fy;
+                    lfps[i].Myy += W * fy * fy;
+                    lfps[i].W   += W;
+                }
+            }
+        } else {
+            // we now undo our fixed-point arithmetic.
+            double delta = 0.5; // adjust for pixel center bias
+            double x = p->x * .5 + delta;
+            double y = p->y * .5 + delta;
+            int ix = cvFloor(x), iy = cvFloor(y);
+            double W = 1;
+
+            if (ix > 0 && ix+1 < im.cols && iy > 0 && iy+1 < im.rows) {
+                int grad_x = im.data[iy * im.cols + ix + 1] -
+                        im.data[iy * im.cols + ix - 1];
+
+                int grad_y = im.data[(iy+1) * im.cols + ix] -
+                        im.data[(iy-1) * im.cols + ix];
+
+                // XXX Tunable. How to shape the gradient magnitude?
+                W = sqrt(grad_x*grad_x + grad_y*grad_y) + 1;
+            }
+
+            double fx = x, fy = y;
+            lfps[i].Mx  += W * fx;
+            lfps[i].My  += W * fy;
+            lfps[i].Mxx += W * fx * fx;
+            lfps[i].Mxy += W * fx * fy;
+            lfps[i].Myy += W * fy * fy;
+            lfps[i].W   += W;
+        }
+    }
+
+    int indices[4];
+    if (1) {
+        if (!quad_segment_maxima(_params, _zarray_size(cluster), lfps, indices))
+            goto finish;
+    } else {
+        if (!quad_segment_agg(sz, lfps, indices))
+            goto finish;
+    }
+
+    //    printf("%d %d %d %d\n", indices[0], indices[1], indices[2], indices[3]);
+
+    if (0) {
+        // no refitting here; just use those points as the vertices.
+        // Note, this is useful for debugging, but pretty bad in
+        // practice since this code path also omits several
+        // plausibility checks that save us tons of time in quad
+        // decoding.
+        for (int i = 0; i < 4; i++) {
+            struct pt *p;
+            _zarray_get_volatile(cluster, indices[i], &p);
+
+            quad->p[i][0] = (float)(.5*p->x); // undo fixed-point arith.
+            quad->p[i][1] = (float)(.5*p->y);
+        }
+
+        res = 1;
+
+    } else {
+        double lines[4][4];
+
+        for (int i = 0; i < 4; i++) {
+            int i0 = indices[i];
+            int i1 = indices[(i+1)&3];
+
+            if (0) {
+                // if there are enough points, skip the points near the corners
+                // (because those tend not to be very good.)
+                if (i1-i0 > 8) {
+                    int t = (i1-i0)/6;
+                    if (t < 0)
+                        t = -t;
+
+                    i0 = (i0 + t) % sz;
+                    i1 = (i1 + sz - t) % sz;
+                }
+            }
+
+            double err;
+            fit_line(lfps, sz, i0, i1, lines[i], NULL, &err);
+
+            if (err > _params.aprilTagMaxLineFitMse) {
+                res = 0;
+                goto finish;
+            }
+        }
+
+        for (int i = 0; i < 4; i++) {
+            // solve for the intersection of lines (i) and (i+1)&3.
+            // p0 + lambda0*u0 = p1 + lambda1*u1, where u0 and u1
+            // are the line directions.
+            //
+            // lambda0*u0 - lambda1*u1 = (p1 - p0)
+            //
+            // rearrange (solve for lambdas)
+            //
+            // [u0_x   -u1_x ] [lambda0] = [ p1_x - p0_x ]
+            // [u0_y   -u1_y ] [lambda1]   [ p1_y - p0_y ]
+            //
+            // remember that lines[i][0,1] = p, lines[i][2,3] = NORMAL vector.
+            // We want the unit vector, so we need the perpendiculars. Thus, below
+            // we have swapped the x and y components and flipped the y components.
+
+            const int i1 = (i + 1) & 3;
+            double A00 =  lines[i][3],  A01 = -lines[i1][3];
+            double A10 =  -lines[i][2],  A11 = lines[i1][2];
+            double B0 = -lines[i][0] + lines[i1][0];
+            double B1 = -lines[i][1] + lines[i1][1];
+
+            double det = A00 * A11 - A10 * A01;
+            if (fabs(det) < 0.001) {
+                res = 0;
+                goto finish;
+            }
+
+            // inverse.
+            double det_inv = 1.0 / det;
+            double W00 = A11 * det_inv, W01 = -A01 * det_inv;
+
+            // solve
+            double L0 = W00*B0 + W01*B1;
+
+            // compute intersection
+            quad->p[i][0] = (float)(lines[i][0] + L0*A00);
+            quad->p[i][1] = (float)(lines[i][1] + L0*A10);
+
+#if !defined(NDEBUG)
+            {
+                // we should get the same intersection starting
+                // from point p1 and moving L1*u1.
+                double W10 = -A10 * det_inv, W11 = A00 * det_inv;
+                double L1 = W10*B0 + W11*B1;
+
+                double x = lines[i1][0] - L1*A01;
+                double y = lines[i1][1] - L1*A11;
+
+                CV_Assert(fabs(x - quad->p[i][0]) < 0.001);
+                CV_Assert(fabs(y - quad->p[i][1]) < 0.001);
+            }
+#endif // NDEBUG
+
+            res = 1;
+        }
+    }
+
+    // reject quads that are too small
+    if (1) {
+        double area = 0;
+
+        // get area of triangle formed by points 0, 1, 2, 0
+        double length[3], p;
+        for (int i = 0; i < 3; i++) {
+            int idxa = i; // 0, 1, 2,
+            int idxb = (i+1) % 3; // 1, 2, 0
+            //length[i] = sqrt(
+            //                 sq(quad->p[idxb][0] - quad->p[idxa][0])
+            //               + sq(quad->p[idxb][1] - quad->p[idxa][1]));
+            double sq1 = quad->p[idxb][0] - quad->p[idxa][0];
+            sq1 = sq1 * sq1;
+            double sq2 = quad->p[idxb][1] - quad->p[idxa][1];
+            sq2 = sq2 * sq2;
+            length[i] = sqrt(sq1 + sq2);
+        }
+        p = (length[0] + length[1] + length[2]) / 2;
+
+        area += sqrt(p*(p-length[0])*(p-length[1])*(p-length[2]));
+
+        // get area of triangle formed by points 2, 3, 0, 2
+        for (int i = 0; i < 3; i++) {
+            int idxs[] = { 2, 3, 0, 2 };
+            int idxa = idxs[i];
+            int idxb = idxs[i+1];
+            //length[i] = sqrt(
+            //                  sq(quad->p[idxb][0] - quad->p[idxa][0])
+            //                + sq(quad->p[idxb][1] - quad->p[idxa][1]));
+            double sq1 = quad->p[idxb][0] - quad->p[idxa][0];
+            sq1 = sq1 * sq1;
+            double sq2 = quad->p[idxb][1] - quad->p[idxa][1];
+            sq2 = sq2 * sq2;
+            length[i] = sqrt(sq1 + sq2);
+        }
+        p = (length[0] + length[1] + length[2]) / 2;
+
+        area += sqrt(p*(p-length[0])*(p-length[1])*(p-length[2]));
+
+        // we don't actually know the family yet (quad detection is generic.)
+        // This threshold is based on a 6x6 tag (which is actually 8x8)
+        //        int d = fam->d + fam->black_border*2;
+        int d = 8;
+        if (area < d*d) {
+            res = 0;
+            goto finish;
+        }
+    }
+
+    // reject quads whose cumulative angle change isn't equal to 2PI
+    if(1){
+        double total = 0;
+
+        for (int i = 0; i < 4; i++) {
+            int i0 = i, i1 = (i+1)&3, i2 = (i+2)&3;
+
+            double theta0 = atan2f(quad->p[i0][1] - quad->p[i1][1],
+                    quad->p[i0][0] - quad->p[i1][0]);
+            double theta1 = atan2f(quad->p[i2][1] - quad->p[i1][1],
+                    quad->p[i2][0] - quad->p[i1][0]);
+
+            double dtheta = theta0 - theta1;
+            if (dtheta < 0)
+                dtheta += 2*CV_PI;
+
+            if (dtheta < _params.aprilTagCriticalRad || dtheta > (CV_PI - _params.aprilTagCriticalRad))
+                res = 0;
+
+            total += dtheta;
+        }
+
+        // looking for 2PI
+        if (total < 6.2 || total > 6.4) {
+            res = 0;
+            goto finish;
+        }
+    }
+
+    finish:
+
+    return res;
+}
+
+
+static void do_quad(int nCidx0, int nCidx1, zarray_t &nClusters, int nW, int nH, zarray_t *nquads, const DetectorParameters &td, const Mat im){
+
+    CV_Assert(nquads != NULL);
+
+    //struct quad_task *task = (struct quad_task*) p;
+
+    //zarray_t *clusters = nClusters;
+    zarray_t *quads = nquads;
+    int w = nW, h = nH;
+
+    for (int cidx = nCidx0; cidx < nCidx1; cidx++) {
+
+        zarray_t *cluster;
+        _zarray_get(&nClusters, cidx, &cluster);
+
+        if (_zarray_size(cluster) < td.aprilTagMinClusterPixels)
+            continue;
+
+        // a cluster should contain only boundary points around the
+        // tag. it cannot be bigger than the whole screen. (Reject
+        // large connected blobs that will be prohibitively slow to
+        // fit quads to.) A typical point along an edge is added three
+        // times (because it has 3 neighbors). The maximum perimeter
+        // is 2w+2h.
+        if (_zarray_size(cluster) > 3*(2*w+2*h)) {
+            continue;
+        }
+
+        struct sQuad quad;
+        memset(&quad, 0, sizeof(struct sQuad));
+
+        if (fit_quad(td, im, cluster, &quad)) {
+            //pthread_mutex_lock(&td.mutex);
+            _zarray_add(quads, &quad);
+            //pthread_mutex_unlock(&td.mutex);
+        }
+    }
+}
+
+void threshold(const Mat mIm, const DetectorParameters &parameters, Mat& mThresh){
+    int w = mIm.cols, h = mIm.rows;
+    int s = (unsigned) mIm.step;
+    CV_Assert(w < 32768);
+    CV_Assert(h < 32768);
+
+    CV_Assert(mThresh.step == (unsigned)s);
+
+    // The idea is to find the maximum and minimum values in a
+    // window around each pixel. If it's a contrast-free region
+    // (max-min is small), don't try to binarize. Otherwise,
+    // threshold according to (max+min)/2.
+    //
+    // Mark low-contrast regions with value 127 so that we can skip
+    // future work on these areas too.
+
+    // however, computing max/min around every pixel is needlessly
+    // expensive. We compute max/min for tiles. To avoid artifacts
+    // that arise when high-contrast features appear near a tile
+    // edge (and thus moving from one tile to another results in a
+    // large change in max/min value), the max/min values used for
+    // any pixel are computed from all 3x3 surrounding tiles. Thus,
+    // the max/min sampling area for nearby pixels overlap by at least
+    // one tile.
+    //
+    // The important thing is that the windows be large enough to
+    // capture edge transitions; the tag does not need to fit into
+    // a tile.
+
+    // XXX Tunable. Generally, small tile sizes--- so long as they're
+    // large enough to span a single tag edge--- seem to be a winner.
+    const int tilesz = 4;
+
+    // the last (possibly partial) tiles along each row and column will
+    // just use the min/max value from the last full tile.
+    int tw = w / tilesz;
+    int th = h / tilesz;
+
+    uint8_t *im_max = (uint8_t*)calloc(tw*th, sizeof(uint8_t));
+    uint8_t *im_min = (uint8_t*)calloc(tw*th, sizeof(uint8_t));
+
+
+    // first, collect min/max statistics for each tile
+    for (int ty = 0; ty < th; ty++) {
+        for (int tx = 0; tx < tw; tx++) {
+            uint8_t max = 0, min = 255;
+
+            for (int dy = 0; dy < tilesz; dy++) {
+
+                for (int dx = 0; dx < tilesz; dx++) {
+
+                    uint8_t v = mIm.data[(ty*tilesz+dy)*s + tx*tilesz + dx];
+                    if (v < min)
+                        min = v;
+                    if (v > max)
+                        max = v;
+                }
+            }
+            im_max[ty*tw+tx] = max;
+            im_min[ty*tw+tx] = min;
+        }
+    }
+
+    // second, apply 3x3 max/min convolution to "blur" these values
+    // over larger areas. This reduces artifacts due to abrupt changes
+    // in the threshold value.
+    uint8_t *im_max_tmp = (uint8_t*)calloc(tw*th, sizeof(uint8_t));
+    uint8_t *im_min_tmp = (uint8_t*)calloc(tw*th, sizeof(uint8_t));
+
+    for (int ty = 0; ty < th; ty++) {
+        for (int tx = 0; tx < tw; tx++) {
+            uint8_t max = 0, min = 255;
+
+            for (int dy = -1; dy <= 1; dy++) {
+                if (ty+dy < 0 || ty+dy >= th)
+                    continue;
+                for (int dx = -1; dx <= 1; dx++) {
+                    if (tx+dx < 0 || tx+dx >= tw)
+                        continue;
+
+                    uint8_t m = im_max[(ty+dy)*tw+tx+dx];
+                    if (m > max)
+                        max = m;
+                    m = im_min[(ty+dy)*tw+tx+dx];
+                    if (m < min)
+                        min = m;
+                }
+            }
+
+            im_max_tmp[ty*tw + tx] = max;
+            im_min_tmp[ty*tw + tx] = min;
+        }
+    }
+    free(im_max);
+    free(im_min);
+    im_max = im_max_tmp;
+    im_min = im_min_tmp;
+
+    for (int ty = 0; ty < th; ty++) {
+        for (int tx = 0; tx < tw; tx++) {
+
+            int min_ = im_min[ty*tw + tx];
+            int max_ = im_max[ty*tw + tx];
+
+            // low contrast region? (no edges)
+            if (max_ - min_ < parameters.aprilTagMinWhiteBlackDiff) {
+                for (int dy = 0; dy < tilesz; dy++) {
+                    int y = ty*tilesz + dy;
+
+                    for (int dx = 0; dx < tilesz; dx++) {
+                        int x = tx*tilesz + dx;
+
+                        //threshim->buf[y*s+x] = 127;
+                        mThresh.data[y*s+x] = 127;
+                    }
+                }
+                continue;
+            }
+
+            // otherwise, actually threshold this tile.
+
+            // argument for biasing towards dark; specular highlights
+            // can be substantially brighter than white tag parts
+            uint8_t thresh = saturate_cast<uint8_t>((max_ + min_) / 2);
+
+            for (int dy = 0; dy < tilesz; dy++) {
+                int y = ty*tilesz + dy;
+
+                for (int dx = 0; dx < tilesz; dx++) {
+                    int x = tx*tilesz + dx;
+
+                    uint8_t v = mIm.data[y*s+x];
+                    mThresh.data[y*s+x] = (v > thresh) ? 255 : 0;
+                }
+            }
+        }
+    }
+
+    // we skipped over the non-full-sized tiles above. Fix those now.
+    for (int y = 0; y < h; y++) {
+
+        // what is the first x coordinate we need to process in this row?
+
+        int x0;
+
+        if (y >= th*tilesz) {
+            x0 = 0; // we're at the bottom; do the whole row.
+        } else {
+            x0 = tw*tilesz; // we only need to do the right most part.
+        }
+
+        // compute tile coordinates and clamp.
+        int ty = y / tilesz;
+        if (ty >= th)
+            ty = th - 1;
+
+        for (int x = x0; x < w; x++) {
+            int tx = x / tilesz;
+            if (tx >= tw)
+                tx = tw - 1;
+
+            int max = im_max[ty*tw + tx];
+            int min = im_min[ty*tw + tx];
+            int thresh = min + (max - min) / 2;
+
+            uint8_t v = mIm.data[y*s+x];
+            if (v > thresh){
+                mThresh.data[y*s+x] = 255;
+            }
+            else{
+                mThresh.data[y*s+x] = 0;
+            }
+        }
+    }
+    free(im_min);
+    free(im_max);
+
+    // this is a dilate/erode deglitching scheme that does not improve
+    // anything as far as I can tell.
+    if (parameters.aprilTagDeglitch) {
+        Mat tmp(h,w, mIm.type());
+        for (int y = 1; y + 1 < h; y++) {
+            for (int x = 1; x + 1 < w; x++) {
+                uint8_t max = 0;
+                for (int dy = -1; dy <= 1; dy++) {
+                    for (int dx = -1; dx <= 1; dx++) {
+                        uint8_t v = mThresh.data[(y+dy)*s + x + dx];
+                        if (v > max)
+                            max = v;
+                    }
+                }
+                tmp.data[y*s+x] = max;
+            }
+        }
+
+        for (int y = 1; y + 1 < h; y++) {
+            for (int x = 1; x + 1 < w; x++) {
+                uint8_t min = 255;
+                for (int dy = -1; dy <= 1; dy++) {
+                    for (int dx = -1; dx <= 1; dx++) {
+                        uint8_t v = tmp.data[(y+dy)*s + x + dx];
+                        if (v < min)
+                            min = v;
+                    }
+                }
+                mThresh.data[y*s+x] = min;
+            }
+        }
+    }
+
+}
+
+#ifdef APRIL_DEBUG
+static void _darken(const Mat &im){
+    for (int y = 0; y < im.rows; y++) {
+        for (int x = 0; x < im.cols; x++) {
+            im.data[im.cols*y+x] /= 2;
+        }
+    }
+}
+#endif
+
+zarray_t *apriltag_quad_thresh(const DetectorParameters &parameters, const Mat & mImg, std::vector<std::vector<Point> > &contours){
+
+    ////////////////////////////////////////////////////////
+    // step 1. threshold the image, creating the edge image.
+
+    int w = mImg.cols, h = mImg.rows;
+
+    Mat thold(h, w, mImg.type());
+    threshold(mImg, parameters, thold);
+
+    int ts = thold.cols;
+
+#ifdef APRIL_DEBUG
+    imwrite("2.2 debug_threshold.pnm", thold);
+#endif
+
+    ////////////////////////////////////////////////////////
+    // step 2. find connected components.
+
+    UnionFind uf(w * h);
+
+    // TODO PARALLELIZE
+    for (int y = 0; y < h - 1; y++) {
+        uf.do_line(thold, w, ts, y);
+    }
+
+    // XXX sizing??
+    int nclustermap = 2*w*h - 1;
+
+    struct uint64_zarray_entry **clustermap = (struct uint64_zarray_entry**)calloc(nclustermap, sizeof(struct uint64_zarray_entry*));
+
+    for (int y = 1; y < h-1; y++) {
+        for (int x = 1; x < w-1; x++) {
+
+            uint8_t v0 = thold.data[y*ts + x];
+            if (v0 == 127)
+                continue;
+
+            // XXX don't query this until we know we need it?
+            uint64_t rep0 = uf.get_representative(y*w + x);
+
+            // whenever we find two adjacent pixels such that one is
+            // white and the other black, we add the point half-way
+            // between them to a cluster associated with the unique
+            // ids of the white and black regions.
+            //
+            // We additionally compute the gradient direction (i.e., which
+            // direction was the white pixel?) Note: if (v1-v0) == 255, then
+            // (dx,dy) points towards the white pixel. if (v1-v0) == -255, then
+            // (dx,dy) points towards the black pixel. p.gx and p.gy will thus
+            // be -255, 0, or 255.
+            //
+            // Note that any given pixel might be added to multiple
+            // different clusters. But in the common case, a given
+            // pixel will be added multiple times to the same cluster,
+            // which increases the size of the cluster and thus the
+            // computational costs.
+            //
+            // A possible optimization would be to combine entries
+            // within the same cluster.
+
+#define DO_CONN(dx, dy)                                                 \
+        if (1) {                                                    \
+            uint8_t v1 = thold.data[y*ts + dy*ts + x + dx];         \
+            \
+            if (v0 + v1 == 255) {                                   \
+                uint64_t rep1 = uf.get_representative(y*w + dy*w + x + dx); \
+                uint64_t clusterid;                                 \
+                if (rep0 < rep1)                                    \
+                clusterid = (rep1 << 32) + rep0;                \
+                else                                                \
+                clusterid = (rep0 << 32) + rep1;                \
+                \
+                /* XXX lousy hash function */                       \
+        uint32_t clustermap_bucket = u64hash_2(clusterid) % nclustermap; \
+        struct uint64_zarray_entry *entry = clustermap[clustermap_bucket]; \
+        while (entry && entry->id != clusterid)     {       \
+            entry = entry->next;                            \
+        }                                                   \
+        \
+        if (!entry) {                                       \
+            entry = (struct uint64_zarray_entry*)calloc(1, sizeof(struct uint64_zarray_entry)); \
+            entry->id = clusterid;                          \
+            entry->cluster = _zarray_create(sizeof(struct pt)); \
+            entry->next = clustermap[clustermap_bucket];    \
+            clustermap[clustermap_bucket] = entry;          \
+        }                                                   \
+        \
+        struct pt p;                                        \
+        p.x = saturate_cast<uint16_t>(2*x + dx);            \
+        p.y = saturate_cast<uint16_t>(2*y + dy);            \
+        p.gx = saturate_cast<uint16_t>(dx*((int) v1-v0));   \
+        p.gy = saturate_cast<uint16_t>(dy*((int) v1-v0));   \
+        _zarray_add(entry->cluster, &p);                    \
+        }                                                   \
+    }
+
+    // do 4 connectivity. NB: Arguments must be [-1, 1] or we'll overflow .gx, .gy
+    DO_CONN(1, 0);
+    DO_CONN(0, 1);
+
+    // do 8 connectivity
+    DO_CONN(-1, 1);
+    DO_CONN(1, 1);
+}
+}
+#undef DO_CONN
+
+#ifdef APRIL_DEBUG
+Mat out = Mat::zeros(h, w, CV_8UC3);
+
+uint32_t *colors = (uint32_t*) calloc(w*h, sizeof(*colors));
+
+for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+        uint32_t v = uf.get_representative(y*w+x);
+
+        if (uf.get_set_size(v) < parameters->aprilTagMinClusterPixels)
+            continue;
+
+        uint32_t color = colors[v];
+        uint8_t r = color >> 16,
+                g = color >> 8,
+                b = color;
+
+        if (color == 0) {
+            const int bias = 50;
+            r = bias + (random() % (200-bias));
+            g = bias + (random() % (200-bias));
+            b = bias + (random() % (200-bias));
+            colors[v] = (r << 16) | (g << 8) | b;
+        }
+        out.at<Vec3b>(y, x)[0]=b;
+        out.at<Vec3b>(y, x)[1]=g;
+        out.at<Vec3b>(y, x)[2]=r;
+    }
+}
+free(colors);
+imwrite("2.3 debug_segmentation.pnm", out);
+out = Mat::zeros(h, w, CV_8UC3);
+#endif
+
+    ////////////////////////////////////////////////////////
+    // step 3. process each connected component.
+    zarray_t *clusters = _zarray_create(sizeof(zarray_t*)); //, uint64_zarray_hash_size(clustermap));
+    CV_Assert(clusters != NULL);
+
+    for (int i = 0; i < nclustermap; i++) {
+        for (struct uint64_zarray_entry *entry = clustermap[i]; entry; entry = entry->next) {
+            // XXX reject clusters here?
+            _zarray_add(clusters, &entry->cluster);
+        }
+    }
+
+#ifdef APRIL_DEBUG
+for (int i = 0; i < _zarray_size(clusters); i++) {
+    zarray_t *cluster;
+    _zarray_get(clusters, i, &cluster);
+
+    uint32_t r, g, b;
+
+    const int bias = 50;
+    r = bias + (random() % (200-bias));
+    g = bias + (random() % (200-bias));
+    b = bias + (random() % (200-bias));
+
+    for (int j = 0; j < _zarray_size(cluster); j++) {
+        struct pt *p;
+        _zarray_get_volatile(cluster, j, &p);
+
+        int x = p->x / 2;
+        int y = p->y / 2;
+        out.at<Vec3b>(y, x)[0]=b;
+        out.at<Vec3b>(y, x)[1]=g;
+        out.at<Vec3b>(y, x)[2]=r;
+    }
+}
+
+imwrite("2.4 debug_clusters.pnm", out);
+out = Mat::zeros(h, w, CV_8UC3);
+#endif
+
+    for (int i = 0; i < _zarray_size(clusters); i++) {
+        zarray_t *cluster;
+        _zarray_get(clusters, i, &cluster);
+
+        std::vector<Point> cnt;
+        for (int j = 0; j < _zarray_size(cluster); j++) {
+            struct pt *p;
+            _zarray_get_volatile(cluster, j, &p);
+
+            Point pnt(p->x, p->y);
+            cnt.push_back(pnt);
+        }
+        contours.push_back(cnt);
+    }
+
+    for (int i = 0; i < nclustermap; i++) {
+        struct uint64_zarray_entry *entry = clustermap[i];
+        while (entry) {
+            struct uint64_zarray_entry *tmp = entry->next;
+            free(entry);
+            entry = tmp;
+        }
+    }
+    free(clustermap);
+
+    zarray_t *quads = _zarray_create(sizeof(struct sQuad));
+
+    //int chunksize = 1 + sz / (APRILTAG_TASKS_PER_THREAD_TARGET * numberOfThreads);
+    int chunksize = std::max(1, h / (10 * getNumThreads()));
+    int sz = _zarray_size(clusters);
+
+    // TODO PARALLELIZE
+    for (int i = 0; i < sz; i += chunksize) {
+        int min = sz < (i+chunksize)? sz: (i+chunksize);
+        do_quad(i, min, *clusters, w, h, quads, parameters, mImg);
+    }
+
+#ifdef APRIL_DEBUG
+mImg.copyTo(out);
+_darken(out);
+_darken(out);
+srandom(0);
+
+for (int i = 0; i < _zarray_size(quads); i++) {
+    struct sQuad *quad;
+    _zarray_get_volatile(quads, i, &quad);
+
+    float rgb[3];
+    int bias = 100;
+
+    for (int i = 0; i < 3; i++)
+        rgb[i] = bias + (random() % (255-bias));
+
+    line(out, Point(quad->p[0][0], quad->p[0][1]), Point(quad->p[1][0], quad->p[1][1]), rgb[i]);
+    line(out, Point(quad->p[1][0], quad->p[1][1]), Point(quad->p[2][0], quad->p[2][1]), rgb[i]);
+    line(out, Point(quad->p[2][0], quad->p[2][1]), Point(quad->p[3][0], quad->p[3][1]), rgb[i]);
+    line(out, Point(quad->p[3][0], quad->p[3][1]), Point(quad->p[0][0], quad->p[0][1]), rgb[i]);
+}
+imwrite("2.5 debug_lines.pnm", out);
+#endif
+
+    for (int i = 0; i < _zarray_size(clusters); i++) {
+        zarray_t *cluster;
+        _zarray_get(clusters, i, &cluster);
+        _zarray_destroy(cluster);
+    }
+    _zarray_destroy(clusters);
+    return quads;
+}
+
+void _apriltag(Mat im_orig, const DetectorParameters & _params, std::vector<std::vector<Point2f> > &candidates,
+               std::vector<std::vector<Point> > &contours){
+
+    ///////////////////////////////////////////////////////////
+    /// Step 1. Detect quads according to requested image decimation
+    /// and blurring parameters.
+    Mat quad_im;
+
+    if (_params.aprilTagQuadDecimate > 1){
+        resize(im_orig, quad_im, Size(), 1/_params.aprilTagQuadDecimate, 1/_params.aprilTagQuadDecimate, INTER_AREA);
+    }
+    else {
+        im_orig.copyTo(quad_im);
+    }
+
+    // Apply a Blur
+    if (_params.aprilTagQuadSigma != 0) {
+        // compute a reasonable kernel width by figuring that the
+        // kernel should go out 2 std devs.
+        //
+        // max sigma          ksz
+        // 0.499              1  (disabled)
+        // 0.999              3
+        // 1.499              5
+        // 1.999              7
+
+        float sigma = fabsf((float) _params.aprilTagQuadSigma);
+
+        int ksz = cvFloor(4 * sigma); // 2 std devs in each direction
+        ksz |= 1; // make odd number
+
+        if (ksz > 1) {
+            if (_params.aprilTagQuadSigma > 0)
+                GaussianBlur(quad_im, quad_im, Size(ksz, ksz), sigma, sigma, BORDER_REPLICATE);
+            else {
+                Mat orig;
+                quad_im.copyTo(orig);
+                GaussianBlur(quad_im, quad_im, Size(ksz, ksz), sigma, sigma, BORDER_REPLICATE);
+
+                // SHARPEN the image by subtracting the low frequency components.
+                for (int y = 0; y < orig.rows; y++) {
+                    for (int x = 0; x < orig.cols; x++) {
+                        int vorig = orig.data[y*orig.step + x];
+                        int vblur = quad_im.data[y*quad_im.step + x];
+
+                        int v = 2*vorig - vblur;
+                        if (v < 0)
+                            v = 0;
+                        if (v > 255)
+                            v = 255;
+
+                        quad_im.data[y*quad_im.step + x] = (uint8_t) v;
+                    }
+                }
+            }
+        }
+    }
+
+#ifdef APRIL_DEBUG
+    imwrite("1.1 debug_preprocess.pnm", quad_im);
+#endif
+
+    ///////////////////////////////////////////////////////////
+    /// Step 2. do the Threshold :: get the set of candidate quads
+    zarray_t *quads = apriltag_quad_thresh(_params, quad_im, contours);
+
+    CV_Assert(quads != NULL);
+
+    // adjust centers of pixels so that they correspond to the
+    // original full-resolution image.
+    if (_params.aprilTagQuadDecimate > 1) {
+        for (int i = 0; i < _zarray_size(quads); i++) {
+            struct sQuad *q;
+            _zarray_get_volatile(quads, i, &q);
+            for (int j = 0; j < 4; j++) {
+                q->p[j][0] *= _params.aprilTagQuadDecimate;
+                q->p[j][1] *= _params.aprilTagQuadDecimate;
+            }
+        }
+    }
+
+#ifdef APRIL_DEBUG
+    Mat im_quads = im_orig.clone();
+    im_quads = im_quads*0.5;
+    srandom(0);
+
+    for (int i = 0; i < _zarray_size(quads); i++) {
+        struct sQuad *quad;
+        _zarray_get_volatile(quads, i, &quad);
+
+        const int bias = 100;
+        int color = bias + (random() % (255-bias));
+
+        line(im_quads, Point(quad->p[0][0], quad->p[0][1]), Point(quad->p[1][0], quad->p[1][1]), color, 1);
+        line(im_quads, Point(quad->p[1][0], quad->p[1][1]), Point(quad->p[2][0], quad->p[2][1]), color, 1);
+        line(im_quads, Point(quad->p[2][0], quad->p[2][1]), Point(quad->p[3][0], quad->p[3][1]), color, 1);
+        line(im_quads, Point(quad->p[3][0], quad->p[3][1]), Point(quad->p[0][0], quad->p[0][1]), color, 1);
+    }
+    imwrite("1.2 debug_quads_raw.pnm", im_quads);
+#endif
+
+    ////////////////////////////////////////////////////////////////
+    /// Step 3. Save the output :: candidate corners
+    for (int i = 0; i < _zarray_size(quads); i++) {
+        struct sQuad *quad;
+        _zarray_get_volatile(quads, i, &quad);
+
+        std::vector<Point2f> corners;
+        corners.push_back(Point2f(quad->p[3][0], quad->p[3][1]));   //pA
+        corners.push_back(Point2f(quad->p[0][0], quad->p[0][1]));   //pB
+        corners.push_back(Point2f(quad->p[1][0], quad->p[1][1]));   //pC
+        corners.push_back(Point2f(quad->p[2][0], quad->p[2][1]));   //pD
+
+        candidates.push_back(corners);
+    }
+
+    _zarray_destroy(quads);
+}
+
+}}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.hpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.hpp
new file mode 100644
index 0000000..aede1bb
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/apriltag_quad_thresh.hpp
@@ -0,0 +1,116 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+// limitation: image size must be <32768 in width and height. This is
+// because we use a fixed-point 16 bit integer representation with one
+// fractional bit.
+
+#ifndef _OPENCV_APRIL_QUAD_THRESH_HPP_
+#define _OPENCV_APRIL_QUAD_THRESH_HPP_
+
+#include "zmaxheap.hpp"
+#include "zarray.hpp"
+
+namespace cv {
+namespace aruco {
+
+static inline uint32_t u64hash_2(uint64_t x) {
+    return uint32_t((2654435761UL * x) >> 32);
+}
+
+struct uint64_zarray_entry{
+    uint64_t id;
+    zarray_t *cluster;
+
+    struct uint64_zarray_entry *next;
+};
+
+struct pt{
+    // Note: these represent 2*actual value.
+    uint16_t x, y;
+    float theta;
+    int16_t gx, gy;
+};
+
+struct remove_vertex{
+    int i;           // which vertex to remove?
+    int left, right; // left vertex, right vertex
+
+    double err;
+};
+
+struct segment{
+    int is_vertex;
+
+    // always greater than zero, but right can be > size, which denotes
+    // a wrap around back to the beginning of the points. and left < right.
+    int left, right;
+};
+
+struct line_fit_pt{
+    double Mx, My;
+    double Mxx, Myy, Mxy;
+    double W; // total weight
+};
+
+/**
+ * lfps contains *cumulative* moments for N points, with
+ * index j reflecting points [0,j] (inclusive).
+ * fit a line to the points [i0, i1] (inclusive). i0, i1 are both (0, sz)
+ * if i1 < i0, we treat this as a wrap around.
+ */
+void fit_line(struct line_fit_pt *lfps, int sz, int i0, int i1, double *lineparm, double *err, double *mse);
+
+int err_compare_descending(const void *_a, const void *_b);
+
+/**
+  1. Identify A) white points near a black point and B) black points near a white point.
+
+  2. Find the connected components within each of the classes above,
+  yielding clusters of "white-near-black" and
+  "black-near-white". (These two classes are kept separate). Each
+  segment has a unique id.
+
+  3. For every pair of "white-near-black" and "black-near-white"
+  clusters, find the set of points that are in one and adjacent to the
+  other. In other words, a "boundary" layer between the two
+  clusters. (This is actually performed by iterating over the pixels,
+  rather than pairs of clusters.) Critically, this helps keep nearby
+  edges from becoming connected.
+ **/
+int quad_segment_maxima(const DetectorParameters &td, int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ * returns 0 if the cluster looks bad.
+ */
+int quad_segment_agg(int sz, struct line_fit_pt *lfps, int indices[4]);
+
+/**
+ *  return 1 if the quad looks okay, 0 if it should be discarded
+ *  quad
+ **/
+int fit_quad(const DetectorParameters &_params, const Mat im, zarray_t *cluster, struct sQuad *quad);
+
+
+void threshold(const Mat mIm, const DetectorParameters &parameters, Mat& mThresh);
+
+
+zarray_t *apriltag_quad_thresh(const DetectorParameters &parameters, const Mat & mImg,
+                               std::vector<std::vector<Point> > &contours);
+
+void _apriltag(Mat im_orig, const DetectorParameters &_params, std::vector<std::vector<Point2f> > &candidates,
+               std::vector<std::vector<Point> > &contours);
+
+}}
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/predefined_dictionaries_apriltag.hpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/predefined_dictionaries_apriltag.hpp
new file mode 100644
index 0000000..cad9802
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/predefined_dictionaries_apriltag.hpp
@@ -0,0 +1,14900 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+namespace {
+
+/**
+  * Dictionaries are stored as a list of bytes in its four rotations.
+  * On each rotation, the marker is divided in bytes assuming a row-major order.
+  * This format allows a faster marker identification.
+  * For a dictionary composed by M markers of NxN bits, the structure dimensions should be:
+  * const char name[nMarkers][4rotations][nBytes], or more specifically:
+  * const char name[M][4][ceil(NxN/8)]
+  * The element [i][j][k] represents the k-th byte of the i-th marker in the dictionary
+  * in its j-th rotation.
+  * Each rotation implies a 90 degree rotation of the marker in anticlockwise direction.
+  */
+static unsigned char DICT_APRILTAG_16h5_BYTES[][4][2] =
+{
+    { {216, 196},
+      {128, 190},
+      {35, 27},
+      {125, 1}
+    },
+    { {165, 116},
+      {106, 120},
+      {46, 165},
+      {30, 86}
+    },
+    { {86, 44},
+      {134, 209},
+      {52, 106},
+      {139, 97}
+    },
+    { {157, 162},
+      {195, 78},
+      {69, 185},
+      {114, 195}
+    },
+    { {101, 158},
+      {105, 211},
+      {121, 166},
+      {203, 150}
+    },
+    { {214, 254},
+      {167, 251},
+      {127, 107},
+      {223, 229}
+    },
+    { {26, 205},
+      {148, 55},
+      {179, 88},
+      {236, 41}
+    },
+    { {162, 231},
+      {31, 58},
+      {231, 69},
+      {92, 248}
+    },
+    { {154, 127},
+      {183, 61},
+      {254, 89},
+      {188, 237}
+    },
+    { {182, 168},
+      {142, 75},
+      {21, 109},
+      {210, 113}
+    },
+    { {208, 28},
+      {160, 153},
+      {56, 11},
+      {153, 5}
+    },
+    { {213, 15},
+      {209, 217},
+      {240, 171},
+      {155, 139}
+    },
+    { {33, 176},
+      {106, 2},
+      {13, 132},
+      {64, 86}
+    },
+    { {108, 226},
+      {11, 230},
+      {71, 54},
+      {103, 208}
+    },
+    { {78, 49},
+      {54, 196},
+      {140, 114},
+      {35, 108}
+    },
+    { {8, 245},
+      {50, 54},
+      {175, 16},
+      {108, 76}
+    },
+    { {60, 144},
+      {168, 70},
+      {9, 60},
+      {98, 21}
+    },
+    { {45, 201},
+      {88, 103},
+      {147, 180},
+      {230, 26}
+    },
+    { {192, 165},
+      {18, 154},
+      {165, 3},
+      {89, 72}
+    },
+    { {241, 98},
+      {203, 168},
+      {70, 143},
+      {21, 211}
+    },
+    { {236, 135},
+      {25, 222},
+      {225, 55},
+      {123, 152}
+    },
+    { {169, 234},
+      {75, 47},
+      {87, 149},
+      {244, 210}
+    },
+    { {66, 251},
+      {55, 163},
+      {223, 66},
+      {197, 236}
+    },
+    { {184, 56},
+      {170, 13},
+      {28, 29},
+      {176, 85}
+    },
+    { {59, 151},
+      {253, 22},
+      {233, 220},
+      {104, 191}
+    },
+    { {181, 206},
+      {201, 123},
+      {115, 173},
+      {222, 147}
+    },
+    { {250, 181},
+      {190, 158},
+      {173, 95},
+      {121, 125}
+    },
+    { {12, 171},
+      {19, 71},
+      {213, 48},
+      {226, 200}
+    },
+    { {83, 224},
+      {198, 162},
+      {7, 202},
+      {69, 99}
+    },
+    { {116, 245},
+      {186, 242},
+      {175, 46},
+      {79, 93}
+    }
+};
+
+
+
+static unsigned char DICT_APRILTAG_25h9_BYTES[][4][4] =
+{
+    { {143, 211, 170, 1},
+      {234, 146, 237, 1},
+      {170, 229, 248, 1},
+      {219, 164, 171, 1}
+    },
+    { {109, 139, 39, 1},
+      {170, 251, 21, 0},
+      {242, 104, 219, 0},
+      {84, 111, 170, 1}
+    },
+    { {22, 208, 222, 1},
+      {94, 6, 244, 1},
+      {189, 133, 180, 0},
+      {151, 176, 61, 0}
+    },
+    { {179, 147, 87, 1},
+      {62, 118, 217, 0},
+      {245, 100, 230, 1},
+      {77, 183, 62, 0}
+    },
+    { {115, 40, 116, 1},
+      {28, 189, 146, 0},
+      {151, 10, 103, 0},
+      {36, 222, 156, 0}
+    },
+    { {221, 18, 172, 0},
+      {164, 145, 124, 1},
+      {26, 164, 93, 1},
+      {159, 68, 146, 1}
+    },
+    { {103, 234, 238, 0},
+      {98, 191, 182, 1},
+      {59, 171, 243, 0},
+      {182, 254, 163, 0}
+    },
+    { {213, 186, 96, 1},
+      {46, 157, 78, 0},
+      {131, 46, 213, 1},
+      {57, 92, 186, 0}
+    },
+    { {231, 69, 93, 1},
+      {89, 117, 157, 1},
+      {221, 81, 115, 1},
+      {220, 215, 77, 0}
+    },
+    { {17, 101, 123, 0},
+      {85, 214, 3, 1},
+      {111, 83, 68, 0},
+      {224, 53, 213, 0}
+    },
+    { {228, 155, 129, 0},
+      {34, 105, 109, 0},
+      {64, 236, 147, 1},
+      {91, 75, 34, 0}
+    },
+    { {130, 77, 138, 0},
+      {65, 10, 169, 1},
+      {40, 217, 32, 1},
+      {202, 168, 65, 0}
+    },
+    { {117, 19, 219, 0},
+      {52, 119, 101, 1},
+      {109, 228, 87, 0},
+      {211, 119, 22, 0}
+    },
+    { {152, 112, 167, 1},
+      {204, 194, 122, 0},
+      {242, 135, 12, 1},
+      {47, 33, 153, 1}
+    },
+    { {75, 152, 26, 1},
+      {154, 27, 192, 1},
+      {172, 12, 233, 0},
+      {129, 236, 44, 1}
+    },
+    { {65, 65, 182, 1},
+      {88, 147, 49, 0},
+      {182, 193, 65, 0},
+      {70, 100, 141, 0}
+    },
+    { {172, 7, 198, 1},
+      {169, 38, 61, 0},
+      {177, 240, 26, 1},
+      {94, 50, 74, 1}
+    },
+    { {129, 217, 185, 0},
+      {82, 216, 105, 1},
+      {78, 205, 192, 1},
+      {203, 13, 165, 0}
+    },
+    { {35, 119, 206, 1},
+      {105, 54, 243, 1},
+      {185, 247, 98, 0},
+      {231, 182, 75, 0}
+    },
+    { {144, 92, 117, 0},
+      {85, 204, 88, 0},
+      {87, 29, 4, 1},
+      {13, 25, 213, 0}
+    },
+    { {138, 62, 250, 0},
+      {177, 142, 234, 1},
+      {47, 190, 40, 1},
+      {171, 184, 198, 1}
+    },
+    { {63, 236, 133, 1},
+      {207, 120, 182, 0},
+      {208, 155, 254, 0},
+      {54, 143, 121, 1}
+    },
+    { {70, 169, 59, 0},
+      {18, 203, 135, 1},
+      {110, 74, 177, 0},
+      {240, 233, 164, 0}
+    },
+    { {162, 116, 1, 1},
+      {73, 96, 202, 0},
+      {192, 23, 34, 1},
+      {41, 131, 73, 0}
+    },
+    { {52, 42, 195, 1},
+      {44, 110, 38, 0},
+      {225, 170, 22, 0},
+      {50, 59, 26, 0}
+    },
+    { {37, 240, 225, 0},
+      {66, 244, 102, 0},
+      {67, 135, 210, 0},
+      {51, 23, 161, 0}
+    },
+    { {144, 226, 137, 0},
+      {102, 64, 42, 1},
+      {72, 163, 132, 1},
+      {170, 1, 51, 0}
+    },
+    { {15, 33, 102, 1},
+      {136, 150, 151, 0},
+      {179, 66, 120, 0},
+      {116, 180, 136, 1}
+    },
+    { {165, 79, 19, 0},
+      {113, 122, 13, 0},
+      {100, 121, 82, 1},
+      {88, 47, 71, 0}
+    },
+    { {221, 124, 193, 0},
+      {197, 93, 110, 0},
+      {65, 159, 93, 1},
+      {59, 93, 81, 1}
+    },
+    { {254, 142, 154, 0},
+      {183, 43, 172, 1},
+      {44, 184, 191, 1},
+      {154, 234, 118, 1}
+    },
+    { {10, 11, 60, 1},
+      {184, 136, 145, 1},
+      {158, 104, 40, 0},
+      {196, 136, 142, 1}
+    },
+    { {139, 80, 95, 0},
+      {208, 86, 216, 1},
+      {125, 5, 104, 1},
+      {141, 181, 5, 1}
+    },
+    { {13, 198, 237, 1},
+      {235, 212, 52, 1},
+      {219, 177, 216, 0},
+      {150, 21, 235, 1}
+    },
+    { {115, 137, 157, 0},
+      {22, 121, 177, 1},
+      {92, 200, 231, 0},
+      {198, 207, 52, 0}
+    }
+};
+
+
+
+static unsigned char DICT_APRILTAG_36h10_BYTES[][4][5] =
+{
+    { {225, 101, 73, 83, 8},
+      {49, 6, 165, 238, 1},
+      {28, 169, 42, 104, 7},
+      {135, 122, 86, 8, 12}
+    },
+    { {50, 53, 132, 160, 4},
+      {65, 139, 98, 33, 2},
+      {32, 82, 26, 196, 12},
+      {72, 68, 109, 24, 2}
+    },
+    { {107, 237, 252, 94, 4},
+      {43, 167, 244, 249, 13},
+      {39, 163, 251, 125, 6},
+      {185, 242, 254, 93, 4}
+    },
+    { {217, 189, 115, 45, 4},
+      {123, 106, 82, 246, 12},
+      {43, 76, 235, 217, 11},
+      {54, 244, 165, 109, 14}
+    },
+    { {87, 115, 222, 38, 12},
+      {233, 207, 79, 209, 1},
+      {54, 71, 188, 238, 10},
+      {136, 191, 47, 57, 7}
+    },
+    { {245, 43, 80, 249, 12},
+      {161, 42, 235, 222, 10},
+      {57, 240, 173, 74, 15},
+      {87, 189, 117, 72, 5}
+    },
+    { {46, 91, 153, 155, 12},
+      {210, 166, 237, 21, 11},
+      {61, 153, 157, 167, 4},
+      {218, 139, 118, 84, 11}
+    },
+    { {127, 167, 237, 114, 2},
+      {179, 155, 190, 233, 5},
+      {68, 235, 126, 95, 14},
+      {169, 119, 221, 156, 13}
+    },
+    { {72, 191, 207, 28, 10},
+      {123, 243, 157, 160, 8},
+      {83, 143, 63, 209, 2},
+      {16, 91, 156, 253, 14}
+    },
+    { {235, 64, 193, 206, 10},
+      {58, 180, 33, 203, 3},
+      {87, 56, 48, 45, 7},
+      {205, 56, 66, 213, 12}
+    },
+    { {215, 152, 253, 186, 6},
+      {240, 185, 214, 211, 15},
+      {101, 219, 241, 158, 11},
+      {252, 182, 185, 208, 15}
+    },
+    { {92, 212, 54, 176, 14},
+      {194, 93, 211, 176, 6},
+      {112, 214, 194, 179, 10},
+      {96, 220, 187, 164, 3}
+    },
+    { {114, 66, 21, 239, 14},
+      {24, 61, 107, 157, 3},
+      {127, 122, 132, 36, 14},
+      {203, 157, 107, 193, 8}
+    },
+    { {200, 18, 236, 76, 1},
+      {110, 161, 12, 138, 4},
+      {131, 35, 116, 129, 3},
+      {37, 19, 8, 87, 6}
+    },
+    { {27, 178, 99, 54, 1},
+      {127, 72, 154, 65, 5},
+      {134, 204, 100, 221, 8},
+      {168, 37, 145, 47, 14}
+    },
+    { {185, 202, 170, 229, 1},
+      {14, 204, 62, 78, 14},
+      {138, 117, 85, 57, 13},
+      {119, 39, 195, 55, 0}
+    },
+    { {55, 38, 64, 234, 9},
+      {165, 40, 43, 105, 3},
+      {149, 112, 38, 78, 12},
+      {201, 109, 65, 74, 5}
+    },
+    { {141, 86, 137, 137, 9},
+      {214, 164, 13, 102, 2},
+      {153, 25, 22, 171, 1},
+      {70, 107, 2, 86, 11}
+    },
+    { {220, 110, 245, 96, 5},
+      {183, 141, 74, 186, 12},
+      {160, 106, 247, 99, 11},
+      {53, 213, 43, 30, 13}
+    },
+    { {81, 225, 58, 109, 5},
+      {13, 110, 86, 220, 4},
+      {171, 101, 200, 120, 10},
+      {35, 182, 167, 107, 0}
+    },
+    { {40, 201, 94, 212, 13},
+      {46, 71, 245, 24, 10},
+      {178, 183, 169, 49, 4},
+      {81, 138, 254, 39, 4}
+    },
+    { {155, 25, 144, 102, 13},
+      {78, 138, 67, 91, 9},
+      {182, 96, 153, 141, 9},
+      {157, 172, 37, 23, 2}
+    },
+    { {198, 37, 228, 219, 13},
+      {165, 163, 193, 175, 7},
+      {189, 178, 122, 70, 3},
+      {239, 88, 60, 90, 5}
+    },
+    { {238, 221, 198, 163, 3},
+      {230, 215, 50, 167, 11},
+      {204, 86, 59, 183, 7},
+      {222, 84, 206, 182, 7}
+    },
+    { {168, 123, 189, 36, 7},
+      {95, 151, 110, 18, 12},
+      {226, 75, 221, 225, 5},
+      {52, 135, 110, 159, 10}
+    },
+    { {38, 247, 86, 43, 7},
+      {229, 119, 122, 53, 1},
+      {237, 70, 174, 246, 4},
+      {138, 197, 238, 234, 7}
+    },
+    { {119, 95, 17, 146, 15},
+      {212, 30, 233, 241, 11},
+      {244, 152, 143, 174, 14},
+      {216, 249, 119, 130, 11}
+    },
+    { {227, 232, 42, 118, 0},
+      {9, 68, 182, 203, 13},
+      {6, 229, 65, 124, 7},
+      {189, 54, 210, 41, 0}
+    },
+    { {219, 116, 9, 26, 8},
+      {83, 44, 133, 227, 1},
+      {21, 137, 2, 237, 11},
+      {140, 122, 19, 76, 10}
+    },
+    { {166, 92, 117, 179, 8},
+      {240, 5, 163, 55, 15},
+      {28, 218, 227, 166, 5},
+      {254, 204, 90, 0, 15}
+    },
+    { {247, 162, 51, 66, 4},
+      {145, 72, 120, 219, 5},
+      {36, 44, 196, 94, 15},
+      {173, 177, 225, 40, 9}
+    },
+    { {45, 210, 218, 190, 4},
+      {234, 228, 254, 80, 3},
+      {39, 213, 180, 187, 4},
+      {192, 167, 242, 117, 7}
+    },
+    { {158, 138, 87, 237, 4},
+      {186, 105, 90, 31, 10},
+      {43, 126, 165, 23, 9},
+      {95, 133, 169, 101, 13}
+    },
+    { {192, 186, 16, 180, 12},
+      {73, 0, 219, 146, 10},
+      {50, 208, 133, 208, 3},
+      {84, 157, 176, 9, 2}
+    },
+    { {19, 70, 233, 230, 12},
+      {56, 140, 79, 105, 7},
+      {54, 121, 118, 44, 8},
+      {233, 111, 35, 17, 12}
+    },
+    { {177, 22, 100, 69, 12},
+      {104, 9, 105, 110, 4},
+      {58, 34, 102, 136, 13},
+      {39, 105, 105, 1, 6}
+    },
+    { {74, 118, 173, 59, 12},
+      {83, 165, 207, 165, 5},
+      {61, 203, 86, 229, 2},
+      {170, 95, 58, 92, 10}
+    },
+    { {133, 254, 70, 49, 2},
+      {225, 85, 154, 102, 8},
+      {72, 198, 39, 250, 1},
+      {22, 101, 154, 168, 7}
+    },
+    { {173, 105, 121, 110, 10},
+      {187, 54, 39, 90, 13},
+      {87, 105, 233, 107, 5},
+      {181, 174, 70, 205, 13}
+    },
+    { {32, 21, 210, 100, 6},
+      {104, 210, 98, 56, 0},
+      {98, 100, 186, 128, 4},
+      {1, 196, 100, 177, 6}
+    },
+    { {147, 181, 91, 6, 6},
+      {121, 90, 84, 115, 1},
+      {102, 13, 170, 220, 9},
+      {140, 226, 165, 169, 14}
+    },
+    { {202, 157, 31, 171, 6},
+      {82, 115, 86, 183, 11},
+      {109, 95, 139, 149, 3},
+      {222, 214, 172, 228, 10}
+    },
+    { {187, 35, 104, 210, 14},
+      {35, 26, 237, 75, 7},
+      {116, 177, 108, 77, 13},
+      {237, 43, 117, 140, 4}
+    },
+    { {52, 107, 195, 95, 14},
+      {185, 254, 233, 12, 9},
+      {127, 172, 61, 98, 12},
+      {147, 9, 119, 249, 13}
+    },
+    { {160, 207, 113, 248, 9},
+      {52, 38, 187, 58, 14},
+      {145, 248, 239, 48, 5},
+      {117, 205, 214, 66, 12}
+    },
+    { {83, 31, 184, 90, 9},
+      {68, 170, 141, 249, 13},
+      {149, 161, 223, 140, 10},
+      {185, 251, 21, 82, 2}
+    },
+    { {241, 127, 53, 41, 9},
+      {85, 47, 43, 246, 12},
+      {153, 74, 207, 232, 15},
+      {54, 253, 79, 74, 10}
+    },
+    { {152, 80, 211, 144, 5},
+      {118, 204, 192, 18, 2},
+      {160, 156, 176, 161, 9},
+      {68, 128, 51, 54, 14}
+    },
+    { {123, 240, 90, 34, 5},
+      {103, 76, 118, 209, 1},
+      {164, 69, 160, 253, 14},
+      {136, 182, 227, 46, 6}
+    },
+    { {197, 168, 151, 126, 5},
+      {157, 225, 210, 218, 9},
+      {167, 238, 145, 90, 3},
+      {149, 180, 184, 123, 9}
+    },
+    { {22, 216, 30, 157, 5},
+      {204, 109, 212, 21, 10},
+      {171, 151, 129, 182, 8},
+      {90, 130, 187, 99, 3}
+    },
+    { {180, 132, 224, 47, 5},
+      {172, 168, 114, 38, 5},
+      {175, 64, 114, 18, 13},
+      {166, 68, 225, 83, 5}
+    },
+    { {237, 52, 164, 150, 13},
+      {207, 129, 225, 226, 7},
+      {182, 146, 82, 203, 7},
+      {228, 120, 120, 31, 3}
+    },
+    { {9, 146, 15, 177, 3},
+      {86, 81, 158, 68, 2},
+      {200, 223, 4, 153, 0},
+      {66, 39, 152, 166, 10}
+    },
+    { {251, 90, 185, 188, 11},
+      {94, 188, 175, 211, 14},
+      {211, 217, 213, 173, 15},
+      {124, 191, 83, 215, 10}
+    },
+    { {37, 6, 52, 30, 11},
+      {140, 49, 169, 112, 5},
+      {215, 130, 198, 10, 4},
+      {160, 233, 88, 195, 1}
+    },
+    { {224, 145, 168, 72, 15},
+      {68, 178, 117, 138, 4},
+      {241, 33, 88, 144, 7},
+      {37, 26, 228, 210, 2}
+    },
+    { {194, 115, 147, 11, 8},
+      {81, 230, 9, 151, 1},
+      {29, 12, 156, 228, 3},
+      {142, 153, 6, 120, 10}
+    },
+    { {16, 43, 26, 208, 4},
+      {1, 74, 204, 24, 10},
+      {32, 181, 141, 64, 8},
+      {81, 131, 53, 40, 0}
+    },
+    { {56, 215, 41, 175, 4},
+      {90, 46, 126, 36, 7},
+      {47, 89, 78, 177, 12},
+      {226, 71, 231, 69, 10}
+    },
+    { {214, 63, 130, 165, 12},
+      {201, 202, 75, 167, 10},
+      {58, 84, 31, 198, 11},
+      {94, 93, 37, 57, 3}
+    },
+    { {93, 176, 247, 42, 2},
+      {243, 249, 18, 208, 5},
+      {69, 78, 240, 219, 10},
+      {160, 180, 137, 252, 15}
+    },
+    { {115, 36, 212, 252, 10},
+      {41, 185, 163, 249, 2},
+      {83, 242, 178, 76, 14},
+      {73, 252, 89, 217, 4}
+    },
+    { {71, 220, 230, 148, 6},
+      {232, 213, 208, 225, 14},
+      {98, 150, 115, 190, 2},
+      {120, 112, 186, 177, 7}
+    },
+    { {221, 26, 76, 114, 14},
+      {226, 25, 207, 202, 9},
+      {116, 227, 37, 139, 11},
+      {149, 63, 57, 132, 7}
+    },
+    { {154, 222, 49, 181, 1},
+      {94, 12, 154, 55, 14},
+      {138, 216, 199, 181, 9},
+      {126, 197, 147, 7, 10}
+    },
+    { {76, 25, 234, 75, 9},
+      {230, 226, 5, 140, 13},
+      {157, 37, 121, 131, 2},
+      {179, 26, 4, 118, 7}
+    },
+    { {129, 149, 32, 65, 5},
+      {68, 2, 80, 110, 4},
+      {168, 32, 74, 152, 1},
+      {39, 96, 164, 2, 2}
+    },
+    { {208, 173, 68, 239, 5},
+      {45, 43, 82, 174, 11},
+      {175, 114, 43, 80, 11},
+      {215, 84, 173, 75, 4}
+    },
+    { {169, 3, 2, 54, 13},
+      {14, 66, 235, 66, 1},
+      {182, 196, 12, 9, 5},
+      {132, 45, 116, 39, 0}
+    },
+    { {90, 99, 243, 101, 13},
+      {63, 206, 75, 157, 4},
+      {186, 108, 252, 101, 10},
+      {43, 157, 39, 63, 12}
+    },
+    { {167, 56, 140, 168, 15},
+      {197, 177, 103, 67, 10},
+      {241, 83, 17, 206, 5},
+      {92, 46, 104, 218, 3}
+    },
+    { {193, 252, 209, 46, 0},
+      {121, 164, 18, 242, 9},
+      {7, 72, 179, 248, 3},
+      {148, 244, 130, 89, 14}
+    },
+    { {18, 162, 88, 245, 0},
+      {41, 8, 158, 29, 2},
+      {10, 241, 164, 84, 8},
+      {75, 135, 145, 9, 4}
+    },
+    { {176, 210, 149, 151, 0},
+      {88, 141, 184, 22, 3},
+      {14, 154, 148, 176, 13},
+      {198, 129, 219, 17, 10}
+    },
+    { {172, 158, 132, 125, 4},
+      {202, 161, 250, 46, 8},
+      {43, 226, 23, 147, 5},
+      {23, 69, 248, 85, 3}
+    },
+    { {112, 105, 55, 71, 12},
+      {25, 79, 97, 156, 13},
+      {62, 46, 201, 96, 14},
+      {179, 152, 111, 41, 8}
+    },
+    { {68, 181, 20, 179, 2},
+      {193, 19, 146, 180, 3},
+      {76, 210, 138, 210, 2},
+      {194, 212, 156, 136, 3}
+    },
+    { {231, 77, 237, 224, 10},
+      {176, 151, 39, 235, 14},
+      {80, 123, 123, 46, 7},
+      {125, 126, 78, 144, 13}
+    },
+    { {53, 29, 98, 66, 10},
+      {224, 90, 33, 104, 13},
+      {84, 36, 107, 138, 12},
+      {177, 104, 69, 160, 7}
+    },
+    { {142, 125, 171, 62, 10},
+      {219, 246, 135, 35, 13},
+      {87, 205, 91, 231, 1},
+      {188, 78, 22, 253, 11}
+    },
+    { {82, 219, 5, 133, 6},
+      {88, 31, 88, 133, 10},
+      {106, 26, 13, 180, 10},
+      {90, 17, 175, 129, 10}
+    },
+    { {240, 135, 244, 59, 6},
+      {32, 187, 250, 182, 5},
+      {109, 194, 254, 16, 15},
+      {166, 213, 253, 208, 4}
+    },
+    { {78, 144, 152, 110, 1},
+      {206, 160, 22, 153, 1},
+      {135, 97, 144, 151, 2},
+      {137, 150, 128, 87, 3}
+    },
+    { {210, 100, 39, 89, 9},
+      {21, 109, 129, 175, 4},
+      {153, 174, 66, 100, 11},
+      {47, 88, 27, 106, 8}
+    },
+    { {36, 194, 245, 253, 5},
+      {188, 165, 250, 28, 6},
+      {171, 250, 244, 50, 4},
+      {99, 133, 250, 83, 13}
+    },
+    { {50, 142, 228, 41, 3},
+      {36, 185, 58, 37, 12},
+      {201, 66, 119, 20, 12},
+      {58, 69, 201, 210, 4}
+    },
+    { {107, 62, 162, 144, 11},
+      {71, 208, 169, 225, 14},
+      {208, 148, 87, 205, 6},
+      {120, 121, 80, 190, 2}
+    },
+    { {217, 65, 43, 194, 11},
+      {22, 94, 5, 202, 7},
+      {212, 61, 72, 41, 11},
+      {229, 58, 7, 166, 8}
+    },
+    { {156, 165, 116, 197, 7},
+      {175, 27, 80, 62, 6},
+      {234, 50, 234, 83, 9},
+      {103, 192, 173, 143, 5}
+    },
+    { {17, 109, 219, 74, 15},
+      {53, 254, 69, 120, 9},
+      {245, 45, 187, 104, 8},
+      {145, 234, 39, 250, 12}
+    },
+    { {174, 87, 71, 134, 8},
+      {250, 71, 41, 35, 3},
+      {22, 30, 46, 167, 5},
+      {204, 73, 78, 37, 15}
+    },
+    { {114, 224, 117, 97, 4},
+      {49, 13, 114, 157, 4},
+      {40, 106, 224, 116, 14},
+      {43, 148, 235, 8, 12}
+    },
+    { {198, 150, 180, 86, 6},
+      {200, 145, 216, 187, 5},
+      {102, 162, 214, 150, 3},
+      {173, 209, 184, 145, 3}
+    },
+    { {168, 197, 195, 205, 1},
+      {62, 230, 48, 46, 2},
+      {139, 60, 58, 49, 5},
+      {71, 64, 198, 119, 12}
+    },
+    { {91, 21, 74, 119, 1},
+      {110, 74, 134, 237, 1},
+      {142, 229, 42, 141, 10},
+      {139, 118, 21, 39, 6}
+    },
+    { {205, 163, 184, 200, 5},
+      {135, 162, 92, 218, 6},
+      {161, 49, 220, 91, 3},
+      {101, 179, 164, 94, 1}
+    },
+    { {74, 204, 221, 214, 7},
+      {62, 149, 212, 185, 11},
+      {230, 187, 179, 53, 2},
+      {217, 210, 186, 151, 12}
+    },
+    { {102, 82, 239, 170, 15},
+      {244, 245, 111, 129, 7},
+      {245, 95, 116, 166, 6},
+      {232, 31, 106, 242, 15}
+    },
+    { {173, 218, 37, 160, 0},
+      {210, 5, 58, 66, 14},
+      {0, 90, 69, 187, 5},
+      {116, 37, 202, 4, 11}
+    },
+    { {252, 230, 67, 94, 0},
+      {187, 108, 184, 170, 1},
+      {7, 172, 38, 115, 15},
+      {133, 81, 211, 109, 13}
+    },
+    { {187, 145, 56, 91, 8},
+      {66, 42, 181, 95, 5},
+      {29, 161, 200, 157, 13},
+      {175, 170, 213, 68, 2}
+    },
+    { {52, 217, 147, 145, 4},
+      {208, 206, 240, 20, 10},
+      {40, 156, 153, 178, 12},
+      {82, 128, 247, 48, 11}
+    },
+    { {160, 29, 41, 117, 12},
+      {88, 2, 231, 46, 12},
+      {58, 233, 75, 128, 5},
+      {55, 78, 116, 1, 10}
+    },
+    { {197, 91, 119, 176, 10},
+      {240, 87, 139, 210, 14},
+      {80, 222, 237, 170, 3},
+      {116, 189, 30, 160, 15}
+    },
+    { {180, 103, 48, 193, 10},
+      {129, 30, 41, 62, 6},
+      {88, 48, 206, 98, 13},
+      {103, 201, 71, 136, 1}
+    },
+    { {79, 215, 217, 189, 10},
+      {250, 182, 159, 245, 2},
+      {91, 217, 190, 191, 2},
+      {74, 255, 150, 213, 15}
+    },
+    { {62, 239, 157, 76, 6},
+      {155, 191, 124, 57, 8},
+      {99, 43, 159, 119, 12},
+      {25, 195, 239, 221, 9}
+    },
+    { {211, 16, 230, 71, 6},
+      {104, 217, 64, 207, 5},
+      {110, 38, 112, 140, 11},
+      {175, 48, 41, 177, 6}
+    },
+    { {150, 212, 131, 130, 1},
+      {212, 204, 16, 35, 3},
+      {132, 28, 18, 182, 9},
+      {204, 64, 131, 50, 11}
+    },
+    { {190, 66, 191, 212, 9},
+      {158, 205, 173, 27, 6},
+      {146, 191, 212, 39, 13},
+      {109, 139, 91, 55, 9}
+    },
+    { {66, 18, 49, 102, 9},
+      {92, 0, 11, 153, 5},
+      {150, 104, 196, 132, 2},
+      {169, 157, 0, 3, 10}
+    },
+    { {51, 202, 85, 219, 9},
+      {52, 45, 185, 93, 11},
+      {157, 186, 165, 60, 12},
+      {219, 169, 219, 66, 12}
+    },
+    { {165, 14, 174, 0, 13},
+      {132, 193, 109, 98, 12},
+      {176, 7, 87, 10, 5},
+      {52, 107, 104, 50, 1}
+    },
+    { {86, 110, 32, 220, 13},
+      {141, 44, 201, 169, 14},
+      {179, 176, 71, 102, 10},
+      {121, 89, 51, 75, 1}
+    },
+    { {126, 177, 2, 164, 3},
+      {207, 90, 50, 129, 2},
+      {194, 84, 8, 215, 14},
+      {72, 20, 197, 175, 3}
+    },
+    { {175, 51, 166, 149, 7},
+      {207, 211, 232, 71, 6},
+      {234, 150, 92, 207, 5},
+      {110, 33, 124, 191, 3}
+    },
+    { {144, 39, 133, 201, 15},
+      {21, 187, 73, 46, 2},
+      {249, 58, 30, 64, 9},
+      {71, 73, 45, 218, 8}
+    },
+    { {26, 175, 114, 194, 0},
+      {35, 74, 24, 57, 15},
+      {4, 52, 239, 85, 8},
+      {249, 193, 133, 44, 4}
+    },
+    { {140, 72, 88, 22, 8},
+      {170, 4, 133, 18, 9},
+      {22, 129, 161, 35, 1},
+      {148, 138, 18, 5, 5}
+    },
+    { {221, 184, 28, 187, 8},
+      {195, 41, 151, 214, 11},
+      {29, 211, 129, 219, 11},
+      {214, 190, 153, 76, 3}
+    },
+    { {41, 92, 192, 64, 12},
+      {98, 132, 97, 104, 8},
+      {48, 32, 51, 169, 4},
+      {17, 104, 98, 20, 6}
+    },
+    { {204, 21, 5, 90, 14},
+      {210, 51, 193, 170, 1},
+      {117, 170, 10, 131, 3},
+      {133, 88, 60, 196, 11}
+    },
+    { {218, 107, 24, 244, 9},
+      {15, 14, 143, 155, 10},
+      {146, 241, 141, 101, 11},
+      {93, 159, 23, 15, 0}
+    },
+    { {167, 135, 108, 37, 9},
+      {172, 3, 63, 103, 4},
+      {154, 67, 110, 30, 5},
+      {46, 111, 204, 3, 5}
+    },
+    { {246, 183, 42, 152, 5},
+      {197, 106, 252, 163, 6},
+      {161, 149, 78, 214, 15},
+      {108, 83, 245, 106, 3}
+    },
+    { {176, 8, 245, 30, 13},
+      {60, 169, 225, 18, 13},
+      {183, 138, 241, 0, 13},
+      {180, 136, 121, 83, 12}
+    },
+    { {75, 168, 124, 205, 13},
+      {47, 33, 85, 221, 14},
+      {187, 51, 225, 93, 2},
+      {123, 186, 168, 79, 4}
+    },
+    { {132, 228, 215, 70, 3},
+      {189, 213, 16, 58, 1},
+      {198, 46, 178, 114, 1},
+      {133, 192, 138, 187, 13}
+    },
+    { {108, 145, 86, 98, 0},
+      {226, 67, 50, 152, 1},
+      {4, 102, 168, 147, 6},
+      {129, 148, 204, 36, 7}
+    },
+    { {161, 89, 232, 111, 0},
+      {104, 166, 38, 78, 13},
+      {15, 97, 121, 168, 5},
+      {183, 38, 70, 81, 6}
+    },
+    { {240, 101, 172, 214, 8},
+      {9, 143, 165, 170, 7},
+      {22, 179, 90, 96, 15},
+      {229, 90, 95, 25, 0}
+    },
+    { {151, 176, 34, 145, 10},
+      {193, 88, 145, 71, 6},
+      {88, 148, 64, 222, 9},
+      {110, 40, 145, 168, 3}
+    },
+    { {191, 36, 1, 206, 6},
+      {155, 56, 96, 107, 3},
+      {103, 56, 2, 79, 13},
+      {205, 96, 97, 205, 9}
+    },
+    { {164, 202, 31, 226, 1},
+      {148, 69, 62, 26, 11},
+      {132, 127, 133, 50, 5},
+      {213, 135, 202, 34, 9}
+    },
+    { {17, 222, 135, 135, 9},
+      {92, 205, 25, 100, 11},
+      {158, 30, 23, 184, 8},
+      {210, 105, 139, 51, 10}
+    },
+    { {57, 73, 184, 51, 5},
+      {6, 142, 230, 84, 13},
+      {172, 193, 217, 41, 12},
+      {178, 166, 119, 22, 0}
+    },
+    { {134, 25, 53, 96, 13},
+      {212, 3, 67, 27, 12},
+      {176, 106, 201, 134, 1},
+      {61, 140, 44, 2, 11}
+    },
+    { {200, 75, 66, 10, 11},
+      {38, 118, 9, 130, 9},
+      {213, 4, 45, 33, 3},
+      {148, 25, 6, 230, 4}
+    },
+    { {81, 136, 22, 43, 15},
+      {4, 121, 83, 212, 9},
+      {253, 70, 129, 24, 10},
+      {146, 188, 169, 226, 0}
+    },
+    { {198, 116, 204, 159, 0},
+      {233, 165, 132, 167, 3},
+      {15, 147, 50, 230, 3},
+      {206, 82, 26, 89, 7}
+    },
+    { {168, 22, 147, 66, 12},
+      {82, 192, 105, 58, 1},
+      {52, 44, 150, 129, 5},
+      {133, 201, 96, 52, 10}
+    },
+    { {91, 182, 26, 190, 12},
+      {75, 104, 223, 241, 3},
+      {55, 213, 134, 221, 10},
+      {200, 255, 177, 109, 2}
+    },
+    { {64, 57, 11, 138, 10},
+      {81, 114, 5, 128, 11},
+      {85, 29, 9, 192, 2},
+      {208, 26, 4, 232, 10}
+    },
+    { {49, 229, 119, 99, 10},
+      {49, 95, 51, 124, 5},
+      {92, 110, 234, 120, 12},
+      {163, 236, 207, 168, 12}
+    },
+    { {138, 181, 190, 128, 6},
+      {67, 211, 84, 51, 6},
+      {96, 23, 218, 213, 1},
+      {108, 194, 172, 188, 2}
+    },
+    { {232, 127, 242, 172, 9},
+      {111, 230, 43, 178, 14},
+      {147, 84, 255, 225, 7},
+      {116, 221, 70, 127, 6}
+    },
+    { {133, 144, 118, 85, 9},
+      {236, 65, 145, 94, 4},
+      {154, 166, 224, 154, 1},
+      {39, 168, 152, 35, 7}
+    },
+    { {173, 4, 85, 41, 5},
+      {182, 33, 98, 118, 0},
+      {169, 74, 162, 11, 5},
+      {6, 228, 104, 70, 13}
+    },
+    { {94, 100, 156, 243, 5},
+      {135, 141, 198, 189, 3},
+      {172, 243, 146, 103, 10},
+      {203, 214, 59, 30, 1}
+    },
+    { {113, 188, 174, 157, 13},
+      {77, 233, 245, 228, 14},
+      {187, 151, 83, 216, 14},
+      {114, 122, 249, 123, 2}
+    },
+    { {202, 194, 32, 47, 13},
+      {14, 36, 91, 135, 5},
+      {191, 64, 68, 53, 3},
+      {174, 29, 162, 71, 0}
+    },
+    { {237, 109, 12, 225, 0},
+      {131, 7, 38, 238, 10},
+      {8, 115, 11, 107, 7},
+      {87, 118, 78, 12, 1}
+    },
+    { {211, 179, 54, 142, 8},
+      {73, 107, 25, 211, 7},
+      {23, 22, 204, 220, 11},
+      {236, 185, 141, 105, 2}
+    },
+    { {88, 251, 152, 132, 4},
+      {75, 142, 92, 144, 10},
+      {34, 17, 157, 241, 10},
+      {80, 147, 167, 29, 2}
+    },
+    { {66, 176, 73, 175, 12},
+      {121, 32, 87, 133, 3},
+      {63, 89, 32, 212, 2},
+      {202, 30, 160, 73, 14}
+    },
+    { {165, 172, 222, 241, 10},
+      {161, 209, 183, 126, 10},
+      {88, 247, 179, 90, 5},
+      {87, 238, 216, 184, 5}
+    },
+    { {126, 74, 98, 45, 6},
+      {170, 124, 106, 133, 12},
+      {107, 68, 101, 39, 14},
+      {58, 21, 99, 229, 5}
+    },
+    { {93, 233, 95, 78, 9},
+      {191, 111, 21, 216, 9},
+      {151, 47, 169, 123, 10},
+      {145, 186, 143, 111, 13}
+    },
+    { {34, 197, 24, 23, 9},
+      {12, 6, 181, 53, 1},
+      {158, 129, 138, 52, 4},
+      {138, 202, 214, 3, 0}
+    },
+    { {115, 117, 108, 186, 5},
+      {101, 47, 230, 225, 7},
+      {165, 211, 106, 236, 14},
+      {232, 118, 127, 74, 6}
+    },
+    { {80, 47, 87, 216, 11},
+      {53, 123, 137, 184, 10},
+      {209, 190, 175, 64, 10},
+      {81, 217, 29, 234, 12}
+    },
+    { {154, 160, 25, 211, 11},
+      {23, 24, 149, 31, 3},
+      {220, 185, 128, 85, 9},
+      {207, 138, 145, 142, 8}
+    },
+    { {61, 180, 129, 166, 15},
+      {223, 152, 115, 96, 3},
+      {246, 88, 18, 219, 12},
+      {192, 108, 225, 159, 11}
+    },
+    { {39, 218, 159, 156, 8},
+      {216, 229, 189, 81, 10},
+      {19, 159, 149, 190, 4},
+      {88, 171, 218, 113, 11}
+    },
+    { {58, 103, 134, 237, 6},
+      {11, 255, 106, 45, 2},
+      {107, 118, 30, 101, 12},
+      {75, 69, 111, 253, 0}
+    },
+    { {132, 55, 15, 143, 6},
+      {217, 115, 76, 38, 3},
+      {111, 31, 14, 194, 1},
+      {198, 67, 44, 233, 11}
+    },
+    { {53, 66, 74, 6, 5},
+      {172, 76, 108, 64, 1},
+      {166, 5, 36, 42, 12},
+      {128, 35, 99, 35, 5}
+    },
+    { {131, 37, 139, 194, 7},
+      {21, 210, 68, 107, 3},
+      {228, 61, 26, 76, 1},
+      {205, 98, 36, 186, 8}
+    },
+    { {6, 72, 246, 57, 4},
+      {160, 229, 194, 21, 12},
+      {41, 198, 241, 38, 0},
+      {58, 132, 58, 112, 5}
+    },
+    { {46, 148, 213, 97, 12},
+      {242, 129, 115, 61, 0},
+      {56, 106, 178, 151, 4},
+      {11, 204, 232, 20, 15}
+    },
+    { {72, 50, 160, 103, 2},
+      {75, 144, 10, 140, 5},
+      {78, 96, 84, 193, 2},
+      {163, 21, 0, 157, 2}
+    },
+    { {228, 117, 33, 147, 1},
+      {213, 6, 160, 166, 7},
+      {140, 152, 74, 226, 7},
+      {230, 80, 86, 10, 11}
+    },
+    { {110, 253, 140, 158, 9},
+      {207, 167, 181, 161, 11},
+      {151, 147, 27, 247, 6},
+      {216, 90, 222, 95, 3}
+    },
+    { {0, 211, 242, 119, 9},
+      {108, 198, 155, 28, 5},
+      {158, 228, 252, 176, 0},
+      {163, 141, 150, 51, 6}
+    },
+    { {99, 216, 68, 68, 11},
+      {108, 21, 49, 201, 8},
+      {210, 34, 33, 188, 6},
+      {25, 56, 202, 131, 6}
+    },
+    { {249, 28, 183, 98, 7},
+      {86, 217, 98, 250, 13},
+      {228, 110, 211, 137, 15},
+      {181, 244, 105, 182, 10}
+    },
+    { {148, 34, 208, 61, 7},
+      {173, 184, 202, 22, 0},
+      {235, 192, 180, 66, 9},
+      {6, 133, 49, 219, 5}
+    },
+    { {187, 200, 20, 31, 6},
+      {10, 61, 240, 87, 9},
+      {111, 130, 129, 61, 13},
+      {158, 160, 251, 197, 0}
+    },
+    { {69, 152, 237, 76, 14},
+      {248, 177, 85, 200, 12},
+      {115, 43, 113, 154, 2},
+      {49, 58, 168, 209, 15}
+    },
+    { {83, 226, 244, 224, 9},
+      {37, 141, 27, 217, 6},
+      {144, 114, 244, 124, 10},
+      {105, 189, 139, 26, 4}
+    },
+    { {241, 178, 125, 130, 9},
+      {117, 9, 61, 210, 7},
+      {148, 27, 228, 216, 15},
+      {228, 187, 201, 10, 14}
+    },
+    { {42, 202, 178, 62, 9},
+      {14, 228, 187, 17, 13},
+      {151, 196, 213, 53, 4},
+      {184, 141, 210, 119, 0}
+    },
+    { {123, 122, 214, 143, 9},
+      {111, 237, 41, 213, 11},
+      {159, 22, 181, 237, 14},
+      {218, 185, 75, 127, 6}
+    },
+    { {130, 225, 42, 209, 13},
+      {5, 70, 213, 15, 6},
+      {184, 181, 72, 116, 1},
+      {111, 10, 182, 42, 0}
+    },
+    { {37, 245, 188, 164, 11},
+      {205, 151, 55, 112, 6},
+      {210, 83, 218, 250, 4},
+      {96, 238, 206, 155, 3}
+    },
+    { {150, 173, 51, 250, 11},
+      {149, 122, 147, 59, 15},
+      {213, 252, 203, 86, 9},
+      {253, 204, 149, 234, 9}
+    },
+    { {116, 221, 218, 89, 11},
+      {228, 254, 181, 188, 8},
+      {217, 165, 187, 178, 14},
+      {19, 218, 215, 242, 7}
+    },
+    { {190, 51, 16, 82, 7},
+      {199, 26, 232, 27, 1},
+      {228, 160, 140, 199, 13},
+      {141, 129, 117, 142, 3}
+    },
+    { {175, 106, 142, 227, 12},
+      {131, 197, 111, 79, 11},
+      {60, 119, 21, 111, 5},
+      {223, 47, 106, 60, 1}
+    },
+    { {80, 157, 15, 85, 14},
+      {88, 91, 213, 172, 8},
+      {122, 175, 11, 144, 10},
+      {19, 90, 189, 161, 10}
+    },
+    { {90, 168, 135, 202, 13},
+      {23, 233, 81, 137, 11},
+      {181, 62, 17, 85, 10},
+      {217, 24, 169, 126, 8}
+    },
+    { {248, 216, 14, 113, 13},
+      {70, 77, 247, 142, 8},
+      {184, 231, 1, 177, 15},
+      {23, 30, 251, 38, 2}
+    },
+    { {18, 41, 212, 58, 0},
+      {33, 171, 130, 17, 9},
+      {5, 194, 185, 68, 8},
+      {152, 132, 29, 88, 4}
+    },
+    { {58, 213, 230, 98, 8},
+      {98, 207, 51, 41, 5},
+      {20, 102, 122, 181, 12},
+      {169, 76, 207, 52, 6}
+    },
+    { {68, 63, 156, 94, 2},
+      {201, 179, 140, 184, 9},
+      {71, 163, 159, 194, 2},
+      {145, 211, 28, 217, 3}
+    },
+    { {53, 224, 26, 247, 2},
+      {137, 92, 182, 92, 3},
+      {78, 245, 128, 122, 12},
+      {195, 166, 211, 169, 1}
+    },
+    { {82, 84, 77, 114, 6},
+      {112, 29, 198, 169, 1},
+      {100, 235, 34, 164, 10},
+      {137, 86, 59, 128, 14}
+    },
+    { {8, 222, 33, 65, 9},
+      {86, 4, 25, 44, 12},
+      {152, 40, 71, 177, 0},
+      {51, 73, 130, 6, 10}
+    },
+    { {151, 233, 242, 229, 5},
+      {173, 206, 82, 95, 14},
+      {170, 116, 249, 126, 9},
+      {127, 164, 167, 59, 5}
+    },
+    { {117, 185, 123, 135, 5},
+      {253, 74, 116, 212, 15},
+      {174, 29, 233, 218, 14},
+      {242, 178, 229, 43, 15}
+    },
+    { {28, 149, 63, 106, 13},
+      {214, 107, 87, 56, 5},
+      {181, 111, 202, 147, 8},
+      {161, 206, 173, 102, 11}
+    },
+    { {72, 136, 208, 174, 15},
+      {46, 176, 83, 144, 11},
+      {247, 80, 177, 17, 2},
+      {208, 156, 160, 215, 4}
+    },
+    { {35, 82, 133, 125, 8},
+      {88, 165, 171, 77, 0},
+      {27, 234, 20, 172, 4},
+      {11, 45, 90, 81, 10}
+    },
+    { {145, 10, 12, 159, 8},
+      {8, 41, 141, 70, 11},
+      {31, 147, 5, 8, 9},
+      {214, 43, 25, 65, 0}
+    },
+    { {114, 106, 253, 204, 4},
+      {57, 173, 108, 153, 14},
+      {35, 59, 245, 100, 14},
+      {121, 147, 107, 89, 12}
+    },
+    { {70, 182, 223, 184, 12},
+      {241, 225, 223, 177, 2},
+      {49, 223, 182, 214, 2},
+      {72, 223, 184, 120, 15}
+    },
+    { {55, 30, 152, 201, 12},
+      {192, 168, 109, 125, 10},
+      {57, 49, 151, 142, 12},
+      {91, 235, 97, 80, 3}
+    },
+    { {242, 133, 64, 180, 10},
+      {40, 26, 179, 163, 2},
+      {82, 208, 42, 20, 15},
+      {76, 92, 213, 129, 4}
+    },
+    { {155, 53, 4, 69, 10},
+      {75, 27, 1, 111, 0},
+      {90, 34, 10, 205, 9},
+      {15, 104, 13, 141, 2}
+    },
+    { {138, 236, 145, 248, 13},
+      {23, 164, 211, 59, 10},
+      {177, 248, 147, 117, 1},
+      {93, 204, 178, 94, 8}
+    },
+    { {173, 85, 173, 77, 15},
+      {222, 183, 101, 110, 4},
+      {251, 43, 90, 171, 5},
+      {39, 106, 110, 215, 11}
+    },
+    { {42, 24, 202, 208, 2},
+      {98, 208, 164, 9, 10},
+      {64, 181, 49, 133, 4},
+      {89, 2, 80, 180, 6}
+    },
+    { {237, 2, 60, 165, 10},
+      {138, 17, 47, 214, 6},
+      {90, 83, 196, 11, 7},
+      {102, 191, 72, 133, 1}
+    },
+    { {190, 137, 112, 155, 1},
+      {166, 42, 176, 23, 15},
+      {141, 144, 233, 23, 13},
+      {254, 128, 213, 70, 5}
+    },
+    { {66, 233, 185, 200, 9},
+      {21, 166, 21, 153, 14},
+      {145, 57, 217, 116, 2},
+      {121, 154, 134, 90, 8}
+    },
+    { {224, 185, 52, 114, 9},
+      {69, 3, 179, 154, 13},
+      {148, 226, 201, 208, 7},
+      {181, 156, 220, 10, 2}
+    },
+    { {135, 32, 220, 54, 11},
+      {173, 145, 135, 83, 1},
+      {214, 195, 176, 78, 1},
+      {140, 174, 24, 155, 5}
+    },
+    { {93, 132, 96, 137, 7},
+      {166, 56, 80, 228, 6},
+      {233, 16, 98, 27, 10},
+      {98, 112, 161, 198, 5}
+    },
+    { {144, 204, 205, 2, 15},
+      {52, 157, 85, 34, 9},
+      {244, 11, 51, 48, 9},
+      {148, 74, 171, 146, 12}
+    },
+    { {140, 134, 212, 168, 8},
+      {162, 161, 27, 50, 2},
+      {17, 82, 182, 19, 1},
+      {68, 205, 136, 84, 5}
+    },
+    { {120, 169, 76, 36, 12},
+      {43, 11, 119, 128, 8},
+      {50, 67, 41, 81, 14},
+      {16, 30, 237, 13, 4}
+    },
+    { {182, 101, 251, 203, 12},
+      {177, 238, 101, 63, 7},
+      {61, 61, 250, 102, 13},
+      {239, 202, 103, 120, 13}
+    },
+    { {39, 167, 32, 26, 6},
+      {129, 50, 248, 97, 5},
+      {101, 128, 78, 94, 4},
+      {168, 97, 244, 200, 1}
+    },
+    { {193, 202, 69, 13, 5},
+      {60, 37, 88, 198, 8},
+      {171, 10, 37, 56, 3},
+      {22, 49, 170, 67, 12}
+    },
+    { {75, 38, 242, 6, 13},
+      {47, 192, 73, 241, 5},
+      {182, 4, 246, 77, 2},
+      {168, 249, 32, 63, 4}
+    },
+    { {146, 37, 46, 39, 11},
+      {13, 91, 7, 39, 5},
+      {222, 71, 74, 68, 9},
+      {174, 78, 13, 171, 0}
+    },
+    { {240, 175, 98, 24, 8},
+      {33, 106, 185, 162, 12},
+      {17, 132, 111, 80, 15},
+      {52, 89, 213, 104, 4}
+    },
+    { {50, 161, 124, 11, 6},
+      {33, 59, 116, 21, 5},
+      {109, 3, 232, 84, 12},
+      {170, 130, 237, 200, 4}
+    },
+    { {107, 9, 58, 162, 14},
+      {2, 82, 103, 209, 15},
+      {116, 85, 201, 13, 6},
+      {248, 190, 100, 164, 0}
+    },
+    { {134, 231, 189, 205, 5},
+      {157, 167, 92, 63, 6},
+      {171, 59, 222, 118, 1},
+      {111, 195, 174, 91, 9}
+    },
+    { {70, 76, 128, 181, 11},
+      {140, 148, 131, 165, 10},
+      {218, 208, 19, 38, 2},
+      {90, 92, 18, 147, 1}
+    },
+    { {110, 146, 188, 233, 7},
+      {198, 177, 126, 157, 6},
+      {233, 115, 212, 151, 6},
+      {107, 151, 232, 214, 3}
+    },
+    { {10, 141, 210, 173, 4},
+      {42, 226, 82, 53, 10},
+      {43, 84, 187, 21, 0},
+      {90, 196, 164, 117, 4}
+    },
+    { {133, 26, 254, 234, 9},
+      {228, 225, 15, 90, 15},
+      {149, 119, 245, 138, 1},
+      {245, 175, 8, 114, 7}
+    },
+    { {102, 122, 112, 73, 9},
+      {229, 36, 41, 157, 12},
+      {153, 32, 229, 230, 6},
+      {59, 153, 66, 74, 7}
+    },
+    { {113, 49, 97, 102, 13},
+      {125, 10, 99, 200, 5},
+      {182, 104, 104, 200, 14},
+      {161, 60, 101, 11, 14}
+    },
+    { {197, 119, 160, 82, 15},
+      {197, 150, 201, 234, 5},
+      {244, 160, 94, 234, 3},
+      {165, 121, 54, 154, 3}
+    },
+    { {224, 70, 76, 187, 12},
+      {32, 37, 239, 166, 3},
+      {61, 211, 38, 32, 7},
+      {198, 95, 122, 64, 4}
+    },
+    { {244, 9, 85, 141, 10},
+      {184, 59, 33, 150, 10},
+      {91, 26, 169, 2, 15},
+      {86, 152, 77, 193, 13}
+    },
+    { {34, 79, 148, 169, 9},
+      {4, 167, 43, 53, 10},
+      {153, 82, 159, 36, 4},
+      {90, 205, 78, 82, 0}
+    },
+    { {229, 88, 200, 244, 13},
+      {236, 132, 231, 202, 10},
+      {178, 241, 49, 170, 7},
+      {85, 62, 114, 19, 7}
+    },
+    { {243, 18, 209, 192, 11},
+      {116, 152, 41, 219, 2},
+      {208, 56, 180, 140, 15},
+      {77, 185, 65, 146, 14}
+    },
+    { {41, 114, 88, 124, 11},
+      {111, 52, 175, 88, 0},
+      {211, 225, 164, 233, 4},
+      {1, 175, 82, 207, 6}
+    },
+    { {65, 179, 38, 98, 4},
+      {65, 67, 90, 200, 5},
+      {36, 102, 76, 216, 2},
+      {161, 53, 172, 40, 2}
+    },
+    { {218, 87, 244, 214, 12},
+      {106, 143, 201, 187, 7},
+      {54, 178, 254, 165, 11},
+      {237, 217, 63, 21, 6}
+    },
+    { {186, 1, 109, 186, 9},
+      {54, 43, 167, 3, 7},
+      {149, 219, 104, 5, 13},
+      {236, 14, 93, 70, 12}
+    },
+    { {53, 137, 198, 176, 5},
+      {164, 203, 242, 64, 10},
+      {160, 214, 57, 26, 12},
+      {80, 36, 253, 50, 5}
+    },
+    { {223, 69, 8, 189, 5},
+      {142, 46, 198, 231, 2},
+      {171, 209, 10, 47, 11},
+      {78, 118, 55, 71, 1}
+    },
+    { {50, 82, 34, 250, 8},
+      {64, 108, 171, 9, 7},
+      {21, 244, 68, 164, 12},
+      {233, 13, 83, 96, 2}
+    },
+    { {87, 54, 121, 125, 4},
+      {249, 40, 206, 253, 4},
+      {43, 233, 230, 206, 10},
+      {43, 247, 49, 73, 15}
+    },
+    { {100, 77, 74, 190, 10},
+      {168, 118, 167, 160, 11},
+      {87, 213, 43, 34, 6},
+      {208, 94, 86, 225, 5}
+    },
+    { {13, 189, 14, 79, 10},
+      {203, 115, 21, 108, 9},
+      {95, 39, 11, 219, 0},
+      {147, 106, 140, 237, 3}
+    },
+    { {20, 18, 155, 246, 13},
+      {220, 200, 207, 24, 3},
+      {182, 253, 148, 130, 8},
+      {193, 143, 49, 51, 11}
+    },
+    { {160, 137, 141, 158, 1},
+      {28, 163, 180, 2, 11},
+      {135, 155, 25, 16, 5},
+      {212, 2, 220, 83, 8}
+    },
+    { {116, 80, 182, 226, 11},
+      {196, 221, 35, 152, 7},
+      {212, 118, 208, 162, 14},
+      {225, 156, 75, 178, 3}
+    },
+    { {224, 228, 28, 54, 7},
+      {13, 21, 246, 178, 1},
+      {230, 195, 130, 112, 7},
+      {132, 214, 250, 139, 0}
+    },
+    { {105, 149, 101, 253, 11},
+      {126, 51, 179, 236, 6},
+      {219, 250, 106, 153, 6},
+      {99, 124, 220, 199, 14}
+    },
+    { {103, 160, 233, 22, 8},
+      {185, 128, 181, 193, 5},
+      {22, 137, 112, 94, 6},
+      {168, 58, 208, 25, 13}
+    },
+    { {25, 252, 180, 77, 12},
+      {75, 173, 81, 124, 12},
+      {59, 34, 211, 249, 8},
+      {51, 232, 171, 93, 2}
+    },
+    { {240, 254, 74, 108, 6},
+      {105, 124, 126, 170, 8},
+      {99, 101, 39, 240, 15},
+      {21, 87, 227, 233, 6}
+    },
+    { {78, 229, 220, 11, 14},
+      {163, 183, 85, 181, 1},
+      {125, 3, 186, 119, 2},
+      {138, 218, 174, 220, 5}
+    },
+    { {178, 90, 177, 231, 7},
+      {92, 156, 106, 31, 15},
+      {238, 120, 213, 164, 13},
+      {255, 133, 99, 147, 10}
+    },
+    { {84, 197, 166, 143, 13},
+      {140, 239, 81, 164, 7},
+      {191, 22, 90, 50, 10},
+      {226, 88, 175, 115, 1}
+    },
+    { {247, 21, 47, 212, 3},
+      {220, 91, 164, 235, 6},
+      {194, 191, 74, 142, 15},
+      {109, 114, 93, 163, 11}
+    },
+    { {79, 145, 125, 232, 10},
+      {242, 51, 23, 217, 6},
+      {81, 123, 232, 159, 2},
+      {105, 190, 140, 196, 15}
+    },
+    { {9, 53, 24, 238, 6},
+      {75, 50, 70, 120, 3},
+      {103, 113, 138, 201, 0},
+      {193, 230, 36, 205, 2}
+    },
+    { {170, 77, 229, 141, 6},
+      {58, 183, 96, 39, 14},
+      {107, 26, 123, 37, 5},
+      {126, 64, 110, 213, 12}
+    },
+    { {251, 189, 163, 100, 14},
+      {91, 218, 115, 235, 12},
+      {114, 108, 91, 221, 15},
+      {61, 124, 229, 189, 10}
+    },
+    { {194, 140, 79, 157, 13},
+      {60, 97, 213, 167, 10},
+      {187, 159, 35, 20, 3},
+      {94, 90, 184, 99, 12}
+    },
+    { {221, 221, 90, 236, 8},
+      {234, 110, 23, 250, 10},
+      {19, 117, 171, 187, 11},
+      {85, 254, 135, 101, 7}
+    },
+    { {154, 123, 45, 105, 4},
+      {83, 47, 78, 15, 12},
+      {41, 107, 77, 229, 9},
+      {63, 7, 47, 76, 10}
+    },
+    { {218, 46, 220, 145, 1},
+      {39, 137, 140, 183, 10},
+      {136, 147, 183, 69, 11},
+      {94, 211, 25, 30, 4}
+    },
+    { {18, 21, 66, 25, 5},
+      {100, 106, 192, 37, 0},
+      {169, 132, 42, 132, 8},
+      {10, 64, 53, 98, 6}
+    },
+    { {58, 253, 126, 65, 13},
+      {103, 79, 117, 61, 12},
+      {184, 39, 235, 245, 12},
+      {59, 202, 239, 46, 6}
+    },
+    { {210, 145, 48, 33, 12},
+      {64, 10, 83, 151, 4},
+      {56, 64, 200, 148, 11},
+      {46, 156, 165, 0, 2}
+    },
+    { {136, 91, 123, 237, 6},
+      {122, 118, 78, 30, 14},
+      {107, 125, 237, 161, 1},
+      {119, 135, 38, 229, 14}
+    },
+    { {255, 26, 148, 3, 13},
+      {198, 137, 105, 215, 9},
+      {188, 2, 149, 143, 15},
+      {158, 185, 105, 22, 3}
+    },
+    { {138, 210, 5, 218, 10},
+      {82, 53, 153, 11, 3},
+      {85, 186, 4, 181, 1},
+      {205, 9, 154, 196, 10}
+    },
+    { {124, 254, 229, 86, 14},
+      {251, 157, 249, 168, 13},
+      {118, 170, 119, 243, 14},
+      {177, 89, 251, 157, 15}
+    },
+    { {15, 29, 188, 45, 9},
+      {206, 163, 7, 117, 12},
+      {155, 67, 219, 143, 0},
+      {58, 238, 12, 87, 3}
+    },
+    { {173, 125, 51, 119, 9},
+      {223, 70, 163, 126, 13},
+      {158, 236, 203, 235, 5},
+      {183, 236, 86, 47, 11}
+    },
+    { {94, 35, 218, 148, 5},
+      {175, 202, 204, 145, 2},
+      {162, 149, 188, 71, 10},
+      {72, 147, 53, 63, 5}
+    },
+    { {202, 135, 100, 114, 13},
+      {38, 3, 219, 171, 5},
+      {180, 226, 110, 21, 3},
+      {173, 93, 188, 6, 4}
+    },
+    { {42, 52, 86, 226, 7},
+      {103, 81, 98, 57, 3},
+      {228, 118, 162, 197, 4},
+      {201, 196, 104, 174, 6}
+    },
+    { {179, 128, 104, 125, 6},
+      {40, 56, 246, 79, 4},
+      {107, 225, 96, 28, 13},
+      {47, 38, 241, 193, 4}
+    },
+    { {73, 224, 165, 31, 6},
+      {27, 181, 208, 196, 5},
+      {111, 138, 80, 121, 2},
+      {162, 48, 186, 221, 8}
+    },
+    { {144, 226, 83, 62, 9},
+      {61, 108, 155, 18, 1},
+      {151, 204, 164, 112, 9},
+      {132, 141, 147, 107, 12}
+    },
+    { {221, 1, 6, 99, 13},
+      {134, 75, 67, 206, 1},
+      {188, 102, 8, 11, 11},
+      {135, 60, 45, 38, 1}
+    },
+    { {118, 160, 92, 144, 8},
+      {161, 9, 181, 145, 2},
+      {16, 147, 160, 86, 14},
+      {72, 154, 217, 8, 5}
+    },
+    { {14, 217, 3, 223, 6},
+      {218, 118, 208, 13, 11},
+      {111, 188, 9, 183, 0},
+      {219, 0, 182, 229, 11}
+    },
+    { {43, 112, 183, 113, 13},
+      {87, 197, 227, 93, 4},
+      {184, 238, 208, 237, 4},
+      {43, 172, 122, 62, 10}
+    },
+    { {78, 140, 226, 119, 3},
+      {174, 208, 146, 173, 13},
+      {206, 228, 115, 23, 2},
+      {187, 84, 144, 183, 5}
+    },
+    { {164, 109, 4, 140, 4},
+      {137, 39, 96, 34, 10},
+      {35, 18, 11, 98, 5},
+      {84, 64, 110, 73, 1}
+    },
+    { {174, 72, 136, 91, 10},
+      {130, 180, 165, 15, 9},
+      {93, 161, 17, 39, 5},
+      {159, 10, 82, 212, 1}
+    },
+    { {10, 163, 70, 143, 3},
+      {47, 115, 24, 5, 3},
+      {207, 22, 44, 85, 0},
+      {202, 1, 140, 239, 4}
+    },
+    { {106, 225, 111, 19, 7},
+      {55, 87, 244, 133, 5},
+      {236, 143, 104, 117, 6},
+      {170, 18, 254, 174, 12}
+    },
+    { {149, 35, 13, 186, 13},
+      {149, 43, 207, 66, 3},
+      {181, 219, 12, 74, 9},
+      {196, 47, 61, 74, 9}
+    },
+    { {228, 136, 181, 77, 4},
+      {152, 161, 112, 158, 12},
+      {43, 42, 209, 18, 7},
+      {55, 144, 232, 81, 9}
+    },
+    { {121, 10, 75, 108, 10},
+      {58, 120, 47, 200, 8},
+      {83, 109, 37, 9, 14},
+      {17, 63, 65, 229, 12}
+    },
+    { {64, 35, 127, 147, 9},
+      {53, 67, 141, 148, 7},
+      {156, 159, 236, 64, 2},
+      {226, 155, 28, 42, 12}
+    },
+    { {45, 191, 41, 200, 3},
+      {215, 50, 60, 104, 14},
+      {193, 57, 79, 219, 4},
+      {113, 99, 196, 206, 11}
+    },
+    { {202, 214, 76, 54, 0},
+      {106, 5, 158, 163, 1},
+      {6, 195, 38, 181, 3},
+      {140, 87, 154, 5, 6}
+    },
+    { {211, 175, 89, 151, 10},
+      {57, 26, 157, 247, 11},
+      {94, 153, 175, 92, 11},
+      {222, 251, 149, 137, 12}
+    },
+    { {157, 46, 167, 143, 5},
+      {159, 233, 72, 102, 15},
+      {175, 30, 87, 75, 9},
+      {246, 97, 41, 127, 9}
+    },
+    { {34, 211, 98, 6, 7},
+      {108, 86, 120, 1, 5},
+      {230, 4, 108, 180, 4},
+      {168, 1, 230, 163, 6}
+    },
+    { {204, 169, 43, 134, 6},
+      {155, 82, 84, 130, 15},
+      {102, 29, 73, 83, 3},
+      {244, 18, 164, 173, 9}
+    },
+    { {85, 43, 159, 167, 1},
+      {157, 203, 14, 212, 11},
+      {142, 95, 157, 74, 10},
+      {210, 183, 13, 59, 9}
+    },
+    { {203, 178, 173, 205, 11},
+      {95, 177, 29, 207, 6},
+      {219, 59, 84, 221, 3},
+      {111, 59, 136, 223, 10}
+    },
+    { {68, 250, 70, 198, 7},
+      {237, 85, 88, 136, 11},
+      {230, 54, 37, 242, 2},
+      {209, 17, 170, 171, 7}
+    },
+    { {231, 38, 143, 185, 7},
+      {149, 241, 238, 231, 2},
+      {233, 223, 22, 78, 7},
+      {78, 119, 120, 250, 9}
+    },
+    { {36, 175, 23, 170, 2},
+      {145, 115, 58, 48, 11},
+      {69, 94, 143, 82, 4},
+      {208, 197, 204, 232, 9}
+    },
+    { {67, 232, 194, 173, 10},
+      {41, 244, 19, 197, 10},
+      {91, 84, 49, 124, 2},
+      {90, 60, 130, 249, 4}
+    },
+    { {145, 205, 26, 71, 13},
+      {12, 78, 85, 126, 9},
+      {190, 37, 139, 56, 9},
+      {151, 234, 167, 35, 0}
+    },
+    { {104, 5, 2, 194, 10},
+      {2, 82, 33, 168, 3},
+      {84, 52, 10, 1, 6},
+      {193, 88, 68, 164, 0}
+    },
+    { {5, 213, 122, 29, 10},
+      {232, 118, 149, 116, 4},
+      {91, 133, 234, 186, 0},
+      {34, 234, 150, 225, 7}
+    },
+    { {88, 51, 178, 20, 8},
+      {75, 202, 137, 144, 4},
+      {18, 132, 220, 193, 10},
+      {32, 153, 21, 61, 2}
+    },
+    { {207, 23, 24, 178, 4},
+      {194, 2, 206, 243, 3},
+      {36, 209, 142, 143, 3},
+      {204, 247, 52, 4, 3}
+    },
+    { {86, 20, 124, 139, 2},
+      {224, 57, 4, 181, 7},
+      {77, 19, 226, 134, 10},
+      {234, 210, 9, 192, 7}
+    },
+    { {254, 81, 189, 45, 1},
+      {222, 175, 38, 151, 4},
+      {139, 75, 216, 167, 15},
+      {46, 150, 79, 87, 11}
+    },
+    { {48, 238, 165, 168, 4},
+      {17, 173, 122, 32, 14},
+      {33, 90, 87, 112, 12},
+      {112, 69, 235, 88, 8}
+    },
+    { {94, 27, 78, 166, 2},
+      {234, 91, 14, 129, 11},
+      {70, 87, 45, 135, 10},
+      {216, 23, 13, 165, 7}
+    },
+    { {37, 57, 142, 52, 3},
+      {205, 211, 166, 64, 8},
+      {194, 199, 25, 202, 4},
+      {16, 38, 92, 187, 3}
+    },
+    { {71, 238, 53, 187, 2},
+      {145, 53, 154, 245, 15},
+      {77, 218, 199, 126, 2},
+      {250, 245, 154, 200, 9}
+    },
+    { {105, 226, 147, 152, 11},
+      {23, 244, 185, 208, 2},
+      {209, 156, 148, 121, 6},
+      {64, 185, 210, 254, 8}
+    },
+    { {203, 235, 3, 139, 4},
+      {19, 102, 88, 199, 11},
+      {45, 28, 13, 125, 3},
+      {222, 49, 166, 108, 8}
+    },
+    { {151, 33, 193, 117, 9},
+      {189, 138, 131, 79, 0},
+      {154, 232, 56, 78, 9},
+      {15, 44, 21, 27, 13}
+    },
+    { {117, 81, 72, 151, 9},
+      {236, 14, 165, 196, 3},
+      {158, 145, 40, 170, 14},
+      {194, 58, 87, 3, 7}
+    },
+    { {87, 243, 99, 229, 3},
+      {253, 94, 26, 205, 6},
+      {202, 124, 108, 254, 10},
+      {107, 53, 135, 171, 15}
+    },
+    { {174, 100, 20, 104, 0},
+      {131, 37, 34, 59, 0},
+      {1, 98, 130, 103, 5},
+      {13, 196, 74, 76, 1}
+    },
+    { {126, 147, 161, 155, 5},
+      {214, 170, 248, 133, 7},
+      {173, 152, 92, 151, 14},
+      {234, 17, 245, 86, 11}
+    },
+    { {169, 131, 209, 245, 2},
+      {58, 146, 186, 94, 2},
+      {74, 248, 188, 25, 5},
+      {71, 165, 212, 149, 12}
+    },
+    { {100, 91, 1, 175, 9},
+      {220, 38, 43, 132, 11},
+      {159, 88, 13, 162, 6},
+      {210, 29, 70, 67, 11}
+    },
+    { {13, 167, 121, 86, 5},
+      {191, 2, 220, 120, 5},
+      {166, 169, 238, 91, 0},
+      {161, 227, 180, 15, 13}
+    },
+    { {114, 16, 159, 147, 13},
+      {84, 201, 229, 149, 3},
+      {188, 159, 144, 132, 14},
+      {202, 154, 121, 50, 10}
+    },
+    { {141, 12, 71, 198, 11},
+      {190, 81, 1, 106, 11},
+      {214, 62, 35, 11, 1},
+      {213, 104, 8, 167, 13}
+    },
+    { {109, 229, 76, 66, 3},
+      {167, 23, 52, 232, 1},
+      {196, 35, 42, 123, 6},
+      {129, 114, 206, 142, 5}
+    },
+    { {241, 35, 191, 102, 11},
+      {29, 219, 47, 218, 5},
+      {214, 111, 220, 72, 15},
+      {165, 191, 77, 187, 8}
+    },
+    { {180, 231, 234, 99, 7},
+      {165, 222, 126, 46, 5},
+      {236, 101, 126, 114, 13},
+      {167, 71, 231, 186, 5}
+    },
+    { {229, 224, 226, 108, 5},
+      {173, 228, 114, 202, 4},
+      {163, 100, 112, 122, 7},
+      {37, 52, 226, 123, 5}
+    },
+    { {90, 49, 4, 158, 15},
+      {79, 59, 193, 129, 3},
+      {247, 146, 8, 197, 10},
+      {200, 24, 61, 207, 2}
+    },
+    { {137, 248, 81, 23, 11},
+      {127, 20, 145, 86, 9},
+      {222, 136, 161, 249, 1},
+      {150, 168, 146, 143, 14}
+    },
+    { {111, 187, 159, 46, 10},
+      {219, 243, 63, 209, 9},
+      {87, 79, 157, 223, 6},
+      {152, 191, 204, 253, 11}
+    },
+    { {80, 175, 172, 250, 6},
+      {1, 187, 222, 168, 15},
+      {101, 243, 95, 80, 10},
+      {241, 87, 189, 216, 0}
+    },
+    { {181, 113, 7, 57, 6},
+      {209, 127, 226, 70, 0},
+      {105, 206, 8, 234, 13},
+      {6, 36, 127, 232, 11}
+    },
+    { {121, 119, 47, 9, 2},
+      {83, 127, 44, 228, 4},
+      {73, 15, 78, 233, 14},
+      {34, 115, 79, 236, 10}
+    },
+    { {177, 29, 65, 73, 3},
+      {116, 58, 32, 110, 8},
+      {201, 40, 43, 136, 13},
+      {23, 96, 69, 194, 14}
+    },
+    { {29, 227, 35, 74, 14},
+      {147, 126, 89, 72, 5},
+      {117, 44, 76, 123, 8},
+      {161, 41, 167, 236, 9}
+    },
+    { {179, 148, 34, 108, 13},
+      {76, 104, 115, 107, 4},
+      {179, 100, 66, 156, 13},
+      {45, 108, 225, 99, 2}
+    },
+    { {44, 126, 92, 173, 1},
+      {239, 37, 46, 52, 10},
+      {139, 83, 167, 227, 4},
+      {82, 199, 74, 79, 7}
+    },
+    { {95, 115, 48, 151, 13},
+      {207, 14, 201, 213, 7},
+      {190, 144, 204, 239, 10},
+      {234, 185, 55, 15, 3}
+    },
+    { {69, 251, 224, 160, 13},
+      {229, 134, 91, 192, 14},
+      {176, 80, 125, 250, 2},
+      {112, 61, 166, 26, 7}
+    },
+    { {9, 122, 74, 176, 0},
+      {99, 68, 142, 64, 10},
+      {0, 213, 37, 233, 0},
+      {80, 39, 18, 44, 6}
+    },
+    { {179, 119, 146, 163, 10},
+      {65, 222, 43, 119, 3},
+      {92, 84, 158, 236, 13},
+      {206, 237, 71, 184, 2}
+    },
+    { {98, 35, 175, 220, 7},
+      {29, 243, 236, 137, 6},
+      {227, 191, 92, 68, 6},
+      {105, 19, 124, 251, 8}
+    },
+    { {108, 155, 99, 108, 9},
+      {254, 98, 59, 136, 12},
+      {147, 108, 109, 147, 6},
+      {49, 29, 196, 103, 15}
+    },
+    { {155, 78, 142, 46, 9},
+      {14, 237, 15, 99, 9},
+      {151, 71, 23, 45, 9},
+      {156, 111, 11, 119, 0}
+    },
+    { {249, 195, 194, 21, 3},
+      {46, 222, 184, 198, 0},
+      {202, 132, 60, 57, 15},
+      {6, 49, 215, 183, 4}
+    },
+    { {119, 43, 15, 234, 11},
+      {149, 123, 47, 201, 11},
+      {213, 127, 13, 78, 14},
+      {217, 63, 77, 234, 9}
+    },
+    { {102, 250, 154, 171, 4},
+      {193, 228, 126, 149, 11},
+      {45, 85, 149, 246, 6},
+      {218, 151, 226, 120, 3}
+    },
+    { {116, 98, 77, 223, 13},
+      {189, 45, 237, 140, 3},
+      {191, 187, 36, 98, 14},
+      {195, 27, 123, 75, 13}
+    },
+    { {25, 222, 78, 102, 4},
+      {106, 77, 94, 104, 9},
+      {38, 103, 39, 185, 8},
+      {145, 103, 171, 37, 6}
+    },
+    { {148, 41, 230, 53, 14},
+      {169, 219, 195, 6, 12},
+      {122, 198, 121, 66, 9},
+      {54, 12, 61, 185, 5}
+    },
+    { {76, 236, 163, 246, 4},
+      {155, 196, 210, 168, 15},
+      {38, 252, 83, 115, 2},
+      {241, 84, 178, 61, 9}
+    },
+    { {164, 180, 6, 106, 6},
+      {193, 113, 114, 42, 1},
+      {101, 102, 2, 210, 5},
+      {133, 68, 232, 232, 3}
+    },
+    { {30, 86, 88, 215, 4},
+      {234, 12, 204, 61, 3},
+      {46, 177, 166, 167, 8},
+      {203, 195, 51, 5, 7}
+    },
+    { {219, 73, 192, 161, 2},
+      {34, 158, 2, 199, 10},
+      {72, 80, 57, 45, 11},
+      {94, 52, 7, 148, 4}
+    },
+    { {79, 81, 144, 218, 7},
+      {198, 182, 192, 217, 3},
+      {229, 176, 152, 175, 2},
+      {201, 176, 54, 214, 3}
+    },
+    { {1, 67, 44, 173, 5},
+      {12, 39, 78, 68, 6},
+      {171, 83, 76, 40, 0},
+      {98, 39, 46, 67, 0}
+    },
+    { {82, 252, 40, 115, 9},
+      {69, 12, 151, 173, 13},
+      {156, 225, 67, 244, 10},
+      {187, 94, 147, 10, 2}
+    },
+    { {67, 147, 62, 210, 15},
+      {68, 83, 221, 217, 7},
+      {244, 183, 204, 156, 2},
+      {233, 187, 188, 162, 2}
+    },
+    { {107, 7, 29, 172, 0},
+      {26, 35, 46, 241, 2},
+      {3, 91, 142, 13, 6},
+      {72, 247, 76, 69, 8}
+    },
+    { {81, 13, 171, 142, 1},
+      {28, 234, 4, 224, 15},
+      {135, 29, 91, 8, 10},
+      {240, 114, 5, 115, 8}
+    },
+    { {80, 201, 26, 157, 10},
+      {8, 126, 149, 148, 10},
+      {91, 149, 137, 48, 10},
+      {82, 154, 151, 225, 0}
+    },
+    { {95, 229, 148, 45, 0},
+      {139, 175, 18, 245, 0},
+      {11, 66, 154, 127, 10},
+      {10, 244, 143, 93, 1}
+    },
+    { {88, 194, 177, 178, 10},
+      {18, 156, 155, 144, 7},
+      {84, 216, 212, 49, 10},
+      {224, 157, 147, 148, 8}
+    },
+    { {137, 65, 77, 139, 14},
+      {50, 55, 69, 70, 3},
+      {125, 27, 40, 41, 1},
+      {198, 42, 46, 196, 12}
+    },
+    { {132, 10, 38, 120, 5},
+      {132, 97, 202, 10, 12},
+      {161, 230, 69, 2, 1},
+      {53, 5, 56, 98, 1}
+    },
+    { {185, 96, 91, 1, 13},
+      {55, 76, 101, 86, 0},
+      {184, 13, 160, 105, 13},
+      {6, 170, 99, 46, 12}
+    },
+    { {20, 186, 220, 247, 7},
+      {237, 153, 222, 28, 11},
+      {238, 243, 181, 210, 8},
+      {211, 135, 185, 155, 7}
+    },
+    { {246, 219, 203, 198, 4},
+      {248, 206, 124, 139, 11},
+      {38, 61, 61, 182, 15},
+      {221, 19, 231, 49, 15}
+    },
+    { {192, 171, 73, 169, 0},
+      {49, 34, 30, 134, 10},
+      {9, 89, 45, 80, 3},
+      {86, 23, 132, 72, 12}
+    },
+    { {153, 38, 27, 157, 2},
+      {27, 120, 140, 118, 2},
+      {75, 157, 134, 73, 9},
+      {70, 227, 17, 237, 8}
+    },
+    { {97, 25, 251, 19, 6},
+      {112, 210, 228, 212, 13},
+      {108, 141, 249, 136, 6},
+      {178, 178, 116, 176, 14}
+    },
+    { {136, 247, 2, 236, 5},
+      {79, 102, 90, 42, 2},
+      {163, 116, 14, 241, 1},
+      {69, 69, 166, 111, 2}
+    },
+    { {59, 109, 198, 146, 3},
+      {39, 223, 160, 97, 11},
+      {196, 150, 59, 109, 12},
+      {216, 96, 95, 190, 4}
+    },
+    { {78, 98, 149, 182, 0},
+      {155, 133, 138, 145, 3},
+      {6, 218, 148, 103, 2},
+      {200, 149, 26, 29, 9}
+    },
+    { {217, 253, 38, 220, 10},
+      {75, 127, 145, 234, 14},
+      {83, 182, 75, 249, 11},
+      {117, 120, 159, 237, 2}
+    },
+    { {185, 170, 215, 180, 13},
+      {63, 201, 251, 82, 10},
+      {178, 222, 181, 89, 13},
+      {84, 173, 249, 63, 12}
+    },
+    { {77, 237, 86, 136, 15},
+      {167, 119, 81, 240, 10},
+      {241, 22, 171, 123, 2},
+      {80, 248, 174, 238, 5}
+    },
+    { {32, 85, 135, 53, 1},
+      {92, 199, 162, 36, 0},
+      {138, 206, 26, 160, 4},
+      {2, 68, 94, 51, 10}
+    },
+    { {229, 194, 49, 87, 1},
+      {156, 4, 184, 222, 5},
+      {142, 168, 196, 58, 7},
+      {167, 177, 210, 3, 9}
+    },
+    { {203, 185, 136, 37, 6},
+      {75, 146, 86, 199, 8},
+      {106, 65, 25, 221, 3},
+      {30, 54, 164, 157, 2}
+    },
+    { {43, 23, 42, 185, 9},
+      {70, 98, 175, 101, 6},
+      {153, 213, 78, 141, 4},
+      {106, 111, 84, 102, 2}
+    },
+    { {171, 204, 25, 105, 3},
+      {22, 52, 54, 127, 8},
+      {201, 105, 131, 61, 5},
+      {31, 230, 194, 198, 8}
+    },
+    { {136, 158, 50, 170, 15},
+      {70, 112, 91, 50, 15},
+      {245, 84, 199, 145, 1},
+      {244, 205, 160, 230, 2}
+    },
+    { {13, 103, 151, 181, 12},
+      {155, 199, 203, 116, 2},
+      {58, 222, 158, 107, 0},
+      {66, 237, 62, 61, 9}
+    },
+    { {110, 236, 61, 135, 6},
+      {155, 21, 116, 181, 15},
+      {110, 27, 195, 119, 6},
+      {250, 210, 234, 141, 9}
+    },
+    { {163, 18, 150, 137, 14},
+      {64, 241, 105, 87, 2},
+      {121, 22, 148, 140, 5},
+      {78, 169, 104, 240, 2}
+    },
+    { {49, 39, 126, 125, 11},
+      {45, 123, 175, 124, 4},
+      {219, 231, 238, 72, 12},
+      {35, 239, 93, 235, 4}
+    },
+    { {197, 59, 33, 41, 14},
+      {209, 50, 75, 198, 12},
+      {121, 72, 77, 202, 3},
+      {54, 61, 36, 200, 11}
+    },
+    { {14, 92, 116, 153, 15},
+      {230, 53, 193, 53, 14},
+      {249, 146, 227, 167, 0},
+      {122, 200, 58, 198, 7}
+    },
+    { {206, 216, 31, 33, 1},
+      {214, 69, 22, 151, 8},
+      {136, 79, 129, 183, 3},
+      {30, 150, 138, 38, 11}
+    },
+    { {17, 190, 238, 22, 3},
+      {109, 217, 156, 96, 13},
+      {198, 135, 119, 216, 8},
+      {176, 99, 153, 187, 6}
+    },
+    { {91, 246, 119, 192, 6},
+      {115, 93, 88, 249, 6},
+      {96, 62, 230, 253, 10},
+      {105, 241, 171, 172, 14}
+    },
+    { {205, 49, 157, 20, 14},
+      {219, 147, 197, 210, 0},
+      {114, 139, 152, 203, 3},
+      {4, 186, 60, 157, 11}
+    },
+    { {33, 104, 14, 72, 13},
+      {5, 101, 101, 72, 8},
+      {177, 39, 1, 104, 4},
+      {17, 42, 106, 106, 0}
+    },
+    { {40, 39, 132, 250, 11},
+      {7, 179, 171, 40, 3},
+      {213, 242, 30, 65, 4},
+      {193, 77, 92, 222, 0}
+    },
+    { {168, 244, 166, 26, 0},
+      {67, 229, 176, 34, 5},
+      {5, 134, 82, 241, 5},
+      {164, 64, 218, 124, 2}
+    },
+    { {49, 118, 81, 59, 4},
+      {113, 44, 234, 116, 1},
+      {45, 200, 166, 232, 12},
+      {130, 229, 115, 72, 14}
+    },
+    { {247, 105, 206, 110, 2},
+      {169, 255, 38, 203, 9},
+      {71, 103, 57, 110, 15},
+      {157, 54, 79, 249, 5}
+    },
+    { {83, 146, 163, 177, 13},
+      {84, 200, 219, 197, 6},
+      {184, 220, 84, 156, 10},
+      {106, 61, 177, 50, 10}
+    },
+    { {88, 101, 173, 108, 15},
+      {31, 191, 71, 168, 4},
+      {243, 107, 90, 97, 10},
+      {33, 94, 47, 223, 8}
+    },
+    { {190, 115, 121, 11, 0},
+      {243, 46, 44, 23, 5},
+      {13, 9, 236, 231, 13},
+      {174, 131, 71, 76, 15}
+    },
+    { {90, 232, 238, 91, 11},
+      {39, 253, 149, 141, 13},
+      {221, 167, 113, 117, 10},
+      {187, 26, 155, 254, 4}
+    },
+    { {139, 106, 57, 122, 0},
+      {19, 36, 142, 91, 13},
+      {5, 233, 197, 109, 1},
+      {189, 167, 18, 76, 8}
+    },
+    { {163, 233, 94, 124, 14},
+      {41, 119, 247, 91, 8},
+      {115, 231, 169, 124, 5},
+      {29, 174, 254, 233, 4}
+    },
+    { {91, 159, 159, 132, 13},
+      {94, 203, 93, 241, 10},
+      {178, 31, 159, 157, 10},
+      {88, 251, 173, 55, 10}
+    },
+    { {47, 75, 147, 199, 11},
+      {158, 214, 41, 93, 11},
+      {222, 60, 157, 47, 4},
+      {219, 169, 70, 183, 9}
+    },
+    { {76, 117, 32, 169, 6},
+      {195, 54, 66, 164, 6},
+      {105, 80, 74, 227, 2},
+      {98, 84, 38, 204, 3}
+    },
+    { {98, 163, 2, 254, 14},
+      {9, 114, 251, 137, 3},
+      {119, 244, 12, 84, 6},
+      {201, 29, 244, 233, 0}
+    },
+    { {103, 190, 132, 139, 7},
+      {197, 177, 120, 229, 11},
+      {237, 18, 23, 222, 6},
+      {218, 113, 232, 218, 3}
+    },
+    { {183, 81, 31, 133, 12},
+      {216, 79, 101, 87, 2},
+      {58, 31, 136, 174, 13},
+      {78, 170, 111, 33, 11}
+    },
+    { {24, 89, 92, 70, 7},
+      {110, 31, 68, 24, 9},
+      {230, 35, 169, 161, 8},
+      {145, 130, 47, 135, 6}
+    },
+    { {21, 230, 55, 117, 0},
+      {153, 77, 154, 124, 4},
+      {10, 238, 198, 122, 8},
+      {35, 229, 155, 41, 9}
+    },
+    { {152, 85, 193, 87, 13},
+      {126, 142, 193, 46, 1},
+      {190, 168, 58, 161, 9},
+      {135, 72, 55, 23, 14}
+    },
+    { {221, 31, 87, 116, 9},
+      {254, 75, 139, 250, 8},
+      {146, 238, 175, 139, 11},
+      {21, 253, 29, 39, 15}
+    },
+    { {116, 139, 16, 186, 5},
+      {132, 42, 250, 144, 11},
+      {165, 208, 141, 18, 14},
+      {208, 149, 245, 66, 1}
+    },
+    { {28, 253, 149, 152, 1},
+      {215, 175, 144, 48, 10},
+      {129, 154, 155, 243, 8},
+      {80, 192, 159, 94, 11}
+    },
+    { {99, 111, 43, 206, 2},
+      {25, 118, 44, 233, 15},
+      {71, 61, 79, 108, 6},
+      {249, 115, 70, 233, 8}
+    },
+    { {175, 140, 36, 152, 13},
+      {134, 33, 241, 99, 14},
+      {177, 146, 67, 31, 5},
+      {124, 104, 248, 70, 1}
+    },
+    { {33, 45, 73, 54, 5},
+      {61, 2, 230, 96, 9},
+      {166, 201, 43, 72, 4},
+      {144, 102, 116, 11, 12}
+    },
+    { {173, 161, 22, 32, 14},
+      {131, 83, 115, 82, 0},
+      {112, 70, 136, 91, 5},
+      {4, 172, 236, 172, 1}
+    },
+    { {239, 49, 13, 89, 13},
+      {215, 35, 229, 207, 0},
+      {185, 171, 8, 207, 7},
+      {15, 58, 124, 78, 11}
+    },
+    { {155, 50, 155, 65, 14},
+      {83, 216, 77, 95, 0},
+      {120, 45, 148, 205, 9},
+      {15, 171, 33, 188, 10}
+    },
+    { {95, 76, 1, 168, 15},
+      {150, 60, 67, 225, 10},
+      {241, 88, 3, 47, 10},
+      {88, 124, 35, 198, 9}
+    },
+    { {110, 151, 175, 238, 0},
+      {218, 227, 62, 169, 7},
+      {7, 127, 94, 151, 6},
+      {233, 87, 204, 117, 11}
+    },
+    { {129, 68, 91, 180, 8},
+      {56, 68, 135, 114, 2},
+      {18, 221, 162, 40, 1},
+      {68, 238, 18, 33, 12}
+    },
+    { {196, 142, 130, 78, 7},
+      {140, 240, 88, 170, 9},
+      {231, 36, 23, 18, 3},
+      {149, 81, 160, 243, 1}
+    },
+    { {225, 39, 182, 160, 12},
+      {1, 195, 107, 242, 6},
+      {48, 86, 222, 72, 7},
+      {100, 253, 108, 56, 0}
+    },
+    { {88, 201, 151, 188, 7},
+      {30, 255, 210, 144, 10},
+      {227, 222, 153, 49, 10},
+      {80, 148, 191, 247, 8}
+    },
+    { {37, 121, 224, 205, 7},
+      {237, 182, 96, 76, 14},
+      {235, 48, 121, 234, 4},
+      {115, 32, 102, 219, 7}
+    },
+    { {107, 93, 4, 34, 7},
+      {70, 23, 98, 225, 9},
+      {228, 66, 11, 173, 6},
+      {152, 116, 110, 134, 2}
+    },
+    { {109, 39, 67, 156, 2},
+      {187, 114, 168, 224, 2},
+      {67, 156, 46, 75, 6},
+      {64, 113, 84, 237, 13}
+    },
+    { {168, 101, 37, 190, 2},
+      {27, 55, 162, 34, 7},
+      {71, 218, 74, 97, 5},
+      {228, 68, 94, 205, 8}
+    },
+    { {197, 187, 243, 235, 0},
+      {241, 226, 26, 222, 15},
+      {13, 124, 253, 218, 3},
+      {247, 181, 132, 120, 15}
+    },
+    { {224, 138, 63, 86, 10},
+      {24, 81, 189, 154, 13},
+      {86, 175, 197, 16, 7},
+      {181, 155, 216, 161, 8}
+    },
+    { {209, 250, 49, 233, 7},
+      {85, 60, 90, 222, 14},
+      {233, 120, 197, 248, 11},
+      {119, 181, 163, 202, 10}
+    },
+    { {102, 72, 123, 117, 10},
+      {184, 84, 167, 157, 12},
+      {90, 237, 225, 38, 6},
+      {59, 158, 82, 161, 13}
+    },
+    { {152, 233, 237, 143, 5},
+      {63, 175, 84, 6, 15},
+      {175, 27, 121, 113, 9},
+      {246, 2, 175, 95, 12}
+    },
+    { {156, 76, 216, 209, 15},
+      {166, 156, 197, 62, 10},
+      {248, 177, 179, 35, 9},
+      {87, 202, 51, 150, 5}
+    },
+    { {219, 162, 17, 122, 14},
+      {19, 56, 219, 219, 1},
+      {117, 232, 132, 93, 11},
+      {141, 189, 177, 204, 8}
+    },
+    { {252, 157, 45, 143, 13},
+      {222, 43, 117, 166, 15},
+      {191, 27, 75, 147, 15},
+      {246, 90, 237, 71, 11}
+    },
+    { {42, 216, 44, 171, 15},
+      {70, 53, 119, 5, 15},
+      {253, 83, 65, 181, 4},
+      {250, 14, 234, 198, 2}
+    },
+    { {203, 77, 206, 196, 5},
+      {46, 199, 68, 235, 10},
+      {162, 55, 59, 45, 3},
+      {93, 114, 46, 55, 4}
+    },
+    { {212, 230, 126, 105, 10},
+      {161, 125, 31, 190, 4},
+      {89, 103, 230, 114, 11},
+      {39, 223, 139, 232, 5}
+    },
+    { {182, 118, 99, 52, 5},
+      {253, 76, 234, 35, 4},
+      {162, 204, 102, 230, 13},
+      {44, 69, 115, 43, 15}
+    },
+    { {129, 161, 64, 232, 13},
+      {37, 34, 83, 74, 2},
+      {177, 112, 40, 88, 1},
+      {69, 44, 164, 74, 4}
+    },
+    { {36, 248, 181, 42, 13},
+      {213, 165, 115, 16, 13},
+      {181, 74, 209, 242, 4},
+      {176, 140, 234, 90, 11}
+    },
+    { {33, 212, 75, 137, 7},
+      {116, 116, 116, 100, 2},
+      {233, 29, 34, 184, 4},
+      {66, 98, 226, 226, 14}
+    },
+    { {143, 130, 58, 23, 11},
+      {142, 80, 157, 87, 5},
+      {222, 133, 196, 31, 1},
+      {174, 171, 144, 167, 1}
+    },
+    { {246, 113, 26, 188, 10},
+      {201, 126, 167, 147, 2},
+      {83, 213, 136, 230, 15},
+      {76, 158, 87, 233, 3}
+    },
+    { {63, 94, 2, 121, 7},
+      {198, 124, 234, 109, 8},
+      {233, 228, 7, 175, 12},
+      {27, 101, 115, 230, 3}
+    },
+    { {205, 212, 228, 99, 15},
+      {230, 149, 83, 238, 5},
+      {252, 98, 114, 187, 3},
+      {167, 124, 170, 150, 7}
+    },
+    { {89, 70, 5, 49, 5},
+      {22, 13, 202, 228, 0},
+      {168, 202, 6, 41, 10},
+      {2, 117, 59, 6, 8}
+    },
+    { {32, 186, 102, 97, 13},
+      {101, 65, 123, 12, 12},
+      {184, 102, 101, 208, 4},
+      {51, 13, 232, 42, 6}
+    },
+    { {151, 191, 26, 90, 0},
+      {193, 106, 156, 123, 9},
+      {5, 165, 143, 222, 9},
+      {157, 227, 149, 104, 3}
+    },
+    { {126, 66, 218, 161, 8},
+      {162, 204, 47, 149, 2},
+      {24, 85, 180, 39, 14},
+      {74, 159, 67, 52, 5}
+    },
+    { {98, 148, 45, 213, 5},
+      {92, 1, 244, 173, 6},
+      {170, 187, 66, 148, 6},
+      {107, 82, 248, 3, 10}
+    },
+    { {177, 229, 50, 4, 7},
+      {13, 94, 112, 114, 4},
+      {226, 4, 202, 120, 13},
+      {36, 224, 231, 171, 0}
+    },
+    { {222, 100, 233, 20, 12},
+      {187, 140, 197, 163, 4},
+      {50, 137, 114, 103, 11},
+      {44, 90, 51, 29, 13}
+    },
+    { {71, 94, 177, 229, 0},
+      {216, 132, 10, 253, 14},
+      {10, 120, 215, 174, 2},
+      {123, 245, 2, 17, 11}
+    },
+    { {25, 165, 108, 166, 9},
+      {47, 11, 23, 96, 7},
+      {150, 83, 106, 89, 8},
+      {224, 110, 141, 15, 4}
+    },
+    { {149, 5, 117, 79, 13},
+      {188, 43, 65, 126, 5},
+      {191, 42, 234, 10, 9},
+      {167, 232, 45, 67, 13}
+    },
+    { {54, 171, 61, 147, 0},
+      {145, 11, 188, 21, 15},
+      {12, 155, 205, 86, 12},
+      {250, 131, 221, 8, 9}
+    },
+    { {87, 132, 157, 120, 1},
+      {148, 169, 150, 249, 0},
+      {129, 235, 146, 30, 10},
+      {9, 246, 153, 82, 9}
+    },
+    { {164, 135, 244, 206, 4},
+      {168, 163, 120, 58, 7},
+      {39, 50, 254, 18, 5},
+      {229, 193, 236, 81, 5}
+    },
+    { {177, 1, 150, 215, 4},
+      {8, 203, 224, 94, 3},
+      {46, 182, 152, 8, 13},
+      {199, 160, 125, 49, 0}
+    },
+    { {202, 139, 220, 248, 6},
+      {34, 179, 222, 155, 10},
+      {97, 243, 189, 21, 3},
+      {93, 151, 188, 212, 4}
+    },
+    { {241, 104, 15, 187, 1},
+      {21, 109, 166, 198, 11},
+      {141, 223, 1, 104, 15},
+      {214, 54, 91, 106, 8}
+    },
+    { {119, 235, 139, 132, 9},
+      {157, 206, 61, 193, 10},
+      {146, 29, 29, 126, 14},
+      {88, 59, 199, 59, 9}
+    },
+    { {2, 83, 18, 189, 4},
+      {72, 102, 202, 21, 2},
+      {43, 212, 140, 164, 0},
+      {74, 133, 54, 97, 2}
+    },
+    { {29, 42, 141, 92, 1},
+      {159, 169, 140, 72, 8},
+      {131, 171, 21, 75, 8},
+      {17, 35, 25, 95, 9}
+    },
+    { {39, 117, 108, 47, 10},
+      {233, 55, 39, 101, 5},
+      {95, 67, 106, 238, 4},
+      {170, 110, 78, 201, 7}
+    },
+    { {61, 80, 83, 188, 9},
+      {254, 108, 163, 80, 2},
+      {147, 220, 160, 171, 12},
+      {64, 172, 83, 103, 15}
+    },
+    { {120, 181, 174, 182, 4},
+      {75, 203, 246, 160, 7},
+      {38, 215, 90, 209, 14},
+      {224, 86, 253, 61, 2}
+    },
+    { {42, 93, 133, 78, 1},
+      {94, 167, 32, 41, 9},
+      {135, 42, 27, 165, 4},
+      {153, 64, 78, 87, 10}
+    },
+    { {0, 239, 149, 206, 12},
+      {25, 167, 89, 56, 11},
+      {55, 58, 159, 112, 0},
+      {209, 201, 174, 89, 8}
+    },
+    { {198, 248, 201, 176, 10},
+      {241, 148, 151, 131, 10},
+      {80, 217, 49, 246, 3},
+      {92, 30, 146, 152, 15}
+    },
+    { {52, 138, 244, 180, 8},
+      {168, 137, 187, 16, 14},
+      {18, 210, 245, 18, 12},
+      {112, 141, 217, 17, 5}
+    },
+    { {154, 221, 191, 118, 3},
+      {94, 223, 150, 59, 13},
+      {198, 239, 219, 181, 9},
+      {189, 198, 159, 183, 10}
+    },
+    { {68, 183, 153, 113, 1},
+      {213, 130, 158, 188, 0},
+      {136, 233, 158, 210, 2},
+      {3, 215, 148, 26, 11}
+    },
+    { {53, 31, 237, 192, 9},
+      {244, 139, 45, 104, 14},
+      {144, 59, 127, 138, 12},
+      {113, 107, 77, 18, 15}
+    },
+    { {240, 132, 133, 185, 5},
+      {20, 169, 242, 166, 2},
+      {169, 218, 18, 16, 15},
+      {70, 84, 249, 82, 8}
+    },
+    { {130, 188, 93, 116, 5},
+      {125, 1, 214, 59, 8},
+      {162, 235, 163, 212, 1},
+      {29, 198, 184, 11, 14}
+    },
+    { {58, 134, 179, 151, 15},
+      {30, 216, 249, 53, 7},
+      {254, 156, 214, 21, 12},
+      {234, 201, 241, 183, 8}
+    },
+    { {140, 232, 137, 29, 15},
+      {159, 180, 213, 6, 8},
+      {251, 137, 17, 115, 1},
+      {22, 10, 178, 223, 9}
+    },
+    { {63, 123, 205, 83, 8},
+      {243, 143, 173, 77, 9},
+      {28, 171, 61, 239, 12},
+      {155, 43, 95, 28, 15}
+    },
+    { {180, 13, 145, 70, 7},
+      {156, 154, 96, 58, 9},
+      {230, 40, 155, 2, 13},
+      {149, 192, 101, 147, 9}
+    },
+    { {109, 172, 86, 182, 6},
+      {171, 81, 242, 240, 11},
+      {102, 214, 163, 91, 6},
+      {208, 244, 248, 173, 5}
+    },
+    { {88, 149, 105, 0, 13},
+      {118, 10, 85, 160, 4},
+      {176, 9, 106, 145, 10},
+      {32, 90, 165, 6, 14}
+    },
+    { {76, 163, 63, 89, 3},
+      {151, 115, 156, 156, 4},
+      {201, 175, 204, 83, 2},
+      {35, 147, 156, 238, 9}
+    },
+    { {53, 167, 215, 80, 1},
+      {181, 203, 184, 120, 0},
+      {128, 174, 190, 90, 12},
+      {1, 225, 221, 58, 13}
+    },
+    { {22, 233, 116, 244, 11},
+      {173, 31, 147, 25, 14},
+      {210, 242, 233, 118, 8},
+      {121, 140, 159, 139, 5}
+    },
+    { {106, 219, 126, 99, 3},
+      {102, 87, 62, 157, 13},
+      {204, 103, 237, 181, 6},
+      {187, 151, 206, 166, 6}
+    },
+    { {172, 254, 199, 138, 5},
+      {247, 229, 120, 34, 11},
+      {165, 30, 55, 243, 5},
+      {212, 65, 234, 126, 15}
+    },
+    { {195, 109, 112, 53, 6},
+      {41, 22, 194, 247, 12},
+      {106, 192, 235, 108, 3},
+      {62, 244, 54, 137, 4}
+    },
+    { {133, 82, 84, 245, 6},
+      {232, 21, 202, 94, 2},
+      {106, 242, 164, 170, 1},
+      {71, 165, 58, 129, 7}
+    },
+    { {211, 112, 148, 110, 7},
+      {77, 189, 66, 219, 1},
+      {231, 98, 144, 236, 11},
+      {141, 180, 43, 219, 2}
+    },
+    { {157, 177, 206, 126, 12},
+      {235, 235, 215, 74, 1},
+      {55, 231, 56, 219, 9},
+      {133, 46, 189, 125, 7}
+    },
+    { {163, 136, 217, 180, 14},
+      {56, 144, 247, 83, 10},
+      {114, 217, 177, 28, 5},
+      {92, 174, 240, 145, 12}
+    },
+    { {98, 252, 134, 118, 14},
+      {73, 213, 243, 169, 9},
+      {118, 230, 19, 244, 6},
+      {153, 92, 250, 185, 2}
+    },
+    { {209, 228, 206, 15, 2},
+      {41, 253, 20, 230, 1},
+      {79, 7, 50, 120, 11},
+      {134, 114, 139, 249, 4}
+    },
+    { {224, 197, 119, 135, 0},
+      {56, 71, 48, 182, 7},
+      {14, 30, 234, 48, 7},
+      {230, 208, 206, 33, 12}
+    },
+    { {136, 137, 241, 121, 7},
+      {54, 178, 210, 30, 12},
+      {233, 232, 249, 17, 1},
+      {55, 132, 180, 214, 12}
+    },
+    { {175, 103, 124, 158, 0},
+      {171, 39, 172, 115, 7},
+      {7, 147, 238, 111, 5},
+      {236, 227, 94, 77, 5}
+    },
+    { {250, 135, 32, 206, 8},
+      {10, 42, 57, 171, 7},
+      {23, 48, 78, 21, 15},
+      {237, 89, 197, 69, 0}
+    },
+    { {32, 136, 108, 197, 14},
+      {40, 17, 117, 12, 14},
+      {122, 51, 97, 16, 4},
+      {115, 10, 232, 129, 4}
+    },
+    { {26, 153, 204, 140, 14},
+      {106, 187, 85, 1, 10},
+      {115, 19, 57, 149, 8},
+      {88, 10, 173, 213, 6}
+    },
+    { {136, 165, 101, 91, 1},
+      {55, 35, 144, 46, 5},
+      {141, 170, 106, 81, 1},
+      {167, 64, 156, 78, 12}
+    },
+    { {214, 247, 236, 2, 5},
+      {229, 143, 92, 163, 5},
+      {164, 3, 126, 246, 11},
+      {172, 83, 175, 26, 7}
+    },
+    { {244, 246, 145, 8, 4},
+      {209, 172, 120, 178, 0},
+      {33, 8, 150, 242, 15},
+      {4, 209, 227, 88, 11}
+    },
+    { {76, 10, 202, 63, 5},
+      {174, 224, 206, 132, 9},
+      {175, 197, 53, 3, 2},
+      {146, 23, 48, 119, 5}
+    },
+    { {31, 5, 164, 12, 7},
+      {142, 187, 64, 97, 4},
+      {227, 2, 90, 15, 8},
+      {40, 96, 45, 215, 1}
+    },
+    { {250, 93, 132, 124, 6},
+      {74, 191, 226, 171, 8},
+      {99, 226, 27, 165, 15},
+      {29, 84, 127, 213, 2}
+    },
+    { {19, 29, 173, 215, 12},
+      {88, 139, 197, 109, 15},
+      {62, 187, 91, 140, 8},
+      {251, 106, 61, 17, 10}
+    },
+    { {195, 96, 214, 57, 15},
+      {37, 245, 195, 215, 0},
+      {249, 198, 176, 108, 3},
+      {14, 188, 58, 250, 4}
+    },
+    { {126, 199, 122, 149, 3},
+      {174, 94, 188, 181, 6},
+      {202, 149, 238, 55, 14},
+      {106, 211, 215, 167, 5}
+    },
+    { {45, 212, 161, 248, 1},
+      {214, 164, 178, 104, 6},
+      {129, 248, 82, 187, 4},
+      {97, 100, 210, 86, 11}
+    },
+    { {196, 27, 169, 22, 11},
+      {220, 146, 141, 130, 13},
+      {214, 137, 93, 130, 3},
+      {180, 27, 20, 147, 11}
+    },
+    { {174, 83, 48, 32, 14},
+      {194, 22, 107, 19, 4},
+      {112, 64, 204, 167, 5},
+      {44, 141, 102, 132, 3}
+    },
+    { {137, 195, 118, 107, 2},
+      {34, 119, 26, 94, 5},
+      {77, 102, 236, 57, 1},
+      {167, 165, 142, 228, 4}
+    },
+    { {17, 167, 104, 69, 2},
+      {41, 26, 28, 108, 4},
+      {74, 33, 110, 88, 8},
+      {35, 99, 133, 137, 4}
+    },
+    { {115, 24, 54, 184, 10},
+      {64, 121, 163, 209, 14},
+      {81, 214, 193, 140, 14},
+      {120, 188, 89, 224, 2}
+    },
+    { {152, 195, 136, 238, 2},
+      {10, 190, 30, 10, 3},
+      {71, 113, 28, 49, 9},
+      {197, 7, 135, 213, 0}
+    },
+    { {50, 158, 254, 117, 6},
+      {104, 217, 254, 61, 12},
+      {106, 231, 247, 148, 12},
+      {59, 199, 249, 177, 6}
+    },
+    { {235, 41, 103, 213, 2},
+      {59, 83, 160, 207, 14},
+      {74, 190, 105, 77, 7},
+      {127, 48, 92, 173, 12}
+    },
+    { {118, 246, 246, 147, 13},
+      {229, 205, 249, 181, 7},
+      {188, 150, 246, 246, 14},
+      {234, 217, 251, 58, 7}
+    },
+    { {75, 54, 229, 94, 10},
+      {123, 177, 137, 233, 5},
+      {87, 170, 118, 205, 2},
+      {169, 121, 24, 221, 14}
+    },
+    { {18, 100, 241, 41, 15},
+      {53, 188, 67, 53, 4},
+      {249, 72, 242, 100, 8},
+      {42, 204, 35, 218, 12}
+    },
+    { {195, 216, 179, 216, 12},
+      {80, 228, 209, 219, 14},
+      {49, 188, 209, 188, 3},
+      {125, 184, 178, 112, 10}
+    },
+    { {184, 252, 222, 50, 9},
+      {103, 205, 183, 50, 9},
+      {148, 199, 179, 241, 13},
+      {148, 206, 219, 62, 6}
+    },
+    { {53, 97, 247, 116, 12},
+      {185, 207, 227, 88, 4},
+      {50, 238, 248, 106, 12},
+      {33, 172, 127, 57, 13}
+    },
+    { {116, 255, 31, 22, 6},
+      {217, 95, 252, 176, 9},
+      {102, 143, 143, 242, 14},
+      {144, 211, 255, 169, 11}
+    },
+    { {29, 80, 232, 123, 6},
+      {226, 188, 198, 76, 5},
+      {109, 225, 112, 171, 8},
+      {163, 38, 51, 212, 7}
+    },
+    { {71, 201, 216, 44, 9},
+      {172, 166, 23, 209, 8},
+      {147, 65, 185, 62, 2},
+      {24, 190, 134, 83, 5}
+    },
+    { {198, 131, 135, 46, 9},
+      {156, 227, 27, 131, 1},
+      {151, 78, 28, 22, 3},
+      {140, 29, 140, 115, 9}
+    },
+    { {182, 245, 65, 140, 14},
+      {249, 62, 113, 35, 2},
+      {115, 24, 42, 246, 13},
+      {76, 72, 231, 201, 15}
+    },
+    { {209, 45, 250, 27, 10},
+      {33, 250, 133, 246, 13},
+      {93, 133, 251, 72, 11},
+      {182, 250, 21, 248, 4}
+    },
+    { {123, 222, 164, 209, 14},
+      {66, 157, 249, 237, 14},
+      {120, 178, 87, 189, 14},
+      {123, 121, 251, 148, 2}
+    },
+    { {148, 215, 11, 206, 8},
+      {216, 110, 29, 42, 3},
+      {23, 61, 14, 178, 9},
+      {197, 75, 135, 97, 11}
+    },
+    { {139, 161, 235, 181, 10},
+      {59, 210, 151, 71, 6},
+      {90, 221, 120, 93, 1},
+      {110, 46, 148, 189, 12}
+    },
+    { {2, 76, 23, 111, 5},
+      {28, 101, 66, 61, 9},
+      {175, 110, 131, 36, 0},
+      {155, 196, 42, 99, 8}
+    },
+    { {54, 104, 158, 115, 11},
+      {133, 221, 167, 29, 9},
+      {220, 231, 145, 102, 12},
+      {155, 142, 91, 186, 1}
+    },
+    { {208, 33, 104, 228, 4},
+      {41, 10, 70, 138, 6},
+      {34, 113, 104, 64, 11},
+      {101, 22, 37, 9, 4}
+    },
+    { {155, 143, 16, 45, 14},
+      {10, 58, 91, 119, 8},
+      {123, 64, 143, 29, 9},
+      {30, 237, 165, 197, 0}
+    },
+    { {126, 132, 92, 39, 11},
+      {174, 25, 55, 181, 1},
+      {222, 67, 162, 23, 14},
+      {138, 222, 201, 135, 5}
+    },
+    { {118, 223, 8, 118, 12},
+      {200, 14, 255, 169, 9},
+      {54, 225, 15, 182, 14},
+      {153, 95, 247, 1, 3}
+    },
+    { {251, 188, 21, 149, 7},
+      {95, 25, 240, 247, 10},
+      {234, 154, 131, 221, 15},
+      {94, 240, 249, 143, 10}
+    },
+    { {70, 128, 175, 59, 2},
+      {144, 241, 150, 133, 5},
+      {77, 207, 80, 22, 2},
+      {170, 22, 152, 240, 9}
+    },
+    { {209, 94, 13, 85, 9},
+      {92, 13, 141, 238, 8},
+      {154, 171, 7, 168, 11},
+      {23, 123, 27, 3, 10}
+    },
+    { {140, 34, 108, 129, 4},
+      {163, 1, 76, 6, 6},
+      {40, 19, 100, 67, 1},
+      {102, 3, 40, 12, 5}
+    },
+    { {118, 43, 180, 156, 1},
+      {141, 171, 168, 145, 14},
+      {131, 146, 221, 70, 14},
+      {120, 145, 93, 91, 1}
+    },
+    { {115, 86, 122, 41, 0},
+      {96, 108, 46, 245, 4},
+      {9, 69, 230, 172, 14},
+      {42, 247, 67, 96, 6}
+    },
+    { {65, 92, 222, 11, 1},
+      {100, 229, 4, 244, 9},
+      {141, 7, 179, 168, 2},
+      {146, 242, 10, 114, 6}
+    },
+    { {9, 152, 244, 128, 11},
+      {102, 145, 17, 80, 14},
+      {208, 18, 241, 153, 0},
+      {112, 168, 136, 150, 6}
+    },
+    { {227, 53, 25, 14, 13},
+      {93, 34, 101, 243, 1},
+      {183, 9, 138, 204, 7},
+      {140, 250, 100, 75, 10}
+    },
+    { {54, 133, 243, 244, 3},
+      {188, 218, 178, 57, 6},
+      {194, 252, 250, 22, 12},
+      {105, 196, 213, 179, 13}
+    },
+    { {149, 140, 227, 231, 8},
+      {184, 200, 19, 110, 15},
+      {30, 124, 115, 26, 9},
+      {247, 108, 129, 49, 13}
+    },
+    { {119, 22, 87, 104, 15},
+      {244, 121, 107, 249, 0},
+      {241, 110, 166, 142, 14},
+      {9, 253, 105, 226, 15}
+    },
+    { {192, 211, 150, 95, 4},
+      {72, 231, 216, 158, 1},
+      {47, 166, 156, 176, 3},
+      {135, 145, 190, 113, 2}
+    },
+    { {212, 159, 135, 115, 2},
+      {208, 219, 154, 174, 9},
+      {76, 238, 31, 146, 11},
+      {151, 85, 157, 176, 11}
+    },
+    { {69, 191, 48, 71, 8},
+      {201, 2, 25, 252, 13},
+      {30, 32, 207, 218, 2},
+      {179, 249, 132, 9, 3}
+    },
+    { {178, 247, 139, 151, 9},
+      {93, 206, 189, 39, 3},
+      {158, 157, 30, 244, 13},
+      {206, 75, 215, 59, 10}
+    },
+    { {182, 81, 172, 193, 7},
+      {196, 159, 100, 15, 6},
+      {232, 51, 88, 166, 13},
+      {111, 2, 111, 146, 3}
+    },
+    { {18, 188, 225, 89, 10},
+      {113, 184, 145, 45, 12},
+      {89, 168, 115, 212, 8},
+      {59, 72, 145, 216, 14}
+    },
+    { {142, 109, 66, 22, 5},
+      {175, 70, 192, 35, 9},
+      {166, 132, 43, 103, 1},
+      {156, 64, 54, 47, 5}
+    },
+    { {247, 219, 218, 17, 6},
+      {224, 222, 252, 215, 8},
+      {104, 133, 189, 190, 15},
+      {30, 179, 247, 176, 7}
+    },
+    { {95, 40, 2, 124, 14},
+      {139, 120, 195, 201, 8},
+      {115, 228, 1, 79, 10},
+      {25, 60, 49, 237, 1}
+    },
+    { {2, 18, 169, 157, 14},
+      {88, 176, 205, 5, 6},
+      {123, 153, 84, 132, 0},
+      {106, 11, 48, 209, 10}
+    },
+    { {191, 254, 168, 18, 10},
+      {195, 156, 189, 99, 13},
+      {84, 129, 87, 255, 13},
+      {188, 107, 211, 156, 3}
+    },
+    { {186, 49, 92, 161, 1},
+      {103, 11, 38, 23, 2},
+      {136, 83, 168, 197, 13},
+      {78, 134, 77, 14, 6}
+    },
+    { {7, 242, 225, 29, 7},
+      {253, 180, 216, 69, 4},
+      {235, 136, 116, 254, 0},
+      {42, 33, 178, 219, 15}
+    },
+    { {234, 79, 43, 164, 13},
+      {30, 70, 111, 163, 14},
+      {178, 93, 79, 37, 7},
+      {124, 95, 102, 39, 8}
+    },
+    { {165, 190, 34, 214, 12},
+      {201, 64, 249, 106, 15},
+      {54, 180, 71, 218, 5},
+      {245, 105, 240, 41, 3}
+    },
+    { {241, 169, 225, 184, 14},
+      {49, 186, 243, 194, 14},
+      {113, 216, 121, 88, 15},
+      {116, 60, 245, 216, 12}
+    },
+    { {202, 168, 155, 183, 7},
+      {31, 208, 214, 151, 11},
+      {238, 221, 145, 85, 3},
+      {222, 150, 176, 191, 8}
+    },
+    { {84, 134, 196, 245, 2},
+      {168, 153, 154, 172, 2},
+      {74, 242, 54, 18, 10},
+      {67, 85, 153, 145, 5}
+    },
+    { {53, 121, 76, 30, 4},
+      {233, 47, 228, 64, 9},
+      {39, 131, 41, 234, 12},
+      {144, 34, 127, 73, 7}
+    },
+    { {110, 216, 72, 137, 8},
+      {226, 36, 53, 133, 10},
+      {25, 17, 33, 183, 6},
+      {90, 26, 194, 68, 7}
+    },
+    { {186, 232, 137, 103, 6},
+      {27, 156, 118, 15, 9},
+      {110, 105, 17, 117, 13},
+      {159, 6, 227, 157, 8}
+    },
+    { {148, 192, 40, 189, 0},
+      {136, 44, 150, 6, 6},
+      {11, 209, 64, 50, 9},
+      {102, 6, 147, 65, 1}
+    },
+    { {115, 76, 162, 183, 6},
+      {8, 220, 226, 229, 15},
+      {110, 212, 83, 44, 14},
+      {250, 116, 115, 177, 0}
+    },
+    { {47, 241, 60, 122, 11},
+      {199, 55, 183, 89, 5},
+      {213, 227, 200, 255, 4},
+      {169, 174, 222, 206, 3}
+    },
+    { {204, 2, 99, 100, 7},
+      {190, 80, 74, 138, 4},
+      {226, 108, 100, 3, 3},
+      {37, 21, 32, 167, 13}
+    },
+    { {222, 144, 69, 41, 2},
+      {242, 57, 18, 135, 0},
+      {73, 74, 32, 151, 11},
+      {14, 20, 137, 196, 15}
+    },
+    { {2, 43, 108, 122, 15},
+      {37, 51, 207, 9, 13},
+      {245, 227, 109, 68, 0},
+      {185, 15, 60, 202, 4}
+    },
+    { {64, 75, 24, 30, 13},
+      {12, 38, 205, 144, 9},
+      {183, 129, 141, 32, 2},
+      {144, 155, 54, 67, 0}
+    },
+    { {44, 49, 42, 198, 5},
+      {207, 66, 100, 8, 7},
+      {166, 53, 72, 195, 4},
+      {225, 2, 100, 47, 3}
+    },
+    { {191, 189, 15, 65, 6},
+      {211, 91, 116, 111, 8},
+      {104, 47, 11, 223, 13},
+      {31, 98, 237, 172, 11}
+    },
+    { {232, 58, 99, 203, 12},
+      {115, 96, 105, 142, 15},
+      {61, 60, 101, 193, 7},
+      {247, 25, 96, 108, 14}
+    },
+    { {231, 89, 156, 35, 2},
+      {192, 151, 38, 215, 9},
+      {76, 67, 153, 174, 7},
+      {158, 182, 78, 144, 3}
+    },
+    { {255, 230, 113, 141, 6},
+      {187, 60, 120, 247, 6},
+      {107, 24, 230, 127, 15},
+      {110, 241, 227, 205, 13}
+    },
+    { {197, 136, 65, 238, 2},
+      {184, 48, 18, 202, 11},
+      {71, 120, 33, 26, 3},
+      {213, 52, 128, 193, 13}
+    },
+    { {171, 180, 217, 16, 2},
+      {115, 144, 180, 115, 0},
+      {64, 137, 178, 221, 5},
+      {12, 226, 208, 156, 14}
+    },
+    { {10, 23, 123, 120, 4},
+      {114, 98, 206, 57, 4},
+      {33, 237, 238, 133, 0},
+      {41, 199, 52, 100, 14}
+    },
+    { {78, 123, 115, 156, 14},
+      {251, 118, 201, 145, 14},
+      {115, 156, 237, 231, 2},
+      {120, 153, 54, 237, 15}
+    },
+    { {34, 227, 251, 26, 1},
+      {53, 230, 188, 17, 5},
+      {133, 141, 252, 116, 4},
+      {168, 131, 214, 122, 12}
+    },
+    { {54, 93, 186, 61, 2},
+      {200, 254, 166, 53, 12},
+      {75, 197, 219, 166, 12},
+      {58, 198, 87, 241, 3}
+    },
+    { {59, 220, 189, 56, 4},
+      {82, 173, 246, 113, 12},
+      {33, 203, 211, 189, 12},
+      {56, 230, 251, 84, 10}
+    },
+    { {200, 199, 188, 19, 5},
+      {6, 135, 220, 182, 5},
+      {172, 131, 222, 49, 3},
+      {166, 211, 190, 22, 0}
+    },
+    { {91, 16, 250, 200, 6},
+      {98, 248, 68, 217, 6},
+      {97, 53, 240, 141, 10},
+      {105, 178, 33, 244, 6}
+    },
+    { {208, 249, 92, 92, 11},
+      {109, 63, 149, 154, 8},
+      {211, 163, 169, 240, 11},
+      {21, 154, 159, 203, 6}
+    },
+    { {153, 6, 142, 77, 7},
+      {14, 249, 76, 110, 0},
+      {235, 39, 22, 9, 9},
+      {7, 99, 41, 247, 0}
+    },
+    { {200, 39, 17, 208, 2},
+      {19, 18, 136, 186, 2},
+      {64, 184, 142, 65, 3},
+      {69, 209, 20, 140, 8}
+    },
+    { {164, 84, 34, 73, 9},
+      {196, 100, 33, 46, 4},
+      {153, 36, 66, 162, 5},
+      {39, 72, 66, 98, 3}
+    },
+    { {169, 103, 185, 198, 3},
+      {31, 150, 44, 122, 7},
+      {198, 57, 222, 105, 5},
+      {229, 227, 70, 159, 8}
+    },
+    { {227, 227, 61, 193, 6},
+      {17, 23, 124, 223, 6},
+      {104, 59, 204, 124, 7},
+      {111, 179, 238, 136, 8}
+    },
+    { {242, 227, 250, 36, 6},
+      {41, 222, 126, 147, 4},
+      {98, 69, 252, 116, 15},
+      {44, 151, 231, 185, 4}
+    },
+    { {171, 214, 110, 194, 10},
+      {98, 85, 61, 107, 7},
+      {84, 55, 102, 189, 5},
+      {237, 107, 202, 164, 6}
+    },
+    { {150, 166, 172, 174, 12},
+      {137, 169, 95, 35, 7},
+      {55, 83, 86, 86, 9},
+      {236, 79, 169, 89, 1}
+    },
+    { {17, 94, 218, 37, 15},
+      {108, 220, 79, 116, 8},
+      {250, 69, 183, 168, 8},
+      {18, 239, 35, 179, 6}
+    },
+    { {224, 72, 217, 79, 9},
+      {60, 164, 37, 158, 9},
+      {159, 41, 177, 32, 7},
+      {151, 154, 66, 83, 12}
+    },
+    { {62, 162, 162, 69, 13},
+      {143, 200, 121, 13, 4},
+      {186, 36, 84, 87, 12},
+      {43, 9, 225, 63, 1}
+    },
+    { {147, 122, 113, 157, 10},
+      {121, 60, 137, 87, 14},
+      {91, 152, 229, 236, 9},
+      {126, 169, 19, 201, 14}
+    },
+    { {109, 101, 53, 32, 4},
+      {147, 7, 98, 240, 4},
+      {32, 74, 202, 107, 6},
+      {32, 244, 110, 12, 9}
+    },
+    { {218, 6, 151, 74, 11},
+      {22, 249, 9, 187, 1},
+      {213, 46, 150, 5, 11},
+      {141, 217, 9, 246, 8}
+    },
+    { {20, 176, 37, 32, 10},
+      {209, 25, 19, 0, 4},
+      {80, 74, 64, 210, 8},
+      {32, 12, 137, 136, 11}
+    },
+    { {122, 150, 135, 109, 5},
+      {94, 233, 122, 173, 0},
+      {171, 110, 22, 149, 14},
+      {11, 85, 233, 119, 10}
+    },
+    { {221, 120, 18, 100, 5},
+      {207, 76, 66, 218, 8},
+      {162, 100, 129, 235, 11},
+      {21, 180, 35, 47, 3}
+    },
+    { {130, 195, 122, 162, 9},
+      {36, 70, 31, 19, 7},
+      {148, 85, 236, 52, 1},
+      {236, 143, 134, 34, 4}
+    },
+    { {151, 25, 250, 15, 4},
+      {232, 234, 68, 87, 13},
+      {47, 5, 249, 142, 9},
+      {190, 162, 37, 113, 7}
+    },
+    { {58, 108, 193, 181, 7},
+      {63, 156, 226, 37, 10},
+      {234, 216, 51, 101, 12},
+      {90, 68, 115, 159, 12}
+    },
+    { {97, 33, 177, 73, 13},
+      {21, 162, 97, 220, 4},
+      {185, 40, 216, 72, 6},
+      {35, 184, 100, 90, 8}
+    },
+    { {208, 123, 6, 29, 14},
+      {73, 127, 201, 134, 8},
+      {123, 134, 13, 224, 11},
+      {22, 25, 63, 233, 2}
+    },
+    { {69, 190, 247, 38, 9},
+      {253, 193, 27, 240, 13},
+      {150, 78, 247, 218, 2},
+      {176, 253, 136, 59, 15}
+    },
+    { {157, 70, 148, 66, 4},
+      {130, 141, 72, 122, 1},
+      {36, 34, 150, 43, 9},
+      {133, 225, 43, 20, 1}
+    },
+    { {77, 251, 186, 241, 4},
+      {195, 198, 222, 220, 14},
+      {40, 245, 221, 251, 2},
+      {115, 183, 182, 60, 3}
+    },
+    { {200, 236, 99, 163, 1},
+      {55, 68, 18, 166, 15},
+      {140, 92, 99, 113, 3},
+      {246, 84, 130, 46, 12}
+    },
+    { {41, 38, 49, 96, 9},
+      {23, 0, 43, 120, 4},
+      {144, 104, 198, 73, 4},
+      {33, 237, 64, 14, 8}
+    },
+    { {34, 234, 181, 80, 10},
+      {17, 149, 185, 25, 12},
+      {80, 170, 213, 116, 4},
+      {57, 137, 218, 152, 8}
+    },
+    { {12, 83, 62, 124, 9},
+      {206, 103, 143, 24, 4},
+      {147, 231, 204, 163, 0},
+      {33, 143, 30, 103, 3}
+    },
+    { {241, 209, 122, 65, 9},
+      {100, 78, 53, 222, 4},
+      {152, 37, 232, 184, 15},
+      {39, 186, 199, 34, 6}
+    },
+    { {190, 41, 45, 21, 12},
+      {155, 11, 229, 7, 12},
+      {58, 139, 73, 71, 13},
+      {62, 10, 125, 13, 9}
+    },
+    { {173, 236, 230, 5, 15},
+      {175, 213, 113, 102, 12},
+      {250, 6, 115, 123, 5},
+      {54, 104, 234, 191, 5}
+    },
+    { {23, 198, 147, 157, 3},
+      {156, 252, 152, 117, 2},
+      {203, 156, 150, 62, 8},
+      {74, 225, 147, 243, 9}
+    },
+    { {76, 195, 212, 88, 9},
+      {166, 167, 153, 152, 0},
+      {145, 162, 188, 51, 2},
+      {1, 153, 158, 86, 5}
+    },
+    { {154, 214, 102, 33, 4},
+      {98, 77, 90, 39, 4},
+      {40, 70, 102, 181, 9},
+      {46, 69, 171, 36, 6}
+    },
+    { {19, 133, 65, 215, 3},
+      {60, 26, 144, 109, 3},
+      {206, 184, 42, 28, 8},
+      {203, 96, 149, 131, 12}
+    },
+    { {86, 15, 151, 244, 5},
+      {156, 203, 202, 185, 10},
+      {162, 254, 159, 6, 10},
+      {89, 213, 61, 51, 9}
+    },
+    { {166, 192, 165, 246, 0},
+      {152, 133, 178, 11, 7},
+      {6, 250, 80, 54, 5},
+      {237, 4, 218, 17, 9}
+    },
+    { {95, 226, 229, 89, 8},
+      {179, 173, 153, 205, 4},
+      {25, 170, 116, 127, 10},
+      {43, 57, 155, 92, 13}
+    },
+    { {67, 190, 136, 118, 5},
+      {77, 128, 222, 233, 9},
+      {166, 225, 23, 220, 2},
+      {153, 119, 176, 27, 2}
+    },
+    { {8, 144, 129, 205, 4},
+      {90, 160, 80, 12, 2},
+      {43, 56, 16, 145, 0},
+      {67, 0, 160, 85, 10}
+    },
+    { {77, 234, 23, 239, 15},
+      {159, 117, 91, 220, 11},
+      {255, 126, 133, 123, 2},
+      {211, 189, 170, 239, 9}
+    },
+    { {124, 58, 173, 18, 0},
+      {211, 137, 172, 128, 13},
+      {4, 139, 85, 195, 14},
+      {176, 19, 89, 28, 11}
+    },
+    { {67, 86, 162, 174, 9},
+      {76, 228, 11, 225, 7},
+      {151, 84, 86, 172, 2},
+      {232, 125, 2, 115, 2}
+    },
+    { {236, 183, 0, 75, 5},
+      {199, 34, 120, 174, 1},
+      {173, 32, 14, 211, 7},
+      {135, 81, 228, 78, 3}
+    },
+    { {247, 97, 178, 178, 7},
+      {133, 222, 226, 211, 7},
+      {228, 212, 216, 110, 15},
+      {236, 180, 119, 186, 1}
+    },
+    { {137, 36, 99, 124, 13},
+      {63, 96, 195, 106, 4},
+      {179, 236, 98, 73, 1},
+      {37, 108, 48, 111, 12}
+    },
+    { {114, 58, 98, 179, 1},
+      {101, 72, 170, 133, 15},
+      {140, 212, 101, 196, 14},
+      {250, 21, 81, 42, 6}
+    },
+    { {41, 180, 125, 69, 1},
+      {127, 1, 52, 124, 4},
+      {138, 43, 226, 217, 4},
+      {35, 226, 200, 15, 14}
+    },
+    { {18, 107, 239, 149, 10},
+      {57, 223, 141, 5, 14},
+      {90, 159, 125, 100, 8},
+      {122, 11, 31, 185, 12}
+    },
+    { {161, 94, 96, 121, 10},
+      {96, 52, 171, 110, 12},
+      {89, 224, 103, 168, 5},
+      {55, 109, 82, 192, 6}
+    },
+    { {126, 76, 172, 58, 13},
+      {134, 173, 231, 161, 13},
+      {181, 195, 83, 39, 14},
+      {184, 94, 123, 86, 1}
+    },
+    { {114, 142, 21, 50, 3},
+      {20, 25, 186, 177, 9},
+      {196, 202, 135, 20, 14},
+      {152, 213, 217, 130, 8}
+    },
+    { {50, 5, 228, 151, 0},
+      {40, 139, 160, 37, 7},
+      {14, 146, 122, 4, 12},
+      {234, 64, 93, 17, 4}
+    },
+    { {20, 99, 87, 142, 15},
+      {189, 127, 73, 16, 3},
+      {247, 30, 172, 98, 8},
+      {192, 137, 47, 235, 13}
+    },
+    { {70, 114, 172, 144, 8},
+      {193, 133, 141, 129, 6},
+      {16, 147, 84, 230, 2},
+      {104, 27, 26, 24, 3}
+    },
+    { {218, 88, 222, 192, 8},
+      {98, 205, 5, 155, 10},
+      {16, 55, 177, 165, 11},
+      {93, 154, 11, 52, 6}
+    },
+    { {201, 31, 228, 54, 4},
+      {106, 131, 202, 226, 13},
+      {38, 194, 127, 137, 3},
+      {180, 117, 60, 21, 6}
+    },
+    { {161, 197, 254, 154, 12},
+      {32, 231, 245, 114, 7},
+      {53, 151, 250, 56, 5},
+      {228, 234, 254, 112, 4}
+    },
+    { {247, 70, 210, 71, 7},
+      {172, 220, 104, 255, 1},
+      {238, 36, 182, 46, 15},
+      {143, 241, 99, 179, 5}
+    },
+    { {56, 73, 248, 205, 2},
+      {42, 190, 36, 28, 14},
+      {75, 49, 249, 33, 12},
+      {115, 130, 71, 213, 4}
+    },
+    { {186, 114, 36, 10, 6},
+      {67, 61, 104, 3, 5},
+      {101, 2, 68, 229, 13},
+      {172, 1, 107, 204, 2}
+    },
+    { {100, 162, 99, 127, 3},
+      {189, 112, 186, 140, 5},
+      {207, 236, 100, 82, 6},
+      {163, 21, 208, 235, 13}
+    },
+    { {132, 80, 221, 43, 3},
+      {244, 181, 6, 22, 1},
+      {205, 75, 176, 162, 1},
+      {134, 134, 10, 210, 15}
+    },
+    { {233, 134, 163, 18, 6},
+      {18, 208, 248, 226, 5},
+      {100, 140, 86, 25, 7},
+      {164, 113, 240, 180, 8}
+    },
+    { {31, 106, 10, 155, 13},
+      {135, 108, 205, 69, 11},
+      {189, 149, 5, 111, 8},
+      {218, 43, 51, 110, 1}
+    },
+    { {193, 131, 19, 193, 9},
+      {20, 66, 25, 222, 2},
+      {152, 60, 140, 24, 3},
+      {71, 185, 132, 34, 8}
+    },
+    { {68, 244, 102, 59, 11},
+      {229, 117, 147, 164, 5},
+      {221, 198, 98, 242, 2},
+      {162, 92, 154, 234, 7}
+    },
+    { {1, 157, 216, 198, 10},
+      {104, 146, 21, 120, 11},
+      {86, 49, 187, 152, 0},
+      {209, 234, 132, 145, 6}
+    },
+    { {207, 106, 252, 4, 8},
+      {171, 133, 13, 211, 12},
+      {18, 3, 245, 111, 3},
+      {60, 187, 10, 29, 5}
+    },
+    { {146, 174, 195, 5, 6},
+      {57, 216, 88, 39, 8},
+      {106, 12, 55, 84, 9},
+      {30, 65, 161, 185, 12}
+    },
+    { {37, 21, 93, 154, 5},
+      {244, 35, 228, 112, 3},
+      {165, 155, 170, 138, 4},
+      {192, 226, 124, 66, 15}
+    },
+    { {22, 10, 92, 69, 6},
+      {168, 25, 76, 29, 8},
+      {106, 35, 165, 6, 8},
+      {27, 131, 41, 129, 5}
+    },
+    { {42, 195, 144, 107, 5},
+      {6, 166, 122, 29, 1},
+      {173, 96, 156, 53, 4},
+      {139, 133, 230, 86, 0}
+    },
+    { {46, 122, 182, 246, 15},
+      {207, 213, 235, 25, 15},
+      {246, 246, 213, 231, 4},
+      {249, 141, 122, 191, 3}
+    },
+    { {158, 250, 147, 214, 12},
+      {219, 204, 217, 27, 11},
+      {54, 188, 149, 247, 9},
+      {221, 137, 179, 61, 11}
+    },
+    { {70, 52, 147, 36, 2},
+      {217, 208, 2, 177, 0},
+      {66, 76, 146, 198, 2},
+      {8, 212, 0, 185, 11}
+    },
+    { {10, 253, 84, 150, 12},
+      {107, 7, 209, 49, 11},
+      {54, 146, 171, 245, 0},
+      {216, 200, 190, 13, 6}
+    },
+    { {176, 98, 61, 37, 0},
+      {25, 13, 46, 22, 4},
+      {10, 75, 196, 96, 13},
+      {38, 135, 75, 9, 8}
+    },
+    { {145, 210, 194, 45, 8},
+      {104, 236, 27, 70, 0},
+      {27, 68, 52, 184, 9},
+      {6, 45, 131, 113, 6}
+    },
+    { {180, 12, 140, 215, 2},
+      {136, 153, 164, 46, 11},
+      {78, 179, 19, 2, 13},
+      {215, 66, 89, 145, 1}
+    },
+    { {159, 137, 21, 197, 9},
+      {158, 11, 17, 95, 10},
+      {154, 58, 137, 31, 9},
+      {95, 168, 141, 7, 9}
+    },
+    { {231, 171, 31, 92, 9},
+      {157, 99, 189, 219, 8},
+      {147, 175, 141, 94, 7},
+      {29, 187, 220, 107, 9}
+    },
+    { {64, 95, 208, 111, 7},
+      {108, 182, 74, 188, 9},
+      {239, 96, 191, 160, 2},
+      {147, 213, 38, 211, 6}
+    },
+    { {107, 30, 197, 224, 6},
+      {114, 145, 106, 233, 10},
+      {96, 122, 55, 141, 6},
+      {89, 117, 104, 148, 14}
+    },
+    { {172, 27, 229, 165, 10},
+      {250, 147, 43, 6, 14},
+      {90, 90, 125, 131, 5},
+      {118, 13, 76, 149, 15}
+    },
+    { {230, 47, 3, 108, 10},
+      {153, 114, 43, 171, 8},
+      {83, 108, 15, 70, 7},
+      {29, 93, 68, 233, 9}
+    },
+    { {127, 229, 102, 248, 8},
+      {163, 111, 179, 233, 6},
+      {17, 246, 106, 127, 14},
+      {105, 124, 223, 108, 5}
+    },
+    { {163, 194, 62, 50, 14},
+      {0, 85, 255, 83, 5},
+      {116, 199, 196, 60, 5},
+      {172, 175, 250, 160, 0}
+    },
+    { {148, 62, 117, 118, 6},
+      {249, 25, 202, 58, 13},
+      {102, 234, 231, 194, 9},
+      {181, 197, 57, 137, 15}
+    },
+    { {52, 186, 30, 90, 15},
+      {197, 121, 253, 24, 9},
+      {245, 167, 133, 210, 12},
+      {145, 139, 249, 234, 3}
+    },
+    { {3, 165, 18, 156, 11},
+      {13, 114, 145, 113, 2},
+      {211, 148, 138, 92, 0},
+      {72, 232, 148, 235, 0}
+    },
+    { {37, 82, 144, 131, 7},
+      {196, 148, 104, 84, 3},
+      {236, 16, 148, 170, 4},
+      {194, 161, 98, 146, 3}
+    },
+    { {152, 56, 107, 83, 15},
+      {119, 88, 197, 14, 13},
+      {252, 173, 97, 193, 9},
+      {183, 10, 49, 174, 14}
+    },
+    { {81, 8, 229, 57, 2},
+      {48, 185, 130, 196, 12},
+      {73, 202, 113, 8, 10},
+      {50, 52, 25, 208, 12}
+    },
+    { {109, 47, 236, 46, 14},
+      {171, 179, 111, 224, 13},
+      {119, 67, 127, 75, 6},
+      {176, 127, 108, 221, 5}
+    },
+    { {82, 188, 16, 202, 10},
+      {65, 56, 17, 185, 11},
+      {85, 48, 131, 212, 10},
+      {217, 216, 129, 200, 2}
+    },
+    { {179, 40, 54, 67, 10},
+      {1, 89, 33, 95, 13},
+      {92, 38, 193, 76, 13},
+      {191, 168, 73, 168, 0}
+    },
+    { {119, 53, 50, 215, 6},
+      {201, 90, 224, 253, 7},
+      {110, 180, 202, 206, 14},
+      {235, 240, 117, 169, 3}
+    },
+    { {60, 107, 123, 81, 7},
+      {183, 94, 236, 28, 12},
+      {232, 173, 237, 99, 12},
+      {51, 131, 119, 174, 13}
+    },
+    { {58, 210, 85, 76, 8},
+      {122, 45, 57, 25, 0},
+      {19, 42, 164, 181, 12},
+      {9, 137, 203, 69, 14}
+    },
+    { {121, 133, 192, 110, 10},
+      {42, 186, 51, 232, 1},
+      {87, 96, 58, 25, 14},
+      {129, 124, 197, 213, 4}
+    },
+    { {197, 187, 154, 199, 7},
+      {205, 210, 92, 222, 11},
+      {238, 53, 157, 218, 3},
+      {215, 179, 164, 187, 3}
+    },
+    { {12, 197, 122, 240, 11},
+      {166, 86, 151, 56, 6},
+      {208, 245, 234, 51, 0},
+      {97, 206, 150, 166, 5}
+    },
+    { {248, 208, 240, 214, 2},
+      {106, 156, 176, 154, 7},
+      {70, 176, 240, 177, 15},
+      {229, 144, 211, 149, 6}
+    },
+    { {129, 63, 211, 226, 11},
+      {117, 210, 11, 122, 11},
+      {212, 124, 191, 200, 1},
+      {213, 237, 4, 186, 14}
+    },
+    { {13, 236, 216, 183, 12},
+      {171, 132, 215, 116, 11},
+      {62, 209, 179, 123, 0},
+      {210, 238, 178, 29, 5}
+    },
+    { {27, 74, 227, 19, 2},
+      {50, 220, 136, 69, 13},
+      {76, 140, 117, 45, 8},
+      {186, 33, 19, 180, 12}
+    },
+    { {210, 32, 64, 67, 5},
+      {37, 8, 64, 143, 1},
+      {172, 32, 32, 68, 11},
+      {143, 16, 33, 10, 4}
+    },
+    { {20, 134, 143, 224, 4},
+      {144, 201, 94, 40, 2},
+      {32, 127, 22, 18, 8},
+      {65, 71, 169, 48, 9}
+    },
+    { {129, 156, 58, 252, 10},
+      {72, 112, 151, 122, 14},
+      {83, 245, 195, 152, 1},
+      {117, 238, 144, 225, 2}
+    },
+    { {69, 204, 88, 112, 14},
+      {160, 20, 215, 248, 8},
+      {112, 225, 163, 58, 2},
+      {17, 254, 178, 128, 5}
+    },
+    { {85, 209, 44, 27, 7},
+      {196, 63, 212, 196, 5},
+      {237, 131, 72, 186, 10},
+      {162, 50, 191, 194, 3}
+    },
+    { {124, 82, 159, 25, 14},
+      {210, 253, 237, 148, 0},
+      {121, 143, 148, 163, 14},
+      {2, 155, 123, 244, 11}
+    },
+    { {112, 145, 54, 145, 1},
+      {68, 75, 176, 148, 6},
+      {136, 150, 200, 144, 14},
+      {98, 144, 221, 34, 2}
+    },
+    { {252, 90, 66, 132, 10},
+      {234, 92, 41, 130, 10},
+      {82, 20, 37, 163, 15},
+      {84, 25, 67, 165, 7}
+    },
+    { {87, 151, 148, 193, 3},
+      {196, 155, 24, 253, 2},
+      {200, 50, 158, 158, 10},
+      {75, 241, 141, 146, 3}
+    },
+    { {165, 209, 196, 248, 2},
+      {224, 183, 178, 74, 2},
+      {65, 242, 56, 186, 5},
+      {69, 36, 222, 208, 7}
+    },
+    { {129, 60, 188, 144, 8},
+      {65, 129, 133, 114, 14},
+      {16, 147, 211, 200, 1},
+      {116, 234, 24, 24, 2}
+    },
+    { {9, 113, 70, 213, 3},
+      {111, 87, 128, 76, 2},
+      {202, 182, 40, 233, 0},
+      {67, 32, 30, 175, 6}
+    },
+    { {106, 207, 210, 216, 5},
+      {38, 230, 248, 185, 10},
+      {161, 180, 191, 53, 6},
+      {89, 209, 246, 118, 4}
+    },
+    { {115, 244, 119, 116, 9},
+      {125, 77, 179, 249, 4},
+      {146, 238, 226, 252, 14},
+      {41, 252, 219, 43, 14}
+    },
+    { {245, 157, 172, 185, 10},
+      {192, 187, 183, 230, 14},
+      {89, 211, 91, 154, 15},
+      {118, 126, 221, 208, 3}
+    },
+    { {202, 249, 118, 232, 4},
+      {99, 103, 82, 155, 14},
+      {33, 118, 233, 245, 3},
+      {125, 148, 174, 108, 6}
+    },
+    { {145, 223, 213, 147, 14},
+      {112, 159, 217, 118, 11},
+      {124, 154, 191, 184, 9},
+      {214, 233, 191, 144, 14}
+    },
+    { {151, 224, 139, 96, 13},
+      {149, 204, 87, 75, 0},
+      {176, 109, 16, 126, 9},
+      {13, 46, 163, 58, 9}
+    },
+    { {171, 24, 195, 41, 7},
+      {118, 240, 98, 71, 8},
+      {233, 76, 49, 141, 5},
+      {30, 36, 96, 246, 14}
+    },
+    { {12, 117, 233, 207, 4},
+      {251, 166, 68, 44, 7},
+      {47, 57, 122, 227, 0},
+      {227, 66, 38, 93, 15}
+    },
+    { {18, 88, 90, 126, 11},
+      {108, 124, 135, 25, 9},
+      {215, 229, 161, 164, 8},
+      {153, 142, 19, 227, 6}
+    },
+    { {226, 61, 82, 49, 9},
+      {101, 66, 163, 183, 8},
+      {152, 196, 171, 196, 7},
+      {30, 220, 84, 42, 6}
+    },
+    { {148, 62, 206, 46, 10},
+      {233, 249, 15, 34, 9},
+      {87, 71, 55, 194, 9},
+      {148, 79, 9, 249, 7}
+    },
+    { {77, 128, 42, 254, 11},
+      {142, 112, 151, 200, 7},
+      {215, 245, 64, 27, 2},
+      {225, 62, 144, 231, 1}
+    },
+    { {99, 222, 29, 74, 1},
+      {84, 37, 60, 249, 9},
+      {133, 43, 135, 188, 6},
+      {153, 243, 202, 66, 10}
+    },
+    { {234, 149, 240, 24, 8},
+      {98, 162, 177, 179, 4},
+      {17, 128, 250, 149, 7},
+      {44, 216, 212, 84, 6}
+    },
+    { {20, 204, 99, 128, 10},
+      {176, 92, 17, 32, 14},
+      {80, 28, 99, 50, 8},
+      {112, 72, 131, 160, 13}
+    },
+    { {200, 176, 49, 75, 15},
+      {87, 48, 81, 158, 5},
+      {253, 40, 192, 209, 3},
+      {167, 152, 160, 206, 10}
+    },
+    { {158, 5, 82, 110, 15},
+      {174, 122, 67, 59, 1},
+      {247, 100, 170, 7, 9},
+      {141, 204, 37, 231, 5}
+    },
+    { {90, 49, 246, 81, 3},
+      {103, 219, 128, 157, 4},
+      {200, 166, 248, 197, 10},
+      {43, 144, 29, 190, 6}
+    },
+    { {2, 64, 141, 174, 9},
+      {28, 165, 7, 1, 3},
+      {151, 91, 16, 36, 0},
+      {200, 14, 10, 83, 8}
+    },
+    { {3, 39, 204, 189, 6},
+      {41, 179, 206, 101, 2},
+      {107, 211, 62, 76, 0},
+      {74, 103, 60, 217, 4}
+    },
+    { {57, 199, 200, 136, 5},
+      {38, 174, 124, 96, 2},
+      {161, 17, 62, 57, 12},
+      {64, 99, 231, 86, 4}
+    },
+    { {29, 241, 95, 61, 5},
+      {255, 111, 214, 84, 0},
+      {171, 207, 168, 251, 8},
+      {2, 166, 191, 111, 15}
+    },
+    { {53, 248, 87, 146, 8},
+      {241, 77, 177, 80, 11},
+      {20, 158, 161, 250, 12},
+      {208, 168, 219, 40, 15}
+    },
+    { {246, 170, 194, 38, 15},
+      {173, 216, 123, 131, 9},
+      {246, 68, 53, 86, 15},
+      {156, 29, 225, 187, 5}
+    },
+    { {231, 224, 91, 154, 9},
+      {181, 100, 181, 211, 3},
+      {149, 157, 160, 126, 7},
+      {204, 186, 210, 106, 13}
+    },
+    { {35, 84, 88, 78, 2},
+      {104, 52, 36, 121, 1},
+      {71, 33, 162, 172, 4},
+      {137, 226, 66, 193, 6}
+    },
+    { {168, 240, 123, 208, 12},
+      {115, 68, 245, 26, 6},
+      {48, 189, 224, 241, 5},
+      {101, 138, 242, 44, 14}
+    },
+    { {31, 123, 242, 62, 3},
+      {239, 254, 138, 81, 13},
+      {199, 196, 253, 239, 8},
+      {184, 165, 23, 255, 7}
+    },
+    { {166, 34, 215, 254, 13},
+      {189, 225, 235, 27, 3},
+      {183, 254, 180, 70, 5},
+      {205, 141, 120, 123, 13}
+    },
+    { {60, 224, 174, 102, 10},
+      {139, 221, 55, 8, 5},
+      {86, 103, 80, 115, 12},
+      {161, 14, 203, 189, 1}
+    },
+    { {157, 234, 252, 246, 9},
+      {175, 141, 159, 90, 15},
+      {150, 243, 245, 123, 9},
+      {245, 175, 155, 31, 5}
+    },
+    { {118, 28, 15, 110, 1},
+      {220, 105, 38, 169, 9},
+      {135, 111, 3, 134, 14},
+      {153, 86, 73, 99, 11}
+    },
+    { {23, 229, 15, 201, 12},
+      {145, 111, 85, 109, 2},
+      {57, 63, 10, 126, 8},
+      {75, 106, 175, 104, 9}
+    },
+    { {107, 215, 2, 212, 12},
+      {74, 70, 249, 233, 2},
+      {50, 180, 14, 189, 6},
+      {73, 121, 246, 37, 2}
+    },
+    { {86, 44, 136, 80, 8},
+      {129, 136, 133, 169, 8},
+      {16, 161, 19, 70, 10},
+      {25, 90, 17, 24, 1}
+    },
+    { {117, 18, 248, 29, 15},
+      {236, 184, 237, 212, 4},
+      {251, 129, 244, 138, 14},
+      {34, 187, 113, 211, 7}
+    },
+    { {126, 225, 73, 21, 0},
+      {187, 14, 180, 133, 0},
+      {10, 137, 40, 119, 14},
+      {10, 18, 215, 13, 13}
+    },
+    { {16, 118, 198, 246, 1},
+      {109, 205, 138, 40, 3},
+      {134, 246, 54, 224, 8},
+      {193, 69, 27, 59, 6}
+    },
+    { {212, 235, 35, 223, 2},
+      {153, 126, 152, 142, 15},
+      {79, 188, 77, 114, 11},
+      {247, 17, 151, 233, 9}
+    },
+    { {40, 207, 171, 134, 10},
+      {26, 214, 61, 32, 15},
+      {86, 29, 95, 49, 4},
+      {240, 75, 198, 181, 8}
+    },
+    { {172, 20, 113, 133, 3},
+      {254, 16, 32, 54, 6},
+      {202, 24, 226, 131, 5},
+      {102, 192, 64, 135, 15}
+    },
+    { {175, 152, 175, 103, 14},
+      {218, 209, 119, 79, 13},
+      {126, 111, 81, 159, 5},
+      {191, 46, 232, 181, 11}
+    },
+    { {193, 158, 114, 157, 1},
+      {108, 96, 152, 246, 14},
+      {139, 148, 231, 152, 3},
+      {118, 241, 144, 99, 6}
+    },
+    { {207, 95, 181, 152, 6},
+      {210, 183, 200, 243, 14},
+      {97, 154, 223, 175, 3},
+      {124, 241, 62, 212, 11}
+    },
+    { {213, 221, 187, 147, 2},
+      {208, 222, 148, 246, 15},
+      {76, 157, 219, 186, 11},
+      {246, 242, 151, 176, 11}
+    },
+    { {79, 134, 37, 109, 3},
+      {158, 49, 26, 237, 4},
+      {203, 106, 70, 31, 2},
+      {43, 117, 136, 199, 9}
+    },
+    { {106, 36, 71, 111, 0},
+      {59, 97, 34, 173, 1},
+      {15, 110, 34, 69, 6},
+      {139, 84, 72, 109, 12}
+    },
+    { {128, 45, 147, 26, 1},
+      {21, 226, 128, 50, 9},
+      {133, 140, 155, 64, 1},
+      {148, 192, 20, 122, 8}
+    },
+    { {29, 205, 131, 180, 9},
+      {158, 206, 147, 96, 10},
+      {146, 220, 27, 59, 8},
+      {80, 108, 151, 55, 9}
+    },
+    { {218, 134, 193, 229, 12},
+      {58, 136, 91, 175, 2},
+      {58, 120, 54, 21, 11},
+      {79, 93, 161, 21, 12}
+    },
+    { {230, 246, 109, 46, 3},
+      {253, 53, 62, 163, 5},
+      {199, 75, 102, 246, 7},
+      {172, 87, 202, 203, 15}
+    },
+    { {61, 137, 16, 149, 7},
+      {142, 26, 240, 84, 10},
+      {234, 144, 137, 27, 12},
+      {82, 160, 245, 135, 1}
+    },
+    { {210, 121, 65, 88, 12},
+      {113, 46, 193, 139, 8},
+      {49, 168, 41, 228, 11},
+      {29, 24, 55, 72, 14}
+    },
+    { {160, 175, 28, 189, 14},
+      {9, 51, 255, 54, 10},
+      {123, 211, 143, 80, 5},
+      {86, 207, 252, 201, 0}
+    },
+    { {1, 87, 110, 34, 13},
+      {100, 71, 79, 96, 5},
+      {180, 71, 110, 168, 0},
+      {160, 111, 46, 34, 6}
+    },
+    { {87, 248, 236, 245, 8},
+      {233, 141, 151, 205, 14},
+      {26, 243, 113, 254, 10},
+      {123, 62, 155, 25, 7}
+    },
+    { {106, 255, 41, 18, 1},
+      {87, 6, 188, 161, 13},
+      {132, 137, 79, 245, 6},
+      {184, 83, 214, 14, 10}
+    },
+    { {251, 33, 174, 202, 0},
+      {3, 235, 36, 203, 7},
+      {5, 55, 88, 77, 15},
+      {237, 50, 77, 124, 0}
+    },
+    { {11, 139, 189, 114, 11},
+      {22, 147, 159, 89, 13},
+      {212, 235, 221, 29, 0},
+      {185, 175, 156, 150, 8}
+    },
+    { {212, 152, 51, 194, 13},
+      {212, 72, 81, 154, 15},
+      {180, 60, 193, 146, 11},
+      {245, 152, 161, 34, 11}
+    },
+    { {225, 75, 0, 230, 14},
+      {8, 22, 107, 202, 11},
+      {118, 112, 13, 40, 7},
+      {213, 61, 102, 129, 0}
+    },
+    { {26, 95, 155, 85, 5},
+      {94, 206, 204, 61, 8},
+      {170, 173, 159, 165, 8},
+      {27, 195, 55, 55, 10}
+    },
+    { {240, 142, 136, 165, 15},
+      {12, 152, 127, 166, 10},
+      {250, 81, 23, 16, 15},
+      {86, 95, 225, 147, 0}
+    },
+    { {167, 153, 98, 167, 6},
+      {232, 82, 114, 71, 15},
+      {110, 84, 105, 158, 5},
+      {254, 36, 228, 161, 7}
+    },
+    { {117, 137, 204, 235, 6},
+      {160, 187, 118, 204, 11},
+      {109, 115, 57, 26, 14},
+      {211, 54, 237, 208, 5}
+    },
+    { {146, 223, 143, 67, 12},
+      {80, 207, 93, 47, 9},
+      {60, 47, 31, 180, 9},
+      {159, 75, 175, 48, 10}
+    },
+    { {174, 86, 155, 223, 2},
+      {218, 244, 172, 63, 3},
+      {79, 189, 150, 167, 5},
+      {207, 195, 82, 245, 11}
+    },
+    { {210, 12, 103, 74, 4},
+      {48, 105, 64, 171, 13},
+      {37, 46, 99, 4, 11},
+      {189, 80, 41, 96, 12}
+    },
+    { {40, 70, 65, 78, 7},
+      {62, 52, 104, 40, 1},
+      {231, 40, 38, 33, 4},
+      {129, 65, 98, 199, 12}
+    },
+    { {108, 201, 54, 127, 1},
+      {142, 103, 178, 156, 13},
+      {143, 230, 201, 51, 6},
+      {179, 148, 222, 103, 1}
+    },
+    { {194, 238, 156, 100, 12},
+      {9, 133, 95, 187, 8},
+      {50, 99, 151, 116, 3},
+      {29, 223, 170, 25, 0}
+    },
+    { {36, 163, 220, 7, 0},
+      {169, 131, 60, 20, 1},
+      {14, 3, 188, 82, 4},
+      {130, 131, 204, 25, 5}
+    },
+    { {41, 169, 53, 183, 11},
+      {31, 19, 179, 84, 15},
+      {222, 218, 201, 89, 4},
+      {242, 172, 220, 143, 8}
+    },
+    { {105, 9, 143, 242, 0},
+      {18, 195, 166, 200, 11},
+      {4, 255, 25, 9, 6},
+      {209, 54, 92, 52, 8}
+    },
+    { {221, 179, 45, 144, 2},
+      {211, 27, 156, 194, 6},
+      {64, 155, 76, 219, 11},
+      {100, 51, 157, 140, 11}
+    },
+    { {17, 24, 73, 168, 13},
+      {116, 40, 71, 64, 10},
+      {177, 89, 33, 136, 8},
+      {80, 46, 33, 66, 14}
+    },
+    { {182, 179, 217, 164, 5},
+      {253, 138, 126, 19, 2},
+      {162, 89, 188, 214, 13},
+      {76, 135, 229, 27, 15}
+    },
+    { {160, 207, 230, 60, 2},
+      {40, 247, 186, 34, 12},
+      {67, 198, 127, 48, 5},
+      {52, 69, 222, 241, 4}
+    },
+    { {55, 59, 166, 59, 8},
+      {193, 235, 171, 69, 13},
+      {29, 198, 93, 206, 12},
+      {186, 45, 93, 120, 3}
+    },
+    { {161, 242, 208, 206, 8},
+      {105, 164, 57, 90, 3},
+      {23, 48, 180, 248, 5},
+      {197, 169, 194, 89, 6}
+    },
+    { {86, 143, 18, 81, 15},
+      {132, 90, 217, 189, 8},
+      {248, 164, 143, 22, 10},
+      {27, 217, 181, 162, 1}
+    },
+    { {194, 231, 12, 94, 10},
+      {9, 55, 157, 171, 1},
+      {87, 163, 14, 116, 3},
+      {141, 91, 158, 201, 0}
+    },
+    { {156, 25, 191, 90, 0},
+      {210, 235, 132, 26, 13},
+      {5, 175, 217, 131, 9},
+      {181, 130, 29, 116, 11}
+    },
+    { {117, 207, 171, 65, 6},
+      {144, 222, 124, 236, 12},
+      {104, 45, 95, 58, 14},
+      {51, 115, 231, 176, 9}
+    },
+    { {126, 204, 41, 109, 0},
+      {154, 44, 54, 173, 12},
+      {11, 105, 67, 55, 14},
+      {59, 86, 195, 69, 9}
+    },
+    { {243, 91, 227, 26, 14},
+      {112, 254, 233, 195, 13},
+      {117, 140, 125, 172, 15},
+      {188, 57, 119, 240, 14}
+    },
+    { {190, 117, 133, 241, 8},
+      {211, 143, 163, 47, 2},
+      {24, 250, 26, 231, 13},
+      {79, 76, 95, 28, 11}
+    },
+    { {33, 154, 217, 93, 10},
+      {120, 176, 189, 92, 8},
+      {91, 169, 181, 152, 4},
+      {19, 171, 208, 209, 14}
+    },
+    { {187, 162, 184, 116, 12},
+      {11, 136, 255, 91, 4},
+      {50, 225, 212, 93, 13},
+      {45, 175, 241, 29, 0}
+    },
+    { {24, 170, 15, 78, 6},
+      {27, 121, 92, 8, 9},
+      {103, 47, 5, 81, 8},
+      {145, 3, 169, 237, 8}
+    },
+    { {141, 163, 255, 65, 12},
+      {179, 195, 93, 94, 4},
+      {56, 47, 252, 91, 1},
+      {39, 171, 172, 60, 13}
+    },
+    { {204, 241, 13, 15, 1},
+      {223, 39, 20, 134, 1},
+      {143, 11, 8, 243, 3},
+      {134, 18, 142, 79, 11}
+    },
+    { {15, 249, 178, 82, 13},
+      {199, 198, 209, 89, 13},
+      {180, 164, 217, 255, 0},
+      {185, 168, 182, 62, 3}
+    },
+    { {1, 159, 5, 220, 10},
+      {88, 51, 153, 104, 10},
+      {83, 186, 15, 152, 0},
+      {81, 105, 156, 193, 10}
+    },
+    { {223, 138, 224, 53, 4},
+      {170, 136, 218, 199, 12},
+      {42, 192, 117, 31, 11},
+      {62, 53, 177, 21, 5}
+    },
+    { {206, 123, 160, 13, 5},
+      {207, 166, 72, 135, 12},
+      {171, 0, 93, 231, 3},
+      {62, 17, 38, 95, 3}
+    },
+    { {217, 125, 237, 88, 6},
+      {115, 191, 196, 234, 12},
+      {97, 171, 123, 233, 11},
+      {53, 114, 63, 220, 14}
+    },
+    { {181, 147, 30, 12, 6},
+      {200, 123, 124, 82, 0},
+      {99, 7, 140, 154, 13},
+      {4, 163, 237, 225, 3}
+    },
+    { {18, 139, 154, 110, 4},
+      {8, 234, 94, 25, 9},
+      {39, 101, 157, 20, 8},
+      {153, 135, 165, 113, 0}
+    },
+    { {242, 22, 60, 166, 3},
+      {76, 25, 46, 179, 7},
+      {198, 83, 198, 132, 15},
+      {236, 215, 73, 131, 2}
+    },
+    { {232, 10, 7, 115, 7},
+      {22, 81, 234, 142, 9},
+      {236, 238, 5, 1, 7},
+      {151, 21, 120, 166, 8}
+    },
+    { {122, 115, 30, 194, 4},
+      {67, 79, 108, 153, 3},
+      {36, 55, 140, 229, 14},
+      {201, 147, 111, 44, 2}
+    },
+    { {53, 218, 126, 240, 11},
+      {228, 93, 191, 88, 14},
+      {208, 247, 229, 186, 12},
+      {113, 175, 219, 162, 7}
+    },
+    { {153, 130, 253, 45, 1},
+      {62, 169, 30, 86, 4},
+      {139, 75, 244, 25, 9},
+      {38, 167, 137, 87, 12}
+    },
+    { {223, 169, 37, 94, 13},
+      {159, 43, 209, 203, 13},
+      {183, 170, 73, 95, 11},
+      {189, 56, 189, 79, 9}
+    },
+    { {165, 30, 214, 188, 15},
+      {236, 241, 235, 114, 10},
+      {243, 214, 183, 138, 5},
+      {84, 237, 120, 243, 7}
+    },
+    { {36, 8, 213, 209, 9},
+      {180, 129, 161, 28, 10},
+      {152, 186, 177, 2, 4},
+      {83, 136, 88, 18, 13}
+    },
+    { {181, 248, 233, 45, 6},
+      {249, 188, 118, 70, 12},
+      {107, 73, 113, 250, 13},
+      {54, 38, 227, 217, 15}
+    },
+    { {145, 54, 188, 78, 0},
+      {73, 169, 12, 122, 5},
+      {7, 35, 214, 200, 9},
+      {165, 227, 9, 89, 2}
+    },
+    { {174, 88, 224, 232, 5},
+      {230, 164, 98, 11, 14},
+      {161, 112, 113, 167, 5},
+      {125, 4, 98, 86, 7}
+    },
+    { {47, 128, 197, 170, 11},
+      {182, 177, 51, 65, 3},
+      {213, 90, 48, 31, 4},
+      {200, 44, 200, 214, 13}
+    },
+    { {218, 73, 123, 17, 9},
+      {54, 78, 133, 151, 12},
+      {152, 141, 233, 37, 11},
+      {62, 154, 23, 38, 12}
+    },
+    { {162, 246, 228, 83, 14},
+      {97, 149, 249, 47, 5},
+      {124, 162, 118, 244, 5},
+      {175, 73, 250, 152, 6}
+    },
+    { {33, 39, 109, 132, 12},
+      {57, 3, 109, 96, 6},
+      {50, 27, 110, 72, 4},
+      {96, 107, 108, 9, 12}
+    },
+    { {107, 121, 40, 104, 12},
+      {67, 38, 103, 201, 12},
+      {49, 97, 73, 237, 6},
+      {57, 62, 102, 76, 2}
+    },
+    { {157, 218, 93, 177, 13},
+      {246, 13, 223, 86, 10},
+      {184, 219, 165, 187, 9},
+      {86, 175, 187, 6, 15}
+    },
+    { {47, 207, 178, 181, 5},
+      {142, 198, 250, 117, 14},
+      {170, 212, 223, 63, 4},
+      {122, 229, 246, 55, 1}
+    },
+    { {175, 32, 71, 30, 8},
+      {187, 97, 161, 67, 1},
+      {23, 142, 32, 79, 5},
+      {140, 40, 88, 109, 13}
+    },
+    { {234, 199, 75, 58, 9},
+      {54, 102, 191, 163, 1},
+      {149, 205, 46, 53, 7},
+      {140, 95, 214, 102, 12}
+    },
+    { {204, 229, 29, 252, 14},
+      {155, 55, 215, 186, 2},
+      {115, 251, 138, 115, 3},
+      {69, 222, 190, 205, 9}
+    },
+    { {97, 48, 133, 50, 1},
+      {85, 129, 162, 192, 1},
+      {132, 202, 16, 200, 6},
+      {128, 52, 88, 26, 10}
+    },
+    { {180, 146, 25, 41, 1},
+      {212, 40, 62, 22, 0},
+      {137, 73, 132, 146, 13},
+      {6, 135, 193, 66, 11}
+    },
+    { {193, 207, 189, 157, 10},
+      {24, 183, 157, 246, 14},
+      {91, 155, 223, 56, 3},
+      {118, 251, 158, 209, 8}
+    },
+    { {8, 221, 26, 54, 6},
+      {74, 86, 214, 48, 9},
+      {102, 197, 139, 177, 0},
+      {144, 198, 182, 165, 2}
+    },
+    { {120, 67, 92, 168, 15},
+      {38, 63, 111, 144, 2},
+      {241, 83, 172, 33, 14},
+      {64, 159, 111, 198, 4}
+    },
+    { {32, 220, 186, 83, 14},
+      {64, 212, 245, 60, 13},
+      {124, 165, 211, 176, 4},
+      {179, 202, 242, 176, 2}
+    },
+    { {227, 132, 165, 236, 6},
+      {24, 177, 114, 235, 6},
+      {99, 122, 82, 28, 7},
+      {109, 116, 232, 209, 8}
+    },
+    { {131, 145, 171, 122, 13},
+      {84, 226, 215, 75, 5},
+      {181, 237, 88, 156, 1},
+      {173, 46, 180, 114, 10}
+    },
+    { {114, 38, 60, 80, 11},
+      {5, 25, 173, 185, 4},
+      {208, 163, 198, 68, 14},
+      {41, 219, 89, 138, 0}
+    },
+    { {242, 174, 11, 171, 12},
+      {17, 104, 127, 167, 11},
+      {61, 93, 7, 84, 15},
+      {222, 95, 225, 104, 8}
+    },
+    { {46, 136, 9, 214, 3},
+      {158, 16, 180, 9, 11},
+      {198, 185, 1, 23, 4},
+      {217, 2, 208, 135, 9}
+    },
+    { {183, 203, 246, 151, 12},
+      {168, 207, 249, 87, 15},
+      {62, 150, 253, 62, 13},
+      {254, 169, 255, 49, 5}
+    },
+    { {49, 251, 244, 57, 14},
+      {97, 191, 251, 84, 12},
+      {121, 194, 253, 248, 12},
+      {50, 173, 255, 216, 6}
+    },
+    { {142, 199, 82, 154, 6},
+      {162, 118, 216, 51, 3},
+      {101, 148, 174, 55, 1},
+      {204, 193, 182, 228, 5}
+    },
+    { {94, 235, 242, 10, 12},
+      {163, 238, 89, 145, 13},
+      {53, 4, 253, 119, 10},
+      {184, 153, 167, 124, 5}
+    },
+    { {227, 59, 129, 212, 12},
+      {89, 130, 233, 203, 10},
+      {50, 184, 29, 204, 7},
+      {93, 57, 116, 25, 10}
+    },
+    { {172, 124, 242, 222, 10},
+      {235, 244, 161, 58, 15},
+      {87, 180, 243, 227, 5},
+      {245, 200, 82, 253, 7}
+    },
+    { {78, 1, 1, 147, 2},
+      {146, 18, 128, 133, 3},
+      {76, 152, 8, 7, 2},
+      {202, 16, 20, 132, 9}
+    },
+    { {201, 144, 131, 96, 5},
+      {86, 192, 82, 202, 0},
+      {160, 108, 16, 153, 3},
+      {5, 52, 160, 54, 10}
+    },
+    { {245, 102, 105, 160, 13},
+      {181, 12, 111, 226, 6},
+      {176, 89, 102, 106, 15},
+      {100, 127, 99, 10, 13}
+    },
+    { {44, 3, 150, 212, 14},
+      {138, 211, 233, 24, 2},
+      {114, 182, 156, 3, 4},
+      {65, 137, 124, 181, 1}
+    },
+    { {118, 193, 117, 204, 7},
+      {188, 63, 112, 153, 6},
+      {227, 58, 232, 54, 14},
+      {105, 144, 239, 195, 13}
+    },
+    { {176, 251, 83, 107, 5},
+      {117, 110, 122, 30, 9},
+      {173, 108, 173, 240, 13},
+      {151, 133, 231, 106, 14}
+    },
+    { {135, 53, 206, 169, 8},
+      {225, 227, 7, 103, 2},
+      {25, 87, 58, 206, 1},
+      {78, 110, 12, 120, 7}
+    },
+    { {231, 139, 244, 106, 11},
+      {164, 179, 59, 219, 13},
+      {213, 98, 253, 30, 7},
+      {189, 189, 204, 210, 5}
+    },
+    { {185, 178, 1, 226, 1},
+      {87, 8, 58, 74, 3},
+      {132, 120, 4, 217, 13},
+      {197, 37, 193, 14, 10}
+    },
+    { {44, 230, 244, 199, 9},
+      {175, 133, 57, 60, 7},
+      {158, 50, 246, 115, 4},
+      {227, 201, 202, 31, 5}
+    },
+    { {240, 26, 58, 172, 4},
+      {72, 104, 110, 146, 14},
+      {35, 85, 197, 128, 15},
+      {116, 151, 97, 97, 2}
+    },
+    { {107, 29, 238, 143, 4},
+      {106, 227, 100, 229, 15},
+      {47, 23, 123, 141, 6},
+      {250, 114, 108, 117, 6}
+    },
+    { {10, 99, 89, 22, 11},
+      {63, 22, 141, 17, 1},
+      {214, 137, 172, 101, 0},
+      {136, 139, 22, 143, 12}
+    },
+    { {61, 80, 237, 142, 0},
+      {250, 173, 36, 64, 7},
+      {7, 27, 112, 171, 12},
+      {224, 34, 75, 85, 15}
+    },
+    { {12, 234, 137, 42, 4},
+      {147, 164, 94, 0, 9},
+      {37, 73, 21, 115, 0},
+      {144, 7, 162, 92, 9}
+    },
+    { {146, 159, 44, 154, 3},
+      {68, 59, 156, 35, 15},
+      {197, 147, 79, 148, 9},
+      {252, 67, 157, 194, 2}
+    },
+    { {144, 185, 171, 44, 8},
+      {89, 234, 23, 2, 12},
+      {19, 77, 89, 208, 9},
+      {52, 14, 133, 121, 10}
+    },
+    { {96, 223, 140, 227, 4},
+      {64, 135, 126, 172, 11},
+      {44, 115, 31, 176, 6},
+      {211, 87, 238, 16, 2}
+    },
+    { {211, 163, 99, 9, 11},
+      {53, 122, 25, 199, 4},
+      {217, 12, 108, 92, 11},
+      {46, 57, 133, 234, 12}
+    },
+    { {37, 61, 159, 195, 3},
+      {213, 211, 36, 124, 11},
+      {204, 63, 155, 202, 4},
+      {211, 226, 76, 186, 11}
+    },
+    { {48, 25, 30, 15, 13},
+      {76, 107, 101, 20, 9},
+      {191, 7, 137, 128, 12},
+      {146, 138, 109, 99, 2}
+    },
+    { {90, 151, 28, 16, 1},
+      {70, 11, 156, 177, 0},
+      {128, 131, 142, 149, 10},
+      {8, 211, 157, 6, 2}
+    },
+    { {42, 15, 107, 51, 10},
+      {50, 82, 175, 37, 13},
+      {92, 205, 111, 5, 4},
+      {186, 79, 84, 164, 12}
+    },
+    { {106, 117, 209, 236, 0},
+      {123, 166, 34, 185, 2},
+      {3, 120, 186, 229, 6},
+      {73, 212, 70, 93, 14}
+    },
+    { {30, 157, 187, 139, 1},
+      {214, 234, 20, 53, 15},
+      {141, 29, 219, 151, 8},
+      {250, 194, 133, 118, 11}
+    },
+    { {47, 58, 225, 220, 9},
+      {255, 160, 169, 73, 14},
+      {147, 184, 117, 207, 4},
+      {121, 41, 80, 95, 15}
+    },
+    { {99, 208, 151, 52, 7},
+      {92, 213, 242, 209, 0},
+      {226, 206, 144, 188, 6},
+      {8, 180, 250, 179, 10}
+    },
+    { {216, 157, 137, 67, 7},
+      {86, 154, 84, 174, 9},
+      {236, 41, 27, 145, 11},
+      {151, 82, 165, 150, 10}
+    },
+    { {131, 189, 136, 80, 11},
+      {69, 146, 149, 107, 8},
+      {208, 161, 27, 220, 1},
+      {29, 106, 148, 154, 2}
+    },
+    { {34, 78, 125, 138, 14},
+      {48, 53, 109, 49, 15},
+      {117, 27, 231, 36, 4},
+      {248, 203, 106, 192, 12}
+    },
+    { {121, 75, 63, 158, 10},
+      {26, 127, 173, 208, 15},
+      {87, 159, 205, 41, 14},
+      {240, 187, 95, 229, 8}
+    },
+    { {141, 51, 167, 110, 15},
+      {223, 243, 75, 74, 5},
+      {247, 110, 92, 203, 1},
+      {165, 45, 44, 255, 11}
+    },
+    { {33, 133, 188, 205, 7},
+      {12, 179, 116, 124, 6},
+      {235, 51, 218, 24, 4},
+      {99, 226, 236, 211, 0}
+    },
+    { {240, 218, 227, 80, 3},
+      {116, 220, 184, 138, 12},
+      {192, 172, 117, 176, 15},
+      {53, 17, 211, 178, 14}
+    },
+    { {204, 223, 42, 42, 8},
+      {194, 102, 31, 162, 13},
+      {21, 69, 79, 179, 3},
+      {180, 95, 134, 100, 3}
+    },
+    { {56, 130, 84, 157, 1},
+      {46, 41, 184, 20, 2},
+      {139, 146, 164, 17, 12},
+      {66, 129, 217, 71, 4}
+    },
+    { {110, 45, 44, 91, 14},
+      {131, 51, 229, 173, 13},
+      {125, 163, 75, 71, 6},
+      {187, 90, 124, 204, 1}
+    },
+    { {122, 43, 200, 47, 2},
+      {43, 186, 46, 133, 9},
+      {79, 65, 61, 69, 14},
+      {154, 23, 69, 221, 4}
+    },
+    { {87, 219, 131, 112, 8},
+      {208, 206, 155, 201, 8},
+      {16, 236, 29, 190, 10},
+      {25, 61, 151, 48, 11}
+    },
+    { {201, 217, 206, 10, 6},
+      {98, 247, 84, 194, 9},
+      {101, 7, 57, 185, 3},
+      {148, 50, 174, 244, 6}
+    },
+    { {140, 81, 7, 168, 12},
+      {210, 103, 67, 2, 2},
+      {49, 94, 8, 163, 1},
+      {68, 12, 46, 100, 11}
+    },
+    { {189, 143, 171, 242, 11},
+      {150, 218, 191, 106, 15},
+      {212, 253, 95, 27, 13},
+      {245, 111, 213, 182, 9}
+    },
+    { {100, 133, 26, 10, 13},
+      {132, 98, 117, 176, 1},
+      {181, 5, 138, 18, 6},
+      {128, 218, 228, 98, 1}
+    },
+    { {220, 109, 58, 176, 4},
+      {131, 78, 198, 178, 14},
+      {32, 213, 203, 99, 11},
+      {116, 214, 55, 44, 1}
+    },
+    { {231, 251, 25, 168, 3},
+      {213, 54, 62, 211, 10},
+      {193, 89, 141, 254, 7},
+      {92, 183, 198, 202, 11}
+    },
+    { {177, 204, 84, 80, 5},
+      {36, 13, 240, 122, 8},
+      {160, 162, 163, 56, 13},
+      {21, 224, 251, 2, 4}
+    },
+    { {97, 110, 245, 148, 7},
+      {61, 149, 232, 240, 14},
+      {226, 154, 247, 104, 6},
+      {112, 241, 122, 155, 12}
+    },
+    { {147, 83, 11, 252, 1},
+      {92, 110, 142, 75, 2},
+      {131, 253, 12, 172, 9},
+      {77, 39, 23, 99, 10}
+    },
+    { {27, 41, 1, 82, 8},
+      {19, 10, 129, 73, 9},
+      {20, 168, 9, 77, 8},
+      {153, 40, 21, 12, 8}
+    },
+    { {197, 245, 7, 104, 1},
+      {213, 103, 18, 234, 0},
+      {129, 110, 10, 250, 3},
+      {5, 116, 142, 106, 11}
+    },
+    { {52, 186, 247, 153, 2},
+      {241, 249, 184, 20, 14},
+      {73, 158, 245, 210, 12},
+      {114, 129, 217, 248, 15}
+    },
+    { {169, 176, 189, 187, 13},
+      {87, 161, 247, 86, 7},
+      {189, 219, 208, 217, 5},
+      {230, 174, 248, 94, 10}
+    },
+    { {149, 57, 193, 12, 5},
+      {253, 170, 64, 66, 8},
+      {163, 8, 57, 202, 9},
+      {20, 32, 37, 91, 15}
+    },
+    { {50, 223, 204, 191, 2},
+      {104, 191, 190, 37, 11},
+      {79, 211, 63, 180, 12},
+      {218, 71, 223, 209, 6}
+    },
+    { {237, 234, 172, 111, 7},
+      {143, 181, 126, 206, 13},
+      {239, 99, 85, 123, 7},
+      {183, 55, 234, 223, 1}
+    },
+    { {77, 86, 15, 172, 10},
+      {218, 117, 15, 224, 2},
+      {83, 95, 6, 171, 2},
+      {64, 127, 10, 229, 11}
+    },
+    { {116, 172, 190, 43, 0},
+      {129, 233, 54, 180, 13},
+      {13, 71, 211, 82, 14},
+      {178, 214, 201, 120, 1}
+    },
+    { {35, 182, 120, 236, 5},
+      {109, 32, 126, 121, 6},
+      {163, 113, 230, 220, 4},
+      {105, 231, 224, 75, 6}
+    },
+    { {232, 210, 137, 53, 1},
+      {94, 132, 190, 134, 0},
+      {138, 201, 20, 177, 7},
+      {6, 23, 210, 23, 10}
+    },
+    { {235, 150, 185, 93, 6},
+      {90, 176, 252, 255, 4},
+      {107, 169, 214, 157, 7},
+      {47, 243, 240, 213, 10}
+    },
+    { {85, 145, 91, 105, 0},
+      {240, 106, 22, 220, 0},
+      {9, 109, 168, 154, 10},
+      {3, 182, 133, 96, 15}
+    },
+    { {40, 186, 189, 218, 6},
+      {83, 177, 252, 24, 15},
+      {101, 187, 213, 209, 4},
+      {241, 131, 248, 220, 10}
+    },
+    { {35, 163, 75, 130, 11},
+      {53, 82, 61, 65, 3},
+      {212, 29, 44, 92, 4},
+      {200, 43, 196, 170, 12}
+    },
+    { {193, 172, 20, 84, 10},
+      {9, 17, 145, 250, 8},
+      {82, 162, 131, 88, 3},
+      {21, 248, 152, 137, 0}
+    },
+    { {100, 182, 175, 131, 2},
+      {209, 209, 60, 164, 7},
+      {76, 31, 86, 210, 6},
+      {226, 83, 200, 184, 11}
+    },
+    { {82, 25, 155, 54, 1},
+      {92, 202, 134, 145, 9},
+      {134, 205, 153, 132, 10},
+      {152, 150, 21, 51, 10}
+    },
+    { {99, 183, 61, 54, 4},
+      {89, 3, 254, 241, 5},
+      {38, 203, 206, 220, 6},
+      {168, 247, 252, 9, 10}
+    },
+    { {192, 85, 112, 85, 8},
+      {104, 6, 129, 190, 4},
+      {26, 160, 234, 160, 3},
+      {39, 216, 22, 1, 6}
+    },
+    { {52, 181, 171, 169, 13},
+      {213, 234, 119, 36, 6},
+      {185, 93, 90, 210, 12},
+      {98, 78, 229, 122, 11}
+    },
+    { {4, 214, 173, 116, 7},
+      {220, 149, 222, 40, 4},
+      {226, 235, 86, 178, 0},
+      {33, 71, 186, 147, 11}
+    },
+    { {58, 185, 185, 47, 15},
+      {95, 186, 119, 21, 13},
+      {255, 73, 217, 213, 12},
+      {186, 142, 229, 223, 10}
+    },
+    { {30, 193, 204, 115, 3},
+      {166, 159, 150, 13, 1},
+      {204, 227, 56, 55, 8},
+      {139, 6, 159, 150, 5}
+    },
+    { {227, 95, 151, 12, 12},
+      {88, 231, 105, 243, 8},
+      {51, 14, 159, 172, 7},
+      {28, 249, 110, 113, 10}
+    },
+    { {82, 233, 202, 244, 7},
+      {45, 222, 214, 137, 10},
+      {226, 245, 57, 116, 10},
+      {89, 22, 183, 187, 4}
+    },
+    { {171, 99, 139, 22, 6},
+      {27, 214, 236, 67, 1},
+      {102, 141, 28, 109, 5},
+      {140, 35, 118, 189, 8}
+    },
+    { {138, 229, 208, 83, 7},
+      {39, 150, 208, 63, 1},
+      {236, 160, 186, 117, 1},
+      {143, 192, 182, 158, 4}
+    },
+    { {103, 173, 81, 43, 1},
+      {181, 34, 50, 245, 9},
+      {141, 72, 171, 94, 6},
+      {154, 244, 196, 74, 13}
+    },
+    { {179, 24, 122, 4, 11},
+      {108, 88, 37, 83, 12},
+      {210, 5, 225, 140, 13},
+      {60, 170, 65, 163, 6}
+    },
+    { {60, 198, 137, 195, 8},
+      {146, 140, 61, 44, 3},
+      {28, 57, 22, 51, 12},
+      {195, 75, 195, 20, 9}
+    },
+    { {250, 116, 11, 175, 7},
+      {95, 124, 102, 167, 3},
+      {239, 93, 2, 229, 15},
+      {206, 86, 99, 239, 10}
+    },
+    { {4, 250, 221, 72, 11},
+      {245, 181, 29, 24, 8},
+      {209, 43, 181, 242, 0},
+      {17, 139, 138, 218, 15}
+    },
+    { {153, 138, 132, 196, 12},
+      {10, 137, 89, 74, 10},
+      {50, 50, 21, 25, 9},
+      {85, 41, 169, 21, 0}
+    },
+    { {63, 252, 218, 241, 1},
+      {231, 204, 182, 125, 10},
+      {136, 245, 179, 255, 12},
+      {91, 230, 211, 62, 7}
+    },
+    { {148, 250, 34, 140, 9},
+      {205, 108, 25, 2, 14},
+      {147, 20, 69, 242, 9},
+      {116, 9, 131, 107, 3}
+    },
+    { {228, 237, 60, 145, 13},
+      {133, 7, 245, 182, 14},
+      {184, 147, 203, 114, 7},
+      {118, 218, 254, 10, 1}
+    },
+    { {3, 55, 138, 20, 12},
+      {73, 194, 205, 97, 0},
+      {50, 133, 30, 204, 0},
+      {8, 107, 52, 57, 2}
+    },
+    { {216, 27, 34, 208, 1},
+      {70, 74, 136, 138, 14},
+      {128, 180, 77, 129, 11},
+      {117, 17, 21, 38, 2}
+    },
+    { {25, 91, 18, 85, 10},
+      {74, 94, 137, 92, 8},
+      {90, 164, 141, 169, 8},
+      {19, 169, 23, 165, 2}
+    },
+    { {33, 72, 120, 182, 2},
+      {40, 20, 166, 80, 15},
+      {70, 209, 225, 40, 4},
+      {240, 166, 82, 129, 4}
+    },
+    { {40, 93, 236, 19, 2},
+      {98, 151, 164, 36, 13},
+      {76, 131, 123, 161, 4},
+      {178, 66, 94, 148, 6}
+    },
+    { {123, 100, 52, 77, 7},
+      {15, 61, 96, 253, 4},
+      {235, 34, 194, 109, 14},
+      {43, 240, 107, 207, 0}
+    },
+    { {98, 75, 151, 138, 7},
+      {20, 247, 104, 145, 11},
+      {229, 30, 157, 36, 6},
+      {216, 145, 110, 242, 8}
+    },
+    { {103, 119, 188, 11, 1},
+      {197, 167, 44, 245, 5},
+      {141, 3, 222, 238, 6},
+      {170, 243, 78, 90, 3}
+    },
+    { {144, 144, 113, 245, 10},
+      {120, 24, 147, 30, 6},
+      {90, 248, 224, 144, 9},
+      {103, 140, 145, 129, 14}
+    },
+    { {37, 206, 233, 123, 13},
+      {180, 164, 255, 108, 13},
+      {189, 233, 119, 58, 4},
+      {179, 111, 242, 82, 13}
+    },
+    { {253, 83, 136, 111, 13},
+      {206, 174, 111, 206, 1},
+      {191, 97, 28, 171, 15},
+      {135, 63, 103, 87, 3}
+    },
+    { {231, 105, 53, 36, 11},
+      {157, 23, 35, 211, 12},
+      {210, 74, 201, 110, 7},
+      {60, 188, 78, 139, 9}
+    },
+    { {24, 201, 137, 127, 9},
+      {30, 174, 151, 12, 9},
+      {159, 233, 25, 49, 8},
+      {147, 14, 151, 87, 8}
+    },
+    { {101, 96, 64, 176, 10},
+      {161, 20, 163, 192, 2},
+      {80, 208, 32, 106, 6},
+      {64, 60, 82, 136, 5}
+    },
+    { {56, 46, 157, 194, 13},
+      {23, 137, 109, 56, 11},
+      {180, 59, 151, 65, 12},
+      {209, 203, 105, 30, 8}
+    },
+    { {205, 242, 177, 37, 13},
+      {223, 132, 91, 214, 4},
+      {186, 72, 212, 251, 3},
+      {38, 189, 162, 31, 11}
+    },
+    { {9, 78, 179, 61, 6},
+      {26, 244, 202, 116, 12},
+      {107, 204, 215, 41, 0},
+      {50, 229, 50, 245, 8}
+    },
+    { {57, 223, 214, 61, 1},
+      {110, 239, 186, 116, 8},
+      {139, 198, 191, 185, 12},
+      {18, 229, 223, 119, 6}
+    },
+    { {249, 54, 192, 90, 7},
+      {103, 184, 232, 234, 1},
+      {229, 160, 54, 201, 15},
+      {133, 113, 113, 222, 6}
+    },
+    { {119, 243, 69, 1, 5},
+      {245, 15, 120, 197, 0},
+      {168, 10, 44, 254, 14},
+      {10, 49, 239, 10, 15}
+    },
+    { {229, 170, 108, 152, 3},
+      {165, 49, 188, 194, 14},
+      {193, 147, 101, 90, 7},
+      {116, 51, 216, 202, 5}
+    },
+    { {176, 232, 167, 19, 14},
+      {17, 221, 241, 6, 13},
+      {124, 142, 81, 112, 13},
+      {182, 8, 251, 184, 8}
+    },
+    { {221, 219, 120, 40, 6},
+      {226, 62, 94, 210, 12},
+      {97, 65, 237, 187, 11},
+      {52, 183, 167, 196, 7}
+    },
+    { {59, 9, 157, 107, 2},
+      {18, 187, 38, 93, 9},
+      {77, 107, 153, 13, 12},
+      {155, 166, 77, 212, 8}
+    },
+    { {64, 234, 217, 35, 3},
+      {53, 148, 30, 148, 9},
+      {204, 73, 181, 112, 2},
+      {146, 151, 130, 154, 12}
+    },
+    { {26, 247, 252, 44, 4},
+      {107, 175, 94, 49, 4},
+      {35, 67, 254, 245, 8},
+      {40, 199, 175, 93, 6}
+    },
+    { {60, 154, 211, 10, 11},
+      {246, 248, 57, 16, 9},
+      {213, 12, 181, 147, 12},
+      {144, 137, 193, 246, 15}
+    },
+    { {179, 6, 81, 36, 2},
+      {56, 24, 42, 115, 0},
+      {66, 72, 166, 12, 13},
+      {12, 229, 65, 129, 12}
+    },
+    { {50, 189, 243, 128, 9},
+      {117, 202, 49, 49, 14},
+      {144, 28, 251, 212, 12},
+      {120, 200, 197, 58, 14}
+    },
+    { {108, 225, 50, 82, 6},
+      {131, 86, 240, 152, 5},
+      {100, 164, 200, 115, 6},
+      {161, 144, 246, 172, 1}
+    },
+    { {87, 93, 59, 77, 8},
+      {216, 110, 5, 253, 12},
+      {27, 45, 203, 174, 10},
+      {59, 250, 7, 97, 11}
+    },
+    { {50, 250, 120, 150, 11},
+      {109, 28, 189, 17, 15},
+      {214, 145, 229, 244, 12},
+      {248, 139, 211, 139, 6}
+    },
+    { {201, 37, 74, 207, 11},
+      {47, 114, 5, 238, 3},
+      {223, 53, 42, 73, 3},
+      {199, 122, 4, 239, 4}
+    },
+    { {91, 227, 88, 153, 8},
+      {35, 46, 157, 213, 2},
+      {25, 145, 172, 125, 10},
+      {74, 187, 151, 76, 4}
+    },
+    { {162, 249, 225, 35, 2},
+      {113, 150, 50, 7, 13},
+      {76, 72, 121, 244, 5},
+      {190, 4, 198, 152, 14}
+    },
+    { {119, 181, 82, 205, 9},
+      {237, 106, 49, 253, 2},
+      {155, 52, 170, 222, 14},
+      {75, 248, 197, 107, 7}
+    },
+    { {176, 219, 205, 212, 10},
+      {120, 159, 189, 10, 10},
+      {82, 187, 61, 176, 13},
+      {85, 11, 223, 145, 14}
+    },
+    { {203, 147, 21, 157, 14},
+      {90, 51, 217, 215, 2},
+      {123, 154, 140, 157, 3},
+      {78, 185, 188, 197, 10}
+    },
+    { {126, 39, 103, 62, 11},
+      {191, 123, 171, 161, 5},
+      {215, 206, 110, 71, 14},
+      {168, 93, 93, 239, 13}
+    },
+    { {27, 68, 157, 3, 7},
+      {22, 157, 68, 117, 1},
+      {236, 11, 146, 45, 8},
+      {138, 226, 43, 150, 8}
+    },
+    { {214, 213, 57, 224, 1},
+      {212, 14, 22, 187, 6},
+      {128, 121, 202, 182, 11},
+      {109, 214, 135, 2, 11}
+    },
+    { {153, 17, 59, 93, 5},
+      {94, 106, 196, 94, 4},
+      {171, 173, 200, 137, 9},
+      {39, 162, 53, 103, 10}
+    },
+    { {237, 201, 222, 175, 0},
+      {170, 231, 54, 214, 11},
+      {15, 87, 185, 59, 7},
+      {214, 182, 206, 117, 5}
+    },
+    { {152, 79, 114, 58, 0},
+      {34, 110, 138, 50, 13},
+      {5, 196, 239, 33, 9},
+      {180, 197, 23, 100, 4}
+    },
+    { {146, 177, 194, 94, 11},
+      {109, 250, 145, 11, 1},
+      {215, 164, 56, 212, 9},
+      {141, 8, 149, 251, 6}
+    },
+    { {233, 83, 55, 170, 15},
+      {86, 119, 107, 210, 7},
+      {245, 94, 204, 169, 7},
+      {228, 189, 110, 230, 10}
+    },
+    { {184, 249, 145, 224, 11},
+      {87, 158, 51, 26, 10},
+      {208, 120, 153, 241, 13},
+      {85, 140, 199, 158, 10}
+    },
+    { {54, 190, 41, 6, 4},
+      {217, 8, 124, 33, 13},
+      {38, 9, 71, 214, 12},
+      {184, 67, 225, 9, 11}
+    },
+    { {109, 88, 75, 223, 15},
+      {254, 116, 229, 204, 11},
+      {255, 189, 33, 171, 6},
+      {211, 58, 114, 231, 15}
+    },
+    { {124, 73, 255, 32, 11},
+      {182, 223, 39, 144, 12},
+      {208, 79, 249, 35, 14},
+      {48, 158, 79, 182, 13}
+    },
+    { {204, 4, 237, 38, 9},
+      {190, 129, 7, 162, 5},
+      {150, 75, 114, 3, 3},
+      {164, 94, 8, 23, 13}
+    },
+    { {126, 191, 195, 88, 12},
+      {243, 234, 249, 169, 8},
+      {49, 172, 63, 215, 14},
+      {25, 89, 245, 124, 15}
+    },
+    { {35, 71, 74, 52, 11},
+      {44, 86, 175, 97, 0},
+      {210, 197, 46, 44, 4},
+      {8, 111, 86, 163, 4}
+    },
+    { {247, 2, 101, 153, 14},
+      {176, 57, 233, 199, 6},
+      {121, 154, 100, 14, 15},
+      {110, 57, 121, 192, 13}
+    },
+    { {183, 134, 11, 177, 9},
+      {148, 72, 191, 103, 2},
+      {152, 221, 6, 30, 13},
+      {78, 111, 209, 34, 9}
+    },
+    { {29, 237, 84, 211, 10},
+      {163, 31, 145, 124, 11},
+      {92, 178, 171, 123, 8},
+      {211, 232, 159, 140, 5}
+    },
+    { {19, 129, 28, 244, 14},
+      {8, 27, 215, 89, 2},
+      {114, 243, 136, 28, 8},
+      {73, 174, 189, 129, 0}
+    },
+    { {38, 136, 183, 166, 7},
+      {156, 209, 114, 17, 15},
+      {230, 94, 209, 22, 4},
+      {248, 132, 232, 179, 9}
+    },
+    { {218, 189, 5, 242, 12},
+      {83, 11, 211, 171, 11},
+      {52, 250, 11, 213, 11},
+      {221, 92, 189, 12, 10}
+    },
+    { {179, 196, 25, 242, 6},
+      {16, 28, 246, 123, 3},
+      {100, 249, 130, 60, 13},
+      {205, 230, 243, 128, 8}
+    },
+    { {3, 88, 126, 158, 12},
+      {104, 101, 197, 81, 15},
+      {55, 151, 225, 172, 0},
+      {248, 170, 58, 97, 6}
+    },
+    { {138, 226, 81, 223, 4},
+      {59, 36, 216, 31, 3},
+      {47, 184, 164, 117, 1},
+      {207, 129, 178, 77, 12}
+    },
+    { {116, 44, 226, 207, 6},
+      {169, 248, 96, 172, 15},
+      {111, 52, 115, 66, 14},
+      {243, 80, 97, 249, 5}
+    },
+    { {80, 87, 235, 180, 4},
+      {120, 206, 206, 160, 6},
+      {34, 221, 126, 160, 10},
+      {96, 87, 55, 49, 14}
+    },
+    { {234, 122, 109, 152, 13},
+      {119, 37, 237, 131, 14},
+      {177, 155, 101, 229, 7},
+      {124, 27, 122, 78, 14}
+    },
+    { {81, 124, 23, 242, 2},
+      {81, 93, 130, 248, 11},
+      {68, 254, 131, 232, 10},
+      {209, 244, 27, 168, 10}
+    },
+    { {116, 206, 76, 238, 0},
+      {168, 45, 62, 168, 11},
+      {7, 115, 39, 50, 14},
+      {209, 87, 203, 65, 5}
+    },
+    { {235, 112, 71, 178, 6},
+      {115, 85, 226, 195, 3},
+      {100, 222, 32, 237, 7},
+      {204, 52, 122, 172, 14}
+    },
+    { {44, 21, 121, 54, 0},
+      {250, 2, 166, 48, 5},
+      {6, 201, 234, 131, 4},
+      {160, 198, 84, 5, 15}
+    },
+    { {10, 102, 96, 115, 1},
+      {39, 4, 138, 45, 5},
+      {140, 224, 102, 101, 0},
+      {171, 69, 18, 14, 4}
+    },
+    { {15, 250, 22, 84, 3},
+      {207, 85, 152, 89, 8},
+      {194, 166, 133, 255, 0},
+      {25, 161, 154, 175, 3}
+    },
+    { {248, 13, 152, 242, 6},
+      {2, 154, 230, 186, 11},
+      {100, 241, 155, 1, 15},
+      {213, 214, 117, 148, 0}
+    },
+    { {17, 81, 213, 137, 2},
+      {112, 191, 0, 84, 2},
+      {73, 26, 184, 168, 8},
+      {66, 160, 15, 208, 14}
+    },
+    { {90, 127, 72, 72, 2},
+      {99, 62, 12, 169, 8},
+      {65, 33, 47, 229, 10},
+      {25, 83, 7, 204, 6}
+    },
+    { {220, 246, 137, 159, 6},
+      {219, 188, 220, 166, 3},
+      {111, 153, 22, 243, 11},
+      {198, 83, 179, 221, 11}
+    },
+    { {142, 116, 239, 41, 6},
+      {243, 245, 70, 39, 4},
+      {105, 79, 114, 231, 1},
+      {46, 70, 42, 252, 15}
+    },
+    { {122, 205, 165, 235, 5},
+      {22, 175, 114, 173, 15},
+      {173, 122, 91, 53, 14},
+      {251, 84, 239, 86, 8}
+    },
+    { {73, 74, 158, 70, 15},
+      {14, 213, 77, 216, 9},
+      {246, 39, 149, 41, 2},
+      {145, 187, 42, 183, 0}
+    },
+    { {92, 188, 59, 49, 3},
+      {215, 88, 150, 180, 12},
+      {200, 205, 195, 211, 10},
+      {50, 214, 145, 174, 11}
+    },
+    { {24, 172, 214, 61, 15},
+      {47, 249, 211, 52, 8},
+      {251, 198, 179, 81, 8},
+      {18, 204, 185, 255, 4}
+    },
+    { {128, 152, 198, 222, 6},
+      {104, 241, 208, 10, 11},
+      {103, 182, 49, 144, 1},
+      {213, 0, 184, 241, 6}
+    },
+    { {171, 158, 93, 173, 10},
+      {122, 49, 63, 119, 10},
+      {91, 91, 167, 157, 5},
+      {94, 239, 200, 197, 14}
+    },
+    { {187, 215, 181, 242, 15},
+      {86, 159, 251, 123, 7},
+      {244, 250, 222, 189, 13},
+      {237, 237, 255, 150, 10}
+    },
+    { {231, 64, 19, 227, 5},
+      {148, 68, 98, 223, 3},
+      {172, 124, 128, 46, 7},
+      {207, 180, 98, 34, 9}
+    },
+    { {185, 180, 142, 161, 12},
+      {67, 201, 119, 102, 2},
+      {56, 87, 18, 217, 13},
+      {70, 110, 233, 60, 2}
+    },
+    { {45, 174, 203, 210, 6},
+      {179, 208, 252, 104, 11},
+      {100, 189, 55, 91, 4},
+      {209, 99, 240, 188, 13}
+    },
+    { {14, 251, 136, 89, 3},
+      {199, 182, 156, 13, 8},
+      {201, 161, 29, 247, 0},
+      {27, 3, 150, 222, 3}
+    },
+    { {140, 253, 170, 193, 1},
+      {199, 198, 20, 46, 14},
+      {136, 53, 91, 243, 1},
+      {119, 66, 134, 62, 3}
+    },
+    { {80, 221, 255, 96, 6},
+      {112, 223, 86, 184, 12},
+      {96, 111, 251, 176, 10},
+      {49, 214, 175, 176, 14}
+    },
+    { {171, 67, 201, 91, 13},
+      {54, 166, 237, 79, 1},
+      {189, 169, 60, 45, 5},
+      {143, 43, 118, 86, 12}
+    },
+    { {80, 242, 159, 163, 14},
+      {81, 221, 95, 148, 3},
+      {124, 95, 148, 240, 10},
+      {194, 159, 171, 184, 10}
+    },
+    { {128, 166, 71, 246, 14},
+      {57, 81, 219, 42, 3},
+      {118, 254, 38, 80, 1},
+      {197, 77, 184, 169, 12}
+    },
+    { {60, 168, 157, 27, 10},
+      {147, 185, 181, 20, 9},
+      {93, 139, 145, 83, 12},
+      {146, 138, 217, 220, 9}
+    },
+    { {24, 77, 221, 97, 1},
+      {54, 143, 6, 60, 8},
+      {136, 107, 187, 33, 8},
+      {19, 198, 15, 22, 12}
+    },
+    { {83, 127, 71, 115, 5},
+      {117, 79, 202, 237, 9},
+      {172, 238, 47, 236, 10},
+      {155, 117, 63, 42, 14}
+    },
+    { {164, 149, 152, 181, 4},
+      {200, 130, 246, 54, 2},
+      {42, 209, 154, 146, 5},
+      {70, 198, 244, 17, 3}
+    },
+    { {58, 161, 233, 220, 1},
+      {63, 170, 180, 9, 6},
+      {131, 185, 120, 85, 12},
+      {105, 2, 213, 95, 12}
+    },
+    { {72, 193, 6, 108, 11},
+      {14, 119, 19, 136, 0},
+      {211, 102, 8, 49, 2},
+      {1, 28, 142, 231, 0}
+    },
+    { {227, 219, 6, 53, 1},
+      {76, 71, 186, 199, 8},
+      {138, 198, 13, 188, 7},
+      {30, 53, 222, 35, 2}
+    },
+    { {26, 241, 58, 17, 0},
+      {67, 78, 148, 21, 4},
+      {8, 133, 200, 245, 8},
+      {42, 130, 151, 44, 2}
+    },
+    { {137, 31, 189, 213, 1},
+      {94, 131, 140, 126, 14},
+      {138, 187, 223, 137, 1},
+      {119, 227, 28, 23, 10}
+    },
+    { {142, 68, 6, 133, 7},
+      {142, 85, 64, 39, 2},
+      {234, 22, 2, 39, 1},
+      {78, 64, 42, 167, 1}
+    },
+    { {135, 127, 42, 107, 5},
+      {197, 102, 78, 111, 13},
+      {173, 101, 79, 238, 1},
+      {191, 103, 38, 106, 3}
+    },
+    { {122, 152, 134, 35, 6},
+      {66, 217, 114, 133, 9},
+      {108, 70, 17, 149, 14},
+      {154, 20, 233, 180, 2}
+    },
+    { {228, 197, 141, 119, 10},
+      {152, 151, 183, 174, 1},
+      {94, 235, 26, 50, 7},
+      {135, 94, 222, 145, 9}
+    },
+    { {70, 156, 46, 177, 8},
+      {192, 65, 151, 165, 14},
+      {24, 215, 67, 150, 2},
+      {122, 94, 152, 32, 3}
+    },
+    { {165, 170, 62, 63, 8},
+      {137, 97, 191, 86, 13},
+      {31, 199, 197, 90, 5},
+      {182, 175, 216, 105, 1}
+    },
+    { {14, 105, 46, 93, 5},
+      {143, 103, 196, 13, 12},
+      {171, 167, 73, 103, 0},
+      {59, 2, 62, 111, 1}
+    },
+    { {6, 57, 165, 147, 9},
+      {213, 131, 129, 5, 15},
+      {156, 154, 89, 198, 0},
+      {250, 8, 28, 26, 11}
+    },
+    { {96, 63, 93, 167, 6},
+      {121, 19, 110, 180, 11},
+      {110, 91, 175, 192, 6},
+      {210, 215, 108, 137, 14}
+    },
+    { {72, 219, 238, 150, 9},
+      {110, 199, 157, 128, 15},
+      {150, 151, 125, 177, 2},
+      {240, 27, 158, 55, 6}
+    },
+    { {95, 215, 109, 233, 5},
+      {246, 47, 94, 237, 6},
+      {169, 123, 110, 191, 10},
+      {107, 119, 175, 70, 15}
+    },
+    { {101, 185, 180, 188, 6},
+      {201, 179, 242, 208, 14},
+      {99, 210, 217, 218, 6},
+      {112, 180, 252, 217, 3}
+    },
+    { {6, 179, 0, 213, 15},
+      {205, 18, 217, 13, 2},
+      {250, 176, 12, 214, 0},
+      {75, 9, 180, 139, 3}
+    },
+    { {76, 98, 251, 222, 11},
+      {191, 244, 141, 152, 7},
+      {215, 189, 244, 99, 2},
+      {225, 155, 18, 255, 13}
+    },
+    { {154, 177, 225, 193, 15},
+      {119, 154, 81, 15, 6},
+      {248, 56, 120, 213, 9},
+      {111, 8, 165, 158, 14}
+    },
+    { {116, 98, 52, 56, 13},
+      {133, 45, 235, 144, 4},
+      {177, 194, 196, 98, 14},
+      {32, 157, 123, 74, 1}
+    },
+    { {229, 34, 138, 114, 8},
+      {129, 192, 175, 202, 1},
+      {20, 229, 20, 74, 7},
+      {133, 63, 80, 56, 1}
+    },
+    { {20, 217, 9, 82, 15},
+      {212, 30, 213, 8, 9},
+      {244, 169, 9, 178, 8},
+      {145, 10, 183, 130, 11}
+    },
+    { {218, 24, 89, 233, 7},
+      {118, 56, 70, 159, 10},
+      {233, 121, 161, 133, 11},
+      {95, 150, 33, 198, 14}
+    },
+    { {38, 80, 144, 16, 9},
+      {196, 132, 161, 17, 0},
+      {144, 128, 144, 166, 4},
+      {8, 136, 82, 18, 3}
+    },
+    { {25, 235, 51, 121, 9},
+      {23, 110, 155, 92, 12},
+      {153, 236, 205, 121, 8},
+      {51, 173, 151, 110, 8}
+    },
+    { {105, 80, 30, 18, 12},
+      {66, 69, 229, 208, 1},
+      {52, 135, 128, 169, 6},
+      {128, 186, 122, 36, 2}
+    },
+    { {150, 139, 94, 59, 15},
+      {164, 123, 223, 23, 9},
+      {253, 199, 173, 22, 9},
+      {158, 143, 189, 226, 5}
+    },
+    { {218, 116, 48, 6, 5},
+      {79, 12, 64, 179, 5},
+      {166, 0, 194, 229, 11},
+      {172, 208, 35, 15, 2}
+    },
+    { {25, 179, 22, 144, 13},
+      {71, 75, 217, 80, 2},
+      {176, 150, 140, 217, 8},
+      {64, 169, 189, 46, 2}
+    },
+    { {25, 3, 122, 37, 8},
+      {42, 74, 15, 84, 4},
+      {26, 69, 236, 9, 8},
+      {34, 175, 5, 37, 4}
+    },
+    { {45, 131, 24, 137, 9},
+      {134, 34, 61, 84, 2},
+      {153, 17, 140, 27, 4},
+      {66, 171, 196, 70, 1}
+    },
+    { {90, 179, 165, 245, 1},
+      {95, 139, 154, 141, 6},
+      {138, 250, 92, 213, 10},
+      {107, 21, 157, 31, 10}
+    },
+    { {122, 166, 126, 219, 8},
+      {35, 105, 189, 189, 7},
+      {29, 183, 230, 85, 14},
+      {235, 219, 217, 108, 4}
+    },
+    { {74, 39, 236, 111, 9},
+      {47, 163, 15, 173, 5},
+      {159, 99, 126, 69, 2},
+      {171, 95, 12, 95, 4}
+    },
+    { {199, 32, 161, 106, 9},
+      {149, 160, 3, 203, 5},
+      {149, 104, 80, 78, 3},
+      {173, 60, 0, 90, 9}
+    },
+    { {70, 101, 77, 162, 0},
+      {177, 7, 6, 161, 3},
+      {4, 91, 42, 102, 2},
+      {200, 86, 14, 8, 13}
+    },
+    { {69, 170, 40, 84, 15},
+      {141, 16, 221, 200, 12},
+      {242, 161, 69, 90, 2},
+      {49, 59, 176, 139, 1}
+    },
+    { {174, 121, 83, 131, 6},
+      {243, 86, 96, 23, 11},
+      {108, 28, 169, 231, 5},
+      {222, 128, 102, 172, 15}
+    },
+    { {156, 98, 82, 80, 12},
+      {163, 76, 201, 26, 0},
+      {48, 164, 164, 99, 9},
+      {5, 137, 51, 44, 5}
+    },
+    { {12, 88, 52, 54, 3},
+      {206, 21, 130, 16, 13},
+      {198, 194, 193, 163, 0},
+      {176, 132, 26, 135, 3}
+    },
+    { {74, 45, 0, 174, 1},
+      {15, 34, 2, 161, 11},
+      {135, 80, 11, 69, 2},
+      {216, 84, 4, 79, 0}
+    },
+    { {116, 221, 28, 199, 10},
+      {200, 31, 53, 188, 11},
+      {94, 51, 139, 178, 14},
+      {211, 218, 207, 129, 3}
+    },
+    { {255, 184, 139, 185, 11},
+      {215, 248, 183, 199, 10},
+      {217, 221, 17, 223, 15},
+      {94, 62, 209, 254, 11}
+    },
+    { {72, 11, 173, 35, 1},
+      {22, 131, 14, 132, 13},
+      {140, 75, 93, 1, 2},
+      {178, 23, 12, 22, 8}
+    },
+    { {7, 41, 136, 152, 1},
+      {133, 162, 132, 65, 10},
+      {129, 145, 25, 78, 0},
+      {88, 34, 20, 90, 1}
+    },
+    { {230, 29, 184, 139, 11},
+      {196, 178, 37, 183, 15},
+      {221, 17, 219, 134, 7},
+      {254, 218, 68, 210, 3}
+    },
+    { {115, 138, 131, 230, 3},
+      {28, 216, 58, 201, 11},
+      {198, 124, 21, 28, 14},
+      {217, 53, 193, 179, 8}
+    },
+    { {39, 0, 88, 211, 10},
+      {160, 16, 165, 93, 3},
+      {92, 177, 160, 14, 4},
+      {203, 170, 80, 128, 5}
+    },
+    { {99, 133, 237, 25, 0},
+      {48, 163, 180, 229, 4},
+      {9, 139, 122, 28, 6},
+      {42, 114, 220, 80, 12}
+    },
+    { {43, 58, 207, 150, 12},
+      {123, 193, 237, 65, 11},
+      {54, 159, 53, 205, 4},
+      {216, 43, 120, 61, 14}
+    },
+    { {219, 208, 152, 69, 3},
+      {78, 156, 20, 223, 0},
+      {202, 33, 144, 189, 11},
+      {15, 178, 131, 151, 2}
+    },
+    { {157, 205, 210, 135, 6},
+      {170, 222, 80, 118, 11},
+      {110, 20, 187, 59, 9},
+      {214, 224, 167, 181, 5}
+    },
+    { {49, 244, 150, 171, 1},
+      {69, 237, 50, 116, 3},
+      {141, 86, 146, 248, 12},
+      {194, 228, 203, 122, 2}
+    },
+    { {31, 47, 77, 37, 3},
+      {191, 27, 14, 101, 8},
+      {202, 75, 47, 79, 8},
+      {26, 103, 13, 143, 13}
+    },
+    { {238, 22, 15, 225, 14},
+      {210, 81, 111, 175, 2},
+      {120, 127, 6, 135, 7},
+      {79, 95, 104, 164, 11}
+    },
+    { {10, 161, 221, 53, 1},
+      {63, 131, 150, 21, 0},
+      {138, 203, 184, 85, 0},
+      {10, 134, 156, 31, 12}
+    },
+    { {86, 173, 47, 172, 10},
+      {153, 123, 23, 161, 14},
+      {83, 95, 75, 86, 10},
+      {120, 94, 141, 233, 9}
+    },
+    { {211, 126, 245, 50, 15},
+      {117, 157, 203, 243, 13},
+      {244, 202, 247, 236, 11},
+      {188, 253, 59, 154, 14}
+    },
+    { {26, 77, 168, 98, 11},
+      {6, 158, 7, 41, 13},
+      {212, 97, 91, 37, 8},
+      {185, 78, 7, 150, 0}
+    },
+    { {14, 14, 83, 226, 12},
+      {178, 64, 75, 57, 11},
+      {52, 124, 167, 7, 0},
+      {217, 205, 32, 36, 13}
+    },
+    { {186, 19, 25, 227, 12},
+      {82, 10, 111, 31, 3},
+      {60, 121, 140, 133, 13},
+      {207, 143, 101, 4, 10}
+    },
+    { {166, 38, 10, 6, 2},
+      {137, 80, 44, 35, 1},
+      {70, 5, 6, 70, 5},
+      {140, 67, 64, 169, 1}
+    },
+    { {59, 165, 11, 14, 1},
+      {31, 106, 52, 97, 1},
+      {135, 13, 10, 93, 12},
+      {136, 98, 197, 111, 8}
+    },
+    { {38, 36, 208, 138, 6},
+      {161, 176, 96, 49, 3},
+      {101, 16, 178, 70, 4},
+      {200, 192, 96, 216, 5}
+    },
+    { {34, 170, 93, 184, 11},
+      {53, 49, 191, 17, 10},
+      {209, 219, 165, 84, 4},
+      {88, 143, 216, 202, 12}
+    },
+    { {204, 89, 30, 234, 11},
+      {198, 119, 7, 154, 11},
+      {213, 119, 137, 163, 3},
+      {213, 158, 14, 230, 3}
+    },
+    { {93, 163, 232, 36, 7},
+      {175, 154, 94, 192, 4},
+      {226, 65, 124, 91, 10},
+      {32, 55, 165, 159, 5}
+    },
+    { {49, 70, 31, 250, 13},
+      {20, 109, 239, 120, 3},
+      {181, 255, 134, 40, 12},
+      {193, 239, 123, 98, 8}
+    },
+    { {225, 228, 77, 220, 5},
+      {61, 37, 244, 234, 2},
+      {163, 187, 34, 120, 7},
+      {69, 114, 250, 75, 12}
+    },
+    { {44, 242, 109, 104, 5},
+      {247, 37, 126, 8, 4},
+      {161, 107, 100, 243, 4},
+      {33, 7, 234, 78, 15}
+    },
+    { {188, 184, 23, 132, 2},
+      {219, 89, 48, 18, 10},
+      {66, 30, 129, 211, 13},
+      {84, 128, 201, 173, 11}
+    },
+    { {229, 105, 162, 218, 12},
+      {129, 230, 225, 202, 15},
+      {53, 180, 89, 106, 7},
+      {245, 56, 118, 120, 1}
+    },
+    { {126, 187, 69, 235, 1},
+      {247, 43, 58, 141, 11},
+      {141, 122, 45, 215, 14},
+      {219, 21, 205, 78, 15}
+    },
+    { {95, 193, 180, 208, 10},
+      {130, 159, 145, 217, 6},
+      {80, 178, 216, 63, 10},
+      {105, 184, 159, 148, 1}
+    },
+    { {67, 231, 225, 87, 9},
+      {61, 134, 153, 237, 5},
+      {158, 168, 126, 124, 2},
+      {171, 121, 150, 27, 12}
+    },
+    { {74, 231, 170, 10, 11},
+      {7, 246, 29, 161, 5},
+      {213, 5, 94, 117, 2},
+      {168, 91, 134, 254, 0}
+    },
+    { {165, 185, 85, 105, 15},
+      {245, 51, 115, 94, 8},
+      {249, 106, 169, 218, 5},
+      {23, 172, 236, 202, 15}
+    },
+    { {224, 84, 118, 144, 13},
+      {100, 69, 225, 178, 6},
+      {176, 150, 226, 160, 7},
+      {100, 216, 122, 34, 6}
+    },
+    { {210, 45, 14, 153, 2},
+      {1, 123, 132, 167, 10},
+      {73, 151, 11, 68, 11},
+      {94, 82, 29, 232, 0}
+    },
+    { {24, 168, 223, 230, 1},
+      {63, 201, 22, 24, 11},
+      {134, 127, 177, 81, 8},
+      {209, 134, 137, 63, 12}
+    },
+    { {69, 219, 175, 11, 10},
+      {208, 247, 29, 196, 13},
+      {93, 15, 93, 186, 2},
+      {178, 59, 142, 240, 11}
+    },
+    { {120, 139, 137, 141, 8},
+      {26, 170, 61, 132, 10},
+      {27, 25, 29, 17, 14},
+      {82, 27, 197, 85, 8}
+    },
+    { {241, 221, 156, 23, 1},
+      {76, 143, 180, 246, 9},
+      {142, 131, 155, 184, 15},
+      {150, 242, 223, 19, 2}
+    },
+    { {168, 83, 82, 179, 8},
+      {98, 70, 171, 22, 3},
+      {28, 212, 172, 161, 5},
+      {198, 141, 86, 36, 6}
+    },
+    { {168, 106, 55, 142, 9},
+      {31, 101, 41, 18, 15},
+      {151, 30, 197, 97, 5},
+      {244, 137, 74, 111, 8}
+    },
+    { {189, 126, 84, 235, 14},
+      {227, 61, 107, 126, 11},
+      {125, 114, 167, 235, 13},
+      {215, 237, 107, 204, 7}
+    },
+    { {223, 220, 164, 141, 1},
+      {206, 173, 16, 231, 14},
+      {139, 18, 83, 191, 11},
+      {126, 112, 139, 87, 3}
+    },
+    { {164, 184, 123, 136, 7},
+      {245, 112, 116, 18, 14},
+      {225, 29, 225, 210, 5},
+      {116, 130, 224, 234, 15}
+    },
+    { {156, 22, 106, 229, 0},
+      {234, 72, 14, 46, 6},
+      {10, 117, 102, 131, 9},
+      {103, 71, 1, 37, 7}
+    },
+    { {7, 66, 172, 242, 15},
+      {132, 149, 207, 73, 7},
+      {244, 243, 84, 46, 0},
+      {233, 47, 58, 146, 1}
+    },
+    { {76, 120, 158, 87, 8},
+      {203, 197, 133, 156, 9},
+      {30, 167, 145, 227, 2},
+      {147, 154, 26, 61, 3}
+    },
+    { {154, 239, 33, 84, 12},
+      {27, 14, 217, 43, 12},
+      {50, 168, 79, 117, 9},
+      {61, 73, 183, 13, 8}
+    },
+    { {114, 33, 143, 98, 6},
+      {17, 219, 102, 137, 1},
+      {100, 111, 24, 68, 14},
+      {137, 22, 109, 184, 8}
+    },
+    { {144, 22, 79, 84, 2},
+      {120, 89, 140, 42, 0},
+      {66, 175, 38, 128, 9},
+      {5, 67, 25, 161, 14}
+    },
+    { {255, 38, 45, 47, 8},
+      {155, 41, 47, 231, 5},
+      {31, 75, 70, 79, 15},
+      {174, 127, 73, 77, 9}
+    },
+    { {155, 75, 33, 101, 11},
+      {30, 30, 11, 79, 12},
+      {218, 104, 77, 45, 9},
+      {63, 45, 7, 135, 8}
+    },
+    { {157, 250, 242, 161, 11},
+      {231, 220, 27, 86, 14},
+      {216, 84, 245, 251, 9},
+      {118, 173, 131, 190, 7}
+    },
+    { {88, 151, 203, 43, 2},
+      {114, 250, 30, 164, 1},
+      {77, 77, 62, 145, 10},
+      {130, 87, 133, 244, 14}
+    },
+    { {71, 47, 124, 245, 10},
+      {169, 19, 143, 253, 14},
+      {90, 243, 239, 78, 2},
+      {123, 255, 28, 137, 5}
+    },
+    { {231, 58, 247, 133, 1},
+      {253, 193, 40, 215, 14},
+      {138, 30, 245, 206, 7},
+      {126, 177, 72, 59, 15}
+    },
+    { {207, 215, 242, 172, 4},
+      {234, 230, 90, 243, 6},
+      {35, 84, 254, 191, 3},
+      {108, 245, 166, 117, 7}
+    },
+    { {34, 145, 90, 60, 13},
+      {108, 98, 247, 17, 0},
+      {179, 197, 168, 148, 4},
+      {8, 142, 244, 99, 6}
+    },
+    { {34, 133, 70, 209, 9},
+      {36, 67, 177, 45, 2},
+      {152, 182, 42, 20, 4},
+      {75, 72, 220, 34, 4}
+    },
+    { {114, 208, 93, 189, 9},
+      {124, 45, 183, 149, 2},
+      {155, 219, 160, 180, 14},
+      {74, 158, 219, 67, 14}
+    },
+    { {66, 217, 149, 82, 0},
+      {80, 135, 144, 153, 9},
+      {4, 170, 153, 180, 2},
+      {153, 144, 158, 16, 10}
+    },
+    { {138, 133, 121, 144, 1},
+      {54, 2, 148, 51, 6},
+      {128, 153, 234, 21, 1},
+      {108, 194, 148, 6, 12}
+    },
+    { {197, 198, 42, 24, 4},
+      {128, 100, 220, 226, 4},
+      {33, 133, 70, 58, 3},
+      {36, 115, 178, 96, 1}
+    },
+    { {233, 151, 88, 80, 13},
+      {102, 2, 253, 250, 0},
+      {176, 161, 174, 153, 7},
+      {5, 251, 244, 6, 6}
+    },
+    { {14, 234, 177, 70, 7},
+      {159, 148, 88, 25, 13},
+      {230, 40, 213, 119, 0},
+      {185, 129, 162, 159, 9}
+    },
+    { {145, 53, 173, 2, 13},
+      {85, 139, 69, 98, 5},
+      {180, 11, 90, 200, 9},
+      {164, 106, 45, 26, 10}
+    },
+    { {190, 141, 200, 78, 4},
+      {170, 170, 116, 43, 9},
+      {39, 33, 59, 23, 13},
+      {157, 66, 229, 85, 5}
+    },
+    { {173, 173, 184, 75, 2},
+      {131, 178, 52, 126, 13},
+      {77, 33, 219, 91, 5},
+      {183, 226, 196, 220, 1}
+    },
+    { {239, 18, 224, 176, 8},
+      {226, 128, 171, 195, 6},
+      {16, 208, 116, 143, 7},
+      {108, 61, 80, 20, 7}
+    },
+    { {110, 30, 54, 228, 4},
+      {202, 65, 106, 185, 14},
+      {34, 118, 199, 135, 6},
+      {121, 213, 104, 37, 3}
+    },
+    { {182, 167, 125, 25, 13},
+      {181, 43, 253, 55, 4},
+      {185, 139, 238, 86, 13},
+      {46, 203, 253, 74, 13}
+    },
+    { {23, 86, 83, 139, 13},
+      {244, 108, 73, 117, 3},
+      {189, 28, 166, 174, 8},
+      {202, 233, 35, 98, 15}
+    },
+    { {95, 18, 213, 36, 1},
+      {254, 137, 10, 209, 0},
+      {130, 74, 180, 143, 10},
+      {8, 181, 9, 23, 15}
+    },
+    { {70, 117, 172, 246, 3},
+      {205, 151, 134, 169, 7},
+      {198, 243, 90, 230, 2},
+      {233, 86, 30, 155, 3}
+    },
+    { {60, 106, 94, 42, 12},
+      {163, 109, 111, 16, 9},
+      {53, 71, 165, 99, 12},
+      {144, 143, 107, 108, 5}
+    },
+    { {36, 27, 3, 248, 15},
+      {212, 114, 235, 8, 10},
+      {241, 252, 13, 130, 4},
+      {81, 13, 116, 226, 11}
+    },
+    { {174, 183, 170, 241, 10},
+      {195, 210, 191, 47, 6},
+      {88, 245, 94, 215, 5},
+      {111, 79, 212, 188, 3}
+    },
+    { {128, 123, 11, 149, 5},
+      {93, 70, 204, 6, 10},
+      {170, 157, 13, 224, 1},
+      {86, 3, 54, 43, 10}
+    },
+    { {6, 123, 185, 142, 2},
+      {217, 182, 12, 17, 15},
+      {71, 25, 221, 230, 0},
+      {248, 131, 6, 217, 11}
+    },
+    { {187, 205, 97, 202, 11},
+      {54, 62, 49, 107, 15},
+      {213, 56, 107, 61, 13},
+      {253, 104, 199, 198, 12}
+    },
+    { {102, 111, 155, 27, 2},
+      {145, 246, 172, 181, 9},
+      {77, 141, 159, 102, 6},
+      {154, 211, 86, 248, 9}
+    },
+    { {220, 128, 108, 119, 5},
+      {174, 9, 214, 142, 5},
+      {174, 227, 96, 19, 11},
+      {167, 22, 185, 7, 5}
+    },
+    { {244, 76, 119, 37, 13},
+      {188, 77, 99, 182, 12},
+      {186, 78, 227, 34, 15},
+      {54, 220, 107, 35, 13}
+    },
+    { {114, 219, 75, 25, 1},
+      {116, 110, 188, 133, 8},
+      {137, 141, 45, 180, 14},
+      {26, 19, 215, 98, 14}
+    },
+    { {16, 18, 108, 127, 9},
+      {108, 41, 143, 12, 5},
+      {159, 227, 100, 128, 8},
+      {163, 15, 25, 67, 6}
+    },
+    { {162, 1, 124, 141, 13},
+      {44, 35, 101, 23, 6},
+      {187, 19, 232, 4, 5},
+      {110, 138, 108, 67, 4}
+    },
+    { {92, 43, 98, 199, 13},
+      {175, 74, 73, 140, 15},
+      {190, 52, 109, 67, 10},
+      {243, 25, 37, 47, 5}
+    },
+    { {246, 17, 249, 50, 13},
+      {244, 138, 231, 147, 5},
+      {180, 201, 248, 134, 15},
+      {172, 158, 117, 18, 15}
+    },
+    { {29, 202, 246, 89, 3},
+      {166, 253, 152, 92, 12},
+      {201, 166, 245, 59, 8},
+      {51, 161, 155, 246, 5}
+    },
+    { {246, 222, 90, 183, 0},
+      {232, 76, 190, 183, 11},
+      {14, 213, 167, 182, 15},
+      {222, 215, 211, 33, 7}
+    },
+    { {2, 227, 95, 133, 4},
+      {57, 71, 92, 21, 2},
+      {42, 31, 172, 116, 0},
+      {74, 131, 174, 41, 12}
+    },
+    { {154, 82, 200, 49, 13},
+      {102, 140, 207, 7, 0},
+      {184, 193, 52, 165, 9},
+      {14, 15, 51, 22, 6}
+    },
+    { {201, 156, 238, 248, 13},
+      {102, 225, 215, 234, 14},
+      {177, 247, 115, 153, 3},
+      {117, 126, 184, 118, 6}
+    },
+    { {164, 0, 185, 178, 3},
+      {148, 144, 166, 18, 7},
+      {196, 217, 208, 2, 5},
+      {228, 134, 80, 146, 9}
+    },
+    { {83, 189, 160, 149, 3},
+      {77, 154, 144, 229, 14},
+      {202, 144, 91, 220, 10},
+      {122, 112, 149, 155, 2}
+    },
+    { {229, 156, 80, 168, 12},
+      {224, 32, 115, 242, 10},
+      {49, 80, 163, 154, 7},
+      {84, 252, 224, 64, 7}
+    },
+    { {171, 95, 148, 193, 7},
+      {70, 151, 104, 127, 10},
+      {232, 50, 159, 173, 5},
+      {95, 225, 110, 150, 2}
+    },
+    { {154, 1, 159, 43, 13},
+      {22, 235, 71, 23, 1},
+      {189, 79, 152, 5, 9},
+      {142, 142, 45, 118, 8}
+    },
+    { {179, 111, 58, 61, 12},
+      {9, 110, 239, 119, 12},
+      {59, 197, 207, 108, 13},
+      {62, 239, 119, 105, 0}
+    },
+    { {192, 187, 244, 25, 3},
+      {101, 179, 152, 150, 12},
+      {201, 130, 253, 208, 3},
+      {54, 145, 156, 218, 6}
+    },
+    { {20, 123, 78, 197, 0},
+      {233, 79, 12, 12, 10},
+      {10, 55, 45, 226, 8},
+      {83, 3, 15, 41, 7}
+    },
+    { {90, 199, 71, 252, 14},
+      {58, 127, 219, 169, 2},
+      {115, 254, 46, 53, 10},
+      {73, 93, 191, 229, 12}
+    },
+    { {55, 33, 111, 157, 0},
+      {185, 107, 164, 69, 6},
+      {11, 159, 104, 78, 12},
+      {106, 34, 93, 105, 13}
+    },
+    { {1, 111, 252, 42, 3},
+      {37, 183, 14, 112, 13},
+      {197, 67, 255, 104, 0},
+      {176, 231, 14, 218, 4}
+    },
+    { {89, 15, 175, 61, 8},
+      {26, 235, 143, 228, 12},
+      {27, 207, 95, 9, 10},
+      {50, 127, 29, 117, 8}
+    },
+    { {153, 1, 84, 216, 10},
+      {34, 59, 129, 90, 2},
+      {81, 178, 168, 9, 9},
+      {69, 168, 29, 196, 4}
+    },
+    { {67, 238, 76, 167, 7},
+      {45, 21, 94, 229, 11},
+      {238, 83, 39, 124, 2},
+      {218, 119, 170, 139, 4}
+    },
+    { {54, 90, 193, 205, 0},
+      {248, 172, 40, 13, 10},
+      {11, 56, 53, 166, 12},
+      {91, 1, 67, 81, 15}
+    },
+    { {131, 166, 230, 183, 5},
+      {45, 193, 218, 103, 7},
+      {174, 214, 118, 92, 1},
+      {238, 101, 184, 59, 4}
+    },
+    { {19, 38, 191, 52, 9},
+      {29, 201, 143, 113, 4},
+      {146, 207, 214, 76, 8},
+      {40, 239, 25, 59, 8}
+    },
+    { {75, 112, 99, 4, 11},
+      {127, 84, 1, 193, 4},
+      {210, 12, 96, 237, 2},
+      {40, 56, 2, 175, 14}
+    },
+    { {138, 249, 189, 185, 10},
+      {83, 183, 151, 23, 14},
+      {89, 219, 217, 245, 1},
+      {126, 142, 158, 220, 10}
+    },
+    { {210, 150, 211, 86, 13},
+      {124, 200, 217, 187, 1},
+      {182, 172, 182, 148, 11},
+      {141, 217, 177, 51, 14}
+    },
+    { {191, 171, 59, 228, 2},
+      {155, 90, 62, 91, 14},
+      {66, 125, 205, 95, 13},
+      {125, 167, 197, 173, 9}
+    },
+    { {174, 86, 204, 98, 6},
+      {226, 149, 110, 43, 1},
+      {100, 99, 54, 167, 5},
+      {141, 71, 106, 148, 7}
+    },
+    { {178, 87, 177, 0, 1},
+      {84, 142, 40, 51, 4},
+      {128, 8, 222, 164, 13},
+      {44, 193, 71, 18, 10}
+    },
+    { {62, 59, 212, 245, 0},
+      {235, 139, 170, 29, 10},
+      {10, 242, 189, 199, 12},
+      {91, 133, 93, 29, 7}
+    },
+    { {81, 226, 98, 81, 13},
+      {37, 76, 217, 204, 4},
+      {184, 164, 100, 120, 10},
+      {35, 57, 179, 42, 4}
+    },
+    { {109, 172, 163, 64, 13},
+      {151, 192, 113, 232, 12},
+      {176, 44, 83, 91, 6},
+      {49, 120, 224, 62, 9}
+    },
+    { {140, 97, 186, 38, 3},
+      {143, 214, 6, 18, 5},
+      {198, 69, 216, 99, 1},
+      {164, 134, 6, 191, 1}
+    },
+    { {188, 245, 45, 34, 0},
+      {211, 15, 54, 34, 5},
+      {4, 75, 74, 243, 13},
+      {164, 70, 207, 12, 11}
+    },
+    { {211, 103, 251, 121, 3},
+      {53, 254, 142, 255, 4},
+      {201, 237, 254, 108, 11},
+      {47, 247, 23, 250, 12}
+    },
+    { {84, 87, 19, 84, 12},
+      {216, 78, 201, 184, 0},
+      {50, 172, 142, 162, 10},
+      {1, 217, 55, 33, 11}
+    },
+    { {252, 69, 102, 73, 14},
+      {162, 127, 97, 174, 4},
+      {121, 38, 106, 35, 15},
+      {39, 88, 111, 228, 5}
+    },
+    { {201, 116, 9, 180, 3},
+      {95, 20, 134, 226, 2},
+      {194, 217, 2, 233, 3},
+      {68, 118, 18, 143, 10}
+    },
+    { {219, 223, 58, 117, 6},
+      {74, 94, 222, 255, 12},
+      {106, 229, 207, 189, 11},
+      {63, 247, 183, 165, 2}
+    },
+    { {124, 198, 54, 99, 4},
+      {130, 77, 122, 188, 5},
+      {44, 102, 198, 51, 14},
+      {163, 213, 235, 36, 1}
+    },
+    { {199, 37, 21, 237, 7},
+      {157, 51, 66, 255, 2},
+      {235, 122, 138, 78, 3},
+      {79, 244, 44, 203, 9}
+    },
+    { {243, 129, 78, 141, 3},
+      {44, 123, 52, 199, 2},
+      {203, 23, 40, 28, 15},
+      {78, 50, 205, 227, 4}
+    },
+    { {1, 97, 236, 83, 14},
+      {33, 151, 197, 76, 5},
+      {124, 163, 120, 104, 0},
+      {163, 42, 62, 152, 4}
+    },
+    { {185, 10, 129, 53, 14},
+      {26, 152, 235, 70, 8},
+      {122, 200, 21, 9, 13},
+      {22, 45, 113, 149, 8}
+    },
+    { {206, 10, 5, 154, 5},
+      {150, 33, 200, 131, 11},
+      {165, 154, 5, 7, 3},
+      {220, 17, 56, 70, 9}
+    },
+    { {177, 143, 157, 57, 3},
+      {20, 187, 190, 118, 8},
+      {201, 203, 159, 24, 13},
+      {22, 231, 221, 210, 8}
+    },
+    { {148, 176, 8, 30, 13},
+      {205, 40, 213, 2, 1},
+      {183, 129, 0, 210, 9},
+      {132, 10, 177, 75, 3}
+    },
+    { {80, 66, 146, 213, 15},
+      {12, 220, 201, 156, 2},
+      {250, 180, 148, 32, 10},
+      {67, 153, 51, 179, 0}
+    },
+    { {35, 150, 114, 80, 11},
+      {100, 80, 185, 121, 4},
+      {208, 164, 230, 156, 4},
+      {41, 233, 208, 162, 6}
+    },
+    { {68, 239, 204, 54, 11},
+      {173, 151, 159, 160, 9},
+      {214, 195, 63, 114, 2},
+      {144, 95, 158, 155, 5}
+    },
+    { {31, 253, 132, 177, 6},
+      {195, 159, 210, 101, 10},
+      {104, 210, 27, 255, 8},
+      {90, 100, 191, 156, 3}
+    },
+    { {197, 49, 181, 191, 8},
+      {217, 163, 131, 214, 7},
+      {31, 218, 216, 202, 3},
+      {230, 188, 28, 89, 11}
+    },
+    { {22, 150, 178, 17, 4},
+      {192, 200, 216, 53, 4},
+      {40, 132, 214, 150, 8},
+      {42, 193, 177, 48, 3}
+    },
+    { {38, 79, 248, 144, 13},
+      {164, 134, 237, 49, 14},
+      {176, 145, 255, 38, 4},
+      {120, 203, 118, 18, 5}
+    },
+    { {246, 196, 223, 173, 7},
+      {188, 253, 118, 183, 2},
+      {235, 95, 178, 54, 15},
+      {78, 214, 235, 243, 13}
+    },
+    { {156, 24, 84, 188, 5},
+      {238, 41, 194, 18, 10},
+      {163, 210, 161, 131, 9},
+      {84, 132, 57, 71, 7}
+    },
+    { {19, 208, 219, 228, 10},
+      {120, 220, 23, 89, 2},
+      {82, 125, 176, 188, 8},
+      {73, 174, 131, 177, 14}
+    },
+    { {249, 179, 22, 59, 4},
+      {67, 107, 250, 214, 1},
+      {45, 198, 140, 217, 15},
+      {134, 181, 253, 108, 2}
+    },
+    { {81, 149, 114, 252, 7},
+      {108, 122, 210, 248, 6},
+      {227, 244, 234, 152, 10},
+      {97, 244, 181, 227, 6}
+    },
+    { {242, 39, 249, 70, 5},
+      {61, 138, 108, 187, 5},
+      {166, 41, 254, 68, 15},
+      {173, 211, 101, 27, 12}
+    },
+    { {102, 190, 189, 206, 13},
+      {221, 161, 125, 185, 15},
+      {183, 59, 215, 214, 6},
+      {249, 219, 232, 91, 11}
+    },
+    { {214, 222, 191, 213, 4},
+      {216, 205, 220, 191, 14},
+      {42, 191, 215, 182, 11},
+      {127, 211, 187, 49, 11}
+    },
+    { {42, 6, 160, 45, 8},
+      {10, 160, 43, 37, 4},
+      {27, 64, 86, 5, 4},
+      {42, 77, 64, 85, 0}
+    },
+    { {20, 53, 95, 118, 11},
+      {253, 91, 135, 56, 1},
+      {214, 239, 170, 194, 8},
+      {129, 206, 29, 171, 15}
+    },
+    { {10, 147, 60, 139, 0},
+      {66, 35, 28, 21, 7},
+      {13, 19, 204, 149, 0},
+      {234, 131, 140, 68, 2}
+    },
+    { {41, 181, 114, 31, 7},
+      {111, 114, 240, 116, 5},
+      {239, 132, 234, 217, 4},
+      {162, 224, 244, 239, 6}
+    },
+    { {10, 176, 119, 109, 10},
+      {123, 113, 19, 29, 4},
+      {91, 110, 224, 213, 0},
+      {43, 140, 136, 237, 14}
+    },
+    { {73, 99, 125, 47, 0},
+      {59, 39, 14, 212, 5},
+      {15, 75, 236, 105, 2},
+      {162, 183, 14, 77, 12}
+    },
+    { {129, 17, 157, 135, 11},
+      {92, 147, 5, 86, 3},
+      {222, 27, 152, 136, 1},
+      {198, 170, 12, 147, 10}
+    },
+    { {140, 179, 51, 58, 10},
+      {211, 114, 155, 18, 5},
+      {85, 204, 204, 211, 1},
+      {164, 141, 148, 236, 11}
+    },
+    { {178, 29, 155, 97, 0},
+      {80, 202, 38, 63, 8},
+      {8, 109, 155, 132, 13},
+      {31, 198, 69, 48, 10}
+    },
+    { {188, 118, 206, 213, 10},
+      {235, 221, 173, 46, 2},
+      {90, 183, 54, 227, 13},
+      {71, 75, 91, 189, 7}
+    },
+    { {160, 15, 75, 230, 8},
+      {56, 66, 47, 42, 11},
+      {22, 125, 47, 0, 5},
+      {213, 79, 68, 33, 12}
+    },
+    { {68, 168, 183, 24, 8},
+      {145, 225, 145, 144, 12},
+      {17, 142, 209, 82, 2},
+      {48, 152, 152, 120, 9}
+    },
+    { {192, 147, 189, 209, 12},
+      {80, 131, 221, 158, 6},
+      {56, 187, 220, 144, 3},
+      {103, 155, 188, 16, 10}
+    },
+    { {67, 88, 203, 57, 12},
+      {112, 228, 199, 197, 8},
+      {57, 205, 49, 172, 2},
+      {26, 62, 50, 112, 14}
+    },
+    { {138, 61, 137, 8, 12},
+      {83, 162, 69, 35, 8},
+      {49, 9, 27, 197, 1},
+      {28, 74, 36, 92, 10}
+    },
+    { {252, 190, 21, 102, 11},
+      {223, 25, 59, 186, 9},
+      {214, 106, 135, 211, 15},
+      {149, 221, 201, 143, 11}
+    },
+    { {203, 103, 181, 191, 5},
+      {31, 167, 202, 247, 7},
+      {175, 218, 222, 109, 3},
+      {238, 245, 62, 95, 8}
+    },
+    { {233, 7, 248, 189, 4},
+      {42, 162, 238, 246, 6},
+      {43, 209, 254, 9, 7},
+      {102, 247, 116, 85, 4}
+    },
+    { {75, 186, 42, 243, 10},
+      {67, 80, 159, 205, 15},
+      {92, 245, 69, 221, 2},
+      {251, 63, 144, 172, 2}
+    },
+    { {113, 234, 245, 7, 10},
+      {57, 157, 57, 212, 13},
+      {94, 10, 245, 120, 14},
+      {178, 185, 203, 153, 12}
+    },
+    { {147, 43, 182, 127, 6},
+      {9, 251, 202, 95, 13},
+      {111, 230, 221, 76, 9},
+      {191, 165, 61, 249, 0}
+    },
+    { {83, 241, 61, 70, 1},
+      {93, 15, 20, 217, 5},
+      {134, 43, 200, 252, 10},
+      {169, 178, 143, 11, 10}
+    },
+    { {99, 45, 7, 61, 3},
+      {29, 115, 162, 229, 8},
+      {203, 206, 11, 76, 6},
+      {26, 116, 92, 235, 8}
+    },
+    { {187, 21, 254, 209, 0},
+      {98, 203, 164, 127, 6},
+      {8, 183, 250, 141, 13},
+      {111, 226, 93, 52, 6}
+    },
+    { {249, 117, 16, 139, 12},
+      {67, 46, 97, 246, 3},
+      {61, 16, 138, 233, 15},
+      {198, 248, 103, 76, 2}
+    },
+    { {82, 137, 180, 183, 15},
+      {12, 155, 211, 149, 15},
+      {254, 210, 217, 20, 10},
+      {250, 156, 189, 147, 0}
+    },
+    { {27, 210, 12, 213, 13},
+      {78, 13, 221, 77, 2},
+      {186, 179, 4, 189, 8},
+      {75, 43, 187, 7, 2}
+    },
+    { {177, 242, 231, 215, 11},
+      {125, 221, 185, 78, 7},
+      {222, 190, 116, 248, 13},
+      {231, 41, 219, 187, 14}
+    },
+    { {59, 199, 234, 23, 8},
+      {42, 206, 189, 101, 5},
+      {30, 133, 126, 61, 12},
+      {170, 107, 215, 53, 4}
+    },
+    { {129, 160, 44, 14, 10},
+      {9, 49, 21, 66, 5},
+      {87, 3, 64, 88, 1},
+      {164, 42, 136, 201, 0}
+    },
+    { {175, 47, 221, 40, 8},
+      {179, 163, 47, 115, 8},
+      {17, 75, 191, 79, 5},
+      {28, 239, 76, 92, 13}
+    },
+    { {102, 160, 63, 60, 5},
+      {157, 97, 246, 145, 4},
+      {163, 207, 192, 86, 6},
+      {40, 150, 248, 107, 9}
+    },
+    { {97, 107, 54, 64, 2},
+      {1, 87, 40, 216, 12},
+      {64, 38, 205, 104, 6},
+      {49, 177, 78, 168, 0}
+    },
+    { {179, 110, 223, 102, 4},
+      {57, 205, 110, 123, 9},
+      {38, 111, 183, 108, 13},
+      {157, 231, 107, 57, 12}
+    },
+    { {221, 206, 234, 142, 13},
+      {174, 236, 93, 226, 15},
+      {183, 21, 119, 59, 11},
+      {244, 123, 163, 119, 5}
+    },
+    { {191, 161, 228, 191, 4},
+      {171, 171, 242, 71, 7},
+      {47, 210, 120, 95, 13},
+      {238, 36, 253, 93, 5}
+    },
+    { {181, 50, 205, 129, 2},
+      {241, 153, 44, 70, 2},
+      {72, 27, 52, 202, 13},
+      {70, 35, 73, 152, 15}
+    },
+    { {93, 75, 26, 56, 8},
+      {130, 110, 143, 208, 8},
+      {17, 197, 141, 43, 10},
+      {16, 191, 23, 100, 1}
+    },
+    { {178, 246, 24, 165, 12},
+      {73, 12, 127, 55, 2},
+      {58, 81, 134, 244, 13},
+      {78, 207, 227, 9, 2}
+    },
+    { {56, 237, 90, 165, 11},
+      {47, 94, 55, 52, 10},
+      {218, 85, 171, 113, 12},
+      {82, 206, 199, 175, 4}
+    },
+    { {73, 219, 225, 19, 5},
+      {118, 134, 216, 196, 13},
+      {172, 136, 125, 185, 2},
+      {178, 49, 182, 22, 14}
+    },
+    { {73, 170, 182, 189, 9},
+      {15, 225, 155, 212, 14},
+      {155, 214, 213, 89, 2},
+      {114, 189, 152, 127, 0}
+    },
+    { {84, 139, 234, 26, 2},
+      {160, 250, 156, 128, 13},
+      {69, 133, 125, 18, 10},
+      {176, 19, 149, 240, 5}
+    },
+    { {157, 15, 70, 19, 1},
+      {166, 75, 136, 102, 9},
+      {140, 134, 47, 11, 9},
+      {150, 97, 29, 38, 5}
+    },
+    { {102, 97, 19, 14, 1},
+      {157, 102, 32, 145, 1},
+      {135, 12, 136, 102, 6},
+      {136, 144, 70, 107, 9}
+    },
+    { {248, 9, 47, 37, 2},
+      {26, 91, 38, 134, 12},
+      {74, 79, 73, 1, 15},
+      {54, 22, 77, 165, 8}
+    },
+    { {11, 201, 149, 46, 14},
+      {26, 183, 83, 81, 9},
+      {119, 74, 153, 61, 0},
+      {152, 172, 174, 213, 8}
+    },
+    { {184, 19, 104, 249, 3},
+      {102, 58, 174, 14, 6},
+      {201, 241, 108, 129, 13},
+      {103, 7, 85, 198, 6}
+    },
+    { {247, 151, 168, 45, 7},
+      {204, 186, 126, 231, 4},
+      {235, 65, 94, 158, 15},
+      {46, 119, 229, 211, 3}
+    },
+    { {64, 198, 85, 224, 12},
+      {48, 5, 91, 184, 2},
+      {48, 122, 166, 48, 2},
+      {65, 221, 170, 0, 12}
+    },
+    { {119, 132, 246, 36, 5},
+      {172, 201, 114, 241, 4},
+      {162, 70, 242, 30, 14},
+      {40, 244, 233, 51, 5}
+    },
+    { {67, 149, 31, 37, 8},
+      {88, 67, 23, 245, 0},
+      {26, 79, 138, 156, 2},
+      {10, 254, 140, 33, 10}
+    },
+    { {45, 159, 144, 243, 0},
+      {194, 130, 186, 124, 11},
+      {12, 240, 159, 155, 4},
+      {211, 229, 212, 20, 3}
+    },
+    { {146, 221, 176, 205, 11},
+      {76, 190, 17, 63, 14},
+      {219, 48, 219, 180, 9},
+      {127, 200, 135, 211, 2}
+    },
+    { {246, 199, 216, 26, 12},
+      {160, 174, 253, 179, 1},
+      {53, 129, 190, 54, 15},
+      {140, 219, 247, 80, 5}
+    },
+    { {24, 194, 89, 137, 6},
+      {50, 60, 92, 20, 2},
+      {105, 25, 164, 49, 8},
+      {66, 131, 163, 196, 12}
+    },
+    { {191, 94, 230, 119, 1},
+      {238, 205, 170, 111, 13},
+      {142, 230, 119, 175, 13},
+      {191, 101, 91, 55, 7}
+    },
+    { {154, 185, 210, 41, 10},
+      {99, 250, 19, 23, 8},
+      {89, 68, 185, 213, 9},
+      {30, 140, 133, 252, 6}
+    },
+    { {85, 134, 127, 171, 1},
+      {180, 105, 30, 244, 7},
+      {141, 95, 230, 26, 10},
+      {226, 247, 137, 98, 13}
+    },
+    { {184, 210, 232, 62, 14},
+      {106, 188, 255, 2, 5},
+      {119, 193, 116, 177, 13},
+      {164, 15, 243, 213, 6}
+    },
+    { {8, 95, 31, 243, 10},
+      {82, 87, 143, 60, 11},
+      {92, 255, 143, 161, 0},
+      {211, 207, 30, 164, 10}
+    },
+    { {18, 244, 23, 56, 3},
+      {85, 125, 146, 49, 0},
+      {193, 206, 130, 244, 8},
+      {8, 196, 155, 234, 10}
+    },
+    { {166, 113, 141, 223, 14},
+      {217, 183, 229, 15, 3},
+      {127, 187, 24, 230, 5},
+      {207, 10, 126, 217, 11}
+    },
+    { {192, 142, 206, 109, 0},
+      {40, 225, 30, 174, 8},
+      {11, 103, 55, 16, 3},
+      {23, 87, 136, 113, 4}
+    },
+    { {109, 149, 12, 180, 7},
+      {206, 19, 246, 224, 2},
+      {226, 211, 10, 155, 6},
+      {64, 118, 252, 135, 3}
+    },
+    { {150, 47, 248, 18, 6},
+      {161, 154, 204, 51, 13},
+      {100, 129, 255, 70, 9},
+      {188, 195, 53, 152, 5}
+    },
+    { {100, 178, 210, 193, 10},
+      {225, 208, 57, 156, 2},
+      {88, 52, 180, 210, 6},
+      {67, 153, 192, 184, 7}
+    },
+    { {171, 232, 165, 221, 12},
+      {27, 165, 241, 79, 14},
+      {59, 186, 81, 125, 5},
+      {127, 40, 250, 93, 8}
+    },
+    { {1, 1, 118, 119, 7},
+      {44, 83, 194, 92, 5},
+      {238, 230, 232, 8, 0},
+      {163, 164, 60, 163, 4}
+    },
+    { {122, 87, 242, 127, 10},
+      {106, 254, 171, 189, 5},
+      {95, 228, 254, 165, 14},
+      {171, 221, 87, 245, 6}
+    },
+    { {49, 50, 151, 33, 7},
+      {85, 217, 106, 84, 0},
+      {232, 78, 148, 200, 12},
+      {2, 165, 105, 186, 10}
+    },
+    { {84, 80, 181, 69, 13},
+      {220, 141, 65, 156, 4},
+      {186, 42, 208, 162, 10},
+      {35, 152, 43, 19, 11}
+    },
+    { {11, 87, 84, 254, 5},
+      {110, 39, 202, 121, 3},
+      {167, 242, 174, 173, 0},
+      {201, 229, 62, 71, 6}
+    },
+    { {182, 45, 55, 60, 6},
+      {153, 123, 226, 51, 12},
+      {99, 206, 203, 70, 13},
+      {60, 196, 125, 233, 9}
+    },
+    { {148, 78, 188, 41, 1},
+      {132, 173, 14, 54, 12},
+      {137, 67, 215, 34, 9},
+      {54, 199, 11, 82, 1}
+    },
+    { {212, 209, 225, 203, 8},
+      {240, 174, 17, 142, 7},
+      {29, 56, 120, 178, 11},
+      {231, 24, 135, 80, 15}
+    },
+    { {41, 127, 114, 212, 15},
+      {111, 86, 233, 120, 14},
+      {242, 180, 239, 233, 4},
+      {113, 233, 118, 175, 6}
+    },
+    { {185, 41, 143, 89, 11},
+      {23, 251, 165, 78, 8},
+      {217, 175, 25, 73, 13},
+      {23, 42, 93, 254, 8}
+    },
+    { {156, 178, 65, 173, 13},
+      {255, 40, 91, 6, 2},
+      {187, 88, 36, 211, 9},
+      {70, 13, 161, 79, 15}
+    },
+    { {9, 10, 241, 177, 13},
+      {54, 128, 203, 84, 14},
+      {184, 216, 245, 9, 0},
+      {114, 173, 48, 22, 12}
+    },
+    { {16, 185, 135, 171, 7},
+      {85, 251, 82, 4, 11},
+      {237, 94, 25, 208, 8},
+      {210, 4, 173, 250, 10}
+    },
+    { {126, 194, 225, 64, 6},
+      {178, 156, 120, 137, 4},
+      {96, 40, 116, 55, 14},
+      {41, 17, 227, 148, 13}
+    },
+    { {67, 167, 86, 127, 1},
+      {45, 99, 154, 253, 1},
+      {143, 230, 174, 92, 2},
+      {139, 245, 156, 107, 4}
+    },
+    { {26, 3, 90, 19, 6},
+      {34, 90, 204, 21, 1},
+      {108, 133, 172, 5, 8},
+      {138, 131, 53, 164, 4}
+    },
+    { {29, 135, 214, 9, 13},
+      {166, 235, 89, 116, 0},
+      {185, 6, 190, 27, 8},
+      {2, 233, 173, 118, 5}
+    },
+    { {166, 252, 66, 185, 15},
+      {229, 116, 243, 39, 10},
+      {249, 212, 35, 246, 5},
+      {94, 76, 242, 234, 7}
+    },
+    { {107, 129, 183, 247, 6},
+      {26, 211, 242, 221, 7},
+      {110, 254, 216, 29, 6},
+      {235, 180, 252, 181, 8}
+    },
+    { {69, 254, 109, 129, 14},
+      {241, 21, 93, 228, 14},
+      {120, 27, 103, 250, 2},
+      {114, 123, 170, 136, 15}
+    },
+    { {53, 236, 43, 184, 7},
+      {149, 124, 246, 96, 14},
+      {225, 221, 67, 122, 12},
+      {112, 102, 243, 234, 9}
+    },
+    { {49, 88, 4, 149, 14},
+      {72, 29, 225, 68, 10},
+      {122, 146, 1, 168, 12},
+      {82, 40, 123, 129, 2}
+    },
+    { {152, 19, 34, 45, 15},
+      {78, 122, 75, 6, 4},
+      {251, 68, 76, 129, 9},
+      {38, 13, 37, 231, 2}
+    },
+    { {154, 159, 90, 231, 3},
+      {110, 90, 30, 63, 11},
+      {206, 117, 175, 149, 9},
+      {223, 199, 133, 167, 6}
+    },
+    { {212, 231, 111, 182, 1},
+      {189, 79, 158, 162, 7},
+      {134, 223, 110, 114, 11},
+      {228, 87, 159, 43, 13}
+    },
+    { {229, 90, 150, 106, 14},
+      {192, 245, 107, 218, 9},
+      {117, 102, 149, 170, 7},
+      {149, 189, 106, 240, 3}
+    },
+    { {79, 187, 212, 222, 13},
+      {239, 163, 217, 217, 11},
+      {183, 178, 189, 223, 2},
+      {217, 185, 188, 95, 7}
+    },
+    { {121, 157, 133, 152, 15},
+      {86, 187, 241, 224, 10},
+      {241, 154, 27, 153, 14},
+      {80, 120, 253, 214, 10}
+    },
+    { {9, 112, 158, 165, 9},
+      {79, 197, 7, 84, 2},
+      {154, 87, 144, 233, 0},
+      {66, 174, 10, 63, 2}
+    },
+    { {3, 87, 205, 203, 8},
+      {112, 167, 13, 109, 3},
+      {29, 59, 62, 172, 0},
+      {203, 107, 14, 80, 14}
+    },
+    { {212, 185, 186, 58, 5},
+      {197, 234, 214, 146, 13},
+      {165, 197, 217, 210, 11},
+      {180, 150, 181, 122, 3}
+    },
+    { {24, 64, 161, 74, 8},
+      {18, 172, 1, 8, 5},
+      {21, 40, 80, 33, 8},
+      {161, 8, 3, 84, 8}
+    },
+    { {118, 93, 35, 164, 0},
+      {216, 78, 34, 161, 14},
+      {2, 92, 75, 166, 14},
+      {120, 84, 71, 33, 11}
+    },
+    { {215, 210, 250, 82, 11},
+      {228, 220, 157, 219, 5},
+      {212, 165, 244, 190, 11},
+      {173, 187, 147, 178, 7}
+    },
+    { {112, 131, 115, 144, 14},
+      {48, 90, 249, 144, 6},
+      {112, 156, 236, 16, 14},
+      {96, 153, 245, 160, 12}
+    },
+    { {54, 219, 219, 178, 9},
+      {244, 206, 191, 17, 11},
+      {148, 221, 189, 182, 12},
+      {216, 143, 215, 50, 15}
+    },
+    { {238, 65, 132, 139, 9},
+      {134, 167, 33, 135, 3},
+      {157, 18, 24, 39, 7},
+      {206, 24, 78, 86, 1}
+    },
+    { {82, 197, 48, 152, 6},
+      {0, 62, 208, 177, 6},
+      {97, 144, 202, 52, 10},
+      {104, 208, 183, 192, 0}
+    },
+    { {252, 86, 183, 22, 2},
+      {218, 221, 168, 178, 5},
+      {70, 142, 214, 163, 15},
+      {164, 209, 91, 181, 11}
+    },
+    { {116, 165, 189, 128, 1},
+      {149, 139, 52, 176, 6},
+      {128, 27, 218, 82, 14},
+      {96, 210, 205, 26, 9}
+    },
+    { {149, 143, 205, 134, 4},
+      {184, 139, 92, 98, 11},
+      {38, 27, 63, 26, 9},
+      {212, 99, 173, 17, 13}
+    },
+    { {217, 178, 146, 205, 0},
+      {75, 232, 24, 222, 2},
+      {11, 52, 148, 217, 11},
+      {71, 177, 129, 125, 2}
+    },
+    { {167, 235, 71, 193, 10},
+      {177, 87, 57, 79, 10},
+      {88, 62, 45, 126, 5},
+      {95, 41, 206, 168, 13}
+    },
+    { {79, 1, 94, 2, 9},
+      {166, 67, 5, 209, 1},
+      {148, 7, 168, 15, 2},
+      {136, 186, 12, 38, 5}
+    },
+    { {106, 36, 9, 113, 10},
+      {19, 16, 167, 173, 0},
+      {88, 233, 2, 69, 6},
+      {11, 94, 80, 140, 8}
+    },
+    { {206, 68, 49, 8, 9},
+      {150, 36, 1, 179, 4},
+      {145, 8, 194, 39, 3},
+      {44, 216, 2, 70, 9}
+    },
+    { {49, 255, 30, 233, 10},
+      {65, 127, 63, 124, 10},
+      {89, 119, 143, 248, 12},
+      {83, 239, 207, 232, 2}
+    },
+    { {20, 10, 7, 54, 11},
+      {156, 89, 139, 0, 9},
+      {214, 206, 5, 2, 8},
+      {144, 13, 25, 163, 9}
+    },
+    { {70, 59, 86, 20, 0},
+      {233, 67, 136, 145, 8},
+      {2, 134, 173, 198, 2},
+      {24, 145, 28, 41, 7}
+    },
+    { {59, 6, 12, 183, 14},
+      {10, 25, 239, 101, 3},
+      {126, 211, 6, 13, 12},
+      {202, 111, 121, 133, 0}
+    },
+    { {183, 192, 126, 222, 10},
+      {168, 125, 181, 91, 7},
+      {87, 183, 224, 62, 13},
+      {237, 170, 219, 225, 5}
+    },
+    { {131, 167, 59, 199, 12},
+      {25, 66, 93, 127, 7},
+      {62, 61, 206, 92, 1},
+      {239, 235, 164, 41, 8}
+    },
+    { {169, 68, 61, 125, 8},
+      {26, 37, 167, 126, 4},
+      {27, 235, 194, 41, 5},
+      {39, 238, 90, 69, 8}
+    },
+    { {89, 62, 133, 40, 0},
+      {83, 169, 10, 224, 8},
+      {1, 74, 23, 201, 10},
+      {16, 117, 9, 92, 10}
+    },
+    { {91, 223, 9, 190, 3},
+      {94, 62, 158, 225, 11},
+      {199, 217, 15, 189, 10},
+      {216, 119, 151, 199, 10}
+    },
+    { {90, 199, 81, 168, 1},
+      {54, 46, 26, 177, 2},
+      {129, 88, 174, 53, 10},
+      {72, 213, 135, 70, 12}
+    },
+    { {172, 197, 14, 185, 6},
+      {130, 119, 246, 38, 2},
+      {105, 215, 10, 51, 5},
+      {70, 70, 254, 228, 1}
+    },
+    { {140, 158, 159, 124, 11},
+      {222, 241, 159, 58, 8},
+      {211, 239, 151, 147, 1},
+      {21, 207, 152, 247, 11}
+    },
+    { {94, 223, 124, 158, 10},
+      {234, 63, 157, 177, 15},
+      {87, 147, 239, 183, 10},
+      {248, 219, 159, 197, 7}
+    },
+    { {194, 247, 145, 150, 7},
+      {93, 150, 216, 179, 3},
+      {230, 152, 158, 244, 3},
+      {204, 209, 182, 155, 10}
+    },
+    { {104, 128, 250, 139, 3},
+      {38, 240, 52, 148, 7},
+      {205, 21, 240, 17, 6},
+      {226, 146, 192, 246, 4}
+    },
+    { {164, 118, 61, 185, 15},
+      {213, 53, 239, 54, 6},
+      {249, 219, 198, 226, 5},
+      {102, 207, 122, 202, 11}
+    },
+    { {232, 136, 149, 37, 11},
+      {30, 145, 51, 150, 8},
+      {218, 74, 145, 17, 7},
+      {22, 156, 200, 151, 8}
+    },
+    { {94, 137, 11, 42, 0},
+      {146, 106, 22, 129, 9},
+      {5, 77, 9, 23, 10},
+      {152, 22, 133, 100, 9}
+    },
+    { {168, 252, 52, 240, 6},
+      {67, 21, 242, 58, 14},
+      {96, 242, 195, 241, 5},
+      {117, 196, 250, 140, 2}
+    },
+    { {102, 80, 220, 156, 14},
+      {232, 181, 229, 145, 2},
+      {115, 147, 176, 166, 6},
+      {72, 154, 122, 209, 7}
+    },
+    { {217, 235, 112, 198, 6},
+      {43, 30, 88, 218, 15},
+      {102, 48, 237, 121, 11},
+      {245, 177, 167, 141, 4}
+    },
+    { {6, 57, 26, 27, 7},
+      {197, 114, 196, 21, 9},
+      {237, 133, 137, 198, 0},
+      {154, 130, 52, 234, 3}
+    },
+    { {100, 213, 236, 219, 14},
+      {224, 183, 245, 172, 7},
+      {125, 179, 122, 178, 6},
+      {227, 90, 254, 208, 7}
+    },
+    { {80, 23, 140, 98, 3},
+      {68, 155, 14, 168, 1},
+      {196, 99, 30, 128, 10},
+      {129, 87, 13, 146, 2}
+    },
+    { {128, 175, 91, 93, 8},
+      {57, 98, 157, 62, 8},
+      {27, 173, 175, 80, 1},
+      {23, 203, 148, 105, 12}
+    },
+    { {178, 110, 247, 189, 9},
+      {61, 237, 171, 55, 14},
+      {155, 222, 247, 100, 13},
+      {126, 205, 91, 123, 12}
+    },
+    { {210, 217, 41, 11, 11},
+      {84, 62, 21, 135, 13},
+      {221, 9, 73, 180, 11},
+      {190, 26, 135, 194, 10}
+    },
+    { {142, 230, 136, 246, 1},
+      {143, 132, 158, 43, 3},
+      {134, 241, 22, 119, 1},
+      {205, 71, 146, 31, 1}
+    },
+    { {144, 133, 126, 179, 5},
+      {36, 75, 214, 54, 7},
+      {172, 215, 234, 16, 9},
+      {230, 198, 189, 34, 4}
+    },
+    { {214, 244, 185, 51, 14},
+      {209, 156, 215, 183, 5},
+      {124, 201, 210, 246, 11},
+      {174, 222, 179, 152, 11}
+    },
+    { {68, 17, 154, 175, 12},
+      {200, 226, 71, 148, 3},
+      {63, 85, 152, 130, 2},
+      {194, 158, 36, 113, 3}
+    },
+    { {48, 177, 90, 93, 2},
+      {105, 122, 180, 28, 0},
+      {75, 165, 168, 208, 12},
+      {3, 130, 213, 233, 6}
+    },
+    { {66, 57, 254, 118, 6},
+      {105, 211, 198, 153, 13},
+      {102, 231, 249, 196, 2},
+      {185, 150, 60, 185, 6}
+    },
+    { {108, 223, 228, 140, 12},
+      {234, 167, 121, 160, 14},
+      {51, 18, 127, 179, 6},
+      {112, 89, 238, 85, 7}
+    },
+    { {110, 159, 250, 19, 0},
+      {226, 194, 188, 181, 13},
+      {12, 133, 255, 151, 6},
+      {186, 211, 212, 52, 7}
+    },
+    { {251, 180, 205, 219, 9},
+      {119, 169, 181, 239, 3},
+      {157, 187, 50, 221, 15},
+      {207, 122, 217, 94, 14}
+    },
+    { {106, 94, 54, 11, 12},
+      {66, 101, 105, 181, 13},
+      {61, 6, 199, 165, 6},
+      {186, 217, 106, 100, 2}
+    },
+    { {187, 128, 110, 3, 5},
+      {38, 73, 116, 71, 5},
+      {172, 7, 96, 29, 13},
+      {174, 34, 233, 38, 4}
+    },
+    { {151, 235, 197, 191, 10},
+      {185, 191, 155, 71, 11},
+      {95, 218, 61, 126, 9},
+      {222, 45, 159, 217, 13}
+    },
+    { {15, 117, 226, 80, 2},
+      {227, 214, 128, 105, 4},
+      {64, 164, 122, 239, 0},
+      {41, 96, 22, 188, 7}
+    },
+    { {11, 49, 73, 156, 8},
+      {123, 34, 133, 65, 2},
+      {19, 153, 40, 205, 0},
+      {72, 42, 20, 77, 14}
+    },
+    { {215, 174, 213, 193, 8},
+      {177, 137, 25, 255, 10},
+      {24, 58, 183, 94, 11},
+      {95, 249, 137, 24, 13}
+    },
+    { {210, 248, 182, 187, 9},
+      {69, 237, 147, 151, 15},
+      {157, 214, 209, 244, 11},
+      {254, 156, 155, 122, 2}
+    },
+    { {34, 55, 245, 42, 9},
+      {117, 163, 43, 49, 5},
+      {149, 74, 254, 196, 4},
+      {168, 205, 76, 90, 14}
+    },
+    { {68, 127, 202, 153, 4},
+      {225, 230, 204, 164, 10},
+      {41, 149, 63, 226, 2},
+      {82, 83, 54, 120, 7}
+    },
+    { {141, 146, 126, 41, 15},
+      {230, 113, 95, 86, 4},
+      {249, 71, 228, 155, 1},
+      {38, 175, 168, 230, 7}
+    },
+    { {13, 54, 100, 46, 5},
+      {239, 33, 74, 96, 5},
+      {167, 66, 102, 203, 0},
+      {160, 101, 40, 79, 7}
+    },
+    { {213, 191, 237, 221, 12},
+      {249, 171, 221, 238, 14},
+      {59, 187, 127, 218, 11},
+      {119, 123, 189, 89, 15}
+    },
+    { {139, 198, 212, 229, 1},
+      {46, 133, 26, 127, 2},
+      {138, 114, 182, 61, 1},
+      {79, 229, 138, 23, 4}
+    },
+    { {221, 244, 124, 110, 1},
+      {239, 45, 22, 250, 5},
+      {135, 99, 226, 251, 11},
+      {165, 246, 139, 79, 7}
+    },
+    { {69, 159, 45, 147, 1},
+      {212, 3, 156, 228, 15},
+      {140, 155, 79, 154, 2},
+      {242, 115, 156, 2, 11}
+    },
+    { {134, 21, 175, 172, 5},
+      {220, 227, 70, 35, 6},
+      {163, 95, 90, 134, 1},
+      {108, 70, 44, 115, 11}
+    },
+    { {52, 174, 42, 121, 9},
+      {133, 104, 191, 44, 12},
+      {153, 229, 71, 82, 12},
+      {51, 79, 209, 106, 1}
+    },
+    { {246, 135, 29, 191, 4},
+      {152, 43, 254, 183, 3},
+      {47, 219, 142, 22, 15},
+      {206, 215, 253, 65, 9}
+    },
+    { {22, 183, 193, 11, 4},
+      {241, 170, 88, 37, 1},
+      {45, 8, 62, 214, 8},
+      {138, 65, 165, 88, 15}
+    },
+    { {122, 54, 203, 160, 5},
+      {119, 200, 110, 161, 2},
+      {160, 93, 54, 197, 14},
+      {72, 87, 97, 62, 14}
+    },
+    { {127, 66, 16, 98, 10},
+      {130, 28, 43, 217, 1},
+      {84, 96, 132, 47, 14},
+      {137, 189, 67, 132, 1}
+    },
+    { {103, 112, 117, 206, 8},
+      {249, 37, 33, 217, 7},
+      {23, 58, 224, 238, 6},
+      {233, 184, 74, 73, 15}
+    },
+    { {167, 70, 60, 209, 12},
+      {128, 5, 237, 127, 6},
+      {56, 179, 198, 46, 5},
+      {111, 235, 122, 0, 1}
+    },
+    { {153, 117, 131, 110, 2},
+      {91, 254, 2, 106, 1},
+      {71, 108, 26, 233, 9},
+      {133, 100, 7, 253, 10}
+    },
+    { {81, 145, 211, 21, 9},
+      {124, 202, 145, 212, 0},
+      {154, 140, 184, 152, 10},
+      {2, 184, 149, 51, 14}
+    },
+    { {53, 76, 2, 185, 8},
+      {128, 108, 163, 100, 10},
+      {25, 212, 3, 42, 12},
+      {82, 108, 83, 96, 1}
+    },
+    { {208, 27, 128, 57, 5},
+      {68, 170, 202, 134, 8},
+      {169, 192, 29, 128, 11},
+      {22, 21, 53, 82, 2}
+    },
+    { {123, 39, 171, 229, 3},
+      {31, 218, 46, 237, 6},
+      {202, 125, 94, 77, 14},
+      {107, 119, 69, 191, 8}
+    },
+    { {168, 140, 171, 169, 4},
+      {18, 224, 118, 38, 14},
+      {41, 93, 83, 17, 5},
+      {118, 70, 224, 116, 8}
+    },
+    { {138, 112, 46, 100, 13},
+      {79, 69, 71, 11, 4},
+      {178, 103, 64, 229, 1},
+      {45, 14, 42, 47, 2}
+    },
+    { {17, 144, 216, 79, 13},
+      {108, 168, 85, 92, 1},
+      {191, 33, 176, 152, 8},
+      {131, 170, 161, 83, 6}
+    },
+    { {168, 56, 156, 230, 8},
+      {75, 129, 39, 26, 11},
+      {22, 115, 145, 193, 5},
+      {213, 142, 72, 29, 2}
+    },
+    { {99, 172, 245, 8, 11},
+      {53, 177, 49, 241, 12},
+      {209, 10, 243, 92, 6},
+      {56, 248, 200, 218, 12}
+    },
+    { {153, 224, 174, 41, 11},
+      {7, 253, 23, 70, 4},
+      {217, 71, 80, 121, 9},
+      {38, 46, 139, 254, 0}
+    },
+    { {232, 139, 97, 157, 3},
+      {62, 50, 184, 134, 14},
+      {203, 152, 109, 17, 7},
+      {118, 17, 212, 199, 12}
+    },
+    { {17, 175, 187, 184, 0},
+      {17, 234, 158, 112, 14},
+      {1, 221, 223, 88, 8},
+      {112, 231, 149, 120, 8}
+    },
+    { {98, 250, 27, 120, 14},
+      {81, 116, 255, 153, 8},
+      {113, 237, 133, 244, 6},
+      {25, 159, 242, 232, 10}
+    },
+    { {241, 171, 236, 42, 5},
+      {37, 171, 126, 194, 13},
+      {165, 67, 125, 88, 15},
+      {180, 55, 237, 90, 4}
+    },
+    { {164, 120, 185, 64, 2},
+      {209, 148, 36, 26, 12},
+      {64, 41, 209, 226, 5},
+      {53, 130, 66, 152, 11}
+    },
+    { {78, 147, 112, 26, 3},
+      {230, 50, 152, 145, 5},
+      {197, 128, 236, 151, 2},
+      {168, 145, 148, 198, 7}
+    },
+    { {93, 31, 190, 33, 6},
+      {194, 219, 78, 244, 12},
+      {104, 71, 223, 139, 10},
+      {50, 247, 45, 180, 3}
+    },
+    { {222, 153, 178, 148, 7},
+      {206, 218, 208, 147, 14},
+      {226, 148, 217, 151, 11},
+      {124, 144, 181, 183, 3}
+    },
+    { {119, 8, 209, 116, 7},
+      {188, 152, 226, 217, 8},
+      {226, 232, 177, 14, 14},
+      {25, 180, 113, 147, 13}
+    },
+    { {187, 192, 140, 154, 8},
+      {2, 173, 181, 67, 3},
+      {21, 147, 16, 61, 13},
+      {204, 42, 219, 84, 0}
+    },
+    { {234, 28, 8, 68, 4},
+      {74, 0, 100, 171, 8},
+      {34, 33, 3, 133, 7},
+      {29, 82, 96, 5, 2}
+    },
+    { {184, 154, 172, 7, 8},
+      {74, 137, 61, 6, 13},
+      {30, 3, 85, 145, 13},
+      {182, 11, 201, 21, 2}
+    },
+    { {151, 79, 121, 58, 13},
+      {180, 46, 207, 115, 13},
+      {181, 201, 239, 46, 9},
+      {188, 239, 55, 66, 13}
+    },
+    { {124, 55, 168, 31, 9},
+      {207, 170, 173, 164, 5},
+      {159, 129, 94, 195, 14},
+      {162, 91, 85, 95, 3}
+    },
+    { {132, 5, 69, 184, 11},
+      {180, 51, 131, 34, 2},
+      {209, 218, 42, 2, 1},
+      {68, 76, 28, 194, 13}
+    },
+    { {137, 136, 232, 242, 10},
+      {34, 144, 151, 74, 15},
+      {84, 241, 113, 25, 1},
+      {245, 46, 144, 148, 4}
+    },
+    { {122, 5, 47, 138, 7},
+      {22, 123, 100, 161, 7},
+      {229, 31, 74, 5, 14},
+      {232, 82, 109, 230, 8}
+    },
+    { {192, 107, 231, 168, 3},
+      {53, 247, 10, 130, 14},
+      {193, 94, 125, 96, 3},
+      {116, 21, 14, 250, 12}
+    },
+    { {225, 214, 143, 229, 13},
+      {92, 197, 127, 238, 2},
+      {186, 127, 22, 184, 7},
+      {71, 127, 234, 51, 10}
+    },
+    { {135, 193, 94, 208, 1},
+      {164, 71, 148, 91, 2},
+      {128, 183, 168, 62, 1},
+      {77, 162, 158, 34, 5}
+    },
+    { {177, 141, 71, 4, 14},
+      {56, 91, 113, 98, 8},
+      {114, 14, 43, 24, 13},
+      {20, 104, 237, 161, 12}
+    },
+    { {185, 96, 48, 55, 10},
+      {11, 28, 163, 86, 5},
+      {94, 192, 192, 105, 13},
+      {166, 172, 83, 141, 0}
+    },
+    { {57, 22, 249, 242, 5},
+      {118, 136, 238, 120, 7},
+      {164, 249, 246, 137, 12},
+      {225, 231, 113, 22, 14}
+    },
+    { {91, 245, 56, 225, 10},
+      {67, 30, 23, 253, 6},
+      {88, 113, 202, 253, 10},
+      {107, 254, 135, 140, 2}
+    },
+    { {69, 2, 140, 137, 3},
+      {132, 177, 12, 196, 2},
+      {201, 19, 20, 10, 2},
+      {66, 51, 8, 210, 1}
+    },
+    { {139, 247, 79, 21, 14},
+      {123, 87, 221, 103, 0},
+      {122, 143, 46, 253, 1},
+      {14, 107, 190, 173, 14}
+    },
+    { {52, 169, 38, 14, 14},
+      {137, 123, 113, 0, 13},
+      {119, 6, 73, 82, 12},
+      {176, 8, 237, 233, 1}
+    },
+    { {254, 161, 180, 87, 2},
+      {139, 155, 176, 159, 5},
+      {78, 162, 216, 87, 15},
+      {175, 144, 221, 157, 1}
+    },
+    { {170, 172, 74, 33, 2},
+      {35, 80, 54, 39, 8},
+      {72, 69, 35, 85, 5},
+      {30, 70, 192, 172, 4}
+    },
+    { {199, 149, 142, 146, 10},
+      {192, 211, 149, 227, 3},
+      {84, 151, 26, 158, 3},
+      {204, 122, 156, 176, 3}
+    },
+    { {77, 114, 150, 13, 7},
+      {207, 245, 72, 212, 0},
+      {235, 6, 148, 235, 2},
+      {2, 177, 42, 255, 3}
+    },
+    { {198, 113, 60, 138, 13},
+      {197, 39, 69, 147, 7},
+      {181, 19, 200, 230, 3},
+      {236, 154, 46, 74, 3}
+    },
+    { {26, 219, 8, 147, 10},
+      {66, 30, 157, 5, 11},
+      {92, 145, 13, 181, 8},
+      {218, 11, 151, 132, 2}
+    },
+    { {235, 178, 94, 21, 3},
+      {111, 81, 188, 215, 0},
+      {202, 135, 164, 221, 7},
+      {14, 179, 216, 175, 6}
+    },
+    { {26, 140, 101, 49, 13},
+      {54, 9, 211, 37, 12},
+      {184, 202, 99, 21, 8},
+      {58, 76, 185, 6, 12}
+    },
+    { {184, 194, 144, 210, 13},
+      {6, 140, 249, 26, 3},
+      {180, 176, 148, 49, 13},
+      {197, 137, 243, 22, 0}
+    },
+    { {237, 10, 185, 59, 12},
+      {146, 160, 239, 214, 13},
+      {61, 201, 213, 11, 7},
+      {182, 191, 112, 84, 9}
+    },
+    { {53, 64, 254, 171, 14},
+      {160, 253, 103, 84, 7},
+      {125, 87, 240, 42, 12},
+      {226, 174, 107, 240, 5}
+    },
+    { {77, 141, 169, 163, 10},
+      {146, 146, 23, 228, 15},
+      {92, 89, 91, 27, 2},
+      {242, 126, 132, 148, 9}
+    },
+    { {25, 111, 83, 7, 9},
+      {63, 78, 9, 116, 9},
+      {158, 12, 175, 105, 8},
+      {146, 233, 7, 47, 12}
+    },
+    { {170, 161, 45, 108, 8},
+      {27, 35, 55, 11, 4},
+      {19, 107, 72, 85, 5},
+      {45, 14, 204, 77, 8}
+    },
+    { {212, 51, 219, 225, 6},
+      {241, 218, 78, 158, 2},
+      {104, 125, 188, 194, 11},
+      {71, 151, 37, 184, 15}
+    },
+    { {41, 68, 117, 210, 10},
+      {50, 21, 161, 120, 7},
+      {84, 186, 226, 41, 4},
+      {225, 232, 90, 132, 12}
+    },
+    { {222, 189, 217, 145, 6},
+      {243, 154, 212, 183, 10},
+      {104, 153, 187, 215, 11},
+      {94, 210, 181, 156, 15}
+    },
+    { {123, 98, 241, 8, 1},
+      {55, 172, 40, 209, 4},
+      {129, 8, 244, 109, 14},
+      {40, 177, 67, 94, 12}
+    },
+    { {16, 243, 23, 219, 8},
+      {81, 111, 153, 28, 3},
+      {29, 190, 140, 240, 8},
+      {195, 137, 159, 104, 10}
+    },
+    { {184, 117, 135, 64, 5},
+      {87, 207, 96, 42, 0},
+      {160, 46, 26, 225, 13},
+      {5, 64, 111, 62, 10}
+    },
+    { {154, 182, 79, 175, 0},
+      {123, 105, 30, 39, 3},
+      {15, 95, 38, 213, 9},
+      {206, 71, 137, 109, 14}
+    },
+    { {212, 4, 243, 160, 1},
+      {180, 200, 2, 178, 6},
+      {128, 92, 242, 2, 11},
+      {100, 212, 1, 50, 13}
+    },
+    { {225, 106, 123, 127, 5},
+      {61, 100, 238, 222, 13},
+      {175, 237, 229, 104, 7},
+      {183, 183, 114, 107, 12}
+    },
+    { {12, 218, 188, 26, 8},
+      {194, 165, 157, 16, 13},
+      {21, 131, 213, 179, 0},
+      {176, 139, 154, 84, 3}
+    },
+    { {4, 96, 183, 149, 11},
+      {157, 213, 129, 20, 6},
+      {218, 158, 208, 98, 0},
+      {98, 136, 26, 187, 9}
+    },
+    { {28, 206, 196, 143, 3},
+      {174, 189, 24, 36, 11},
+      {207, 18, 55, 51, 8},
+      {210, 65, 139, 215, 5}
+    },
+    { {35, 222, 229, 165, 12},
+      {120, 133, 123, 101, 14},
+      {58, 90, 119, 188, 4},
+      {122, 109, 234, 17, 14}
+    },
+    { {99, 5, 255, 232, 5},
+      {52, 227, 102, 249, 6},
+      {161, 127, 250, 12, 6},
+      {105, 246, 108, 114, 12}
+    },
+    { {225, 195, 39, 185, 4},
+      {16, 103, 250, 198, 6},
+      {41, 222, 76, 56, 7},
+      {102, 53, 254, 96, 8}
+    },
+    { {140, 43, 164, 30, 0},
+      {139, 163, 136, 2, 13},
+      {7, 130, 93, 67, 1},
+      {180, 1, 28, 93, 1}
+    },
+    { {28, 217, 222, 180, 0},
+      {234, 207, 150, 16, 10},
+      {2, 215, 185, 179, 8},
+      {80, 134, 159, 53, 7}
+    },
+    { {85, 100, 240, 183, 1},
+      {173, 140, 130, 244, 7},
+      {142, 208, 242, 106, 10},
+      {226, 244, 19, 27, 5}
+    },
+    { {176, 199, 42, 118, 10},
+      {8, 94, 191, 42, 5},
+      {86, 229, 78, 48, 13},
+      {165, 79, 215, 161, 0}
+    },
+    { {231, 13, 80, 70, 9},
+      {172, 2, 33, 251, 9},
+      {150, 32, 171, 14, 7},
+      {157, 248, 68, 3, 5}
+    },
+    { {50, 149, 124, 126, 3},
+      {108, 59, 182, 57, 5},
+      {199, 227, 234, 148, 12},
+      {169, 198, 221, 195, 6}
+    },
+    { {71, 130, 81, 20, 11},
+      {188, 16, 153, 209, 0},
+      {210, 136, 164, 30, 2},
+      {8, 185, 144, 131, 13}
+    },
+    { {120, 242, 17, 22, 15},
+      {95, 28, 249, 144, 1},
+      {246, 136, 132, 241, 14},
+      {128, 153, 243, 143, 10}
+    },
+    { {144, 251, 64, 119, 10},
+      {105, 30, 155, 14, 9},
+      {94, 224, 45, 240, 9},
+      {151, 13, 151, 137, 6}
+    },
+    { {162, 111, 219, 64, 3},
+      {53, 214, 44, 59, 8},
+      {192, 45, 191, 100, 5},
+      {29, 195, 70, 186, 12}
+    },
+    { {36, 36, 50, 53, 7},
+      {141, 80, 226, 52, 4},
+      {234, 196, 194, 66, 4},
+      {34, 196, 112, 171, 1}
+    },
+    { {135, 138, 180, 213, 3},
+      {140, 145, 152, 95, 14},
+      {202, 178, 213, 30, 1},
+      {127, 161, 152, 147, 1}
+    },
+    { {238, 169, 194, 236, 0},
+      {171, 226, 50, 139, 10},
+      {3, 116, 57, 87, 7},
+      {93, 20, 196, 125, 5}
+    },
+    { {194, 91, 81, 134, 10},
+      {120, 22, 9, 147, 11},
+      {86, 24, 173, 164, 3},
+      {220, 153, 6, 129, 14}
+    },
+    { {154, 26, 220, 22, 4},
+      {106, 137, 204, 19, 9},
+      {38, 131, 181, 133, 9},
+      {156, 131, 57, 21, 6}
+    },
+    { {115, 131, 224, 101, 1},
+      {44, 138, 58, 205, 4},
+      {138, 96, 124, 28, 14},
+      {43, 53, 197, 19, 4}
+    },
+    { {25, 137, 191, 169, 14},
+      {18, 251, 87, 84, 14},
+      {121, 95, 217, 25, 8},
+      {114, 174, 173, 244, 8}
+    },
+    { {29, 136, 219, 124, 13},
+      {190, 232, 215, 88, 8},
+      {179, 237, 177, 27, 8},
+      {17, 174, 177, 119, 13}
+    },
+    { {58, 57, 201, 98, 1},
+      {119, 138, 38, 9, 9},
+      {132, 105, 57, 197, 12},
+      {153, 6, 69, 30, 14}
+    },
+    { {196, 95, 111, 141, 1},
+      {252, 103, 12, 166, 14},
+      {139, 31, 111, 162, 3},
+      {118, 83, 14, 99, 15}
+    },
+    { {127, 212, 244, 88, 13},
+      {230, 173, 241, 249, 4},
+      {177, 162, 242, 191, 14},
+      {41, 248, 251, 86, 7}
+    },
+    { {235, 94, 5, 198, 13},
+      {94, 5, 105, 235, 11},
+      {182, 58, 7, 173, 7},
+      {221, 121, 106, 7, 10}
+    },
+    { {0, 222, 87, 31, 10},
+      {120, 117, 153, 52, 9},
+      {95, 142, 167, 176, 0},
+      {146, 201, 154, 225, 14}
+    },
+    { {48, 182, 57, 119, 2},
+      {89, 24, 190, 60, 5},
+      {78, 233, 198, 208, 12},
+      {163, 199, 209, 137, 10}
+    },
+    { {217, 17, 79, 9, 9},
+      {118, 107, 5, 198, 0},
+      {153, 15, 40, 137, 11},
+      {6, 58, 13, 102, 14}
+    },
+    { {11, 138, 78, 254, 13},
+      {46, 97, 223, 73, 11},
+      {183, 247, 37, 29, 0},
+      {217, 47, 184, 103, 4}
+    },
+    { {150, 200, 148, 195, 5},
+      {132, 141, 80, 31, 11},
+      {172, 50, 145, 54, 9},
+      {223, 128, 171, 18, 1}
+    },
+    { {222, 86, 207, 27, 9},
+      {246, 237, 141, 167, 1},
+      {157, 143, 54, 167, 11},
+      {142, 91, 27, 118, 15}
+    },
+    { {233, 20, 44, 234, 11},
+      {70, 49, 39, 234, 7},
+      {213, 115, 66, 137, 7},
+      {229, 126, 72, 198, 2}
+    },
+    { {166, 193, 149, 63, 7},
+      {156, 183, 242, 23, 1},
+      {239, 202, 152, 54, 5},
+      {142, 132, 254, 211, 9}
+    },
+    { {112, 249, 99, 53, 11},
+      {125, 94, 179, 132, 12},
+      {218, 204, 105, 240, 14},
+      {50, 28, 215, 171, 14}
+    },
+    { {60, 210, 112, 229, 12},
+      {234, 12, 123, 28, 6},
+      {58, 112, 228, 179, 12},
+      {99, 141, 227, 5, 7}
+    },
+    { {67, 44, 58, 151, 8},
+      {9, 64, 133, 245, 15},
+      {30, 149, 195, 76, 2},
+      {250, 250, 16, 41, 0}
+    },
+    { {96, 54, 213, 83, 2},
+      {113, 145, 168, 188, 1},
+      {76, 170, 182, 192, 6},
+      {131, 209, 88, 152, 14}
+    },
+    { {135, 118, 248, 196, 14},
+      {233, 148, 77, 123, 6},
+      {114, 49, 246, 238, 1},
+      {109, 235, 34, 153, 7}
+    },
+    { {32, 85, 144, 158, 12},
+      {72, 166, 225, 48, 3},
+      {55, 144, 154, 160, 4},
+      {192, 200, 118, 81, 2}
+    },
+    { {51, 149, 147, 18, 0},
+      {80, 202, 176, 113, 1},
+      {4, 140, 154, 156, 12},
+      {136, 224, 213, 48, 10}
+    },
+    { {61, 129, 11, 57, 10},
+      {146, 122, 183, 68, 0},
+      {89, 205, 8, 27, 12},
+      {2, 46, 213, 228, 9}
+    },
+    { {39, 67, 30, 187, 2},
+      {128, 119, 174, 85, 3},
+      {77, 215, 140, 46, 4},
+      {202, 167, 94, 224, 1}
+    },
+    { {240, 133, 185, 233, 2},
+      {16, 186, 54, 190, 6},
+      {73, 121, 218, 16, 15},
+      {103, 214, 197, 208, 8}
+    },
+    { {163, 11, 146, 226, 0},
+      {0, 194, 42, 91, 11},
+      {4, 116, 157, 12, 5},
+      {221, 165, 68, 48, 0}
+    },
+    { {220, 20, 37, 232, 5},
+      {214, 41, 66, 170, 6},
+      {161, 122, 66, 131, 11},
+      {101, 84, 41, 70, 11}
+    },
+    { {180, 171, 135, 231, 11},
+      {157, 219, 59, 14, 11},
+      {222, 126, 29, 82, 13},
+      {215, 13, 205, 187, 9}
+    },
+    { {143, 183, 62, 39, 0},
+      {203, 67, 30, 119, 5},
+      {14, 71, 206, 223, 1},
+      {174, 231, 140, 45, 3}
+    },
+    { {255, 211, 18, 95, 2},
+      {202, 126, 184, 223, 1},
+      {79, 164, 140, 191, 15},
+      {143, 177, 215, 229, 3}
+    },
+    { {5, 76, 149, 162, 10},
+      {144, 149, 3, 112, 11},
+      {84, 90, 147, 42, 0},
+      {208, 236, 10, 144, 9}
+    },
+    { {29, 121, 189, 67, 6},
+      {211, 159, 68, 92, 13},
+      {108, 43, 217, 235, 8},
+      {179, 162, 47, 156, 11}
+    },
+    { {49, 220, 189, 155, 11},
+      {84, 189, 181, 116, 15},
+      {221, 155, 211, 184, 12},
+      {242, 234, 219, 210, 10}
+    },
+    { {93, 131, 76, 204, 2},
+      {170, 59, 28, 200, 2},
+      {67, 51, 44, 27, 10},
+      {65, 51, 141, 197, 5}
+    },
+    { {184, 110, 95, 128, 10},
+      {51, 93, 45, 50, 10},
+      {80, 31, 167, 97, 13},
+      {84, 203, 75, 172, 12}
+    },
+    { {221, 181, 2, 55, 14},
+      {203, 90, 211, 230, 1},
+      {126, 196, 10, 219, 11},
+      {134, 124, 181, 173, 3}
+    },
+    { {204, 212, 249, 32, 2},
+      {242, 148, 22, 178, 4},
+      {64, 73, 242, 179, 3},
+      {36, 214, 130, 148, 15}
+    },
+    { {222, 175, 20, 123, 3},
+      {135, 59, 154, 191, 9},
+      {205, 226, 143, 87, 11},
+      {159, 213, 157, 206, 1}
+    },
+    { {157, 32, 19, 22, 15},
+      {159, 88, 193, 82, 1},
+      {246, 140, 128, 75, 9},
+      {132, 168, 49, 175, 9}
+    },
+    { {124, 189, 240, 175, 1},
+      {239, 170, 50, 180, 15},
+      {143, 80, 251, 211, 14},
+      {242, 212, 197, 95, 7}
+    },
+    { {34, 195, 216, 114, 10},
+      {32, 150, 191, 25, 1},
+      {84, 225, 188, 52, 4},
+      {137, 143, 214, 144, 4}
+    },
+    { {69, 199, 100, 214, 12},
+      {168, 7, 217, 232, 7},
+      {54, 178, 110, 58, 2},
+      {225, 121, 190, 1, 5}
+    },
+    { {141, 147, 90, 116, 0},
+      {234, 66, 158, 90, 0},
+      {2, 229, 172, 155, 1},
+      {5, 167, 148, 37, 7}
+    },
+    { {177, 161, 236, 16, 8},
+      {33, 139, 181, 66, 4},
+      {16, 131, 120, 88, 13},
+      {36, 42, 221, 24, 4}
+    },
+    { {208, 121, 53, 51, 6},
+      {81, 31, 194, 150, 13},
+      {108, 202, 201, 224, 11},
+      {182, 148, 63, 136, 10}
+    },
+    { {74, 81, 93, 164, 6},
+      {122, 23, 70, 145, 2},
+      {98, 91, 168, 165, 2},
+      {72, 150, 46, 133, 14}
+    },
+    { {58, 45, 19, 35, 5},
+      {23, 74, 98, 53, 9},
+      {172, 76, 139, 69, 12},
+      {154, 196, 101, 46, 8}
+    },
+    { {236, 65, 230, 22, 1},
+      {174, 199, 160, 130, 5},
+      {134, 134, 120, 35, 7},
+      {164, 16, 94, 55, 5}
+    },
+    { {127, 172, 78, 24, 2},
+      {163, 121, 180, 225, 8},
+      {65, 135, 35, 95, 14},
+      {24, 114, 217, 236, 5}
+    },
+    { {115, 198, 100, 107, 13},
+      {36, 45, 123, 237, 5},
+      {189, 98, 102, 60, 14},
+      {171, 125, 235, 66, 4}
+    },
+    { {77, 251, 76, 21, 7},
+      {239, 23, 220, 196, 8},
+      {234, 131, 45, 251, 2},
+      {18, 51, 190, 143, 7}
+    },
+    { {229, 15, 78, 90, 11},
+      {164, 115, 173, 234, 9},
+      {213, 167, 47, 10, 7},
+      {149, 123, 92, 226, 5}
+    },
+    { {122, 161, 57, 166, 0},
+      {27, 10, 54, 145, 7},
+      {6, 89, 200, 85, 14},
+      {232, 150, 197, 13, 8}
+    },
+    { {18, 122, 254, 87, 13},
+      {109, 205, 205, 29, 13},
+      {190, 167, 245, 228, 8},
+      {187, 139, 59, 59, 6}
+    },
+    { {168, 230, 106, 159, 15},
+      {47, 116, 253, 38, 7},
+      {255, 149, 102, 113, 5},
+      {230, 75, 242, 239, 4}
+    },
+    { {89, 155, 96, 189, 8},
+      {106, 42, 155, 196, 14},
+      {27, 208, 109, 153, 10},
+      {114, 61, 149, 69, 6}
+    },
+    { {49, 234, 54, 102, 9},
+      {13, 77, 59, 88, 13},
+      {150, 102, 197, 120, 12},
+      {177, 173, 203, 43, 0}
+    },
+    { {55, 203, 228, 166, 3},
+      {172, 159, 58, 65, 15},
+      {198, 82, 125, 62, 12},
+      {248, 37, 207, 147, 5}
+    },
+    { {134, 60, 248, 42, 13},
+      {229, 160, 71, 51, 13},
+      {181, 65, 243, 198, 1},
+      {188, 206, 32, 90, 7}
+    },
+    { {14, 181, 149, 30, 6},
+      {219, 179, 208, 49, 1},
+      {103, 138, 154, 215, 0},
+      {136, 192, 188, 221, 11}
+    },
+    { {197, 251, 85, 118, 12},
+      {249, 7, 219, 218, 9},
+      {54, 234, 173, 250, 3},
+      {149, 189, 190, 9, 15}
+    },
+    { {123, 128, 210, 239, 5},
+      {46, 232, 114, 221, 3},
+      {175, 116, 176, 29, 14},
+      {203, 180, 225, 119, 4}
+    },
+    { {195, 179, 195, 50, 10},
+      {113, 210, 155, 195, 1},
+      {84, 204, 60, 220, 3},
+      {140, 61, 148, 184, 14}
+    },
+    { {103, 62, 26, 116, 11},
+      {205, 80, 175, 249, 8},
+      {210, 229, 135, 206, 6},
+      {25, 255, 80, 171, 3}
+    },
+    { {146, 201, 210, 150, 1},
+      {44, 206, 144, 19, 11},
+      {134, 148, 185, 52, 9},
+      {220, 128, 151, 51, 4}
+    },
+    { {127, 25, 25, 12, 11},
+      {222, 58, 37, 209, 8},
+      {211, 9, 137, 143, 14},
+      {24, 186, 69, 199, 11}
+    },
+    { {144, 112, 164, 195, 10},
+      {65, 157, 1, 14, 7},
+      {92, 50, 80, 224, 9},
+      {231, 8, 11, 152, 2}
+    },
+    { {113, 67, 83, 178, 1},
+      {52, 78, 170, 208, 3},
+      {132, 220, 172, 40, 14},
+      {192, 181, 87, 34, 12}
+    },
+    { {251, 75, 181, 78, 15},
+      {30, 191, 105, 219, 13},
+      {247, 42, 221, 45, 15},
+      {189, 185, 111, 215, 8}
+    },
+    { {197, 129, 104, 9, 8},
+      {160, 34, 21, 198, 4},
+      {25, 1, 104, 26, 3},
+      {38, 58, 132, 64, 5}
+    },
+    { {43, 241, 86, 121, 0},
+      {99, 103, 178, 93, 0},
+      {9, 230, 168, 253, 4},
+      {11, 164, 222, 108, 6}
+    },
+    { {139, 50, 134, 244, 8},
+      {75, 193, 139, 75, 2},
+      {18, 246, 20, 205, 1},
+      {77, 45, 24, 61, 2}
+    },
+    { {35, 88, 1, 235, 6},
+      {80, 52, 98, 77, 11},
+      {109, 120, 1, 172, 4},
+      {219, 36, 98, 192, 10}
+    },
+    { {42, 83, 143, 50, 8},
+      {82, 199, 175, 1, 1},
+      {20, 207, 28, 165, 4},
+      {136, 15, 94, 52, 10}
+    },
+    { {16, 109, 126, 84, 8},
+      {41, 79, 133, 56, 12},
+      {18, 167, 235, 96, 8},
+      {49, 202, 31, 41, 4}
+    },
+    { {70, 253, 197, 231, 10},
+      {249, 151, 19, 173, 11},
+      {94, 122, 59, 246, 2},
+      {219, 92, 142, 153, 15}
+    },
+    { {69, 106, 10, 93, 0},
+      {137, 100, 140, 204, 8},
+      {11, 165, 5, 106, 2},
+      {19, 51, 18, 105, 1}
+    },
+    { {217, 50, 39, 125, 10},
+      {91, 121, 139, 206, 4},
+      {91, 238, 68, 201, 11},
+      {39, 61, 25, 237, 10}
+    },
+    { {97, 59, 235, 152, 1},
+      {117, 226, 172, 192, 14},
+      {129, 157, 125, 200, 6},
+      {112, 51, 84, 122, 14}
+    },
+    { {191, 19, 181, 70, 0},
+      {218, 139, 40, 91, 5},
+      {6, 42, 220, 143, 13},
+      {173, 161, 77, 21, 11}
+    },
+    { {130, 186, 168, 203, 13},
+      {69, 160, 93, 15, 15},
+      {189, 49, 85, 212, 1},
+      {255, 11, 160, 90, 2}
+    },
+    { {81, 205, 99, 27, 3},
+      {52, 126, 144, 228, 13},
+      {205, 140, 107, 56, 10},
+      {178, 112, 151, 226, 12}
+    },
+    { {112, 171, 240, 76, 7},
+      {45, 186, 120, 152, 12},
+      {227, 32, 253, 80, 14},
+      {49, 145, 229, 219, 4}
+    },
+    { {170, 102, 185, 24, 7},
+      {23, 180, 236, 51, 4},
+      {225, 137, 214, 101, 5},
+      {44, 195, 114, 222, 8}
+    },
+    { {140, 20, 60, 97, 6},
+      {194, 17, 70, 62, 4},
+      {104, 99, 194, 131, 1},
+      {39, 198, 40, 132, 3}
+    },
+    { {241, 160, 157, 75, 0},
+      {17, 169, 52, 222, 1},
+      {13, 43, 144, 88, 15},
+      {135, 178, 201, 88, 8}
+    },
+    { {95, 27, 95, 220, 4},
+      {250, 107, 204, 217, 10},
+      {35, 191, 173, 143, 10},
+      {89, 179, 61, 101, 15}
+    },
+    { {104, 72, 189, 153, 8},
+      {18, 165, 165, 148, 14},
+      {25, 155, 209, 33, 6},
+      {114, 154, 90, 84, 8}
+    },
+    { {235, 245, 28, 134, 10},
+      {75, 23, 53, 243, 3},
+      {86, 19, 138, 253, 7},
+      {204, 250, 206, 141, 2}
+    },
+    { {201, 92, 23, 53, 15},
+      {94, 85, 195, 246, 8},
+      {250, 206, 131, 169, 3},
+      {22, 252, 58, 167, 10}
+    },
+    { {164, 229, 178, 170, 9},
+      {133, 230, 51, 50, 7},
+      {149, 84, 218, 114, 5},
+      {228, 204, 198, 122, 1}
+    },
+    { {137, 187, 40, 109, 9},
+      {79, 34, 31, 78, 12},
+      {155, 97, 77, 217, 1},
+      {55, 47, 132, 79, 2}
+    },
+    { {252, 83, 211, 81, 9},
+      {246, 206, 169, 158, 0},
+      {152, 172, 188, 163, 15},
+      {7, 153, 87, 54, 15}
+    },
+    { {132, 250, 176, 250, 11},
+      {197, 180, 155, 26, 15},
+      {213, 240, 213, 242, 1},
+      {245, 141, 146, 218, 3}
+    },
+    { {135, 156, 9, 173, 7},
+      {220, 48, 86, 103, 10},
+      {235, 89, 3, 158, 1},
+      {94, 102, 160, 195, 11}
+    },
+    { {84, 19, 120, 184, 10},
+      {224, 58, 143, 144, 6},
+      {81, 209, 236, 130, 10},
+      {96, 159, 21, 192, 7}
+    },
+    { {93, 207, 118, 108, 5},
+      {174, 111, 90, 248, 12},
+      {163, 102, 239, 59, 10},
+      {49, 245, 175, 103, 5}
+    },
+    { {15, 128, 112, 181, 8},
+      {170, 0, 147, 85, 6},
+      {26, 208, 224, 31, 0},
+      {106, 172, 144, 5, 5}
+    },
+    { {208, 181, 28, 15, 14},
+      {73, 59, 85, 182, 1},
+      {127, 3, 138, 208, 11},
+      {134, 218, 173, 201, 2}
+    },
+    { {132, 202, 160, 119, 12},
+      {136, 132, 219, 14, 13},
+      {62, 224, 85, 50, 1},
+      {183, 13, 178, 17, 1}
+    },
+    { {237, 211, 180, 253, 12},
+      {202, 167, 251, 222, 6},
+      {59, 242, 220, 187, 7},
+      {103, 189, 254, 85, 3}
+    },
+    { {54, 161, 151, 8, 4},
+      {145, 235, 112, 17, 0},
+      {33, 14, 152, 86, 12},
+      {8, 128, 237, 120, 9}
+    },
+    { {140, 65, 87, 242, 7},
+      {182, 87, 194, 26, 3},
+      {228, 254, 168, 35, 1},
+      {197, 132, 62, 166, 13}
+    },
+    { {236, 146, 34, 145, 13},
+      {198, 64, 249, 134, 6},
+      {184, 148, 68, 147, 7},
+      {102, 25, 240, 38, 3}
+    },
+    { {44, 51, 74, 17, 10},
+      {227, 82, 173, 4, 0},
+      {88, 133, 44, 195, 4},
+      {2, 11, 84, 172, 7}
+    },
+    { {149, 119, 148, 119, 8},
+      {201, 143, 139, 126, 1},
+      {30, 226, 158, 234, 9},
+      {135, 237, 31, 25, 3}
+    },
+    { {79, 158, 57, 137, 13},
+      {214, 32, 93, 245, 14},
+      {185, 25, 199, 159, 2},
+      {122, 251, 160, 70, 11}
+    },
+    { {181, 203, 34, 59, 11},
+      {132, 126, 187, 70, 13},
+      {221, 196, 77, 58, 13},
+      {182, 45, 215, 226, 1}
+    },
+    { {238, 226, 189, 59, 11},
+      {151, 181, 191, 151, 5},
+      {221, 203, 212, 119, 7},
+      {174, 159, 218, 222, 9}
+    },
+    { {133, 212, 25, 195, 12},
+      {208, 4, 85, 126, 3},
+      {60, 57, 130, 186, 1},
+      {199, 234, 162, 0, 11}
+    },
+    { {186, 35, 215, 19, 11},
+      {55, 219, 169, 23, 1},
+      {220, 142, 188, 69, 13},
+      {142, 137, 93, 190, 12}
+    },
+    { {141, 72, 238, 157, 1},
+      {174, 229, 132, 70, 14},
+      {139, 151, 113, 43, 1},
+      {118, 34, 26, 119, 5}
+    },
+    { {120, 69, 116, 14, 9},
+      {46, 47, 33, 176, 5},
+      {151, 2, 234, 33, 14},
+      {160, 216, 79, 71, 4}
+    },
+    { {100, 231, 234, 47, 8},
+      {169, 230, 63, 164, 5},
+      {31, 69, 126, 114, 6},
+      {162, 95, 198, 121, 5}
+    },
+    { {100, 118, 246, 62, 4},
+      {233, 229, 234, 176, 5},
+      {39, 198, 246, 226, 6},
+      {160, 213, 122, 121, 7}
+    },
+    { {14, 238, 158, 149, 0},
+      {139, 197, 156, 53, 10},
+      {10, 151, 151, 119, 0},
+      {90, 195, 154, 61, 1}
+    },
+    { {220, 175, 168, 110, 11},
+      {143, 186, 31, 170, 13},
+      {215, 97, 95, 83, 11},
+      {181, 95, 133, 223, 1}
+    },
+    { {135, 109, 56, 242, 14},
+      {129, 22, 199, 123, 15},
+      {116, 241, 203, 110, 1},
+      {253, 238, 54, 136, 1}
+    },
+    { {59, 235, 39, 76, 5},
+      {31, 111, 120, 73, 12},
+      {163, 46, 77, 125, 12},
+      {57, 33, 239, 111, 8}
+    },
+    { {184, 191, 89, 23, 4},
+      {123, 10, 252, 54, 9},
+      {46, 137, 175, 209, 13},
+      {150, 195, 245, 13, 14}
+    },
+    { {171, 32, 236, 13, 0},
+      {43, 161, 36, 71, 4},
+      {11, 3, 112, 77, 5},
+      {46, 34, 72, 93, 4}
+    },
+    { {13, 85, 26, 83, 3},
+      {198, 86, 132, 124, 1},
+      {204, 165, 138, 171, 0},
+      {131, 226, 22, 166, 3}
+    },
+    { {164, 73, 46, 167, 8},
+      {136, 71, 39, 6, 15},
+      {30, 87, 73, 34, 5},
+      {246, 14, 78, 33, 1}
+    },
+    { {93, 108, 92, 103, 6},
+      {171, 29, 70, 252, 9},
+      {110, 99, 163, 107, 10},
+      {147, 246, 43, 141, 5}
+    },
+    { {153, 4, 153, 70, 10},
+      {26, 152, 5, 122, 1},
+      {86, 41, 146, 9, 9},
+      {133, 234, 1, 149, 8}
+    },
+    { {10, 157, 128, 226, 6},
+      {66, 146, 82, 41, 11},
+      {100, 112, 27, 149, 0},
+      {217, 68, 164, 148, 2}
+    },
+    { {105, 134, 183, 41, 15},
+      {22, 241, 123, 244, 4},
+      {249, 78, 214, 25, 6},
+      {34, 253, 232, 246, 8}
+    },
+    { {143, 173, 130, 44, 13},
+      {143, 226, 83, 99, 8},
+      {179, 68, 27, 95, 1},
+      {28, 108, 164, 127, 1}
+    },
+    { {226, 67, 95, 38, 3},
+      {60, 87, 46, 147, 1},
+      {198, 79, 172, 36, 7},
+      {140, 151, 78, 163, 12}
+    },
+    { {209, 155, 215, 78, 11},
+      {124, 251, 25, 218, 9},
+      {215, 46, 189, 152, 11},
+      {149, 185, 141, 243, 14}
+    },
+    { {196, 218, 25, 133, 15},
+      {220, 20, 93, 150, 10},
+      {250, 25, 133, 178, 3},
+      {86, 155, 162, 131, 11}
+    },
+    { {26, 193, 30, 251, 4},
+      {2, 111, 214, 29, 3},
+      {45, 247, 136, 53, 8},
+      {203, 134, 191, 100, 0}
+    },
+    { {17, 45, 28, 17, 1},
+      {5, 11, 132, 116, 8},
+      {136, 131, 139, 72, 8},
+      {18, 226, 29, 10, 0}
+    },
+    { {45, 76, 8, 144, 6},
+      {130, 20, 228, 96, 10},
+      {96, 145, 3, 43, 4},
+      {80, 98, 114, 132, 1}
+    },
+    { {108, 235, 79, 250, 4},
+      {179, 103, 254, 136, 11},
+      {37, 255, 45, 115, 6},
+      {209, 23, 254, 108, 13}
+    },
+    { {171, 203, 198, 115, 11},
+      {38, 215, 187, 79, 9},
+      {220, 230, 61, 61, 5},
+      {159, 45, 222, 182, 4}
+    },
+    { {40, 32, 233, 173, 13},
+      {63, 160, 103, 4, 6},
+      {187, 89, 112, 65, 4},
+      {98, 14, 96, 95, 12}
+    },
+    { {127, 250, 209, 178, 2},
+      {243, 156, 186, 209, 11},
+      {68, 216, 181, 255, 14},
+      {216, 181, 211, 156, 15}
+    },
+    { {27, 102, 106, 88, 7},
+      {39, 124, 204, 105, 4},
+      {225, 165, 102, 109, 8},
+      {41, 99, 51, 238, 4}
+    },
+    { {164, 137, 72, 44, 7},
+      {172, 50, 118, 2, 8},
+      {227, 65, 41, 18, 5},
+      {20, 6, 228, 195, 5}
+    },
+    { {141, 42, 28, 71, 0},
+      {139, 1, 12, 94, 9},
+      {14, 35, 133, 75, 1},
+      {151, 163, 8, 13, 1}
+    },
+    { {125, 182, 84, 216, 0},
+      {227, 41, 184, 248, 2},
+      {1, 178, 166, 219, 14},
+      {65, 241, 217, 76, 7}
+    },
+    { {179, 222, 10, 136, 11},
+      {68, 124, 61, 99, 10},
+      {209, 21, 7, 188, 13},
+      {92, 107, 195, 226, 2}
+    },
+    { {214, 120, 202, 34, 1},
+      {229, 204, 6, 131, 9},
+      {132, 69, 49, 230, 11},
+      {156, 22, 3, 58, 7}
+    },
+    { {136, 97, 82, 97, 11},
+      {39, 86, 3, 30, 0},
+      {216, 100, 168, 97, 1},
+      {7, 140, 6, 174, 4}
+    },
+    { {0, 238, 90, 84, 7},
+      {45, 84, 220, 56, 8},
+      {226, 165, 167, 112, 0},
+      {17, 195, 178, 171, 4}
+    },
+    { {84, 105, 30, 139, 4},
+      {129, 111, 68, 148, 11},
+      {45, 23, 137, 98, 10},
+      {210, 146, 47, 104, 1}
+    },
+    { {128, 254, 13, 106, 8},
+      {81, 37, 31, 42, 9},
+      {21, 107, 7, 240, 1},
+      {149, 79, 138, 72, 10}
+    },
+    { {195, 127, 154, 209, 2},
+      {65, 214, 140, 255, 10},
+      {72, 181, 159, 236, 3},
+      {95, 243, 22, 184, 2}
+    },
+    { {57, 235, 155, 203, 12},
+      {19, 238, 125, 92, 11},
+      {61, 61, 157, 121, 12},
+      {211, 171, 231, 124, 8}
+    },
+    { {156, 205, 246, 33, 8},
+      {162, 207, 19, 54, 12},
+      {24, 70, 251, 51, 9},
+      {54, 204, 143, 52, 5}
+    },
+    { {83, 192, 184, 251, 11},
+      {4, 188, 151, 221, 7},
+      {221, 241, 208, 60, 10},
+      {235, 190, 147, 210, 0}
+    },
+    { {159, 93, 81, 153, 0},
+      {242, 46, 128, 119, 10},
+      {9, 152, 171, 175, 9},
+      {94, 224, 23, 68, 15}
+    },
+    { {208, 152, 110, 185, 3},
+      {100, 121, 150, 134, 14},
+      {201, 215, 97, 144, 11},
+      {118, 22, 153, 226, 6}
+    },
+    { {21, 133, 42, 206, 6},
+      {136, 122, 84, 104, 7},
+      {103, 53, 74, 26, 8},
+      {225, 98, 165, 225, 1}
+    },
+    { {144, 212, 121, 19, 3},
+      {116, 28, 148, 54, 5},
+      {204, 137, 226, 176, 9},
+      {166, 194, 147, 130, 14}
+    },
+    { {44, 22, 172, 202, 12},
+      {194, 161, 109, 40, 7},
+      {53, 51, 86, 131, 4},
+      {225, 75, 104, 84, 3}
+    },
+    { {112, 226, 233, 181, 14},
+      {57, 156, 255, 132, 6},
+      {122, 217, 116, 112, 14},
+      {98, 31, 243, 153, 12}
+    },
+    { {36, 160, 106, 178, 15},
+      {165, 80, 247, 0, 7},
+      {244, 213, 96, 82, 4},
+      {224, 14, 240, 170, 5}
+    },
+    { {114, 1, 237, 44, 10},
+      {56, 187, 39, 129, 4},
+      {83, 75, 120, 4, 14},
+      {40, 30, 77, 209, 12}
+    },
+    { {76, 99, 9, 66, 8},
+      {147, 6, 13, 136, 1},
+      {20, 41, 12, 99, 2},
+      {129, 27, 6, 12, 9}
+    },
+    { {6, 185, 203, 230, 13},
+      {253, 194, 87, 9, 11},
+      {182, 125, 57, 214, 0},
+      {217, 14, 164, 59, 15}
+    },
+    { {215, 246, 104, 218, 12},
+      {225, 44, 221, 235, 7},
+      {53, 177, 102, 254, 11},
+      {237, 123, 179, 72, 7}
+    },
+    { {129, 109, 246, 113, 1},
+      {37, 199, 130, 126, 12},
+      {136, 230, 251, 104, 1},
+      {55, 228, 30, 58, 4}
+    },
+    { {88, 117, 65, 240, 5},
+      {119, 14, 194, 168, 2},
+      {160, 248, 42, 225, 10},
+      {65, 84, 55, 14, 14}
+    },
+    { {74, 115, 6, 33, 0},
+      {67, 71, 10, 133, 0},
+      {8, 70, 12, 229, 2},
+      {10, 21, 14, 44, 2}
+    },
+    { {72, 9, 86, 13, 1},
+      {46, 99, 0, 148, 8},
+      {139, 6, 169, 1, 2},
+      {18, 144, 12, 103, 4}
+    },
+    { {59, 153, 72, 245, 11},
+      {110, 26, 183, 77, 10},
+      {218, 241, 41, 157, 12},
+      {91, 46, 213, 135, 6}
+    },
+    { {54, 150, 213, 148, 6},
+      {248, 153, 248, 49, 2},
+      {98, 154, 182, 150, 12},
+      {72, 193, 249, 145, 15}
+    },
+    { {81, 34, 220, 136, 12},
+      {33, 169, 77, 208, 2},
+      {49, 19, 180, 72, 10},
+      {64, 187, 41, 88, 4}
+    },
+    { {168, 69, 58, 219, 0},
+      {2, 102, 164, 62, 7},
+      {13, 181, 202, 33, 5},
+      {231, 194, 86, 100, 0}
+    },
+    { {180, 120, 208, 7, 12},
+      {233, 140, 97, 22, 9},
+      {62, 0, 177, 226, 13},
+      {150, 136, 99, 25, 7}
+    },
+    { {213, 175, 225, 90, 1},
+      {181, 170, 152, 234, 13},
+      {133, 168, 127, 90, 11},
+      {181, 113, 149, 90, 13}
+    },
+    { {4, 255, 169, 156, 13},
+      {221, 166, 221, 32, 14},
+      {179, 153, 95, 242, 0},
+      {112, 75, 182, 91, 11}
+    },
+    { {178, 170, 134, 106, 1},
+      {5, 233, 58, 11, 9},
+      {133, 102, 21, 84, 13},
+      {157, 5, 201, 122, 0}
+    },
+    { {33, 202, 57, 14, 7},
+      {28, 52, 124, 80, 13},
+      {231, 9, 197, 56, 4},
+      {176, 163, 226, 195, 8}
+    },
+    { {217, 149, 56, 136, 0},
+      {66, 42, 20, 242, 6},
+      {1, 17, 202, 153, 11},
+      {100, 242, 133, 68, 2}
+    },
+    { {158, 66, 134, 121, 2},
+      {130, 253, 138, 15, 0},
+      {73, 230, 20, 39, 9},
+      {15, 5, 27, 244, 1}
+    },
+    { {35, 126, 230, 40, 15},
+      {101, 245, 107, 97, 12},
+      {241, 70, 119, 236, 4},
+      {56, 109, 106, 250, 6}
+    },
+    { {223, 217, 194, 111, 1},
+      {238, 238, 18, 207, 9},
+      {143, 100, 57, 191, 11},
+      {159, 52, 135, 119, 7}
+    },
+    { {134, 37, 95, 146, 14},
+      {177, 83, 197, 51, 3},
+      {116, 159, 170, 70, 1},
+      {204, 202, 60, 168, 13}
+    },
+    { {89, 24, 159, 35, 8},
+      {82, 201, 7, 212, 9},
+      {28, 79, 145, 137, 10},
+      {146, 190, 9, 52, 10}
+    },
+    { {83, 168, 9, 113, 7},
+      {21, 24, 214, 205, 8},
+      {232, 233, 1, 92, 10},
+      {27, 54, 177, 138, 8}
+    },
+    { {8, 171, 22, 118, 15},
+      {15, 83, 219, 24, 9},
+      {246, 230, 141, 81, 0},
+      {145, 141, 188, 175, 0}
+    },
+    { {249, 140, 152, 28, 13},
+      {14, 168, 245, 242, 8},
+      {179, 129, 147, 25, 15},
+      {20, 250, 241, 87, 0}
+    },
+    { {249, 136, 239, 149, 11},
+      {62, 217, 181, 198, 14},
+      {218, 159, 113, 25, 15},
+      {118, 58, 217, 183, 12}
+    },
+    { {31, 2, 254, 30, 14},
+      {170, 249, 205, 81, 5},
+      {119, 135, 244, 15, 8},
+      {168, 171, 57, 245, 5}
+    },
+    { {104, 234, 254, 163, 13},
+      {39, 197, 127, 148, 15},
+      {188, 87, 245, 113, 6},
+      {242, 159, 234, 62, 4}
+    },
+    { {126, 145, 79, 240, 6},
+      {242, 91, 246, 137, 2},
+      {96, 255, 40, 151, 14},
+      {73, 22, 253, 164, 15}
+    },
+    { {44, 149, 20, 92, 13},
+      {206, 35, 241, 56, 0},
+      {179, 162, 138, 147, 4},
+      {1, 200, 252, 71, 3}
+    },
+    { {62, 147, 44, 208, 8},
+      {194, 11, 189, 9, 6},
+      {16, 179, 76, 151, 12},
+      {105, 11, 221, 4, 3}
+    },
+    { {183, 92, 175, 40, 3},
+      {212, 253, 38, 99, 12},
+      {193, 79, 83, 174, 13},
+      {60, 102, 75, 242, 11}
+    },
+    { {186, 245, 114, 60, 11},
+      {111, 126, 179, 51, 4},
+      {211, 196, 234, 245, 13},
+      {44, 204, 215, 239, 6}
+    },
+    { {121, 203, 18, 140, 13},
+      {14, 110, 121, 208, 10},
+      {179, 20, 141, 57, 14},
+      {80, 185, 231, 103, 0}
+    },
+    { {64, 87, 46, 30, 0},
+      {72, 103, 140, 160, 5},
+      {7, 135, 78, 160, 2},
+      {160, 83, 30, 97, 2}
+    },
+    { {82, 212, 150, 97, 15},
+      {68, 221, 83, 189, 0},
+      {248, 102, 146, 180, 10},
+      {11, 220, 171, 178, 2}
+    },
+    { {177, 112, 92, 13, 10},
+      {105, 61, 37, 86, 0},
+      {91, 3, 160, 232, 13},
+      {6, 170, 75, 201, 6}
+    },
+    { {99, 49, 219, 103, 3},
+      {125, 210, 38, 221, 1},
+      {206, 109, 184, 204, 6},
+      {139, 182, 68, 187, 14}
+    },
+    { {16, 154, 188, 196, 1},
+      {76, 137, 28, 24, 14},
+      {130, 51, 213, 144, 8},
+      {113, 131, 137, 19, 2}
+    },
+    { {96, 60, 124, 104, 15},
+      {101, 49, 103, 184, 12},
+      {241, 99, 227, 192, 6},
+      {49, 222, 104, 202, 6}
+    },
+    { {115, 50, 161, 255, 11},
+      {93, 184, 171, 205, 7},
+      {223, 248, 84, 204, 14},
+      {235, 61, 81, 219, 10}
+    },
+    { {61, 143, 96, 230, 4},
+      {170, 10, 122, 104, 15},
+      {38, 112, 111, 27, 12},
+      {241, 101, 229, 5, 5}
+    },
+    { {202, 97, 172, 50, 9},
+      {7, 135, 135, 131, 5},
+      {148, 195, 88, 101, 3},
+      {172, 30, 30, 30, 0}
+    },
+    { {132, 25, 50, 28, 14},
+      {200, 114, 193, 18, 12},
+      {115, 132, 201, 130, 1},
+      {52, 136, 52, 225, 3}
+    },
+    { {171, 167, 29, 138, 7},
+      {23, 51, 124, 115, 3},
+      {229, 27, 142, 93, 5},
+      {204, 227, 236, 206, 8}
+    },
+    { {220, 105, 76, 91, 7},
+      {167, 63, 196, 142, 9},
+      {237, 163, 41, 99, 11},
+      {151, 18, 63, 206, 5}
+    },
+    { {244, 156, 252, 224, 5},
+      {228, 137, 118, 186, 14},
+      {160, 115, 243, 146, 15},
+      {117, 214, 233, 18, 7}
+    },
+    { {200, 69, 243, 60, 3},
+      {62, 246, 130, 178, 4},
+      {195, 204, 250, 33, 3},
+      {36, 212, 22, 247, 12}
+    },
+    { {104, 74, 251, 82, 12},
+      {50, 196, 237, 152, 13},
+      {52, 173, 245, 33, 6},
+      {177, 155, 114, 52, 12}
+    },
+    { {214, 20, 91, 29, 3},
+      {252, 120, 132, 183, 0},
+      {203, 141, 162, 134, 11},
+      {14, 210, 17, 227, 15}
+    },
+    { {16, 253, 223, 173, 12},
+      {121, 239, 87, 52, 10},
+      {59, 95, 187, 240, 8},
+      {82, 206, 175, 121, 14}
+    },
+    { {31, 139, 72, 20, 8},
+      {170, 10, 157, 65, 8},
+      {18, 129, 45, 31, 8},
+      {24, 43, 149, 5, 5}
+    },
+    { {156, 50, 163, 233, 3},
+      {215, 248, 10, 14, 6},
+      {201, 124, 84, 195, 9},
+      {103, 5, 1, 254, 11}
+    },
+    { {157, 108, 124, 56, 7},
+      {167, 61, 198, 114, 12},
+      {225, 195, 227, 107, 9},
+      {52, 230, 59, 206, 5}
+    },
+    { {183, 3, 177, 221, 5},
+      {156, 170, 232, 95, 6},
+      {171, 184, 220, 14, 13},
+      {111, 161, 117, 83, 9}
+    },
+    { {111, 221, 59, 152, 0},
+      {210, 102, 180, 241, 14},
+      {1, 157, 203, 191, 6},
+      {120, 242, 214, 100, 11}
+    },
+    { {178, 62, 176, 218, 4},
+      {65, 168, 232, 59, 15},
+      {37, 176, 215, 196, 13},
+      {253, 193, 113, 88, 2}
+    },
+    { {115, 173, 103, 162, 0},
+      {49, 75, 50, 225, 15},
+      {4, 94, 107, 92, 14},
+      {248, 116, 205, 40, 12}
+    },
+    { {83, 97, 3, 190, 8},
+      {25, 110, 131, 193, 3},
+      {23, 220, 8, 108, 10},
+      {200, 60, 23, 105, 8}
+    },
+    { {214, 122, 66, 252, 3},
+      {237, 124, 138, 139, 10},
+      {195, 244, 37, 230, 11},
+      {93, 21, 19, 235, 7}
+    },
+    { {31, 40, 119, 191, 6},
+      {187, 121, 194, 85, 15},
+      {111, 222, 225, 79, 8},
+      {250, 164, 57, 237, 13}
+    },
+    { {45, 103, 170, 137, 12},
+      {131, 230, 109, 100, 6},
+      {57, 21, 94, 107, 4},
+      {98, 107, 102, 124, 1}
+    },
+    { {168, 55, 137, 133, 0},
+      {91, 130, 44, 38, 2},
+      {10, 25, 30, 193, 5},
+      {70, 67, 68, 29, 10}
+    },
+    { {47, 235, 63, 25, 12},
+      {147, 103, 253, 85, 12},
+      {57, 143, 205, 127, 4},
+      {58, 171, 254, 108, 9}
+    },
+    { {41, 160, 212, 118, 5},
+      {47, 129, 242, 88, 1},
+      {166, 226, 176, 89, 4},
+      {129, 164, 248, 31, 4}
+    },
+    { {65, 177, 230, 167, 15},
+      {109, 211, 83, 196, 7},
+      {254, 86, 120, 216, 2},
+      {226, 60, 172, 187, 6}
+    },
+    { {248, 93, 126, 140, 7},
+      {110, 127, 100, 178, 14},
+      {227, 23, 235, 161, 15},
+      {116, 210, 111, 231, 6}
+    },
+    { {133, 48, 143, 35, 4},
+      {209, 193, 70, 70, 1},
+      {44, 79, 16, 202, 1},
+      {134, 38, 40, 56, 11}
+    },
+    { {121, 131, 156, 71, 5},
+      {14, 139, 124, 220, 1},
+      {174, 35, 156, 25, 14},
+      {131, 179, 237, 23, 0}
+    },
+    { {75, 124, 102, 113, 8},
+      {99, 69, 131, 237, 12},
+      {24, 230, 99, 237, 2},
+      {59, 124, 26, 44, 6}
+    },
+    { {231, 237, 2, 5, 2},
+      {137, 86, 48, 231, 8},
+      {74, 4, 11, 126, 7},
+      {30, 112, 198, 169, 1}
+    },
+    { {57, 33, 5, 61, 13},
+      {31, 43, 227, 68, 0},
+      {187, 202, 8, 73, 12},
+      {2, 44, 125, 79, 8}
+    },
+    { {46, 92, 218, 7, 3},
+      {238, 212, 36, 53, 9},
+      {206, 5, 179, 167, 4},
+      {154, 194, 66, 183, 7}
+    },
+    { {191, 65, 151, 115, 14},
+      {146, 223, 227, 95, 1},
+      {124, 238, 152, 47, 13},
+      {143, 172, 127, 180, 9}
+    },
+    { {229, 242, 167, 113, 14},
+      {209, 213, 251, 206, 4},
+      {120, 238, 84, 250, 7},
+      {39, 61, 250, 184, 11}
+    },
+    { {189, 13, 222, 45, 14},
+      {170, 251, 103, 118, 8},
+      {123, 71, 187, 11, 13},
+      {22, 238, 109, 245, 5}
+    },
+    { {104, 73, 143, 23, 14},
+      {26, 215, 229, 132, 9},
+      {126, 143, 25, 33, 6},
+      {146, 26, 126, 181, 8}
+    },
+    { {183, 56, 155, 230, 11},
+      {221, 216, 39, 91, 11},
+      {214, 125, 145, 206, 13},
+      {221, 174, 65, 187, 11}
+    },
+    { {41, 127, 247, 175, 7},
+      {127, 247, 106, 116, 15},
+      {239, 94, 255, 233, 4},
+      {242, 229, 110, 255, 14}
+    },
+    { {177, 201, 139, 131, 7},
+      {20, 222, 116, 70, 11},
+      {236, 29, 25, 56, 13},
+      {214, 34, 231, 178, 8}
+    },
+    { {112, 239, 122, 3, 2},
+      {33, 94, 60, 180, 13},
+      {76, 5, 239, 112, 14},
+      {178, 211, 199, 168, 4}
+    },
+    { {155, 66, 34, 76, 0},
+      {10, 108, 8, 75, 4},
+      {3, 36, 68, 45, 9},
+      {45, 33, 3, 101, 0}
+    },
+    { {45, 220, 24, 13, 15},
+      {206, 52, 117, 116, 8},
+      {251, 1, 131, 187, 4},
+      {18, 234, 226, 199, 3}
+    },
+    { {10, 189, 5, 237, 15},
+      {95, 51, 83, 45, 10},
+      {251, 122, 11, 213, 0},
+      {91, 76, 172, 207, 10}
+    },
+    { {225, 190, 133, 89, 1},
+      {85, 161, 184, 238, 8},
+      {137, 170, 23, 216, 7},
+      {23, 113, 216, 90, 10}
+    },
+    { {145, 183, 86, 114, 7},
+      {101, 91, 218, 122, 1},
+      {228, 230, 174, 216, 9},
+      {133, 229, 189, 170, 6}
+    },
+    { {45, 22, 243, 125, 11},
+      {254, 240, 171, 124, 4},
+      {219, 236, 246, 139, 4},
+      {35, 237, 80, 247, 15}
+    },
+    { {39, 176, 238, 193, 6},
+      {225, 209, 116, 77, 6},
+      {104, 55, 112, 222, 4},
+      {107, 34, 232, 184, 7}
+    },
+    { {108, 133, 130, 249, 13},
+      {134, 226, 243, 172, 2},
+      {185, 244, 26, 19, 6},
+      {67, 92, 244, 118, 1}
+    },
+    { {115, 83, 40, 110, 3},
+      {76, 62, 46, 201, 5},
+      {199, 97, 76, 172, 14},
+      {169, 55, 71, 195, 2}
+    },
+    { {97, 193, 148, 57, 1},
+      {4, 167, 178, 212, 0},
+      {137, 194, 152, 56, 6},
+      {2, 180, 222, 82, 0}
+    },
+    { {123, 144, 243, 154, 9},
+      {118, 232, 177, 209, 7},
+      {149, 156, 240, 157, 14},
+      {232, 184, 209, 118, 14}
+    },
+    { {199, 152, 208, 205, 5},
+      {236, 160, 80, 223, 10},
+      {171, 48, 177, 158, 3},
+      {95, 176, 160, 83, 7}
+    },
+    { {40, 109, 39, 77, 11},
+      {31, 119, 33, 44, 12},
+      {219, 46, 75, 97, 4},
+      {51, 72, 78, 239, 8}
+    },
+    { {217, 203, 12, 182, 4},
+      {10, 15, 222, 194, 11},
+      {38, 211, 13, 57, 11},
+      {212, 55, 191, 5, 0}
+    },
+    { {74, 39, 247, 51, 6},
+      {51, 211, 202, 181, 5},
+      {108, 206, 254, 69, 2},
+      {170, 213, 60, 188, 12}
+    },
+    { {58, 192, 163, 225, 10},
+      {18, 220, 51, 13, 6},
+      {88, 124, 80, 53, 12},
+      {107, 12, 195, 180, 8}
+    },
+    { {7, 221, 220, 229, 7},
+      {236, 151, 86, 125, 10},
+      {234, 115, 187, 190, 0},
+      {91, 230, 174, 147, 7}
+    },
+    { {136, 88, 155, 155, 11},
+      {86, 244, 133, 22, 11},
+      {221, 157, 145, 161, 1},
+      {214, 138, 18, 246, 10}
+    },
+    { {138, 23, 163, 27, 11},
+      {86, 242, 137, 39, 5},
+      {221, 140, 94, 133, 1},
+      {174, 73, 20, 246, 10}
+    },
+    { {238, 5, 82, 209, 7},
+      {166, 82, 224, 191, 2},
+      {232, 180, 170, 7, 7},
+      {79, 208, 116, 166, 5}
+    },
+    { {187, 95, 31, 51, 1},
+      {86, 79, 174, 119, 9},
+      {140, 207, 143, 173, 13},
+      {158, 231, 95, 38, 10}
+    },
+    { {208, 60, 187, 190, 2},
+      {89, 248, 134, 178, 15},
+      {71, 221, 211, 192, 11},
+      {244, 214, 17, 249, 10}
+    },
+    { {152, 244, 149, 172, 6},
+      {91, 189, 82, 50, 2},
+      {99, 90, 146, 241, 9},
+      {68, 196, 171, 221, 10}
+    },
+    { {197, 139, 251, 112, 15},
+      {180, 210, 223, 218, 12},
+      {240, 237, 253, 26, 3},
+      {53, 191, 180, 178, 13}
+    },
+    { {122, 253, 6, 239, 8},
+      {75, 111, 51, 173, 11},
+      {31, 118, 11, 245, 14},
+      {219, 92, 207, 109, 2}
+    },
+    { {81, 109, 127, 193, 5},
+      {53, 79, 68, 252, 14},
+      {168, 63, 235, 104, 10},
+      {115, 242, 47, 42, 12}
+    },
+    { {187, 149, 178, 239, 2},
+      {74, 250, 50, 127, 7},
+      {79, 116, 218, 157, 13},
+      {239, 228, 197, 245, 2}
+    },
+    { {74, 73, 174, 244, 10},
+      {10, 215, 135, 137, 14},
+      {82, 247, 89, 37, 2},
+      {121, 30, 30, 181, 0}
+    },
+    { {121, 22, 119, 209, 9},
+      {118, 73, 169, 252, 6},
+      {152, 190, 230, 137, 14},
+      {99, 249, 89, 38, 14}
+    },
+    { {171, 195, 19, 250, 3},
+      {22, 118, 186, 91, 3},
+      {197, 252, 140, 61, 5},
+      {205, 165, 214, 230, 8}
+    },
+    { {97, 72, 188, 236, 1},
+      {12, 165, 38, 216, 14},
+      {131, 115, 209, 40, 6},
+      {113, 182, 74, 83, 0}
+    },
+    { {189, 91, 56, 250, 15},
+      {198, 62, 239, 90, 15},
+      {245, 241, 205, 171, 13},
+      {245, 175, 119, 198, 3}
+    },
+    { {167, 203, 22, 91, 5},
+      {132, 103, 248, 95, 9},
+      {173, 166, 141, 62, 5},
+      {159, 161, 254, 98, 1}
+    },
+    { {122, 215, 157, 221, 12},
+      {90, 175, 253, 189, 2},
+      {59, 187, 158, 181, 14},
+      {75, 219, 255, 85, 10}
+    },
+    { {30, 33, 123, 48, 10},
+      {179, 90, 135, 17, 4},
+      {80, 205, 232, 71, 8},
+      {40, 142, 21, 172, 13}
+    },
+    { {7, 106, 159, 128, 15},
+      {149, 213, 77, 81, 10},
+      {240, 31, 149, 110, 0},
+      {88, 171, 42, 186, 9}
+    },
+    { {66, 20, 244, 73, 5},
+      {100, 161, 64, 189, 4},
+      {169, 34, 242, 132, 2},
+      {43, 208, 40, 82, 6}
+    },
+    { {90, 77, 21, 204, 4},
+      {26, 47, 64, 185, 10},
+      {35, 58, 139, 37, 10},
+      {89, 208, 47, 69, 8}
+    },
+    { {42, 237, 24, 136, 14},
+      {3, 54, 117, 49, 10},
+      {113, 17, 139, 117, 4},
+      {88, 202, 230, 204, 0}
+    },
+    { {74, 162, 225, 254, 13},
+      {63, 160, 219, 137, 7},
+      {183, 248, 116, 85, 2},
+      {233, 29, 176, 95, 12}
+    },
+    { {132, 142, 174, 178, 2},
+      {128, 209, 158, 34, 15},
+      {68, 215, 87, 18, 1},
+      {244, 71, 152, 176, 1}
+    },
+    { {51, 40, 220, 225, 13},
+      {37, 137, 103, 93, 10},
+      {184, 115, 177, 76, 12},
+      {91, 174, 105, 26, 4}
+    },
+    { {58, 219, 131, 61, 10},
+      {90, 254, 187, 5, 8},
+      {91, 204, 29, 181, 12},
+      {26, 13, 215, 245, 10}
+    },
+    { {115, 169, 29, 159, 13},
+      {29, 43, 245, 213, 11},
+      {191, 155, 137, 92, 14},
+      {218, 186, 253, 75, 8}
+    },
+    { {4, 109, 218, 103, 10},
+      {169, 214, 7, 60, 9},
+      {94, 101, 187, 98, 0},
+      {147, 206, 6, 185, 5}
+    },
+    { {58, 203, 120, 189, 13},
+      {46, 46, 255, 21, 14},
+      {187, 209, 237, 53, 12},
+      {122, 143, 247, 71, 4}
+    },
+    { {206, 153, 231, 26, 12},
+      {242, 227, 209, 131, 13},
+      {53, 142, 121, 151, 3},
+      {188, 24, 188, 116, 15}
+    },
+    { {165, 37, 165, 84, 6},
+      {153, 147, 224, 106, 4},
+      {98, 170, 90, 74, 5},
+      {37, 96, 124, 153, 9}
+    },
+    { {240, 63, 168, 232, 1},
+      {69, 170, 46, 170, 14},
+      {129, 113, 95, 192, 15},
+      {117, 87, 69, 90, 2}
+    },
+    { {118, 229, 192, 251, 1},
+      {165, 174, 178, 173, 3},
+      {141, 240, 58, 118, 14},
+      {203, 84, 215, 90, 5}
+    },
+    { {227, 99, 237, 110, 12},
+      {57, 167, 111, 203, 5},
+      {55, 107, 124, 108, 7},
+      {173, 63, 110, 89, 12}
+    },
+    { {116, 249, 37, 224, 5},
+      {213, 15, 114, 136, 14},
+      {160, 122, 73, 242, 14},
+      {113, 20, 239, 10, 11}
+    },
+    { {198, 217, 168, 122, 2},
+      {192, 182, 150, 139, 13},
+      {69, 225, 89, 182, 3},
+      {189, 22, 150, 208, 3}
+    },
+    { {13, 96, 234, 117, 11},
+      {175, 212, 135, 76, 4},
+      {218, 229, 112, 107, 0},
+      {35, 46, 18, 191, 5}
+    },
+    { {51, 227, 74, 122, 13},
+      {37, 110, 255, 73, 1},
+      {181, 229, 44, 124, 12},
+      {137, 47, 247, 106, 4}
+    },
+    { {113, 122, 201, 96, 4},
+      {113, 140, 110, 200, 8},
+      {32, 105, 53, 232, 14},
+      {17, 55, 99, 24, 14}
+    },
+    { {152, 138, 48, 249, 12},
+      {2, 40, 219, 30, 14},
+      {57, 240, 197, 17, 9},
+      {119, 141, 177, 68, 0}
+    },
+    { {46, 163, 26, 179, 12},
+      {131, 66, 255, 21, 3},
+      {60, 213, 140, 87, 4},
+      {202, 143, 244, 44, 1}
+    },
+    { {172, 182, 25, 142, 10},
+      {219, 48, 61, 50, 3},
+      {87, 25, 134, 211, 5},
+      {196, 203, 192, 205, 11}
+    },
+    { {240, 101, 182, 107, 5},
+      {5, 239, 98, 190, 5},
+      {173, 102, 218, 96, 15},
+      {167, 212, 111, 122, 0}
+    },
+    { {168, 198, 88, 212, 0},
+      {42, 4, 188, 58, 2},
+      {2, 177, 166, 49, 5},
+      {69, 195, 210, 5, 4}
+    },
+    { {204, 173, 140, 128, 11},
+      {135, 147, 21, 162, 10},
+      {208, 19, 27, 83, 3},
+      {84, 90, 140, 158, 1}
+    },
+    { {163, 169, 133, 130, 14},
+      {17, 147, 113, 67, 11},
+      {116, 26, 25, 92, 5},
+      {220, 40, 236, 152, 8}
+    },
+    { {236, 44, 102, 29, 0},
+      {171, 97, 160, 166, 12},
+      {11, 134, 99, 67, 7},
+      {54, 80, 88, 109, 5}
+    },
+    { {25, 228, 167, 179, 8},
+      {19, 205, 147, 100, 7},
+      {28, 222, 82, 121, 8},
+      {226, 108, 155, 60, 8}
+    },
+    { {141, 26, 103, 29, 6},
+      {250, 113, 200, 70, 12},
+      {107, 142, 101, 139, 1},
+      {54, 33, 56, 229, 15}
+    },
+    { {178, 43, 3, 194, 13},
+      {21, 74, 105, 11, 11},
+      {180, 60, 13, 68, 13},
+      {221, 9, 101, 42, 8}
+    },
+    { {233, 107, 129, 42, 2},
+      {19, 182, 42, 194, 9},
+      {69, 72, 29, 105, 7},
+      {148, 53, 70, 220, 8}
+    },
+    { {175, 188, 151, 185, 4},
+      {211, 225, 242, 119, 10},
+      {41, 222, 147, 223, 5},
+      {94, 228, 248, 124, 11}
+    },
+    { {46, 29, 146, 160, 8},
+      {194, 194, 35, 49, 10},
+      {16, 84, 155, 135, 4},
+      {88, 204, 68, 52, 3}
+    },
+    { {20, 26, 214, 160, 3},
+      {228, 217, 10, 16, 10},
+      {192, 86, 181, 130, 8},
+      {80, 133, 9, 178, 7}
+    },
+    { {181, 12, 21, 252, 0},
+      {152, 41, 162, 122, 10},
+      {3, 250, 131, 10, 13},
+      {85, 228, 89, 65, 9}
+    },
+    { {95, 40, 182, 146, 9},
+      {135, 201, 129, 209, 15},
+      {148, 150, 209, 79, 10},
+      {248, 184, 25, 62, 1}
+    },
+    { {5, 73, 160, 42, 15},
+      {132, 182, 67, 64, 13},
+      {245, 64, 89, 42, 0},
+      {176, 44, 38, 210, 1}
+    },
+    { {170, 29, 19, 140, 15},
+      {94, 114, 97, 51, 10},
+      {243, 28, 139, 133, 5},
+      {92, 200, 100, 231, 10}
+    },
+    { {214, 197, 212, 242, 6},
+      {160, 159, 210, 187, 3},
+      {100, 242, 186, 54, 11},
+      {205, 212, 191, 144, 5}
+    },
+    { {175, 39, 99, 231, 15},
+      {191, 82, 107, 111, 7},
+      {254, 124, 110, 79, 5},
+      {239, 109, 100, 175, 13}
+    },
+    { {13, 30, 84, 39, 10},
+      {234, 17, 11, 116, 9},
+      {94, 66, 167, 139, 0},
+      {146, 237, 8, 133, 7}
+    },
+    { {105, 13, 29, 67, 9},
+      {22, 3, 37, 252, 9},
+      {156, 43, 139, 9, 6},
+      {147, 250, 76, 6, 8}
+    },
+    { {142, 118, 82, 211, 11},
+      {231, 84, 137, 63, 3},
+      {220, 180, 166, 231, 1},
+      {207, 201, 18, 174, 7}
+    },
+    { {183, 231, 13, 198, 11},
+      {157, 31, 61, 107, 3},
+      {214, 59, 14, 126, 13},
+      {205, 107, 207, 139, 9}
+    },
+    { {91, 61, 61, 135, 11},
+      {95, 27, 5, 245, 15},
+      {222, 27, 203, 205, 10},
+      {250, 250, 13, 143, 10}
+    },
+    { {79, 134, 142, 113, 6},
+      {130, 209, 222, 237, 0},
+      {104, 231, 22, 31, 2},
+      {11, 119, 184, 180, 1}
+    },
+    { {177, 31, 187, 167, 12},
+      {88, 202, 111, 118, 15},
+      {62, 93, 223, 136, 13},
+      {246, 239, 101, 49, 10}
+    },
+    { {128, 174, 197, 152, 2},
+      {49, 177, 152, 34, 10},
+      {65, 154, 55, 80, 1},
+      {84, 65, 152, 216, 12}
+    },
+    { {213, 231, 198, 181, 15},
+      {173, 223, 219, 230, 2},
+      {250, 214, 62, 122, 11},
+      {70, 125, 191, 187, 5}
+    },
+    { {93, 45, 129, 118, 3},
+      {159, 154, 130, 232, 9},
+      {198, 232, 27, 75, 10},
+      {145, 116, 21, 159, 9}
+    },
+    { {203, 168, 201, 76, 1},
+      {63, 160, 20, 203, 8},
+      {131, 41, 49, 93, 3},
+      {29, 50, 128, 95, 12}
+    },
+    { {103, 230, 75, 17, 3},
+      {181, 84, 188, 229, 0},
+      {200, 141, 38, 126, 6},
+      {10, 115, 210, 170, 13}
+    },
+    { {250, 67, 80, 92, 14},
+      {42, 62, 233, 155, 0},
+      {115, 160, 172, 37, 15},
+      {13, 153, 119, 197, 4}
+    },
+    { {240, 150, 174, 222, 7},
+      {76, 249, 252, 170, 7},
+      {231, 183, 86, 144, 15},
+      {229, 83, 249, 243, 2}
+    },
+    { {71, 218, 157, 211, 11},
+      {212, 149, 157, 221, 11},
+      {220, 187, 149, 190, 2},
+      {219, 187, 154, 146, 11}
+    },
+    { {154, 5, 75, 133, 14},
+      {58, 90, 69, 39, 2},
+      {122, 29, 42, 5, 9},
+      {78, 74, 37, 165, 12}
+    },
+    { {120, 108, 53, 241, 11},
+      {23, 29, 163, 188, 14},
+      {216, 250, 195, 97, 14},
+      {115, 220, 91, 142, 8}
+    },
+    { {147, 175, 244, 140, 6},
+      {41, 187, 88, 115, 14},
+      {99, 18, 255, 92, 9},
+      {124, 225, 173, 217, 4}
+    },
+    { {42, 176, 175, 52, 11},
+      {95, 209, 183, 1, 4},
+      {210, 207, 80, 213, 4},
+      {40, 14, 216, 191, 10}
+    },
+    { {240, 11, 250, 99, 1},
+      {36, 202, 46, 158, 13},
+      {140, 101, 253, 0, 15},
+      {183, 151, 69, 50, 4}
+    },
+    { {76, 166, 198, 133, 5},
+      {175, 193, 88, 164, 2},
+      {170, 22, 54, 83, 2},
+      {66, 81, 168, 63, 5}
+    },
+    { {186, 20, 227, 14, 1},
+      {126, 232, 32, 35, 5},
+      {135, 12, 114, 133, 13},
+      {172, 64, 65, 119, 14}
+    },
+    { {33, 208, 242, 145, 8},
+      {96, 196, 177, 84, 6},
+      {24, 148, 240, 184, 4},
+      {98, 168, 210, 48, 6}
+    },
+    { {195, 163, 48, 100, 2},
+      {9, 18, 26, 219, 4},
+      {66, 96, 204, 92, 3},
+      {45, 181, 132, 137, 0}
+    },
+    { {55, 157, 233, 153, 7},
+      {244, 186, 244, 101, 14},
+      {233, 153, 123, 158, 12},
+      {122, 98, 245, 210, 15}
+    },
+    { {34, 132, 160, 94, 1},
+      {12, 160, 176, 41, 5},
+      {135, 160, 82, 20, 4},
+      {169, 64, 208, 83, 0}
+    },
+    { {111, 213, 214, 14, 1},
+      {238, 231, 48, 241, 1},
+      {135, 6, 186, 191, 6},
+      {136, 240, 206, 119, 7}
+    },
+    { {203, 84, 111, 171, 13},
+      {118, 101, 71, 231, 7},
+      {189, 95, 98, 173, 3},
+      {238, 126, 42, 102, 14}
+    },
+    { {156, 42, 145, 229, 8},
+      {155, 136, 11, 30, 10},
+      {26, 120, 149, 67, 9},
+      {87, 141, 1, 29, 9}
+    },
+    { {61, 210, 148, 126, 15},
+      {206, 189, 251, 88, 1},
+      {247, 226, 148, 187, 12},
+      {129, 173, 251, 215, 3}
+    },
+    { {100, 83, 228, 51, 13},
+      {228, 135, 235, 132, 5},
+      {188, 194, 124, 162, 6},
+      {162, 29, 126, 18, 7}
+    },
+    { {43, 198, 86, 24, 12},
+      {34, 101, 249, 113, 0},
+      {49, 134, 166, 61, 4},
+      {8, 233, 250, 100, 4}
+    },
+    { {37, 39, 183, 207, 14},
+      {153, 243, 105, 124, 7},
+      {127, 62, 222, 74, 4},
+      {227, 233, 108, 249, 9}
+    },
+    { {22, 36, 199, 38, 13},
+      {189, 201, 67, 33, 1},
+      {182, 78, 50, 70, 8},
+      {136, 76, 41, 59, 13}
+    },
+    { {202, 176, 164, 248, 14},
+      {67, 177, 211, 139, 6},
+      {113, 242, 80, 213, 3},
+      {109, 28, 184, 220, 2}
+    },
+    { {193, 236, 138, 99, 14},
+      {1, 212, 87, 238, 9},
+      {124, 101, 19, 120, 3},
+      {151, 126, 162, 184, 0}
+    },
+    { {82, 142, 30, 232, 13},
+      {4, 105, 95, 185, 10},
+      {177, 119, 135, 20, 10},
+      {89, 223, 169, 98, 0}
+    },
+    { {254, 163, 79, 210, 9},
+      {183, 75, 189, 139, 3},
+      {148, 191, 44, 87, 15},
+      {205, 27, 221, 46, 13}
+    },
+    { {92, 145, 249, 82, 6},
+      {242, 154, 212, 152, 5},
+      {100, 169, 248, 147, 10},
+      {161, 146, 181, 148, 15}
+    },
+    { {42, 103, 218, 12, 8},
+      {43, 230, 45, 49, 0},
+      {19, 5, 190, 101, 4},
+      {8, 203, 70, 125, 4}
+    },
+    { {111, 147, 7, 201, 2},
+      {210, 115, 56, 205, 2},
+      {73, 62, 12, 159, 6},
+      {75, 49, 204, 228, 11}
+    },
+    { {27, 127, 101, 218, 0},
+      {115, 47, 136, 105, 15},
+      {5, 186, 111, 237, 8},
+      {249, 97, 31, 76, 14}
+    },
+    { {96, 94, 48, 82, 3},
+      {68, 20, 168, 184, 13},
+      {196, 160, 199, 160, 6},
+      {177, 209, 82, 130, 2}
+    },
+    { {187, 3, 116, 51, 0},
+      {34, 11, 170, 87, 5},
+      {12, 194, 236, 13, 13},
+      {174, 165, 93, 4, 4}
+    },
+    { {245, 150, 230, 89, 11},
+      {228, 249, 185, 238, 4},
+      {217, 166, 118, 154, 15},
+      {39, 121, 217, 242, 7}
+    },
+    { {146, 81, 227, 36, 14},
+      {120, 222, 67, 3, 4},
+      {114, 76, 120, 164, 9},
+      {44, 12, 39, 177, 14}
+    },
+    { {37, 129, 147, 161, 3},
+      {148, 210, 50, 84, 2},
+      {200, 92, 152, 26, 4},
+      {66, 164, 196, 178, 9}
+    },
+    { {179, 35, 202, 164, 8},
+      {41, 202, 47, 67, 2},
+      {18, 85, 60, 76, 13},
+      {76, 47, 69, 57, 4}
+    },
+    { {141, 73, 29, 60, 1},
+      {158, 39, 134, 82, 8},
+      {131, 203, 137, 43, 1},
+      {20, 166, 30, 71, 9}
+    },
+    { {227, 51, 36, 195, 13},
+      {69, 3, 105, 207, 7},
+      {188, 50, 76, 204, 7},
+      {239, 57, 108, 10, 2}
+    },
+    { {184, 54, 252, 47, 7},
+      {111, 185, 110, 54, 5},
+      {239, 67, 246, 193, 13},
+      {166, 199, 105, 223, 6}
+    },
+    { {237, 209, 46, 107, 4},
+      {194, 103, 118, 206, 5},
+      {45, 103, 72, 187, 7},
+      {167, 54, 238, 100, 3}
+    },
+    { {235, 71, 59, 247, 10},
+      {26, 86, 175, 255, 7},
+      {94, 253, 206, 45, 7},
+      {239, 255, 86, 165, 8}
+    },
+    { {20, 242, 111, 82, 9},
+      {245, 77, 157, 8, 5},
+      {148, 175, 100, 242, 8},
+      {161, 11, 155, 42, 15}
+    },
+    { {205, 127, 26, 185, 15},
+      {199, 118, 207, 246, 10},
+      {249, 213, 143, 235, 3},
+      {86, 255, 54, 238, 3}
+    },
+    { {198, 53, 226, 175, 3},
+      {237, 242, 2, 167, 7},
+      {207, 84, 122, 198, 3},
+      {238, 84, 4, 251, 7}
+    },
+    { {215, 249, 12, 215, 3},
+      {205, 31, 148, 207, 11},
+      {206, 179, 9, 254, 11},
+      {223, 50, 159, 139, 3}
+    },
+    { {83, 21, 215, 208, 12},
+      {112, 203, 193, 249, 2},
+      {48, 190, 186, 140, 10},
+      {73, 248, 61, 48, 14}
+    },
+    { {86, 18, 116, 213, 1},
+      {236, 9, 136, 157, 6},
+      {138, 178, 228, 134, 10},
+      {107, 145, 25, 3, 7}
+    },
+    { {181, 26, 186, 149, 2},
+      {200, 216, 172, 86, 14},
+      {74, 149, 213, 138, 13},
+      {118, 163, 81, 177, 3}
+    },
+    { {98, 62, 7, 58, 4},
+      {81, 97, 234, 161, 9},
+      {37, 206, 7, 196, 6},
+      {152, 85, 120, 104, 10}
+    },
+    { {235, 252, 157, 72, 14},
+      {83, 181, 117, 251, 8},
+      {113, 43, 147, 253, 7},
+      {29, 250, 234, 220, 10}
+    },
+    { {129, 51, 86, 47, 14},
+      {105, 115, 75, 86, 1},
+      {127, 70, 172, 200, 1},
+      {134, 173, 44, 233, 6}
+    },
+    { {125, 43, 146, 2, 6},
+      {131, 218, 104, 208, 9},
+      {100, 4, 157, 75, 14},
+      {144, 177, 101, 188, 1}
+    },
+    { {144, 85, 192, 202, 6},
+      {96, 190, 64, 42, 3},
+      {101, 48, 58, 160, 9},
+      {197, 64, 39, 208, 6}
+    },
+    { {205, 132, 181, 92, 15},
+      {158, 177, 209, 250, 4},
+      {243, 170, 210, 27, 3},
+      {37, 248, 184, 215, 9}
+    },
+    { {11, 54, 92, 9, 4},
+      {99, 33, 76, 117, 0},
+      {41, 3, 166, 205, 0},
+      {10, 227, 40, 76, 6}
+    },
+    { {190, 98, 7, 5, 10},
+      {155, 93, 41, 7, 0},
+      {90, 14, 4, 103, 13},
+      {14, 9, 75, 173, 9}
+    },
+    { {39, 38, 95, 35, 12},
+      {177, 65, 111, 117, 1},
+      {60, 79, 166, 78, 4},
+      {138, 239, 104, 40, 13}
+    },
+    { {100, 138, 166, 99, 10},
+      {128, 209, 59, 140, 13},
+      {92, 102, 85, 18, 6},
+      {179, 29, 200, 176, 1}
+    },
+    { {254, 101, 69, 2, 13},
+      {183, 15, 97, 163, 1},
+      {180, 10, 42, 103, 15},
+      {140, 88, 111, 14, 13}
+    },
+    { {167, 99, 68, 48, 13},
+      {165, 7, 235, 67, 0},
+      {176, 194, 44, 110, 5},
+      {12, 45, 126, 10, 5}
+    },
+    { {217, 192, 126, 10, 8},
+      {34, 109, 21, 210, 5},
+      {21, 7, 224, 57, 11},
+      {164, 186, 139, 100, 4}
+    },
+    { {29, 104, 212, 20, 13},
+      {175, 141, 193, 80, 8},
+      {178, 130, 177, 107, 8},
+      {16, 168, 59, 31, 5}
+    },
+    { {203, 197, 40, 112, 3},
+      {6, 22, 150, 235, 4},
+      {192, 225, 74, 61, 3},
+      {45, 118, 150, 134, 0}
+    },
+    { {228, 40, 28, 188, 9},
+      {141, 33, 167, 146, 10},
+      {147, 211, 129, 66, 7},
+      {84, 158, 88, 75, 1}
+    },
+    { {225, 221, 170, 221, 6},
+      {72, 246, 244, 238, 14},
+      {107, 181, 91, 184, 7},
+      {119, 114, 246, 241, 2}
+    },
+    { {244, 239, 90, 230, 13},
+      {173, 78, 127, 186, 11},
+      {182, 117, 175, 114, 15},
+      {213, 223, 231, 43, 5}
+    },
+    { {122, 159, 45, 115, 15},
+      {86, 27, 255, 173, 13},
+      {252, 235, 79, 149, 14},
+      {187, 95, 253, 134, 10}
+    },
+    { {189, 215, 111, 86, 6},
+      {250, 95, 252, 106, 5},
+      {102, 175, 110, 187, 13},
+      {165, 99, 255, 165, 15}
+    },
+    { {79, 139, 34, 80, 4},
+      {130, 66, 216, 201, 12},
+      {32, 164, 77, 31, 2},
+      {57, 49, 180, 36, 1}
+    },
+    { {104, 156, 225, 61, 6},
+      {122, 176, 242, 164, 12},
+      {107, 200, 115, 145, 6},
+      {50, 84, 240, 213, 14}
+    },
+    { {23, 125, 226, 145, 13},
+      {229, 206, 193, 101, 14},
+      {184, 148, 123, 238, 8},
+      {122, 104, 55, 58, 7}
+    },
+    { {101, 27, 125, 109, 2},
+      {248, 51, 46, 220, 12},
+      {75, 107, 237, 138, 6},
+      {51, 183, 76, 193, 15}
+    },
+    { {230, 30, 244, 128, 14},
+      {224, 145, 105, 179, 14},
+      {112, 18, 247, 134, 7},
+      {124, 217, 104, 144, 7}
+    },
+    { {10, 131, 197, 183, 14},
+      {58, 147, 219, 5, 3},
+      {126, 218, 60, 21, 0},
+      {202, 13, 188, 149, 12}
+    },
+    { {113, 216, 247, 205, 5},
+      {124, 237, 112, 220, 14},
+      {171, 62, 241, 184, 14},
+      {115, 176, 235, 115, 14}
+    },
+    { {119, 102, 40, 235, 6},
+      {129, 60, 110, 237, 7},
+      {109, 113, 70, 110, 14},
+      {235, 119, 99, 200, 1}
+    },
+    { {164, 71, 35, 16, 2},
+      {144, 86, 168, 34, 4},
+      {64, 140, 78, 34, 5},
+      {36, 65, 86, 160, 9}
+    },
+    { {141, 28, 30, 136, 7},
+      {198, 113, 68, 114, 10},
+      {225, 23, 131, 139, 1},
+      {84, 226, 40, 230, 3}
+    },
+    { {174, 5, 207, 117, 0},
+      {186, 195, 166, 47, 0},
+      {10, 239, 58, 7, 5},
+      {15, 70, 92, 53, 13}
+    },
+    { {242, 185, 238, 5, 10},
+      {105, 219, 53, 135, 12},
+      {90, 7, 121, 212, 15},
+      {62, 26, 205, 185, 6}
+    },
+    { {150, 184, 220, 80, 14},
+      {225, 153, 213, 27, 8},
+      {112, 163, 177, 214, 9},
+      {29, 138, 185, 152, 7}
+    },
+    { {191, 140, 179, 54, 4},
+      {154, 200, 242, 115, 13},
+      {38, 204, 211, 31, 13},
+      {188, 228, 241, 53, 9}
+    },
+    { {77, 139, 178, 107, 7},
+      {134, 242, 90, 220, 13},
+      {237, 100, 221, 27, 2},
+      {179, 181, 164, 246, 1}
+    },
+    { {48, 111, 43, 129, 9},
+      {21, 78, 45, 36, 14},
+      {152, 29, 79, 96, 12},
+      {114, 75, 71, 42, 8}
+    },
+    { {134, 223, 39, 101, 6},
+      {216, 87, 90, 47, 12},
+      {106, 110, 79, 182, 1},
+      {63, 69, 174, 161, 11}
+    },
+    { {201, 63, 168, 244, 10},
+      {75, 146, 143, 234, 14},
+      {82, 241, 95, 201, 3},
+      {117, 127, 20, 157, 2}
+    },
+    { {178, 101, 205, 76, 0},
+      {57, 175, 36, 43, 0},
+      {3, 43, 58, 100, 13},
+      {13, 66, 79, 89, 12}
+    },
+    { {230, 107, 232, 211, 7},
+      {165, 150, 236, 143, 15},
+      {236, 177, 125, 102, 7},
+      {255, 19, 118, 154, 5}
+    },
+    { {172, 157, 252, 25, 5},
+      {230, 163, 244, 54, 12},
+      {169, 131, 251, 147, 5},
+      {54, 194, 252, 86, 7}
+    },
+    { {177, 19, 196, 190, 12},
+      {104, 171, 235, 66, 3},
+      {55, 210, 60, 136, 13},
+      {196, 45, 125, 81, 6}
+    },
+    { {211, 223, 9, 161, 13},
+      {84, 14, 95, 231, 10},
+      {184, 89, 15, 188, 11},
+      {94, 127, 167, 2, 10}
+    },
+    { {238, 69, 143, 67, 7},
+      {150, 215, 100, 175, 1},
+      {236, 47, 26, 39, 7},
+      {143, 82, 110, 182, 9}
+    },
+    { {103, 202, 12, 176, 9},
+      {132, 5, 191, 193, 10},
+      {144, 211, 5, 62, 6},
+      {88, 63, 218, 2, 1}
+    },
+    { {179, 49, 95, 108, 5},
+      {125, 107, 102, 91, 0},
+      {163, 111, 168, 204, 13},
+      {13, 166, 109, 107, 14}
+    },
+    { {51, 113, 11, 210, 2},
+      {81, 94, 164, 73, 3},
+      {68, 189, 8, 236, 12},
+      {201, 34, 87, 168, 10}
+    },
+    { {155, 233, 139, 184, 6},
+      {19, 254, 214, 67, 10},
+      {97, 221, 25, 125, 9},
+      {92, 38, 183, 252, 8}
+    },
+    { {65, 191, 62, 12, 5},
+      {77, 99, 92, 240, 12},
+      {163, 7, 207, 216, 2},
+      {48, 243, 172, 107, 2}
+    },
+    { {39, 180, 57, 11, 8},
+      {209, 32, 53, 117, 5},
+      {29, 9, 194, 222, 4},
+      {170, 234, 192, 72, 11}
+    },
+    { {22, 194, 235, 111, 10},
+      {184, 252, 31, 13, 5},
+      {95, 109, 116, 54, 8},
+      {171, 15, 131, 241, 13}
+    },
+    { {180, 216, 190, 76, 8},
+      {200, 237, 53, 26, 12},
+      {19, 39, 209, 178, 13},
+      {53, 138, 203, 113, 3}
+    },
+    { {157, 108, 51, 41, 10},
+      {147, 124, 3, 118, 12},
+      {89, 76, 195, 107, 9},
+      {54, 236, 3, 236, 9}
+    },
+    { {62, 93, 56, 87, 15},
+      {206, 30, 229, 61, 13},
+      {254, 161, 203, 167, 12},
+      {187, 202, 119, 135, 3}
+    },
+    { {180, 100, 140, 48, 10},
+      {129, 157, 167, 34, 0},
+      {80, 195, 18, 98, 13},
+      {4, 78, 91, 152, 1}
+    },
+    { {93, 101, 141, 153, 11},
+      {151, 191, 133, 228, 2},
+      {217, 155, 26, 107, 10},
+      {66, 122, 31, 222, 9}
+    },
+    { {75, 57, 30, 253, 8},
+      {75, 99, 135, 221, 10},
+      {27, 247, 137, 205, 2},
+      {91, 190, 28, 109, 2}
+    },
+    { {159, 102, 246, 244, 7},
+      {175, 221, 202, 123, 6},
+      {226, 246, 246, 111, 9},
+      {109, 229, 59, 191, 5}
+    },
+    { {99, 251, 122, 188, 8},
+      {105, 102, 191, 209, 14},
+      {19, 213, 237, 252, 6},
+      {120, 191, 214, 105, 6}
+    },
+    { {48, 213, 149, 195, 13},
+      {84, 143, 113, 60, 3},
+      {188, 58, 154, 176, 12},
+      {195, 200, 239, 18, 10}
+    },
+    { {44, 228, 218, 91, 8},
+      {163, 228, 181, 60, 1},
+      {29, 165, 178, 115, 4},
+      {131, 202, 210, 124, 5}
+    },
+    { {123, 79, 47, 122, 4},
+      {18, 111, 238, 233, 13},
+      {37, 239, 79, 45, 14},
+      {185, 119, 127, 100, 8}
+    },
+    { {80, 165, 170, 211, 11},
+      {5, 218, 149, 172, 7},
+      {220, 181, 90, 80, 10},
+      {227, 90, 149, 186, 0}
+    },
+    { {53, 99, 219, 99, 9},
+      {181, 206, 47, 92, 1},
+      {156, 109, 188, 106, 12},
+      {131, 175, 71, 58, 13}
+    },
+    { {202, 17, 193, 89, 1},
+      {118, 162, 128, 143, 0},
+      {137, 168, 56, 133, 3},
+      {15, 16, 20, 86, 14}
+    },
+    { {119, 153, 15, 22, 8},
+      {216, 75, 181, 193, 9},
+      {22, 143, 9, 158, 14},
+      {152, 58, 221, 33, 11}
+    },
+    { {6, 232, 6, 138, 11},
+      {133, 117, 17, 1, 11},
+      {213, 22, 1, 118, 0},
+      {216, 8, 138, 234, 1}
+    },
+    { {88, 242, 76, 249, 1},
+      {103, 45, 158, 140, 2},
+      {137, 243, 36, 241, 10},
+      {67, 23, 155, 78, 6}
+    },
+    { {87, 131, 120, 211, 4},
+      {160, 10, 220, 221, 7},
+      {44, 177, 236, 30, 10},
+      {235, 179, 181, 0, 5}
+    },
+    { {102, 199, 182, 12, 6},
+      {136, 247, 120, 177, 4},
+      {99, 6, 222, 54, 6},
+      {40, 209, 238, 241, 1}
+    },
+    { {120, 143, 69, 72, 0},
+      {50, 43, 56, 168, 8},
+      {1, 42, 47, 17, 14},
+      {17, 81, 205, 68, 12}
+    },
+    { {233, 239, 208, 58, 13},
+      {39, 166, 251, 242, 9},
+      {181, 192, 191, 121, 7},
+      {148, 253, 246, 94, 4}
+    },
+    { {39, 212, 15, 163, 10},
+      {208, 85, 55, 101, 3},
+      {92, 95, 2, 190, 4},
+      {202, 110, 202, 160, 11}
+    },
+    { {125, 42, 249, 128, 10},
+      {179, 152, 45, 208, 14},
+      {80, 25, 245, 75, 14},
+      {112, 187, 65, 156, 13}
+    },
+    { {86, 144, 82, 117, 6},
+      {232, 88, 210, 157, 0},
+      {106, 228, 160, 150, 10},
+      {11, 148, 177, 161, 7}
+    },
+    { {30, 225, 231, 61, 2},
+      {187, 255, 146, 5, 4},
+      {75, 206, 120, 119, 8},
+      {42, 4, 159, 253, 13}
+    },
+    { {254, 157, 166, 210, 9},
+      {198, 203, 177, 171, 15},
+      {148, 182, 91, 151, 15},
+      {253, 88, 221, 54, 3}
+    },
+    { {75, 222, 118, 252, 11},
+      {110, 117, 155, 249, 14},
+      {211, 246, 231, 189, 2},
+      {121, 253, 154, 231, 6}
+    },
+    { {50, 21, 75, 223, 8},
+      {120, 106, 165, 45, 3},
+      {31, 189, 42, 132, 12},
+      {203, 74, 85, 97, 14}
+    },
+    { {141, 94, 72, 11, 6},
+      {226, 52, 76, 102, 9},
+      {109, 1, 39, 171, 1},
+      {150, 99, 34, 196, 7}
+    },
+    { {85, 153, 228, 23, 12},
+      {232, 139, 209, 196, 13},
+      {62, 130, 121, 154, 10},
+      {178, 56, 189, 17, 7}
+    },
+    { {127, 178, 100, 131, 2},
+      {227, 25, 56, 197, 7},
+      {76, 18, 100, 223, 14},
+      {234, 49, 201, 140, 7}
+    },
+    { {6, 201, 57, 111, 3},
+      {156, 54, 22, 29, 13},
+      {207, 105, 201, 54, 0},
+      {187, 134, 134, 195, 9}
+    },
+    { {66, 202, 124, 45, 2},
+      {40, 53, 30, 149, 12},
+      {75, 67, 229, 52, 2},
+      {58, 151, 138, 193, 4}
+    },
+    { {78, 192, 248, 186, 12},
+      {162, 164, 215, 145, 7},
+      {53, 209, 240, 55, 2},
+      {232, 158, 178, 84, 5}
+    },
+    { {45, 113, 131, 30, 11},
+      {223, 246, 161, 64, 1},
+      {215, 140, 24, 235, 4},
+      {128, 40, 86, 255, 11}
+    },
+    { {128, 130, 234, 70, 4},
+      {40, 192, 92, 10, 5},
+      {38, 37, 116, 16, 1},
+      {165, 3, 160, 49, 4}
+    },
+    { {172, 206, 58, 52, 3},
+      {142, 84, 190, 50, 12},
+      {194, 197, 199, 51, 5},
+      {52, 199, 210, 167, 1}
+    },
+    { {88, 160, 32, 181, 13},
+      {15, 8, 211, 132, 6},
+      {186, 208, 64, 81, 10},
+      {98, 28, 177, 15, 0}
+    },
+    { {114, 159, 129, 35, 8},
+      {80, 138, 59, 165, 9},
+      {28, 72, 31, 148, 14},
+      {154, 93, 197, 16, 10}
+    },
+    { {123, 5, 90, 20, 12},
+      {42, 74, 229, 241, 0},
+      {50, 133, 170, 13, 14},
+      {8, 250, 117, 37, 4}
+    },
+    { {150, 248, 124, 233, 1},
+      {229, 45, 22, 31, 14},
+      {137, 115, 225, 246, 9},
+      {127, 134, 139, 74, 7}
+    },
+    { {41, 99, 28, 75, 10},
+      {3, 55, 45, 92, 1},
+      {93, 35, 140, 105, 4},
+      {131, 171, 78, 204, 0}
+    },
+    { {157, 226, 24, 237, 14},
+      {139, 60, 95, 94, 2},
+      {123, 113, 132, 123, 9},
+      {71, 175, 163, 205, 1}
+    },
+    { {58, 230, 175, 66, 4},
+      {19, 205, 124, 41, 5},
+      {36, 47, 86, 117, 12},
+      {169, 67, 235, 60, 8}
+    },
+    { {180, 56, 174, 163, 3},
+      {197, 217, 38, 6, 15},
+      {204, 87, 81, 194, 13},
+      {246, 6, 73, 186, 3}
+    },
+    { {208, 70, 61, 144, 7},
+      {20, 29, 204, 178, 6},
+      {224, 155, 198, 32, 11},
+      {100, 211, 59, 130, 8}
+    },
+    { {187, 32, 151, 39, 0},
+      {27, 201, 34, 87, 1},
+      {14, 78, 144, 77, 13},
+      {142, 164, 73, 61, 8}
+    },
+    { {229, 143, 37, 62, 0},
+      {152, 35, 186, 226, 13},
+      {7, 202, 79, 26, 7},
+      {180, 117, 220, 65, 9}
+    },
+    { {194, 117, 158, 53, 4},
+      {73, 199, 198, 183, 0},
+      {42, 199, 154, 228, 3},
+      {14, 214, 62, 57, 2}
+    },
+    { {10, 66, 188, 132, 7},
+      {14, 149, 76, 17, 6},
+      {226, 19, 212, 37, 0},
+      {104, 131, 42, 151, 0}
+    },
+    { {173, 67, 236, 130, 11},
+      {166, 151, 45, 66, 7},
+      {212, 19, 124, 43, 5},
+      {228, 43, 78, 150, 5}
+    },
+    { {61, 136, 115, 251, 11},
+      {182, 120, 179, 92, 15},
+      {221, 252, 225, 27, 12},
+      {243, 172, 209, 230, 13}
+    },
+    { {102, 161, 166, 184, 11},
+      {133, 243, 179, 129, 6},
+      {209, 214, 88, 86, 6},
+      {104, 28, 220, 250, 1}
+    },
+    { {221, 141, 175, 200, 4},
+      {146, 235, 84, 234, 14},
+      {33, 63, 91, 27, 11},
+      {117, 114, 173, 116, 9}
+    },
+    { {21, 7, 218, 203, 3},
+      {164, 250, 12, 124, 3},
+      {205, 53, 190, 10, 8},
+      {195, 227, 5, 242, 5}
+    },
+    { {137, 254, 190, 99, 3},
+      {71, 213, 30, 126, 13},
+      {204, 103, 215, 249, 1},
+      {183, 231, 138, 190, 2}
+    },
+    { {25, 7, 189, 144, 10},
+      {18, 155, 141, 112, 6},
+      {80, 155, 222, 9, 8},
+      {96, 235, 29, 148, 8}
+    },
+    { {98, 241, 188, 178, 14},
+      {65, 151, 247, 145, 7},
+      {116, 211, 216, 244, 6},
+      {232, 158, 254, 152, 2}
+    },
+    { {14, 147, 144, 200, 10},
+      {194, 178, 25, 25, 2},
+      {81, 48, 156, 151, 0},
+      {73, 137, 132, 212, 3}
+    },
+    { {102, 251, 212, 124, 10},
+      {233, 183, 187, 153, 8},
+      {83, 226, 189, 246, 6},
+      {25, 157, 222, 217, 7}
+    },
+    { {203, 127, 203, 186, 5},
+      {119, 230, 206, 227, 11},
+      {165, 221, 63, 237, 3},
+      {220, 119, 54, 126, 14}
+    },
+    { {72, 77, 150, 114, 5},
+      {6, 199, 194, 184, 9},
+      {164, 230, 155, 33, 2},
+      {145, 212, 62, 54, 0}
+    },
+    { {182, 201, 156, 184, 13},
+      {132, 175, 247, 19, 10},
+      {177, 211, 153, 54, 13},
+      {92, 142, 255, 82, 1}
+    },
+    { {214, 73, 19, 109, 6},
+      {152, 126, 66, 159, 8},
+      {107, 108, 137, 38, 11},
+      {31, 148, 39, 225, 9}
+    },
+    { {13, 229, 2, 166, 2},
+      {139, 86, 18, 96, 3},
+      {70, 84, 10, 123, 0},
+      {192, 100, 134, 173, 1}
+    },
+    { {249, 154, 61, 119, 4},
+      {90, 9, 254, 222, 13},
+      {46, 235, 197, 153, 15},
+      {183, 183, 249, 5, 10}
+    },
+    { {124, 20, 82, 167, 4},
+      {234, 72, 98, 180, 3},
+      {46, 84, 162, 131, 14},
+      {194, 212, 97, 37, 7}
+    },
+    { {57, 81, 76, 89, 15},
+      {102, 63, 229, 76, 0},
+      {249, 163, 40, 169, 12},
+      {3, 42, 127, 198, 6}
+    },
+    { {202, 63, 57, 87, 14},
+      {91, 18, 205, 191, 13},
+      {126, 169, 207, 197, 3},
+      {191, 219, 52, 141, 10}
+    },
+    { {219, 212, 95, 243, 10},
+      {114, 93, 151, 255, 3},
+      {92, 255, 162, 189, 11},
+      {207, 254, 155, 164, 14}
+    },
+    { {113, 246, 139, 38, 2},
+      {89, 220, 62, 224, 1},
+      {70, 77, 22, 248, 14},
+      {128, 119, 195, 185, 10}
+    },
+    { {61, 34, 41, 13, 7},
+      {159, 56, 108, 68, 4},
+      {235, 9, 68, 75, 12},
+      {34, 35, 97, 207, 9}
+    },
+    { {154, 77, 130, 207, 12},
+      {10, 238, 65, 47, 11},
+      {63, 52, 27, 37, 9},
+      {223, 72, 39, 117, 0}
+    },
+    { {16, 141, 72, 139, 2},
+      {32, 58, 20, 36, 11},
+      {77, 17, 43, 16, 8},
+      {210, 66, 133, 192, 4}
+    },
+    { {66, 66, 157, 48, 14},
+      {16, 149, 207, 145, 0},
+      {112, 203, 148, 36, 2},
+      {8, 159, 58, 144, 8}
+    },
+    { {191, 242, 183, 46, 9},
+      {223, 237, 59, 83, 5},
+      {151, 78, 212, 255, 13},
+      {172, 173, 203, 127, 11}
+    },
+    { {137, 69, 178, 16, 8},
+      {2, 198, 129, 114, 4},
+      {16, 132, 218, 41, 1},
+      {36, 232, 22, 52, 0}
+    },
+    { {156, 83, 206, 106, 1},
+      {230, 239, 14, 10, 1},
+      {133, 103, 60, 163, 9},
+      {133, 7, 15, 118, 7}
+    },
+    { {246, 110, 46, 178, 11},
+      {133, 93, 175, 163, 15},
+      {212, 215, 71, 102, 15},
+      {252, 95, 91, 170, 1}
+    },
+    { {123, 135, 22, 82, 6},
+      {2, 91, 248, 249, 1},
+      {100, 166, 142, 29, 14},
+      {137, 241, 253, 164, 0}
+    },
+    { {117, 48, 198, 172, 7},
+      {237, 249, 98, 192, 2},
+      {227, 86, 48, 202, 14},
+      {64, 52, 105, 251, 7}
+    },
+    { {219, 148, 76, 224, 4},
+      {98, 9, 86, 235, 2},
+      {32, 115, 34, 157, 11},
+      {77, 118, 169, 4, 6}
+    },
+    { {64, 156, 92, 188, 6},
+      {104, 49, 214, 176, 10},
+      {99, 211, 163, 144, 2},
+      {80, 214, 184, 193, 6}
+    },
+    { {96, 119, 25, 168, 12},
+      {81, 38, 111, 176, 2},
+      {49, 89, 142, 224, 6},
+      {64, 223, 102, 72, 10}
+    },
+    { {100, 136, 107, 16, 1},
+      {180, 64, 180, 128, 12},
+      {128, 141, 97, 18, 6},
+      {48, 18, 208, 34, 13}
+    },
+    { {33, 158, 169, 148, 0},
+      {88, 128, 188, 96, 14},
+      {2, 153, 87, 152, 4},
+      {112, 99, 208, 17, 10}
+    },
+    { {146, 100, 250, 242, 11},
+      {37, 220, 135, 59, 7},
+      {212, 245, 242, 100, 9},
+      {237, 206, 19, 186, 4}
+    },
+    { {214, 14, 81, 55, 9},
+      {188, 8, 139, 183, 9},
+      {158, 200, 167, 6, 11},
+      {158, 221, 17, 3, 13}
+    },
+    { {6, 232, 25, 146, 12},
+      {145, 4, 213, 17, 11},
+      {52, 153, 129, 118, 0},
+      {216, 138, 178, 8, 9}
+    },
+    { {101, 196, 213, 201, 3},
+      {180, 181, 48, 252, 2},
+      {201, 58, 178, 58, 6},
+      {67, 240, 202, 210, 13}
+    },
+    { {91, 1, 85, 227, 4},
+      {50, 11, 66, 221, 3},
+      {44, 122, 168, 13, 10},
+      {203, 180, 45, 4, 12}
+    },
+    { {93, 64, 143, 102, 1},
+      {158, 205, 6, 200, 1},
+      {134, 111, 16, 43, 10},
+      {129, 54, 11, 55, 9}
+    },
+    { {61, 239, 243, 168, 13},
+      {183, 238, 123, 112, 14},
+      {177, 92, 255, 123, 12},
+      {112, 237, 231, 126, 13}
+    },
+    { {83, 37, 200, 86, 6},
+      {41, 154, 196, 233, 1},
+      {102, 161, 58, 76, 10},
+      {137, 114, 53, 153, 4}
+    },
+    { {18, 10, 174, 82, 10},
+      {0, 217, 141, 9, 13},
+      {84, 167, 85, 4, 8},
+      {185, 11, 25, 176, 0}
+    },
+    { {155, 29, 191, 200, 11},
+      {86, 251, 5, 123, 14},
+      {209, 63, 219, 141, 9},
+      {125, 234, 13, 246, 10}
+    },
+    { {207, 183, 171, 86, 8},
+      {219, 194, 157, 235, 5},
+      {22, 173, 94, 223, 3},
+      {173, 123, 148, 61, 11}
+    },
+    { {42, 141, 220, 32, 7},
+      {38, 147, 118, 49, 8},
+      {224, 67, 187, 21, 4},
+      {24, 198, 236, 150, 4}
+    },
+    { {142, 106, 174, 19, 3},
+      {135, 213, 140, 7, 13},
+      {204, 135, 85, 103, 1},
+      {190, 3, 26, 190, 1}
+    },
+    { {171, 253, 77, 159, 3},
+      {127, 55, 180, 103, 11},
+      {207, 155, 43, 253, 5},
+      {222, 98, 222, 207, 14}
+    },
+    { {45, 9, 17, 6, 12},
+      {154, 2, 97, 80, 9},
+      {54, 8, 137, 11, 4},
+      {144, 168, 100, 5, 9}
+    },
+    { {168, 207, 127, 12, 12},
+      {58, 103, 125, 50, 12},
+      {51, 15, 239, 49, 5},
+      {52, 203, 238, 101, 12}
+    },
+    { {166, 83, 153, 76, 7},
+      {220, 182, 108, 27, 0},
+      {227, 41, 156, 166, 5},
+      {13, 131, 102, 211, 11}
+    },
+    { {135, 166, 224, 109, 0},
+      {169, 160, 26, 111, 4},
+      {11, 96, 118, 94, 1},
+      {47, 101, 128, 89, 5}
+    },
+    { {59, 232, 221, 151, 0},
+      {59, 141, 180, 85, 11},
+      {14, 155, 177, 125, 12},
+      {218, 162, 219, 29, 12}
+    },
+    { {209, 178, 226, 250, 9},
+      {101, 232, 155, 202, 7},
+      {149, 244, 116, 216, 11},
+      {229, 61, 145, 122, 6}
+    },
+    { {0, 188, 184, 78, 7},
+      {77, 176, 84, 56, 13},
+      {231, 33, 211, 208, 0},
+      {177, 194, 160, 219, 2}
+    },
+    { {166, 167, 158, 98, 11},
+      {133, 211, 63, 59, 1},
+      {212, 103, 158, 86, 5},
+      {141, 207, 204, 186, 1}
+    },
+    { {200, 134, 91, 1, 3},
+      {54, 80, 28, 182, 0},
+      {200, 13, 166, 17, 3},
+      {6, 211, 128, 166, 12}
+    },
+    { {12, 255, 119, 177, 9},
+      {247, 71, 155, 52, 14},
+      {152, 222, 239, 243, 0},
+      {114, 205, 158, 46, 15}
+    },
+    { {142, 29, 220, 148, 3},
+      {238, 147, 132, 51, 10},
+      {194, 147, 187, 135, 1},
+      {92, 194, 28, 151, 7}
+    },
+    { {18, 244, 200, 158, 7},
+      {109, 188, 212, 33, 3},
+      {231, 145, 50, 244, 8},
+      {200, 66, 179, 219, 6}
+    },
+    { {221, 245, 180, 168, 13},
+      {199, 175, 83, 242, 6},
+      {177, 82, 218, 251, 11},
+      {100, 252, 175, 94, 3}
+    },
+    { {97, 194, 86, 250, 10},
+      {32, 117, 187, 216, 3},
+      {85, 246, 164, 56, 6},
+      {193, 189, 218, 224, 4}
+    },
+    { {34, 2, 81, 216, 5},
+      {52, 32, 232, 25, 2},
+      {161, 184, 164, 4, 4},
+      {73, 129, 112, 66, 12}
+    },
+    { {160, 222, 24, 47, 2},
+      {72, 52, 62, 54, 9},
+      {79, 65, 135, 176, 5},
+      {150, 199, 194, 193, 2}
+    },
+    { {203, 116, 62, 141, 0},
+      {75, 101, 4, 247, 6},
+      {11, 23, 194, 237, 3},
+      {110, 242, 10, 109, 2}
+    },
+    { {32, 93, 174, 186, 9},
+      {68, 231, 167, 32, 15},
+      {149, 215, 91, 160, 4},
+      {240, 78, 94, 114, 2}
+    },
+    { {182, 151, 72, 253, 13},
+      {236, 42, 255, 47, 2},
+      {187, 241, 46, 150, 13},
+      {79, 79, 245, 67, 7}
+    },
+    { {244, 165, 139, 213, 6},
+      {153, 218, 244, 174, 2},
+      {106, 189, 26, 82, 15},
+      {71, 82, 245, 185, 9}
+    },
+    { {137, 147, 208, 12, 15},
+      {110, 178, 89, 82, 0},
+      {243, 0, 188, 153, 1},
+      {4, 169, 164, 215, 6}
+    },
+    { {43, 161, 206, 80, 15},
+      {39, 211, 245, 73, 0},
+      {240, 167, 56, 93, 4},
+      {9, 42, 252, 190, 4}
+    },
+    { {84, 31, 38, 148, 10},
+      {200, 91, 137, 160, 14},
+      {82, 150, 79, 130, 10},
+      {112, 89, 29, 161, 3}
+    },
+    { {250, 73, 70, 153, 5},
+      {38, 111, 224, 135, 10},
+      {169, 150, 41, 37, 15},
+      {94, 16, 127, 102, 4}
+    },
+    { {143, 119, 77, 200, 6},
+      {243, 55, 76, 107, 2},
+      {97, 59, 46, 239, 1},
+      {77, 99, 46, 204, 15}
+    },
+    { {21, 73, 52, 191, 10},
+      {136, 63, 131, 84, 15},
+      {95, 210, 201, 42, 8},
+      {242, 172, 31, 193, 1}
+    },
+    { {160, 179, 125, 121, 0},
+      {113, 35, 190, 30, 4},
+      {9, 235, 236, 208, 5},
+      {39, 135, 220, 72, 14}
+    },
+    { {94, 29, 64, 6, 12},
+      {234, 10, 65, 161, 9},
+      {54, 0, 43, 135, 10},
+      {152, 88, 37, 5, 7}
+    },
+    { {247, 121, 227, 64, 9},
+      {245, 206, 33, 203, 12},
+      {144, 44, 121, 238, 15},
+      {61, 56, 71, 58, 15}
+    },
+    { {126, 60, 103, 41, 12},
+      {243, 105, 99, 165, 12},
+      {57, 78, 99, 199, 14},
+      {58, 92, 105, 108, 15}
+    },
+    { {38, 10, 20, 204, 8},
+      {136, 33, 41, 25, 10},
+      {19, 50, 133, 6, 4},
+      {89, 137, 72, 65, 1}
+    },
+    { {210, 180, 127, 62, 15},
+      {125, 121, 215, 179, 5},
+      {247, 207, 226, 212, 11},
+      {172, 222, 185, 235, 14}
+    },
+    { {52, 74, 22, 15, 2},
+      {136, 125, 40, 20, 9},
+      {79, 6, 133, 34, 12},
+      {146, 129, 75, 225, 1}
+    },
+    { {240, 88, 87, 246, 9},
+      {124, 77, 163, 154, 11},
+      {150, 254, 161, 160, 15},
+      {213, 156, 91, 35, 14}
+    },
+    { {200, 222, 73, 90, 3},
+      {118, 52, 156, 170, 9},
+      {197, 169, 39, 177, 3},
+      {149, 83, 146, 198, 14}
+    },
+    { {41, 152, 52, 89, 7},
+      {70, 49, 240, 92, 12},
+      {233, 162, 193, 153, 4},
+      {51, 160, 248, 198, 2}
+    },
+    { {192, 28, 220, 163, 10},
+      {96, 145, 7, 182, 11},
+      {92, 83, 179, 128, 3},
+      {214, 222, 8, 144, 6}
+    },
+    { {17, 134, 214, 198, 15},
+      {44, 217, 89, 120, 3},
+      {246, 54, 182, 24, 8},
+      {193, 233, 169, 179, 4}
+    },
+    { {199, 106, 99, 224, 0},
+      {177, 68, 10, 203, 14},
+      {0, 124, 101, 110, 3},
+      {125, 53, 2, 40, 13}
+    },
+    { {250, 63, 143, 86, 4},
+      {91, 203, 236, 171, 9},
+      {38, 175, 31, 197, 15},
+      {157, 83, 125, 61, 10}
+    },
+    { {30, 208, 47, 67, 7},
+      {214, 93, 84, 13, 5},
+      {236, 47, 64, 183, 8},
+      {171, 2, 171, 166, 11}
+    },
+    { {167, 132, 152, 85, 15},
+      {140, 144, 245, 127, 0},
+      {250, 161, 146, 30, 5},
+      {15, 234, 240, 147, 1}
+    },
+    { {12, 209, 94, 200, 6},
+      {226, 119, 84, 24, 2},
+      {97, 55, 168, 179, 0},
+      {65, 130, 174, 228, 7}
+    },
+    { {222, 242, 230, 20, 0},
+      {235, 205, 152, 131, 4},
+      {2, 134, 116, 247, 11},
+      {44, 17, 155, 61, 7}
+    },
+    { {172, 114, 24, 123, 12},
+      {195, 36, 239, 30, 1},
+      {61, 225, 132, 227, 5},
+      {135, 143, 114, 76, 3}
+    },
+    { {103, 201, 15, 119, 7},
+      {156, 87, 246, 205, 9},
+      {238, 239, 9, 62, 6},
+      {155, 54, 254, 163, 9}
+    },
+    { {7, 91, 205, 34, 11},
+      {244, 151, 15, 65, 9},
+      {212, 75, 61, 174, 0},
+      {152, 47, 14, 146, 15}
+    },
+    { {201, 190, 213, 237, 13},
+      {127, 161, 91, 254, 10},
+      {187, 122, 183, 217, 3},
+      {87, 253, 168, 95, 14}
+    },
+    { {106, 147, 24, 117, 4},
+      {74, 2, 254, 157, 0},
+      {42, 225, 140, 149, 6},
+      {11, 151, 244, 5, 2}
+    },
+    { {107, 212, 146, 123, 3},
+      {70, 244, 178, 253, 1},
+      {205, 228, 146, 189, 6},
+      {139, 244, 210, 246, 2}
+    },
+    { {118, 132, 7, 115, 8},
+      {144, 73, 179, 173, 1},
+      {28, 238, 2, 22, 14},
+      {139, 92, 217, 32, 9}
+    },
+    { {181, 12, 26, 120, 15},
+      {132, 120, 231, 122, 8},
+      {241, 229, 131, 10, 13},
+      {21, 238, 113, 226, 1}
+    },
+    { {153, 76, 54, 246, 14},
+      {10, 93, 195, 122, 15},
+      {118, 246, 195, 41, 9},
+      {245, 236, 59, 165, 0}
+    },
+    { {33, 245, 36, 87, 11},
+      {77, 23, 177, 108, 5},
+      {222, 162, 74, 248, 4},
+      {163, 104, 222, 139, 2}
+    },
+    { {97, 170, 231, 238, 4},
+      {57, 225, 122, 200, 15},
+      {39, 126, 117, 88, 6},
+      {241, 53, 232, 121, 12}
+    },
+    { {36, 1, 140, 232, 5},
+      {132, 163, 102, 8, 2},
+      {161, 115, 24, 2, 4},
+      {65, 6, 108, 82, 1}
+    },
+    { {97, 41, 206, 35, 10},
+      {33, 211, 39, 196, 9},
+      {92, 71, 57, 72, 6},
+      {146, 62, 76, 184, 4}
+    },
+    { {164, 226, 123, 199, 10},
+      {185, 84, 61, 30, 7},
+      {94, 61, 228, 114, 5},
+      {231, 139, 194, 169, 13}
+    },
+    { {182, 249, 62, 111, 6},
+      {201, 127, 118, 31, 13},
+      {111, 103, 201, 246, 13},
+      {191, 134, 239, 233, 3}
+    },
+    { {184, 158, 66, 250, 4},
+      {98, 104, 250, 42, 11},
+      {37, 244, 39, 145, 13},
+      {213, 69, 241, 100, 6}
+    },
+    { {205, 168, 178, 163, 12},
+      {131, 192, 83, 214, 15},
+      {60, 84, 209, 91, 3},
+      {246, 188, 160, 60, 1}
+    },
+    { {76, 57, 177, 159, 7},
+      {223, 178, 192, 148, 15},
+      {239, 152, 217, 195, 2},
+      {242, 144, 52, 223, 11}
+    },
+    { {185, 129, 38, 244, 2},
+      {10, 91, 178, 74, 6},
+      {66, 246, 72, 25, 13},
+      {101, 36, 221, 165, 0}
+    },
+    { {14, 11, 250, 182, 8},
+      {170, 194, 143, 17, 15},
+      {22, 213, 253, 7, 0},
+      {248, 143, 20, 53, 5}
+    },
+    { {242, 177, 157, 60, 6},
+      {89, 187, 246, 147, 0},
+      {99, 203, 152, 212, 15},
+      {12, 150, 253, 217, 10}
+    },
+    { {62, 75, 92, 90, 2},
+      {162, 63, 172, 25, 9},
+      {69, 163, 173, 39, 12},
+      {153, 131, 95, 196, 5}
+    },
+    { {53, 13, 105, 45, 8},
+      {184, 42, 39, 100, 12},
+      {27, 73, 107, 10, 12},
+      {50, 110, 69, 65, 13}
+    },
+    { {180, 35, 142, 37, 5},
+      {141, 203, 110, 6, 0},
+      {170, 71, 28, 66, 13},
+      {6, 7, 109, 59, 1}
+    },
+    { {69, 98, 201, 154, 0},
+      {177, 164, 140, 192, 3},
+      {5, 153, 52, 106, 2},
+      {192, 51, 18, 88, 13}
+    },
+    { {180, 56, 177, 59, 0},
+      {209, 168, 162, 22, 13},
+      {13, 200, 209, 194, 13},
+      {182, 132, 81, 88, 11}
+    },
+    { {131, 20, 145, 146, 14},
+      {80, 144, 193, 115, 3},
+      {116, 152, 146, 140, 1},
+      {204, 232, 48, 144, 10}
+    },
+    { {255, 9, 118, 5, 7},
+      {174, 91, 96, 215, 12},
+      {234, 6, 233, 15, 15},
+      {62, 176, 109, 167, 5}
+    },
+    { {76, 85, 220, 22, 13},
+      {238, 135, 197, 176, 1},
+      {182, 131, 186, 163, 2},
+      {128, 218, 62, 23, 7}
+    },
+    { {104, 114, 128, 201, 15},
+      {71, 180, 105, 140, 2},
+      {249, 48, 20, 225, 6},
+      {67, 25, 98, 222, 2}
+    },
+    { {118, 171, 174, 160, 4},
+      {129, 203, 126, 129, 14},
+      {32, 87, 93, 86, 14},
+      {120, 23, 237, 56, 1}
+    },
+    { {145, 170, 76, 41, 14},
+      {33, 57, 95, 70, 8},
+      {121, 67, 37, 88, 9},
+      {22, 47, 169, 200, 4}
+    },
+    { {172, 153, 124, 202, 8},
+      {226, 35, 53, 26, 15},
+      {21, 51, 233, 147, 5},
+      {245, 138, 204, 68, 7}
+    },
+    { {14, 211, 209, 214, 1},
+      {254, 134, 152, 25, 3},
+      {134, 184, 188, 183, 0},
+      {201, 129, 150, 23, 15}
+    },
+    { {186, 245, 248, 135, 3},
+      {111, 158, 52, 55, 7},
+      {206, 17, 250, 245, 13},
+      {238, 194, 199, 159, 6}
+    },
+    { {24, 203, 208, 54, 12},
+      {42, 142, 219, 16, 9},
+      {54, 192, 189, 49, 8},
+      {144, 141, 183, 21, 4}
+    },
+    { {230, 136, 49, 122, 7},
+      {148, 48, 242, 155, 13},
+      {229, 232, 193, 22, 7},
+      {189, 148, 240, 194, 9}
+    },
+    { {38, 93, 140, 24, 7},
+      {196, 183, 228, 33, 8},
+      {225, 131, 27, 166, 4},
+      {24, 66, 126, 210, 3}
+    },
+    { {37, 253, 177, 16, 7},
+      {213, 150, 240, 112, 12},
+      {224, 136, 219, 250, 4},
+      {48, 224, 246, 154, 11}
+    },
+    { {46, 105, 226, 33, 9},
+      {167, 198, 35, 5, 12},
+      {152, 68, 121, 103, 4},
+      {58, 12, 70, 62, 5}
+    },
+    { {148, 212, 15, 127, 5},
+      {220, 109, 214, 46, 1},
+      {175, 239, 2, 178, 9},
+      {135, 70, 187, 99, 11}
+    },
+    { {104, 227, 24, 161, 2},
+      {3, 22, 62, 148, 2},
+      {72, 81, 140, 113, 6},
+      {66, 151, 198, 140, 0}
+    },
+    { {115, 38, 168, 12, 2},
+      {9, 184, 44, 225, 4},
+      {67, 1, 86, 76, 14},
+      {40, 115, 65, 217, 0}
+    },
+    { {8, 225, 19, 56, 4},
+      {19, 102, 210, 16, 0},
+      {33, 204, 136, 113, 0},
+      {0, 132, 182, 108, 8}
+    },
+    { {30, 74, 153, 58, 11},
+      {150, 188, 143, 17, 9},
+      {213, 201, 149, 39, 8},
+      {152, 143, 19, 214, 9}
+    },
+    { {56, 123, 230, 193, 11},
+      {103, 223, 41, 12, 14},
+      {216, 54, 125, 225, 12},
+      {115, 9, 79, 190, 6}
+    },
+    { {23, 164, 136, 165, 2},
+      {137, 152, 22, 101, 2},
+      {74, 81, 18, 94, 8},
+      {74, 102, 129, 153, 1}
+    },
+    { {100, 67, 135, 200, 8},
+      {144, 231, 41, 136, 2},
+      {17, 62, 28, 34, 6},
+      {65, 25, 78, 112, 9}
+    },
+    { {110, 7, 130, 143, 7},
+      {142, 242, 104, 165, 3},
+      {239, 20, 30, 7, 6},
+      {202, 81, 100, 247, 1}
+    },
+    { {184, 128, 233, 2, 2},
+      {50, 152, 52, 2, 5},
+      {68, 9, 112, 17, 13},
+      {164, 2, 193, 148, 12}
+    },
+    { {62, 14, 185, 83, 2},
+      {146, 152, 172, 61, 13},
+      {76, 169, 215, 7, 12},
+      {187, 195, 81, 148, 9}
+    },
+    { {143, 140, 17, 176, 2},
+      {146, 16, 146, 115, 10},
+      {64, 216, 131, 31, 1},
+      {92, 228, 144, 132, 9}
+    },
+    { {27, 141, 195, 155, 13},
+      {54, 234, 209, 101, 11},
+      {189, 156, 59, 29, 8},
+      {218, 104, 181, 118, 12}
+    },
+    { {238, 130, 108, 30, 9},
+      {174, 33, 189, 131, 5},
+      {151, 131, 100, 23, 7},
+      {172, 27, 216, 71, 5}
+    },
+    { {149, 96, 110, 240, 8},
+      {161, 77, 135, 74, 6},
+      {16, 247, 96, 106, 9},
+      {101, 46, 27, 40, 5}
+    },
+    { {80, 228, 38, 86, 2},
+      {9, 93, 144, 168, 5},
+      {70, 166, 66, 112, 10},
+      {161, 80, 155, 169, 0}
+    },
+    { {212, 77, 143, 180, 2},
+      {152, 223, 134, 162, 10},
+      {66, 223, 27, 34, 11},
+      {84, 86, 31, 177, 9}
+    },
+    { {5, 79, 54, 9, 7},
+      {132, 119, 72, 116, 12},
+      {233, 6, 207, 42, 0},
+      {50, 225, 46, 226, 1}
+    },
+    { {165, 246, 91, 233, 9},
+      {245, 100, 63, 126, 2},
+      {153, 125, 166, 250, 5},
+      {71, 239, 194, 106, 15}
+    },
+    { {246, 67, 68, 234, 5},
+      {164, 47, 106, 139, 3},
+      {165, 114, 44, 38, 15},
+      {205, 21, 111, 66, 5}
+    },
+    { {85, 81, 175, 40, 13},
+      {212, 239, 71, 192, 4},
+      {177, 79, 88, 170, 10},
+      {32, 62, 47, 114, 11}
+    },
+    { {27, 94, 104, 63, 5},
+      {110, 44, 206, 101, 13},
+      {175, 193, 103, 173, 8},
+      {186, 103, 51, 71, 6}
+    },
+    { {6, 118, 167, 222, 12},
+      {217, 229, 201, 41, 7},
+      {55, 190, 86, 230, 0},
+      {233, 73, 58, 121, 11}
+    },
+    { {70, 176, 31, 231, 11},
+      {221, 81, 23, 157, 3},
+      {222, 127, 128, 214, 2},
+      {203, 158, 136, 171, 11}
+    },
+    { {38, 80, 223, 195, 0},
+      {240, 197, 36, 29, 3},
+      {12, 63, 176, 166, 4},
+      {203, 130, 74, 48, 15}
+    },
+    { {52, 1, 83, 23, 3},
+      {188, 90, 160, 20, 1},
+      {206, 140, 168, 2, 12},
+      {130, 128, 85, 163, 13}
+    },
+    { {185, 183, 76, 10, 12},
+      {99, 43, 125, 98, 1},
+      {53, 3, 46, 217, 13},
+      {132, 107, 237, 76, 6}
+    },
+    { {103, 124, 93, 21, 5},
+      {253, 5, 228, 245, 8},
+      {170, 139, 163, 238, 6},
+      {26, 242, 122, 11, 15}
+    },
+    { {62, 14, 116, 210, 9},
+      {166, 9, 169, 57, 15},
+      {148, 178, 231, 7, 12},
+      {249, 201, 89, 6, 5}
+    },
+    { {135, 91, 221, 123, 4},
+      {240, 167, 206, 95, 9},
+      {45, 235, 189, 174, 1},
+      {159, 167, 62, 80, 15}
+    },
+    { {243, 250, 71, 202, 15},
+      {117, 125, 121, 203, 11},
+      {245, 62, 37, 252, 15},
+      {221, 57, 235, 234, 14}
+    },
+    { {215, 194, 170, 201, 7},
+      {132, 252, 92, 207, 6},
+      {233, 53, 84, 62, 11},
+      {111, 51, 163, 242, 1}
+    },
+    { {9, 112, 244, 98, 8},
+      {99, 133, 3, 88, 5},
+      {20, 98, 240, 233, 0},
+      {161, 172, 10, 28, 6}
+    },
+    { {49, 139, 231, 50, 10},
+      {48, 219, 187, 64, 13},
+      {84, 206, 125, 24, 12},
+      {176, 45, 221, 176, 12}
+    },
+    { {250, 59, 245, 187, 4},
+      {115, 171, 234, 151, 15},
+      {45, 218, 253, 197, 15},
+      {254, 149, 125, 92, 14}
+    },
+    { {119, 186, 106, 0, 14},
+      {225, 88, 125, 193, 12},
+      {112, 5, 101, 222, 14},
+      {56, 59, 225, 168, 7}
+    },
+    { {245, 7, 16, 43, 15},
+      {132, 58, 107, 246, 1},
+      {253, 64, 142, 10, 15},
+      {134, 253, 101, 194, 1}
+    },
+    { {55, 185, 16, 190, 8},
+      {201, 42, 179, 81, 11},
+      {23, 208, 137, 222, 12},
+      {216, 172, 213, 73, 3}
+    },
+    { {154, 36, 87, 204, 1},
+      {63, 105, 0, 59, 2},
+      {131, 62, 162, 69, 9},
+      {77, 192, 9, 111, 12}
+    },
+    { {86, 238, 203, 19, 12},
+      {177, 204, 221, 165, 9},
+      {60, 141, 55, 118, 10},
+      {154, 91, 179, 56, 13}
+    },
+    { {19, 93, 119, 167, 4},
+      {120, 79, 66, 117, 15},
+      {46, 94, 235, 172, 8},
+      {250, 228, 47, 33, 14}
+    },
+    { {13, 146, 253, 48, 4},
+      {242, 129, 222, 80, 4},
+      {32, 203, 244, 155, 0},
+      {32, 167, 184, 20, 15}
+    },
+    { {237, 122, 230, 34, 3},
+      {231, 213, 42, 194, 13},
+      {196, 70, 117, 235, 7},
+      {180, 53, 74, 190, 7}
+    },
+    { {141, 125, 109, 37, 12},
+      {251, 7, 71, 102, 12},
+      {58, 75, 107, 235, 1},
+      {54, 110, 46, 13, 15}
+    },
+    { {120, 62, 207, 103, 3},
+      {127, 217, 46, 172, 9},
+      {206, 111, 55, 193, 14},
+      {147, 87, 73, 191, 14}
+    },
+    { {62, 116, 93, 252, 6},
+      {251, 61, 230, 57, 2},
+      {99, 251, 162, 231, 12},
+      {73, 198, 123, 205, 15}
+    },
+    { {188, 170, 218, 5, 10},
+      {171, 216, 61, 22, 8},
+      {90, 5, 181, 83, 13},
+      {22, 139, 193, 189, 5}
+    },
+    { {13, 162, 38, 20, 8},
+      {139, 65, 153, 64, 4},
+      {18, 134, 68, 91, 0},
+      {32, 41, 152, 45, 1}
+    },
+    { {134, 217, 94, 7, 10},
+      {232, 87, 21, 23, 9},
+      {94, 7, 169, 182, 1},
+      {158, 138, 142, 161, 7}
+    },
+    { {37, 126, 156, 27, 14},
+      {193, 181, 237, 116, 9},
+      {125, 131, 151, 234, 4},
+      {146, 235, 122, 216, 3}
+    },
+    { {221, 222, 210, 16, 1},
+      {230, 204, 152, 242, 8},
+      {128, 132, 183, 187, 11},
+      {20, 241, 147, 54, 7}
+    },
+    { {233, 1, 205, 160, 13},
+      {54, 131, 103, 194, 2},
+      {176, 91, 56, 9, 7},
+      {68, 62, 108, 22, 12}
+    },
+    { {119, 152, 12, 57, 4},
+      {192, 41, 246, 197, 8},
+      {41, 195, 1, 158, 14},
+      {26, 54, 249, 64, 3}
+    },
+    { {209, 14, 75, 139, 7},
+      {52, 120, 76, 230, 11},
+      {237, 29, 39, 8, 11},
+      {214, 115, 33, 226, 12}
+    },
+    { {226, 178, 81, 251, 9},
+      {117, 32, 187, 159, 3},
+      {157, 248, 164, 212, 7},
+      {207, 157, 208, 74, 14}
+    },
+    { {108, 39, 137, 18, 7},
+      {151, 146, 236, 160, 1},
+      {228, 137, 30, 67, 6},
+      {128, 83, 116, 158, 9}
+    },
+    { {78, 213, 70, 229, 4},
+      {234, 71, 82, 173, 2},
+      {42, 118, 42, 183, 2},
+      {75, 84, 174, 37, 7}
+    },
+    { {240, 6, 14, 244, 9},
+      {12, 73, 175, 170, 2},
+      {146, 247, 6, 0, 15},
+      {69, 95, 89, 35, 0}
+    },
+    { {179, 69, 148, 196, 9},
+      {12, 143, 33, 123, 2},
+      {146, 50, 154, 44, 13},
+      {77, 232, 79, 19, 0}
+    },
+    { {183, 99, 0, 71, 12},
+      {137, 14, 105, 79, 1},
+      {62, 32, 12, 110, 13},
+      {143, 41, 103, 9, 1}
+    },
+    { {124, 196, 229, 3, 1},
+      {182, 141, 48, 164, 5},
+      {140, 10, 114, 51, 14},
+      {162, 80, 203, 22, 13}
+    },
+    { {86, 1, 102, 16, 6},
+      {160, 91, 192, 129, 4},
+      {96, 134, 104, 6, 10},
+      {40, 16, 61, 160, 5}
+    },
+    { {82, 75, 187, 242, 15},
+      {20, 222, 207, 153, 15},
+      {244, 253, 221, 36, 10},
+      {249, 159, 55, 178, 8}
+    },
+    { {142, 50, 98, 30, 15},
+      {239, 112, 201, 3, 5},
+      {247, 132, 100, 199, 1},
+      {172, 9, 48, 239, 7}
+    },
+    { {66, 68, 75, 195, 9},
+      {52, 68, 5, 173, 3},
+      {156, 61, 34, 36, 2},
+      {203, 90, 2, 34, 12}
+    },
+    { {139, 101, 126, 225, 12},
+      {35, 71, 71, 127, 6},
+      {56, 119, 234, 109, 1},
+      {111, 238, 46, 44, 4}
+    },
+    { {53, 42, 182, 84, 7},
+      {141, 217, 232, 88, 12},
+      {226, 166, 213, 74, 12},
+      {49, 161, 121, 187, 1}
+    },
+    { {231, 165, 75, 233, 2},
+      {177, 114, 54, 239, 2},
+      {73, 125, 42, 94, 7},
+      {79, 118, 196, 232, 13}
+    },
+    { {120, 30, 244, 21, 3},
+      {110, 153, 168, 180, 12},
+      {202, 130, 247, 129, 14},
+      {50, 209, 89, 151, 6}
+    },
+    { {50, 242, 74, 129, 2},
+      {97, 92, 60, 5, 2},
+      {72, 21, 36, 244, 12},
+      {74, 3, 195, 168, 6}
+    },
+    { {40, 17, 16, 119, 11},
+      {78, 18, 163, 28, 1},
+      {222, 224, 136, 129, 4},
+      {131, 140, 84, 135, 2}
+    },
+    { {37, 203, 65, 84, 13},
+      {188, 6, 249, 72, 8},
+      {178, 168, 45, 58, 4},
+      {17, 41, 246, 3, 13}
+    },
+    { {167, 103, 245, 103, 1},
+      {189, 135, 42, 127, 5},
+      {142, 106, 254, 110, 5},
+      {175, 229, 78, 27, 13}
+    },
+    { {91, 165, 158, 70, 11},
+      {15, 219, 21, 249, 1},
+      {214, 39, 154, 93, 10},
+      {137, 250, 141, 191, 0}
+    },
+    { {88, 61, 62, 106, 2},
+      {67, 123, 6, 184, 13},
+      {69, 103, 203, 193, 10},
+      {177, 214, 13, 236, 2}
+    },
+    { {191, 77, 67, 125, 10},
+      {186, 126, 163, 111, 8},
+      {91, 236, 43, 47, 13},
+      {31, 108, 87, 229, 13}
+    },
+    { {160, 164, 162, 247, 2},
+      {9, 208, 178, 46, 7},
+      {78, 244, 82, 80, 5},
+      {231, 68, 208, 185, 0}
+    },
+    { {93, 52, 153, 184, 6},
+      {211, 184, 198, 240, 2},
+      {97, 217, 146, 203, 10},
+      {64, 246, 49, 220, 11}
+    },
+    { {211, 7, 214, 157, 5},
+      {44, 235, 200, 247, 2},
+      {171, 150, 190, 12, 11},
+      {78, 241, 61, 115, 4}
+    },
+    { {155, 172, 247, 16, 14},
+      {51, 217, 209, 115, 12},
+      {112, 142, 243, 93, 9},
+      {60, 232, 185, 188, 12}
+    },
+    { {196, 108, 246, 252, 13},
+      {173, 229, 195, 186, 14},
+      {179, 246, 243, 98, 3},
+      {117, 220, 58, 123, 5}
+    },
+    { {184, 1, 141, 118, 12},
+      {26, 139, 231, 10, 1},
+      {54, 235, 24, 1, 13},
+      {133, 14, 125, 21, 8}
+    },
+    { {232, 151, 127, 181, 13},
+      {126, 67, 255, 182, 6},
+      {186, 223, 238, 145, 7},
+      {102, 223, 252, 39, 14}
+    },
+    { {11, 60, 141, 188, 5},
+      {95, 161, 198, 97, 10},
+      {163, 219, 19, 205, 0},
+      {88, 102, 56, 95, 10}
+    },
+    { {20, 20, 133, 139, 8},
+      {208, 169, 1, 36, 3},
+      {29, 26, 18, 130, 8},
+      {194, 72, 9, 80, 11}
+    },
+    { {115, 104, 16, 10, 4},
+      {1, 44, 96, 209, 9},
+      {37, 0, 129, 108, 14},
+      {152, 176, 99, 72, 0}
+    },
+    { {18, 132, 134, 239, 3},
+      {12, 249, 18, 45, 3},
+      {207, 118, 18, 20, 8},
+      {203, 68, 137, 243, 0}
+    },
+    { {210, 252, 86, 125, 0},
+      {105, 109, 146, 191, 8},
+      {11, 230, 163, 244, 11},
+      {31, 212, 155, 105, 6}
+    },
+    { {91, 207, 66, 130, 14},
+      {34, 94, 89, 225, 11},
+      {116, 20, 47, 61, 10},
+      {216, 121, 167, 164, 4}
+    },
+    { {73, 183, 123, 167, 3},
+      {127, 82, 30, 244, 7},
+      {206, 93, 238, 217, 2},
+      {226, 247, 132, 175, 14}
+    },
+    { {97, 229, 12, 169, 15},
+      {5, 55, 119, 228, 2},
+      {249, 83, 10, 120, 6},
+      {66, 126, 238, 202, 0}
+    },
+    { {28, 221, 19, 226, 0},
+      {210, 78, 18, 56, 11},
+      {4, 124, 139, 179, 8},
+      {209, 196, 135, 36, 11}
+    },
+    { {241, 23, 253, 83, 15},
+      {116, 155, 237, 254, 5},
+      {252, 171, 254, 136, 15},
+      {167, 251, 125, 146, 14}
+    },
+    { {141, 51, 92, 19, 13},
+      {231, 3, 205, 86, 1},
+      {188, 131, 172, 203, 1},
+      {134, 171, 60, 14, 7}
+    },
+    { {248, 223, 155, 48, 4},
+      {82, 206, 254, 178, 8},
+      {32, 205, 159, 177, 15},
+      {20, 215, 247, 52, 10}
+    },
+    { {205, 115, 59, 196, 0},
+      {219, 70, 12, 218, 6},
+      {2, 61, 204, 235, 3},
+      {101, 179, 6, 45, 11}
+    },
+    { {35, 29, 150, 151, 9},
+      {76, 195, 161, 117, 11},
+      {158, 150, 155, 140, 4},
+      {218, 232, 92, 51, 2}
+    },
+    { {44, 151, 177, 71, 6},
+      {218, 146, 120, 60, 5},
+      {110, 40, 222, 147, 4},
+      {163, 193, 228, 149, 11}
+    },
+    { {230, 105, 156, 80, 1},
+      {133, 135, 164, 155, 8},
+      {128, 163, 153, 102, 7},
+      {29, 146, 94, 26, 1}
+    },
+    { {181, 161, 208, 86, 14},
+      {169, 154, 241, 90, 1},
+      {118, 160, 184, 90, 13},
+      {133, 168, 245, 153, 5}
+    },
+    { {60, 125, 33, 88, 4},
+      {211, 46, 224, 40, 12},
+      {33, 168, 75, 227, 12},
+      {49, 64, 119, 76, 11}
+    },
+    { {173, 20, 11, 20, 5},
+      {222, 64, 228, 98, 0},
+      {162, 141, 2, 139, 5},
+      {4, 98, 112, 39, 11}
+    },
+    { {251, 9, 110, 114, 3},
+      {38, 91, 166, 203, 13},
+      {196, 231, 105, 13, 15},
+      {189, 54, 93, 166, 4}
+    },
+    { {23, 132, 105, 191, 13},
+      {188, 40, 215, 101, 7},
+      {191, 217, 98, 30, 8},
+      {234, 110, 177, 67, 13}
+    },
+    { {36, 48, 61, 47, 6},
+      {217, 49, 102, 20, 5},
+      {111, 75, 192, 194, 4},
+      {162, 134, 104, 201, 11}
+    },
+    { {235, 214, 231, 21, 5},
+      {126, 197, 248, 231, 4},
+      {170, 142, 118, 189, 7},
+      {46, 113, 250, 55, 14}
+    },
+    { {147, 91, 170, 215, 11},
+      {76, 222, 141, 79, 15},
+      {222, 181, 93, 172, 9},
+      {255, 43, 23, 179, 2}
+    },
+    { {209, 95, 34, 205, 13},
+      {76, 110, 73, 238, 14},
+      {187, 52, 79, 168, 11},
+      {119, 121, 39, 99, 2}
+    },
+    { {55, 178, 213, 83, 15},
+      {245, 153, 249, 93, 1},
+      {252, 170, 180, 222, 12},
+      {139, 169, 249, 154, 15}
+    },
+    { {211, 101, 213, 98, 8},
+      {49, 143, 3, 251, 1},
+      {20, 106, 186, 108, 11},
+      {141, 252, 15, 24, 12}
+    },
+    { {29, 118, 183, 146, 15},
+      {215, 221, 201, 112, 7},
+      {244, 158, 214, 235, 8},
+      {224, 233, 59, 190, 11}
+    },
+    { {87, 185, 126, 171, 11},
+      {229, 123, 23, 213, 15},
+      {221, 87, 233, 222, 10},
+      {250, 190, 141, 234, 7}
+    },
+    { {9, 11, 171, 164, 4},
+      {26, 194, 78, 64, 14},
+      {34, 93, 93, 9, 0},
+      {112, 39, 36, 53, 8}
+    },
+    { {163, 131, 97, 118, 11},
+      {60, 18, 187, 75, 5},
+      {214, 232, 108, 28, 5},
+      {173, 45, 212, 131, 12}
+    },
+    { {156, 250, 125, 156, 6},
+      {251, 61, 220, 18, 14},
+      {99, 155, 229, 243, 9},
+      {116, 131, 187, 205, 15}
+    },
+    { {76, 134, 94, 122, 15},
+      {166, 113, 223, 184, 1},
+      {245, 231, 166, 19, 2},
+      {129, 223, 184, 230, 5}
+    },
+    { {249, 13, 22, 148, 11},
+      {14, 91, 161, 242, 10},
+      {210, 150, 139, 9, 15},
+      {84, 248, 93, 167, 0}
+    },
+    { {120, 93, 12, 212, 1},
+      {78, 15, 164, 168, 10},
+      {130, 179, 11, 161, 14},
+      {81, 82, 95, 7, 2}
+    },
+    { {51, 98, 95, 192, 1},
+      {53, 77, 44, 89, 2},
+      {128, 63, 164, 108, 12},
+      {73, 163, 75, 42, 12}
+    },
+    { {0, 213, 240, 148, 3},
+      {108, 150, 144, 48, 6},
+      {194, 144, 250, 176, 0},
+      {96, 192, 150, 147, 6}
+    },
+    { {167, 185, 175, 176, 8},
+      {209, 195, 183, 67, 14},
+      {16, 223, 89, 222, 5},
+      {124, 46, 220, 56, 11}
+    },
+    { {223, 59, 151, 88, 10},
+      {211, 251, 137, 219, 8},
+      {81, 174, 157, 207, 11},
+      {29, 185, 29, 252, 11}
+    },
+    { {182, 138, 31, 89, 2},
+      {144, 121, 188, 31, 8},
+      {73, 175, 133, 22, 13},
+      {31, 131, 217, 224, 9}
+    },
+    { {103, 50, 106, 212, 0},
+      {233, 64, 172, 201, 6},
+      {2, 181, 100, 206, 6},
+      {105, 51, 80, 41, 7}
+    },
+    { {7, 184, 90, 134, 3},
+      {237, 80, 20, 81, 11},
+      {198, 21, 161, 222, 0},
+      {216, 162, 128, 171, 7}
+    },
+    { {37, 38, 25, 247, 15},
+      {157, 16, 239, 124, 3},
+      {254, 249, 134, 74, 4},
+      {195, 239, 112, 139, 9}
+    },
+    { {130, 206, 71, 104, 3},
+      {52, 117, 26, 43, 8},
+      {193, 110, 39, 52, 1},
+      {29, 69, 138, 226, 12}
+    },
+    { {108, 230, 33, 121, 12},
+      {147, 36, 251, 172, 4},
+      {57, 232, 70, 115, 6},
+      {35, 93, 242, 76, 9}
+    },
+    { {98, 230, 221, 55, 8},
+      {57, 133, 191, 181, 1},
+      {30, 203, 182, 116, 6},
+      {138, 223, 218, 25, 12}
+    },
+    { {62, 92, 11, 17, 10},
+      {210, 92, 165, 37, 8},
+      {88, 141, 3, 167, 12},
+      {26, 74, 83, 164, 11}
+    },
+    { {57, 245, 112, 80, 8},
+      {99, 14, 177, 120, 4},
+      {16, 160, 234, 249, 12},
+      {33, 232, 215, 12, 6}
+    },
+    { {214, 87, 51, 142, 6},
+      {216, 126, 72, 179, 7},
+      {103, 28, 206, 166, 11},
+      {236, 209, 39, 225, 11}
+    },
+    { {192, 98, 168, 92, 12},
+      {9, 164, 205, 138, 4},
+      {51, 161, 84, 96, 3},
+      {37, 27, 50, 89, 0}
+    },
+    { {131, 220, 0, 222, 5},
+      {76, 36, 208, 107, 11},
+      {167, 176, 3, 188, 1},
+      {221, 96, 178, 67, 2}
+    },
+    { {177, 33, 195, 250, 3},
+      {53, 250, 162, 74, 3},
+      {197, 252, 56, 72, 13},
+      {197, 36, 85, 250, 12}
+    },
+    { {227, 149, 10, 113, 14},
+      {64, 82, 247, 239, 0},
+      {120, 229, 10, 156, 7},
+      {15, 126, 244, 160, 2}
+    },
+    { {113, 29, 253, 190, 8},
+      {120, 171, 167, 240, 15},
+      {23, 219, 251, 136, 14},
+      {240, 254, 93, 81, 14}
+    },
+    { {130, 171, 112, 191, 2},
+      {41, 50, 154, 23, 15},
+      {79, 208, 237, 84, 1},
+      {254, 133, 148, 201, 4}
+    },
+    { {93, 123, 132, 66, 1},
+      {199, 143, 8, 200, 9},
+      {132, 34, 29, 235, 10},
+      {145, 49, 15, 30, 3}
+    },
+    { {103, 239, 52, 200, 12},
+      {129, 39, 121, 249, 14},
+      {49, 50, 207, 126, 6},
+      {121, 249, 238, 72, 1}
+    },
+    { {202, 53, 231, 230, 13},
+      {127, 195, 67, 171, 7},
+      {182, 126, 122, 197, 3},
+      {237, 92, 44, 63, 14}
+    },
+    { {36, 1, 77, 111, 11},
+      {188, 51, 39, 12, 1},
+      {223, 107, 40, 2, 4},
+      {131, 14, 76, 195, 13}
+    },
+    { {183, 239, 157, 161, 14},
+      {145, 159, 127, 119, 10},
+      {120, 91, 159, 126, 13},
+      {94, 239, 239, 152, 9}
+    },
+    { {176, 76, 172, 188, 7},
+      {12, 189, 230, 34, 14},
+      {227, 211, 83, 32, 13},
+      {116, 70, 123, 211, 0}
+    },
+    { {193, 166, 3, 154, 8},
+      {17, 96, 153, 226, 3},
+      {21, 156, 6, 88, 3},
+      {196, 121, 144, 104, 8}
+    },
+    { {197, 1, 82, 163, 10},
+      {160, 82, 3, 214, 3},
+      {92, 84, 168, 10, 3},
+      {198, 188, 4, 160, 5}
+    },
+    { {220, 202, 43, 43, 7},
+      {150, 124, 94, 134, 13},
+      {237, 77, 69, 51, 11},
+      {182, 23, 163, 230, 9}
+    },
+    { {88, 6, 54, 143, 3},
+      {14, 121, 8, 180, 7},
+      {207, 22, 198, 1, 10},
+      {226, 209, 9, 231, 0}
+    },
+    { {139, 223, 114, 151, 10},
+      {106, 86, 153, 119, 15},
+      {94, 148, 239, 189, 1},
+      {254, 233, 150, 165, 6}
+    },
+    { {118, 72, 225, 171, 10},
+      {176, 188, 35, 133, 15},
+      {93, 88, 113, 38, 14},
+      {250, 28, 67, 208, 13}
+    },
+    { {224, 20, 244, 247, 7},
+      {108, 145, 226, 190, 7},
+      {238, 242, 242, 128, 7},
+      {231, 212, 120, 147, 6}
+    },
+    { {113, 170, 60, 249, 0},
+      {1, 41, 190, 220, 14},
+      {9, 243, 197, 88, 14},
+      {115, 183, 217, 72, 0}
+    },
+    { {156, 171, 243, 108, 14},
+      {187, 250, 91, 26, 12},
+      {115, 108, 253, 83, 9},
+      {53, 141, 165, 253, 13}
+    },
+    { {135, 84, 73, 90, 15},
+      {244, 52, 197, 107, 1},
+      {245, 169, 34, 174, 1},
+      {141, 106, 50, 194, 15}
+    },
+    { {154, 153, 213, 71, 2},
+      {122, 155, 16, 31, 9},
+      {78, 42, 185, 149, 9},
+      {159, 128, 141, 149, 14}
+    },
+    { {231, 44, 187, 69, 6},
+      {153, 208, 100, 255, 12},
+      {106, 45, 211, 78, 7},
+      {63, 242, 96, 185, 9}
+    },
+    { {196, 176, 203, 147, 1},
+      {245, 192, 148, 134, 3},
+      {140, 157, 48, 210, 3},
+      {198, 18, 144, 58, 15}
+    },
+    { {137, 237, 4, 93, 7},
+      {15, 55, 208, 110, 8},
+      {235, 162, 11, 121, 1},
+      {23, 96, 190, 207, 0}
+    },
+    { {199, 169, 10, 58, 11},
+      {133, 114, 151, 195, 9},
+      {213, 197, 9, 94, 3},
+      {156, 62, 148, 234, 1}
+    },
+    { {65, 90, 235, 196, 2},
+      {120, 212, 12, 200, 14},
+      {66, 61, 117, 168, 2},
+      {113, 51, 2, 177, 14}
+    },
+    { {127, 85, 215, 48, 2},
+      {242, 223, 162, 241, 0},
+      {64, 206, 186, 175, 14},
+      {8, 244, 95, 180, 15}
+    },
+    { {17, 75, 16, 122, 6},
+      {0, 62, 202, 88, 9},
+      {101, 224, 141, 40, 8},
+      {145, 165, 55, 192, 0}
+    },
+    { {230, 235, 111, 39, 4},
+      {185, 71, 126, 135, 13},
+      {46, 79, 109, 118, 7},
+      {190, 23, 238, 41, 13}
+    },
+    { {132, 244, 176, 135, 15},
+      {205, 148, 81, 54, 7},
+      {254, 16, 210, 242, 1},
+      {230, 200, 162, 155, 3}
+    },
+    { {91, 222, 44, 8, 8},
+      {66, 45, 29, 225, 12},
+      {17, 3, 71, 189, 10},
+      {56, 123, 139, 68, 2}
+    },
+    { {205, 253, 149, 194, 7},
+      {215, 151, 80, 250, 11},
+      {228, 58, 155, 251, 3},
+      {213, 240, 174, 158, 11}
+    },
+    { {51, 193, 37, 123, 3},
+      {20, 63, 178, 77, 5},
+      {205, 234, 72, 60, 12},
+      {171, 36, 223, 194, 8}
+    },
+    { {99, 27, 71, 141, 15},
+      {124, 115, 105, 197, 10},
+      {251, 30, 45, 140, 6},
+      {90, 57, 108, 227, 14}
+    },
+    { {229, 239, 80, 81, 11},
+      {165, 22, 185, 254, 8},
+      {216, 160, 175, 122, 7},
+      {23, 249, 214, 138, 5}
+    },
+    { {65, 141, 160, 190, 12},
+      {8, 162, 211, 224, 15},
+      {55, 208, 91, 24, 2},
+      {240, 124, 180, 81, 0}
+    },
+    { {193, 184, 36, 139, 1},
+      {69, 33, 16, 198, 15},
+      {141, 18, 65, 216, 3},
+      {246, 48, 136, 74, 2}
+    },
+    { {118, 222, 87, 133, 11},
+      {252, 93, 57, 181, 10},
+      {218, 30, 167, 182, 14},
+      {90, 217, 203, 163, 15}
+    },
+    { {219, 201, 87, 218, 6},
+      {50, 127, 208, 219, 11},
+      {101, 190, 169, 61, 11},
+      {221, 176, 191, 228, 12}
+    },
+    { {202, 225, 244, 5, 4},
+      {43, 135, 80, 151, 4},
+      {42, 2, 248, 117, 3},
+      {46, 144, 174, 29, 4}
+    },
+    { {145, 76, 36, 42, 2},
+      {0, 61, 2, 98, 13},
+      {69, 66, 67, 40, 9},
+      {180, 100, 11, 192, 0}
+    },
+    { {69, 163, 208, 168, 2},
+      {161, 178, 26, 208, 2},
+      {65, 80, 188, 90, 2},
+      {64, 181, 132, 216, 5}
+    },
+    { {136, 154, 125, 93, 13},
+      {126, 33, 221, 30, 12},
+      {187, 171, 229, 145, 1},
+      {55, 139, 184, 71, 14}
+    },
+    { {154, 61, 179, 211, 2},
+      {83, 218, 128, 63, 15},
+      {76, 188, 219, 197, 9},
+      {255, 192, 21, 188, 10}
+    },
+    { {208, 44, 134, 112, 15},
+      {5, 217, 195, 170, 8},
+      {240, 230, 19, 64, 11},
+      {21, 92, 57, 186, 0}
+    },
+    { {21, 123, 52, 80, 12},
+      {193, 15, 201, 88, 12},
+      {48, 162, 205, 234, 8},
+      {49, 169, 63, 8, 3}
+    },
+    { {137, 13, 55, 91, 10},
+      {18, 115, 129, 126, 13},
+      {93, 174, 203, 9, 1},
+      {183, 232, 28, 228, 8}
+    },
+    { {137, 27, 201, 59, 10},
+      {114, 178, 143, 70, 9},
+      {93, 201, 61, 137, 1},
+      {150, 47, 20, 212, 14}
+    },
+    { {138, 2, 216, 10, 3},
+      {38, 176, 12, 19, 1},
+      {197, 1, 180, 5, 1},
+      {140, 131, 0, 214, 4}
+    },
+    { {30, 93, 243, 65, 14},
+      {242, 222, 65, 61, 12},
+      {120, 44, 251, 167, 8},
+      {59, 200, 39, 180, 15}
+    },
+    { {120, 109, 137, 131, 2},
+      {19, 158, 36, 164, 11},
+      {76, 25, 27, 97, 14},
+      {210, 82, 71, 156, 8}
+    },
+    { {172, 247, 228, 126, 13},
+      {239, 167, 251, 42, 5},
+      {183, 226, 126, 243, 5},
+      {165, 77, 254, 95, 7}
+    },
+    { {28, 22, 226, 90, 0},
+      {226, 232, 136, 40, 5},
+      {5, 164, 118, 131, 8},
+      {161, 65, 17, 116, 7}
+    },
+    { {46, 169, 4, 13, 9},
+      {143, 35, 49, 5, 8},
+      {155, 2, 9, 87, 4},
+      {26, 8, 204, 79, 1}
+    },
+    { {243, 38, 138, 238, 5},
+      {13, 232, 110, 235, 3},
+      {167, 117, 22, 76, 15},
+      {205, 119, 97, 123, 0}
+    },
+    { {128, 232, 75, 204, 11},
+      {61, 116, 21, 10, 10},
+      {211, 61, 33, 112, 1},
+      {85, 10, 130, 235, 12}
+    },
+    { {162, 190, 211, 245, 12},
+      {121, 192, 251, 63, 10},
+      {58, 252, 183, 212, 5},
+      {95, 205, 240, 57, 14}
+    },
+    { {179, 172, 4, 251, 2},
+      {1, 57, 178, 111, 11},
+      {77, 242, 3, 92, 13},
+      {223, 100, 217, 200, 0}
+    },
+    { {132, 89, 129, 25, 2},
+      {208, 182, 128, 6, 8},
+      {73, 136, 25, 162, 1},
+      {22, 0, 22, 208, 11}
+    },
+    { {96, 167, 159, 201, 4},
+      {17, 227, 124, 188, 2},
+      {41, 63, 158, 80, 6},
+      {67, 211, 236, 120, 8}
+    },
+    { {19, 143, 250, 197, 9},
+      {44, 202, 29, 125, 14},
+      {154, 53, 255, 28, 8},
+      {123, 235, 133, 51, 4}
+    },
+    { {214, 125, 112, 144, 3},
+      {229, 30, 128, 179, 14},
+      {192, 144, 235, 230, 11},
+      {124, 208, 23, 138, 7}
+    },
+    { {43, 138, 160, 242, 5},
+      {6, 128, 250, 73, 15},
+      {164, 240, 85, 29, 4},
+      {249, 37, 240, 22, 0}
+    },
+    { {41, 131, 176, 59, 10},
+      {2, 178, 187, 84, 5},
+      {93, 192, 220, 25, 4},
+      {162, 173, 212, 212, 0}
+    },
+    { {140, 215, 81, 28, 8},
+      {250, 38, 153, 50, 0},
+      {19, 136, 174, 179, 1},
+      {4, 201, 150, 69, 15}
+    },
+    { {47, 222, 77, 2, 12},
+      {242, 5, 125, 97, 9},
+      {52, 11, 39, 191, 4},
+      {152, 107, 234, 4, 15}
+    },
+    { {213, 4, 207, 5, 12},
+      {184, 201, 69, 230, 0},
+      {58, 15, 50, 10, 11},
+      {6, 122, 41, 49, 13}
+    },
+    { {186, 231, 214, 153, 0},
+      {35, 239, 184, 55, 2},
+      {9, 150, 190, 117, 13},
+      {78, 193, 223, 124, 4}
+    },
+    { {156, 243, 126, 164, 13},
+      {239, 79, 95, 18, 6},
+      {178, 87, 236, 243, 9},
+      {100, 143, 175, 47, 7}
+    },
+    { {143, 79, 97, 177, 14},
+      {178, 22, 203, 103, 14},
+      {120, 216, 111, 47, 1},
+      {126, 109, 54, 132, 13}
+    },
+    { {137, 255, 175, 206, 6},
+      {91, 247, 92, 106, 15},
+      {103, 63, 95, 249, 1},
+      {245, 99, 174, 253, 10}
+    },
+    { {124, 126, 177, 202, 2},
+      {211, 188, 40, 184, 15},
+      {69, 56, 215, 227, 14},
+      {241, 209, 67, 220, 11}
+    },
+    { {150, 194, 61, 167, 11},
+      {156, 29, 31, 23, 7},
+      {222, 91, 196, 54, 9},
+      {238, 143, 139, 131, 9}
+    }
+};
+
+
+
+static unsigned char DICT_APRILTAG_36h11_BYTES[][4][5] =
+{
+    { {33, 161, 70, 186, 11},
+      {37, 115, 179, 64, 3},
+      {213, 214, 40, 88, 4},
+      {192, 44, 220, 234, 4}
+    },
+    { {146, 209, 143, 233, 11},
+      {84, 255, 23, 15, 2},
+      {217, 127, 24, 180, 9},
+      {79, 14, 143, 242, 10}
+    },
+    { {112, 137, 1, 75, 11},
+      {20, 58, 49, 140, 9},
+      {221, 40, 9, 16, 14},
+      {147, 24, 197, 194, 8}
+    },
+    { {25, 57, 121, 226, 7},
+      {119, 26, 70, 88, 15},
+      {228, 121, 233, 201, 8},
+      {241, 166, 37, 142, 14}
+    },
+    { {68, 21, 61, 61, 7},
+      {220, 51, 198, 180, 4},
+      {235, 203, 202, 130, 2},
+      {34, 214, 60, 195, 11}
+    },
+    { {53, 205, 91, 140, 15},
+      {188, 126, 117, 112, 10},
+      {243, 29, 171, 58, 12},
+      {80, 234, 231, 227, 13}
+    },
+    { {161, 11, 165, 106, 0},
+      {16, 163, 42, 74, 13},
+      {5, 106, 93, 8, 5},
+      {181, 37, 76, 80, 8}
+    },
+    { {43, 135, 74, 96, 8},
+      {34, 66, 63, 105, 0},
+      {16, 101, 46, 29, 4},
+      {9, 111, 196, 36, 4}
+    },
+    { {181, 127, 184, 212, 4},
+      {201, 142, 236, 122, 14},
+      {34, 177, 223, 234, 13},
+      {117, 227, 119, 25, 3}
+    },
+    { {78, 32, 181, 166, 4},
+      {155, 129, 66, 145, 7},
+      {38, 90, 208, 71, 2},
+      {232, 148, 40, 29, 9}
+    },
+    { {97, 216, 151, 242, 12},
+      {80, 197, 243, 216, 11},
+      {52, 254, 145, 184, 6},
+      {209, 188, 250, 48, 10}
+    },
+    { {171, 52, 105, 255, 12},
+      {123, 32, 231, 111, 7},
+      {63, 249, 98, 205, 5},
+      {239, 110, 112, 77, 14}
+    },
+    { {89, 76, 164, 92, 2},
+      {10, 189, 128, 232, 12},
+      {67, 162, 83, 41, 10},
+      {49, 112, 27, 213, 0}
+    },
+    { {250, 28, 45, 46, 2},
+      {90, 57, 38, 163, 13},
+      {71, 75, 67, 133, 15},
+      {188, 86, 73, 197, 10}
+    },
+    { {151, 194, 75, 151, 2},
+      {184, 92, 156, 71, 3},
+      {78, 157, 36, 62, 9},
+      {206, 35, 147, 161, 13}
+    },
+    { {117, 146, 134, 36, 10},
+      {200, 217, 59, 192, 0},
+      {82, 70, 20, 154, 14},
+      {0, 61, 201, 177, 3}
+    },
+    { {28, 170, 254, 153, 10},
+      {163, 249, 157, 20, 14},
+      {89, 151, 245, 83, 8},
+      {114, 139, 153, 252, 5}
+    },
+    { {50, 54, 221, 193, 6},
+      {113, 153, 108, 61, 2},
+      {104, 59, 182, 196, 12},
+      {75, 195, 105, 152, 14}
+    },
+    { {136, 78, 82, 125, 6},
+      {42, 116, 202, 62, 8},
+      {107, 228, 167, 33, 1},
+      {23, 197, 50, 229, 4}
+    },
+    { {87, 113, 168, 199, 14},
+      {201, 158, 69, 205, 7},
+      {126, 49, 88, 238, 10},
+      {235, 58, 39, 153, 3}
+    },
+    { {245, 41, 37, 184, 1},
+      {149, 43, 162, 194, 14},
+      {129, 218, 73, 74, 15},
+      {116, 52, 93, 74, 9}
+    },
+    { {46, 89, 204, 26, 1},
+      {230, 167, 164, 1, 9},
+      {133, 131, 57, 167, 4},
+      {152, 2, 94, 86, 7}
+    },
+    { {127, 165, 138, 179, 1},
+      {135, 202, 182, 229, 3},
+      {140, 213, 26, 95, 14},
+      {202, 118, 213, 62, 1}
+    },
+    { {235, 67, 56, 79, 9},
+      {14, 38, 45, 223, 5},
+      {159, 33, 204, 45, 7},
+      {175, 187, 70, 71, 0}
+    },
+    { {57, 19, 213, 52, 5},
+      {126, 139, 234, 80, 0},
+      {162, 202, 188, 137, 12},
+      {0, 165, 125, 23, 14}
+    },
+    { {215, 155, 26, 59, 5},
+      {196, 106, 222, 215, 9},
+      {173, 197, 141, 158, 11},
+      {158, 183, 181, 98, 3}
+    },
+    { {13, 251, 231, 104, 13},
+      {247, 231, 91, 72, 12},
+      {177, 110, 125, 251, 0},
+      {49, 45, 174, 126, 15}
+    },
+    { {92, 215, 160, 49, 13},
+      {198, 142, 219, 164, 4},
+      {184, 192, 94, 179, 10},
+      {34, 93, 183, 22, 3}
+    },
+    { {185, 200, 247, 164, 11},
+      {62, 221, 51, 82, 14},
+      {210, 94, 241, 57, 13},
+      {116, 172, 203, 183, 12}
+    },
+    { {70, 152, 126, 6, 11},
+      {236, 81, 21, 145, 13},
+      {214, 7, 225, 150, 2},
+      {184, 154, 136, 163, 7}
+    },
+    { {110, 12, 93, 82, 7},
+      {182, 17, 228, 185, 9},
+      {228, 171, 163, 7, 6},
+      {153, 210, 120, 134, 13}
+    },
+    { {91, 197, 103, 187, 4},
+      {50, 111, 210, 229, 7},
+      {45, 222, 106, 61, 10},
+      {234, 116, 191, 100, 12}
+    },
+    { {30, 99, 2, 188, 2},
+      {139, 126, 138, 1, 2},
+      {67, 212, 12, 103, 8},
+      {72, 5, 23, 237, 1}
+    },
+    { {138, 199, 208, 70, 10},
+      {42, 150, 25, 59, 1},
+      {86, 32, 190, 53, 1},
+      {141, 201, 134, 149, 4}
+    },
+    { {166, 95, 226, 50, 6},
+      {224, 214, 234, 35, 13},
+      {100, 196, 127, 166, 5},
+      {188, 69, 118, 176, 7}
+    },
+    { {84, 0, 235, 97, 6},
+      {176, 216, 70, 140, 4},
+      {104, 109, 112, 2, 10},
+      {35, 22, 33, 176, 13}
+    },
+    { {247, 160, 102, 131, 6},
+      {161, 89, 112, 199, 7},
+      {108, 22, 96, 94, 15},
+      {238, 48, 233, 168, 5}
+    },
+    { {45, 208, 175, 223, 6},
+      {218, 245, 244, 76, 7},
+      {111, 191, 80, 187, 4},
+      {227, 34, 250, 245, 11}
+    },
+    { {59, 156, 182, 11, 1},
+      {70, 233, 48, 117, 13},
+      {141, 6, 211, 157, 12},
+      {186, 224, 201, 118, 2}
+    },
+    { {173, 106, 28, 175, 9},
+      {143, 37, 47, 86, 11},
+      {159, 83, 133, 107, 5},
+      {214, 175, 74, 79, 1}
+    },
+    { {147, 182, 46, 251, 5},
+      {69, 105, 222, 111, 7},
+      {173, 247, 70, 220, 9},
+      {239, 103, 185, 106, 2}
+    },
+    { {187, 33, 13, 147, 13},
+      {23, 11, 229, 71, 3},
+      {188, 155, 8, 77, 13},
+      {206, 42, 125, 14, 8}
+    },
+    { {222, 229, 80, 148, 11},
+      {175, 30, 145, 179, 2},
+      {210, 144, 170, 119, 11},
+      {76, 216, 151, 143, 5}
+    },
+    { {160, 205, 20, 121, 11},
+      {4, 55, 179, 62, 8},
+      {217, 226, 139, 48, 5},
+      {23, 204, 222, 194, 0}
+    },
+    { {42, 35, 171, 178, 7},
+      {23, 210, 238, 1, 7},
+      {228, 221, 92, 69, 4},
+      {232, 7, 116, 190, 8}
+    },
+    { {79, 103, 244, 181, 15},
+      {175, 151, 203, 245, 6},
+      {250, 210, 254, 111, 2},
+      {106, 253, 62, 159, 5}
+    },
+    { {88, 168, 21, 129, 8},
+      {19, 9, 17, 148, 10},
+      {24, 26, 129, 81, 10},
+      {82, 152, 137, 12, 8}
+    },
+    { {116, 52, 39, 214, 4},
+      {217, 73, 224, 168, 7},
+      {38, 190, 66, 194, 14},
+      {225, 80, 121, 41, 11}
+    },
+    { {29, 236, 64, 135, 4},
+      {171, 12, 80, 100, 11},
+      {46, 16, 35, 123, 8},
+      {210, 96, 163, 13, 5}
+    },
+    { {137, 42, 179, 160, 2},
+      {19, 208, 10, 82, 14},
+      {64, 92, 213, 73, 1},
+      {116, 165, 0, 188, 8}
+    },
+    { {56, 213, 116, 46, 14},
+      {106, 63, 115, 48, 5},
+      {119, 66, 234, 177, 12},
+      {160, 204, 239, 197, 6}
+    },
+    { {12, 67, 86, 122, 1},
+      {166, 103, 138, 24, 1},
+      {133, 230, 172, 35, 0},
+      {129, 133, 30, 102, 5}
+    },
+    { {93, 179, 17, 203, 1},
+      {215, 42, 24, 220, 3},
+      {141, 56, 140, 219, 10},
+      {195, 177, 133, 78, 11}
+    },
+    { {201, 87, 202, 31, 9},
+      {110, 230, 141, 230, 1},
+      {159, 133, 62, 169, 3},
+      {134, 123, 22, 119, 6}
+    },
+    { {162, 36, 87, 130, 3},
+      {53, 81, 32, 51, 3},
+      {196, 30, 162, 68, 5},
+      {204, 192, 72, 170, 12}
+    },
+    { {41, 172, 233, 143, 3},
+      {63, 176, 52, 100, 15},
+      {207, 25, 115, 89, 4},
+      {242, 98, 192, 223, 12}
+    },
+    { {204, 197, 44, 82, 8},
+      {130, 7, 149, 170, 5},
+      {20, 163, 74, 51, 3},
+      {165, 90, 158, 4, 1}
+    },
+    { {218, 139, 53, 120, 12},
+      {18, 43, 219, 155, 12},
+      {49, 234, 205, 21, 11},
+      {61, 157, 189, 68, 8}
+    },
+    { {213, 180, 185, 227, 6},
+      {209, 152, 86, 254, 7},
+      {108, 121, 210, 218, 11},
+      {231, 246, 161, 152, 11}
+    },
+    { {172, 156, 221, 60, 14},
+      {250, 177, 247, 50, 8},
+      {115, 203, 179, 147, 5},
+      {20, 206, 248, 213, 15}
+    },
+    { {203, 218, 168, 57, 1},
+      {70, 164, 158, 199, 12},
+      {137, 193, 85, 189, 3},
+      {62, 55, 146, 86, 2}
+    },
+    { {25, 134, 37, 107, 1},
+      {22, 41, 26, 108, 5},
+      {141, 106, 70, 25, 8},
+      {163, 101, 137, 70, 8}
+    },
+    { {186, 230, 204, 136, 9},
+      {39, 173, 61, 35, 2},
+      {145, 19, 54, 117, 13},
+      {76, 75, 203, 94, 4}
+    },
+    { {223, 145, 177, 14, 5},
+      {222, 170, 80, 211, 5},
+      {167, 8, 216, 159, 11},
+      {172, 176, 165, 87, 11}
+    },
+    { {161, 169, 213, 167, 5},
+      {61, 131, 114, 86, 11},
+      {174, 90, 185, 88, 5},
+      {214, 164, 236, 27, 12}
+    },
+    { {43, 101, 26, 169, 13},
+      {7, 102, 103, 117, 2},
+      {185, 85, 138, 109, 4},
+      {74, 238, 102, 110, 0}
+    },
+    { {77, 92, 46, 25, 13},
+      {198, 101, 197, 228, 12},
+      {185, 135, 67, 171, 2},
+      {50, 122, 58, 102, 3}
+    },
+    { {91, 22, 55, 54, 11},
+      {94, 89, 139, 241, 5},
+      {214, 206, 198, 141, 10},
+      {168, 253, 25, 167, 10}
+    },
+    { {247, 83, 214, 10, 8},
+      {224, 239, 41, 211, 1},
+      {21, 6, 188, 174, 15},
+      {140, 185, 79, 112, 7}
+    },
+    { {94, 132, 179, 125, 2},
+      {154, 248, 146, 189, 4},
+      {75, 236, 210, 23, 10},
+      {43, 212, 145, 245, 9}
+    },
+    { {252, 228, 58, 159, 2},
+      {139, 124, 180, 182, 7},
+      {79, 149, 194, 115, 15},
+      {230, 210, 211, 237, 1}
+    },
+    { {187, 146, 109, 26, 6},
+      {114, 57, 252, 67, 5},
+      {101, 139, 100, 157, 13},
+      {172, 35, 249, 196, 14}
+    },
+    { {237, 141, 35, 110, 5},
+      {158, 98, 114, 234, 13},
+      {167, 108, 75, 27, 7},
+      {181, 116, 228, 103, 9}
+    },
+    { {106, 248, 70, 243, 7},
+      {103, 85, 242, 141, 11},
+      {236, 246, 33, 245, 6},
+      {219, 20, 250, 174, 6}
+    },
+    { {234, 86, 165, 19, 8},
+      {82, 133, 169, 167, 5},
+      {28, 138, 86, 165, 7},
+      {174, 89, 90, 20, 10}
+    },
+    { {93, 73, 113, 70, 12},
+      {186, 14, 65, 216, 13},
+      {54, 40, 233, 43, 10},
+      {177, 184, 39, 5, 13}
+    },
+    { {71, 3, 96, 236, 10},
+      {168, 50, 11, 201, 6},
+      {83, 112, 108, 14, 2},
+      {105, 61, 4, 193, 5}
+    },
+    { {140, 75, 205, 103, 10},
+      {186, 151, 15, 14, 9},
+      {94, 107, 61, 35, 1},
+      {151, 15, 14, 149, 13}
+    },
+    { {41, 95, 57, 1, 14},
+      {82, 22, 109, 116, 12},
+      {120, 9, 207, 169, 4},
+      {50, 235, 102, 132, 10}
+    },
+    { {246, 181, 119, 233, 7},
+      {245, 123, 114, 191, 6},
+      {233, 126, 234, 214, 15},
+      {111, 212, 237, 234, 15}
+    },
+    { {82, 6, 2, 245, 10},
+      {8, 88, 139, 173, 2},
+      {90, 244, 6, 4, 10},
+      {75, 93, 17, 161, 0}
+    },
+    { {181, 17, 148, 146, 14},
+      {192, 155, 225, 82, 3},
+      {116, 146, 152, 138, 13},
+      {196, 168, 125, 144, 3}
+    },
+    { {72, 226, 153, 171, 7},
+      {23, 180, 94, 148, 3},
+      {237, 89, 148, 113, 2},
+      {194, 151, 162, 222, 8}
+    },
+    { {183, 159, 87, 55, 10},
+      {248, 91, 187, 119, 9},
+      {94, 206, 175, 158, 13},
+      {158, 237, 221, 161, 15}
+    },
+    { {168, 20, 198, 131, 14},
+      {98, 209, 97, 38, 3},
+      {124, 22, 50, 129, 5},
+      {198, 72, 104, 180, 6}
+    },
+    { {45, 169, 0, 88, 3},
+      {135, 50, 176, 72, 8},
+      {193, 160, 9, 91, 4},
+      {17, 32, 212, 206, 1}
+    },
+    { {212, 171, 164, 121, 7},
+      {133, 187, 218, 142, 12},
+      {233, 226, 93, 82, 11},
+      {55, 21, 189, 218, 1}
+    },
+    { {152, 42, 14, 101, 12},
+      {11, 73, 79, 14, 8},
+      {58, 103, 5, 65, 9},
+      {23, 15, 41, 45, 0}
+    },
+    { {244, 128, 204, 193, 5},
+      {164, 137, 116, 142, 2},
+      {168, 51, 48, 18, 15},
+      {71, 18, 233, 18, 5}
+    },
+    { {11, 32, 234, 115, 2},
+      {35, 208, 134, 77, 5},
+      {76, 229, 112, 77, 0},
+      {171, 38, 16, 188, 4}
+    },
+    { {169, 80, 103, 16, 10},
+      {114, 85, 161, 66, 4},
+      {80, 142, 96, 169, 5},
+      {36, 40, 90, 164, 14}
+    },
+    { {4, 134, 226, 238, 1},
+      {172, 224, 26, 40, 7},
+      {135, 116, 118, 18, 0},
+      {225, 69, 128, 115, 5}
+    },
+    { {176, 169, 114, 97, 5},
+      {37, 74, 114, 30, 12},
+      {168, 100, 233, 80, 13},
+      {55, 132, 229, 42, 4}
+    },
+    { {231, 63, 58, 37, 7},
+      {205, 82, 110, 247, 12},
+      {234, 69, 207, 206, 7},
+      {62, 247, 100, 171, 3}
+    },
+    { {23, 226, 5, 185, 8},
+      {145, 45, 155, 69, 2},
+      {25, 218, 4, 126, 8},
+      {74, 45, 155, 72, 9}
+    },
+    { {236, 154, 178, 178, 4},
+      {194, 192, 250, 146, 15},
+      {36, 212, 213, 147, 7},
+      {244, 149, 240, 52, 3}
+    },
+    { {217, 51, 158, 7, 6},
+      {75, 219, 76, 214, 1},
+      {110, 7, 156, 201, 11},
+      {134, 179, 45, 189, 2}
+    },
+    { {235, 136, 116, 249, 9},
+      {38, 33, 179, 223, 14},
+      {153, 242, 225, 29, 7},
+      {127, 188, 216, 70, 4}
+    },
+    { {148, 32, 165, 92, 12},
+      {153, 169, 193, 10, 4},
+      {51, 170, 80, 66, 9},
+      {37, 8, 57, 89, 9}
+    },
+    { {227, 100, 255, 153, 2},
+      {49, 245, 164, 247, 6},
+      {73, 159, 242, 108, 7},
+      {110, 242, 90, 248, 12}
+    },
+    { {138, 76, 184, 240, 10},
+      {2, 148, 135, 59, 14},
+      {80, 241, 211, 37, 1},
+      {125, 206, 18, 148, 0}
+    },
+    { {247, 42, 238, 118, 6},
+      {169, 217, 238, 203, 13},
+      {102, 231, 117, 78, 15},
+      {189, 55, 121, 185, 5}
+    },
+    { {115, 204, 107, 86, 9},
+      {60, 76, 181, 233, 13},
+      {150, 173, 99, 60, 14},
+      {185, 122, 211, 35, 12}
+    },
+    { {201, 156, 166, 165, 9},
+      {78, 193, 19, 230, 14},
+      {154, 86, 83, 153, 3},
+      {118, 124, 136, 55, 2}
+    },
+    { {54, 106, 12, 83, 5},
+      {133, 13, 236, 13, 9},
+      {172, 163, 5, 102, 12},
+      {155, 3, 123, 10, 1}
+    },
+    { {80, 158, 81, 148, 3},
+      {124, 24, 152, 176, 10},
+      {194, 152, 167, 144, 10},
+      {80, 209, 145, 131, 14}
+    },
+    { {186, 109, 34, 125, 1},
+      {15, 110, 162, 47, 12},
+      {139, 228, 75, 101, 13},
+      {63, 68, 87, 111, 0}
+    },
+    { {210, 172, 241, 99, 11},
+      {53, 152, 19, 191, 13},
+      {220, 104, 243, 84, 11},
+      {191, 220, 129, 154, 12}
+    },
+    { {217, 137, 254, 246, 8},
+      {42, 203, 151, 218, 15},
+      {22, 247, 249, 25, 11},
+      {245, 190, 157, 53, 4}
+    },
+    { {100, 23, 7, 187, 2},
+      {208, 115, 170, 164, 3},
+      {77, 222, 14, 130, 6},
+      {194, 85, 92, 224, 11}
+    },
+    { {249, 189, 49, 42, 11},
+      {87, 58, 51, 242, 13},
+      {213, 72, 203, 217, 15},
+      {180, 252, 197, 206, 10}
+    },
+    { {119, 115, 156, 32, 7},
+      {197, 159, 110, 209, 0},
+      {224, 67, 156, 238, 14},
+      {8, 183, 111, 154, 3}
+    },
+    { {104, 191, 141, 27, 15},
+      {87, 179, 253, 164, 9},
+      {253, 139, 31, 209, 6},
+      {146, 91, 252, 222, 10}
+    },
+    { {222, 221, 132, 166, 14},
+      {202, 159, 83, 163, 11},
+      {118, 82, 27, 183, 11},
+      {220, 92, 175, 149, 3}
+    },
+    { {66, 234, 236, 73, 11},
+      {37, 181, 29, 141, 12},
+      {217, 35, 117, 116, 2},
+      {59, 27, 138, 218, 4}
+    },
+    { {48, 43, 104, 213, 3},
+      {45, 26, 172, 12, 14},
+      {202, 177, 109, 64, 12},
+      {115, 3, 85, 139, 4}
+    },
+    { {78, 187, 147, 12, 14},
+      {219, 242, 89, 145, 8},
+      {115, 12, 157, 215, 2},
+      {24, 153, 164, 253, 11}
+    },
+    { {67, 156, 93, 155, 5},
+      {116, 33, 212, 245, 11},
+      {173, 155, 163, 156, 2},
+      {218, 242, 184, 66, 14}
+    },
+    { {225, 252, 146, 40, 13},
+      {69, 228, 115, 242, 8},
+      {177, 68, 147, 248, 7},
+      {20, 252, 226, 122, 2}
+    },
+    { {248, 166, 168, 212, 10},
+      {11, 152, 189, 170, 6},
+      {82, 177, 86, 81, 15},
+      {101, 91, 209, 157, 0}
+    },
+    { {181, 57, 2, 161, 8},
+      {193, 74, 35, 70, 10},
+      {24, 84, 9, 202, 13},
+      {86, 44, 69, 40, 3}
+    },
+    { {177, 99, 71, 94, 14},
+      {57, 127, 233, 74, 1},
+      {119, 174, 44, 104, 13},
+      {133, 41, 127, 233, 12}
+    },
+    { {173, 47, 90, 242, 9},
+      {167, 66, 175, 122, 11},
+      {148, 245, 175, 75, 5},
+      {213, 239, 84, 46, 5}
+    },
+    { {170, 181, 220, 133, 0},
+      {107, 131, 52, 55, 2},
+      {10, 19, 186, 213, 5},
+      {78, 194, 204, 29, 6}
+    },
+    { {179, 236, 37, 120, 6},
+      {17, 61, 242, 107, 12},
+      {97, 234, 67, 124, 13},
+      {61, 100, 251, 200, 8}
+    },
+    { {71, 153, 196, 64, 5},
+      {228, 131, 80, 201, 8},
+      {160, 34, 57, 158, 2},
+      {25, 48, 172, 18, 7}
+    },
+    { {139, 198, 141, 192, 4},
+      {18, 133, 92, 107, 2},
+      {32, 59, 22, 61, 1},
+      {77, 99, 170, 20, 8}
+    },
+    { {112, 47, 21, 221, 14},
+      {25, 59, 233, 188, 10},
+      {123, 186, 143, 64, 14},
+      {83, 217, 125, 201, 8}
+    },
+    { {180, 34, 147, 218, 9},
+      {149, 232, 169, 26, 3},
+      {149, 188, 148, 66, 13},
+      {197, 137, 81, 122, 9}
+    },
+    { {26, 202, 208, 56, 2},
+      {34, 188, 154, 17, 8},
+      {65, 192, 181, 53, 8},
+      {24, 133, 147, 212, 4}
+    },
+    { {129, 51, 99, 151, 1},
+      {125, 66, 136, 70, 7},
+      {142, 156, 108, 200, 1},
+      {230, 33, 20, 43, 14}
+    },
+    { {14, 105, 42, 215, 0},
+      {139, 70, 132, 13, 15},
+      {14, 181, 73, 103, 0},
+      {251, 2, 22, 45, 1}
+    },
+    { {138, 208, 92, 91, 9},
+      {102, 37, 149, 31, 1},
+      {157, 163, 160, 181, 1},
+      {143, 138, 154, 70, 6}
+    },
+    { {133, 230, 84, 193, 11},
+      {165, 21, 25, 126, 2},
+      {216, 50, 166, 122, 1},
+      {71, 233, 138, 138, 5}
+    },
+    { {61, 10, 194, 179, 11},
+      {166, 216, 171, 68, 11},
+      {220, 212, 53, 11, 12},
+      {210, 45, 81, 182, 5}
+    },
+    { {75, 191, 160, 85, 2},
+      {75, 146, 152, 237, 12},
+      {74, 160, 95, 221, 2},
+      {59, 113, 148, 157, 2}
+    },
+    { {114, 45, 222, 48, 6},
+      {33, 219, 230, 177, 8},
+      {96, 199, 187, 68, 14},
+      {24, 214, 125, 184, 4}
+    },
+    { {54, 157, 26, 205, 2},
+      {200, 122, 52, 61, 10},
+      {75, 53, 139, 150, 12},
+      {91, 194, 197, 225, 3}
+    },
+    { {162, 217, 148, 230, 0},
+      {72, 135, 50, 27, 11},
+      {6, 114, 153, 180, 5},
+      {221, 132, 206, 17, 2}
+    },
+    { {95, 173, 145, 57, 13},
+      {151, 170, 211, 245, 8},
+      {185, 200, 155, 95, 10},
+      {26, 252, 181, 94, 9}
+    },
+    { {87, 83, 90, 233, 6},
+      {224, 126, 78, 221, 2},
+      {105, 117, 172, 174, 10},
+      {75, 183, 39, 224, 7}
+    },
+    { {95, 94, 241, 212, 6},
+      {250, 156, 200, 249, 14},
+      {98, 184, 247, 175, 10},
+      {121, 241, 51, 149, 15}
+    },
+    { {235, 195, 230, 172, 12},
+      {42, 231, 123, 195, 6},
+      {51, 86, 124, 61, 7},
+      {108, 61, 238, 117, 4}
+    },
+    { {10, 153, 200, 53, 13},
+      {110, 130, 215, 5, 8},
+      {186, 193, 57, 149, 0},
+      {26, 14, 180, 23, 6}
+    },
+    { {84, 99, 228, 154, 5},
+      {165, 175, 200, 128, 7},
+      {165, 146, 124, 98, 10},
+      {224, 17, 63, 90, 5}
+    },
+    { {37, 103, 104, 147, 10},
+      {161, 22, 173, 100, 7},
+      {92, 145, 110, 106, 4},
+      {226, 107, 86, 136, 5}
+    },
+    { {171, 237, 55, 6, 4},
+      {27, 71, 112, 115, 13},
+      {38, 14, 203, 125, 5},
+      {188, 224, 238, 45, 8}
+    },
+    { {89, 189, 222, 217, 4},
+      {99, 235, 212, 252, 10},
+      {41, 183, 187, 217, 10},
+      {83, 242, 189, 124, 6}
+    },
+    { {100, 250, 4, 192, 9},
+      {197, 5, 57, 136, 10},
+      {144, 50, 5, 242, 6},
+      {81, 25, 202, 10, 3}
+    },
+    { {37, 14, 68, 231, 5},
+      {172, 1, 106, 108, 11},
+      {174, 114, 39, 10, 4},
+      {211, 101, 104, 3, 5}
+    },
+    { {229, 138, 55, 75, 12},
+      {144, 97, 121, 222, 13},
+      {61, 46, 197, 26, 7},
+      {183, 185, 232, 96, 9}
+    },
+    { {36, 202, 165, 116, 1},
+      {156, 133, 186, 8, 12},
+      {130, 234, 85, 50, 4},
+      {49, 5, 218, 19, 9}
+    },
+    { {228, 44, 246, 88, 8},
+      {161, 225, 161, 186, 12},
+      {17, 166, 243, 66, 7},
+      {53, 216, 88, 120, 5}
+    },
+    { {110, 162, 56, 83, 8},
+      {131, 0, 189, 157, 5},
+      {28, 161, 196, 87, 6},
+      {171, 155, 208, 12, 1}
+    },
+    { {247, 88, 19, 2, 5},
+      {212, 76, 96, 211, 9},
+      {164, 12, 129, 174, 15},
+      {156, 176, 99, 34, 11}
+    },
+    { {12, 235, 51, 187, 13},
+      {151, 102, 219, 20, 15},
+      {189, 220, 205, 115, 0},
+      {242, 141, 182, 110, 9}
+    },
+    { {120, 106, 232, 103, 0},
+      {43, 140, 46, 140, 13},
+      {14, 97, 117, 97, 14},
+      {179, 23, 67, 29, 4}
+    },
+    { {240, 222, 140, 150, 9},
+      {76, 141, 189, 162, 11},
+      {150, 147, 23, 176, 15},
+      {212, 91, 219, 19, 2}
+    },
+    { {38, 200, 30, 254, 6},
+      {136, 117, 246, 25, 11},
+      {103, 247, 129, 54, 4},
+      {217, 134, 250, 225, 1}
+    },
+    { {105, 244, 137, 8, 6},
+      {83, 180, 116, 224, 0},
+      {97, 9, 18, 249, 6},
+      {0, 114, 226, 220, 10}
+    },
+    { {63, 191, 146, 164, 13},
+      {207, 202, 123, 113, 10},
+      {178, 84, 159, 223, 12},
+      {88, 237, 229, 63, 3}
+    },
+    { {214, 85, 90, 118, 0},
+      {232, 78, 134, 187, 1},
+      {6, 229, 170, 166, 11},
+      {141, 214, 23, 33, 7}
+    },
+    { {156, 202, 226, 54, 13},
+      {174, 204, 219, 2, 13},
+      {182, 196, 117, 51, 9},
+      {180, 13, 179, 55, 5}
+    },
+    { {178, 86, 193, 106, 3},
+      {116, 188, 42, 43, 1},
+      {197, 104, 54, 164, 13},
+      {141, 69, 67, 210, 14}
+    },
+    { {215, 138, 199, 34, 1},
+      {180, 201, 26, 195, 9},
+      {132, 78, 53, 30, 11},
+      {156, 53, 137, 50, 13}
+    },
+    { {45, 193, 254, 38, 2},
+      {170, 215, 54, 80, 5},
+      {70, 71, 248, 59, 4},
+      {160, 166, 206, 181, 5}
+    },
+    { {175, 32, 81, 9, 0},
+      {179, 32, 32, 87, 0},
+      {9, 8, 160, 79, 5},
+      {14, 160, 64, 76, 13}
+    },
+    { {147, 44, 8, 175, 14},
+      {9, 56, 71, 103, 11},
+      {127, 81, 3, 76, 9},
+      {222, 110, 33, 201, 0}
+    },
+    { {83, 254, 202, 119, 5},
+      {109, 204, 222, 237, 9},
+      {174, 229, 55, 252, 10},
+      {155, 119, 179, 59, 6}
+    },
+    { {93, 41, 36, 151, 10},
+      {139, 27, 129, 196, 15},
+      {94, 146, 73, 75, 10},
+      {242, 56, 29, 141, 1}
+    },
+    { {47, 16, 26, 34, 11},
+      {198, 80, 39, 81, 1},
+      {212, 69, 128, 143, 4},
+      {136, 174, 64, 166, 3}
+    },
+    { {198, 173, 22, 177, 4},
+      {129, 67, 210, 183, 10},
+      {40, 214, 139, 86, 3},
+      {94, 212, 188, 40, 1}
+    },
+    { {210, 236, 164, 178, 0},
+      {1, 141, 146, 163, 15},
+      {4, 210, 83, 116, 11},
+      {252, 84, 155, 24, 0}
+    },
+    { {166, 250, 96, 61, 4},
+      {233, 36, 250, 7, 12},
+      {43, 192, 101, 246, 5},
+      {62, 5, 242, 73, 7}
+    },
+    { {48, 87, 195, 182, 9},
+      {124, 206, 171, 32, 3},
+      {150, 220, 62, 160, 12},
+      {192, 77, 87, 51, 14}
+    },
+    { {232, 23, 181, 77, 2},
+      {90, 179, 40, 190, 4},
+      {75, 42, 222, 129, 7},
+      {39, 209, 76, 213, 10}
+    },
+    { {64, 171, 252, 62, 0},
+      {41, 163, 158, 144, 13},
+      {7, 195, 253, 80, 2},
+      {176, 151, 156, 89, 4}
+    },
+    { {245, 58, 209, 110, 7},
+      {253, 184, 106, 218, 9},
+      {231, 104, 181, 202, 15},
+      {149, 181, 97, 219, 15}
+    },
+    { {54, 243, 160, 110, 8},
+      {201, 174, 59, 9, 5},
+      {23, 96, 92, 246, 12},
+      {169, 13, 199, 89, 3}
+    },
+    { {39, 120, 46, 65, 8},
+      {193, 69, 37, 77, 12},
+      {24, 39, 65, 238, 4},
+      {59, 42, 74, 40, 3}
+    },
+    { {62, 144, 98, 20, 6},
+      {234, 88, 240, 1, 4},
+      {98, 132, 96, 151, 12},
+      {40, 0, 241, 165, 7}
+    },
+    { {1, 253, 122, 212, 14},
+      {105, 86, 213, 120, 14},
+      {114, 181, 235, 248, 0},
+      {113, 234, 182, 169, 6}
+    },
+    { {200, 118, 91, 198, 4},
+      {123, 68, 76, 186, 3},
+      {38, 61, 166, 225, 3},
+      {197, 211, 34, 45, 14}
+    },
+    { {173, 61, 130, 21, 15},
+      {207, 210, 225, 102, 8},
+      {250, 132, 27, 203, 5},
+      {22, 104, 116, 191, 3}
+    },
+    { {150, 49, 122, 39, 14},
+      {233, 90, 71, 23, 5},
+      {126, 69, 232, 198, 9},
+      {174, 142, 37, 169, 7}
+    },
+    { {5, 248, 19, 202, 6},
+      {209, 116, 80, 88, 11},
+      {101, 60, 129, 250, 0},
+      {209, 160, 162, 232, 11}
+    },
+    { {14, 122, 220, 34, 14},
+      {227, 149, 79, 17, 9},
+      {116, 67, 181, 231, 0},
+      {152, 143, 42, 156, 7}
+    },
+    { {191, 82, 196, 165, 0},
+      {234, 141, 42, 71, 2},
+      {10, 82, 52, 175, 13},
+      {78, 37, 75, 21, 7}
+    },
+    { {114, 79, 106, 226, 14},
+      {32, 94, 111, 169, 15},
+      {116, 117, 111, 36, 14},
+      {249, 95, 103, 160, 4}
+    },
+    { {84, 15, 215, 234, 8},
+      {176, 235, 11, 184, 11},
+      {21, 126, 191, 2, 10},
+      {209, 221, 13, 112, 13}
+    },
+    { {156, 150, 47, 116, 1},
+      {222, 73, 158, 42, 4},
+      {130, 239, 70, 147, 9},
+      {37, 71, 153, 39, 11}
+    },
+    { {38, 64, 66, 176, 1},
+      {164, 68, 162, 1, 2},
+      {128, 212, 32, 38, 4},
+      {72, 4, 82, 34, 5}
+    },
+    { {25, 124, 183, 117, 4},
+      {91, 205, 194, 124, 12},
+      {42, 238, 211, 233, 8},
+      {51, 228, 59, 61, 10}
+    },
+    { {31, 43, 184, 80, 13},
+      {135, 138, 205, 89, 12},
+      {176, 161, 221, 79, 8},
+      {57, 171, 53, 30, 1}
+    },
+    { {200, 125, 108, 42, 13},
+      {103, 39, 71, 162, 13},
+      {181, 67, 107, 225, 3},
+      {180, 94, 46, 78, 6}
+    },
+    { {220, 141, 45, 237, 14},
+      {154, 59, 87, 174, 14},
+      {123, 123, 75, 19, 11},
+      {119, 94, 173, 197, 9}
+    },
+    { {203, 107, 1, 115, 8},
+      {19, 6, 139, 207, 9},
+      {28, 232, 13, 109, 3},
+      {159, 61, 22, 12, 8}
+    },
+    { {190, 66, 16, 54, 8},
+      {138, 12, 171, 19, 1},
+      {22, 192, 132, 39, 13},
+      {140, 141, 83, 5, 1}
+    },
+    { {187, 70, 34, 167, 7},
+      {14, 92, 106, 103, 7},
+      {238, 84, 70, 45, 13},
+      {238, 101, 99, 167, 0}
+    },
+    { {115, 50, 38, 239, 8},
+      {73, 105, 43, 205, 7},
+      {31, 118, 68, 204, 14},
+      {235, 61, 73, 105, 2}
+    },
+    { {73, 51, 173, 227, 9},
+      {87, 131, 15, 204, 7},
+      {156, 123, 92, 201, 2},
+      {227, 63, 12, 30, 10}
+    },
+    { {31, 28, 137, 108, 7},
+      {222, 184, 70, 105, 8},
+      {227, 105, 19, 143, 8},
+      {25, 102, 33, 215, 11}
+    },
+    { {137, 118, 101, 171, 10},
+      {115, 53, 11, 102, 7},
+      {93, 90, 102, 233, 1},
+      {230, 109, 10, 204, 14}
+    },
+    { {146, 244, 107, 161, 2},
+      {113, 92, 22, 39, 6},
+      {72, 93, 98, 244, 9},
+      {110, 70, 131, 168, 14}
+    },
+    { {41, 121, 129, 118, 7},
+      {95, 150, 226, 72, 9},
+      {230, 232, 25, 233, 4},
+      {145, 36, 118, 159, 10}
+    },
+    { {173, 112, 44, 248, 13},
+      {199, 37, 231, 74, 6},
+      {177, 243, 64, 235, 5},
+      {101, 46, 122, 78, 3}
+    },
+    { {71, 49, 152, 185, 0},
+      {193, 162, 134, 213, 2},
+      {9, 209, 152, 206, 2},
+      {74, 182, 20, 88, 3}
+    },
+    { {236, 46, 142, 6, 11},
+      {143, 209, 45, 162, 9},
+      {214, 7, 23, 67, 7},
+      {148, 91, 72, 191, 1}
+    },
+    { {54, 161, 214, 152, 0},
+      {161, 235, 176, 17, 2},
+      {1, 150, 184, 86, 12},
+      {72, 128, 221, 120, 5}
+    },
+    { {165, 206, 134, 80, 15},
+      {132, 213, 249, 106, 8},
+      {240, 166, 23, 58, 5},
+      {21, 105, 250, 178, 1}
+    },
+    { {99, 120, 112, 52, 8},
+      {105, 4, 163, 209, 12},
+      {18, 192, 225, 236, 6},
+      {56, 188, 82, 9, 6}
+    },
+    { {243, 171, 65, 212, 6},
+      {57, 26, 248, 203, 10},
+      {98, 184, 45, 92, 15},
+      {93, 49, 245, 137, 12}
+    },
+    { {230, 3, 42, 139, 5},
+      {132, 98, 108, 135, 7},
+      {173, 21, 76, 6, 7},
+      {238, 19, 100, 98, 1}
+    },
+    { {76, 17, 238, 199, 3},
+      {238, 211, 4, 140, 7},
+      {206, 55, 120, 131, 2},
+      {227, 18, 12, 183, 7}
+    },
+    { {38, 29, 229, 13, 6},
+      {248, 179, 96, 37, 12},
+      {107, 10, 123, 134, 4},
+      {58, 64, 108, 209, 15}
+    },
+    { {41, 102, 22, 227, 2},
+      {3, 85, 42, 124, 3},
+      {76, 118, 134, 105, 4},
+      {195, 229, 74, 172, 0}
+    },
+    { {55, 207, 241, 160, 10},
+      {176, 158, 59, 113, 14},
+      {80, 88, 255, 62, 12},
+      {120, 237, 199, 144, 13}
+    },
+    { {196, 87, 132, 122, 11},
+      {196, 183, 139, 170, 1},
+      {213, 226, 30, 162, 3},
+      {133, 93, 30, 210, 3}
+    },
+    { {119, 110, 82, 255, 9},
+      {173, 108, 171, 253, 11},
+      {159, 244, 167, 110, 14},
+      {219, 253, 83, 107, 5}
+    },
+    { {152, 8, 25, 187, 9},
+      {22, 40, 135, 22, 11},
+      {157, 217, 129, 1, 9},
+      {214, 142, 17, 70, 8}
+    },
+    { {80, 203, 43, 93, 8},
+      {24, 110, 157, 140, 12},
+      {27, 173, 77, 48, 10},
+      {51, 27, 151, 97, 8}
+    },
+    { {139, 105, 24, 6, 3},
+      {15, 22, 4, 83, 9},
+      {198, 1, 137, 109, 1},
+      {156, 162, 6, 143, 0}
+    },
+    { {18, 217, 194, 206, 9},
+      {108, 238, 17, 9, 11},
+      {151, 52, 57, 180, 8},
+      {217, 8, 135, 115, 6}
+    },
+    { {21, 140, 46, 115, 8},
+      {128, 73, 151, 108, 13},
+      {28, 231, 67, 26, 8},
+      {179, 110, 153, 32, 1}
+    },
+    { {107, 132, 1, 94, 10},
+      {26, 48, 177, 233, 1},
+      {87, 168, 2, 29, 6},
+      {137, 120, 208, 197, 8}
+    },
+    { {103, 105, 93, 185, 15},
+      {181, 55, 231, 213, 10},
+      {249, 219, 169, 110, 6},
+      {90, 190, 126, 202, 13}
+    },
+    { {62, 114, 116, 92, 1},
+      {239, 45, 168, 25, 4},
+      {131, 162, 228, 231, 12},
+      {41, 129, 91, 79, 7}
+    },
+    { {1, 202, 26, 87, 1},
+      {12, 68, 156, 92, 9},
+      {142, 165, 133, 56, 0},
+      {147, 163, 146, 35, 0}
+    },
+    { {34, 231, 3, 111, 5},
+      {29, 102, 122, 45, 1},
+      {175, 108, 14, 116, 4},
+      {139, 69, 230, 107, 8}
+    },
+    { {213, 220, 237, 174, 1},
+      {252, 173, 22, 226, 15},
+      {135, 91, 115, 186, 11},
+      {244, 118, 139, 83, 15}
+    },
+    { {128, 149, 50, 197, 11},
+      {76, 82, 17, 62, 6},
+      {218, 52, 202, 144, 1},
+      {103, 200, 132, 163, 2}
+    },
+    { {247, 228, 233, 213, 4},
+      {185, 140, 244, 239, 6},
+      {42, 185, 114, 126, 15},
+      {111, 114, 243, 25, 13}
+    },
+    { {89, 216, 79, 156, 11},
+      {126, 125, 149, 192, 10},
+      {211, 159, 33, 185, 10},
+      {80, 58, 155, 231, 14}
+    },
+    { {244, 46, 208, 133, 1},
+      {173, 136, 40, 182, 10},
+      {138, 16, 183, 66, 15},
+      {86, 209, 65, 27, 5}
+    },
+    { {93, 180, 169, 31, 10},
+      {219, 184, 149, 228, 5},
+      {95, 137, 82, 219, 10},
+      {162, 122, 145, 221, 11}
+    },
+    { {13, 88, 229, 177, 15},
+      {246, 149, 195, 68, 14},
+      {248, 218, 113, 171, 0},
+      {114, 44, 58, 150, 15}
+    },
+    { {105, 251, 159, 164, 3},
+      {95, 215, 62, 208, 10},
+      {194, 95, 157, 249, 6},
+      {80, 183, 206, 191, 10}
+    },
+    { {41, 186, 81, 246, 0},
+      {123, 0, 186, 88, 11},
+      {6, 248, 165, 217, 4},
+      {209, 165, 208, 13, 14}
+    },
+    { {88, 124, 103, 66, 7},
+      {119, 93, 64, 168, 13},
+      {228, 46, 99, 225, 10},
+      {177, 80, 43, 174, 14}
+    },
+    { {216, 185, 2, 30, 13},
+      {79, 106, 209, 130, 9},
+      {183, 132, 9, 209, 11},
+      {148, 24, 181, 111, 2}
+    },
+    { {187, 89, 68, 73, 14},
+      {98, 63, 97, 79, 8},
+      {121, 34, 41, 173, 13},
+      {31, 40, 111, 196, 6}
+    },
+    { {170, 35, 31, 53, 10},
+      {27, 83, 175, 23, 0},
+      {90, 207, 140, 69, 5},
+      {14, 143, 92, 173, 8}
+    },
+    { {13, 149, 148, 63, 4},
+      {202, 163, 210, 116, 1},
+      {47, 194, 154, 155, 0},
+      {130, 228, 188, 85, 3}
+    },
+    { {222, 196, 97, 37, 7},
+      {190, 28, 82, 167, 4},
+      {234, 72, 98, 55, 11},
+      {46, 84, 163, 135, 13}
+    },
+    { {5, 161, 105, 48, 13},
+      {181, 2, 215, 64, 4},
+      {176, 201, 104, 90, 0},
+      {32, 46, 180, 10, 13}
+    },
+    { {226, 81, 46, 181, 8},
+      {72, 71, 167, 135, 6},
+      {26, 215, 72, 164, 7},
+      {110, 30, 94, 33, 2}
+    },
+    { {171, 72, 226, 220, 0},
+      {42, 228, 160, 75, 14},
+      {3, 180, 113, 45, 5},
+      {125, 32, 82, 117, 4}
+    },
+    { {12, 182, 132, 148, 15},
+      {207, 145, 217, 32, 2},
+      {242, 146, 22, 211, 0},
+      {64, 73, 184, 159, 3}
+    },
+    { {146, 122, 107, 91, 1},
+      {117, 108, 140, 15, 13},
+      {141, 173, 101, 228, 9},
+      {191, 3, 19, 106, 14}
+    },
+    { {187, 144, 243, 69, 0},
+      {122, 200, 48, 95, 4},
+      {10, 44, 240, 157, 13},
+      {47, 160, 193, 53, 14}
+    },
+    { {99, 46, 143, 173, 0},
+      {25, 225, 46, 229, 10},
+      {11, 95, 23, 76, 6},
+      {90, 119, 72, 121, 8}
+    },
+    { {194, 238, 175, 42, 7},
+      {21, 245, 94, 163, 13},
+      {229, 79, 87, 116, 3},
+      {188, 87, 170, 250, 8}
+    },
+    { {30, 178, 175, 57, 13},
+      {215, 233, 223, 5, 4},
+      {185, 207, 84, 215, 8},
+      {42, 15, 185, 126, 11}
+    },
+    { {81, 21, 72, 197, 2},
+      {104, 26, 4, 236, 2},
+      {74, 49, 42, 136, 10},
+      {67, 114, 5, 129, 6}
+    },
+    { {70, 147, 213, 222, 4},
+      {248, 163, 216, 153, 3},
+      {39, 186, 188, 150, 2},
+      {201, 145, 188, 81, 15}
+    },
+    { {136, 142, 145, 97, 13},
+      {22, 128, 91, 62, 8},
+      {184, 104, 151, 17, 1},
+      {23, 205, 160, 22, 8}
+    },
+    { {104, 131, 111, 244, 15},
+      {62, 83, 255, 136, 6},
+      {242, 255, 108, 17, 6},
+      {97, 31, 252, 167, 12}
+    },
+    { {81, 189, 46, 68, 1},
+      {77, 75, 20, 232, 12},
+      {130, 39, 75, 216, 10},
+      {49, 114, 141, 43, 2}
+    },
+    { {122, 10, 196, 14, 9},
+      {46, 169, 41, 129, 9},
+      {151, 2, 53, 5, 14},
+      {152, 25, 73, 87, 4}
+    },
+    { {139, 183, 98, 180, 10},
+      {107, 82, 155, 99, 6},
+      {82, 212, 110, 221, 1},
+      {108, 109, 148, 173, 6}
+    },
+    { {28, 175, 131, 161, 10},
+      {147, 218, 27, 36, 10},
+      {88, 92, 31, 83, 8},
+      {82, 77, 133, 188, 9}
+    },
+    { {194, 112, 11, 187, 13},
+      {85, 100, 199, 135, 3},
+      {189, 221, 0, 228, 3},
+      {206, 30, 50, 106, 10}
+    },
+    { {251, 46, 208, 154, 10},
+      {35, 184, 169, 243, 11},
+      {85, 144, 183, 77, 15},
+      {220, 249, 81, 220, 4}
+    },
+    { {248, 82, 2, 148, 14},
+      {74, 92, 233, 130, 2},
+      {114, 148, 4, 161, 15},
+      {68, 25, 115, 165, 2}
+    },
+    { {122, 161, 4, 202, 6},
+      {3, 59, 112, 137, 3},
+      {101, 50, 8, 85, 14},
+      {201, 16, 237, 204, 0}
+    },
+    { {106, 150, 210, 188, 11},
+      {110, 240, 187, 177, 2},
+      {211, 212, 182, 149, 6},
+      {72, 221, 208, 247, 6}
+    },
+    { {40, 242, 236, 117, 14},
+      {107, 149, 255, 12, 4},
+      {122, 227, 116, 241, 4},
+      {35, 15, 250, 157, 6}
+    },
+    { {96, 112, 101, 235, 4},
+      {113, 37, 98, 140, 7},
+      {45, 122, 96, 224, 6},
+      {227, 20, 106, 72, 14}
+    },
+    { {122, 217, 179, 168, 12},
+      {82, 238, 115, 145, 14},
+      {49, 92, 217, 181, 14},
+      {120, 156, 231, 116, 10}
+    },
+    { {53, 114, 214, 203, 15},
+      {229, 253, 105, 92, 3},
+      {253, 54, 180, 234, 12},
+      {195, 169, 107, 250, 7}
+    },
+    { {212, 38, 239, 184, 15},
+      {181, 249, 207, 162, 6},
+      {241, 223, 118, 66, 11},
+      {100, 95, 57, 250, 13}
+    },
+    { {100, 238, 77, 186, 10},
+      {177, 53, 191, 160, 11},
+      {85, 219, 39, 114, 6},
+      {208, 95, 218, 200, 13}
+    },
+    { {152, 61, 122, 143, 1},
+      {111, 106, 4, 54, 15},
+      {143, 21, 235, 193, 9},
+      {246, 194, 5, 111, 6}
+    },
+    { {140, 163, 31, 73, 9},
+      {151, 99, 29, 30, 0},
+      {153, 47, 140, 83, 1},
+      {7, 139, 140, 110, 9}
+    },
+    { {2, 84, 87, 180, 6},
+      {120, 85, 194, 49, 2},
+      {98, 222, 162, 164, 0},
+      {72, 196, 58, 161, 14}
+    },
+    { {213, 58, 228, 20, 9},
+      {237, 137, 137, 194, 12},
+      {146, 130, 117, 202, 11},
+      {52, 57, 25, 27, 7}
+    },
+    { {157, 60, 100, 57, 6},
+      {227, 57, 194, 102, 12},
+      {105, 194, 99, 203, 9},
+      {54, 100, 57, 204, 7}
+    },
+    { {121, 83, 50, 238, 5},
+      {78, 110, 106, 216, 7},
+      {167, 116, 204, 169, 14},
+      {225, 181, 103, 103, 2}
+    },
+    { {112, 136, 77, 102, 4},
+      {56, 9, 118, 136, 9},
+      {38, 107, 33, 16, 14},
+      {145, 22, 233, 1, 12}
+    },
+    { {29, 211, 82, 141, 8},
+      {234, 110, 25, 84, 2},
+      {27, 20, 172, 187, 8},
+      {66, 169, 135, 101, 7}
+    },
+    { {216, 229, 29, 36, 6},
+      {27, 31, 86, 178, 0},
+      {98, 75, 138, 113, 11},
+      {4, 214, 175, 141, 8}
+    },
+    { {214, 2, 156, 163, 8},
+      {128, 137, 15, 151, 3},
+      {28, 83, 148, 6, 11},
+      {206, 159, 9, 16, 1}
+    },
+    { {217, 74, 182, 16, 12},
+      {2, 205, 201, 210, 12},
+      {48, 134, 213, 41, 11},
+      {52, 185, 59, 52, 0}
+    },
+    { {118, 107, 184, 136, 0},
+      {129, 174, 44, 145, 14},
+      {1, 17, 221, 102, 14},
+      {120, 147, 71, 88, 1}
+    },
+    { {253, 12, 107, 49, 9},
+      {182, 72, 167, 230, 12},
+      {152, 205, 99, 11, 15},
+      {54, 126, 81, 38, 13}
+    },
+    { {59, 255, 139, 157, 1},
+      {95, 238, 188, 101, 10},
+      {139, 157, 31, 253, 12},
+      {90, 99, 215, 127, 10}
+    },
+    { {231, 134, 244, 212, 14},
+      {168, 145, 249, 251, 6},
+      {114, 178, 246, 30, 7},
+      {109, 249, 248, 145, 5}
+    },
+    { {212, 230, 185, 183, 9},
+      {157, 140, 159, 182, 7},
+      {158, 217, 214, 114, 11},
+      {230, 223, 147, 27, 9}
+    },
+    { {207, 168, 187, 54, 9},
+      {159, 192, 151, 211, 13},
+      {150, 205, 209, 95, 3},
+      {188, 190, 144, 63, 9}
+    },
+    { {32, 164, 54, 108, 6},
+      {9, 113, 114, 56, 4},
+      {99, 102, 194, 80, 4},
+      {33, 196, 232, 233, 0}
+    },
+    { {92, 239, 185, 83, 6},
+      {147, 158, 220, 188, 13},
+      {108, 169, 223, 115, 10},
+      {179, 211, 183, 156, 9}
+    },
+    { {15, 6, 182, 96, 5},
+      {134, 193, 74, 121, 4},
+      {160, 102, 214, 15, 0},
+      {41, 229, 40, 54, 1}
+    },
+    { {187, 81, 210, 94, 7},
+      {110, 254, 224, 91, 1},
+      {231, 164, 184, 173, 13},
+      {141, 160, 119, 247, 6}
+    },
+    { {247, 226, 98, 100, 1},
+      {173, 76, 58, 203, 4},
+      {130, 100, 100, 126, 15},
+      {45, 53, 195, 43, 5}
+    },
+    { {129, 253, 169, 133, 5},
+      {93, 134, 84, 102, 14},
+      {170, 25, 91, 248, 1},
+      {118, 98, 166, 27, 10}
+    },
+    { {34, 65, 219, 197, 9},
+      {60, 198, 37, 29, 2},
+      {154, 61, 184, 36, 4},
+      {75, 138, 70, 51, 12}
+    },
+    { {86, 251, 75, 40, 0},
+      {241, 110, 30, 129, 8},
+      {1, 77, 45, 246, 10},
+      {24, 23, 135, 104, 15}
+    },
+    { {237, 166, 76, 109, 0},
+      {171, 33, 62, 238, 0},
+      {11, 99, 38, 91, 7},
+      {7, 119, 200, 77, 5}
+    },
+    { {206, 123, 8, 15, 4},
+      {203, 38, 76, 135, 9},
+      {47, 1, 13, 231, 3},
+      {158, 19, 38, 77, 3}
+    },
+    { {97, 146, 238, 126, 9},
+      {108, 225, 191, 200, 5},
+      {151, 231, 116, 152, 6},
+      {161, 63, 216, 115, 6}
+    },
+    { {148, 63, 245, 18, 4},
+      {241, 139, 200, 50, 13},
+      {36, 138, 255, 194, 9},
+      {180, 193, 61, 24, 15}
+    },
+    { {136, 179, 190, 173, 15},
+      {79, 243, 95, 22, 6},
+      {251, 87, 220, 209, 1},
+      {102, 143, 172, 255, 2}
+    },
+    { {155, 39, 229, 141, 0},
+      {59, 171, 8, 103, 6},
+      {11, 26, 126, 77, 9},
+      {110, 97, 13, 93, 12}
+    },
+    { {190, 11, 69, 253, 2},
+      {186, 59, 170, 15, 10},
+      {75, 250, 45, 7, 13},
+      {95, 5, 93, 197, 13}
+    },
+    { {105, 251, 58, 114, 10},
+      {67, 86, 191, 216, 13},
+      {84, 229, 205, 249, 6},
+      {177, 191, 214, 172, 2}
+    },
+    { {97, 56, 58, 131, 2},
+      {65, 80, 36, 212, 15},
+      {76, 21, 193, 200, 6},
+      {242, 178, 64, 168, 2}
+    },
+    { {102, 136, 99, 155, 3},
+      {180, 112, 176, 133, 15},
+      {205, 156, 97, 22, 6},
+      {250, 16, 208, 226, 13}
+    },
+    { {84, 208, 28, 153, 2},
+      {192, 61, 148, 148, 2},
+      {73, 147, 128, 178, 10},
+      {66, 146, 155, 192, 3}
+    },
+    { {144, 177, 12, 2, 10},
+      {65, 27, 21, 2, 1},
+      {84, 3, 8, 208, 9},
+      {132, 10, 141, 136, 2}
+    },
+    { {246, 103, 252, 109, 1},
+      {173, 175, 46, 191, 4},
+      {139, 99, 254, 102, 15},
+      {47, 215, 79, 91, 5}
+    },
+    { {122, 205, 117, 129, 3},
+      {54, 31, 48, 181, 14},
+      {200, 26, 235, 53, 14},
+      {122, 208, 207, 134, 12}
+    },
+    { {58, 189, 7, 246, 1},
+      {95, 75, 178, 41, 11},
+      {134, 254, 11, 213, 12},
+      {217, 68, 221, 47, 10}
+    },
+    { {84, 48, 18, 71, 3},
+      {205, 88, 0, 156, 1},
+      {206, 36, 128, 194, 10},
+      {131, 144, 1, 171, 3}
+    },
+    { {6, 119, 148, 213, 8},
+      {201, 135, 137, 61, 2},
+      {26, 178, 158, 230, 0},
+      {75, 201, 30, 25, 3}
+    },
+    { {168, 85, 177, 32, 1},
+      {86, 134, 34, 50, 4},
+      {128, 72, 218, 161, 5},
+      {36, 196, 70, 22, 10}
+    },
+    { {156, 180, 215, 253, 11},
+      {255, 249, 147, 62, 2},
+      {219, 254, 178, 211, 9},
+      {71, 204, 153, 255, 15}
+    },
+    { {49, 161, 147, 230, 10},
+      {25, 218, 51, 88, 3},
+      {86, 124, 152, 88, 12},
+      {193, 172, 197, 185, 8}
+    },
+    { {61, 163, 183, 109, 4},
+      {155, 235, 122, 92, 4},
+      {43, 110, 220, 91, 12},
+      {35, 165, 237, 125, 9}
+    },
+    { {65, 83, 241, 224, 4},
+      {112, 134, 74, 216, 6},
+      {32, 120, 252, 168, 2},
+      {97, 181, 38, 16, 14}
+    },
+    { {85, 68, 51, 91, 5},
+      {148, 108, 192, 252, 5},
+      {173, 172, 194, 42, 10},
+      {163, 240, 51, 98, 9}
+    },
+    { {146, 246, 18, 73, 13},
+      {69, 108, 89, 63, 0},
+      {185, 36, 134, 244, 9},
+      {15, 201, 163, 106, 2}
+    },
+    { {38, 154, 53, 248, 10},
+      {208, 49, 187, 25, 14},
+      {81, 250, 197, 150, 4},
+      {121, 141, 216, 192, 11}
+    },
+    { {4, 38, 119, 137, 6},
+      {177, 113, 72, 52, 6},
+      {105, 30, 230, 66, 0},
+      {98, 193, 40, 232, 13}
+    },
+    { {148, 135, 205, 198, 15},
+      {188, 155, 93, 42, 3},
+      {246, 59, 62, 18, 9},
+      {197, 75, 173, 147, 13}
+    },
+    { {78, 167, 231, 217, 12},
+      {179, 227, 217, 173, 6},
+      {57, 190, 126, 87, 2},
+      {107, 89, 188, 124, 13}
+    },
+    { {46, 54, 115, 69, 11},
+      {255, 80, 41, 61, 4},
+      {218, 44, 230, 199, 4},
+      {43, 201, 64, 175, 15}
+    },
+    { {58, 94, 143, 48, 4},
+      {82, 205, 238, 33, 8},
+      {32, 207, 23, 165, 12},
+      {24, 71, 123, 52, 10}
+    },
+    { {118, 217, 250, 167, 7},
+      {236, 222, 118, 149, 15},
+      {238, 85, 249, 182, 14},
+      {250, 150, 231, 179, 7}
+    },
+    { {100, 228, 234, 29, 15},
+      {173, 244, 245, 164, 4},
+      {251, 133, 114, 114, 6},
+      {34, 90, 242, 251, 5}
+    },
+    { {18, 167, 180, 52, 13},
+      {13, 139, 219, 49, 4},
+      {178, 194, 222, 84, 8},
+      {40, 205, 189, 27, 0}
+    },
+    { {73, 115, 217, 85, 3},
+      {127, 150, 140, 220, 0},
+      {202, 169, 188, 233, 2},
+      {3, 179, 22, 159, 14}
+    },
+    { {205, 180, 24, 151, 5},
+      {207, 0, 212, 246, 3},
+      {174, 145, 130, 219, 3},
+      {198, 242, 176, 15, 3}
+    },
+    { {139, 218, 118, 210, 14},
+      {98, 85, 217, 91, 15},
+      {116, 182, 229, 189, 1},
+      {253, 169, 186, 164, 6}
+    },
+    { {245, 74, 77, 236, 8},
+      {184, 45, 47, 202, 10},
+      {19, 123, 37, 42, 15},
+      {85, 63, 75, 65, 13}
+    },
+    { {129, 22, 22, 248, 10},
+      {64, 113, 139, 122, 2},
+      {81, 246, 134, 136, 1},
+      {69, 237, 24, 224, 2}
+    },
+    { {64, 54, 244, 230, 11},
+      {109, 145, 11, 184, 7},
+      {214, 114, 246, 192, 2},
+      {225, 221, 8, 155, 6}
+    },
+    { {39, 54, 40, 42, 6},
+      {193, 48, 110, 97, 5},
+      {101, 65, 70, 206, 4},
+      {168, 103, 96, 200, 3}
+    },
+    { {164, 19, 210, 41, 15},
+      {228, 242, 107, 22, 0},
+      {249, 68, 188, 130, 5},
+      {6, 141, 100, 242, 7}
+    },
+    { {144, 31, 228, 193, 7},
+      {100, 155, 72, 46, 14},
+      {232, 50, 127, 128, 9},
+      {119, 65, 45, 146, 6}
+    },
+    { {154, 191, 206, 86, 14},
+      {107, 219, 221, 43, 9},
+      {118, 167, 63, 213, 9},
+      {157, 75, 189, 189, 6}
+    },
+    { {45, 50, 91, 158, 15},
+      {255, 112, 237, 80, 3},
+      {247, 157, 164, 203, 4},
+      {192, 171, 112, 239, 15}
+    },
+    { {217, 144, 31, 106, 9},
+      {86, 105, 23, 218, 1},
+      {149, 111, 128, 153, 11},
+      {133, 190, 137, 102, 10}
+    },
+    { {58, 166, 79, 173, 14},
+      {59, 121, 127, 37, 2},
+      {123, 95, 38, 85, 12},
+      {74, 79, 233, 237, 12}
+    },
+    { {101, 40, 141, 96, 11},
+      {149, 145, 39, 200, 8},
+      {208, 107, 17, 74, 6},
+      {17, 62, 72, 154, 9}
+    },
+    { {10, 83, 233, 96, 11},
+      {118, 150, 15, 9, 4},
+      {208, 105, 124, 165, 0},
+      {41, 15, 6, 150, 14}
+    },
+    { {233, 224, 156, 62, 4},
+      {11, 165, 246, 210, 1},
+      {39, 195, 144, 121, 7},
+      {132, 182, 250, 93, 0}
+    },
+    { {77, 155, 120, 99, 13},
+      {230, 2, 95, 220, 13},
+      {188, 97, 237, 155, 2},
+      {179, 191, 164, 6, 7}
+    },
+    { {217, 139, 180, 131, 3},
+      {6, 155, 24, 214, 15},
+      {204, 18, 221, 25, 11},
+      {246, 177, 141, 150, 0}
+    },
+    { {52, 177, 129, 237, 7},
+      {221, 186, 114, 12, 2},
+      {235, 120, 24, 210, 12},
+      {67, 4, 229, 219, 11}
+    },
+    { {91, 55, 63, 73, 0},
+      {83, 107, 12, 253, 4},
+      {9, 47, 206, 205, 10},
+      {43, 243, 13, 108, 10}
+    },
+    { {133, 114, 183, 185, 1},
+      {213, 229, 138, 86, 6},
+      {137, 222, 212, 234, 1},
+      {102, 165, 26, 122, 11}
+    },
+    { {44, 93, 5, 106, 4},
+      {210, 39, 98, 40, 9},
+      {37, 106, 11, 163, 4},
+      {145, 68, 110, 68, 11}
+    },
+    { {228, 103, 18, 150, 13},
+      {141, 70, 233, 178, 3},
+      {182, 148, 142, 98, 7},
+      {196, 217, 118, 43, 1}
+    },
+    { {42, 8, 214, 247, 8},
+      {42, 193, 163, 29, 11},
+      {30, 246, 177, 5, 4},
+      {219, 140, 88, 53, 4}
+    },
+    { {69, 41, 73, 198, 1},
+      {189, 2, 4, 200, 11},
+      {134, 57, 41, 74, 2},
+      {209, 50, 4, 11, 13}
+    },
+    { {37, 1, 236, 91, 7},
+      {164, 179, 228, 76, 5},
+      {237, 163, 120, 10, 4},
+      {163, 34, 124, 210, 5}
+    },
+    { {184, 245, 71, 121, 12},
+      {115, 111, 243, 46, 0},
+      {57, 238, 42, 241, 13},
+      {7, 76, 255, 108, 14}
+    },
+    { {163, 183, 234, 75, 3},
+      {101, 242, 60, 111, 5},
+      {205, 37, 126, 220, 5},
+      {175, 99, 196, 250, 6}
+    },
+    { {68, 61, 107, 155, 4},
+      {241, 98, 196, 164, 15},
+      {45, 157, 107, 194, 2},
+      {242, 82, 52, 104, 15}
+    },
+    { {190, 45, 203, 132, 8},
+      {187, 202, 37, 35, 10},
+      {18, 29, 59, 71, 13},
+      {92, 74, 69, 61, 13}
+    },
+    { {181, 31, 196, 126, 12},
+      {232, 171, 235, 106, 9},
+      {55, 226, 63, 138, 13},
+      {149, 109, 125, 81, 7}
+    },
+    { {111, 56, 207, 152, 8},
+      {243, 225, 165, 193, 10},
+      {17, 159, 49, 207, 6},
+      {88, 58, 88, 124, 15}
+    },
+    { {144, 242, 254, 147, 4},
+      {97, 205, 220, 22, 7},
+      {44, 151, 244, 240, 9},
+      {230, 131, 187, 56, 6}
+    },
+    { {7, 253, 84, 10, 11},
+      {229, 55, 17, 113, 9},
+      {213, 2, 171, 254, 0},
+      {152, 232, 142, 202, 7}
+    },
+    { {238, 83, 195, 208, 8},
+      {242, 198, 169, 139, 2},
+      {16, 188, 60, 167, 7},
+      {77, 25, 86, 52, 15}
+    },
+    { {247, 9, 142, 188, 10},
+      {136, 251, 167, 195, 10},
+      {83, 215, 25, 14, 15},
+      {92, 62, 93, 241, 1}
+    },
+    { {101, 70, 124, 48, 9},
+      {164, 5, 175, 240, 4},
+      {144, 195, 230, 42, 6},
+      {32, 255, 90, 2, 5}
+    },
+    { {174, 111, 215, 151, 14},
+      {187, 215, 233, 55, 11},
+      {126, 158, 191, 103, 5},
+      {222, 201, 126, 189, 13}
+    },
+    { {139, 196, 115, 158, 9},
+      {62, 100, 145, 115, 7},
+      {151, 156, 226, 61, 1},
+      {236, 232, 146, 103, 12}
+    },
+    { {151, 25, 48, 254, 4},
+      {200, 42, 194, 91, 15},
+      {39, 240, 201, 142, 9},
+      {253, 164, 53, 65, 3}
+    },
+    { {154, 117, 45, 245, 7},
+      {95, 31, 198, 47, 6},
+      {234, 251, 74, 229, 9},
+      {111, 70, 63, 143, 10}
+    },
+    { {189, 71, 254, 83, 14},
+      {162, 223, 237, 126, 5},
+      {124, 167, 254, 43, 13},
+      {167, 235, 127, 180, 5}
+    },
+    { {111, 21, 48, 146, 8},
+      {194, 2, 161, 241, 7},
+      {20, 144, 202, 143, 6},
+      {232, 248, 84, 4, 3}
+    },
+    { {93, 225, 204, 72, 9},
+      {167, 175, 21, 200, 0},
+      {145, 35, 56, 123, 10},
+      {1, 58, 143, 94, 5}
+    },
+    { {17, 28, 227, 220, 13},
+      {124, 232, 193, 104, 14},
+      {179, 188, 115, 136, 8},
+      {113, 104, 49, 115, 14}
+    },
+    { {164, 199, 225, 87, 12},
+      {184, 134, 249, 46, 5},
+      {62, 168, 126, 50, 5},
+      {167, 73, 246, 17, 13}
+    },
+    { {85, 38, 145, 17, 2},
+      {145, 152, 136, 244, 0},
+      {72, 136, 150, 74, 10},
+      {2, 241, 17, 152, 9}
+    },
+    { {157, 101, 17, 128, 5},
+      {151, 14, 64, 114, 2},
+      {160, 24, 138, 107, 9},
+      {68, 224, 39, 14, 9}
+    },
+    { {102, 99, 193, 203, 3},
+      {181, 182, 40, 141, 3},
+      {205, 56, 60, 102, 6},
+      {203, 17, 70, 218, 13}
+    },
+    { {191, 197, 148, 0, 2},
+      {130, 159, 48, 115, 0},
+      {64, 2, 154, 63, 13},
+      {12, 224, 207, 148, 1}
+    },
+    { {58, 53, 0, 56, 7},
+      {71, 58, 226, 33, 0},
+      {225, 192, 10, 197, 12},
+      {8, 68, 117, 206, 2}
+    },
+    { {118, 212, 246, 121, 12},
+      {224, 237, 243, 189, 4},
+      {57, 230, 242, 182, 14},
+      {43, 220, 251, 112, 7}
+    },
+    { {68, 111, 38, 103, 11},
+      {141, 87, 11, 172, 13},
+      {222, 102, 79, 98, 2},
+      {179, 93, 14, 171, 1}
+    },
+    { {23, 174, 89, 233, 7},
+      {181, 56, 94, 125, 10},
+      {233, 121, 167, 94, 8},
+      {91, 231, 161, 202, 13}
+    },
+    { {54, 19, 45, 99, 14},
+      {208, 27, 111, 13, 5},
+      {124, 107, 76, 134, 12},
+      {171, 15, 109, 128, 11}
+    },
+    { {142, 7, 73, 43, 15},
+      {182, 50, 79, 39, 1},
+      {253, 73, 46, 7, 1},
+      {142, 79, 36, 198, 13}
+    },
+    { {24, 138, 205, 223, 1},
+      {62, 169, 156, 12, 11},
+      {143, 187, 53, 17, 8},
+      {211, 3, 153, 87, 12}
+    },
+    { {237, 144, 82, 208, 2},
+      {226, 80, 176, 218, 2},
+      {64, 180, 160, 155, 7},
+      {69, 176, 208, 164, 7}
+    },
+    { {91, 107, 208, 31, 5},
+      {47, 174, 200, 213, 9},
+      {175, 128, 189, 109, 10},
+      {154, 177, 55, 95, 4}
+    },
+    { {132, 164, 208, 112, 14},
+      {161, 144, 211, 58, 0},
+      {112, 224, 178, 82, 1},
+      {5, 204, 176, 152, 5}
+    },
+    { {201, 178, 163, 175, 4},
+      {91, 224, 90, 198, 7},
+      {47, 92, 84, 217, 3},
+      {230, 53, 160, 125, 10}
+    },
+    { {171, 24, 133, 47, 12},
+      {90, 161, 99, 71, 9},
+      {63, 74, 17, 141, 5},
+      {158, 44, 104, 85, 10}
+    },
+    { {157, 233, 24, 57, 0},
+      {131, 46, 150, 86, 8},
+      {9, 193, 137, 123, 9},
+      {22, 166, 151, 76, 1}
+    },
+    { {53, 118, 238, 158, 0},
+      {233, 237, 172, 96, 7},
+      {7, 151, 118, 234, 12},
+      {224, 99, 91, 121, 7}
+    },
+    { {232, 208, 13, 33, 0},
+      {82, 5, 54, 134, 0},
+      {8, 75, 0, 177, 7},
+      {6, 22, 202, 4, 10}
+    },
+    { {112, 155, 90, 149, 12},
+      {104, 74, 253, 148, 10},
+      {58, 149, 173, 144, 14},
+      {82, 155, 245, 33, 6}
+    },
+    { {169, 2, 42, 49, 4},
+      {2, 64, 238, 70, 4},
+      {40, 197, 68, 9, 5},
+      {38, 39, 112, 36, 0}
+    },
+    { {160, 62, 162, 185, 12},
+      {65, 224, 235, 38, 14},
+      {57, 212, 87, 192, 5},
+      {118, 77, 112, 120, 2}
+    },
+    { {30, 88, 158, 197, 14},
+      {202, 221, 69, 29, 10},
+      {122, 55, 145, 167, 8},
+      {91, 138, 43, 181, 3}
+    },
+    { {116, 71, 14, 237, 13},
+      {140, 111, 111, 172, 2},
+      {187, 119, 14, 34, 14},
+      {67, 95, 111, 99, 1}
+    },
+    { {54, 189, 68, 21, 9},
+      {237, 11, 177, 37, 8},
+      {154, 130, 43, 214, 12},
+      {26, 72, 221, 11, 7}
+    },
+    { {183, 248, 210, 81, 6},
+      {225, 220, 240, 95, 8},
+      {104, 164, 177, 254, 13},
+      {31, 160, 243, 184, 7}
+    },
+    { {220, 222, 75, 250, 5},
+      {246, 108, 222, 170, 11},
+      {165, 253, 39, 179, 11},
+      {213, 87, 179, 102, 15}
+    },
+    { {158, 218, 153, 195, 0},
+      {210, 140, 28, 31, 11},
+      {12, 57, 149, 183, 9},
+      {223, 131, 131, 20, 11}
+    },
+    { {143, 251, 152, 168, 11},
+      {199, 182, 31, 83, 10},
+      {209, 81, 157, 255, 1},
+      {92, 175, 134, 222, 3}
+    },
+    { {154, 199, 119, 231, 1},
+      {62, 79, 26, 63, 7},
+      {142, 126, 238, 53, 9},
+      {239, 197, 143, 39, 12}
+    },
+    { {141, 10, 83, 203, 3},
+      {182, 112, 8, 94, 11},
+      {205, 60, 165, 11, 1},
+      {215, 161, 0, 230, 13}
+    },
+    { {201, 237, 29, 206, 13},
+      {31, 39, 85, 250, 11},
+      {183, 59, 139, 121, 3},
+      {213, 250, 174, 79, 8}
+    },
+    { {194, 56, 83, 94, 10},
+      {121, 112, 129, 155, 9},
+      {87, 172, 161, 196, 3},
+      {157, 152, 16, 233, 14}
+    },
+    { {238, 74, 166, 67, 7},
+      {134, 213, 104, 143, 13},
+      {236, 38, 85, 39, 7},
+      {191, 17, 106, 182, 1}
+    },
+    { {205, 131, 69, 161, 14},
+      {178, 19, 91, 198, 2},
+      {120, 90, 44, 27, 3},
+      {70, 61, 172, 132, 13}
+    },
+    { {90, 25, 224, 90, 14},
+      {98, 186, 193, 137, 13},
+      {117, 160, 121, 133, 10},
+      {185, 24, 53, 212, 6}
+    },
+    { {150, 215, 128, 210, 5},
+      {196, 142, 216, 43, 3},
+      {164, 176, 30, 182, 9},
+      {205, 65, 183, 18, 3}
+    },
+    { {226, 200, 133, 24, 5},
+      {20, 165, 240, 131, 8},
+      {161, 138, 17, 52, 7},
+      {28, 16, 250, 82, 8}
+    },
+    { {197, 49, 79, 141, 11},
+      {253, 115, 5, 198, 2},
+      {219, 31, 40, 202, 3},
+      {70, 58, 12, 235, 15}
+    },
+    { {164, 124, 55, 238, 1},
+      {221, 101, 34, 58, 15},
+      {135, 126, 195, 226, 5},
+      {245, 196, 74, 107, 11}
+    },
+    { {29, 130, 198, 248, 12},
+      {162, 233, 219, 72, 2},
+      {49, 246, 52, 27, 8},
+      {65, 45, 185, 116, 5}
+    },
+    { {50, 92, 92, 108, 8},
+      {104, 45, 39, 57, 8},
+      {19, 99, 163, 164, 12},
+      {25, 206, 75, 65, 6}
+    },
+    { {93, 157, 27, 174, 0},
+      {218, 106, 22, 240, 11},
+      {7, 93, 139, 155, 10},
+      {208, 246, 133, 101, 11}
+    },
+    { {149, 73, 224, 117, 14},
+      {168, 158, 195, 78, 12},
+      {122, 224, 121, 42, 9},
+      {55, 44, 55, 145, 5}
+    },
+    { {138, 104, 69, 193, 5},
+      {55, 5, 64, 15, 10},
+      {168, 58, 33, 101, 1},
+      {95, 0, 42, 14, 12}
+    },
+    { {173, 249, 241, 15, 14},
+      {251, 182, 113, 86, 13},
+      {127, 8, 249, 251, 5},
+      {182, 168, 230, 221, 15}
+    },
+    { {149, 206, 243, 11, 0},
+      {176, 236, 24, 118, 13},
+      {13, 12, 247, 58, 9},
+      {182, 225, 131, 112, 13}
+    },
+    { {113, 147, 59, 32, 13},
+      {84, 74, 127, 208, 4},
+      {176, 77, 204, 152, 14},
+      {32, 191, 229, 34, 10}
+    },
+    { {31, 13, 227, 166, 15},
+      {190, 218, 67, 97, 15},
+      {246, 92, 123, 15, 8},
+      {248, 108, 37, 183, 13}
+    },
+    { {89, 111, 91, 186, 6},
+      {51, 126, 206, 240, 11},
+      {101, 221, 175, 105, 10},
+      {208, 247, 55, 236, 12}
+    },
+    { {205, 97, 217, 243, 4},
+      {179, 134, 198, 222, 3},
+      {44, 249, 184, 107, 3},
+      {199, 182, 54, 28, 13}
+    },
+    { {164, 120, 173, 50, 8},
+      {209, 133, 167, 2, 13},
+      {20, 203, 81, 226, 5},
+      {180, 14, 90, 24, 11}
+    },
+    { {218, 222, 64, 18, 15},
+      {102, 28, 217, 163, 9},
+      {244, 128, 39, 181, 11},
+      {156, 89, 179, 134, 6}
+    },
+    { {209, 87, 100, 55, 0},
+      {104, 15, 138, 230, 5},
+      {14, 194, 110, 168, 11},
+      {166, 117, 31, 1, 6}
+    },
+    { {58, 43, 245, 210, 2},
+      {51, 155, 168, 25, 15},
+      {68, 186, 253, 69, 12},
+      {249, 129, 93, 156, 12}
+    },
+    { {35, 3, 227, 72, 13},
+      {52, 226, 105, 73, 4},
+      {177, 44, 124, 12, 4},
+      {41, 41, 100, 114, 12}
+    },
+    { {65, 185, 191, 154, 9},
+      {85, 227, 149, 208, 15},
+      {149, 159, 217, 216, 2},
+      {240, 186, 156, 122, 10}
+    },
+    { {90, 78, 147, 238, 3},
+      {30, 252, 10, 185, 11},
+      {199, 124, 151, 37, 10},
+      {217, 213, 3, 247, 8}
+    },
+    { {70, 43, 68, 81, 2},
+      {161, 19, 136, 141, 8},
+      {72, 162, 45, 70, 2},
+      {27, 17, 28, 136, 5}
+    },
+    { {78, 1, 113, 156, 1},
+      {190, 34, 128, 145, 6},
+      {131, 152, 232, 7, 2},
+      {104, 144, 20, 71, 13}
+    },
+    { {115, 160, 217, 19, 7},
+      {53, 152, 244, 213, 1},
+      {236, 137, 176, 92, 14},
+      {138, 178, 241, 154, 12}
+    },
+    { {147, 43, 65, 109, 13},
+      {61, 42, 75, 79, 8},
+      {187, 104, 45, 76, 9},
+      {31, 45, 37, 75, 12}
+    },
+    { {255, 75, 97, 90, 7},
+      {182, 62, 232, 203, 13},
+      {229, 168, 109, 47, 15},
+      {189, 49, 119, 198, 13}
+    },
+    { {44, 136, 15, 26, 12},
+      {146, 97, 245, 0, 9},
+      {53, 143, 1, 19, 4},
+      {144, 10, 248, 100, 9}
+    },
+    { {111, 59, 182, 170, 1},
+      {199, 227, 42, 209, 15},
+      {133, 86, 221, 207, 6},
+      {248, 181, 76, 126, 3}
+    },
+    { {71, 109, 33, 174, 6},
+      {153, 54, 66, 225, 15},
+      {103, 88, 75, 110, 2},
+      {248, 116, 38, 201, 9}
+    },
+    { {249, 194, 144, 104, 8},
+      {2, 172, 59, 218, 0},
+      {17, 96, 148, 57, 15},
+      {5, 189, 195, 84, 0}
+    },
+    { {118, 129, 17, 33, 0},
+      {144, 10, 50, 149, 0},
+      {8, 72, 136, 22, 14},
+      {10, 148, 197, 0, 9}
+    },
+    { {98, 52, 88, 245, 5},
+      {109, 0, 230, 189, 2},
+      {170, 241, 162, 196, 6},
+      {75, 214, 112, 11, 6}
+    },
+    { {243, 25, 25, 225, 15},
+      {84, 26, 103, 223, 10},
+      {248, 121, 137, 140, 15},
+      {95, 190, 101, 130, 10}
+    },
+    { {239, 71, 167, 221, 1},
+      {158, 231, 168, 239, 6},
+      {139, 190, 94, 47, 7},
+      {111, 113, 94, 119, 9}
+    },
+    { {198, 199, 119, 128, 8},
+      {176, 71, 25, 179, 6},
+      {16, 30, 238, 54, 3},
+      {108, 217, 142, 32, 13}
+    },
+    { {238, 201, 111, 9, 6},
+      {178, 119, 116, 135, 12},
+      {105, 15, 105, 55, 7},
+      {62, 18, 238, 228, 13}
+    },
+    { {155, 60, 155, 218, 15},
+      {87, 248, 197, 123, 11},
+      {245, 189, 147, 205, 9},
+      {221, 234, 49, 254, 10}
+    },
+    { {111, 212, 50, 87, 3},
+      {206, 84, 176, 253, 5},
+      {206, 164, 194, 191, 6},
+      {171, 240, 210, 167, 3}
+    },
+    { {96, 231, 208, 170, 9},
+      {37, 166, 59, 176, 3},
+      {149, 80, 190, 112, 6},
+      {192, 221, 198, 90, 4}
+    },
+    { {6, 81, 205, 163, 4},
+      {240, 135, 70, 5, 3},
+      {44, 91, 56, 166, 0},
+      {202, 6, 46, 16, 15}
+    },
+    { {226, 172, 192, 78, 7},
+      {45, 176, 112, 171, 9},
+      {231, 32, 51, 84, 7},
+      {157, 80, 224, 219, 4}
+    },
+    { {148, 96, 209, 162, 2},
+      {177, 156, 2, 18, 3},
+      {68, 88, 176, 98, 9},
+      {196, 132, 3, 152, 13}
+    },
+    { {130, 183, 155, 23, 7},
+      {93, 210, 220, 55, 1},
+      {238, 141, 158, 212, 1},
+      {142, 195, 180, 187, 10}
+    },
+    { {78, 177, 137, 244, 11},
+      {223, 146, 151, 137, 2},
+      {210, 249, 24, 215, 2},
+      {73, 30, 148, 159, 11}
+    },
+    { {203, 249, 195, 177, 14},
+      {115, 214, 211, 199, 10},
+      {120, 220, 57, 253, 3},
+      {94, 60, 182, 188, 14}
+    },
+    { {111, 108, 100, 132, 1},
+      {175, 5, 32, 225, 14},
+      {130, 18, 99, 111, 6},
+      {120, 112, 74, 15, 5}
+    },
+    { {229, 78, 80, 162, 14},
+      {160, 20, 107, 242, 11},
+      {116, 80, 167, 42, 7},
+      {212, 253, 98, 128, 5}
+    },
+    { {99, 47, 48, 242, 3},
+      {5, 18, 170, 249, 15},
+      {196, 240, 207, 76, 6},
+      {249, 245, 84, 138, 0}
+    },
+    { {179, 187, 61, 230, 12},
+      {89, 11, 127, 91, 15},
+      {54, 123, 205, 220, 13},
+      {253, 175, 237, 9, 10}
+    },
+    { {99, 49, 245, 56, 3},
+      {117, 179, 162, 209, 4},
+      {193, 202, 248, 204, 6},
+      {40, 180, 92, 218, 14}
+    },
+    { {188, 161, 218, 254, 5},
+      {175, 234, 246, 26, 3},
+      {167, 245, 184, 83, 13},
+      {197, 134, 245, 127, 5}
+    },
+    { {209, 129, 108, 171, 9},
+      {36, 43, 23, 198, 7},
+      {157, 83, 104, 24, 11},
+      {230, 62, 141, 66, 4}
+    },
+    { {13, 132, 7, 172, 10},
+      {154, 113, 19, 96, 2},
+      {83, 94, 2, 27, 0},
+      {64, 108, 136, 229, 9}
+    },
+    { {121, 78, 29, 126, 5},
+      {30, 45, 238, 248, 9},
+      {167, 235, 135, 41, 14},
+      {145, 247, 123, 71, 8}
+    },
+    { {146, 222, 101, 68, 2},
+      {120, 29, 24, 43, 12},
+      {66, 42, 103, 180, 9},
+      {61, 65, 139, 129, 14}
+    },
+    { {101, 20, 151, 148, 9},
+      {220, 193, 161, 240, 2},
+      {146, 158, 146, 138, 6},
+      {64, 248, 88, 51, 11}
+    },
+    { {51, 247, 81, 113, 2},
+      {113, 30, 186, 125, 0},
+      {72, 232, 174, 252, 12},
+      {11, 229, 215, 136, 14}
+    },
+    { {60, 156, 233, 25, 5},
+      {246, 168, 244, 36, 12},
+      {169, 137, 115, 147, 12},
+      {50, 66, 241, 86, 15}
+    },
+    { {126, 203, 129, 215, 10},
+      {154, 158, 185, 141, 11},
+      {94, 184, 29, 55, 14},
+      {219, 25, 215, 149, 9}
+    },
+    { {237, 225, 64, 23, 8},
+      {171, 6, 177, 198, 1},
+      {30, 128, 40, 123, 7},
+      {134, 56, 214, 13, 5}
+    },
+    { {192, 155, 14, 226, 12},
+      {64, 67, 95, 138, 11},
+      {52, 119, 13, 144, 3},
+      {213, 31, 172, 32, 2}
+    },
+    { {20, 230, 31, 119, 4},
+      {153, 77, 222, 60, 1},
+      {46, 239, 134, 114, 8},
+      {131, 199, 187, 41, 9}
+    },
+    { {109, 51, 102, 73, 10},
+      {227, 115, 41, 204, 4},
+      {89, 38, 108, 203, 6},
+      {35, 57, 76, 236, 7}
+    },
+    { {134, 93, 208, 136, 0},
+      {224, 166, 0, 51, 10},
+      {1, 16, 187, 166, 1},
+      {92, 192, 6, 80, 7}
+    },
+    { {247, 33, 75, 251, 8},
+      {177, 106, 167, 207, 3},
+      {29, 253, 40, 78, 15},
+      {207, 62, 85, 104, 13}
+    },
+    { {216, 185, 194, 226, 2},
+      {99, 218, 18, 138, 11},
+      {68, 116, 57, 209, 11},
+      {213, 20, 133, 188, 6}
+    },
+    { {153, 167, 7, 55, 15},
+      {31, 91, 219, 102, 1},
+      {254, 206, 14, 89, 9},
+      {134, 109, 189, 175, 8}
+    },
+    { {192, 236, 249, 12, 9},
+      {61, 164, 21, 178, 12},
+      {147, 9, 243, 112, 3},
+      {52, 218, 130, 91, 12}
+    },
+    { {187, 139, 38, 224, 1},
+      {6, 75, 58, 75, 14},
+      {128, 118, 77, 29, 13},
+      {125, 37, 205, 38, 0}
+    },
+    { {5, 103, 143, 202, 12},
+      {145, 231, 77, 104, 3},
+      {53, 63, 30, 106, 0},
+      {193, 107, 46, 120, 9}
+    },
+    { {51, 180, 131, 131, 4},
+      {81, 200, 112, 101, 3},
+      {44, 28, 18, 220, 12},
+      {202, 96, 225, 56, 10}
+    },
+    { {235, 157, 132, 184, 3},
+      {70, 179, 178, 227, 10},
+      {193, 210, 27, 157, 7},
+      {92, 116, 220, 214, 2}
+    },
+    { {124, 162, 119, 234, 2},
+      {179, 121, 58, 152, 7},
+      {69, 126, 228, 83, 14},
+      {225, 149, 201, 236, 13}
+    },
+    { {2, 175, 95, 102, 11},
+      {61, 83, 31, 57, 9},
+      {214, 111, 175, 84, 0},
+      {153, 207, 140, 171, 12}
+    },
+    { {74, 103, 140, 18, 2},
+      {3, 151, 140, 161, 1},
+      {68, 131, 30, 101, 2},
+      {136, 83, 30, 156, 0}
+    },
+    { {18, 21, 146, 191, 3},
+      {76, 250, 130, 53, 3},
+      {207, 212, 154, 132, 8},
+      {202, 196, 21, 243, 2}
+    },
+    { {204, 130, 180, 140, 9},
+      {142, 161, 25, 146, 6},
+      {147, 18, 212, 19, 3},
+      {100, 153, 136, 87, 1}
+    },
+    { {119, 203, 233, 15, 12},
+      {184, 174, 125, 197, 13},
+      {63, 9, 125, 62, 14},
+      {186, 59, 231, 81, 13}
+    },
+    { {94, 247, 215, 147, 1},
+      {247, 207, 152, 181, 3},
+      {140, 158, 190, 247, 10},
+      {202, 209, 159, 62, 15}
+    },
+    { {17, 121, 71, 153, 5},
+      {117, 111, 192, 68, 10},
+      {169, 158, 41, 232, 8},
+      {82, 32, 63, 106, 14}
+    },
+    { {52, 77, 95, 151, 0},
+      {184, 79, 164, 52, 11},
+      {14, 159, 171, 34, 12},
+      {210, 194, 95, 33, 13}
+    },
+    { {223, 47, 18, 231, 2},
+      {139, 90, 10, 255, 11},
+      {78, 116, 143, 79, 11},
+      {223, 245, 5, 173, 1}
+    },
+    { {17, 66, 119, 179, 7},
+      {52, 93, 202, 84, 7},
+      {236, 222, 228, 40, 8},
+      {226, 165, 59, 162, 12}
+    },
+    { {11, 143, 167, 61, 5},
+      {30, 227, 218, 101, 12},
+      {171, 206, 95, 29, 0},
+      {58, 101, 188, 119, 8}
+    },
+    { {54, 225, 111, 66, 3},
+      {181, 95, 52, 9, 5},
+      {196, 47, 104, 118, 12},
+      {169, 2, 207, 170, 13}
+    },
+    { {5, 116, 2, 183, 14},
+      {201, 84, 195, 100, 3},
+      {126, 212, 2, 234, 0},
+      {194, 108, 50, 169, 3}
+    },
+    { {195, 66, 66, 58, 7},
+      {36, 116, 202, 195, 1},
+      {229, 196, 36, 44, 3},
+      {140, 53, 50, 226, 4}
+    },
+    { {117, 140, 52, 218, 11},
+      {132, 57, 177, 248, 15},
+      {213, 178, 195, 26, 14},
+      {241, 248, 217, 194, 1}
+    },
+    { {103, 220, 97, 97, 4},
+      {240, 4, 114, 237, 12},
+      {40, 104, 99, 190, 6},
+      {59, 116, 226, 0, 15}
+    },
+    { {41, 178, 34, 6, 8},
+      {75, 64, 57, 64, 5},
+      {22, 4, 68, 217, 4},
+      {160, 41, 192, 45, 2}
+    },
+    { {113, 1, 175, 15, 10},
+      {24, 251, 37, 196, 5},
+      {95, 15, 88, 8, 14},
+      {162, 58, 77, 241, 8}
+    },
+    { {84, 210, 43, 199, 5},
+      {220, 76, 92, 140, 7},
+      {174, 61, 68, 178, 10},
+      {227, 19, 163, 35, 11}
+    },
+    { {144, 139, 163, 175, 9},
+      {28, 234, 27, 6, 15},
+      {159, 92, 93, 16, 9},
+      {246, 13, 133, 115, 8}
+    },
+    { {235, 104, 201, 181, 1},
+      {63, 132, 166, 199, 10},
+      {138, 217, 49, 109, 7},
+      {94, 54, 82, 31, 12}
+    },
+    { {38, 5, 212, 66, 12},
+      {160, 131, 97, 57, 1},
+      {52, 34, 186, 6, 4},
+      {137, 200, 108, 16, 5}
+    },
+    { {106, 184, 139, 127, 4},
+      {91, 224, 246, 141, 9},
+      {47, 237, 17, 213, 6},
+      {155, 22, 240, 125, 10}
+    },
+    { {32, 124, 118, 87, 13},
+      {109, 69, 225, 60, 13},
+      {190, 166, 227, 224, 4},
+      {179, 200, 122, 43, 6}
+    },
+    { {55, 121, 64, 210, 0},
+      {225, 14, 160, 73, 11},
+      {4, 176, 41, 238, 12},
+      {217, 32, 87, 8, 7}
+    },
+    { {172, 46, 183, 123, 6},
+      {147, 241, 234, 62, 13},
+      {109, 238, 215, 67, 5},
+      {183, 197, 120, 252, 9}
+    },
+    { {62, 135, 49, 142, 12},
+      {154, 42, 121, 49, 7},
+      {55, 24, 206, 23, 12},
+      {232, 201, 229, 69, 9}
+    },
+    { {71, 175, 234, 26, 10},
+      {161, 242, 157, 225, 13},
+      {85, 133, 127, 94, 2},
+      {184, 123, 148, 248, 5}
+    },
+    { {70, 222, 53, 183, 4},
+      {216, 5, 218, 181, 15},
+      {46, 218, 199, 182, 2},
+      {250, 213, 186, 1, 11}
+    },
+    { {72, 163, 107, 161, 0},
+      {51, 66, 30, 132, 6},
+      {8, 93, 108, 81, 2},
+      {98, 23, 132, 44, 12}
+    },
+    { {240, 113, 21, 54, 11},
+      {93, 31, 163, 146, 1},
+      {214, 202, 136, 224, 15},
+      {132, 156, 95, 139, 10}
+    },
+    { {150, 63, 135, 237, 4},
+      {217, 235, 74, 47, 10},
+      {43, 126, 31, 198, 9},
+      {95, 69, 45, 121, 11}
+    },
+    { {216, 58, 185, 150, 5},
+      {95, 136, 204, 146, 15},
+      {166, 153, 213, 193, 11},
+      {244, 147, 49, 31, 10}
+    },
+    { {123, 46, 181, 160, 15},
+      {23, 153, 107, 241, 14},
+      {240, 90, 215, 77, 14},
+      {120, 253, 105, 158, 8}
+    },
+    { {182, 173, 250, 243, 2},
+      {161, 218, 182, 63, 15},
+      {76, 245, 251, 86, 13},
+      {255, 198, 213, 184, 5}
+    },
+    { {135, 224, 122, 78, 10},
+      {169, 116, 21, 91, 5},
+      {87, 37, 224, 126, 1},
+      {173, 170, 130, 233, 5}
+    },
+    { {123, 69, 24, 244, 14},
+      {10, 30, 231, 249, 2},
+      {114, 241, 138, 45, 14},
+      {73, 254, 119, 133, 0}
+    },
+    { {144, 100, 163, 115, 8},
+      {17, 204, 131, 46, 5},
+      {28, 236, 82, 96, 9},
+      {167, 76, 19, 56, 8}
+    },
+    { {60, 36, 44, 161, 2},
+      {131, 25, 38, 36, 6},
+      {72, 83, 66, 67, 12},
+      {98, 70, 73, 140, 1}
+    },
+    { {150, 178, 92, 74, 4},
+      {225, 41, 92, 27, 1},
+      {37, 35, 164, 214, 9},
+      {141, 131, 169, 72, 7}
+    },
+    { {139, 1, 216, 58, 12},
+      {34, 162, 199, 83, 1},
+      {53, 193, 184, 13, 1},
+      {140, 174, 52, 84, 4}
+    },
+    { {229, 28, 206, 178, 5},
+      {228, 193, 230, 226, 11},
+      {164, 215, 51, 138, 7},
+      {212, 118, 120, 50, 7}
+    },
+    { {72, 15, 88, 219, 0},
+      {34, 34, 140, 188, 11},
+      {13, 177, 175, 1, 2},
+      {211, 211, 20, 68, 4}
+    },
+    { {186, 226, 149, 134, 7},
+      {31, 157, 120, 19, 3},
+      {230, 26, 148, 117, 13},
+      {204, 129, 235, 159, 8}
+    },
+    { {137, 252, 15, 186, 0},
+      {83, 101, 150, 98, 11},
+      {5, 223, 3, 249, 1},
+      {212, 102, 154, 108, 10}
+    },
+    { {221, 6, 71, 94, 9},
+      {190, 105, 137, 234, 1},
+      {151, 174, 38, 11, 11},
+      {133, 121, 25, 103, 13}
+    },
+    { {247, 254, 70, 180, 12},
+      {233, 77, 251, 227, 10},
+      {50, 214, 39, 254, 15},
+      {92, 125, 251, 41, 7}
+    },
+    { {67, 206, 240, 38, 13},
+      {44, 132, 91, 241, 13},
+      {182, 64, 247, 60, 2},
+      {184, 253, 162, 19, 4}
+    },
+    { {99, 147, 88, 90, 2},
+      {96, 50, 188, 217, 1},
+      {69, 161, 172, 156, 6},
+      {137, 179, 212, 192, 6}
+    },
+    { {135, 180, 4, 69, 6},
+      {201, 17, 80, 111, 0},
+      {106, 34, 2, 222, 1},
+      {15, 96, 168, 137, 3}
+    },
+    { {79, 164, 124, 190, 10},
+      {171, 49, 151, 241, 7},
+      {87, 211, 226, 95, 2},
+      {232, 254, 152, 205, 5}
+    },
+    { {118, 25, 249, 85, 10},
+      {248, 154, 165, 157, 12},
+      {90, 169, 249, 134, 14},
+      {59, 154, 85, 145, 15}
+    },
+    { {81, 185, 161, 51, 0},
+      {81, 138, 146, 196, 13},
+      {12, 200, 89, 216, 10},
+      {178, 52, 149, 24, 10}
+    },
+    { {21, 51, 99, 124, 7},
+      {253, 122, 202, 72, 4},
+      {227, 236, 108, 202, 8},
+      {33, 37, 53, 235, 15}
+    },
+    { {117, 135, 169, 114, 10},
+      {144, 154, 191, 232, 5},
+      {84, 233, 94, 26, 14},
+      {161, 127, 213, 144, 9}
+    },
+    { {96, 222, 17, 98, 2},
+      {80, 20, 58, 184, 9},
+      {68, 104, 135, 176, 6},
+      {145, 213, 194, 128, 10}
+    },
+    { {125, 76, 230, 138, 14},
+      {162, 253, 97, 224, 15},
+      {117, 22, 115, 43, 14},
+      {240, 120, 107, 244, 5}
+    },
+    { {175, 19, 94, 129, 12},
+      {226, 67, 109, 87, 2},
+      {56, 23, 172, 143, 5},
+      {78, 171, 108, 36, 7}
+    },
+    { {49, 201, 182, 71, 12},
+      {8, 207, 113, 92, 13},
+      {62, 38, 217, 56, 12},
+      {179, 168, 239, 49, 0}
+    },
+    { {172, 67, 216, 21, 5},
+      {174, 134, 236, 22, 0},
+      {170, 129, 188, 35, 5},
+      {6, 131, 118, 23, 5}
+    },
+    { {216, 83, 225, 207, 11},
+      {126, 190, 9, 142, 7},
+      {223, 56, 124, 161, 11},
+      {231, 25, 7, 215, 14}
+    },
+    { {79, 205, 197, 207, 0},
+      {186, 167, 16, 237, 11},
+      {15, 58, 59, 63, 2},
+      {219, 112, 142, 85, 13}
+    },
+    { {238, 105, 111, 210, 13},
+      {183, 71, 229, 139, 15},
+      {180, 191, 105, 103, 7},
+      {253, 26, 126, 46, 13}
+    },
+    { {183, 22, 24, 71, 5},
+      {204, 8, 108, 127, 1},
+      {174, 33, 134, 142, 13},
+      {143, 227, 97, 3, 3}
+    },
+    { {185, 180, 184, 120, 1},
+      {71, 168, 182, 122, 4},
+      {129, 225, 210, 217, 13},
+      {37, 230, 209, 94, 2}
+    },
+    { {50, 133, 121, 80, 5},
+      {52, 10, 244, 57, 4},
+      {160, 169, 234, 20, 12},
+      {41, 194, 245, 2, 12}
+    },
+    { {149, 233, 71, 119, 1},
+      {189, 79, 146, 78, 9},
+      {142, 238, 41, 122, 9},
+      {151, 36, 159, 43, 13}
+    },
+    { {154, 160, 48, 46, 2},
+      {11, 56, 18, 19, 5},
+      {71, 64, 192, 85, 9},
+      {172, 132, 129, 205, 0}
+    },
+    { {236, 24, 40, 209, 7},
+      {198, 16, 228, 142, 14},
+      {232, 177, 65, 131, 7},
+      {119, 18, 112, 134, 3}
+    },
+    { {188, 80, 121, 99, 5},
+      {246, 12, 102, 30, 5},
+      {172, 105, 224, 163, 13},
+      {167, 134, 99, 6, 15}
+    },
+    { {135, 133, 193, 183, 9},
+      {188, 130, 147, 103, 3},
+      {158, 216, 58, 30, 1},
+      {206, 108, 148, 19, 13}
+    },
+    { {211, 122, 173, 183, 10},
+      {89, 157, 143, 199, 15},
+      {94, 219, 85, 236, 11},
+      {254, 63, 27, 153, 10}
+    },
+    { {129, 127, 2, 206, 0},
+      {73, 102, 8, 106, 11},
+      {7, 52, 15, 232, 1},
+      {213, 97, 6, 105, 2}
+    },
+    { {253, 99, 223, 176, 10},
+      {179, 223, 175, 210, 2},
+      {80, 223, 188, 107, 15},
+      {68, 191, 95, 188, 13}
+    },
+    { {81, 10, 193, 175, 2},
+      {56, 184, 10, 196, 11},
+      {79, 88, 53, 8, 10},
+      {210, 53, 1, 209, 12}
+    },
+    { {61, 30, 223, 141, 3},
+      {254, 249, 44, 116, 10},
+      {203, 31, 183, 139, 12},
+      {82, 227, 73, 247, 15}
+    },
+    { {244, 183, 58, 64, 2},
+      {193, 90, 60, 186, 4},
+      {64, 37, 206, 210, 15},
+      {37, 211, 197, 168, 3}
+    },
+    { {55, 215, 137, 233, 12},
+      {208, 174, 127, 109, 2},
+      {57, 121, 30, 190, 12},
+      {75, 111, 231, 80, 11}
+    },
+    { {143, 17, 199, 124, 10},
+      {250, 243, 131, 75, 0},
+      {83, 238, 56, 143, 1},
+      {13, 44, 28, 245, 15}
+    },
+    { {196, 189, 3, 107, 14},
+      {209, 114, 83, 174, 9},
+      {125, 108, 11, 210, 3},
+      {151, 92, 164, 232, 11}
+    },
+    { {125, 250, 153, 92, 9},
+      {223, 172, 189, 216, 8},
+      {147, 169, 149, 251, 14},
+      {17, 187, 211, 95, 11}
+    },
+    { {123, 20, 232, 37, 1},
+      {110, 136, 38, 229, 4},
+      {138, 65, 114, 141, 14},
+      {42, 118, 65, 23, 6}
+    },
+    { {202, 7, 14, 127, 4},
+      {10, 99, 206, 175, 1},
+      {47, 231, 14, 5, 3},
+      {143, 87, 60, 101, 0}
+    },
+    { {92, 34, 219, 205, 5},
+      {191, 232, 76, 156, 2},
+      {171, 61, 180, 67, 10},
+      {67, 147, 33, 127, 13}
+    },
+    { {160, 219, 114, 108, 8},
+      {104, 102, 59, 26, 12},
+      {19, 100, 237, 176, 5},
+      {53, 141, 198, 97, 6}
+    },
+    { {107, 119, 118, 222, 2},
+      {107, 119, 168, 249, 7},
+      {71, 182, 238, 237, 6},
+      {233, 241, 94, 237, 6}
+    },
+    { {128, 245, 142, 116, 8},
+      {73, 199, 151, 42, 0},
+      {18, 231, 26, 240, 1},
+      {5, 78, 158, 57, 2}
+    },
+    { {225, 172, 31, 244, 10},
+      {25, 81, 183, 250, 10},
+      {82, 255, 131, 88, 7},
+      {85, 254, 216, 169, 8}
+    },
+    { {27, 186, 234, 133, 12},
+      {107, 200, 93, 69, 14},
+      {58, 21, 117, 221, 8},
+      {122, 43, 161, 61, 6}
+    },
+    { {38, 172, 85, 127, 12},
+      {185, 33, 243, 61, 9},
+      {63, 234, 163, 86, 4},
+      {155, 204, 248, 73, 13}
+    },
+    { {229, 209, 239, 53, 7},
+      {252, 215, 246, 198, 4},
+      {234, 207, 120, 186, 7},
+      {38, 54, 254, 179, 15}
+    },
+    { {31, 41, 212, 225, 0},
+      {163, 139, 2, 93, 10},
+      {8, 114, 185, 79, 8},
+      {91, 164, 13, 28, 5}
+    },
+    { {69, 159, 187, 21, 11},
+      {220, 210, 157, 244, 12},
+      {218, 141, 223, 154, 2},
+      {50, 251, 148, 179, 11}
+    },
+    { {212, 176, 73, 85, 9},
+      {253, 8, 149, 142, 0},
+      {154, 169, 32, 210, 11},
+      {7, 26, 145, 11, 15}
+    },
+    { {108, 183, 10, 207, 8},
+      {203, 98, 61, 172, 3},
+      {31, 53, 14, 211, 6},
+      {195, 91, 196, 109, 3}
+    },
+    { {248, 97, 122, 81, 8},
+      {35, 78, 165, 158, 4},
+      {24, 165, 232, 97, 15},
+      {39, 154, 87, 44, 4}
+    },
+    { {195, 145, 218, 195, 4},
+      {96, 194, 84, 223, 3},
+      {44, 53, 184, 156, 3},
+      {207, 178, 164, 48, 6}
+    },
+    { {81, 35, 94, 44, 12},
+      {41, 107, 79, 208, 0},
+      {51, 71, 172, 72, 10},
+      {0, 191, 45, 105, 4}
+    },
+    { {116, 64, 124, 79, 14},
+      {168, 61, 101, 156, 5},
+      {127, 35, 224, 34, 14},
+      {163, 154, 107, 193, 5}
+    },
+    { {223, 22, 9, 162, 4},
+      {210, 8, 78, 227, 3},
+      {36, 89, 6, 143, 11},
+      {204, 119, 33, 4, 11}
+    },
+    { {206, 210, 125, 193, 7},
+      {246, 21, 92, 159, 6},
+      {232, 59, 228, 183, 3},
+      {111, 147, 170, 134, 15}
+    }
+};
+
+}//namespace
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/unionfind.hpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/unionfind.hpp
new file mode 100644
index 0000000..f7a2d6a
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/unionfind.hpp
@@ -0,0 +1,131 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_UNIONFIND_HPP_
+#define _OPENCV_UNIONFIND_HPP_
+
+namespace cv {
+namespace aruco {
+
+struct UnionFind {
+    UnionFind(uint32_t _maxid)
+    {
+        maxid = _maxid;
+        data.resize(maxid+1);
+        for (unsigned int i = 0; i <= maxid; i++) {
+            data[i].size = 1;
+            data[i].parent = i;
+        }
+    };
+
+    inline uint32_t get_representative(uint32_t id) {
+        uint32_t root = id;
+
+        // chase down the root
+        while (data[root].parent != root) {
+            root = data[root].parent;
+        }
+
+        // go back and collapse the tree.
+        //
+        // XXX: on some of our workloads that have very shallow trees
+        // (e.g. image segmentation), we are actually faster not doing
+        // this...
+        while (data[id].parent != root) {
+            uint32_t tmp = data[id].parent;
+            data[id].parent = root;
+            id = tmp;
+        }
+
+        return root;
+    }
+
+    inline uint32_t get_set_size(uint32_t id) {
+        uint32_t repid = get_representative(id);
+        return data[repid].size;
+    }
+
+    inline uint32_t connect(uint32_t aid, uint32_t bid) {
+        uint32_t aroot = get_representative(aid);
+        uint32_t broot = get_representative(bid);
+
+        if (aroot == broot)
+            return aroot;
+
+        // we don't perform "union by rank", but we perform a similar
+        // operation (but probably without the same asymptotic guarantee):
+        // We join trees based on the number of *elements* (as opposed to
+        // rank) contained within each tree. I.e., we use size as a proxy
+        // for rank.  In my testing, it's often *faster* to use size than
+        // rank, perhaps because the rank of the tree isn't that critical
+        // if there are very few nodes in it.
+        uint32_t asize = data[aroot].size;
+        uint32_t bsize = data[broot].size;
+
+        // optimization idea: We could shortcut some or all of the tree
+        // that is grafted onto the other tree. Pro: those nodes were just
+        // read and so are probably in cache. Con: it might end up being
+        // wasted effort -- the tree might be grafted onto another tree in
+        // a moment!
+        if (asize > bsize) {
+            data[broot].parent = aroot;
+            data[aroot].size += bsize;
+            return aroot;
+        } else {
+            data[aroot].parent = broot;
+            data[broot].size += asize;
+            return broot;
+        }
+    }
+
+    #define DO_UNIONFIND(dx, dy) if (im.data[y*s + dy*s + x + dx] == v) connect(y*w + x, y*w + dy*w + x + dx);
+    void do_line(Mat &im, int w, int s, int y) {
+        CV_Assert(y+1 < im.rows);
+        CV_Assert(!im.empty());
+
+        for (int x = 1; x < w - 1; x++) {
+            uint8_t v = im.data[y*s + x];
+
+            if (v == 127)
+                continue;
+
+            // (dx,dy) pairs for 8 connectivity:
+            //          (REFERENCE) (1, 0)
+            // (-1, 1)    (0, 1)    (1, 1)
+            //
+            DO_UNIONFIND(1, 0);
+            DO_UNIONFIND(0, 1);
+            if (v == 255) {
+                DO_UNIONFIND(-1, 1);
+                DO_UNIONFIND(1, 1);
+            }
+        }
+    }
+    #undef DO_UNIONFIND
+
+    struct ufrec {
+        // the parent of this node. If a node's parent is its own index,
+        // then it is a root.
+        uint32_t parent;
+
+        // for the root of a connected component, the number of components
+        // connected to it. For intermediate values, it's not meaningful.
+        uint32_t size;
+    };
+
+    uint32_t maxid;
+    std::vector<ufrec> data;
+};
+
+}}
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/zarray.hpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zarray.hpp
new file mode 100644
index 0000000..4c05c92
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zarray.hpp
@@ -0,0 +1,148 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZARRAY_HPP_
+#define _OPENCV_ZARRAY_HPP_
+
+
+namespace cv {
+namespace aruco {
+
+
+struct sQuad{
+    float p[4][2]; // corners
+};
+
+/**
+ * Defines a structure which acts as a resize-able array ala Java's ArrayList.
+ */
+typedef struct zarray zarray_t;
+struct zarray{
+    size_t el_sz; // size of each element
+
+    int size; // how many elements?
+    int alloc; // we've allocated storage for how many elements?
+    char *data;
+};
+
+/**
+ * Creates and returns a variable array structure capable of holding elements of
+ * the specified size. It is the caller's responsibility to call zarray_destroy()
+ * on the returned array when it is no longer needed.
+ */
+inline static zarray_t *_zarray_create(size_t el_sz){
+    zarray_t *za = (zarray_t*) calloc(1, sizeof(zarray_t));
+    za->el_sz = el_sz;
+    return za;
+}
+
+/**
+ * Frees all resources associated with the variable array structure which was
+ * created by zarray_create(). After calling, 'za' will no longer be valid for storage.
+ */
+inline static void _zarray_destroy(zarray_t *za){
+    if (za == NULL)
+        return;
+
+    if (za->data != NULL)
+        free(za->data);
+    memset(za, 0, sizeof(zarray_t));
+    free(za);
+}
+
+/**
+ * Retrieves the number of elements currently being contained by the passed
+ * array, which may be different from its capacity. The index of the last element
+ * in the array will be one less than the returned value.
+ */
+inline static int _zarray_size(const zarray_t *za){
+    return za->size;
+}
+
+/**
+ * Allocates enough internal storage in the supplied variable array structure to
+ * guarantee that the supplied number of elements (capacity) can be safely stored.
+ */
+inline static void _zarray_ensure_capacity(zarray_t *za, int capacity){
+    if (capacity <= za->alloc)
+        return;
+
+    while (za->alloc < capacity) {
+        za->alloc *= 2;
+        if (za->alloc < 8)
+            za->alloc = 8;
+    }
+
+    za->data = (char*) realloc(za->data, za->alloc * za->el_sz);
+}
+
+/**
+ * Adds a new element to the end of the supplied array, and sets its value
+ * (by copying) from the data pointed to by the supplied pointer 'p'.
+ * Automatically ensures that enough storage space is available for the new element.
+ */
+inline static void _zarray_add(zarray_t *za, const void *p){
+    _zarray_ensure_capacity(za, za->size + 1);
+
+    memcpy(&za->data[za->size*za->el_sz], p, za->el_sz);
+    za->size++;
+}
+
+/**
+ * Retrieves the element from the supplied array located at the zero-based
+ * index of 'idx' and copies its value into the variable pointed to by the pointer
+ * 'p'.
+ */
+inline static void _zarray_get(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    memcpy(p, &za->data[idx*za->el_sz], za->el_sz);
+}
+
+/**
+ * Similar to zarray_get(), but returns a "live" pointer to the internal
+ * storage, avoiding a memcpy. This pointer is not valid across
+ * operations which might move memory around (i.e. zarray_remove_value(),
+ * zarray_remove_index(), zarray_insert(), zarray_sort(), zarray_clear()).
+ * 'p' should be a pointer to the pointer which will be set to the internal address.
+ */
+inline static void _zarray_get_volatile(const zarray_t *za, int idx, void *p){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    *((void**) p) = &za->data[idx*za->el_sz];
+}
+
+inline static void _zarray_truncate(zarray_t *za, int sz){
+    za->size = sz;
+}
+
+/**
+ * Sets the value of the current element at index 'idx' by copying its value from
+ * the data pointed to by 'p'. The previous value of the changed element will be
+ * copied into the data pointed to by 'outp' if it is not null.
+ */
+static inline void _zarray_set(zarray_t *za, int idx, const void *p, void *outp){
+    CV_DbgAssert(idx >= 0);
+    CV_DbgAssert(idx < za->size);
+
+    if (outp != NULL)
+        memcpy(outp, &za->data[idx*za->el_sz], za->el_sz);
+
+    memcpy(&za->data[idx*za->el_sz], p, za->el_sz);
+}
+
+}
+}
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp
new file mode 100644
index 0000000..5e7ca49
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.cpp
@@ -0,0 +1,206 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+
+#include "../../precomp.hpp"
+#include "zmaxheap.hpp"
+
+
+//                 0
+//         1               2
+//      3     4        5       6
+//     7 8   9 10    11 12   13 14
+//
+// Children of node i:  2*i+1, 2*i+2
+// Parent of node i: (i-1) / 2
+//
+// Heap property: a parent is greater than (or equal to) its children.
+
+#define MIN_CAPACITY 16
+namespace cv {
+namespace aruco {
+struct zmaxheap
+{
+    size_t el_sz;
+
+    int size;
+    int alloc;
+
+    float *values;
+    char *data;
+
+    void (*swap)(zmaxheap_t *heap, int a, int b);
+};
+
+static inline void _swap_default(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    cv::AutoBuffer<char> tmp(heap->el_sz);
+    memcpy(tmp.data(), &heap->data[a*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[a*heap->el_sz], &heap->data[b*heap->el_sz], heap->el_sz);
+    memcpy(&heap->data[b*heap->el_sz], tmp.data(), heap->el_sz);
+}
+
+static inline void _swap_pointer(zmaxheap_t *heap, int a, int b)
+{
+    float t = heap->values[a];
+    heap->values[a] = heap->values[b];
+    heap->values[b] = t;
+
+    void **pp = (void**) heap->data;
+    void *tmp = pp[a];
+    pp[a] = pp[b];
+    pp[b] = tmp;
+}
+
+
+zmaxheap_t *zmaxheap_create(size_t el_sz)
+{
+    zmaxheap_t *heap = (zmaxheap_t*)calloc(1, sizeof(zmaxheap_t));
+    heap->el_sz = el_sz;
+
+    heap->swap = _swap_default;
+
+    if (el_sz == sizeof(void*))
+        heap->swap = _swap_pointer;
+
+    return heap;
+}
+
+void zmaxheap_destroy(zmaxheap_t *heap)
+{
+    free(heap->values);
+    free(heap->data);
+    free(heap);
+}
+
+static void _zmaxheap_ensure_capacity(zmaxheap_t *heap, int capacity)
+{
+    if (heap->alloc >= capacity)
+        return;
+
+    int newcap = heap->alloc;
+
+    while (newcap < capacity) {
+        if (newcap < MIN_CAPACITY) {
+            newcap = MIN_CAPACITY;
+            continue;
+        }
+
+        newcap *= 2;
+    }
+
+    heap->values = (float*)realloc(heap->values, newcap * sizeof(float));
+    heap->data = (char*)realloc(heap->data, newcap * heap->el_sz);
+    heap->alloc = newcap;
+}
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v)
+{
+    _zmaxheap_ensure_capacity(heap, heap->size + 1);
+
+    int idx = heap->size;
+
+    heap->values[idx] = v;
+    memcpy(&heap->data[idx*heap->el_sz], p, heap->el_sz);
+
+    heap->size++;
+
+    while (idx > 0) {
+
+        int parent = (idx - 1) / 2;
+
+        // we're done!
+        if (heap->values[parent] >= v)
+            break;
+
+        // else, swap and recurse upwards.
+        heap->swap(heap, idx, parent);
+        idx = parent;
+    }
+}
+
+// Removes the item in the heap at the given index.  Returns 1 if the
+// item existed. 0 Indicates an invalid idx (heap is smaller than
+// idx). This is mostly intended to be used by zmaxheap_remove_max.
+static int zmaxheap_remove_index(zmaxheap_t *heap, int idx, void *p, float *v)
+{
+    if (idx >= heap->size)
+        return 0;
+
+    // copy out the requested element from the heap.
+    if (v != NULL)
+        *v = heap->values[idx];
+    if (p != NULL)
+        memcpy(p, &heap->data[idx*heap->el_sz], heap->el_sz);
+
+    heap->size--;
+
+    // If this element is already the last one, then there's nothing
+    // for us to do.
+    if (idx == heap->size)
+        return 1;
+
+    // copy last element to first element. (which probably upsets
+    // the heap property).
+    heap->values[idx] = heap->values[heap->size];
+    memcpy(&heap->data[idx*heap->el_sz], &heap->data[heap->el_sz * heap->size], heap->el_sz);
+
+    // now fix the heap. Note, as we descend, we're "pushing down"
+    // the same node the entire time. Thus, while the index of the
+    // parent might change, the parent_score doesn't.
+    int parent = idx;
+    float parent_score = heap->values[idx];
+
+    // descend, fixing the heap.
+    while (parent < heap->size) {
+
+        int left = 2*parent + 1;
+        int right = left + 1;
+
+//            assert(parent_score == heap->values[parent]);
+
+        float left_score = (left < heap->size) ? heap->values[left] : -INFINITY;
+        float right_score = (right < heap->size) ? heap->values[right] : -INFINITY;
+
+        // put the biggest of (parent, left, right) as the parent.
+
+        // already okay?
+        if (parent_score >= left_score && parent_score >= right_score)
+            break;
+
+        // if we got here, then one of the children is bigger than the parent.
+        if (left_score >= right_score) {
+            CV_Assert(left < heap->size);
+            heap->swap(heap, parent, left);
+            parent = left;
+        } else {
+            // right_score can't be less than left_score if right_score is -INFINITY.
+            CV_Assert(right < heap->size);
+            heap->swap(heap, parent, right);
+            parent = right;
+        }
+    }
+
+    return 1;
+}
+
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v)
+{
+    return zmaxheap_remove_index(heap, 0, p, v);
+}
+
+}}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.hpp b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.hpp
new file mode 100644
index 0000000..7d3fbc0
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/apriltag/zmaxheap.hpp
@@ -0,0 +1,38 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2013-2016, The Regents of The University of Michigan.
+//
+// This software was developed in the APRIL Robotics Lab under the
+// direction of Edwin Olson, ebolson@umich.edu. This software may be
+// available under alternative licensing terms; contact the address above.
+//
+// The views and conclusions contained in the software and documentation are those
+// of the authors and should not be interpreted as representing official policies,
+// either expressed or implied, of the Regents of The University of Michigan.
+#ifndef _OPENCV_ZMAXHEAP_HPP_
+#define _OPENCV_ZMAXHEAP_HPP_
+
+namespace cv {
+namespace aruco {
+typedef struct zmaxheap zmaxheap_t;
+
+typedef struct zmaxheap_iterator zmaxheap_iterator_t;
+struct zmaxheap_iterator {
+    zmaxheap_t *heap;
+    int in, out;
+};
+
+zmaxheap_t *zmaxheap_create(size_t el_sz);
+
+void zmaxheap_destroy(zmaxheap_t *heap);
+
+void zmaxheap_add(zmaxheap_t *heap, void *p, float v);
+
+// returns 0 if the heap is empty, so you can do
+// while (zmaxheap_remove_max(...)) { }
+int zmaxheap_remove_max(zmaxheap_t *heap, void *p, float *v);
+
+}}
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp b/upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp
new file mode 100644
index 0000000..0c613fd
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/aruco_board.cpp
@@ -0,0 +1,644 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include <opencv2/core/utils/logger.hpp>
+#include "opencv2/objdetect/aruco_board.hpp"
+
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+#include <numeric>
+
+namespace cv {
+namespace aruco {
+using namespace std;
+
+struct Board::Impl {
+    Dictionary dictionary;
+    std::vector<int> ids;
+    std::vector<std::vector<Point3f> > objPoints;
+    Point3f rightBottomBorder;
+
+    explicit Impl(const Dictionary& _dictionary):
+        dictionary(_dictionary)
+    {}
+
+    virtual ~Impl() {}
+
+    Impl(const Impl&) = delete;
+    Impl& operator=(const Impl&) = delete;
+
+    virtual void matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray _objPoints,
+                                  OutputArray imgPoints) const;
+
+    virtual void generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const;
+};
+
+void Board::Impl::matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray _objPoints,
+                                   OutputArray imgPoints) const {
+    CV_Assert(detectedIds.total() == detectedCorners.total());
+    CV_Assert(detectedIds.total() > 0ull);
+    CV_Assert(detectedCorners.depth() == CV_32F);
+
+    size_t nDetectedMarkers = detectedIds.total();
+
+    vector<Point3f> objPnts;
+    objPnts.reserve(nDetectedMarkers);
+
+    vector<Point2f> imgPnts;
+    imgPnts.reserve(nDetectedMarkers);
+
+    // look for detected markers that belong to the board and get their information
+    Mat detectedIdsMat = detectedIds.getMat();
+    vector<Mat> detectedCornersVecMat;
+
+    detectedCorners.getMatVector(detectedCornersVecMat);
+    CV_Assert((int)detectedCornersVecMat.front().total()*detectedCornersVecMat.front().channels() == 8);
+
+    for(unsigned int i = 0; i < nDetectedMarkers; i++) {
+        int currentId = detectedIdsMat.at<int>(i);
+        for(unsigned int j = 0; j < ids.size(); j++) {
+            if(currentId == ids[j]) {
+                for(int p = 0; p < 4; p++) {
+                    objPnts.push_back(objPoints[j][p]);
+                    imgPnts.push_back(detectedCornersVecMat[i].ptr<Point2f>(0)[p]);
+                }
+            }
+        }
+    }
+
+    // create output
+    Mat(objPnts).copyTo(_objPoints);
+    Mat(imgPnts).copyTo(imgPoints);
+}
+
+void Board::Impl::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(!outSize.empty());
+    CV_Assert(marginSize >= 0);
+
+    img.create(outSize, CV_8UC1);
+    Mat out = img.getMat();
+    out.setTo(Scalar::all(255));
+    out.adjustROI(-marginSize, -marginSize, -marginSize, -marginSize);
+
+    // calculate max and min values in XY plane
+    CV_Assert(objPoints.size() > 0);
+    float minX, maxX, minY, maxY;
+    minX = maxX = objPoints[0][0].x;
+    minY = maxY = objPoints[0][0].y;
+
+    for(unsigned int i = 0; i < objPoints.size(); i++) {
+        for(int j = 0; j < 4; j++) {
+            minX = min(minX, objPoints[i][j].x);
+            maxX = max(maxX, objPoints[i][j].x);
+            minY = min(minY, objPoints[i][j].y);
+            maxY = max(maxY, objPoints[i][j].y);
+        }
+    }
+
+    float sizeX = maxX - minX;
+    float sizeY = maxY - minY;
+
+    // now paint each marker
+    Mat marker;
+    Point2f outCorners[3];
+    Point2f inCorners[3];
+    for(unsigned int m = 0; m < objPoints.size(); m++) {
+        // transform corners to markerZone coordinates
+        for(int j = 0; j < 3; j++) {
+            Point2f pf = Point2f(objPoints[m][j].x, objPoints[m][j].y);
+            // move top left to 0, 0
+            pf -= Point2f(minX, minY);
+            pf.x = pf.x / sizeX * float(out.cols);
+            pf.y = pf.y / sizeY * float(out.rows);
+            outCorners[j] = pf;
+        }
+
+        // get marker
+        Point2f vecWidth  = outCorners[1] - outCorners[0];
+        float width = (float)cv::norm(vecWidth);
+
+        Point2f vecHeight = outCorners[2] - outCorners[0];
+        float height = (float)cv::norm(vecHeight);
+
+        Size dst_sz(cvRound(width), cvRound(height));
+        dst_sz.width = dst_sz.height = std::min(dst_sz.width, dst_sz.height); //marker should be square
+        dictionary.generateImageMarker(ids[m], dst_sz.width, marker, borderBits);
+
+        if((outCorners[0].y == outCorners[1].y) && (outCorners[1].x == outCorners[2].x)) {
+            // marker is aligned to image axes
+            marker.copyTo(out(Rect(outCorners[0], dst_sz)));
+            continue;
+        }
+
+        // interpolate tiny marker to marker position in markerZone
+        inCorners[0] = Point2f(-0.5f, -0.5f);
+        inCorners[1] = Point2f(marker.cols - 0.5f, -0.5f);
+        inCorners[2] = Point2f(marker.cols - 0.5f, marker.rows - 0.5f);
+
+        // remove perspective
+        Mat transformation = getAffineTransform(inCorners, outCorners);
+        warpAffine(marker, out, transformation, out.size(), INTER_LINEAR,
+                        BORDER_TRANSPARENT);
+    }
+}
+
+Board::Board(const Ptr<Impl>& _impl):
+    impl(_impl)
+{
+    CV_Assert(impl);
+}
+
+Board::Board():
+    impl(nullptr)
+{}
+
+Board::Board(InputArrayOfArrays objPoints, const Dictionary &dictionary, InputArray ids):
+    Board(new Board::Impl(dictionary)) {
+    CV_Assert(objPoints.total() == ids.total());
+    CV_Assert(objPoints.type() == CV_32FC3 || objPoints.type() == CV_32FC1);
+
+    vector<vector<Point3f> > obj_points_vector;
+    Point3f rightBottomBorder = Point3f(0.f, 0.f, 0.f);
+    for (unsigned int i = 0; i < objPoints.total(); i++) {
+        vector<Point3f> corners;
+        Mat corners_mat = objPoints.getMat(i);
+
+        if (corners_mat.type() == CV_32FC1)
+            corners_mat = corners_mat.reshape(3);
+        CV_Assert(corners_mat.total() == 4);
+
+        for (int j = 0; j < 4; j++) {
+            const Point3f &corner = corners_mat.at<Point3f>(j);
+            corners.push_back(corner);
+            rightBottomBorder.x = std::max(rightBottomBorder.x, corner.x);
+            rightBottomBorder.y = std::max(rightBottomBorder.y, corner.y);
+            rightBottomBorder.z = std::max(rightBottomBorder.z, corner.z);
+        }
+        obj_points_vector.push_back(corners);
+    }
+
+    ids.copyTo(impl->ids);
+    impl->objPoints = obj_points_vector;
+    impl->rightBottomBorder = rightBottomBorder;
+}
+
+const Dictionary& Board::getDictionary() const {
+    CV_Assert(this->impl);
+    return this->impl->dictionary;
+}
+
+const vector<vector<Point3f> >& Board::getObjPoints() const {
+    CV_Assert(this->impl);
+    return this->impl->objPoints;
+}
+
+const Point3f& Board::getRightBottomCorner() const {
+    CV_Assert(this->impl);
+    return this->impl->rightBottomBorder;
+}
+
+const vector<int>& Board::getIds() const {
+    CV_Assert(this->impl);
+    return this->impl->ids;
+}
+
+/** @brief Implementation of draw planar board that accepts a raw Board pointer.
+ */
+void Board::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(this->impl);
+    impl->generateImage(outSize, img, marginSize, borderBits);
+}
+
+void Board::matchImagePoints(InputArrayOfArrays detectedCorners, InputArray detectedIds, OutputArray objPoints,
+                             OutputArray imgPoints) const {
+    CV_Assert(this->impl);
+    impl->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints);
+}
+
+struct GridBoardImpl : public Board::Impl {
+    GridBoardImpl(const Dictionary& _dictionary, const Size& _size, float _markerLength, float _markerSeparation):
+        Board::Impl(_dictionary),
+        size(_size),
+        markerLength(_markerLength),
+        markerSeparation(_markerSeparation),
+        legacyPattern(false)
+    {
+        CV_Assert(size.width*size.height > 0 && markerLength > 0 && markerSeparation > 0);
+    }
+
+    // number of markers in X and Y directions
+    const Size size;
+    // marker side length (normally in meters)
+    float markerLength;
+    // separation between markers in the grid
+    float markerSeparation;
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
+};
+
+GridBoard::GridBoard() {}
+
+GridBoard::GridBoard(const Size& size, float markerLength, float markerSeparation,
+                     const Dictionary &dictionary, InputArray ids):
+    Board(new GridBoardImpl(dictionary, size, markerLength, markerSeparation)) {
+    float onePin = markerLength / ((float)(dictionary.markerSize+2));
+    if (markerSeparation < onePin*.7f) {
+        CV_LOG_WARNING(NULL, "Marker border " << markerSeparation << " is less than 70% of ArUco pin size "
+            << onePin << ". Please increase markerSeparation or decrease markerLength for stable board detection");
+    }
+    size_t totalMarkers = (size_t) size.width*size.height;
+    CV_Assert(ids.empty() || totalMarkers == ids.total());
+    vector<vector<Point3f> > objPoints;
+    objPoints.reserve(totalMarkers);
+
+    if(!ids.empty()) {
+        ids.copyTo(impl->ids);
+    } else {
+        impl->ids = std::vector<int>(totalMarkers);
+        std::iota(impl->ids.begin(), impl->ids.end(), 0);
+    }
+
+    // calculate Board objPoints
+    for (int y = 0; y < size.height; y++) {
+        for (int x = 0; x < size.width; x++) {
+            vector <Point3f> corners(4);
+            corners[0] = Point3f(x * (markerLength + markerSeparation),
+                                 y * (markerLength + markerSeparation), 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, markerLength, 0);
+            objPoints.push_back(corners);
+        }
+    }
+    impl->objPoints = objPoints;
+    impl->rightBottomBorder = Point3f(size.width * markerLength + markerSeparation * (size.width - 1),
+                                           size.height * markerLength + markerSeparation * (size.height - 1), 0.f);
+}
+
+Size GridBoard::getGridSize() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->size;
+}
+
+float GridBoard::getMarkerLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->markerLength;
+}
+
+float GridBoard::getMarkerSeparation() const {
+    CV_Assert(impl);
+    return static_pointer_cast<GridBoardImpl>(impl)->markerSeparation;
+}
+
+struct CharucoBoardImpl : Board::Impl {
+    CharucoBoardImpl(const Dictionary& _dictionary, const Size& _size, float _squareLength, float _markerLength):
+        Board::Impl(_dictionary),
+        size(_size),
+        squareLength(_squareLength),
+        markerLength(_markerLength),
+        legacyPattern(false)
+    {}
+
+    // chessboard size
+    Size size;
+
+    // Physical size of chessboard squares side (normally in meters)
+    float squareLength;
+
+    // Physical marker side length (normally in meters)
+    float markerLength;
+
+    // set pre4.6.0 chessboard pattern behavior (even row count patterns have a white box in the upper left corner)
+    bool legacyPattern;
+
+    // vector of chessboard 3D corners precalculated
+    std::vector<Point3f> chessboardCorners;
+
+    // for each charuco corner, nearest marker index in ids array
+    std::vector<std::vector<int> > nearestMarkerIdx;
+    // for each charuco corner, nearest marker corner id of each marker
+    std::vector<std::vector<int> > nearestMarkerCorners;
+
+    void createCharucoBoard();
+    void calcNearestMarkerCorners();
+
+    void matchImagePoints(InputArrayOfArrays detectedCharuco, InputArray detectedIds,
+                          OutputArray objPoints, OutputArray imgPoints) const override;
+
+    void generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const override;
+};
+
+void CharucoBoardImpl::createCharucoBoard() {
+    float diffSquareMarkerLength = (squareLength - markerLength) / 2;
+    int totalMarkers = (int)(ids.size());
+    // calculate Board objPoints
+    int nextId = 0;
+    objPoints.clear();
+    for(int y = 0; y < size.height; y++) {
+        for(int x = 0; x < size.width; x++) {
+
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 == x % 2) continue; // black corner, no marker here
+            } else {
+                if(y % 2 == x % 2) continue; // black corner, no marker here
+            }
+
+            vector<Point3f> corners(4);
+            corners[0] = Point3f(x * squareLength + diffSquareMarkerLength,
+                                 y * squareLength + diffSquareMarkerLength, 0);
+            corners[1] = corners[0] + Point3f(markerLength, 0, 0);
+            corners[2] = corners[0] + Point3f(markerLength, markerLength, 0);
+            corners[3] = corners[0] + Point3f(0, markerLength, 0);
+            objPoints.push_back(corners);
+            // first ids in dictionary
+            if (totalMarkers == 0)
+                ids.push_back(nextId);
+            nextId++;
+        }
+    }
+    if (totalMarkers > 0 && nextId != totalMarkers)
+        CV_Error(cv::Error::StsBadSize, "Size of ids must be equal to the number of markers: "+std::to_string(nextId));
+
+    // now fill chessboardCorners
+    chessboardCorners.clear();
+    for(int y = 0; y < size.height - 1; y++) {
+        for(int x = 0; x < size.width - 1; x++) {
+            Point3f corner;
+            corner.x = (x + 1) * squareLength;
+            corner.y = (y + 1) * squareLength;
+            corner.z = 0;
+            chessboardCorners.push_back(corner);
+        }
+    }
+    rightBottomBorder = Point3f(size.width * squareLength, size.height * squareLength, 0.f);
+    calcNearestMarkerCorners();
+}
+
+/** Fill nearestMarkerIdx and nearestMarkerCorners arrays */
+void CharucoBoardImpl::calcNearestMarkerCorners() {
+    nearestMarkerIdx.clear();
+    nearestMarkerCorners.clear();
+    nearestMarkerIdx.resize(chessboardCorners.size());
+    nearestMarkerCorners.resize(chessboardCorners.size());
+    unsigned int nMarkers = (unsigned int)objPoints.size();
+    unsigned int nCharucoCorners = (unsigned int)chessboardCorners.size();
+    for(unsigned int i = 0; i < nCharucoCorners; i++) {
+        double minDist = -1; // distance of closest markers
+        Point3f charucoCorner = chessboardCorners[i];
+        for(unsigned int j = 0; j < nMarkers; j++) {
+            // calculate distance from marker center to charuco corner
+            Point3f center = Point3f(0, 0, 0);
+            for(unsigned int k = 0; k < 4; k++)
+                center += objPoints[j][k];
+            center /= 4.;
+            double sqDistance;
+            Point3f distVector = charucoCorner - center;
+            sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+            if(j == 0 || fabs(sqDistance - minDist) < cv::pow(0.01 * squareLength, 2)) {
+                // if same minimum distance (or first iteration), add to nearestMarkerIdx vector
+                nearestMarkerIdx[i].push_back(j);
+                minDist = sqDistance;
+            } else if(sqDistance < minDist) {
+                // if finding a closest marker to the charuco corner
+                nearestMarkerIdx[i].clear(); // remove any previous added marker
+                nearestMarkerIdx[i].push_back(j); // add the new closest marker index
+                minDist = sqDistance;
+            }
+        }
+        // for each of the closest markers, search the marker corner index closer
+        // to the charuco corner
+        for(unsigned int j = 0; j < nearestMarkerIdx[i].size(); j++) {
+            nearestMarkerCorners[i].resize(nearestMarkerIdx[i].size());
+            double minDistCorner = -1;
+            for(unsigned int k = 0; k < 4; k++) {
+                double sqDistance;
+                Point3f distVector = charucoCorner - objPoints[nearestMarkerIdx[i][j]][k];
+                sqDistance = distVector.x * distVector.x + distVector.y * distVector.y;
+                if(k == 0 || sqDistance < minDistCorner) {
+                    // if this corner is closer to the charuco corner, assing its index
+                    // to nearestMarkerCorners
+                    minDistCorner = sqDistance;
+                    nearestMarkerCorners[i][j] = k;
+                }
+            }
+        }
+    }
+}
+
+void CharucoBoardImpl::matchImagePoints(InputArrayOfArrays detectedCharuco, InputArray detectedIds,
+                                        OutputArray outObjPoints, OutputArray outImgPoints) const {
+    CV_CheckEQ(detectedIds.total(), detectedCharuco.total(), "Number of corners and ids must be equal");
+    CV_Assert(detectedIds.total() > 0ull);
+    CV_Assert(detectedCharuco.depth() == CV_32F);
+    // detectedCharuco includes charuco corners as vector<Point2f> or Mat.
+    // Python bindings could add extra dimension to detectedCharuco and therefore vector<Mat> case is additionally processed.
+    CV_Assert((detectedCharuco.isMat() || detectedCharuco.isVector() || detectedCharuco.isMatVector() || detectedCharuco.isUMatVector())
+               && detectedCharuco.depth() == CV_32F);
+    size_t nDetected = detectedCharuco.total();
+    vector<Point3f> objPnts(nDetected);
+    vector<Point2f> imgPnts(nDetected);
+    Mat detectedCharucoMat, detectedIdsMat = detectedIds.getMat();
+    if (!detectedCharuco.isMatVector()) {
+        detectedCharucoMat = detectedCharuco.getMat();
+        CV_Assert(detectedCharucoMat.checkVector(2));
+    }
+
+    std::vector<Mat> detectedCharucoVecMat;
+    if (detectedCharuco.isMatVector()) {
+        detectedCharuco.getMatVector(detectedCharucoVecMat);
+    }
+
+    for(size_t i = 0ull; i < nDetected; i++) {
+        int pointId = detectedIdsMat.at<int>((int)i);
+        CV_Assert(pointId >= 0 && pointId < (int)chessboardCorners.size());
+        objPnts[i] = chessboardCorners[pointId];
+        if (detectedCharuco.isMatVector()) {
+            CV_Assert((int)detectedCharucoVecMat[i].total() * detectedCharucoVecMat[i].channels() == 2);
+            imgPnts[i] = detectedCharucoVecMat[i].ptr<Point2f>(0)[0];
+        }
+        else
+            imgPnts[i] = detectedCharucoMat.ptr<Point2f>(0)[i];
+    }
+    Mat(objPnts).copyTo(outObjPoints);
+    Mat(imgPnts).copyTo(outImgPoints);
+}
+
+void CharucoBoardImpl::generateImage(Size outSize, OutputArray img, int marginSize, int borderBits) const {
+    CV_Assert(!outSize.empty());
+    CV_Assert(marginSize >= 0);
+
+    img.create(outSize, CV_8UC1);
+    img.setTo(255);
+    Mat out = img.getMat();
+    Mat noMarginsImg =
+        out.colRange(marginSize, out.cols - marginSize).rowRange(marginSize, out.rows - marginSize);
+
+    // the size of the chessboard square depends on the location of the chessboard
+    float pixInSquare = 0.f;
+    // the size of the chessboard in pixels
+    Size pixInChessboard(noMarginsImg.cols, noMarginsImg.rows);
+
+    // determine the zone where the chessboard is placed
+    float pixInSquareX = (float)noMarginsImg.cols / (float)size.width;
+    float pixInSquareY = (float)noMarginsImg.rows / (float)size.height;
+    Point startChessboard(0, 0);
+    if (pixInSquareX <= pixInSquareY) {
+        // the width of "noMarginsImg" image determines the dimensions of the chessboard
+        pixInSquare = pixInSquareX;
+        pixInChessboard.height = cvRound(pixInSquare*size.height);
+        int rowsMargin = (noMarginsImg.rows - pixInChessboard.height) / 2;
+        startChessboard.y = rowsMargin;
+    }
+    else {
+        // the height of "noMarginsImg" image determines the dimensions of the chessboard
+        pixInSquare = pixInSquareY;
+        pixInChessboard.width = cvRound(pixInSquare*size.width);
+        int colsMargin = (noMarginsImg.cols - pixInChessboard.width) / 2;
+        startChessboard.x = colsMargin;
+    }
+    // determine the zone where the chessboard is located
+    Mat chessboardZoneImg = noMarginsImg(Rect(startChessboard, pixInChessboard));
+
+    // marker size in pixels
+    const float pixInMarker = markerLength/squareLength*pixInSquare;
+    // the size of the marker margin in pixels
+    const float pixInMarginMarker = 0.5f*(pixInSquare - pixInMarker);
+
+    // determine the zone where the aruco markers are located
+    int endArucoX = cvRound(pixInSquare*(size.width-1)+pixInMarginMarker+pixInMarker);
+    int endArucoY = cvRound(pixInSquare*(size.height-1)+pixInMarginMarker+pixInMarker);
+    Mat arucoZone = chessboardZoneImg(Range(cvRound(pixInMarginMarker), endArucoY), Range(cvRound(pixInMarginMarker), endArucoX));
+
+    // draw markers
+    Board::Impl::generateImage(arucoZone.size(), arucoZone, 0, borderBits);
+
+    // now draw black squares
+    for(int y = 0; y < size.height; y++) {
+        for(int x = 0; x < size.width; x++) {
+
+            if(legacyPattern && (size.height % 2 == 0)) { // legacy behavior only for even row count patterns
+                if((y + 1) % 2 != x % 2) continue; // white corner, don't do anything
+            } else {
+                if(y % 2 != x % 2) continue; // white corner, don't do anything
+            }
+
+            float startX = pixInSquare * float(x);
+            float startY = pixInSquare * float(y);
+
+            Mat squareZone = chessboardZoneImg(Range(cvRound(startY), cvRound(startY + pixInSquare)),
+                                               Range(cvRound(startX), cvRound(startX + pixInSquare)));
+
+            squareZone.setTo(0);
+        }
+    }
+}
+
+CharucoBoard::CharucoBoard(){}
+
+CharucoBoard::CharucoBoard(const Size& size, float squareLength, float markerLength,
+                           const Dictionary &dictionary, InputArray ids):
+    Board(new CharucoBoardImpl(dictionary, size, squareLength, markerLength)) {
+
+    CV_Assert(size.width > 1 && size.height > 1 && markerLength > 0 && squareLength > markerLength);
+    float onePin = markerLength / ((float)(dictionary.markerSize+2));
+    float markerSeparation = (squareLength - markerLength)/2.f;
+    if (markerSeparation < onePin*.7f) {
+        CV_LOG_WARNING(NULL, "Marker border " << markerSeparation << " is less than 70% of ArUco pin size "
+            << onePin <<". Please increase markerSeparation or decrease markerLength for stable board detection");
+    }
+    ids.copyTo(impl->ids);
+
+    static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
+}
+
+Size CharucoBoard::getChessboardSize() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->size;
+}
+
+float CharucoBoard::getSquareLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->squareLength;
+}
+
+float CharucoBoard::getMarkerLength() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->markerLength;
+}
+
+void CharucoBoard::setLegacyPattern(bool legacyPattern) {
+    CV_Assert(impl);
+    if (static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern != legacyPattern)
+    {
+        static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern = legacyPattern;
+        static_pointer_cast<CharucoBoardImpl>(impl)->createCharucoBoard();
+    }
+}
+
+bool CharucoBoard::getLegacyPattern() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->legacyPattern;
+}
+
+bool CharucoBoard::checkCharucoCornersCollinear(InputArray charucoIds) const {
+    CV_Assert(impl);
+    Mat charucoIdsMat = charucoIds.getMat();
+
+    unsigned int nCharucoCorners = (unsigned int)charucoIdsMat.total();
+    if (nCharucoCorners <= 2)
+        return true;
+
+    // only test if there are 3 or more corners
+    auto board = static_pointer_cast<CharucoBoardImpl>(impl);
+    CV_Assert(board->chessboardCorners.size() >= charucoIdsMat.total());
+
+    Vec<double, 3> point0(board->chessboardCorners[charucoIdsMat.at<int>(0)].x,
+                          board->chessboardCorners[charucoIdsMat.at<int>(0)].y, 1);
+
+    Vec<double, 3> point1(board->chessboardCorners[charucoIdsMat.at<int>(1)].x,
+                          board->chessboardCorners[charucoIdsMat.at<int>(1)].y, 1);
+
+    // create a line from the first two points.
+    Vec<double, 3> testLine = point0.cross(point1);
+    Vec<double, 3> testPoint(0, 0, 1);
+
+    double divisor = sqrt(testLine[0]*testLine[0] + testLine[1]*testLine[1]);
+    CV_Assert(divisor != 0.0);
+
+    // normalize the line with normal
+    testLine /= divisor;
+
+    double dotProduct;
+    for (unsigned int i = 2; i < nCharucoCorners; i++){
+        testPoint(0) = board->chessboardCorners[charucoIdsMat.at<int>(i)].x;
+        testPoint(1) = board->chessboardCorners[charucoIdsMat.at<int>(i)].y;
+
+        // if testPoint is on testLine, dotProduct will be zero (or very, very close)
+        dotProduct = testPoint.dot(testLine);
+
+        if (std::abs(dotProduct) > 1e-6){
+            return false;
+        }
+    }
+    // no points found that were off of testLine, return true that all points collinear.
+    return true;
+}
+
+std::vector<Point3f> CharucoBoard::getChessboardCorners() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->chessboardCorners;
+}
+
+std::vector<std::vector<int> > CharucoBoard::getNearestMarkerIdx() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->nearestMarkerIdx;
+}
+
+std::vector<std::vector<int> > CharucoBoard::getNearestMarkerCorners() const {
+    CV_Assert(impl);
+    return static_pointer_cast<CharucoBoardImpl>(impl)->nearestMarkerCorners;
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp b/upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp
new file mode 100644
index 0000000..c641f89
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/aruco_detector.cpp
@@ -0,0 +1,1597 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include <opencv2/geometry.hpp>
+
+#include "opencv2/objdetect/aruco_detector.hpp"
+#include "opencv2/objdetect/aruco_board.hpp"
+#include "apriltag/apriltag_quad_thresh.hpp"
+#include "aruco_utils.hpp"
+#include <algorithm>
+#include <cmath>
+#include <map>
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+static inline bool readWrite(DetectorParameters &params, const FileNode* readNode,
+                             FileStorage* writeStorage = nullptr)
+{
+    CV_Assert(readNode || writeStorage);
+    bool check = false;
+
+    check |= readWriteParameter("adaptiveThreshWinSizeMin", params.adaptiveThreshWinSizeMin, readNode, writeStorage);
+    check |= readWriteParameter("adaptiveThreshWinSizeMax", params.adaptiveThreshWinSizeMax, readNode, writeStorage);
+    check |= readWriteParameter("adaptiveThreshWinSizeStep", params.adaptiveThreshWinSizeStep, readNode, writeStorage);
+    check |= readWriteParameter("adaptiveThreshConstant", params.adaptiveThreshConstant, readNode, writeStorage);
+    check |= readWriteParameter("minMarkerPerimeterRate", params.minMarkerPerimeterRate, readNode, writeStorage);
+    check |= readWriteParameter("maxMarkerPerimeterRate", params.maxMarkerPerimeterRate, readNode, writeStorage);
+    check |= readWriteParameter("polygonalApproxAccuracyRate", params.polygonalApproxAccuracyRate,
+                                readNode, writeStorage);
+    check |= readWriteParameter("minCornerDistanceRate", params.minCornerDistanceRate, readNode, writeStorage);
+    check |= readWriteParameter("minDistanceToBorder", params.minDistanceToBorder, readNode, writeStorage);
+    check |= readWriteParameter("minMarkerDistanceRate", params.minMarkerDistanceRate, readNode, writeStorage);
+    check |= readWriteParameter("cornerRefinementMethod", params.cornerRefinementMethod, readNode, writeStorage);
+    check |= readWriteParameter("cornerRefinementWinSize", params.cornerRefinementWinSize, readNode, writeStorage);
+    check |= readWriteParameter("relativeCornerRefinmentWinSize", params.relativeCornerRefinmentWinSize, readNode,
+                                writeStorage);
+    check |= readWriteParameter("cornerRefinementMaxIterations", params.cornerRefinementMaxIterations,
+                                readNode, writeStorage);
+    check |= readWriteParameter("cornerRefinementMinAccuracy", params.cornerRefinementMinAccuracy,
+                                readNode, writeStorage);
+    check |= readWriteParameter("markerBorderBits", params.markerBorderBits, readNode, writeStorage);
+    check |= readWriteParameter("perspectiveRemovePixelPerCell", params.perspectiveRemovePixelPerCell,
+                                readNode, writeStorage);
+    check |= readWriteParameter("perspectiveRemoveIgnoredMarginPerCell", params.perspectiveRemoveIgnoredMarginPerCell,
+                                readNode, writeStorage);
+    check |= readWriteParameter("maxErroneousBitsInBorderRate", params.maxErroneousBitsInBorderRate,
+                                readNode, writeStorage);
+    check |= readWriteParameter("minOtsuStdDev", params.minOtsuStdDev, readNode, writeStorage);
+    check |= readWriteParameter("errorCorrectionRate", params.errorCorrectionRate, readNode, writeStorage);
+    check |= readWriteParameter("minGroupDistance", params.minGroupDistance, readNode, writeStorage);
+    // new aruco 3 functionality
+    check |= readWriteParameter("useAruco3Detection", params.useAruco3Detection, readNode, writeStorage);
+    check |= readWriteParameter("minSideLengthCanonicalImg", params.minSideLengthCanonicalImg, readNode, writeStorage);
+    check |= readWriteParameter("minMarkerLengthRatioOriginalImg", params.minMarkerLengthRatioOriginalImg,
+                                readNode, writeStorage);
+    return check;
+}
+
+bool DetectorParameters::readDetectorParameters(const FileNode& fn)
+{
+    if (fn.empty())
+        return false;
+    return readWrite(*this, &fn);
+}
+
+bool DetectorParameters::writeDetectorParameters(FileStorage& fs, const String& name)
+{
+    CV_Assert(fs.isOpened());
+    if (!name.empty())
+        fs << name << "{";
+    bool res = readWrite(*this, nullptr, &fs);
+    if (!name.empty())
+        fs << "}";
+    return res;
+}
+
+static inline bool readWrite(RefineParameters& refineParameters, const FileNode* readNode,
+                             FileStorage* writeStorage = nullptr)
+{
+    CV_Assert(readNode || writeStorage);
+    bool check = false;
+
+    check |= readWriteParameter("minRepDistance", refineParameters.minRepDistance, readNode, writeStorage);
+    check |= readWriteParameter("errorCorrectionRate", refineParameters.errorCorrectionRate, readNode, writeStorage);
+    check |= readWriteParameter("checkAllOrders", refineParameters.checkAllOrders, readNode, writeStorage);
+    return check;
+}
+
+RefineParameters::RefineParameters(float _minRepDistance, float _errorCorrectionRate, bool _checkAllOrders):
+                                   minRepDistance(_minRepDistance), errorCorrectionRate(_errorCorrectionRate),
+                                   checkAllOrders(_checkAllOrders){}
+
+bool RefineParameters::readRefineParameters(const FileNode &fn)
+{
+    if (fn.empty())
+        return false;
+    return readWrite(*this, &fn);
+}
+
+bool RefineParameters::writeRefineParameters(FileStorage& fs, const String& name)
+{
+    CV_Assert(fs.isOpened());
+    if (!name.empty())
+        fs << name << "{";
+    bool res = readWrite(*this, nullptr, &fs);
+    if (!name.empty())
+        fs << "}";
+    return res;
+}
+
+/**
+  * @brief Threshold input image using adaptive thresholding
+  */
+static void _threshold(InputArray _in, OutputArray _out, int winSize, double constant) {
+
+    CV_Assert(winSize >= 3);
+    if(winSize % 2 == 0) winSize++; // win size must be odd
+    adaptiveThreshold(_in, _out, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, winSize, constant);
+}
+
+
+/**
+  * @brief Given a thresholded image, find the contours, calculate their polygonal approximation
+  * and take those that accomplish some conditions
+  */
+static void _findMarkerContours(const Mat &in, vector<vector<Point2f> > &candidates,
+                                vector<vector<Point> > &contoursOut, double minPerimeterRate,
+                                double maxPerimeterRate, double accuracyRate,
+                                double minCornerDistanceRate, int minSize) {
+
+    CV_Assert(minPerimeterRate > 0 && maxPerimeterRate > 0 && accuracyRate > 0 &&
+              minCornerDistanceRate >= 0);
+
+    // calculate maximum and minimum sizes in pixels
+    unsigned int minPerimeterPixels =
+        (unsigned int)(minPerimeterRate * max(in.cols, in.rows));
+    unsigned int maxPerimeterPixels =
+        (unsigned int)(maxPerimeterRate * max(in.cols, in.rows));
+
+    // for aruco3 functionality
+    if (minSize != 0) {
+        minPerimeterPixels = 4*minSize;
+    }
+
+    vector<vector<Point> > contours;
+    findContours(in, contours, RETR_LIST, CHAIN_APPROX_NONE);
+    // now filter list of contours
+    for(unsigned int i = 0; i < contours.size(); i++) {
+        // check perimeter
+        if(contours[i].size() < minPerimeterPixels || contours[i].size() > maxPerimeterPixels)
+            continue;
+
+        // check is square and is convex
+        vector<Point> approxCurve;
+        approxPolyDP(contours[i], approxCurve, double(contours[i].size()) * accuracyRate, true);
+        if(approxCurve.size() != 4 || !isContourConvex(approxCurve)) continue;
+
+        // check min distance between corners
+        double minDistSq = max(in.cols, in.rows) * max(in.cols, in.rows);
+        for(int j = 0; j < 4; j++) {
+            double d = (double)(approxCurve[j].x - approxCurve[(j + 1) % 4].x) *
+                           (double)(approxCurve[j].x - approxCurve[(j + 1) % 4].x) +
+                       (double)(approxCurve[j].y - approxCurve[(j + 1) % 4].y) *
+                           (double)(approxCurve[j].y - approxCurve[(j + 1) % 4].y);
+            minDistSq = min(minDistSq, d);
+        }
+        double minCornerDistancePixels = double(contours[i].size()) * minCornerDistanceRate;
+        if(minDistSq < minCornerDistancePixels * minCornerDistancePixels) continue;
+
+        // if it passes all the test, add to candidates vector
+        vector<Point2f> currentCandidate;
+        currentCandidate.resize(4);
+        for(int j = 0; j < 4; j++) {
+            currentCandidate[j] = Point2f((float)approxCurve[j].x, (float)approxCurve[j].y);
+        }
+        candidates.push_back(currentCandidate);
+        contoursOut.push_back(contours[i]);
+    }
+}
+
+
+/**
+  * @brief Assure order of candidate corners is clockwise direction
+  */
+static void _reorderCandidatesCorners(vector<vector<Point2f> > &candidates) {
+
+    for(unsigned int i = 0; i < candidates.size(); i++) {
+        double dx1 = candidates[i][1].x - candidates[i][0].x;
+        double dy1 = candidates[i][1].y - candidates[i][0].y;
+        double dx2 = candidates[i][2].x - candidates[i][0].x;
+        double dy2 = candidates[i][2].y - candidates[i][0].y;
+        double crossProduct = (dx1 * dy2) - (dy1 * dx2);
+
+        if(crossProduct < 0.0) { // not clockwise direction
+            swap(candidates[i][1], candidates[i][3]);
+        }
+    }
+}
+
+static float getAverageModuleSize(const vector<Point2f>& markerCorners, int markerSize, int markerBorderBits) {
+    float averageArucoModuleSize = 0.f;
+    for (size_t i = 0ull; i < 4ull; i++) {
+        averageArucoModuleSize += sqrt(normL2Sqr<float>(Point2f(markerCorners[i] - markerCorners[(i+1ull) % 4ull])));
+    }
+    int numModules = markerSize + markerBorderBits * 2;
+    averageArucoModuleSize /= ((float)markerCorners.size()*numModules);
+    return averageArucoModuleSize;
+}
+
+static bool checkMarker1InMarker2(const vector<Point2f>& marker1, const vector<Point2f>& marker2) {
+    return pointPolygonTest(marker2, marker1[0], false) >= 0 && pointPolygonTest(marker2, marker1[1], false) >= 0 &&
+           pointPolygonTest(marker2, marker1[2], false) >= 0 && pointPolygonTest(marker2, marker1[3], false) >= 0;
+}
+
+struct MarkerCandidate {
+    vector<Point2f> corners;
+    vector<Point> contour;
+    float perimeter = 0.f;
+};
+
+struct MarkerCandidateTree : MarkerCandidate{
+    int parent = -1;
+    int depth = 0;
+    vector<MarkerCandidate> closeContours;
+
+    MarkerCandidateTree() {}
+
+    MarkerCandidateTree(vector<Point2f>&& corners_, vector<Point>&& contour_) {
+        corners = std::move(corners_);
+        contour = std::move(contour_);
+        perimeter = 0.f;
+        for (size_t i = 0ull; i < 4ull; i++) {
+            perimeter += sqrt(normL2Sqr<float>(Point2f(corners[i] - corners[(i+1ull) % 4ull])));
+        }
+    }
+
+    bool operator<(const MarkerCandidateTree& m) const {
+        // sorting the contors in descending order
+        return perimeter > m.perimeter;
+    }
+};
+
+
+// returns the average distance between the marker points
+float static inline getAverageDistance(const std::vector<Point2f>& marker1, const std::vector<Point2f>& marker2) {
+    float minDistSq = std::numeric_limits<float>::max();
+    // fc is the first corner considered on one of the markers, 4 combinations are possible
+    for(int fc = 0; fc < 4; fc++) {
+        float distSq = 0;
+        for(int c = 0; c < 4; c++) {
+            // modC is the corner considering first corner is fc
+            int modC = (c + fc) % 4;
+            distSq += normL2Sqr<float>(marker1[modC] - marker2[c]);
+        }
+        distSq /= 4.f;
+        minDistSq = min(minDistSq, distSq);
+    }
+    return sqrt(minDistSq);
+}
+
+/**
+ * @brief Initial steps on finding square candidates
+ */
+static void _detectInitialCandidates(const Mat &grey, vector<vector<Point2f> > &candidates,
+                                     vector<vector<Point> > &contours,
+                                     const DetectorParameters &params) {
+
+    CV_Assert(params.adaptiveThreshWinSizeMin >= 3 && params.adaptiveThreshWinSizeMax >= 3);
+    CV_Assert(params.adaptiveThreshWinSizeMax >= params.adaptiveThreshWinSizeMin);
+    CV_Assert(params.adaptiveThreshWinSizeStep > 0);
+
+    // number of window sizes (scales) to apply adaptive thresholding
+    int nScales =  (params.adaptiveThreshWinSizeMax - params.adaptiveThreshWinSizeMin) /
+                      params.adaptiveThreshWinSizeStep + 1;
+
+    vector<vector<vector<Point2f> > > candidatesArrays((size_t) nScales);
+    vector<vector<vector<Point> > > contoursArrays((size_t) nScales);
+
+    ////for each value in the interval of thresholding window sizes
+    parallel_for_(Range(0, nScales), [&](const Range& range) {
+        const int begin = range.start;
+        const int end = range.end;
+
+        for (int i = begin; i < end; i++) {
+            int currScale = params.adaptiveThreshWinSizeMin + i * params.adaptiveThreshWinSizeStep;
+            // threshold
+            Mat thresh;
+            _threshold(grey, thresh, currScale, params.adaptiveThreshConstant);
+
+            // detect rectangles
+            _findMarkerContours(thresh, candidatesArrays[i], contoursArrays[i],
+                                params.minMarkerPerimeterRate, params.maxMarkerPerimeterRate,
+                                params.polygonalApproxAccuracyRate, params.minCornerDistanceRate,
+                                params.minSideLengthCanonicalImg);
+        }
+    });
+    // join candidates
+    for(int i = 0; i < nScales; i++) {
+        for(unsigned int j = 0; j < candidatesArrays[i].size(); j++) {
+            candidates.push_back(candidatesArrays[i][j]);
+            contours.push_back(contoursArrays[i][j]);
+        }
+    }
+}
+
+
+/**
+  * @brief Given an input image and candidate corners, extract the cell pixel ratio of the candidate, including
+  * the border bits
+  */
+static Mat _extractCellPixelRatio(InputArray _image, const vector<Point2f>& corners, int markerSize,
+                                   int markerBorderBits, int cellSize, double cellMarginRate, double minStdDevOtsu) {
+    CV_Assert(_image.getMat().channels() == 1);
+    CV_Assert(corners.size() == 4ull);
+    CV_Assert(markerBorderBits > 0 && cellSize > 0 && cellMarginRate >= 0 && cellMarginRate <= 0.5);
+    CV_Assert(minStdDevOtsu >= 0);
+
+    // number of bits in the marker
+    int markerSizeWithBorders = markerSize + 2 * markerBorderBits;
+    int cellMarginPixels = int(cellMarginRate * cellSize);
+
+    Mat resultImg; // marker image after removing perspective
+    int resultImgSize = markerSizeWithBorders * cellSize;
+    Mat resultImgCorners(4, 1, CV_32FC2);
+    resultImgCorners.ptr<Point2f>(0)[0] = Point2f(0, 0);
+    resultImgCorners.ptr<Point2f>(0)[1] = Point2f((float)resultImgSize - 1, 0);
+    resultImgCorners.ptr<Point2f>(0)[2] =
+        Point2f((float)resultImgSize - 1, (float)resultImgSize - 1);
+    resultImgCorners.ptr<Point2f>(0)[3] = Point2f(0, (float)resultImgSize - 1);
+
+    // remove perspective
+    Mat transformation = getPerspectiveTransform(corners, resultImgCorners);
+    warpPerspective(_image, resultImg, transformation, Size(resultImgSize, resultImgSize),
+                    INTER_NEAREST);
+
+    // output image containing the ratio of white pixels in each cell
+    Mat cellPixelRatio(markerSizeWithBorders, markerSizeWithBorders, CV_32FC1, Scalar::all(0));
+
+    // check if standard deviation is enough to apply Otsu
+    // if not enough, it probably means all pixels are the same color (black or white)
+    Mat mean, stddev;
+    // Remove some border just to avoid border noise from perspective transformation
+    Mat innerRegion = resultImg.colRange(cellSize / 2, resultImg.cols - cellSize / 2)
+                          .rowRange(cellSize / 2, resultImg.rows - cellSize / 2);
+    meanStdDev(innerRegion, mean, stddev);
+    if(stddev.ptr< double >(0)[0] < minStdDevOtsu) {
+        // all black or all white, depending on mean value
+        if(mean.ptr< double >(0)[0] > 127){
+            cellPixelRatio.setTo(1);
+        } else {
+            cellPixelRatio.setTo(0);
+        }
+
+        return cellPixelRatio;
+    }
+
+    // now extract code, first threshold using Otsu
+    threshold(resultImg, resultImg, 125, 255, THRESH_BINARY | THRESH_OTSU);
+
+    // for each cell
+    for(int y = 0; y < markerSizeWithBorders; y++) {
+        for(int x = 0; x < markerSizeWithBorders; x++) {
+            int Xstart = x * (cellSize) + cellMarginPixels;
+            int Ystart = y * (cellSize) + cellMarginPixels;
+            Mat square = resultImg(Rect(Xstart, Ystart, cellSize - 2 * cellMarginPixels,
+                                        cellSize - 2 * cellMarginPixels));
+            // count white pixels on each cell to assign its value
+            size_t nZ = (size_t) countNonZero(square);
+
+            // define the cell pixel ratio as the ratio of the white pixels. For inverted markers, the ratio will be inverted.
+            cellPixelRatio.at<float>(y, x) = (nZ / (float)square.total());
+        }
+    }
+
+    return cellPixelRatio;
+}
+
+
+
+/**
+  * @brief Return number of erroneous bits in border, i.e. bits for which pixel ratio > validBitIdThreshold.
+  */
+ static int _getBorderErrors(const Mat &cellPixelRatio, int markerSize, int borderSize, float validBitIdThreshold) {
+
+    int sizeWithBorders = markerSize + 2 * borderSize;
+
+    CV_Assert(markerSize > 0 && cellPixelRatio.cols == sizeWithBorders && cellPixelRatio.rows == sizeWithBorders);
+
+    // Get border error. cellPixelRatio has the opposite color as the borders.
+    int totalErrors = 0;
+    for(int y = 0; y < sizeWithBorders; y++) {
+        for(int k = 0; k < borderSize; k++) {
+            // Left and right vertical sides
+            if(cellPixelRatio.ptr<float>(y)[k] > validBitIdThreshold)  totalErrors++;
+            if(cellPixelRatio.ptr<float>(y)[sizeWithBorders - 1 - k] > validBitIdThreshold) totalErrors++;
+        }
+    }
+    for(int x = borderSize; x < sizeWithBorders - borderSize; x++) {
+        for(int k = 0; k < borderSize; k++) {
+            // Top and bottom horizontal sides
+            if(cellPixelRatio.ptr<float>(k)[x] > validBitIdThreshold) totalErrors++;
+            if(cellPixelRatio.ptr<float>(sizeWithBorders - 1 - k)[x] > validBitIdThreshold) totalErrors++;
+        }
+    }
+    return totalErrors;
+}
+
+
+/** @brief Given a matrix containing the percentage of white pixels in each marker cell, returns the normalized marker confidence [0;1].
+ * The confidence is defined as 1 - normalized uncertainty, where 1 describes a pixel perfect detection.
+ * The rotation is set to 0,1,2,3 for [0, 90, 180, 270] deg CCW rotations.
+ */
+
+static float _getMarkerConfidence(const Mat& groundTruthbits, const Mat &cellPixelRatio, const int markerSize, const int borderSize) {
+
+    CV_Assert(markerSize == groundTruthbits.cols && markerSize == groundTruthbits.rows);
+
+    const int sizeWithBorders = markerSize + 2 * borderSize;
+    CV_Assert(markerSize > 0 && cellPixelRatio.cols == sizeWithBorders && cellPixelRatio.rows == sizeWithBorders);
+
+    // Get border uncertainty. cellPixelRatio has the opposite color as the borders --> it is the uncertainty.
+    float tempBorderUnc = 0.f;
+    for(int y = 0; y < sizeWithBorders; y++) {
+        for(int k = 0; k < borderSize; k++) {
+            // Left and right vertical sides
+            tempBorderUnc += cellPixelRatio.ptr<float>(y)[k];
+            tempBorderUnc += cellPixelRatio.ptr<float>(y)[sizeWithBorders - 1 - k];
+        }
+    }
+    for(int x = borderSize; x < sizeWithBorders - borderSize; x++) {
+        for(int k = 0; k < borderSize; k++) {
+            // Top and bottom horizontal sides
+            tempBorderUnc += cellPixelRatio.ptr<float>(k)[x];
+            tempBorderUnc += cellPixelRatio.ptr<float>(sizeWithBorders - 1 - k)[x];
+        }
+    }
+
+    // Get the inner marker uncertainty. For a white or black cell, the uncertainty is the ratio of black or white pixels respectively.
+    float tempInnerUnc = 0.f;
+    for(int y = borderSize; y < markerSize + borderSize; y++) {
+        for(int x = borderSize; x < markerSize + borderSize; x++) {
+            tempInnerUnc += std::abs(groundTruthbits.ptr<float>(y - borderSize)[x - borderSize] - cellPixelRatio.ptr<float>(y)[x]);
+        }
+    }
+
+    // Compute the overall normalized marker uncertainty and convert it to confidence
+    const float area = static_cast<float>(sizeWithBorders) * sizeWithBorders;
+    const float normalizedMarkerUnc = (tempInnerUnc + tempBorderUnc) / area;
+    const float normalizedMarkerConfidence = 1.f - normalizedMarkerUnc;
+
+    return std::max(0.f, std::min(1.f, normalizedMarkerConfidence));
+}
+
+
+/**
+ * @brief Tries to identify one candidate given the dictionary
+ * @return candidate typ. zero if the candidate is not valid,
+ *                           1 if the candidate is a black candidate (default candidate)
+ *                           2 if the candidate is a white candidate
+ */
+static uint8_t _identifyOneCandidate(const Dictionary& dictionary, const Mat& _image,
+                                     const vector<Point2f>& _corners, int& idx,
+                                     const DetectorParameters& params, int& rotation,
+                                     float &markerConfidence, bool confidenceNeeded,
+                                     const float scale = 1.f) {
+    CV_DbgAssert(params.markerBorderBits > 0);
+    uint8_t typ=1;
+    // get bits
+    // scale corners to the correct size to search on the corresponding image pyramid
+    vector<Point2f> scaled_corners(4);
+    for (int i = 0; i < 4; ++i) {
+        scaled_corners[i].x = _corners[i].x * scale;
+        scaled_corners[i].y = _corners[i].y * scale;
+    }
+
+    Mat cellPixelRatio =
+        _extractCellPixelRatio(_image, scaled_corners, dictionary.markerSize, params.markerBorderBits,
+                               params.perspectiveRemovePixelPerCell,
+                               params.perspectiveRemoveIgnoredMarginPerCell, params.minOtsuStdDev);
+
+    // analyze border bits
+    int maximumErrorsInBorder =
+    int(dictionary.markerSize * dictionary.markerSize * params.maxErroneousBitsInBorderRate);
+    int borderErrors =
+        _getBorderErrors(cellPixelRatio, dictionary.markerSize, params.markerBorderBits, params.validBitIdThreshold);
+
+    // check if it is a white marker
+    if(params.detectInvertedMarker){
+        Mat invCellPixelRatio = 1.f - cellPixelRatio;
+        int invBError = _getBorderErrors(invCellPixelRatio, dictionary.markerSize, params.markerBorderBits, params.validBitIdThreshold);
+        // white marker
+        if(invBError<borderErrors){
+            borderErrors = invBError;
+            invCellPixelRatio.copyTo(cellPixelRatio);
+            typ=2;
+        }
+    }
+    if(borderErrors > maximumErrorsInBorder) return 0; // border is wrong
+
+    // take only inner bits
+    Mat onlyCellPixelRatio =
+        cellPixelRatio.rowRange(params.markerBorderBits,
+                                cellPixelRatio.rows - params.markerBorderBits)
+            .colRange(params.markerBorderBits, cellPixelRatio.cols - params.markerBorderBits);
+
+    // try to identify the marker
+    if(!dictionary.identify(onlyCellPixelRatio, idx, rotation, params.errorCorrectionRate, params.validBitIdThreshold))
+        return 0;
+
+    // compute the candidate's confidence
+    if(confidenceNeeded) {
+        Mat groundTruthbits = dictionary.getMarkerBits(idx, rotation);
+        markerConfidence = _getMarkerConfidence(groundTruthbits, cellPixelRatio, dictionary.markerSize, params.markerBorderBits);
+    }
+
+    return typ;
+}
+
+/**
+ * @brief rotate the initial corner to get to the right position
+ */
+static void correctCornerPosition(vector<Point2f>& _candidate, int rotate){
+    std::rotate(_candidate.begin(), _candidate.begin() + 4 - rotate, _candidate.end());
+}
+
+static size_t _findOptPyrImageForCanonicalImg(
+        const vector<Mat>& img_pyr,
+        const int scaled_width,
+        const int cur_perimeter,
+        const int min_perimeter) {
+    CV_Assert(scaled_width > 0);
+    size_t optLevel = 0;
+    float dist = std::numeric_limits<float>::max();
+    for (size_t i = 0; i < img_pyr.size(); ++i) {
+        const float scale = img_pyr[i].cols / static_cast<float>(scaled_width);
+        const float perimeter_scaled = cur_perimeter * scale;
+        // instead of std::abs() favor the larger pyramid level by checking if the distance is postive
+        // will slow down the algorithm but find more corners in the end
+        const float new_dist = perimeter_scaled - min_perimeter;
+        if (new_dist < dist && new_dist > 0.f) {
+            dist = new_dist;
+            optLevel = i;
+        }
+    }
+    return optLevel;
+}
+
+
+/**
+ * Line fitting  A * B = C :: Called from function refineCandidateLines
+ * @param nContours contour-container
+ */
+static Point3f _interpolate2Dline(const vector<Point2f>& nContours){
+    CV_Assert(nContours.size() >= 2);
+    float minX, minY, maxX, maxY;
+    minX = maxX = nContours[0].x;
+    minY = maxY = nContours[0].y;
+
+    for(unsigned int i = 0; i< nContours.size(); i++){
+        minX = nContours[i].x < minX ? nContours[i].x : minX;
+        minY = nContours[i].y < minY ? nContours[i].y : minY;
+        maxX = nContours[i].x > maxX ? nContours[i].x : maxX;
+        maxY = nContours[i].y > maxY ? nContours[i].y : maxY;
+    }
+
+    Mat A = Mat::ones((int)nContours.size(), 2, CV_32F); // Coefficient Matrix (N x 2)
+    Mat B((int)nContours.size(), 1, CV_32F);                // Variables   Matrix (N x 1)
+    Mat C;                                            // Constant
+
+    if(maxX - minX > maxY - minY){
+        for(unsigned int i =0; i < nContours.size(); i++){
+            A.at<float>(i,0)= nContours[i].x;
+            B.at<float>(i,0)= nContours[i].y;
+        }
+
+        solve(A, B, C, DECOMP_NORMAL);
+
+        return Point3f(C.at<float>(0, 0), -1., C.at<float>(1, 0));
+    }
+    else{
+        for(unsigned int i =0; i < nContours.size(); i++){
+            A.at<float>(i,0)= nContours[i].y;
+            B.at<float>(i,0)= nContours[i].x;
+        }
+
+        solve(A, B, C, DECOMP_NORMAL);
+
+        return Point3f(-1., C.at<float>(0, 0), C.at<float>(1, 0));
+    }
+
+}
+
+/**
+ * Find the Point where the lines crosses :: Called from function refineCandidateLines
+ * @param nLine1
+ * @param nLine2
+ * @return Crossed Point
+ */
+static Point2f _getCrossPoint(Point3f nLine1, Point3f nLine2){
+    Matx22f A(nLine1.x, nLine1.y, nLine2.x, nLine2.y);
+    Vec2f B(-nLine1.z, -nLine2.z);
+    return Vec2f(A.solve(B).val);
+}
+
+/**
+ * Refine Corners using the contour vector :: Called from function detectMarkers
+ * @param nContours contour-container
+ * @param nCorners candidate Corners
+ */
+static void _refineCandidateLines(vector<Point>& nContours, vector<Point2f>& nCorners){
+    vector<Point2f> contour2f(nContours.begin(), nContours.end());
+    /* 5 groups :: to group the edges
+     * 4 - classified by its corner
+     * extra group - (temporary) if contours do not begin with a corner
+     */
+    vector<Point2f> cntPts[5];
+    int cornerIndex[4]={-1};
+    int group=4;
+
+    for ( unsigned int i =0; i < nContours.size(); i++ ) {
+        for(unsigned int j=0; j<4; j++){
+            if ( nCorners[j] == contour2f[i] ){
+                cornerIndex[j] = i;
+                group=j;
+            }
+        }
+        cntPts[group].push_back(contour2f[i]);
+    }
+    for (int i = 0; i < 4; i++)
+    {
+        CV_Assert(cornerIndex[i] != -1);
+    }
+    // saves extra group into corresponding
+    if( !cntPts[4].empty() ){
+        for( unsigned int i=0; i < cntPts[4].size() ; i++ )
+            cntPts[group].push_back(cntPts[4].at(i));
+        cntPts[4].clear();
+    }
+
+    //Evaluate contour direction :: using the position of the detected corners
+    int inc=1;
+
+        inc = ( (cornerIndex[0] > cornerIndex[1]) &&  (cornerIndex[3] > cornerIndex[0]) ) ? -1:inc;
+    inc = ( (cornerIndex[2] > cornerIndex[3]) &&  (cornerIndex[1] > cornerIndex[2]) ) ? -1:inc;
+
+    // calculate the line :: who passes through the grouped points
+    Point3f lines[4];
+    for(int i=0; i<4; i++){
+        lines[i]=_interpolate2Dline(cntPts[i]);
+    }
+
+    /*
+     * calculate the corner :: where the lines crosses to each other
+     * clockwise direction        no clockwise direction
+     *      0                           1
+     *      .---. 1                     .---. 2
+     *      |   |                       |   |
+     *    3 .___.                     0 .___.
+     *          2                           3
+     */
+    for(int i=0; i < 4; i++){
+        if(inc<0)
+            nCorners[i] = _getCrossPoint(lines[ i ], lines[ (i+1)%4 ]);    // 01 12 23 30
+        else
+            nCorners[i] = _getCrossPoint(lines[ i ], lines[ (i+3)%4 ]);    // 30 01 12 23
+    }
+}
+
+static inline void findCornerInPyrImage(const float scale_init, const int closest_pyr_image_idx,
+                                        const vector<Mat>& grey_pyramid, Mat corners,
+                                        const DetectorParameters& params) {
+    // scale them to the closest pyramid level
+    if (scale_init != 1.f)
+        corners *= scale_init; // scale_init * scale_pyr
+    for (int idx = closest_pyr_image_idx - 1; idx >= 0; --idx) {
+        // scale them to new pyramid level
+        corners *= 2.f; // *= scale_pyr;
+        // use larger win size for larger images
+        const int subpix_win_size = std::max(grey_pyramid[idx].cols, grey_pyramid[idx].rows) > 1080 ? 5 : 3;
+        cornerSubPix(grey_pyramid[idx], corners,
+                     Size(subpix_win_size, subpix_win_size),
+                     Size(-1, -1),
+                     TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                  params.cornerRefinementMaxIterations,
+                                  params.cornerRefinementMinAccuracy));
+    }
+}
+
+enum class DictionaryMode {
+    Single,
+    Multi
+};
+
+struct ArucoDetector::ArucoDetectorImpl {
+    /// dictionaries indicates the types of markers that will be searched
+    vector<Dictionary> dictionaries;
+
+    /// marker detection parameters, check DetectorParameters docs to see available settings
+    DetectorParameters detectorParams;
+
+    /// marker refine parameters
+    RefineParameters refineParams;
+    ArucoDetectorImpl() {}
+
+    ArucoDetectorImpl(const vector<Dictionary>&_dictionaries, const DetectorParameters &_detectorParams,
+                      const RefineParameters& _refineParams): dictionaries(_dictionaries),
+                      detectorParams(_detectorParams), refineParams(_refineParams) {
+                          CV_Assert(!dictionaries.empty());
+                      }
+
+    /*
+     * @brief Detect markers either using multiple or just first dictionary
+     */
+    void detectMarkers(InputArray _image, OutputArrayOfArrays _corners, OutputArray _ids,
+            OutputArrayOfArrays _rejectedImgPoints, OutputArray _dictIndices, OutputArray _markersConfidence, DictionaryMode dictMode) {
+        CV_Assert(!_image.empty());
+
+        CV_Assert(detectorParams.markerBorderBits > 0);
+        // check that the parameters are set correctly if Aruco3 is used
+        CV_Assert(!(detectorParams.useAruco3Detection == true &&
+                    detectorParams.minSideLengthCanonicalImg == 0 &&
+                    detectorParams.minMarkerLengthRatioOriginalImg == 0.0));
+
+        Mat grey;
+        _convertToGrey(_image, grey);
+
+        // Aruco3 functionality is the extension of Aruco.
+        // The description can be found in:
+        // [1] Speeded up detection of squared fiducial markers, 2018, FJ Romera-Ramirez et al.
+        // if Aruco3 functionality if not wanted
+        // change some parameters to be sure to turn it off
+        if (!detectorParams.useAruco3Detection) {
+            detectorParams.minMarkerLengthRatioOriginalImg = 0.0;
+            detectorParams.minSideLengthCanonicalImg = 0;
+        }
+        else {
+            // always turn on corner refinement in case of Aruco3, due to upsampling
+            detectorParams.cornerRefinementMethod = (int)CORNER_REFINE_SUBPIX;
+            // only CORNER_REFINE_SUBPIX implement correctly for useAruco3Detection
+            // Todo: update other CORNER_REFINE methods
+        }
+
+        /// Step 0: equation (2) from paper [1]
+        const float fxfy = (!detectorParams.useAruco3Detection ? 1.f : detectorParams.minSideLengthCanonicalImg /
+                (detectorParams.minSideLengthCanonicalImg + std::max(grey.cols, grey.rows)*
+                 detectorParams.minMarkerLengthRatioOriginalImg));
+
+        /// Step 1: create image pyramid. Section 3.4. in [1]
+        vector<Mat> grey_pyramid;
+        int closest_pyr_image_idx = 0, num_levels = 0;
+        //// Step 1.1: resize image with equation (1) from paper [1]
+        if (detectorParams.useAruco3Detection) {
+            const float scale_pyr = 2.f;
+            const float img_area = static_cast<float>(grey.rows*grey.cols);
+            const float min_area_marker = static_cast<float>(detectorParams.minSideLengthCanonicalImg*
+                    detectorParams.minSideLengthCanonicalImg);
+            // find max level
+            num_levels = static_cast<int>(log2(img_area / min_area_marker)/scale_pyr);
+            // the closest pyramid image to the downsampled segmentation image
+            // will later be used as start index for corner upsampling
+            const float scale_img_area = img_area * fxfy * fxfy;
+            closest_pyr_image_idx = cvRound(log2(img_area / scale_img_area)/scale_pyr);
+        }
+        buildPyramid(grey, grey_pyramid, num_levels);
+
+        // resize to segmentation image
+        // in this reduces size the contours will be detected
+        if (fxfy != 1.f)
+            resize(grey, grey, Size(cvRound(fxfy * grey.cols), cvRound(fxfy * grey.rows)));
+
+        /// STEP 2: Detect marker candidates
+        vector<vector<Point2f> > candidates;
+        vector<vector<Point> > contours;
+        vector<int> ids;
+        vector<float> markersConfidence;
+
+        /// STEP 2.a Detect marker candidates :: using AprilTag
+        if(detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_APRILTAG){
+            _apriltag(grey, detectorParams, candidates, contours);
+        }
+        /// STEP 2.b Detect marker candidates :: traditional way
+        else {
+            detectCandidates(grey, candidates, contours);
+        }
+
+        /// STEP 2.c FILTER OUT NEAR CANDIDATE PAIRS
+        vector<int> dictIndices;
+        vector<vector<Point2f>> rejectedImgPoints;
+        if (DictionaryMode::Single == dictMode) {
+            Dictionary& dictionary = dictionaries.at(0);
+            auto selectedCandidates = filterTooCloseCandidates(grey.size(), candidates, contours, dictionary.markerSize);
+            candidates.clear();
+            contours.clear();
+
+            /// STEP 2: Check candidate codification (identify markers)
+            identifyCandidates(grey, grey_pyramid, selectedCandidates, candidates, contours,
+                    ids, dictionary, rejectedImgPoints, markersConfidence, _markersConfidence.needed());
+
+            /// STEP 3: Corner refinement :: use corner subpix
+            if (detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_SUBPIX) {
+                performCornerSubpixRefinement(grey, grey_pyramid, closest_pyr_image_idx, candidates, dictionary);
+            }
+        } else if (DictionaryMode::Multi == dictMode) {
+            map<int, vector<MarkerCandidateTree>> candidatesPerDictionarySize;
+            for (const Dictionary& dictionary : dictionaries) {
+                candidatesPerDictionarySize.emplace(dictionary.markerSize, vector<MarkerCandidateTree>());
+            }
+
+            // create candidate trees for each dictionary size
+            for (auto& candidatesTreeEntry : candidatesPerDictionarySize) {
+                // copy candidates
+                vector<vector<Point2f>> candidatesCopy = candidates;
+                vector<vector<Point> > contoursCopy = contours;
+                candidatesTreeEntry.second = filterTooCloseCandidates(grey.size(), candidatesCopy, contoursCopy, candidatesTreeEntry.first);
+            }
+            candidates.clear();
+            contours.clear();
+
+            /// STEP 2: Check candidate codification (identify markers)
+            int dictIndex = 0;
+            for (const Dictionary&  currentDictionary : dictionaries) {
+                // temporary variable to store the current candidates
+                vector<vector<Point2f>> currentCandidates;
+                identifyCandidates(grey, grey_pyramid, candidatesPerDictionarySize.at(currentDictionary.markerSize), currentCandidates, contours,
+                        ids, currentDictionary, rejectedImgPoints, markersConfidence, _markersConfidence.needed());
+                if (_dictIndices.needed()) {
+                    dictIndices.insert(dictIndices.end(), currentCandidates.size(), dictIndex);
+                }
+
+                /// STEP 3: Corner refinement :: use corner subpix
+                if (detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_SUBPIX) {
+                    performCornerSubpixRefinement(grey, grey_pyramid, closest_pyr_image_idx, currentCandidates, currentDictionary);
+                }
+                candidates.insert(candidates.end(), currentCandidates.begin(), currentCandidates.end());
+                dictIndex++;
+            }
+
+            // Clean up rejectedImgPoints by comparing to itself and all candidates
+            const float epsilon = 0.000001f;
+            auto compareCandidates = [epsilon](vector<Point2f> a, vector<Point2f> b) {
+                for (int i = 0; i < 4; i++) {
+                    if (std::abs(a[i].x - b[i].x) > epsilon || std::abs(a[i].y - b[i].y) > epsilon) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+            std::sort(rejectedImgPoints.begin(), rejectedImgPoints.end(), [](const vector<Point2f>& a, const vector<Point2f>&b){
+                    float avgX = (a[0].x + a[1].x + a[2].x + a[3].x)*.25f;
+                    float avgY = (a[0].y + a[1].y + a[2].y + a[3].y)*.25f;
+                    float aDist = avgX*avgX + avgY*avgY;
+                    avgX = (b[0].x + b[1].x + b[2].x + b[3].x)*.25f;
+                    avgY = (b[0].y + b[1].y + b[2].y + b[3].y)*.25f;
+                    float bDist = avgX*avgX + avgY*avgY;
+                    return aDist < bDist;
+                });
+            auto last = std::unique(rejectedImgPoints.begin(), rejectedImgPoints.end(), compareCandidates);
+            rejectedImgPoints.erase(last, rejectedImgPoints.end());
+
+            for (auto it = rejectedImgPoints.begin(); it != rejectedImgPoints.end();) {
+                bool erased = false;
+                for (const auto& candidate : candidates) {
+                    if (compareCandidates(candidate, *it)) {
+                        it = rejectedImgPoints.erase(it);
+                        erased = true;
+                        break;
+                    }
+                }
+                if (!erased) {
+                    it++;
+                }
+            }
+        }
+
+        /// STEP 3, Optional : Corner refinement :: use contour container
+        if (detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_CONTOUR){
+
+            if (!ids.empty()) {
+
+                // do corner refinement using the contours for each detected markers
+                parallel_for_(Range(0, (int)candidates.size()), [&](const Range& range) {
+                        for (int i = range.start; i < range.end; i++) {
+                        _refineCandidateLines(contours[i], candidates[i]);
+                        }
+                        });
+            }
+        }
+
+        if (detectorParams.cornerRefinementMethod != (int)CORNER_REFINE_SUBPIX && fxfy != 1.f) {
+            // only CORNER_REFINE_SUBPIX implement correctly for useAruco3Detection
+            // Todo: update other CORNER_REFINE methods
+
+            // scale to original size, this however will lead to inaccurate detections!
+            for (auto &vecPoints : candidates)
+                for (auto &point : vecPoints)
+                    point *= 1.f/fxfy;
+        }
+
+        // copy to output arrays
+        _copyVector2Output(candidates, _corners);
+        Mat(ids).copyTo(_ids);
+        if(_rejectedImgPoints.needed()) {
+            _copyVector2Output(rejectedImgPoints, _rejectedImgPoints);
+        }
+        if (_dictIndices.needed()) {
+            Mat(dictIndices).copyTo(_dictIndices);
+        }
+        if (_markersConfidence.needed()) {
+            Mat(markersConfidence).copyTo(_markersConfidence);
+        }
+    }
+
+    /**
+     * @brief Detect square candidates in the input image
+     */
+    void detectCandidates(const Mat& grey, vector<vector<Point2f> >& candidates, vector<vector<Point> >& contours) {
+        /// 1. DETECT FIRST SET OF CANDIDATES
+        _detectInitialCandidates(grey, candidates, contours, detectorParams);
+        /// 2. SORT CORNERS
+        _reorderCandidatesCorners(candidates);
+    }
+
+    /**
+     * @brief FILTER OUT NEAR CANDIDATES PAIRS AND TOO NEAR CANDIDATES TO IMAGE BORDER
+     *
+     * save the outer/inner border (i.e. potential candidates) to vector<MarkerCandidateTree>,
+     * clear candidates and contours
+     */
+    vector<MarkerCandidateTree>
+    filterTooCloseCandidates(const Size &imageSize, vector<vector<Point2f> > &candidates, vector<vector<Point> > &contours, int markerSize) {
+        CV_Assert(detectorParams.minMarkerDistanceRate >= 0. && detectorParams.minDistanceToBorder >= 0);
+        vector<MarkerCandidateTree> candidateTree(candidates.size());
+        for(size_t i = 0ull; i < candidates.size(); i++) {
+            candidateTree[i] = MarkerCandidateTree(std::move(candidates[i]), std::move(contours[i]));
+        }
+
+        // sort candidates from big to small
+        std::stable_sort(candidateTree.begin(), candidateTree.end());
+        // group index for each candidate
+        vector<int> groupId(candidateTree.size(), -1);
+        vector<vector<size_t> > groupedCandidates;
+        vector<bool> isSelectedContours(candidateTree.size(), true);
+
+        for (size_t i = 0ull; i < candidateTree.size(); i++) {
+            for (size_t j = i + 1ull; j < candidateTree.size(); j++) {
+                float minDist = getAverageDistance(candidateTree[i].corners, candidateTree[j].corners);
+                // if mean distance is too low, group markers
+                // the distance between the points of two independent markers should be more than half the side of the marker
+                // half the side of the marker = (perimeter / 4) * 0.5 = perimeter * 0.125
+                if(minDist < candidateTree[j].perimeter*(float)detectorParams.minMarkerDistanceRate) {
+                    isSelectedContours[i] = false;
+                    isSelectedContours[j] = false;
+                    // i and j are not related to a group
+                    if(groupId[i] < 0 && groupId[j] < 0){
+                        // mark candidates with their corresponding group number
+                        groupId[i] = groupId[j] = (int)groupedCandidates.size();
+                        // create group
+                        groupedCandidates.push_back({i, j});
+                    }
+                    // i is related to a group
+                    else if(groupId[i] > -1 && groupId[j] == -1) {
+                        int group = groupId[i];
+                        groupId[j] = group;
+                        // add to group
+                        groupedCandidates[group].push_back(j);
+                    }
+                    // j is related to a group
+                    else if(groupId[j] > -1 && groupId[i] == -1) {
+                        int group = groupId[j];
+                        groupId[i] = group;
+                        // add to group
+                        groupedCandidates[group].push_back(i);
+                    }
+                }
+            }
+            // group of one candidate
+            if(isSelectedContours[i]) {
+                isSelectedContours[i] = false;
+                groupId[i] = (int)groupedCandidates.size();
+                groupedCandidates.push_back({i});
+            }
+        }
+
+        for (vector<size_t>& grouped : groupedCandidates) {
+            if (detectorParams.detectInvertedMarker) // if detectInvertedMarker choose smallest contours
+                std::stable_sort(grouped.begin(), grouped.end(), [](const size_t &a, const size_t &b) {
+                    return a > b;
+                });
+            else // if detectInvertedMarker==false choose largest contours
+                std::stable_sort(grouped.begin(), grouped.end());
+            size_t currId = grouped[0];
+            // check if it is too near to the image border
+            bool tooNearBorder = false;
+            for (const auto& corner : candidateTree[currId].corners) {
+                if (corner.x < detectorParams.minDistanceToBorder ||
+                    corner.y < detectorParams.minDistanceToBorder ||
+                    corner.x > imageSize.width - 1 - detectorParams.minDistanceToBorder ||
+                    corner.y > imageSize.height - 1 - detectorParams.minDistanceToBorder) {
+                    tooNearBorder = true;
+                    break;
+                }
+            }
+            if (tooNearBorder) {
+                continue;
+            }
+            isSelectedContours[currId] = true;
+            for (size_t i = 1ull; i < grouped.size(); i++) {
+                size_t id = grouped[i];
+                float dist = getAverageDistance(candidateTree[id].corners, candidateTree[currId].corners);
+                float moduleSize = getAverageModuleSize(candidateTree[id].corners, markerSize, detectorParams.markerBorderBits);
+                if (dist > detectorParams.minGroupDistance*moduleSize) {
+                    currId = id;
+                    candidateTree[grouped[0]].closeContours.push_back(candidateTree[id]);
+                }
+            }
+        }
+
+        vector<MarkerCandidateTree> selectedCandidates;
+        selectedCandidates.reserve(groupedCandidates.size());
+        for (size_t i = 0ull; i < candidateTree.size(); i++) {
+            if (isSelectedContours[i]) {
+                selectedCandidates.push_back(std::move(candidateTree[i]));
+            }
+        }
+
+        // find hierarchy in the candidate tree
+        for (int i = (int)selectedCandidates.size()-1; i >= 0; i--) {
+            for (int j = i - 1; j >= 0; j--) {
+                if (checkMarker1InMarker2(selectedCandidates[i].corners, selectedCandidates[j].corners)) {
+                    selectedCandidates[i].parent = j;
+                    selectedCandidates[j].depth = max(selectedCandidates[j].depth, selectedCandidates[i].depth + 1);
+                    break;
+                }
+            }
+        }
+        return selectedCandidates;
+    }
+
+    /**
+     * @brief Identify square candidates according to a marker dictionary
+     */
+    void identifyCandidates(const Mat& grey, const vector<Mat>& image_pyr, vector<MarkerCandidateTree>& selectedContours,
+                            vector<vector<Point2f> >& accepted, vector<vector<Point> >& contours,
+                            vector<int>& ids, const Dictionary& currentDictionary, vector<vector<Point2f>>& rejected, vector<float>& markersConfidence, bool confidenceNeeded) const {
+        size_t ncandidates = selectedContours.size();
+
+        vector<float> markersConfidenceTmp(ncandidates, 0.f);
+        vector<int> idsTmp(ncandidates, -1);
+        vector<int> rotated(ncandidates, 0);
+        vector<uint8_t> validCandidates(ncandidates, 0);
+        vector<uint8_t> was(ncandidates, false);
+        bool checkCloseContours = true;
+
+        int maxDepth = 0;
+        for (size_t i = 0ull; i < selectedContours.size(); i++)
+            maxDepth = max(selectedContours[i].depth, maxDepth);
+        vector<vector<size_t>> depths(maxDepth+1);
+        for (size_t i = 0ull; i < selectedContours.size(); i++) {
+            depths[selectedContours[i].depth].push_back(i);
+        }
+
+        //// Analyze each of the candidates
+        int depth = 0;
+        size_t counter = 0;
+        while (counter < ncandidates) {
+            parallel_for_(Range(0, (int)depths[depth].size()), [&](const Range& range) {
+                const int begin = range.start;
+                const int end = range.end;
+                for (int i = begin; i < end; i++) {
+                    size_t v = depths[depth][i];
+                    was[v] = true;
+                    Mat img = grey;
+                    // implements equation (4)
+                    if (detectorParams.useAruco3Detection) {
+                        const int minPerimeter = detectorParams.minSideLengthCanonicalImg * 4;
+                        const size_t nearestImgId = _findOptPyrImageForCanonicalImg(image_pyr, grey.cols, static_cast<int>(selectedContours[v].contour.size()), minPerimeter);
+                        img = image_pyr[nearestImgId];
+                    }
+                    const float scale = detectorParams.useAruco3Detection ? img.cols / static_cast<float>(grey.cols) : 1.f;
+
+                    validCandidates[v] = _identifyOneCandidate(currentDictionary, img, selectedContours[v].corners, idsTmp[v], detectorParams, rotated[v], markersConfidenceTmp[v], confidenceNeeded, scale);
+
+                    if (validCandidates[v] == 0 && checkCloseContours) {
+                        for (const MarkerCandidate& closeMarkerCandidate: selectedContours[v].closeContours) {
+                            validCandidates[v] = _identifyOneCandidate(currentDictionary, img, closeMarkerCandidate.corners, idsTmp[v], detectorParams, rotated[v], markersConfidenceTmp[v], confidenceNeeded, scale);
+                            if (validCandidates[v] > 0) {
+                                selectedContours[v].corners = closeMarkerCandidate.corners;
+                                selectedContours[v].contour = closeMarkerCandidate.contour;
+                                break;
+                            }
+                        }
+                    }
+                }
+            });
+
+            // visit the parent vertices of the detected markers to skip identify parent contours
+            for(size_t v : depths[depth]) {
+                if(validCandidates[v] > 0) {
+                    int parent = selectedContours[v].parent;
+                    while (parent != -1) {
+                        if (!was[parent]) {
+                            was[parent] = true;
+                            counter++;
+                        }
+                        parent = selectedContours[parent].parent;
+                    }
+                }
+                counter++;
+            }
+            depth++;
+        }
+
+        for (size_t i = 0ull; i < selectedContours.size(); i++) {
+            if (validCandidates[i] > 0) {
+                // shift corner positions to the correct rotation
+                correctCornerPosition(selectedContours[i].corners, rotated[i]);
+
+                accepted.push_back(selectedContours[i].corners);
+                contours.push_back(selectedContours[i].contour);
+                ids.push_back(idsTmp[i]);
+            } else {
+                rejected.push_back(selectedContours[i].corners);
+            }
+        }
+
+        if(confidenceNeeded) {
+            for (size_t i = 0ull; i < selectedContours.size(); i++) {
+                if (validCandidates[i] > 0) {
+                    markersConfidence.push_back(markersConfidenceTmp[i]);
+                }
+            }
+        }
+    }
+
+    void performCornerSubpixRefinement(const Mat& grey, const vector<Mat>& grey_pyramid, int closest_pyr_image_idx, const vector<vector<Point2f>>& candidates, const Dictionary& dictionary) const {
+        CV_Assert(detectorParams.cornerRefinementWinSize > 0 && detectorParams.cornerRefinementMaxIterations > 0 &&
+                detectorParams.cornerRefinementMinAccuracy > 0);
+        // Do subpixel estimation. In Aruco3 start on the lowest pyramid level and upscale the corners
+        parallel_for_(Range(0, (int)candidates.size()), [&](const Range& range) {
+            const int begin = range.start;
+            const int end = range.end;
+
+            for (int i = begin; i < end; i++) {
+                if (detectorParams.useAruco3Detection) {
+                    const float scale_init = (float) grey_pyramid[closest_pyr_image_idx].cols / grey.cols;
+                    findCornerInPyrImage(scale_init, closest_pyr_image_idx, grey_pyramid, Mat(candidates[i]), detectorParams);
+                } else {
+                    int cornerRefinementWinSize = std::max(1, cvRound(detectorParams.relativeCornerRefinmentWinSize*
+                                getAverageModuleSize(candidates[i], dictionary.markerSize, detectorParams.markerBorderBits)));
+                    cornerRefinementWinSize = min(cornerRefinementWinSize, detectorParams.cornerRefinementWinSize);
+                    cornerSubPix(grey, Mat(candidates[i]), Size(cornerRefinementWinSize, cornerRefinementWinSize), Size(-1, -1),
+                            TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                detectorParams.cornerRefinementMaxIterations,
+                                detectorParams.cornerRefinementMinAccuracy));
+                }
+            }
+        });
+    }
+};
+
+ArucoDetector::ArucoDetector(const Dictionary &_dictionary,
+                             const DetectorParameters &_detectorParams,
+                             const RefineParameters& _refineParams) {
+    arucoDetectorImpl = makePtr<ArucoDetectorImpl>(vector<Dictionary>{_dictionary}, _detectorParams, _refineParams);
+}
+
+ArucoDetector::ArucoDetector(const vector<Dictionary> &_dictionaries,
+                             const DetectorParameters &_detectorParams,
+                             const RefineParameters& _refineParams) {
+    arucoDetectorImpl = makePtr<ArucoDetectorImpl>(_dictionaries, _detectorParams, _refineParams);
+}
+
+void ArucoDetector::detectMarkersWithConfidence(InputArray _image, OutputArrayOfArrays _corners, OutputArray _ids, OutputArray _markersConfidence,
+                                  OutputArrayOfArrays _rejectedImgPoints) const {
+    arucoDetectorImpl->detectMarkers(_image, _corners, _ids, _rejectedImgPoints, noArray(), _markersConfidence, DictionaryMode::Single);
+}
+
+void ArucoDetector::detectMarkers(InputArray _image, OutputArrayOfArrays _corners, OutputArray _ids,
+                                  OutputArrayOfArrays _rejectedImgPoints) const {
+    arucoDetectorImpl->detectMarkers(_image, _corners, _ids, _rejectedImgPoints, noArray(), noArray(), DictionaryMode::Single);
+}
+
+void ArucoDetector::detectMarkersMultiDict(InputArray _image, OutputArrayOfArrays _corners, OutputArray _ids,
+                                  OutputArrayOfArrays _rejectedImgPoints, OutputArray _dictIndices) const {
+    arucoDetectorImpl->detectMarkers(_image, _corners, _ids, _rejectedImgPoints, _dictIndices, noArray(), DictionaryMode::Multi);
+}
+
+/**
+  * Project board markers that are not included in the list of detected markers
+  */
+static inline void _projectUndetectedMarkers(const Board &board, InputOutputArrayOfArrays detectedCorners,
+                                             InputOutputArray detectedIds, InputArray cameraMatrix, InputArray distCoeffs,
+                                             vector<vector<Point2f> >& undetectedMarkersProjectedCorners,
+                                             OutputArray undetectedMarkersIds) {
+    Mat rvec, tvec; // first estimate board pose with the current avaible markers
+    Mat objPoints, imgPoints; // object and image points for the solvePnP function
+    // To refine corners of ArUco markers the function refineDetectedMarkers() find an aruco markers pose from 3D-2D point correspondences.
+    // To find 3D-2D point correspondences uses matchImagePoints().
+    // The method matchImagePoints() works with ArUco corners (in Board/GridBoard cases) or with ChArUco corners (in CharucoBoard case).
+    // To refine corners of ArUco markers we need work with ArUco corners only in all boards.
+    // To call matchImagePoints() with ArUco corners for all boards we need to call matchImagePoints() from base class Board.
+    // The method matchImagePoints() implemented in Pimpl and we need to create temp Board object to call the base method.
+    Board(board.getObjPoints(), board.getDictionary(), board.getIds()).matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints);
+    if (objPoints.total() < 4ull) // at least one marker from board so rvec and tvec are valid
+        return;
+    solvePnP(objPoints, imgPoints, cameraMatrix, distCoeffs, rvec, tvec);
+
+    // search undetected markers and project them using the previous pose
+    vector<vector<Point2f> > undetectedCorners;
+    const std::vector<int>& ids = board.getIds();
+    vector<int> undetectedIds;
+    for(unsigned int i = 0; i < ids.size(); i++) {
+        int foundIdx = -1;
+        for(unsigned int j = 0; j < detectedIds.total(); j++) {
+            if(ids[i] == detectedIds.getMat().ptr<int>()[j]) {
+                foundIdx = j;
+                break;
+            }
+        }
+
+        // not detected
+        if(foundIdx == -1) {
+            undetectedCorners.push_back(vector<Point2f>());
+            undetectedIds.push_back(ids[i]);
+            projectPoints(board.getObjPoints()[i], rvec, tvec, cameraMatrix, distCoeffs,
+                          undetectedCorners.back());
+        }
+    }
+    // parse output
+    Mat(undetectedIds).copyTo(undetectedMarkersIds);
+    undetectedMarkersProjectedCorners = undetectedCorners;
+}
+
+/**
+  * Interpolate board markers that are not included in the list of detected markers using
+  * global homography
+  */
+static void _projectUndetectedMarkers(const Board &_board, InputOutputArrayOfArrays _detectedCorners,
+                               InputOutputArray _detectedIds,
+                               vector<vector<Point2f> >& _undetectedMarkersProjectedCorners,
+                               OutputArray _undetectedMarkersIds) {
+    // check board points are in the same plane, if not, global homography cannot be applied
+    CV_Assert(_board.getObjPoints().size() > 0);
+    CV_Assert(_board.getObjPoints()[0].size() > 0);
+    float boardZ = _board.getObjPoints()[0][0].z;
+    for(unsigned int i = 0; i < _board.getObjPoints().size(); i++) {
+        for(unsigned int j = 0; j < _board.getObjPoints()[i].size(); j++)
+            CV_Assert(boardZ == _board.getObjPoints()[i][j].z);
+    }
+
+    vector<Point2f> detectedMarkersObj2DAll; // Object coordinates (without Z) of all the detected
+                                             // marker corners in a single vector
+    vector<Point2f> imageCornersAll; // Image corners of all detected markers in a single vector
+    vector<vector<Point2f> > undetectedMarkersObj2D; // Object coordinates (without Z) of all
+                                                        // missing markers in different vectors
+    vector<int> undetectedMarkersIds; // ids of missing markers
+    // find markers included in board, and missing markers from board. Fill the previous vectors
+    for(unsigned int j = 0; j < _board.getIds().size(); j++) {
+        bool found = false;
+        for(unsigned int i = 0; i < _detectedIds.total(); i++) {
+            if(_detectedIds.getMat().ptr<int>()[i] == _board.getIds()[j]) {
+                for(int c = 0; c < 4; c++) {
+                    imageCornersAll.push_back(_detectedCorners.getMat(i).ptr<Point2f>()[c]);
+                    detectedMarkersObj2DAll.push_back(
+                        Point2f(_board.getObjPoints()[j][c].x, _board.getObjPoints()[j][c].y));
+                }
+                found = true;
+                break;
+            }
+        }
+        if(!found) {
+            undetectedMarkersObj2D.push_back(vector<Point2f>());
+            for(int c = 0; c < 4; c++) {
+                undetectedMarkersObj2D.back().push_back(
+                    Point2f(_board.getObjPoints()[j][c].x, _board.getObjPoints()[j][c].y));
+            }
+            undetectedMarkersIds.push_back(_board.getIds()[j]);
+        }
+    }
+    if(imageCornersAll.size() == 0) return;
+
+    // get homography from detected markers
+    Mat transformation = findHomography(detectedMarkersObj2DAll, imageCornersAll);
+
+    _undetectedMarkersProjectedCorners.resize(undetectedMarkersIds.size());
+
+    // for each undetected marker, apply transformation
+    for(unsigned int i = 0; i < undetectedMarkersObj2D.size(); i++) {
+        perspectiveTransform(undetectedMarkersObj2D[i], _undetectedMarkersProjectedCorners[i], transformation);
+    }
+    Mat(undetectedMarkersIds).copyTo(_undetectedMarkersIds);
+}
+
+void ArucoDetector::refineDetectedMarkers(InputArray _image, const Board& _board,
+                                          InputOutputArrayOfArrays _detectedCorners, InputOutputArray _detectedIds,
+                                          InputOutputArrayOfArrays _rejectedCorners, InputArray _cameraMatrix,
+                                          InputArray _distCoeffs, OutputArray _recoveredIdxs) const {
+    DetectorParameters& detectorParams = arucoDetectorImpl->detectorParams;
+    const Dictionary& dictionary = arucoDetectorImpl->dictionaries.at(0);
+    RefineParameters& refineParams = arucoDetectorImpl->refineParams;
+    CV_Assert(refineParams.minRepDistance > 0);
+
+    if(_detectedIds.total() == 0 || _rejectedCorners.total() == 0) return;
+
+    // get projections of missing markers in the board
+    vector<vector<Point2f> > undetectedMarkersCorners;
+    vector<int> undetectedMarkersIds;
+    if(_cameraMatrix.total() != 0) {
+        // reproject based on camera projection model
+        _projectUndetectedMarkers(_board, _detectedCorners, _detectedIds, _cameraMatrix, _distCoeffs,
+                                  undetectedMarkersCorners, undetectedMarkersIds);
+
+    } else {
+        // reproject based on global homography
+        _projectUndetectedMarkers(_board, _detectedCorners, _detectedIds, undetectedMarkersCorners,
+                                  undetectedMarkersIds);
+    }
+
+    // list of missing markers indicating if they have been assigned to a candidate
+    vector<bool > alreadyIdentified(_rejectedCorners.total(), false);
+
+    // maximum bits that can be corrected
+    int maxCorrectionRecalculated =
+        int(double(dictionary.maxCorrectionBits) * refineParams.errorCorrectionRate);
+
+    Mat grey;
+    _convertToGrey(_image, grey);
+
+    // vector of final detected marker corners and ids
+    vector<vector<Point2f> > finalAcceptedCorners;
+    vector<int> finalAcceptedIds;
+    // fill with the current markers
+    finalAcceptedCorners.resize(_detectedCorners.total());
+    finalAcceptedIds.resize(_detectedIds.total());
+    for(unsigned int i = 0; i < _detectedIds.total(); i++) {
+        finalAcceptedCorners[i] = _detectedCorners.getMat(i).clone();
+        finalAcceptedIds[i] = _detectedIds.getMat().ptr<int>()[i];
+    }
+    vector<int> recoveredIdxs; // original indexes of accepted markers in _rejectedCorners
+
+    // for each missing marker, try to find a correspondence
+    for(unsigned int i = 0; i < undetectedMarkersIds.size(); i++) {
+
+        // best match at the moment
+        int closestCandidateIdx = -1;
+        double closestCandidateDistance = refineParams.minRepDistance * refineParams.minRepDistance + 1;
+        Mat closestRotatedMarker;
+
+        for(unsigned int j = 0; j < _rejectedCorners.total(); j++) {
+            if(alreadyIdentified[j]) continue;
+
+            // check distance
+            double minDistance = closestCandidateDistance + 1;
+            bool valid = false;
+            int validRot = 0;
+            for(int c = 0; c < 4; c++) { // first corner in rejected candidate
+                double currentMaxDistance = 0;
+                for(int k = 0; k < 4; k++) {
+                    Point2f rejCorner = _rejectedCorners.getMat(j).ptr<Point2f>()[(c + k) % 4];
+                    Point2f distVector = undetectedMarkersCorners[i][k] - rejCorner;
+                    double cornerDist = distVector.x * distVector.x + distVector.y * distVector.y;
+                    currentMaxDistance = max(currentMaxDistance, cornerDist);
+                }
+                // if distance is better than current best distance
+                if(currentMaxDistance < closestCandidateDistance) {
+                    valid = true;
+                    validRot = c;
+                    minDistance = currentMaxDistance;
+                }
+                if(!refineParams.checkAllOrders) break;
+            }
+
+            if(!valid) continue;
+
+            // apply rotation
+            Mat rotatedMarker;
+            if(refineParams.checkAllOrders) {
+                rotatedMarker = Mat(4, 1, CV_32FC2);
+                for(int c = 0; c < 4; c++)
+                    rotatedMarker.ptr<Point2f>()[c] =
+                        _rejectedCorners.getMat(j).ptr<Point2f>()[(c + 4 + validRot) % 4];
+            }
+            else rotatedMarker = _rejectedCorners.getMat(j);
+
+            // last filter, check if inner code is close enough to the assigned marker code
+            int codeDistance = 0;
+            // if errorCorrectionRate, don't check code
+            if(refineParams.errorCorrectionRate >= 0) {
+
+                // extract bits
+                Mat cellPixelRatio = _extractCellPixelRatio(
+                    grey, rotatedMarker, dictionary.markerSize, detectorParams.markerBorderBits,
+                    detectorParams.perspectiveRemovePixelPerCell,
+                    detectorParams.perspectiveRemoveIgnoredMarginPerCell, detectorParams.minOtsuStdDev);
+
+                Mat bits;
+                cellPixelRatio.convertTo(bits, CV_8UC1);
+
+                Mat onlyBits =
+                    bits.rowRange(detectorParams.markerBorderBits, bits.rows - detectorParams.markerBorderBits)
+                        .colRange(detectorParams.markerBorderBits, bits.rows - detectorParams.markerBorderBits);
+
+                codeDistance =
+                    dictionary.getDistanceToId(onlyBits, undetectedMarkersIds[i], false);
+            }
+
+            // if everythin is ok, assign values to current best match
+            if(refineParams.errorCorrectionRate < 0 || codeDistance < maxCorrectionRecalculated) {
+                closestCandidateIdx = j;
+                closestCandidateDistance = minDistance;
+                closestRotatedMarker = rotatedMarker;
+            }
+        }
+
+        // if at least one good match, we have rescue the missing marker
+        if(closestCandidateIdx >= 0) {
+
+            // subpixel refinement
+            if(detectorParams.cornerRefinementMethod == (int)CORNER_REFINE_SUBPIX) {
+                CV_Assert(detectorParams.cornerRefinementWinSize > 0 &&
+                          detectorParams.cornerRefinementMaxIterations > 0 &&
+                          detectorParams.cornerRefinementMinAccuracy > 0);
+
+                std::vector<Point2f> marker(closestRotatedMarker.begin<Point2f>(), closestRotatedMarker.end<Point2f>());
+                int cornerRefinementWinSize = std::max(1, cvRound(detectorParams.relativeCornerRefinmentWinSize*
+                                              getAverageModuleSize(marker, dictionary.markerSize, detectorParams.markerBorderBits)));
+                cornerRefinementWinSize = min(cornerRefinementWinSize, detectorParams.cornerRefinementWinSize);
+                cornerSubPix(grey, closestRotatedMarker,
+                             Size(cornerRefinementWinSize, cornerRefinementWinSize),
+                             Size(-1, -1), TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                                        detectorParams.cornerRefinementMaxIterations,
+                                                        detectorParams.cornerRefinementMinAccuracy));
+            }
+
+            // remove from rejected
+            alreadyIdentified[closestCandidateIdx] = true;
+
+            // add to detected
+            finalAcceptedCorners.push_back(closestRotatedMarker);
+            finalAcceptedIds.push_back(undetectedMarkersIds[i]);
+
+            // add the original index of the candidate
+            recoveredIdxs.push_back(closestCandidateIdx);
+        }
+    }
+
+    // parse output
+    if(finalAcceptedIds.size() != _detectedIds.total()) {
+        // parse output
+        Mat(finalAcceptedIds).copyTo(_detectedIds);
+        _copyVector2Output(finalAcceptedCorners, _detectedCorners);
+
+        vector<vector<Point2f> > rejectedCorners;
+        _copyInput2Vector(_rejectedCorners, rejectedCorners);
+
+        // recalculate _rejectedCorners based on alreadyIdentified
+        vector<vector<Point2f> > finalRejected;
+        for(size_t i = 0; i < alreadyIdentified.size(); i++) {
+            if(!alreadyIdentified[i]) {
+                finalRejected.push_back(rejectedCorners[i]);
+            }
+        }
+        rejectedCorners.clear();
+        for (size_t i = 0; i < finalRejected.size(); i++)
+            rejectedCorners.push_back(finalRejected[i]);
+        _copyVector2Output(rejectedCorners, _rejectedCorners);
+
+        if(_recoveredIdxs.needed()) {
+            Mat(recoveredIdxs).copyTo(_recoveredIdxs);
+        }
+    }
+}
+
+void ArucoDetector::write(FileStorage &fs) const {
+    // preserve old format for single dictionary case
+    if (1 == arucoDetectorImpl->dictionaries.size()) {
+        arucoDetectorImpl->dictionaries[0].writeDictionary(fs);
+    } else {
+        fs << "dictionaries" << "[";
+        for (auto& dictionary : arucoDetectorImpl->dictionaries) {
+            fs << "{";
+            dictionary.writeDictionary(fs);
+            fs << "}";
+        }
+        fs << "]";
+    }
+    arucoDetectorImpl->detectorParams.writeDetectorParameters(fs);
+    arucoDetectorImpl->refineParams.writeRefineParameters(fs);
+}
+
+void ArucoDetector::read(const FileNode &fn) {
+    arucoDetectorImpl->dictionaries.clear();
+    if (!fn.empty() && !fn["dictionaries"].empty() && fn["dictionaries"].isSeq()) {
+        for (const auto& dictionaryNode : fn["dictionaries"]) {
+            arucoDetectorImpl->dictionaries.emplace_back();
+            arucoDetectorImpl->dictionaries.back().readDictionary(dictionaryNode);
+        }
+    } else {
+        // backward compatibility
+        arucoDetectorImpl->dictionaries.emplace_back();
+        arucoDetectorImpl->dictionaries.back().readDictionary(fn);
+    }
+    arucoDetectorImpl->detectorParams.readDetectorParameters(fn);
+    arucoDetectorImpl->refineParams.readRefineParameters(fn);
+}
+
+const Dictionary& ArucoDetector::getDictionary() const {
+    return arucoDetectorImpl->dictionaries[0];
+}
+
+void ArucoDetector::setDictionary(const Dictionary& dictionary) {
+    if (arucoDetectorImpl->dictionaries.empty()) {
+        arucoDetectorImpl->dictionaries.push_back(dictionary);
+    } else {
+        arucoDetectorImpl->dictionaries[0] = dictionary;
+    }
+}
+
+vector<Dictionary> ArucoDetector::getDictionaries() const {
+    return arucoDetectorImpl->dictionaries;
+}
+
+void ArucoDetector::setDictionaries(const vector<Dictionary>& dictionaries) {
+    CV_Assert(!dictionaries.empty());
+    arucoDetectorImpl->dictionaries = dictionaries;
+}
+
+const DetectorParameters& ArucoDetector::getDetectorParameters() const {
+    return arucoDetectorImpl->detectorParams;
+}
+
+void ArucoDetector::setDetectorParameters(const DetectorParameters& detectorParameters) {
+    arucoDetectorImpl->detectorParams = detectorParameters;
+}
+
+const RefineParameters& ArucoDetector::getRefineParameters() const {
+    return arucoDetectorImpl->refineParams;
+}
+
+void ArucoDetector::setRefineParameters(const RefineParameters& refineParameters) {
+    arucoDetectorImpl->refineParams = refineParameters;
+}
+
+void drawDetectedMarkers(InputOutputArray _image, InputArrayOfArrays _corners,
+                         InputArray _ids, Scalar borderColor) {
+    CV_Assert(_image.getMat().total() != 0 &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_corners.total() == _ids.total()) || _ids.total() == 0);
+
+    // calculate colors
+    Scalar textColor, cornerColor;
+    textColor = cornerColor = borderColor;
+    swap(textColor.val[0], textColor.val[1]);     // text color just sawp G and R
+    swap(cornerColor.val[1], cornerColor.val[2]); // corner color just sawp G and B
+
+    int nMarkers = (int)_corners.total();
+    for(int i = 0; i < nMarkers; i++) {
+        Mat currentMarker = _corners.getMat(i);
+        CV_Assert(currentMarker.total() == 4 && currentMarker.channels() == 2);
+        if (currentMarker.type() != CV_32SC2)
+            currentMarker.convertTo(currentMarker, CV_32SC2);
+
+        // draw marker sides
+        for(int j = 0; j < 4; j++) {
+            Point p0, p1;
+            p0 = currentMarker.ptr<Point>(0)[j];
+            p1 = currentMarker.ptr<Point>(0)[(j + 1) % 4];
+            line(_image, p0, p1, borderColor, 1);
+        }
+        // draw first corner mark
+        rectangle(_image, currentMarker.ptr<Point>(0)[0] - Point(3, 3),
+                  currentMarker.ptr<Point>(0)[0] + Point(3, 3), cornerColor, 1, LINE_AA);
+
+        // draw ID
+        if(_ids.total() != 0) {
+            Point cent(0, 0);
+            for(int p = 0; p < 4; p++)
+                cent += currentMarker.ptr<Point>(0)[p];
+            cent = cent / 4.;
+            stringstream s;
+            s << "id=" << _ids.getMat().ptr<int>(0)[i];
+            putText(_image, s.str(), cent, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 2);
+        }
+    }
+}
+
+void generateImageMarker(const Dictionary &dictionary, int id, int sidePixels, OutputArray _img, int borderBits) {
+    dictionary.generateImageMarker(id, sidePixels, _img, borderBits);
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp b/upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp
new file mode 100644
index 0000000..b8e478f
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/aruco_dictionary.cpp
@@ -0,0 +1,490 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include "opencv2/core/hal/hal.hpp"
+
+#include "aruco_utils.hpp"
+#include "predefined_dictionaries.hpp"
+#include "apriltag/predefined_dictionaries_apriltag.hpp"
+#include <opencv2/objdetect/aruco_dictionary.hpp>
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+Dictionary::Dictionary(): markerSize(0), maxCorrectionBits(0) {}
+
+
+Dictionary::Dictionary(const Mat &_bytesList, int _markerSize, int _maxcorr) {
+    markerSize = _markerSize;
+    maxCorrectionBits = _maxcorr;
+    bytesList = _bytesList;
+}
+
+
+bool Dictionary::readDictionary(const cv::FileNode& fn) {
+    int nMarkers = 0, _markerSize = 0;
+    if (fn.empty() || !readParameter("nmarkers", nMarkers, fn) || !readParameter("markersize", _markerSize, fn))
+        return false;
+    Mat bytes(0, 0, CV_8UC1), marker(_markerSize, _markerSize, CV_8UC1);
+    std::string markerString;
+    for (int i = 0; i < nMarkers; i++) {
+        std::ostringstream ostr;
+        ostr << i;
+        if (!readParameter("marker_" + ostr.str(), markerString, fn))
+            return false;
+        for (int j = 0; j < (int) markerString.size(); j++)
+            marker.at<unsigned char>(j) = (markerString[j] == '0') ? 0 : 1;
+        bytes.push_back(Dictionary::getByteListFromBits(marker));
+    }
+    int _maxCorrectionBits = 0;
+    readParameter("maxCorrectionBits", _maxCorrectionBits, fn);
+    *this = Dictionary(bytes, _markerSize, _maxCorrectionBits);
+    return true;
+}
+
+void Dictionary::writeDictionary(FileStorage& fs, const String &name)
+{
+    CV_Assert(fs.isOpened());
+
+    if (!name.empty())
+        fs << name << "{";
+
+    fs << "nmarkers" << bytesList.rows;
+    fs << "markersize" << markerSize;
+    fs << "maxCorrectionBits" << maxCorrectionBits;
+    for (int i = 0; i < bytesList.rows; i++) {
+        Mat row = bytesList.row(i);;
+        Mat bitMarker = getBitsFromByteList(row, markerSize);
+        std::ostringstream ostr;
+        ostr << i;
+        string markerName = "marker_" + ostr.str();
+        string marker;
+        for (int j = 0; j < markerSize * markerSize; j++)
+            marker.push_back(bitMarker.at<uint8_t>(j) + '0');
+        fs << markerName << marker;
+    }
+
+    if (!name.empty())
+        fs << "}";
+}
+
+
+bool Dictionary::identify(const Mat &onlyCellPixelRatio, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate, float validBitIdThreshold) const {
+    CV_Assert(onlyCellPixelRatio.rows == markerSize && onlyCellPixelRatio.cols == markerSize);
+
+    int maxCorrectionRecalculed = int(double(maxCorrectionBits) * maxCorrectionRate);
+
+    idx = -1; // by default, not found
+
+    // search closest marker in dict
+    for(int m = 0; m < bytesList.rows; m++) {
+        int currentMinDistance = markerSize * markerSize + 1;
+        int currentRotation = -1;
+        for(int r = 0; r < 4; r++) {
+
+            Mat bitsRot = getBitsFromByteList(bytesList.rowRange(m, m + 1), markerSize, r);
+            bitsRot.convertTo(bitsRot, CV_32F);
+
+            // Loop over all bits dictBitsList [m, markerSize * markerSize, 4]; onlyCellPixelRatio [markerSize, markerSize]
+            int currentHamming = 0;
+            for(int i = 0; i < markerSize; i++) {
+                for(int j = 0; j < markerSize; j++) {
+                    // If detected bit is too far from the ground truth, consider it false.
+                    if(fabs(onlyCellPixelRatio.at<float>(i, j) - static_cast<float>(bitsRot.at<float>(i, j))) > validBitIdThreshold){
+                        currentHamming++;
+                    }
+                }
+            }
+
+            if(currentHamming < currentMinDistance) {
+                currentMinDistance = currentHamming;
+                currentRotation = r;
+            }
+        }
+
+        // if maxCorrection is fulfilled, return this one
+        if(currentMinDistance <= maxCorrectionRecalculed) {
+            idx = m;
+            rotation = currentRotation;
+            break;
+        }
+    }
+
+    return idx != -1;
+}
+
+
+bool Dictionary::identify(const Mat &onlyBits, CV_OUT int &idx, CV_OUT int &rotation, double maxCorrectionRate) const {
+    CV_Assert(onlyBits.rows == markerSize && onlyBits.cols == markerSize);
+
+    Mat candidateBitRatio;
+    onlyBits.convertTo(candidateBitRatio, CV_32F);
+    const float validBitIdThreshold = DEFAULT_VALID_BIT_ID_THRESHOLD;
+    return identify(candidateBitRatio, idx, rotation, maxCorrectionRate, validBitIdThreshold);
+}
+
+
+int Dictionary::getDistanceToId(InputArray bits, int id, bool allRotations) const {
+
+    CV_Assert(id >= 0 && id < bytesList.rows);
+
+    unsigned int nRotations = 4;
+    if(!allRotations) nRotations = 1;
+
+    Mat candidateBytes = getByteListFromBits(bits.getMat());
+    int currentMinDistance = int(bits.total() * bits.total());
+    for(unsigned int r = 0; r < nRotations; r++) {
+        int currentHamming = cv::hal::normHamming(
+                bytesList.ptr(id) + r*candidateBytes.cols,
+                candidateBytes.ptr(),
+                candidateBytes.cols);
+
+        if(currentHamming < currentMinDistance) {
+            currentMinDistance = currentHamming;
+        }
+    }
+    return currentMinDistance;
+}
+
+
+void Dictionary::generateImageMarker(int id, int sidePixels, OutputArray _img, int borderBits) const {
+    CV_Assert(sidePixels >= (markerSize + 2*borderBits));
+    CV_Assert(id < bytesList.rows);
+    CV_Assert(borderBits > 0);
+
+    _img.create(sidePixels, sidePixels, CV_8UC1);
+
+    // create small marker with 1 pixel per bin
+    Mat tinyMarker(markerSize + 2 * borderBits, markerSize + 2 * borderBits, CV_8UC1,
+                   Scalar::all(0));
+    Mat innerRegion = tinyMarker.rowRange(borderBits, tinyMarker.rows - borderBits)
+                          .colRange(borderBits, tinyMarker.cols - borderBits);
+    // put inner bits
+    Mat bits = getMarkerBits(id);
+    bits.convertTo(bits, CV_8U, 255.0);
+    CV_Assert(innerRegion.total() == bits.total());
+    bits.copyTo(innerRegion);
+
+    // resize tiny marker to output size
+    cv::resize(tinyMarker, _img.getMat(), _img.getMat().size(), 0, 0, INTER_NEAREST);
+}
+
+
+Mat Dictionary::getByteListFromBits(const Mat &bits) {
+    // integer ceil
+    int nbytes = (bits.cols * bits.rows + 8 - 1) / 8;
+
+    Mat candidateByteList(1, nbytes, CV_8UC4, Scalar::all(0));
+    unsigned char currentBit = 0;
+    int currentByte = 0;
+
+    // the 4 rotations
+    uchar* rot0 = candidateByteList.ptr();
+    uchar* rot1 = candidateByteList.ptr() + 1*nbytes;
+    uchar* rot2 = candidateByteList.ptr() + 2*nbytes;
+    uchar* rot3 = candidateByteList.ptr() + 3*nbytes;
+
+    for(int row = 0; row < bits.rows; row++) {
+        for(int col = 0; col < bits.cols; col++) {
+            // circular shift
+            rot0[currentByte] <<= 1;
+            rot1[currentByte] <<= 1;
+            rot2[currentByte] <<= 1;
+            rot3[currentByte] <<= 1;
+            // set bit
+            rot0[currentByte] |= bits.at<uchar>(row, col);
+            rot1[currentByte] |= bits.at<uchar>(col, bits.cols - 1 - row);
+            rot2[currentByte] |= bits.at<uchar>(bits.rows - 1 - row, bits.cols - 1 - col);
+            rot3[currentByte] |= bits.at<uchar>(bits.rows - 1 - col, row);
+            currentBit++;
+            if(currentBit == 8) {
+                // next byte
+                currentBit = 0;
+                currentByte++;
+            }
+        }
+    }
+    return candidateByteList;
+}
+
+
+Mat Dictionary::getMarkerBits(int markerId, int rotationId) const {
+
+    const int nbRotations = 4;
+    CV_Assert(markerId < bytesList.rows);
+    CV_Assert(rotationId < nbRotations);
+
+    Mat bits(markerSize, markerSize, CV_32F, Scalar::all(0));
+    Mat bitsUints = getBitsFromByteList(bytesList.rowRange(markerId, markerId + 1), markerSize, rotationId);
+    bitsUints.convertTo(bits, CV_32F);
+
+    CV_Assert(bits.rows == markerSize && bits.cols == markerSize);
+    return bits;
+}
+
+
+Mat Dictionary::getBitsFromByteList(const Mat &byteList, int markerSize, int rotationId) {
+    CV_Assert(byteList.total() > 0 &&
+              byteList.total() >= (unsigned int)markerSize * markerSize / 8 &&
+              byteList.total() <= (unsigned int)markerSize * markerSize / 8 + 1);
+
+    CV_Assert(byteList.channels() >= 4);
+    CV_Assert(rotationId >= 0 && rotationId < 4);
+
+    Mat bits = Mat::zeros(markerSize, markerSize, CV_8UC1);
+    unsigned char *bitsPtr = bits.ptr();
+
+    // Use a base offset for the selected rotation
+    int nbytes = (bits.cols * bits.rows + 8 - 1) / 8; // integer ceil
+    int base = rotationId * nbytes;
+    const unsigned char *currentBytePtr = byteList.ptr() + base;
+    const unsigned char *currentBytePtrEnd = currentBytePtr + bits.total() / 8;
+
+    for(;currentBytePtr < currentBytePtrEnd; ++currentBytePtr) {
+        unsigned char currentByte = *currentBytePtr;
+        for(int mask = 1 << 7; mask != 0; mask >>= 1) {
+            if (currentByte & mask) *bitsPtr = 1;
+            ++bitsPtr;
+        }
+    }
+    // if not enough bits for one more byte, we are in the end
+    // update bit position accordingly
+    if (bits.total() % 8 != 0) {
+        unsigned char currentByte = *currentBytePtrEnd;
+        int mask = 1 << ((bits.total() % 8) - 1);
+        for(; mask != 0; mask >>= 1) {
+            if (currentByte & mask) *bitsPtr = 1;
+            ++bitsPtr;
+        }
+    }
+    return bits;
+}
+
+
+Dictionary getPredefinedDictionary(PredefinedDictionaryType name) {
+    // The maximum number of bits that can be corrected is theoretically (d-1)/2,
+    // where d is the minimum Hamming distance between any two codes in the dictionary.
+    // However, we use a more conservative limit (d/2)-1 to reduce the probability
+    // of false positives during detection. This formula is equivalent to the
+    // theoretical limit for even distances and stricter for odd distances.
+
+    // DictionaryData constructors calls
+    //    moved out of globals so construted on first use, which allows lazy-loading of opencv dll
+    static const Dictionary DICT_ARUCO_DATA = Dictionary(Mat(1024, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_ARUCO_BYTES), 5, (3-1)/2);
+
+    static const Dictionary DICT_4X4_50_DATA = Dictionary(Mat(50, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (4-1)/2);
+    static const Dictionary DICT_4X4_100_DATA = Dictionary(Mat(100, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (3-1)/2);
+    static const Dictionary DICT_4X4_250_DATA = Dictionary(Mat(250, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (3-1)/2);
+    static const Dictionary DICT_4X4_1000_DATA = Dictionary(Mat(1000, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_4X4_1000_BYTES), 4, (2-1)/2);
+
+    static const Dictionary DICT_5X5_50_DATA = Dictionary(Mat(50, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (8-1)/2);
+    static const Dictionary DICT_5X5_100_DATA = Dictionary(Mat(100, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (7-1)/2);
+    static const Dictionary DICT_5X5_250_DATA = Dictionary(Mat(250, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (6-1)/2);
+    static const Dictionary DICT_5X5_1000_DATA = Dictionary(Mat(1000, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_5X5_1000_BYTES), 5, (5-1)/2);
+
+    static const Dictionary DICT_6X6_50_DATA = Dictionary(Mat(50, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (13-1)/2);
+    static const Dictionary DICT_6X6_100_DATA = Dictionary(Mat(100, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (12-1)/2);
+    static const Dictionary DICT_6X6_250_DATA = Dictionary(Mat(250, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (11-1)/2);
+    static const Dictionary DICT_6X6_1000_DATA = Dictionary(Mat(1000, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_6X6_1000_BYTES), 6, (9-1)/2);
+
+    static const Dictionary DICT_7X7_50_DATA = Dictionary(Mat(50, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (19-1)/2);
+    static const Dictionary DICT_7X7_100_DATA = Dictionary(Mat(100, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (18-1)/2);
+    static const Dictionary DICT_7X7_250_DATA = Dictionary(Mat(250, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (17-1)/2);
+    static const Dictionary DICT_7X7_1000_DATA = Dictionary(Mat(1000, (7 * 7 + 7) / 8, CV_8UC4, (uchar*)DICT_7X7_1000_BYTES), 7, (14-1)/2);
+
+    static const Dictionary DICT_APRILTAG_16h5_DATA = Dictionary(Mat(30, (4 * 4 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_16h5_BYTES), 4, (5-1)/2);
+    static const Dictionary DICT_APRILTAG_25h9_DATA = Dictionary(Mat(35, (5 * 5 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_25h9_BYTES), 5, (9-1)/2);
+    static const Dictionary DICT_APRILTAG_36h10_DATA = Dictionary(Mat(2320, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_36h10_BYTES), 6, (10-1)/2);
+    static const Dictionary DICT_APRILTAG_36h11_DATA = Dictionary(Mat(587, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_APRILTAG_36h11_BYTES), 6, (11-1)/2);
+
+    static const Dictionary DICT_ARUCO_MIP_36h12_DATA = Dictionary(Mat(250, (6 * 6 + 7) / 8, CV_8UC4, (uchar*)DICT_ARUCO_MIP_36h12_BYTES), 6, (12-1)/2);
+
+    switch(name) {
+
+    case DICT_ARUCO_ORIGINAL:
+        return Dictionary(DICT_ARUCO_DATA);
+
+    case DICT_4X4_50:
+        return Dictionary(DICT_4X4_50_DATA);
+    case DICT_4X4_100:
+        return Dictionary(DICT_4X4_100_DATA);
+    case DICT_4X4_250:
+        return Dictionary(DICT_4X4_250_DATA);
+    case DICT_4X4_1000:
+        return Dictionary(DICT_4X4_1000_DATA);
+
+    case DICT_5X5_50:
+        return Dictionary(DICT_5X5_50_DATA);
+    case DICT_5X5_100:
+        return Dictionary(DICT_5X5_100_DATA);
+    case DICT_5X5_250:
+        return Dictionary(DICT_5X5_250_DATA);
+    case DICT_5X5_1000:
+        return Dictionary(DICT_5X5_1000_DATA);
+
+    case DICT_6X6_50:
+        return Dictionary(DICT_6X6_50_DATA);
+    case DICT_6X6_100:
+        return Dictionary(DICT_6X6_100_DATA);
+    case DICT_6X6_250:
+        return Dictionary(DICT_6X6_250_DATA);
+    case DICT_6X6_1000:
+        return Dictionary(DICT_6X6_1000_DATA);
+
+    case DICT_7X7_50:
+        return Dictionary(DICT_7X7_50_DATA);
+    case DICT_7X7_100:
+        return Dictionary(DICT_7X7_100_DATA);
+    case DICT_7X7_250:
+        return Dictionary(DICT_7X7_250_DATA);
+    case DICT_7X7_1000:
+        return Dictionary(DICT_7X7_1000_DATA);
+
+    case DICT_APRILTAG_16h5:
+        return Dictionary(DICT_APRILTAG_16h5_DATA);
+    case DICT_APRILTAG_25h9:
+        return Dictionary(DICT_APRILTAG_25h9_DATA);
+    case DICT_APRILTAG_36h10:
+        return Dictionary(DICT_APRILTAG_36h10_DATA);
+    case DICT_APRILTAG_36h11:
+        return Dictionary(DICT_APRILTAG_36h11_DATA);
+
+    case DICT_ARUCO_MIP_36h12:
+        return Dictionary(DICT_ARUCO_MIP_36h12_DATA);
+    }
+    return Dictionary(DICT_4X4_50_DATA);
+}
+
+
+Dictionary getPredefinedDictionary(int dict) {
+    return getPredefinedDictionary(PredefinedDictionaryType(dict));
+}
+
+
+/**
+ * @brief Generates a random marker Mat of size markerSize x markerSize
+ */
+static Mat _generateRandomMarker(int markerSize, RNG &rng) {
+    Mat marker(markerSize, markerSize, CV_8UC1, Scalar::all(0));
+    for(int i = 0; i < markerSize; i++) {
+        for(int j = 0; j < markerSize; j++) {
+            unsigned char bit = (unsigned char) (rng.uniform(0,2));
+            marker.at<unsigned char>(i, j) = bit;
+        }
+    }
+    return marker;
+}
+
+/**
+ * @brief Calculate selfDistance of the codification of a marker Mat. Self distance is the Hamming
+ * distance of the marker to itself in the other rotations.
+ * See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+ * "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+ * Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+ */
+static int _getSelfDistance(const Mat &marker) {
+    Mat bytes = Dictionary::getByteListFromBits(marker);
+    int minHamming = (int)marker.total() + 1;
+    for(int r = 1; r < 4; r++) {
+        int currentHamming = cv::hal::normHamming(bytes.ptr(), bytes.ptr() + bytes.cols*r, bytes.cols);
+        if(currentHamming < minHamming) minHamming = currentHamming;
+    }
+    return minHamming;
+}
+
+
+Dictionary extendDictionary(int nMarkers, int markerSize, const Dictionary &baseDictionary, int randomSeed) {
+    CV_Assert(nMarkers > 0);
+    RNG rng((uint64)(randomSeed));
+
+    Dictionary out = Dictionary(Mat(), markerSize);
+    out.markerSize = markerSize;
+
+    // theoretical maximum intermarker distance
+    // See S. Garrido-Jurado, R. Muñoz-Salinas, F. J. Madrid-Cuevas, and M. J. Marín-Jiménez. 2014.
+    // "Automatic generation and detection of highly reliable fiducial markers under occlusion".
+    // Pattern Recogn. 47, 6 (June 2014), 2280-2292. DOI=10.1016/j.patcog.2014.01.005
+    int C = (int)std::floor(float(markerSize * markerSize) / 4.f);
+    int tau = 2 * (int)std::floor(float(C) * 4.f / 3.f);
+
+    // if baseDictionary is provided, calculate its intermarker distance
+    if(baseDictionary.bytesList.rows > 0) {
+        CV_Assert(baseDictionary.markerSize == markerSize);
+        out.bytesList = baseDictionary.bytesList.rowRange(0, min(nMarkers, baseDictionary.bytesList.rows)).clone();
+
+        int minDistance = markerSize * markerSize + 1;
+        for(int i = 0; i < out.bytesList.rows; i++) {
+            Mat markerBytes = out.bytesList.rowRange(i, i + 1);
+            Mat markerBits = Dictionary::getBitsFromByteList(markerBytes, markerSize);
+            minDistance = min(minDistance, _getSelfDistance(markerBits));
+            for(int j = i + 1; j < out.bytesList.rows; j++) {
+                minDistance = min(minDistance, out.getDistanceToId(markerBits, j));
+            }
+        }
+        tau = minDistance;
+    }
+
+    // current best option
+    int bestTau = 0;
+    Mat bestMarker;
+
+    // after these number of unproductive iterations, the best option is accepted
+    const int maxUnproductiveIterations = 5000;
+    int unproductiveIterations = 0;
+
+    while(out.bytesList.rows < nMarkers) {
+        Mat currentMarker = _generateRandomMarker(markerSize, rng);
+
+        int selfDistance = _getSelfDistance(currentMarker);
+        int minDistance = selfDistance;
+
+        // if self distance is better or equal than current best option, calculate distance
+        // to previous accepted markers
+        if(selfDistance >= bestTau) {
+            for(int i = 0; i < out.bytesList.rows; i++) {
+                int currentDistance = out.getDistanceToId(currentMarker, i);
+                minDistance = min(currentDistance, minDistance);
+                if(minDistance <= bestTau) {
+                    break;
+                }
+            }
+        }
+
+        // if distance is high enough, accept the marker
+        if(minDistance >= tau) {
+            unproductiveIterations = 0;
+            bestTau = 0;
+            Mat bytes = Dictionary::getByteListFromBits(currentMarker);
+            out.bytesList.push_back(bytes);
+        } else {
+            unproductiveIterations++;
+
+            // if distance is not enough, but is better than the current best option
+            if(minDistance > bestTau) {
+                bestTau = minDistance;
+                bestMarker = currentMarker;
+            }
+
+            // if number of unproductive iterarions has been reached, accept the current best option
+            if(unproductiveIterations == maxUnproductiveIterations) {
+                unproductiveIterations = 0;
+                tau = bestTau;
+                bestTau = 0;
+                Mat bytes = Dictionary::getByteListFromBits(bestMarker);
+                out.bytesList.push_back(bytes);
+            }
+        }
+    }
+
+    // update the maximum number of correction bits for the generated dictionary
+    out.maxCorrectionBits = (tau - 1) / 2;
+
+    return out;
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp b/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp
new file mode 100644
index 0000000..4b31787
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.cpp
@@ -0,0 +1,87 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+#include "aruco_utils.hpp"
+
+namespace cv {
+namespace aruco {
+using namespace std;
+
+void _copyInput2Vector(InputArrayOfArrays inp, vector<vector<Point2f> > &vec)
+{
+    size_t i, nvecs = inp.size().area();
+    int inpdepth = inp.depth();
+    CV_Assert(inpdepth == CV_32F);
+    vec.resize(nvecs);
+    if(inp.isMatVector() || inp.kind() == _InputArray::STD_VECTOR_VECTOR)
+    {
+        for (i = 0; i < nvecs; i++)
+        {
+            Mat inp_i = inp.getMat((int)i);
+            int j, npoints = inp_i.checkVector(2, inpdepth, true);
+            CV_Assert(npoints >= 0);
+            const Point2f* inpptr = inp_i.ptr<Point2f>();
+            vector<Point2f>& vec_i = vec[i];
+            vec_i.resize(npoints);
+            for (j = 0; j < npoints; j++)
+                vec_i[j] = inpptr[j];
+        }
+    }
+    else {
+        CV_Error(cv::Error::StsNotImplemented,
+                 "Only Mat vector, UMat vector, and vector<vector> OutputArrays are currently supported.");
+    }
+}
+
+void _copyVector2Output(vector<vector<Point2f> > &vec, OutputArrayOfArrays out, const float scale) {
+    size_t i, j, nvecs = vec.size();
+    if(out.isMatVector()) {
+        vector<Mat>& out_ = out.getMatVecRef();
+        out_.resize(nvecs);
+        for (i = 0; i < nvecs; i++) {
+            const vector<Point2f>& vec_i = vec[i];
+            Mat& out_i = out_[i];
+            Mat(vec_i).reshape(2, 1).convertTo(out_i, CV_32F, scale);
+        }
+    }
+    else if(out.isUMatVector()) {
+        vector<UMat>& out_ = out.getUMatVecRef();
+        out_.resize(nvecs);
+        for (i = 0; i < nvecs; i++) {
+            const vector<Point2f>& vec_i = vec[i];
+            UMat& out_i = out_[i];
+            Mat(vec_i).reshape(2, 1).convertTo(out_i, CV_32F, scale);
+        }
+    }
+    else if(out.kind() == _OutputArray::STD_VECTOR_VECTOR &&
+            out.type() == CV_32FC2){
+        vector<vector<Point2f>>& out_ = out.getVecVecRef<Point2f>();
+        out_.resize(nvecs);
+        for (i = 0; i < nvecs; i++) {
+            const vector<Point2f>& vec_i = vec[i];
+            size_t npoints_i = vec_i.size();
+            vector<Point2f>& out_i = out_[i];
+            out_i.resize(npoints_i);
+            for (j = 0; j < npoints_i; j++) {
+                out_i[j] = vec_i[j]*scale;
+            }
+        }
+    }
+    else {
+        CV_Error(cv::Error::StsNotImplemented,
+                 "Only Mat vector, UMat vector, and vector<vector> OutputArrays are currently supported.");
+    }
+}
+
+void _convertToGrey(InputArray _in, Mat& _out) {
+    CV_Assert(_in.type() == CV_8UC1 || _in.type() == CV_8UC3 || _in.type() == CV_8UC4);
+    if(_in.type() != CV_8UC1)
+        cvtColor(_in, _out, COLOR_BGR2GRAY);
+    else
+        _out = _in.getMat();
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.hpp b/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.hpp
new file mode 100644
index 0000000..24b50f7
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/aruco_utils.hpp
@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef __OPENCV_OBJDETECT_ARUCO_UTILS_HPP__
+#define __OPENCV_OBJDETECT_ARUCO_UTILS_HPP__
+
+#include <opencv2/core.hpp>
+#include <vector>
+
+namespace cv {
+namespace aruco {
+
+/**
+ * @brief Copy the contents of a corners vector to an OutputArray, settings its size.
+ */
+void _copyVector2Output(std::vector<std::vector<Point2f> > &vec, OutputArrayOfArrays out, const float scale = 1.f);
+
+/**
+ * @brief Copy the contents of InputArray to a corners vector.
+ */
+void _copyInput2Vector(InputArrayOfArrays inp, std::vector<std::vector<Point2f> > &vec);
+
+/**
+  * @brief Convert input image to gray if it is a BGR or BGRA image
+  */
+void _convertToGrey(InputArray _in, Mat& _out);
+
+template<typename T>
+inline bool readParameter(const std::string& name, T& parameter, const FileNode& node)
+{
+    if (!node.empty() && !node[name].empty()) {
+        node[name] >> parameter;
+        return true;
+    }
+    return false;
+}
+
+template<typename T>
+inline bool readWriteParameter(const std::string& name, T& parameter, const FileNode* readNode, FileStorage* writeStorage)
+{
+    if (readNode)
+        return readParameter(name, parameter, *readNode);
+    CV_Assert(writeStorage);
+    *writeStorage << name << parameter;
+    return true;
+}
+
+}
+}
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp b/upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp
new file mode 100644
index 0000000..d0ba8af
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/charuco_detector.cpp
@@ -0,0 +1,627 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "../precomp.hpp"
+
+#include <opencv2/geometry.hpp>
+#include <opencv2/core/utils/logger.hpp>
+#include "opencv2/objdetect/charuco_detector.hpp"
+#include "aruco_utils.hpp"
+
+namespace cv {
+namespace aruco {
+
+using namespace std;
+
+struct CharucoDetector::CharucoDetectorImpl {
+    CharucoBoard board;
+    CharucoParameters charucoParameters;
+    ArucoDetector arucoDetector;
+
+    CharucoDetectorImpl(const CharucoBoard& _board, const CharucoParameters _charucoParameters,
+                        const ArucoDetector& _arucoDetector): board(_board), charucoParameters(_charucoParameters),
+                                                              arucoDetector(_arucoDetector)
+    {}
+
+    bool checkBoard(InputArrayOfArrays markerCorners, InputArray markerIds, InputArray charucoCorners, InputArray charucoIds) {
+        vector<Mat> mCorners;
+        markerCorners.getMatVector(mCorners);
+        const Mat mIds = markerIds.getMat();
+        const Mat chCorners = charucoCorners.getMat();
+        const Mat chIds = charucoIds.getMat();
+        const vector<int>& boardIds = board.getIds();
+
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        const vector<vector<int> > nearestMarkerCorners = board.getNearestMarkerCorners();
+
+        vector<Point2f> distance(nearestMarkerIdx.size(), Point2f(0.f, std::numeric_limits<float>::max()));
+        // distance[i].x: max distance from the i-th charuco corner to charuco corner-forming markers.
+        // The two charuco corner-forming markers of i-th charuco corner are defined in getNearestMarkerIdx()[i]
+        // distance[i].y: min distance from the charuco corner to other markers.
+        for (size_t i = 0ull; i < chIds.total(); i++) {
+            int chId = chIds.ptr<int>(0)[i];
+            Point2f charucoCorner(chCorners.ptr<Point2f>(0)[i]);
+            for (size_t j = 0ull; j < mIds.total(); j++) {
+                int idMaker = mIds.ptr<int>(0)[j];
+                // skip the check if the marker is not in the current board.
+                if (find(boardIds.begin(), boardIds.end(), idMaker) == boardIds.end())
+                    continue;
+                Point2f centerMarker((mCorners[j].ptr<Point2f>(0)[0] + mCorners[j].ptr<Point2f>(0)[1] +
+                                      mCorners[j].ptr<Point2f>(0)[2] + mCorners[j].ptr<Point2f>(0)[3]) / 4.f);
+                float dist = sqrt(normL2Sqr<float>(centerMarker - charucoCorner));
+                // nearestMarkerIdx contains for each charuco corner, nearest marker index in ids array
+                const int nearestMarkerId1 = boardIds[nearestMarkerIdx[chId][0]];
+                const int nearestMarkerId2 = boardIds[nearestMarkerIdx[chId][1]];
+                if (nearestMarkerId1 == idMaker || nearestMarkerId2 == idMaker) {
+                    int nearestCornerId = nearestMarkerId1 == idMaker ? nearestMarkerCorners[chId][0] : nearestMarkerCorners[chId][1];
+                    Point2f nearestCorner = mCorners[j].ptr<Point2f>(0)[nearestCornerId];
+                    // distToNearest: distance from the charuco corner to charuco corner-forming markers
+                    float distToNearest = sqrt(normL2Sqr<float>(nearestCorner - charucoCorner));
+                    distance[chId].x = max(distance[chId].x, distToNearest);
+                    // check that nearestCorner is nearest point
+                    {
+                        Point2f mid1 = (mCorners[j].ptr<Point2f>(0)[(nearestCornerId + 1) % 4]+nearestCorner)*0.5f;
+                        Point2f mid2 = (mCorners[j].ptr<Point2f>(0)[(nearestCornerId + 3) % 4]+nearestCorner)*0.5f;
+                        float tmpDist = min(sqrt(normL2Sqr<float>(mid1 - charucoCorner)), sqrt(normL2Sqr<float>(mid2 - charucoCorner)));
+                        if (tmpDist < distToNearest)
+                            return false;
+                    }
+                }
+                // check distance from the charuco corner to other markers
+                else
+                    distance[chId].y = min(distance[chId].y, dist);
+            }
+            // if distance from the charuco corner to charuco corner-forming markers more then distance from the charuco corner to other markers,
+            // then a false board is found.
+            if (distance[chId].x > 0.f && distance[chId].y < std::numeric_limits<float>::max() && distance[chId].x > distance[chId].y)
+                return false;
+        }
+        return true;
+    }
+
+    /** Calculate the maximum window sizes for corner refinement for each charuco corner based on the distance
+     * to their closest markers */
+    vector<Size> getMaximumSubPixWindowSizes(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                               InputArray charucoCorners) {
+        size_t nCharucoCorners = charucoCorners.getMat().total();
+
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        const vector<vector<int> > nearestMarkerCorners = board.getNearestMarkerCorners();
+
+        CV_Assert(nearestMarkerIdx.size() == nCharucoCorners);
+
+        vector<Size> winSizes(nCharucoCorners, Size(-1, -1));
+        for(size_t i = 0ull; i < nCharucoCorners; i++) {
+            if(charucoCorners.getMat().at<Point2f>((int)i) == Point2f(-1.f, -1.f)) continue;
+            if(nearestMarkerIdx[i].empty()) continue;
+                double minDist = -1;
+                int counter = 0;
+                // calculate the distance to each of the closest corner of each closest marker
+                for(size_t j = 0; j < nearestMarkerIdx[i].size(); j++) {
+                    // find marker
+                    int markerId = board.getIds()[nearestMarkerIdx[i][j]];
+                    int markerIdx = -1;
+                    for(size_t k = 0; k < markerIds.getMat().total(); k++) {
+                        if(markerIds.getMat().at<int>((int)k) == markerId) {
+                            markerIdx = (int)k;
+                                break;
+                            }
+                        }
+                    if(markerIdx == -1) continue;
+                    Point2f markerCorner =
+                        markerCorners.getMat(markerIdx).at<Point2f>(nearestMarkerCorners[i][j]);
+                    Point2f charucoCorner = charucoCorners.getMat().at<Point2f>((int)i);
+                    double dist = norm(markerCorner - charucoCorner);
+                    if(minDist == -1) minDist = dist; // if first distance, just assign it
+                    minDist = min(dist, minDist);
+                    counter++;
+                }
+                // if this is the first closest marker, don't do anything
+                if(counter == 0)
+                    continue;
+                else {
+                    // else, calculate the maximum window size
+                    int winSizeInt = int(minDist - 2); // remove 2 pixels for safety
+                    if(winSizeInt < 1) winSizeInt = 1; // minimum size is 1
+                    if(winSizeInt > 10) winSizeInt = 10; // maximum size is 10
+                    winSizes[i] = Size(winSizeInt, winSizeInt);
+                }
+            }
+        return winSizes;
+    }
+
+    /** @brief From all projected chessboard corners, select those inside the image and apply subpixel refinement */
+    void selectAndRefineChessboardCorners(InputArray allCorners, InputArray image, OutputArray selectedCorners,
+                                          OutputArray selectedIds, const vector<Size> &winSizes) {
+        const int minDistToBorder = 2; // minimum distance of the corner to the image border
+        // remaining corners, ids and window refinement sizes after removing corners outside the image
+        vector<Point2f> filteredChessboardImgPoints;
+        vector<Size> filteredWinSizes;
+        vector<int> filteredIds;
+        // filter corners outside the image
+        Rect innerRect(minDistToBorder, minDistToBorder, image.getMat().cols - 2 * minDistToBorder,
+                       image.getMat().rows - 2 * minDistToBorder);
+        for(unsigned int i = 0; i < allCorners.getMat().total(); i++) {
+            if(innerRect.contains(allCorners.getMat().at<Point2f>(i))) {
+                filteredChessboardImgPoints.push_back(allCorners.getMat().at<Point2f>(i));
+                filteredIds.push_back(i);
+                filteredWinSizes.push_back(winSizes[i]);
+            }
+        }
+        // if none valid, return 0
+        if(filteredChessboardImgPoints.empty()) return;
+        // corner refinement, first convert input image to grey
+        Mat grey;
+        if(image.type() == CV_8UC3)
+            cvtColor(image, grey, COLOR_BGR2GRAY);
+        else
+            grey = image.getMat();
+        //// For each of the charuco corners, apply subpixel refinement using its correspondind winSize
+        parallel_for_(Range(0, (int)filteredChessboardImgPoints.size()), [&](const Range& range) {
+            const int begin = range.start;
+            const int end = range.end;
+            for (int i = begin; i < end; i++) {
+                vector<Point2f> in;
+                in.push_back(filteredChessboardImgPoints[i]);
+                Size winSize = filteredWinSizes[i];
+                if (winSize.height == -1 || winSize.width == -1)
+                    winSize = Size(arucoDetector.getDetectorParameters().cornerRefinementWinSize,
+                                   arucoDetector.getDetectorParameters().cornerRefinementWinSize);
+                cornerSubPix(grey, in, winSize, Size(),
+                             TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS,
+                                          arucoDetector.getDetectorParameters().cornerRefinementMaxIterations,
+                                          arucoDetector.getDetectorParameters().cornerRefinementMinAccuracy));
+                filteredChessboardImgPoints[i] = in[0];
+            }
+        });
+        // parse output
+        Mat(filteredChessboardImgPoints).copyTo(selectedCorners);
+        Mat(filteredIds).copyTo(selectedIds);
+    }
+
+    /** Interpolate charuco corners using approximated pose estimation */
+    void interpolateCornersCharucoApproxCalib(InputArrayOfArrays markerCorners, InputArray markerIds,
+                                              InputArray image, OutputArray charucoCorners, OutputArray charucoIds) {
+        CV_Assert(image.getMat().channels() == 1 || image.getMat().channels() == 3);
+        CV_Assert(markerCorners.total() == markerIds.getMat().total());
+
+        // approximated pose estimation using marker corners
+        Mat approximatedRvec, approximatedTvec;
+        Mat objPoints, imgPoints; // object and image points for the solvePnP function
+        Board simpleBoard(board.getObjPoints(), board.getDictionary(), board.getIds());
+        simpleBoard.matchImagePoints(markerCorners, markerIds, objPoints, imgPoints);
+        if (objPoints.total() < 4ull)  // need, at least, 4 corners
+            return;
+
+        solvePnP(objPoints, imgPoints, charucoParameters.cameraMatrix, charucoParameters.distCoeffs, approximatedRvec, approximatedTvec);
+
+        // project chessboard corners
+        vector<Point2f> allChessboardImgPoints;
+        projectPoints(board.getChessboardCorners(), approximatedRvec, approximatedTvec, charucoParameters.cameraMatrix,
+                      charucoParameters.distCoeffs, allChessboardImgPoints);
+        // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+        // to the closes marker corner to avoid erroneous displacements to marker corners
+        vector<Size> subPixWinSizes = getMaximumSubPixWindowSizes(markerCorners, markerIds, allChessboardImgPoints);
+        // filter corners outside the image and subpixel-refine charuco corners
+        selectAndRefineChessboardCorners(allChessboardImgPoints, image, charucoCorners, charucoIds, subPixWinSizes);
+    }
+
+    /** Interpolate charuco corners using local homography */
+    void interpolateCornersCharucoLocalHom(InputArrayOfArrays markerCorners, InputArray markerIds, InputArray image,
+                                           OutputArray charucoCorners, OutputArray charucoIds) {
+        CV_Assert(image.getMat().channels() == 1 || image.getMat().channels() == 3);
+        CV_Assert(markerCorners.total() == markerIds.getMat().total());
+        size_t nMarkers = markerIds.getMat().total();
+        // calculate local homographies for each marker
+        vector<Mat> transformations(nMarkers);
+        vector<bool> validTransform(nMarkers, false);
+        const auto& ids = board.getIds();
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+
+        for(size_t i = 0ull; i < nMarkers; i++) {
+            vector<Point2f> markerObjPoints2D;
+            int markerId = markerIds.getMat().at<int>((int)i);
+            auto it = find(ids.begin(), ids.end(), markerId);
+            if(it == ids.end()) continue;
+            auto boardIdx = it - ids.begin();
+            markerObjPoints2D.resize(4ull);
+            for(size_t j = 0ull; j < 4ull; j++)
+                markerObjPoints2D[j] =
+                    Point2f(board.getObjPoints()[boardIdx][j].x, board.getObjPoints()[boardIdx][j].y);
+            transformations[i] = getPerspectiveTransform(markerObjPoints2D, markerCorners.getMat((int)i));
+            // set transform as valid if transformation is non-singular
+            double det = determinant(transformations[i]);
+            validTransform[i] = std::abs(det) > 1e-6;
+        }
+        const vector<Point3f> chessboardCorners = board.getChessboardCorners();
+        size_t nCharucoCorners = (size_t)chessboardCorners.size();
+        vector<Point2f> allChessboardImgPoints(nCharucoCorners, Point2f(-1, -1));
+        // for each charuco corner, calculate its interpolation position based on the closest markers
+        // homographies
+        for(size_t i = 0ull; i < nCharucoCorners; i++) {
+            Point2f objPoint2D = Point2f(chessboardCorners[i].x, chessboardCorners[i].y);
+            vector<Point2f> interpolatedPositions;
+            for(size_t j = 0ull; j < nearestMarkerIdx[i].size(); j++) {
+                int markerId = board.getIds()[nearestMarkerIdx[i][j]];
+                int markerIdx = -1;
+                for(size_t k = 0ull; k < markerIds.getMat().total(); k++) {
+                    if(markerIds.getMat().at<int>((int)k) == markerId) {
+                        markerIdx = (int)k;
+                        break;
+                    }
+                }
+                if (markerIdx != -1 &&
+                    validTransform[markerIdx])
+                {
+                    vector<Point2f> in, out;
+                    in.push_back(objPoint2D);
+                    perspectiveTransform(in, out, transformations[markerIdx]);
+                    interpolatedPositions.push_back(out[0]);
+                }
+            }
+            // none of the closest markers detected
+            if(interpolatedPositions.empty()) continue;
+            // more than one closest marker detected, take middle point
+            if(interpolatedPositions.size() > 1ull) {
+                allChessboardImgPoints[i] = (interpolatedPositions[0] + interpolatedPositions[1]) / 2.;
+            }
+            // a single closest marker detected
+            else allChessboardImgPoints[i] = interpolatedPositions[0];
+        }
+        // calculate maximum window sizes for subpixel refinement. The size is limited by the distance
+        // to the closes marker corner to avoid erroneous displacements to marker corners
+        vector<Size> subPixWinSizes = getMaximumSubPixWindowSizes(markerCorners, markerIds, allChessboardImgPoints);
+        // filter corners outside the image and subpixel-refine charuco corners
+        selectAndRefineChessboardCorners(allChessboardImgPoints, image, charucoCorners, charucoIds, subPixWinSizes);
+    }
+
+    /** Remove charuco corners if any of their minMarkers closest markers has not been detected */
+    int filterCornersWithoutMinMarkers(InputArray _allCharucoCorners, InputArray allCharucoIds, InputArray allArucoIds,
+                                       OutputArray _filteredCharucoCorners, OutputArray _filteredCharucoIds) {
+        CV_Assert(charucoParameters.minMarkers >= 0 && charucoParameters.minMarkers <= 2);
+        vector<Point2f> filteredCharucoCorners;
+        vector<int> filteredCharucoIds;
+        const vector<vector<int> > nearestMarkerIdx = board.getNearestMarkerIdx(); // only copy the vectors once
+        // for each charuco corner
+        for(unsigned int i = 0; i < allCharucoIds.getMat().total(); i++) {
+            int currentCharucoId = allCharucoIds.getMat().at<int>(i);
+            int totalMarkers = 0; // nomber of closest marker detected
+            // look for closest markers
+            for(unsigned int m = 0; m < nearestMarkerIdx[currentCharucoId].size(); m++) {
+                int markerId = board.getIds()[nearestMarkerIdx[currentCharucoId][m]];
+                bool found = false;
+                for(unsigned int k = 0; k < allArucoIds.getMat().total(); k++) {
+                    if(allArucoIds.getMat().at<int>(k) == markerId) {
+                        found = true;
+                        break;
+                    }
+                }
+                if(found) totalMarkers++;
+            }
+            // if enough markers detected, add the charuco corner to the final list
+            if(totalMarkers >= charucoParameters.minMarkers) {
+                filteredCharucoIds.push_back(currentCharucoId);
+                filteredCharucoCorners.push_back(_allCharucoCorners.getMat().at<Point2f>(i));
+            }
+        }
+        // parse output
+        Mat(filteredCharucoCorners).copyTo(_filteredCharucoCorners);
+        Mat(filteredCharucoIds).copyTo(_filteredCharucoIds);
+        return (int)_filteredCharucoIds.total();
+    }
+
+    void detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                     InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) {
+        CV_Assert((markerCorners.empty() && markerIds.empty() && !image.empty()) || (markerCorners.total() == markerIds.total()));
+        vector<vector<Point2f>> tmpMarkerCorners;
+        vector<int> tmpMarkerIds;
+        InputOutputArrayOfArrays _markerCorners = markerCorners.needed() ? markerCorners : _InputOutputArray(tmpMarkerCorners);
+        InputOutputArray _markerIds = markerIds.needed() ? markerIds : _InputOutputArray(tmpMarkerIds);
+
+        if (markerCorners.empty() && markerIds.empty()) {
+            vector<vector<Point2f> > rejectedMarkers;
+            arucoDetector.detectMarkers(image, _markerCorners, _markerIds, rejectedMarkers);
+            if (charucoParameters.tryRefineMarkers)
+                arucoDetector.refineDetectedMarkers(image, board, _markerCorners, _markerIds, rejectedMarkers);
+            if (_markerCorners.empty() && _markerIds.empty())
+                return;
+        }
+        // if camera parameters are avaible, use approximated calibration
+        if(!charucoParameters.cameraMatrix.empty())
+            interpolateCornersCharucoApproxCalib(_markerCorners, _markerIds, image, charucoCorners, charucoIds);
+        // else use local homography
+        else
+            interpolateCornersCharucoLocalHom(_markerCorners, _markerIds, image, charucoCorners, charucoIds);
+        // to return a charuco corner, its closest aruco markers should have been detected
+        filterCornersWithoutMinMarkers(charucoCorners, charucoIds, _markerIds, charucoCorners, charucoIds);
+    }
+
+    void detectBoardWithCheck(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                              InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) {
+        vector<vector<Point2f>> tmpMarkerCorners;
+        vector<int> tmpMarkerIds;
+        InputOutputArrayOfArrays _markerCorners = markerCorners.needed() ? markerCorners : _InputOutputArray(tmpMarkerCorners);
+        InputOutputArray _markerIds = markerIds.needed() ? markerIds : _InputOutputArray(tmpMarkerIds);
+        detectBoard(image, charucoCorners, charucoIds, _markerCorners, _markerIds);
+        if (charucoParameters.checkMarkers && checkBoard(_markerCorners, _markerIds, charucoCorners, charucoIds) == false) {
+            CV_LOG_DEBUG(NULL, "ChArUco board is built incorrectly");
+            charucoCorners.release();
+            charucoIds.release();
+        }
+    }
+};
+
+CharucoDetector::CharucoDetector(const CharucoBoard &board, const CharucoParameters &charucoParams,
+                                 const DetectorParameters &detectorParams, const RefineParameters& refineParams) {
+    this->charucoDetectorImpl = makePtr<CharucoDetectorImpl>(board, charucoParams, ArucoDetector(board.getDictionary(), detectorParams, refineParams));
+}
+
+const CharucoBoard& CharucoDetector::getBoard() const {
+    return charucoDetectorImpl->board;
+}
+
+void CharucoDetector::setBoard(const CharucoBoard& board) {
+     this->charucoDetectorImpl->board = board;
+      charucoDetectorImpl->arucoDetector.setDictionary(board.getDictionary());
+}
+
+const CharucoParameters &CharucoDetector::getCharucoParameters() const {
+    return charucoDetectorImpl->charucoParameters;
+}
+
+void CharucoDetector::setCharucoParameters(CharucoParameters &charucoParameters) {
+    charucoDetectorImpl->charucoParameters = charucoParameters;
+}
+
+const DetectorParameters& CharucoDetector::getDetectorParameters() const {
+    return charucoDetectorImpl->arucoDetector.getDetectorParameters();
+}
+
+void CharucoDetector::setDetectorParameters(const DetectorParameters& detectorParameters) {
+    charucoDetectorImpl->arucoDetector.setDetectorParameters(detectorParameters);
+}
+
+const RefineParameters& CharucoDetector::getRefineParameters() const {
+    return charucoDetectorImpl->arucoDetector.getRefineParameters();
+}
+
+void CharucoDetector::setRefineParameters(const RefineParameters& refineParameters) {
+    charucoDetectorImpl->arucoDetector.setRefineParameters(refineParameters);
+}
+
+void CharucoDetector::detectBoard(InputArray image, OutputArray charucoCorners, OutputArray charucoIds,
+                                  InputOutputArrayOfArrays markerCorners, InputOutputArray markerIds) const {
+    charucoDetectorImpl->detectBoardWithCheck(image, charucoCorners, charucoIds, markerCorners, markerIds);
+}
+
+void CharucoDetector::detectDiamonds(InputArray image, OutputArrayOfArrays _diamondCorners, OutputArray _diamondIds,
+                                     InputOutputArrayOfArrays inMarkerCorners, InputOutputArray inMarkerIds) const {
+    CV_Assert(getBoard().getChessboardSize() == Size(3, 3));
+    CV_Assert((inMarkerCorners.empty() && inMarkerIds.empty() && !image.empty()) || (inMarkerCorners.total() == inMarkerIds.total()));
+
+    vector<vector<Point2f>> tmpMarkerCorners;
+    vector<int> tmpMarkerIds;
+    InputOutputArrayOfArrays _markerCorners = inMarkerCorners.needed() ? inMarkerCorners : _InputOutputArray(tmpMarkerCorners);
+    InputOutputArray _markerIds = inMarkerIds.needed() ? inMarkerIds : _InputOutputArray(tmpMarkerIds);
+    if (_markerCorners.empty() && _markerIds.empty()) {
+        charucoDetectorImpl->arucoDetector.detectMarkers(image, _markerCorners, _markerIds);
+    }
+
+    const float minRepDistanceRate = 1.302455f;
+    vector<vector<Point2f>> diamondCorners;
+    vector<Vec4i> diamondIds;
+
+    // stores if the detected markers have been assigned or not to a diamond
+    vector<bool> assigned(_markerIds.total(), false);
+    if(_markerIds.total() < 4ull)
+    {
+        if (_diamondCorners.needed()) _diamondCorners.release();
+        if (_diamondIds.needed()) _diamondIds.release();
+        return; // a diamond need at least 4 markers
+    }
+
+    // convert input image to grey
+    Mat grey;
+    if(image.type() == CV_8UC3)
+        cvtColor(image, grey, COLOR_BGR2GRAY);
+    else
+        grey = image.getMat();
+    auto board = getBoard();
+
+    unsigned int nmarkers = (unsigned int)_markerCorners.total();
+    std::vector<std::vector<Point2f>> markerCorners(nmarkers);
+    for(unsigned int i = 0; i < nmarkers; i++)
+        _markerCorners.getMat((int)i).copyTo(markerCorners[i]);
+
+    // for each of the detected markers, try to find a diamond
+    for(unsigned int i = 0; i < (unsigned int)_markerIds.total(); i++) {
+        if(assigned[i]) continue;
+
+        // calculate marker perimeter
+        float perimeterSq = 0;
+        for(int c = 0; c < 4; c++) {
+          Point2f edge = markerCorners[i][c] - markerCorners[i][(c + 1) % 4];
+          perimeterSq += edge.x*edge.x + edge.y*edge.y;
+        }
+        // maximum reprojection error relative to perimeter
+        float minRepDistance = sqrt(perimeterSq) * minRepDistanceRate;
+
+        int currentId = _markerIds.getMat().at<int>(i);
+
+        // prepare data to call refineDetectedMarkers()
+        // detected markers (only the current one)
+        vector<vector<Point2f> > currentMarker;
+        vector<int> currentMarkerId;
+        currentMarker.push_back(markerCorners[i]);
+        currentMarkerId.push_back(currentId);
+
+        // marker candidates (the rest of markers if they have not been assigned)
+        vector<vector<Point2f> > candidates;
+        vector<int> candidatesIdxs;
+        for(unsigned int k = 0; k < assigned.size(); k++) {
+            if(k == i) continue;
+            if(!assigned[k]) {
+                candidates.push_back(markerCorners[k]);
+                candidatesIdxs.push_back(k);
+            }
+        }
+        if(candidates.size() < 3ull) break; // we need at least 3 free markers
+        // modify charuco layout id to make sure all the ids are different than current id
+        vector<int> tmpIds(4ull);
+        for(int k = 1; k < 4; k++)
+            tmpIds[k] = currentId + 1 + k;
+        // current id is assigned to [0], so it is the marker on the top
+        tmpIds[0] = currentId;
+
+        // create Charuco board layout for diamond (3x3 layout)
+        charucoDetectorImpl->board = CharucoBoard(Size(3, 3), board.getSquareLength(),
+                                                  board.getMarkerLength(), board.getDictionary(), tmpIds);
+
+        // try to find the rest of markers in the diamond
+        vector<int> acceptedIdxs;
+        if (currentMarker.size() != 4ull)
+        {
+            RefineParameters refineParameters(minRepDistance, -1.f, false);
+            RefineParameters tmp = charucoDetectorImpl->arucoDetector.getRefineParameters();
+            charucoDetectorImpl->arucoDetector.setRefineParameters(refineParameters);
+            charucoDetectorImpl->arucoDetector.refineDetectedMarkers(grey, getBoard(), currentMarker, currentMarkerId,
+                                                                     candidates,
+                                                                     noArray(), noArray(), acceptedIdxs);
+            charucoDetectorImpl->arucoDetector.setRefineParameters(tmp);
+        }
+
+        // if found, we have a diamond
+        if(currentMarker.size() == 4ull) {
+            assigned[i] = true;
+            // calculate diamond id, acceptedIdxs array indicates the markers taken from candidates array
+            Vec4i markerId;
+            markerId[0] = currentId;
+            for(int k = 1; k < 4; k++) {
+                int currentMarkerIdx = candidatesIdxs[acceptedIdxs[k - 1]];
+                markerId[k] = _markerIds.getMat().at<int>(currentMarkerIdx);
+                assigned[currentMarkerIdx] = true;
+            }
+
+            // interpolate the charuco corners of the diamond
+            vector<Point2f> currentMarkerCorners;
+            Mat aux;
+            charucoDetectorImpl->detectBoardWithCheck(grey, currentMarkerCorners, aux, currentMarker, currentMarkerId);
+
+            // if everything is ok, save the diamond
+            if(currentMarkerCorners.size() > 0ull) {
+                // reorder corners
+                vector<Point2f> currentMarkerCornersReorder;
+                currentMarkerCornersReorder.resize(4);
+                currentMarkerCornersReorder[0] = currentMarkerCorners[0];
+                currentMarkerCornersReorder[1] = currentMarkerCorners[1];
+                currentMarkerCornersReorder[2] = currentMarkerCorners[3];
+                currentMarkerCornersReorder[3] = currentMarkerCorners[2];
+
+                diamondCorners.push_back(currentMarkerCornersReorder);
+                diamondIds.push_back(markerId);
+            }
+        }
+    }
+    charucoDetectorImpl->board = board;
+
+    if(diamondIds.size() > 0ull) {
+        // parse output
+        if (_diamondIds.needed())
+        {
+            Mat(diamondIds).copyTo(_diamondIds);
+        }
+
+        if (_diamondCorners.needed())
+        {
+            _diamondCorners.create((int)diamondCorners.size(), 1, CV_32FC2);
+            for(unsigned int i = 0; i < diamondCorners.size(); i++) {
+                _diamondCorners.create(4, 1, CV_32FC2, i, true);
+                for(int j = 0; j < 4; j++) {
+                    _diamondCorners.getMat(i).at<Point2f>(j) = diamondCorners[i][j];
+                }
+            }
+        }
+    }
+    else
+    {
+        if (_diamondCorners.needed()) _diamondCorners.release();
+        if (_diamondIds.needed()) _diamondIds.release();
+    }
+}
+
+void drawDetectedCornersCharuco(InputOutputArray _image, InputArray _charucoCorners,
+                                InputArray _charucoIds, Scalar cornerColor) {
+    CV_Assert(!_image.getMat().empty() &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_charucoCorners.total() == _charucoIds.total()) ||
+              _charucoIds.total() == 0);
+    CV_Assert(_charucoCorners.channels() == 2);
+
+    Mat charucoCorners = _charucoCorners.getMat();
+    if (charucoCorners.type() != CV_32SC2)
+        charucoCorners.convertTo(charucoCorners, CV_32SC2);
+    Mat charucoIds;
+    if (!_charucoIds.empty())
+        charucoIds = _charucoIds.getMat();
+    size_t nCorners = charucoCorners.total();
+    for(size_t i = 0; i < nCorners; i++) {
+        Point corner = charucoCorners.at<Point>((int)i);
+        // draw first corner mark
+        rectangle(_image, corner - Point(3, 3), corner + Point(3, 3), cornerColor, 1, LINE_AA);
+        // draw ID
+        if(!_charucoIds.empty()) {
+            int id = charucoIds.at<int>((int)i);
+            stringstream s;
+            s << "id=" << id;
+            putText(_image, s.str(), corner + Point(5, -5), FONT_HERSHEY_SIMPLEX, 0.5,
+                    cornerColor, 2);
+        }
+    }
+}
+
+void drawDetectedDiamonds(InputOutputArray _image, InputArrayOfArrays _corners, InputArray _ids, Scalar borderColor) {
+    CV_Assert(_image.getMat().total() != 0 &&
+              (_image.getMat().channels() == 1 || _image.getMat().channels() == 3));
+    CV_Assert((_corners.total() == _ids.total()) || _ids.total() == 0);
+
+    // calculate colors
+    Scalar textColor, cornerColor;
+    textColor = cornerColor = borderColor;
+    swap(textColor.val[0], textColor.val[1]);     // text color just sawp G and R
+    swap(cornerColor.val[1], cornerColor.val[2]); // corner color just sawp G and B
+
+    int nMarkers = (int)_corners.total();
+    for(int i = 0; i < nMarkers; i++) {
+        Mat currentMarker = _corners.getMat(i);
+        CV_Assert(currentMarker.total() == 4 && currentMarker.channels() == 2);
+        if (currentMarker.type() != CV_32SC2)
+            currentMarker.convertTo(currentMarker, CV_32SC2);
+
+        // draw marker sides
+        for(int j = 0; j < 4; j++) {
+            Point p0, p1;
+            p0 = currentMarker.at<Point>(j);
+            p1 = currentMarker.at<Point>((j + 1) % 4);
+            line(_image, p0, p1, borderColor, 1);
+        }
+
+        // draw first corner mark
+        rectangle(_image, currentMarker.at<Point>(0) - Point(3, 3),
+                  currentMarker.at<Point>(0) + Point(3, 3), cornerColor, 1, LINE_AA);
+
+        // draw id composed by four numbers
+        if(_ids.total() != 0) {
+            Point cent(0, 0);
+            for(int p = 0; p < 4; p++)
+                cent += currentMarker.at<Point>(p);
+            cent = cent / 4.;
+            stringstream s;
+            s << "id=" << _ids.getMat().at< Vec4i >(i);
+            putText(_image, s.str(), cent, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 2);
+        }
+    }
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/aruco/predefined_dictionaries.hpp b/upstream/opencv/modules/objdetect/src/aruco/predefined_dictionaries.hpp
new file mode 100644
index 0000000..2f22e38
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/aruco/predefined_dictionaries.hpp
@@ -0,0 +1,20129 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+namespace {
+
+
+
+/**
+  * Dictionaries are stored as a list of bytes in its four rotations
+  * On each rotation, the marker is divided in bytes assuming a row-major order
+  * This format allows a faster marker identification.
+  * For a dictionary composed by M markers of NxN bits, the structure dimensions should be:
+  * const char name[nMarkers][4rotations][nBytes], or more specifically:
+  * const char name[M][4][ceil(NxN/8)]
+  * The element [i][j][k] represents the k-th byte of the i-th marker in the dictionary
+  * in its j-th rotation.
+  * Each rotation implies a 90 degree rotation of the marker in anticlockwise direction.
+  */
+
+static unsigned char DICT_ARUCO_BYTES[][4][4] = {
+    { { 132, 33, 8, 0 },
+      { 0, 0, 15, 1 },
+      { 8, 66, 16, 1 },
+      { 248, 0, 0, 0 }, },
+    { { 132, 33, 11, 1 },
+      { 8, 66, 15, 1 },
+      { 232, 66, 16, 1 },
+      { 248, 33, 8, 0 }, },
+    { { 132, 33, 4, 1 },
+      { 8, 0, 31, 0 },
+      { 144, 66, 16, 1 },
+      { 124, 0, 8, 0 }, },
+    { { 132, 33, 7, 0 },
+      { 0, 66, 31, 0 },
+      { 112, 66, 16, 1 },
+      { 124, 33, 0, 0 }, },
+    { { 132, 33, 120, 0 },
+      { 16, 132, 15, 1 },
+      { 15, 66, 16, 1 },
+      { 248, 16, 132, 0 }, },
+    { { 132, 33, 123, 1 },
+      { 24, 198, 15, 1 },
+      { 239, 66, 16, 1 },
+      { 248, 49, 140, 0 }, },
+    { { 132, 33, 116, 1 },
+      { 24, 132, 31, 0 },
+      { 151, 66, 16, 1 },
+      { 124, 16, 140, 0 }, },
+    { { 132, 33, 119, 0 },
+      { 16, 198, 31, 0 },
+      { 119, 66, 16, 1 },
+      { 124, 49, 132, 0 }, },
+    { { 132, 32, 152, 0 },
+      { 16, 0, 46, 1 },
+      { 12, 130, 16, 1 },
+      { 186, 0, 4, 0 }, },
+    { { 132, 32, 155, 1 },
+      { 24, 66, 46, 1 },
+      { 236, 130, 16, 1 },
+      { 186, 33, 12, 0 }, },
+    { { 132, 32, 148, 1 },
+      { 24, 0, 62, 0 },
+      { 148, 130, 16, 1 },
+      { 62, 0, 12, 0 }, },
+    { { 132, 32, 151, 0 },
+      { 16, 66, 62, 0 },
+      { 116, 130, 16, 1 },
+      { 62, 33, 4, 0 }, },
+    { { 132, 32, 232, 0 },
+      { 0, 132, 46, 1 },
+      { 11, 130, 16, 1 },
+      { 186, 16, 128, 0 }, },
+    { { 132, 32, 235, 1 },
+      { 8, 198, 46, 1 },
+      { 235, 130, 16, 1 },
+      { 186, 49, 136, 0 }, },
+    { { 132, 32, 228, 1 },
+      { 8, 132, 62, 0 },
+      { 147, 130, 16, 1 },
+      { 62, 16, 136, 0 }, },
+    { { 132, 32, 231, 0 },
+      { 0, 198, 62, 0 },
+      { 115, 130, 16, 1 },
+      { 62, 49, 128, 0 }, },
+    { { 132, 47, 8, 0 },
+      { 33, 8, 15, 1 },
+      { 8, 122, 16, 1 },
+      { 248, 8, 66, 0 }, },
+    { { 132, 47, 11, 1 },
+      { 41, 74, 15, 1 },
+      { 232, 122, 16, 1 },
+      { 248, 41, 74, 0 }, },
+    { { 132, 47, 4, 1 },
+      { 41, 8, 31, 0 },
+      { 144, 122, 16, 1 },
+      { 124, 8, 74, 0 }, },
+    { { 132, 47, 7, 0 },
+      { 33, 74, 31, 0 },
+      { 112, 122, 16, 1 },
+      { 124, 41, 66, 0 }, },
+    { { 132, 47, 120, 0 },
+      { 49, 140, 15, 1 },
+      { 15, 122, 16, 1 },
+      { 248, 24, 198, 0 }, },
+    { { 132, 47, 123, 1 },
+      { 57, 206, 15, 1 },
+      { 239, 122, 16, 1 },
+      { 248, 57, 206, 0 }, },
+    { { 132, 47, 116, 1 },
+      { 57, 140, 31, 0 },
+      { 151, 122, 16, 1 },
+      { 124, 24, 206, 0 }, },
+    { { 132, 47, 119, 0 },
+      { 49, 206, 31, 0 },
+      { 119, 122, 16, 1 },
+      { 124, 57, 198, 0 }, },
+    { { 132, 46, 152, 0 },
+      { 49, 8, 46, 1 },
+      { 12, 186, 16, 1 },
+      { 186, 8, 70, 0 }, },
+    { { 132, 46, 155, 1 },
+      { 57, 74, 46, 1 },
+      { 236, 186, 16, 1 },
+      { 186, 41, 78, 0 }, },
+    { { 132, 46, 148, 1 },
+      { 57, 8, 62, 0 },
+      { 148, 186, 16, 1 },
+      { 62, 8, 78, 0 }, },
+    { { 132, 46, 151, 0 },
+      { 49, 74, 62, 0 },
+      { 116, 186, 16, 1 },
+      { 62, 41, 70, 0 }, },
+    { { 132, 46, 232, 0 },
+      { 33, 140, 46, 1 },
+      { 11, 186, 16, 1 },
+      { 186, 24, 194, 0 }, },
+    { { 132, 46, 235, 1 },
+      { 41, 206, 46, 1 },
+      { 235, 186, 16, 1 },
+      { 186, 57, 202, 0 }, },
+    { { 132, 46, 228, 1 },
+      { 41, 140, 62, 0 },
+      { 147, 186, 16, 1 },
+      { 62, 24, 202, 0 }, },
+    { { 132, 46, 231, 0 },
+      { 33, 206, 62, 0 },
+      { 115, 186, 16, 1 },
+      { 62, 57, 194, 0 }, },
+    { { 132, 19, 8, 0 },
+      { 32, 0, 77, 1 },
+      { 8, 100, 16, 1 },
+      { 217, 0, 2, 0 }, },
+    { { 132, 19, 11, 1 },
+      { 40, 66, 77, 1 },
+      { 232, 100, 16, 1 },
+      { 217, 33, 10, 0 }, },
+    { { 132, 19, 4, 1 },
+      { 40, 0, 93, 0 },
+      { 144, 100, 16, 1 },
+      { 93, 0, 10, 0 }, },
+    { { 132, 19, 7, 0 },
+      { 32, 66, 93, 0 },
+      { 112, 100, 16, 1 },
+      { 93, 33, 2, 0 }, },
+    { { 132, 19, 120, 0 },
+      { 48, 132, 77, 1 },
+      { 15, 100, 16, 1 },
+      { 217, 16, 134, 0 }, },
+    { { 132, 19, 123, 1 },
+      { 56, 198, 77, 1 },
+      { 239, 100, 16, 1 },
+      { 217, 49, 142, 0 }, },
+    { { 132, 19, 116, 1 },
+      { 56, 132, 93, 0 },
+      { 151, 100, 16, 1 },
+      { 93, 16, 142, 0 }, },
+    { { 132, 19, 119, 0 },
+      { 48, 198, 93, 0 },
+      { 119, 100, 16, 1 },
+      { 93, 49, 134, 0 }, },
+    { { 132, 18, 152, 0 },
+      { 48, 0, 108, 1 },
+      { 12, 164, 16, 1 },
+      { 155, 0, 6, 0 }, },
+    { { 132, 18, 155, 1 },
+      { 56, 66, 108, 1 },
+      { 236, 164, 16, 1 },
+      { 155, 33, 14, 0 }, },
+    { { 132, 18, 148, 1 },
+      { 56, 0, 124, 0 },
+      { 148, 164, 16, 1 },
+      { 31, 0, 14, 0 }, },
+    { { 132, 18, 151, 0 },
+      { 48, 66, 124, 0 },
+      { 116, 164, 16, 1 },
+      { 31, 33, 6, 0 }, },
+    { { 132, 18, 232, 0 },
+      { 32, 132, 108, 1 },
+      { 11, 164, 16, 1 },
+      { 155, 16, 130, 0 }, },
+    { { 132, 18, 235, 1 },
+      { 40, 198, 108, 1 },
+      { 235, 164, 16, 1 },
+      { 155, 49, 138, 0 }, },
+    { { 132, 18, 228, 1 },
+      { 40, 132, 124, 0 },
+      { 147, 164, 16, 1 },
+      { 31, 16, 138, 0 }, },
+    { { 132, 18, 231, 0 },
+      { 32, 198, 124, 0 },
+      { 115, 164, 16, 1 },
+      { 31, 49, 130, 0 }, },
+    { { 132, 29, 8, 0 },
+      { 1, 8, 77, 1 },
+      { 8, 92, 16, 1 },
+      { 217, 8, 64, 0 }, },
+    { { 132, 29, 11, 1 },
+      { 9, 74, 77, 1 },
+      { 232, 92, 16, 1 },
+      { 217, 41, 72, 0 }, },
+    { { 132, 29, 4, 1 },
+      { 9, 8, 93, 0 },
+      { 144, 92, 16, 1 },
+      { 93, 8, 72, 0 }, },
+    { { 132, 29, 7, 0 },
+      { 1, 74, 93, 0 },
+      { 112, 92, 16, 1 },
+      { 93, 41, 64, 0 }, },
+    { { 132, 29, 120, 0 },
+      { 17, 140, 77, 1 },
+      { 15, 92, 16, 1 },
+      { 217, 24, 196, 0 }, },
+    { { 132, 29, 123, 1 },
+      { 25, 206, 77, 1 },
+      { 239, 92, 16, 1 },
+      { 217, 57, 204, 0 }, },
+    { { 132, 29, 116, 1 },
+      { 25, 140, 93, 0 },
+      { 151, 92, 16, 1 },
+      { 93, 24, 204, 0 }, },
+    { { 132, 29, 119, 0 },
+      { 17, 206, 93, 0 },
+      { 119, 92, 16, 1 },
+      { 93, 57, 196, 0 }, },
+    { { 132, 28, 152, 0 },
+      { 17, 8, 108, 1 },
+      { 12, 156, 16, 1 },
+      { 155, 8, 68, 0 }, },
+    { { 132, 28, 155, 1 },
+      { 25, 74, 108, 1 },
+      { 236, 156, 16, 1 },
+      { 155, 41, 76, 0 }, },
+    { { 132, 28, 148, 1 },
+      { 25, 8, 124, 0 },
+      { 148, 156, 16, 1 },
+      { 31, 8, 76, 0 }, },
+    { { 132, 28, 151, 0 },
+      { 17, 74, 124, 0 },
+      { 116, 156, 16, 1 },
+      { 31, 41, 68, 0 }, },
+    { { 132, 28, 232, 0 },
+      { 1, 140, 108, 1 },
+      { 11, 156, 16, 1 },
+      { 155, 24, 192, 0 }, },
+    { { 132, 28, 235, 1 },
+      { 9, 206, 108, 1 },
+      { 235, 156, 16, 1 },
+      { 155, 57, 200, 0 }, },
+    { { 132, 28, 228, 1 },
+      { 9, 140, 124, 0 },
+      { 147, 156, 16, 1 },
+      { 31, 24, 200, 0 }, },
+    { { 132, 28, 231, 0 },
+      { 1, 206, 124, 0 },
+      { 115, 156, 16, 1 },
+      { 31, 57, 192, 0 }, },
+    { { 133, 225, 8, 0 },
+      { 66, 16, 15, 1 },
+      { 8, 67, 208, 1 },
+      { 248, 4, 33, 0 }, },
+    { { 133, 225, 11, 1 },
+      { 74, 82, 15, 1 },
+      { 232, 67, 208, 1 },
+      { 248, 37, 41, 0 }, },
+    { { 133, 225, 4, 1 },
+      { 74, 16, 31, 0 },
+      { 144, 67, 208, 1 },
+      { 124, 4, 41, 0 }, },
+    { { 133, 225, 7, 0 },
+      { 66, 82, 31, 0 },
+      { 112, 67, 208, 1 },
+      { 124, 37, 33, 0 }, },
+    { { 133, 225, 120, 0 },
+      { 82, 148, 15, 1 },
+      { 15, 67, 208, 1 },
+      { 248, 20, 165, 0 }, },
+    { { 133, 225, 123, 1 },
+      { 90, 214, 15, 1 },
+      { 239, 67, 208, 1 },
+      { 248, 53, 173, 0 }, },
+    { { 133, 225, 116, 1 },
+      { 90, 148, 31, 0 },
+      { 151, 67, 208, 1 },
+      { 124, 20, 173, 0 }, },
+    { { 133, 225, 119, 0 },
+      { 82, 214, 31, 0 },
+      { 119, 67, 208, 1 },
+      { 124, 53, 165, 0 }, },
+    { { 133, 224, 152, 0 },
+      { 82, 16, 46, 1 },
+      { 12, 131, 208, 1 },
+      { 186, 4, 37, 0 }, },
+    { { 133, 224, 155, 1 },
+      { 90, 82, 46, 1 },
+      { 236, 131, 208, 1 },
+      { 186, 37, 45, 0 }, },
+    { { 133, 224, 148, 1 },
+      { 90, 16, 62, 0 },
+      { 148, 131, 208, 1 },
+      { 62, 4, 45, 0 }, },
+    { { 133, 224, 151, 0 },
+      { 82, 82, 62, 0 },
+      { 116, 131, 208, 1 },
+      { 62, 37, 37, 0 }, },
+    { { 133, 224, 232, 0 },
+      { 66, 148, 46, 1 },
+      { 11, 131, 208, 1 },
+      { 186, 20, 161, 0 }, },
+    { { 133, 224, 235, 1 },
+      { 74, 214, 46, 1 },
+      { 235, 131, 208, 1 },
+      { 186, 53, 169, 0 }, },
+    { { 133, 224, 228, 1 },
+      { 74, 148, 62, 0 },
+      { 147, 131, 208, 1 },
+      { 62, 20, 169, 0 }, },
+    { { 133, 224, 231, 0 },
+      { 66, 214, 62, 0 },
+      { 115, 131, 208, 1 },
+      { 62, 53, 161, 0 }, },
+    { { 133, 239, 8, 0 },
+      { 99, 24, 15, 1 },
+      { 8, 123, 208, 1 },
+      { 248, 12, 99, 0 }, },
+    { { 133, 239, 11, 1 },
+      { 107, 90, 15, 1 },
+      { 232, 123, 208, 1 },
+      { 248, 45, 107, 0 }, },
+    { { 133, 239, 4, 1 },
+      { 107, 24, 31, 0 },
+      { 144, 123, 208, 1 },
+      { 124, 12, 107, 0 }, },
+    { { 133, 239, 7, 0 },
+      { 99, 90, 31, 0 },
+      { 112, 123, 208, 1 },
+      { 124, 45, 99, 0 }, },
+    { { 133, 239, 120, 0 },
+      { 115, 156, 15, 1 },
+      { 15, 123, 208, 1 },
+      { 248, 28, 231, 0 }, },
+    { { 133, 239, 123, 1 },
+      { 123, 222, 15, 1 },
+      { 239, 123, 208, 1 },
+      { 248, 61, 239, 0 }, },
+    { { 133, 239, 116, 1 },
+      { 123, 156, 31, 0 },
+      { 151, 123, 208, 1 },
+      { 124, 28, 239, 0 }, },
+    { { 133, 239, 119, 0 },
+      { 115, 222, 31, 0 },
+      { 119, 123, 208, 1 },
+      { 124, 61, 231, 0 }, },
+    { { 133, 238, 152, 0 },
+      { 115, 24, 46, 1 },
+      { 12, 187, 208, 1 },
+      { 186, 12, 103, 0 }, },
+    { { 133, 238, 155, 1 },
+      { 123, 90, 46, 1 },
+      { 236, 187, 208, 1 },
+      { 186, 45, 111, 0 }, },
+    { { 133, 238, 148, 1 },
+      { 123, 24, 62, 0 },
+      { 148, 187, 208, 1 },
+      { 62, 12, 111, 0 }, },
+    { { 133, 238, 151, 0 },
+      { 115, 90, 62, 0 },
+      { 116, 187, 208, 1 },
+      { 62, 45, 103, 0 }, },
+    { { 133, 238, 232, 0 },
+      { 99, 156, 46, 1 },
+      { 11, 187, 208, 1 },
+      { 186, 28, 227, 0 }, },
+    { { 133, 238, 235, 1 },
+      { 107, 222, 46, 1 },
+      { 235, 187, 208, 1 },
+      { 186, 61, 235, 0 }, },
+    { { 133, 238, 228, 1 },
+      { 107, 156, 62, 0 },
+      { 147, 187, 208, 1 },
+      { 62, 28, 235, 0 }, },
+    { { 133, 238, 231, 0 },
+      { 99, 222, 62, 0 },
+      { 115, 187, 208, 1 },
+      { 62, 61, 227, 0 }, },
+    { { 133, 211, 8, 0 },
+      { 98, 16, 77, 1 },
+      { 8, 101, 208, 1 },
+      { 217, 4, 35, 0 }, },
+    { { 133, 211, 11, 1 },
+      { 106, 82, 77, 1 },
+      { 232, 101, 208, 1 },
+      { 217, 37, 43, 0 }, },
+    { { 133, 211, 4, 1 },
+      { 106, 16, 93, 0 },
+      { 144, 101, 208, 1 },
+      { 93, 4, 43, 0 }, },
+    { { 133, 211, 7, 0 },
+      { 98, 82, 93, 0 },
+      { 112, 101, 208, 1 },
+      { 93, 37, 35, 0 }, },
+    { { 133, 211, 120, 0 },
+      { 114, 148, 77, 1 },
+      { 15, 101, 208, 1 },
+      { 217, 20, 167, 0 }, },
+    { { 133, 211, 123, 1 },
+      { 122, 214, 77, 1 },
+      { 239, 101, 208, 1 },
+      { 217, 53, 175, 0 }, },
+    { { 133, 211, 116, 1 },
+      { 122, 148, 93, 0 },
+      { 151, 101, 208, 1 },
+      { 93, 20, 175, 0 }, },
+    { { 133, 211, 119, 0 },
+      { 114, 214, 93, 0 },
+      { 119, 101, 208, 1 },
+      { 93, 53, 167, 0 }, },
+    { { 133, 210, 152, 0 },
+      { 114, 16, 108, 1 },
+      { 12, 165, 208, 1 },
+      { 155, 4, 39, 0 }, },
+    { { 133, 210, 155, 1 },
+      { 122, 82, 108, 1 },
+      { 236, 165, 208, 1 },
+      { 155, 37, 47, 0 }, },
+    { { 133, 210, 148, 1 },
+      { 122, 16, 124, 0 },
+      { 148, 165, 208, 1 },
+      { 31, 4, 47, 0 }, },
+    { { 133, 210, 151, 0 },
+      { 114, 82, 124, 0 },
+      { 116, 165, 208, 1 },
+      { 31, 37, 39, 0 }, },
+    { { 133, 210, 232, 0 },
+      { 98, 148, 108, 1 },
+      { 11, 165, 208, 1 },
+      { 155, 20, 163, 0 }, },
+    { { 133, 210, 235, 1 },
+      { 106, 214, 108, 1 },
+      { 235, 165, 208, 1 },
+      { 155, 53, 171, 0 }, },
+    { { 133, 210, 228, 1 },
+      { 106, 148, 124, 0 },
+      { 147, 165, 208, 1 },
+      { 31, 20, 171, 0 }, },
+    { { 133, 210, 231, 0 },
+      { 98, 214, 124, 0 },
+      { 115, 165, 208, 1 },
+      { 31, 53, 163, 0 }, },
+    { { 133, 221, 8, 0 },
+      { 67, 24, 77, 1 },
+      { 8, 93, 208, 1 },
+      { 217, 12, 97, 0 }, },
+    { { 133, 221, 11, 1 },
+      { 75, 90, 77, 1 },
+      { 232, 93, 208, 1 },
+      { 217, 45, 105, 0 }, },
+    { { 133, 221, 4, 1 },
+      { 75, 24, 93, 0 },
+      { 144, 93, 208, 1 },
+      { 93, 12, 105, 0 }, },
+    { { 133, 221, 7, 0 },
+      { 67, 90, 93, 0 },
+      { 112, 93, 208, 1 },
+      { 93, 45, 97, 0 }, },
+    { { 133, 221, 120, 0 },
+      { 83, 156, 77, 1 },
+      { 15, 93, 208, 1 },
+      { 217, 28, 229, 0 }, },
+    { { 133, 221, 123, 1 },
+      { 91, 222, 77, 1 },
+      { 239, 93, 208, 1 },
+      { 217, 61, 237, 0 }, },
+    { { 133, 221, 116, 1 },
+      { 91, 156, 93, 0 },
+      { 151, 93, 208, 1 },
+      { 93, 28, 237, 0 }, },
+    { { 133, 221, 119, 0 },
+      { 83, 222, 93, 0 },
+      { 119, 93, 208, 1 },
+      { 93, 61, 229, 0 }, },
+    { { 133, 220, 152, 0 },
+      { 83, 24, 108, 1 },
+      { 12, 157, 208, 1 },
+      { 155, 12, 101, 0 }, },
+    { { 133, 220, 155, 1 },
+      { 91, 90, 108, 1 },
+      { 236, 157, 208, 1 },
+      { 155, 45, 109, 0 }, },
+    { { 133, 220, 148, 1 },
+      { 91, 24, 124, 0 },
+      { 148, 157, 208, 1 },
+      { 31, 12, 109, 0 }, },
+    { { 133, 220, 151, 0 },
+      { 83, 90, 124, 0 },
+      { 116, 157, 208, 1 },
+      { 31, 45, 101, 0 }, },
+    { { 133, 220, 232, 0 },
+      { 67, 156, 108, 1 },
+      { 11, 157, 208, 1 },
+      { 155, 28, 225, 0 }, },
+    { { 133, 220, 235, 1 },
+      { 75, 222, 108, 1 },
+      { 235, 157, 208, 1 },
+      { 155, 61, 233, 0 }, },
+    { { 133, 220, 228, 1 },
+      { 75, 156, 124, 0 },
+      { 147, 157, 208, 1 },
+      { 31, 28, 233, 0 }, },
+    { { 133, 220, 231, 0 },
+      { 67, 222, 124, 0 },
+      { 115, 157, 208, 1 },
+      { 31, 61, 225, 0 }, },
+    { { 130, 97, 8, 0 },
+      { 64, 0, 139, 1 },
+      { 8, 67, 32, 1 },
+      { 232, 128, 1, 0 }, },
+    { { 130, 97, 11, 1 },
+      { 72, 66, 139, 1 },
+      { 232, 67, 32, 1 },
+      { 232, 161, 9, 0 }, },
+    { { 130, 97, 4, 1 },
+      { 72, 0, 155, 0 },
+      { 144, 67, 32, 1 },
+      { 108, 128, 9, 0 }, },
+    { { 130, 97, 7, 0 },
+      { 64, 66, 155, 0 },
+      { 112, 67, 32, 1 },
+      { 108, 161, 1, 0 }, },
+    { { 130, 97, 120, 0 },
+      { 80, 132, 139, 1 },
+      { 15, 67, 32, 1 },
+      { 232, 144, 133, 0 }, },
+    { { 130, 97, 123, 1 },
+      { 88, 198, 139, 1 },
+      { 239, 67, 32, 1 },
+      { 232, 177, 141, 0 }, },
+    { { 130, 97, 116, 1 },
+      { 88, 132, 155, 0 },
+      { 151, 67, 32, 1 },
+      { 108, 144, 141, 0 }, },
+    { { 130, 97, 119, 0 },
+      { 80, 198, 155, 0 },
+      { 119, 67, 32, 1 },
+      { 108, 177, 133, 0 }, },
+    { { 130, 96, 152, 0 },
+      { 80, 0, 170, 1 },
+      { 12, 131, 32, 1 },
+      { 170, 128, 5, 0 }, },
+    { { 130, 96, 155, 1 },
+      { 88, 66, 170, 1 },
+      { 236, 131, 32, 1 },
+      { 170, 161, 13, 0 }, },
+    { { 130, 96, 148, 1 },
+      { 88, 0, 186, 0 },
+      { 148, 131, 32, 1 },
+      { 46, 128, 13, 0 }, },
+    { { 130, 96, 151, 0 },
+      { 80, 66, 186, 0 },
+      { 116, 131, 32, 1 },
+      { 46, 161, 5, 0 }, },
+    { { 130, 96, 232, 0 },
+      { 64, 132, 170, 1 },
+      { 11, 131, 32, 1 },
+      { 170, 144, 129, 0 }, },
+    { { 130, 96, 235, 1 },
+      { 72, 198, 170, 1 },
+      { 235, 131, 32, 1 },
+      { 170, 177, 137, 0 }, },
+    { { 130, 96, 228, 1 },
+      { 72, 132, 186, 0 },
+      { 147, 131, 32, 1 },
+      { 46, 144, 137, 0 }, },
+    { { 130, 96, 231, 0 },
+      { 64, 198, 186, 0 },
+      { 115, 131, 32, 1 },
+      { 46, 177, 129, 0 }, },
+    { { 130, 111, 8, 0 },
+      { 97, 8, 139, 1 },
+      { 8, 123, 32, 1 },
+      { 232, 136, 67, 0 }, },
+    { { 130, 111, 11, 1 },
+      { 105, 74, 139, 1 },
+      { 232, 123, 32, 1 },
+      { 232, 169, 75, 0 }, },
+    { { 130, 111, 4, 1 },
+      { 105, 8, 155, 0 },
+      { 144, 123, 32, 1 },
+      { 108, 136, 75, 0 }, },
+    { { 130, 111, 7, 0 },
+      { 97, 74, 155, 0 },
+      { 112, 123, 32, 1 },
+      { 108, 169, 67, 0 }, },
+    { { 130, 111, 120, 0 },
+      { 113, 140, 139, 1 },
+      { 15, 123, 32, 1 },
+      { 232, 152, 199, 0 }, },
+    { { 130, 111, 123, 1 },
+      { 121, 206, 139, 1 },
+      { 239, 123, 32, 1 },
+      { 232, 185, 207, 0 }, },
+    { { 130, 111, 116, 1 },
+      { 121, 140, 155, 0 },
+      { 151, 123, 32, 1 },
+      { 108, 152, 207, 0 }, },
+    { { 130, 111, 119, 0 },
+      { 113, 206, 155, 0 },
+      { 119, 123, 32, 1 },
+      { 108, 185, 199, 0 }, },
+    { { 130, 110, 152, 0 },
+      { 113, 8, 170, 1 },
+      { 12, 187, 32, 1 },
+      { 170, 136, 71, 0 }, },
+    { { 130, 110, 155, 1 },
+      { 121, 74, 170, 1 },
+      { 236, 187, 32, 1 },
+      { 170, 169, 79, 0 }, },
+    { { 130, 110, 148, 1 },
+      { 121, 8, 186, 0 },
+      { 148, 187, 32, 1 },
+      { 46, 136, 79, 0 }, },
+    { { 130, 110, 151, 0 },
+      { 113, 74, 186, 0 },
+      { 116, 187, 32, 1 },
+      { 46, 169, 71, 0 }, },
+    { { 130, 110, 232, 0 },
+      { 97, 140, 170, 1 },
+      { 11, 187, 32, 1 },
+      { 170, 152, 195, 0 }, },
+    { { 130, 110, 235, 1 },
+      { 105, 206, 170, 1 },
+      { 235, 187, 32, 1 },
+      { 170, 185, 203, 0 }, },
+    { { 130, 110, 228, 1 },
+      { 105, 140, 186, 0 },
+      { 147, 187, 32, 1 },
+      { 46, 152, 203, 0 }, },
+    { { 130, 110, 231, 0 },
+      { 97, 206, 186, 0 },
+      { 115, 187, 32, 1 },
+      { 46, 185, 195, 0 }, },
+    { { 130, 83, 8, 0 },
+      { 96, 0, 201, 1 },
+      { 8, 101, 32, 1 },
+      { 201, 128, 3, 0 }, },
+    { { 130, 83, 11, 1 },
+      { 104, 66, 201, 1 },
+      { 232, 101, 32, 1 },
+      { 201, 161, 11, 0 }, },
+    { { 130, 83, 4, 1 },
+      { 104, 0, 217, 0 },
+      { 144, 101, 32, 1 },
+      { 77, 128, 11, 0 }, },
+    { { 130, 83, 7, 0 },
+      { 96, 66, 217, 0 },
+      { 112, 101, 32, 1 },
+      { 77, 161, 3, 0 }, },
+    { { 130, 83, 120, 0 },
+      { 112, 132, 201, 1 },
+      { 15, 101, 32, 1 },
+      { 201, 144, 135, 0 }, },
+    { { 130, 83, 123, 1 },
+      { 120, 198, 201, 1 },
+      { 239, 101, 32, 1 },
+      { 201, 177, 143, 0 }, },
+    { { 130, 83, 116, 1 },
+      { 120, 132, 217, 0 },
+      { 151, 101, 32, 1 },
+      { 77, 144, 143, 0 }, },
+    { { 130, 83, 119, 0 },
+      { 112, 198, 217, 0 },
+      { 119, 101, 32, 1 },
+      { 77, 177, 135, 0 }, },
+    { { 130, 82, 152, 0 },
+      { 112, 0, 232, 1 },
+      { 12, 165, 32, 1 },
+      { 139, 128, 7, 0 }, },
+    { { 130, 82, 155, 1 },
+      { 120, 66, 232, 1 },
+      { 236, 165, 32, 1 },
+      { 139, 161, 15, 0 }, },
+    { { 130, 82, 148, 1 },
+      { 120, 0, 248, 0 },
+      { 148, 165, 32, 1 },
+      { 15, 128, 15, 0 }, },
+    { { 130, 82, 151, 0 },
+      { 112, 66, 248, 0 },
+      { 116, 165, 32, 1 },
+      { 15, 161, 7, 0 }, },
+    { { 130, 82, 232, 0 },
+      { 96, 132, 232, 1 },
+      { 11, 165, 32, 1 },
+      { 139, 144, 131, 0 }, },
+    { { 130, 82, 235, 1 },
+      { 104, 198, 232, 1 },
+      { 235, 165, 32, 1 },
+      { 139, 177, 139, 0 }, },
+    { { 130, 82, 228, 1 },
+      { 104, 132, 248, 0 },
+      { 147, 165, 32, 1 },
+      { 15, 144, 139, 0 }, },
+    { { 130, 82, 231, 0 },
+      { 96, 198, 248, 0 },
+      { 115, 165, 32, 1 },
+      { 15, 177, 131, 0 }, },
+    { { 130, 93, 8, 0 },
+      { 65, 8, 201, 1 },
+      { 8, 93, 32, 1 },
+      { 201, 136, 65, 0 }, },
+    { { 130, 93, 11, 1 },
+      { 73, 74, 201, 1 },
+      { 232, 93, 32, 1 },
+      { 201, 169, 73, 0 }, },
+    { { 130, 93, 4, 1 },
+      { 73, 8, 217, 0 },
+      { 144, 93, 32, 1 },
+      { 77, 136, 73, 0 }, },
+    { { 130, 93, 7, 0 },
+      { 65, 74, 217, 0 },
+      { 112, 93, 32, 1 },
+      { 77, 169, 65, 0 }, },
+    { { 130, 93, 120, 0 },
+      { 81, 140, 201, 1 },
+      { 15, 93, 32, 1 },
+      { 201, 152, 197, 0 }, },
+    { { 130, 93, 123, 1 },
+      { 89, 206, 201, 1 },
+      { 239, 93, 32, 1 },
+      { 201, 185, 205, 0 }, },
+    { { 130, 93, 116, 1 },
+      { 89, 140, 217, 0 },
+      { 151, 93, 32, 1 },
+      { 77, 152, 205, 0 }, },
+    { { 130, 93, 119, 0 },
+      { 81, 206, 217, 0 },
+      { 119, 93, 32, 1 },
+      { 77, 185, 197, 0 }, },
+    { { 130, 92, 152, 0 },
+      { 81, 8, 232, 1 },
+      { 12, 157, 32, 1 },
+      { 139, 136, 69, 0 }, },
+    { { 130, 92, 155, 1 },
+      { 89, 74, 232, 1 },
+      { 236, 157, 32, 1 },
+      { 139, 169, 77, 0 }, },
+    { { 130, 92, 148, 1 },
+      { 89, 8, 248, 0 },
+      { 148, 157, 32, 1 },
+      { 15, 136, 77, 0 }, },
+    { { 130, 92, 151, 0 },
+      { 81, 74, 248, 0 },
+      { 116, 157, 32, 1 },
+      { 15, 169, 69, 0 }, },
+    { { 130, 92, 232, 0 },
+      { 65, 140, 232, 1 },
+      { 11, 157, 32, 1 },
+      { 139, 152, 193, 0 }, },
+    { { 130, 92, 235, 1 },
+      { 73, 206, 232, 1 },
+      { 235, 157, 32, 1 },
+      { 139, 185, 201, 0 }, },
+    { { 130, 92, 228, 1 },
+      { 73, 140, 248, 0 },
+      { 147, 157, 32, 1 },
+      { 15, 152, 201, 0 }, },
+    { { 130, 92, 231, 0 },
+      { 65, 206, 248, 0 },
+      { 115, 157, 32, 1 },
+      { 15, 185, 193, 0 }, },
+    { { 131, 161, 8, 0 },
+      { 2, 16, 139, 1 },
+      { 8, 66, 224, 1 },
+      { 232, 132, 32, 0 }, },
+    { { 131, 161, 11, 1 },
+      { 10, 82, 139, 1 },
+      { 232, 66, 224, 1 },
+      { 232, 165, 40, 0 }, },
+    { { 131, 161, 4, 1 },
+      { 10, 16, 155, 0 },
+      { 144, 66, 224, 1 },
+      { 108, 132, 40, 0 }, },
+    { { 131, 161, 7, 0 },
+      { 2, 82, 155, 0 },
+      { 112, 66, 224, 1 },
+      { 108, 165, 32, 0 }, },
+    { { 131, 161, 120, 0 },
+      { 18, 148, 139, 1 },
+      { 15, 66, 224, 1 },
+      { 232, 148, 164, 0 }, },
+    { { 131, 161, 123, 1 },
+      { 26, 214, 139, 1 },
+      { 239, 66, 224, 1 },
+      { 232, 181, 172, 0 }, },
+    { { 131, 161, 116, 1 },
+      { 26, 148, 155, 0 },
+      { 151, 66, 224, 1 },
+      { 108, 148, 172, 0 }, },
+    { { 131, 161, 119, 0 },
+      { 18, 214, 155, 0 },
+      { 119, 66, 224, 1 },
+      { 108, 181, 164, 0 }, },
+    { { 131, 160, 152, 0 },
+      { 18, 16, 170, 1 },
+      { 12, 130, 224, 1 },
+      { 170, 132, 36, 0 }, },
+    { { 131, 160, 155, 1 },
+      { 26, 82, 170, 1 },
+      { 236, 130, 224, 1 },
+      { 170, 165, 44, 0 }, },
+    { { 131, 160, 148, 1 },
+      { 26, 16, 186, 0 },
+      { 148, 130, 224, 1 },
+      { 46, 132, 44, 0 }, },
+    { { 131, 160, 151, 0 },
+      { 18, 82, 186, 0 },
+      { 116, 130, 224, 1 },
+      { 46, 165, 36, 0 }, },
+    { { 131, 160, 232, 0 },
+      { 2, 148, 170, 1 },
+      { 11, 130, 224, 1 },
+      { 170, 148, 160, 0 }, },
+    { { 131, 160, 235, 1 },
+      { 10, 214, 170, 1 },
+      { 235, 130, 224, 1 },
+      { 170, 181, 168, 0 }, },
+    { { 131, 160, 228, 1 },
+      { 10, 148, 186, 0 },
+      { 147, 130, 224, 1 },
+      { 46, 148, 168, 0 }, },
+    { { 131, 160, 231, 0 },
+      { 2, 214, 186, 0 },
+      { 115, 130, 224, 1 },
+      { 46, 181, 160, 0 }, },
+    { { 131, 175, 8, 0 },
+      { 35, 24, 139, 1 },
+      { 8, 122, 224, 1 },
+      { 232, 140, 98, 0 }, },
+    { { 131, 175, 11, 1 },
+      { 43, 90, 139, 1 },
+      { 232, 122, 224, 1 },
+      { 232, 173, 106, 0 }, },
+    { { 131, 175, 4, 1 },
+      { 43, 24, 155, 0 },
+      { 144, 122, 224, 1 },
+      { 108, 140, 106, 0 }, },
+    { { 131, 175, 7, 0 },
+      { 35, 90, 155, 0 },
+      { 112, 122, 224, 1 },
+      { 108, 173, 98, 0 }, },
+    { { 131, 175, 120, 0 },
+      { 51, 156, 139, 1 },
+      { 15, 122, 224, 1 },
+      { 232, 156, 230, 0 }, },
+    { { 131, 175, 123, 1 },
+      { 59, 222, 139, 1 },
+      { 239, 122, 224, 1 },
+      { 232, 189, 238, 0 }, },
+    { { 131, 175, 116, 1 },
+      { 59, 156, 155, 0 },
+      { 151, 122, 224, 1 },
+      { 108, 156, 238, 0 }, },
+    { { 131, 175, 119, 0 },
+      { 51, 222, 155, 0 },
+      { 119, 122, 224, 1 },
+      { 108, 189, 230, 0 }, },
+    { { 131, 174, 152, 0 },
+      { 51, 24, 170, 1 },
+      { 12, 186, 224, 1 },
+      { 170, 140, 102, 0 }, },
+    { { 131, 174, 155, 1 },
+      { 59, 90, 170, 1 },
+      { 236, 186, 224, 1 },
+      { 170, 173, 110, 0 }, },
+    { { 131, 174, 148, 1 },
+      { 59, 24, 186, 0 },
+      { 148, 186, 224, 1 },
+      { 46, 140, 110, 0 }, },
+    { { 131, 174, 151, 0 },
+      { 51, 90, 186, 0 },
+      { 116, 186, 224, 1 },
+      { 46, 173, 102, 0 }, },
+    { { 131, 174, 232, 0 },
+      { 35, 156, 170, 1 },
+      { 11, 186, 224, 1 },
+      { 170, 156, 226, 0 }, },
+    { { 131, 174, 235, 1 },
+      { 43, 222, 170, 1 },
+      { 235, 186, 224, 1 },
+      { 170, 189, 234, 0 }, },
+    { { 131, 174, 228, 1 },
+      { 43, 156, 186, 0 },
+      { 147, 186, 224, 1 },
+      { 46, 156, 234, 0 }, },
+    { { 131, 174, 231, 0 },
+      { 35, 222, 186, 0 },
+      { 115, 186, 224, 1 },
+      { 46, 189, 226, 0 }, },
+    { { 131, 147, 8, 0 },
+      { 34, 16, 201, 1 },
+      { 8, 100, 224, 1 },
+      { 201, 132, 34, 0 }, },
+    { { 131, 147, 11, 1 },
+      { 42, 82, 201, 1 },
+      { 232, 100, 224, 1 },
+      { 201, 165, 42, 0 }, },
+    { { 131, 147, 4, 1 },
+      { 42, 16, 217, 0 },
+      { 144, 100, 224, 1 },
+      { 77, 132, 42, 0 }, },
+    { { 131, 147, 7, 0 },
+      { 34, 82, 217, 0 },
+      { 112, 100, 224, 1 },
+      { 77, 165, 34, 0 }, },
+    { { 131, 147, 120, 0 },
+      { 50, 148, 201, 1 },
+      { 15, 100, 224, 1 },
+      { 201, 148, 166, 0 }, },
+    { { 131, 147, 123, 1 },
+      { 58, 214, 201, 1 },
+      { 239, 100, 224, 1 },
+      { 201, 181, 174, 0 }, },
+    { { 131, 147, 116, 1 },
+      { 58, 148, 217, 0 },
+      { 151, 100, 224, 1 },
+      { 77, 148, 174, 0 }, },
+    { { 131, 147, 119, 0 },
+      { 50, 214, 217, 0 },
+      { 119, 100, 224, 1 },
+      { 77, 181, 166, 0 }, },
+    { { 131, 146, 152, 0 },
+      { 50, 16, 232, 1 },
+      { 12, 164, 224, 1 },
+      { 139, 132, 38, 0 }, },
+    { { 131, 146, 155, 1 },
+      { 58, 82, 232, 1 },
+      { 236, 164, 224, 1 },
+      { 139, 165, 46, 0 }, },
+    { { 131, 146, 148, 1 },
+      { 58, 16, 248, 0 },
+      { 148, 164, 224, 1 },
+      { 15, 132, 46, 0 }, },
+    { { 131, 146, 151, 0 },
+      { 50, 82, 248, 0 },
+      { 116, 164, 224, 1 },
+      { 15, 165, 38, 0 }, },
+    { { 131, 146, 232, 0 },
+      { 34, 148, 232, 1 },
+      { 11, 164, 224, 1 },
+      { 139, 148, 162, 0 }, },
+    { { 131, 146, 235, 1 },
+      { 42, 214, 232, 1 },
+      { 235, 164, 224, 1 },
+      { 139, 181, 170, 0 }, },
+    { { 131, 146, 228, 1 },
+      { 42, 148, 248, 0 },
+      { 147, 164, 224, 1 },
+      { 15, 148, 170, 0 }, },
+    { { 131, 146, 231, 0 },
+      { 34, 214, 248, 0 },
+      { 115, 164, 224, 1 },
+      { 15, 181, 162, 0 }, },
+    { { 131, 157, 8, 0 },
+      { 3, 24, 201, 1 },
+      { 8, 92, 224, 1 },
+      { 201, 140, 96, 0 }, },
+    { { 131, 157, 11, 1 },
+      { 11, 90, 201, 1 },
+      { 232, 92, 224, 1 },
+      { 201, 173, 104, 0 }, },
+    { { 131, 157, 4, 1 },
+      { 11, 24, 217, 0 },
+      { 144, 92, 224, 1 },
+      { 77, 140, 104, 0 }, },
+    { { 131, 157, 7, 0 },
+      { 3, 90, 217, 0 },
+      { 112, 92, 224, 1 },
+      { 77, 173, 96, 0 }, },
+    { { 131, 157, 120, 0 },
+      { 19, 156, 201, 1 },
+      { 15, 92, 224, 1 },
+      { 201, 156, 228, 0 }, },
+    { { 131, 157, 123, 1 },
+      { 27, 222, 201, 1 },
+      { 239, 92, 224, 1 },
+      { 201, 189, 236, 0 }, },
+    { { 131, 157, 116, 1 },
+      { 27, 156, 217, 0 },
+      { 151, 92, 224, 1 },
+      { 77, 156, 236, 0 }, },
+    { { 131, 157, 119, 0 },
+      { 19, 222, 217, 0 },
+      { 119, 92, 224, 1 },
+      { 77, 189, 228, 0 }, },
+    { { 131, 156, 152, 0 },
+      { 19, 24, 232, 1 },
+      { 12, 156, 224, 1 },
+      { 139, 140, 100, 0 }, },
+    { { 131, 156, 155, 1 },
+      { 27, 90, 232, 1 },
+      { 236, 156, 224, 1 },
+      { 139, 173, 108, 0 }, },
+    { { 131, 156, 148, 1 },
+      { 27, 24, 248, 0 },
+      { 148, 156, 224, 1 },
+      { 15, 140, 108, 0 }, },
+    { { 131, 156, 151, 0 },
+      { 19, 90, 248, 0 },
+      { 116, 156, 224, 1 },
+      { 15, 173, 100, 0 }, },
+    { { 131, 156, 232, 0 },
+      { 3, 156, 232, 1 },
+      { 11, 156, 224, 1 },
+      { 139, 156, 224, 0 }, },
+    { { 131, 156, 235, 1 },
+      { 11, 222, 232, 1 },
+      { 235, 156, 224, 1 },
+      { 139, 189, 232, 0 }, },
+    { { 131, 156, 228, 1 },
+      { 11, 156, 248, 0 },
+      { 147, 156, 224, 1 },
+      { 15, 156, 232, 0 }, },
+    { { 131, 156, 231, 0 },
+      { 3, 222, 248, 0 },
+      { 115, 156, 224, 1 },
+      { 15, 189, 224, 0 }, },
+    { { 188, 33, 8, 0 },
+      { 132, 32, 15, 1 },
+      { 8, 66, 30, 1 },
+      { 248, 2, 16, 1 }, },
+    { { 188, 33, 11, 1 },
+      { 140, 98, 15, 1 },
+      { 232, 66, 30, 1 },
+      { 248, 35, 24, 1 }, },
+    { { 188, 33, 4, 1 },
+      { 140, 32, 31, 0 },
+      { 144, 66, 30, 1 },
+      { 124, 2, 24, 1 }, },
+    { { 188, 33, 7, 0 },
+      { 132, 98, 31, 0 },
+      { 112, 66, 30, 1 },
+      { 124, 35, 16, 1 }, },
+    { { 188, 33, 120, 0 },
+      { 148, 164, 15, 1 },
+      { 15, 66, 30, 1 },
+      { 248, 18, 148, 1 }, },
+    { { 188, 33, 123, 1 },
+      { 156, 230, 15, 1 },
+      { 239, 66, 30, 1 },
+      { 248, 51, 156, 1 }, },
+    { { 188, 33, 116, 1 },
+      { 156, 164, 31, 0 },
+      { 151, 66, 30, 1 },
+      { 124, 18, 156, 1 }, },
+    { { 188, 33, 119, 0 },
+      { 148, 230, 31, 0 },
+      { 119, 66, 30, 1 },
+      { 124, 51, 148, 1 }, },
+    { { 188, 32, 152, 0 },
+      { 148, 32, 46, 1 },
+      { 12, 130, 30, 1 },
+      { 186, 2, 20, 1 }, },
+    { { 188, 32, 155, 1 },
+      { 156, 98, 46, 1 },
+      { 236, 130, 30, 1 },
+      { 186, 35, 28, 1 }, },
+    { { 188, 32, 148, 1 },
+      { 156, 32, 62, 0 },
+      { 148, 130, 30, 1 },
+      { 62, 2, 28, 1 }, },
+    { { 188, 32, 151, 0 },
+      { 148, 98, 62, 0 },
+      { 116, 130, 30, 1 },
+      { 62, 35, 20, 1 }, },
+    { { 188, 32, 232, 0 },
+      { 132, 164, 46, 1 },
+      { 11, 130, 30, 1 },
+      { 186, 18, 144, 1 }, },
+    { { 188, 32, 235, 1 },
+      { 140, 230, 46, 1 },
+      { 235, 130, 30, 1 },
+      { 186, 51, 152, 1 }, },
+    { { 188, 32, 228, 1 },
+      { 140, 164, 62, 0 },
+      { 147, 130, 30, 1 },
+      { 62, 18, 152, 1 }, },
+    { { 188, 32, 231, 0 },
+      { 132, 230, 62, 0 },
+      { 115, 130, 30, 1 },
+      { 62, 51, 144, 1 }, },
+    { { 188, 47, 8, 0 },
+      { 165, 40, 15, 1 },
+      { 8, 122, 30, 1 },
+      { 248, 10, 82, 1 }, },
+    { { 188, 47, 11, 1 },
+      { 173, 106, 15, 1 },
+      { 232, 122, 30, 1 },
+      { 248, 43, 90, 1 }, },
+    { { 188, 47, 4, 1 },
+      { 173, 40, 31, 0 },
+      { 144, 122, 30, 1 },
+      { 124, 10, 90, 1 }, },
+    { { 188, 47, 7, 0 },
+      { 165, 106, 31, 0 },
+      { 112, 122, 30, 1 },
+      { 124, 43, 82, 1 }, },
+    { { 188, 47, 120, 0 },
+      { 181, 172, 15, 1 },
+      { 15, 122, 30, 1 },
+      { 248, 26, 214, 1 }, },
+    { { 188, 47, 123, 1 },
+      { 189, 238, 15, 1 },
+      { 239, 122, 30, 1 },
+      { 248, 59, 222, 1 }, },
+    { { 188, 47, 116, 1 },
+      { 189, 172, 31, 0 },
+      { 151, 122, 30, 1 },
+      { 124, 26, 222, 1 }, },
+    { { 188, 47, 119, 0 },
+      { 181, 238, 31, 0 },
+      { 119, 122, 30, 1 },
+      { 124, 59, 214, 1 }, },
+    { { 188, 46, 152, 0 },
+      { 181, 40, 46, 1 },
+      { 12, 186, 30, 1 },
+      { 186, 10, 86, 1 }, },
+    { { 188, 46, 155, 1 },
+      { 189, 106, 46, 1 },
+      { 236, 186, 30, 1 },
+      { 186, 43, 94, 1 }, },
+    { { 188, 46, 148, 1 },
+      { 189, 40, 62, 0 },
+      { 148, 186, 30, 1 },
+      { 62, 10, 94, 1 }, },
+    { { 188, 46, 151, 0 },
+      { 181, 106, 62, 0 },
+      { 116, 186, 30, 1 },
+      { 62, 43, 86, 1 }, },
+    { { 188, 46, 232, 0 },
+      { 165, 172, 46, 1 },
+      { 11, 186, 30, 1 },
+      { 186, 26, 210, 1 }, },
+    { { 188, 46, 235, 1 },
+      { 173, 238, 46, 1 },
+      { 235, 186, 30, 1 },
+      { 186, 59, 218, 1 }, },
+    { { 188, 46, 228, 1 },
+      { 173, 172, 62, 0 },
+      { 147, 186, 30, 1 },
+      { 62, 26, 218, 1 }, },
+    { { 188, 46, 231, 0 },
+      { 165, 238, 62, 0 },
+      { 115, 186, 30, 1 },
+      { 62, 59, 210, 1 }, },
+    { { 188, 19, 8, 0 },
+      { 164, 32, 77, 1 },
+      { 8, 100, 30, 1 },
+      { 217, 2, 18, 1 }, },
+    { { 188, 19, 11, 1 },
+      { 172, 98, 77, 1 },
+      { 232, 100, 30, 1 },
+      { 217, 35, 26, 1 }, },
+    { { 188, 19, 4, 1 },
+      { 172, 32, 93, 0 },
+      { 144, 100, 30, 1 },
+      { 93, 2, 26, 1 }, },
+    { { 188, 19, 7, 0 },
+      { 164, 98, 93, 0 },
+      { 112, 100, 30, 1 },
+      { 93, 35, 18, 1 }, },
+    { { 188, 19, 120, 0 },
+      { 180, 164, 77, 1 },
+      { 15, 100, 30, 1 },
+      { 217, 18, 150, 1 }, },
+    { { 188, 19, 123, 1 },
+      { 188, 230, 77, 1 },
+      { 239, 100, 30, 1 },
+      { 217, 51, 158, 1 }, },
+    { { 188, 19, 116, 1 },
+      { 188, 164, 93, 0 },
+      { 151, 100, 30, 1 },
+      { 93, 18, 158, 1 }, },
+    { { 188, 19, 119, 0 },
+      { 180, 230, 93, 0 },
+      { 119, 100, 30, 1 },
+      { 93, 51, 150, 1 }, },
+    { { 188, 18, 152, 0 },
+      { 180, 32, 108, 1 },
+      { 12, 164, 30, 1 },
+      { 155, 2, 22, 1 }, },
+    { { 188, 18, 155, 1 },
+      { 188, 98, 108, 1 },
+      { 236, 164, 30, 1 },
+      { 155, 35, 30, 1 }, },
+    { { 188, 18, 148, 1 },
+      { 188, 32, 124, 0 },
+      { 148, 164, 30, 1 },
+      { 31, 2, 30, 1 }, },
+    { { 188, 18, 151, 0 },
+      { 180, 98, 124, 0 },
+      { 116, 164, 30, 1 },
+      { 31, 35, 22, 1 }, },
+    { { 188, 18, 232, 0 },
+      { 164, 164, 108, 1 },
+      { 11, 164, 30, 1 },
+      { 155, 18, 146, 1 }, },
+    { { 188, 18, 235, 1 },
+      { 172, 230, 108, 1 },
+      { 235, 164, 30, 1 },
+      { 155, 51, 154, 1 }, },
+    { { 188, 18, 228, 1 },
+      { 172, 164, 124, 0 },
+      { 147, 164, 30, 1 },
+      { 31, 18, 154, 1 }, },
+    { { 188, 18, 231, 0 },
+      { 164, 230, 124, 0 },
+      { 115, 164, 30, 1 },
+      { 31, 51, 146, 1 }, },
+    { { 188, 29, 8, 0 },
+      { 133, 40, 77, 1 },
+      { 8, 92, 30, 1 },
+      { 217, 10, 80, 1 }, },
+    { { 188, 29, 11, 1 },
+      { 141, 106, 77, 1 },
+      { 232, 92, 30, 1 },
+      { 217, 43, 88, 1 }, },
+    { { 188, 29, 4, 1 },
+      { 141, 40, 93, 0 },
+      { 144, 92, 30, 1 },
+      { 93, 10, 88, 1 }, },
+    { { 188, 29, 7, 0 },
+      { 133, 106, 93, 0 },
+      { 112, 92, 30, 1 },
+      { 93, 43, 80, 1 }, },
+    { { 188, 29, 120, 0 },
+      { 149, 172, 77, 1 },
+      { 15, 92, 30, 1 },
+      { 217, 26, 212, 1 }, },
+    { { 188, 29, 123, 1 },
+      { 157, 238, 77, 1 },
+      { 239, 92, 30, 1 },
+      { 217, 59, 220, 1 }, },
+    { { 188, 29, 116, 1 },
+      { 157, 172, 93, 0 },
+      { 151, 92, 30, 1 },
+      { 93, 26, 220, 1 }, },
+    { { 188, 29, 119, 0 },
+      { 149, 238, 93, 0 },
+      { 119, 92, 30, 1 },
+      { 93, 59, 212, 1 }, },
+    { { 188, 28, 152, 0 },
+      { 149, 40, 108, 1 },
+      { 12, 156, 30, 1 },
+      { 155, 10, 84, 1 }, },
+    { { 188, 28, 155, 1 },
+      { 157, 106, 108, 1 },
+      { 236, 156, 30, 1 },
+      { 155, 43, 92, 1 }, },
+    { { 188, 28, 148, 1 },
+      { 157, 40, 124, 0 },
+      { 148, 156, 30, 1 },
+      { 31, 10, 92, 1 }, },
+    { { 188, 28, 151, 0 },
+      { 149, 106, 124, 0 },
+      { 116, 156, 30, 1 },
+      { 31, 43, 84, 1 }, },
+    { { 188, 28, 232, 0 },
+      { 133, 172, 108, 1 },
+      { 11, 156, 30, 1 },
+      { 155, 26, 208, 1 }, },
+    { { 188, 28, 235, 1 },
+      { 141, 238, 108, 1 },
+      { 235, 156, 30, 1 },
+      { 155, 59, 216, 1 }, },
+    { { 188, 28, 228, 1 },
+      { 141, 172, 124, 0 },
+      { 147, 156, 30, 1 },
+      { 31, 26, 216, 1 }, },
+    { { 188, 28, 231, 0 },
+      { 133, 238, 124, 0 },
+      { 115, 156, 30, 1 },
+      { 31, 59, 208, 1 }, },
+    { { 189, 225, 8, 0 },
+      { 198, 48, 15, 1 },
+      { 8, 67, 222, 1 },
+      { 248, 6, 49, 1 }, },
+    { { 189, 225, 11, 1 },
+      { 206, 114, 15, 1 },
+      { 232, 67, 222, 1 },
+      { 248, 39, 57, 1 }, },
+    { { 189, 225, 4, 1 },
+      { 206, 48, 31, 0 },
+      { 144, 67, 222, 1 },
+      { 124, 6, 57, 1 }, },
+    { { 189, 225, 7, 0 },
+      { 198, 114, 31, 0 },
+      { 112, 67, 222, 1 },
+      { 124, 39, 49, 1 }, },
+    { { 189, 225, 120, 0 },
+      { 214, 180, 15, 1 },
+      { 15, 67, 222, 1 },
+      { 248, 22, 181, 1 }, },
+    { { 189, 225, 123, 1 },
+      { 222, 246, 15, 1 },
+      { 239, 67, 222, 1 },
+      { 248, 55, 189, 1 }, },
+    { { 189, 225, 116, 1 },
+      { 222, 180, 31, 0 },
+      { 151, 67, 222, 1 },
+      { 124, 22, 189, 1 }, },
+    { { 189, 225, 119, 0 },
+      { 214, 246, 31, 0 },
+      { 119, 67, 222, 1 },
+      { 124, 55, 181, 1 }, },
+    { { 189, 224, 152, 0 },
+      { 214, 48, 46, 1 },
+      { 12, 131, 222, 1 },
+      { 186, 6, 53, 1 }, },
+    { { 189, 224, 155, 1 },
+      { 222, 114, 46, 1 },
+      { 236, 131, 222, 1 },
+      { 186, 39, 61, 1 }, },
+    { { 189, 224, 148, 1 },
+      { 222, 48, 62, 0 },
+      { 148, 131, 222, 1 },
+      { 62, 6, 61, 1 }, },
+    { { 189, 224, 151, 0 },
+      { 214, 114, 62, 0 },
+      { 116, 131, 222, 1 },
+      { 62, 39, 53, 1 }, },
+    { { 189, 224, 232, 0 },
+      { 198, 180, 46, 1 },
+      { 11, 131, 222, 1 },
+      { 186, 22, 177, 1 }, },
+    { { 189, 224, 235, 1 },
+      { 206, 246, 46, 1 },
+      { 235, 131, 222, 1 },
+      { 186, 55, 185, 1 }, },
+    { { 189, 224, 228, 1 },
+      { 206, 180, 62, 0 },
+      { 147, 131, 222, 1 },
+      { 62, 22, 185, 1 }, },
+    { { 189, 224, 231, 0 },
+      { 198, 246, 62, 0 },
+      { 115, 131, 222, 1 },
+      { 62, 55, 177, 1 }, },
+    { { 189, 239, 8, 0 },
+      { 231, 56, 15, 1 },
+      { 8, 123, 222, 1 },
+      { 248, 14, 115, 1 }, },
+    { { 189, 239, 11, 1 },
+      { 239, 122, 15, 1 },
+      { 232, 123, 222, 1 },
+      { 248, 47, 123, 1 }, },
+    { { 189, 239, 4, 1 },
+      { 239, 56, 31, 0 },
+      { 144, 123, 222, 1 },
+      { 124, 14, 123, 1 }, },
+    { { 189, 239, 7, 0 },
+      { 231, 122, 31, 0 },
+      { 112, 123, 222, 1 },
+      { 124, 47, 115, 1 }, },
+    { { 189, 239, 120, 0 },
+      { 247, 188, 15, 1 },
+      { 15, 123, 222, 1 },
+      { 248, 30, 247, 1 }, },
+    { { 189, 239, 123, 1 },
+      { 255, 254, 15, 1 },
+      { 239, 123, 222, 1 },
+      { 248, 63, 255, 1 }, },
+    { { 189, 239, 116, 1 },
+      { 255, 188, 31, 0 },
+      { 151, 123, 222, 1 },
+      { 124, 30, 255, 1 }, },
+    { { 189, 239, 119, 0 },
+      { 247, 254, 31, 0 },
+      { 119, 123, 222, 1 },
+      { 124, 63, 247, 1 }, },
+    { { 189, 238, 152, 0 },
+      { 247, 56, 46, 1 },
+      { 12, 187, 222, 1 },
+      { 186, 14, 119, 1 }, },
+    { { 189, 238, 155, 1 },
+      { 255, 122, 46, 1 },
+      { 236, 187, 222, 1 },
+      { 186, 47, 127, 1 }, },
+    { { 189, 238, 148, 1 },
+      { 255, 56, 62, 0 },
+      { 148, 187, 222, 1 },
+      { 62, 14, 127, 1 }, },
+    { { 189, 238, 151, 0 },
+      { 247, 122, 62, 0 },
+      { 116, 187, 222, 1 },
+      { 62, 47, 119, 1 }, },
+    { { 189, 238, 232, 0 },
+      { 231, 188, 46, 1 },
+      { 11, 187, 222, 1 },
+      { 186, 30, 243, 1 }, },
+    { { 189, 238, 235, 1 },
+      { 239, 254, 46, 1 },
+      { 235, 187, 222, 1 },
+      { 186, 63, 251, 1 }, },
+    { { 189, 238, 228, 1 },
+      { 239, 188, 62, 0 },
+      { 147, 187, 222, 1 },
+      { 62, 30, 251, 1 }, },
+    { { 189, 238, 231, 0 },
+      { 231, 254, 62, 0 },
+      { 115, 187, 222, 1 },
+      { 62, 63, 243, 1 }, },
+    { { 189, 211, 8, 0 },
+      { 230, 48, 77, 1 },
+      { 8, 101, 222, 1 },
+      { 217, 6, 51, 1 }, },
+    { { 189, 211, 11, 1 },
+      { 238, 114, 77, 1 },
+      { 232, 101, 222, 1 },
+      { 217, 39, 59, 1 }, },
+    { { 189, 211, 4, 1 },
+      { 238, 48, 93, 0 },
+      { 144, 101, 222, 1 },
+      { 93, 6, 59, 1 }, },
+    { { 189, 211, 7, 0 },
+      { 230, 114, 93, 0 },
+      { 112, 101, 222, 1 },
+      { 93, 39, 51, 1 }, },
+    { { 189, 211, 120, 0 },
+      { 246, 180, 77, 1 },
+      { 15, 101, 222, 1 },
+      { 217, 22, 183, 1 }, },
+    { { 189, 211, 123, 1 },
+      { 254, 246, 77, 1 },
+      { 239, 101, 222, 1 },
+      { 217, 55, 191, 1 }, },
+    { { 189, 211, 116, 1 },
+      { 254, 180, 93, 0 },
+      { 151, 101, 222, 1 },
+      { 93, 22, 191, 1 }, },
+    { { 189, 211, 119, 0 },
+      { 246, 246, 93, 0 },
+      { 119, 101, 222, 1 },
+      { 93, 55, 183, 1 }, },
+    { { 189, 210, 152, 0 },
+      { 246, 48, 108, 1 },
+      { 12, 165, 222, 1 },
+      { 155, 6, 55, 1 }, },
+    { { 189, 210, 155, 1 },
+      { 254, 114, 108, 1 },
+      { 236, 165, 222, 1 },
+      { 155, 39, 63, 1 }, },
+    { { 189, 210, 148, 1 },
+      { 254, 48, 124, 0 },
+      { 148, 165, 222, 1 },
+      { 31, 6, 63, 1 }, },
+    { { 189, 210, 151, 0 },
+      { 246, 114, 124, 0 },
+      { 116, 165, 222, 1 },
+      { 31, 39, 55, 1 }, },
+    { { 189, 210, 232, 0 },
+      { 230, 180, 108, 1 },
+      { 11, 165, 222, 1 },
+      { 155, 22, 179, 1 }, },
+    { { 189, 210, 235, 1 },
+      { 238, 246, 108, 1 },
+      { 235, 165, 222, 1 },
+      { 155, 55, 187, 1 }, },
+    { { 189, 210, 228, 1 },
+      { 238, 180, 124, 0 },
+      { 147, 165, 222, 1 },
+      { 31, 22, 187, 1 }, },
+    { { 189, 210, 231, 0 },
+      { 230, 246, 124, 0 },
+      { 115, 165, 222, 1 },
+      { 31, 55, 179, 1 }, },
+    { { 189, 221, 8, 0 },
+      { 199, 56, 77, 1 },
+      { 8, 93, 222, 1 },
+      { 217, 14, 113, 1 }, },
+    { { 189, 221, 11, 1 },
+      { 207, 122, 77, 1 },
+      { 232, 93, 222, 1 },
+      { 217, 47, 121, 1 }, },
+    { { 189, 221, 4, 1 },
+      { 207, 56, 93, 0 },
+      { 144, 93, 222, 1 },
+      { 93, 14, 121, 1 }, },
+    { { 189, 221, 7, 0 },
+      { 199, 122, 93, 0 },
+      { 112, 93, 222, 1 },
+      { 93, 47, 113, 1 }, },
+    { { 189, 221, 120, 0 },
+      { 215, 188, 77, 1 },
+      { 15, 93, 222, 1 },
+      { 217, 30, 245, 1 }, },
+    { { 189, 221, 123, 1 },
+      { 223, 254, 77, 1 },
+      { 239, 93, 222, 1 },
+      { 217, 63, 253, 1 }, },
+    { { 189, 221, 116, 1 },
+      { 223, 188, 93, 0 },
+      { 151, 93, 222, 1 },
+      { 93, 30, 253, 1 }, },
+    { { 189, 221, 119, 0 },
+      { 215, 254, 93, 0 },
+      { 119, 93, 222, 1 },
+      { 93, 63, 245, 1 }, },
+    { { 189, 220, 152, 0 },
+      { 215, 56, 108, 1 },
+      { 12, 157, 222, 1 },
+      { 155, 14, 117, 1 }, },
+    { { 189, 220, 155, 1 },
+      { 223, 122, 108, 1 },
+      { 236, 157, 222, 1 },
+      { 155, 47, 125, 1 }, },
+    { { 189, 220, 148, 1 },
+      { 223, 56, 124, 0 },
+      { 148, 157, 222, 1 },
+      { 31, 14, 125, 1 }, },
+    { { 189, 220, 151, 0 },
+      { 215, 122, 124, 0 },
+      { 116, 157, 222, 1 },
+      { 31, 47, 117, 1 }, },
+    { { 189, 220, 232, 0 },
+      { 199, 188, 108, 1 },
+      { 11, 157, 222, 1 },
+      { 155, 30, 241, 1 }, },
+    { { 189, 220, 235, 1 },
+      { 207, 254, 108, 1 },
+      { 235, 157, 222, 1 },
+      { 155, 63, 249, 1 }, },
+    { { 189, 220, 228, 1 },
+      { 207, 188, 124, 0 },
+      { 147, 157, 222, 1 },
+      { 31, 30, 249, 1 }, },
+    { { 189, 220, 231, 0 },
+      { 199, 254, 124, 0 },
+      { 115, 157, 222, 1 },
+      { 31, 63, 241, 1 }, },
+    { { 186, 97, 8, 0 },
+      { 196, 32, 139, 1 },
+      { 8, 67, 46, 1 },
+      { 232, 130, 17, 1 }, },
+    { { 186, 97, 11, 1 },
+      { 204, 98, 139, 1 },
+      { 232, 67, 46, 1 },
+      { 232, 163, 25, 1 }, },
+    { { 186, 97, 4, 1 },
+      { 204, 32, 155, 0 },
+      { 144, 67, 46, 1 },
+      { 108, 130, 25, 1 }, },
+    { { 186, 97, 7, 0 },
+      { 196, 98, 155, 0 },
+      { 112, 67, 46, 1 },
+      { 108, 163, 17, 1 }, },
+    { { 186, 97, 120, 0 },
+      { 212, 164, 139, 1 },
+      { 15, 67, 46, 1 },
+      { 232, 146, 149, 1 }, },
+    { { 186, 97, 123, 1 },
+      { 220, 230, 139, 1 },
+      { 239, 67, 46, 1 },
+      { 232, 179, 157, 1 }, },
+    { { 186, 97, 116, 1 },
+      { 220, 164, 155, 0 },
+      { 151, 67, 46, 1 },
+      { 108, 146, 157, 1 }, },
+    { { 186, 97, 119, 0 },
+      { 212, 230, 155, 0 },
+      { 119, 67, 46, 1 },
+      { 108, 179, 149, 1 }, },
+    { { 186, 96, 152, 0 },
+      { 212, 32, 170, 1 },
+      { 12, 131, 46, 1 },
+      { 170, 130, 21, 1 }, },
+    { { 186, 96, 155, 1 },
+      { 220, 98, 170, 1 },
+      { 236, 131, 46, 1 },
+      { 170, 163, 29, 1 }, },
+    { { 186, 96, 148, 1 },
+      { 220, 32, 186, 0 },
+      { 148, 131, 46, 1 },
+      { 46, 130, 29, 1 }, },
+    { { 186, 96, 151, 0 },
+      { 212, 98, 186, 0 },
+      { 116, 131, 46, 1 },
+      { 46, 163, 21, 1 }, },
+    { { 186, 96, 232, 0 },
+      { 196, 164, 170, 1 },
+      { 11, 131, 46, 1 },
+      { 170, 146, 145, 1 }, },
+    { { 186, 96, 235, 1 },
+      { 204, 230, 170, 1 },
+      { 235, 131, 46, 1 },
+      { 170, 179, 153, 1 }, },
+    { { 186, 96, 228, 1 },
+      { 204, 164, 186, 0 },
+      { 147, 131, 46, 1 },
+      { 46, 146, 153, 1 }, },
+    { { 186, 96, 231, 0 },
+      { 196, 230, 186, 0 },
+      { 115, 131, 46, 1 },
+      { 46, 179, 145, 1 }, },
+    { { 186, 111, 8, 0 },
+      { 229, 40, 139, 1 },
+      { 8, 123, 46, 1 },
+      { 232, 138, 83, 1 }, },
+    { { 186, 111, 11, 1 },
+      { 237, 106, 139, 1 },
+      { 232, 123, 46, 1 },
+      { 232, 171, 91, 1 }, },
+    { { 186, 111, 4, 1 },
+      { 237, 40, 155, 0 },
+      { 144, 123, 46, 1 },
+      { 108, 138, 91, 1 }, },
+    { { 186, 111, 7, 0 },
+      { 229, 106, 155, 0 },
+      { 112, 123, 46, 1 },
+      { 108, 171, 83, 1 }, },
+    { { 186, 111, 120, 0 },
+      { 245, 172, 139, 1 },
+      { 15, 123, 46, 1 },
+      { 232, 154, 215, 1 }, },
+    { { 186, 111, 123, 1 },
+      { 253, 238, 139, 1 },
+      { 239, 123, 46, 1 },
+      { 232, 187, 223, 1 }, },
+    { { 186, 111, 116, 1 },
+      { 253, 172, 155, 0 },
+      { 151, 123, 46, 1 },
+      { 108, 154, 223, 1 }, },
+    { { 186, 111, 119, 0 },
+      { 245, 238, 155, 0 },
+      { 119, 123, 46, 1 },
+      { 108, 187, 215, 1 }, },
+    { { 186, 110, 152, 0 },
+      { 245, 40, 170, 1 },
+      { 12, 187, 46, 1 },
+      { 170, 138, 87, 1 }, },
+    { { 186, 110, 155, 1 },
+      { 253, 106, 170, 1 },
+      { 236, 187, 46, 1 },
+      { 170, 171, 95, 1 }, },
+    { { 186, 110, 148, 1 },
+      { 253, 40, 186, 0 },
+      { 148, 187, 46, 1 },
+      { 46, 138, 95, 1 }, },
+    { { 186, 110, 151, 0 },
+      { 245, 106, 186, 0 },
+      { 116, 187, 46, 1 },
+      { 46, 171, 87, 1 }, },
+    { { 186, 110, 232, 0 },
+      { 229, 172, 170, 1 },
+      { 11, 187, 46, 1 },
+      { 170, 154, 211, 1 }, },
+    { { 186, 110, 235, 1 },
+      { 237, 238, 170, 1 },
+      { 235, 187, 46, 1 },
+      { 170, 187, 219, 1 }, },
+    { { 186, 110, 228, 1 },
+      { 237, 172, 186, 0 },
+      { 147, 187, 46, 1 },
+      { 46, 154, 219, 1 }, },
+    { { 186, 110, 231, 0 },
+      { 229, 238, 186, 0 },
+      { 115, 187, 46, 1 },
+      { 46, 187, 211, 1 }, },
+    { { 186, 83, 8, 0 },
+      { 228, 32, 201, 1 },
+      { 8, 101, 46, 1 },
+      { 201, 130, 19, 1 }, },
+    { { 186, 83, 11, 1 },
+      { 236, 98, 201, 1 },
+      { 232, 101, 46, 1 },
+      { 201, 163, 27, 1 }, },
+    { { 186, 83, 4, 1 },
+      { 236, 32, 217, 0 },
+      { 144, 101, 46, 1 },
+      { 77, 130, 27, 1 }, },
+    { { 186, 83, 7, 0 },
+      { 228, 98, 217, 0 },
+      { 112, 101, 46, 1 },
+      { 77, 163, 19, 1 }, },
+    { { 186, 83, 120, 0 },
+      { 244, 164, 201, 1 },
+      { 15, 101, 46, 1 },
+      { 201, 146, 151, 1 }, },
+    { { 186, 83, 123, 1 },
+      { 252, 230, 201, 1 },
+      { 239, 101, 46, 1 },
+      { 201, 179, 159, 1 }, },
+    { { 186, 83, 116, 1 },
+      { 252, 164, 217, 0 },
+      { 151, 101, 46, 1 },
+      { 77, 146, 159, 1 }, },
+    { { 186, 83, 119, 0 },
+      { 244, 230, 217, 0 },
+      { 119, 101, 46, 1 },
+      { 77, 179, 151, 1 }, },
+    { { 186, 82, 152, 0 },
+      { 244, 32, 232, 1 },
+      { 12, 165, 46, 1 },
+      { 139, 130, 23, 1 }, },
+    { { 186, 82, 155, 1 },
+      { 252, 98, 232, 1 },
+      { 236, 165, 46, 1 },
+      { 139, 163, 31, 1 }, },
+    { { 186, 82, 148, 1 },
+      { 252, 32, 248, 0 },
+      { 148, 165, 46, 1 },
+      { 15, 130, 31, 1 }, },
+    { { 186, 82, 151, 0 },
+      { 244, 98, 248, 0 },
+      { 116, 165, 46, 1 },
+      { 15, 163, 23, 1 }, },
+    { { 186, 82, 232, 0 },
+      { 228, 164, 232, 1 },
+      { 11, 165, 46, 1 },
+      { 139, 146, 147, 1 }, },
+    { { 186, 82, 235, 1 },
+      { 236, 230, 232, 1 },
+      { 235, 165, 46, 1 },
+      { 139, 179, 155, 1 }, },
+    { { 186, 82, 228, 1 },
+      { 236, 164, 248, 0 },
+      { 147, 165, 46, 1 },
+      { 15, 146, 155, 1 }, },
+    { { 186, 82, 231, 0 },
+      { 228, 230, 248, 0 },
+      { 115, 165, 46, 1 },
+      { 15, 179, 147, 1 }, },
+    { { 186, 93, 8, 0 },
+      { 197, 40, 201, 1 },
+      { 8, 93, 46, 1 },
+      { 201, 138, 81, 1 }, },
+    { { 186, 93, 11, 1 },
+      { 205, 106, 201, 1 },
+      { 232, 93, 46, 1 },
+      { 201, 171, 89, 1 }, },
+    { { 186, 93, 4, 1 },
+      { 205, 40, 217, 0 },
+      { 144, 93, 46, 1 },
+      { 77, 138, 89, 1 }, },
+    { { 186, 93, 7, 0 },
+      { 197, 106, 217, 0 },
+      { 112, 93, 46, 1 },
+      { 77, 171, 81, 1 }, },
+    { { 186, 93, 120, 0 },
+      { 213, 172, 201, 1 },
+      { 15, 93, 46, 1 },
+      { 201, 154, 213, 1 }, },
+    { { 186, 93, 123, 1 },
+      { 221, 238, 201, 1 },
+      { 239, 93, 46, 1 },
+      { 201, 187, 221, 1 }, },
+    { { 186, 93, 116, 1 },
+      { 221, 172, 217, 0 },
+      { 151, 93, 46, 1 },
+      { 77, 154, 221, 1 }, },
+    { { 186, 93, 119, 0 },
+      { 213, 238, 217, 0 },
+      { 119, 93, 46, 1 },
+      { 77, 187, 213, 1 }, },
+    { { 186, 92, 152, 0 },
+      { 213, 40, 232, 1 },
+      { 12, 157, 46, 1 },
+      { 139, 138, 85, 1 }, },
+    { { 186, 92, 155, 1 },
+      { 221, 106, 232, 1 },
+      { 236, 157, 46, 1 },
+      { 139, 171, 93, 1 }, },
+    { { 186, 92, 148, 1 },
+      { 221, 40, 248, 0 },
+      { 148, 157, 46, 1 },
+      { 15, 138, 93, 1 }, },
+    { { 186, 92, 151, 0 },
+      { 213, 106, 248, 0 },
+      { 116, 157, 46, 1 },
+      { 15, 171, 85, 1 }, },
+    { { 186, 92, 232, 0 },
+      { 197, 172, 232, 1 },
+      { 11, 157, 46, 1 },
+      { 139, 154, 209, 1 }, },
+    { { 186, 92, 235, 1 },
+      { 205, 238, 232, 1 },
+      { 235, 157, 46, 1 },
+      { 139, 187, 217, 1 }, },
+    { { 186, 92, 228, 1 },
+      { 205, 172, 248, 0 },
+      { 147, 157, 46, 1 },
+      { 15, 154, 217, 1 }, },
+    { { 186, 92, 231, 0 },
+      { 197, 238, 248, 0 },
+      { 115, 157, 46, 1 },
+      { 15, 187, 209, 1 }, },
+    { { 187, 161, 8, 0 },
+      { 134, 48, 139, 1 },
+      { 8, 66, 238, 1 },
+      { 232, 134, 48, 1 }, },
+    { { 187, 161, 11, 1 },
+      { 142, 114, 139, 1 },
+      { 232, 66, 238, 1 },
+      { 232, 167, 56, 1 }, },
+    { { 187, 161, 4, 1 },
+      { 142, 48, 155, 0 },
+      { 144, 66, 238, 1 },
+      { 108, 134, 56, 1 }, },
+    { { 187, 161, 7, 0 },
+      { 134, 114, 155, 0 },
+      { 112, 66, 238, 1 },
+      { 108, 167, 48, 1 }, },
+    { { 187, 161, 120, 0 },
+      { 150, 180, 139, 1 },
+      { 15, 66, 238, 1 },
+      { 232, 150, 180, 1 }, },
+    { { 187, 161, 123, 1 },
+      { 158, 246, 139, 1 },
+      { 239, 66, 238, 1 },
+      { 232, 183, 188, 1 }, },
+    { { 187, 161, 116, 1 },
+      { 158, 180, 155, 0 },
+      { 151, 66, 238, 1 },
+      { 108, 150, 188, 1 }, },
+    { { 187, 161, 119, 0 },
+      { 150, 246, 155, 0 },
+      { 119, 66, 238, 1 },
+      { 108, 183, 180, 1 }, },
+    { { 187, 160, 152, 0 },
+      { 150, 48, 170, 1 },
+      { 12, 130, 238, 1 },
+      { 170, 134, 52, 1 }, },
+    { { 187, 160, 155, 1 },
+      { 158, 114, 170, 1 },
+      { 236, 130, 238, 1 },
+      { 170, 167, 60, 1 }, },
+    { { 187, 160, 148, 1 },
+      { 158, 48, 186, 0 },
+      { 148, 130, 238, 1 },
+      { 46, 134, 60, 1 }, },
+    { { 187, 160, 151, 0 },
+      { 150, 114, 186, 0 },
+      { 116, 130, 238, 1 },
+      { 46, 167, 52, 1 }, },
+    { { 187, 160, 232, 0 },
+      { 134, 180, 170, 1 },
+      { 11, 130, 238, 1 },
+      { 170, 150, 176, 1 }, },
+    { { 187, 160, 235, 1 },
+      { 142, 246, 170, 1 },
+      { 235, 130, 238, 1 },
+      { 170, 183, 184, 1 }, },
+    { { 187, 160, 228, 1 },
+      { 142, 180, 186, 0 },
+      { 147, 130, 238, 1 },
+      { 46, 150, 184, 1 }, },
+    { { 187, 160, 231, 0 },
+      { 134, 246, 186, 0 },
+      { 115, 130, 238, 1 },
+      { 46, 183, 176, 1 }, },
+    { { 187, 175, 8, 0 },
+      { 167, 56, 139, 1 },
+      { 8, 122, 238, 1 },
+      { 232, 142, 114, 1 }, },
+    { { 187, 175, 11, 1 },
+      { 175, 122, 139, 1 },
+      { 232, 122, 238, 1 },
+      { 232, 175, 122, 1 }, },
+    { { 187, 175, 4, 1 },
+      { 175, 56, 155, 0 },
+      { 144, 122, 238, 1 },
+      { 108, 142, 122, 1 }, },
+    { { 187, 175, 7, 0 },
+      { 167, 122, 155, 0 },
+      { 112, 122, 238, 1 },
+      { 108, 175, 114, 1 }, },
+    { { 187, 175, 120, 0 },
+      { 183, 188, 139, 1 },
+      { 15, 122, 238, 1 },
+      { 232, 158, 246, 1 }, },
+    { { 187, 175, 123, 1 },
+      { 191, 254, 139, 1 },
+      { 239, 122, 238, 1 },
+      { 232, 191, 254, 1 }, },
+    { { 187, 175, 116, 1 },
+      { 191, 188, 155, 0 },
+      { 151, 122, 238, 1 },
+      { 108, 158, 254, 1 }, },
+    { { 187, 175, 119, 0 },
+      { 183, 254, 155, 0 },
+      { 119, 122, 238, 1 },
+      { 108, 191, 246, 1 }, },
+    { { 187, 174, 152, 0 },
+      { 183, 56, 170, 1 },
+      { 12, 186, 238, 1 },
+      { 170, 142, 118, 1 }, },
+    { { 187, 174, 155, 1 },
+      { 191, 122, 170, 1 },
+      { 236, 186, 238, 1 },
+      { 170, 175, 126, 1 }, },
+    { { 187, 174, 148, 1 },
+      { 191, 56, 186, 0 },
+      { 148, 186, 238, 1 },
+      { 46, 142, 126, 1 }, },
+    { { 187, 174, 151, 0 },
+      { 183, 122, 186, 0 },
+      { 116, 186, 238, 1 },
+      { 46, 175, 118, 1 }, },
+    { { 187, 174, 232, 0 },
+      { 167, 188, 170, 1 },
+      { 11, 186, 238, 1 },
+      { 170, 158, 242, 1 }, },
+    { { 187, 174, 235, 1 },
+      { 175, 254, 170, 1 },
+      { 235, 186, 238, 1 },
+      { 170, 191, 250, 1 }, },
+    { { 187, 174, 228, 1 },
+      { 175, 188, 186, 0 },
+      { 147, 186, 238, 1 },
+      { 46, 158, 250, 1 }, },
+    { { 187, 174, 231, 0 },
+      { 167, 254, 186, 0 },
+      { 115, 186, 238, 1 },
+      { 46, 191, 242, 1 }, },
+    { { 187, 147, 8, 0 },
+      { 166, 48, 201, 1 },
+      { 8, 100, 238, 1 },
+      { 201, 134, 50, 1 }, },
+    { { 187, 147, 11, 1 },
+      { 174, 114, 201, 1 },
+      { 232, 100, 238, 1 },
+      { 201, 167, 58, 1 }, },
+    { { 187, 147, 4, 1 },
+      { 174, 48, 217, 0 },
+      { 144, 100, 238, 1 },
+      { 77, 134, 58, 1 }, },
+    { { 187, 147, 7, 0 },
+      { 166, 114, 217, 0 },
+      { 112, 100, 238, 1 },
+      { 77, 167, 50, 1 }, },
+    { { 187, 147, 120, 0 },
+      { 182, 180, 201, 1 },
+      { 15, 100, 238, 1 },
+      { 201, 150, 182, 1 }, },
+    { { 187, 147, 123, 1 },
+      { 190, 246, 201, 1 },
+      { 239, 100, 238, 1 },
+      { 201, 183, 190, 1 }, },
+    { { 187, 147, 116, 1 },
+      { 190, 180, 217, 0 },
+      { 151, 100, 238, 1 },
+      { 77, 150, 190, 1 }, },
+    { { 187, 147, 119, 0 },
+      { 182, 246, 217, 0 },
+      { 119, 100, 238, 1 },
+      { 77, 183, 182, 1 }, },
+    { { 187, 146, 152, 0 },
+      { 182, 48, 232, 1 },
+      { 12, 164, 238, 1 },
+      { 139, 134, 54, 1 }, },
+    { { 187, 146, 155, 1 },
+      { 190, 114, 232, 1 },
+      { 236, 164, 238, 1 },
+      { 139, 167, 62, 1 }, },
+    { { 187, 146, 148, 1 },
+      { 190, 48, 248, 0 },
+      { 148, 164, 238, 1 },
+      { 15, 134, 62, 1 }, },
+    { { 187, 146, 151, 0 },
+      { 182, 114, 248, 0 },
+      { 116, 164, 238, 1 },
+      { 15, 167, 54, 1 }, },
+    { { 187, 146, 232, 0 },
+      { 166, 180, 232, 1 },
+      { 11, 164, 238, 1 },
+      { 139, 150, 178, 1 }, },
+    { { 187, 146, 235, 1 },
+      { 174, 246, 232, 1 },
+      { 235, 164, 238, 1 },
+      { 139, 183, 186, 1 }, },
+    { { 187, 146, 228, 1 },
+      { 174, 180, 248, 0 },
+      { 147, 164, 238, 1 },
+      { 15, 150, 186, 1 }, },
+    { { 187, 146, 231, 0 },
+      { 166, 246, 248, 0 },
+      { 115, 164, 238, 1 },
+      { 15, 183, 178, 1 }, },
+    { { 187, 157, 8, 0 },
+      { 135, 56, 201, 1 },
+      { 8, 92, 238, 1 },
+      { 201, 142, 112, 1 }, },
+    { { 187, 157, 11, 1 },
+      { 143, 122, 201, 1 },
+      { 232, 92, 238, 1 },
+      { 201, 175, 120, 1 }, },
+    { { 187, 157, 4, 1 },
+      { 143, 56, 217, 0 },
+      { 144, 92, 238, 1 },
+      { 77, 142, 120, 1 }, },
+    { { 187, 157, 7, 0 },
+      { 135, 122, 217, 0 },
+      { 112, 92, 238, 1 },
+      { 77, 175, 112, 1 }, },
+    { { 187, 157, 120, 0 },
+      { 151, 188, 201, 1 },
+      { 15, 92, 238, 1 },
+      { 201, 158, 244, 1 }, },
+    { { 187, 157, 123, 1 },
+      { 159, 254, 201, 1 },
+      { 239, 92, 238, 1 },
+      { 201, 191, 252, 1 }, },
+    { { 187, 157, 116, 1 },
+      { 159, 188, 217, 0 },
+      { 151, 92, 238, 1 },
+      { 77, 158, 252, 1 }, },
+    { { 187, 157, 119, 0 },
+      { 151, 254, 217, 0 },
+      { 119, 92, 238, 1 },
+      { 77, 191, 244, 1 }, },
+    { { 187, 156, 152, 0 },
+      { 151, 56, 232, 1 },
+      { 12, 156, 238, 1 },
+      { 139, 142, 116, 1 }, },
+    { { 187, 156, 155, 1 },
+      { 159, 122, 232, 1 },
+      { 236, 156, 238, 1 },
+      { 139, 175, 124, 1 }, },
+    { { 187, 156, 148, 1 },
+      { 159, 56, 248, 0 },
+      { 148, 156, 238, 1 },
+      { 15, 142, 124, 1 }, },
+    { { 187, 156, 151, 0 },
+      { 151, 122, 248, 0 },
+      { 116, 156, 238, 1 },
+      { 15, 175, 116, 1 }, },
+    { { 187, 156, 232, 0 },
+      { 135, 188, 232, 1 },
+      { 11, 156, 238, 1 },
+      { 139, 158, 240, 1 }, },
+    { { 187, 156, 235, 1 },
+      { 143, 254, 232, 1 },
+      { 235, 156, 238, 1 },
+      { 139, 191, 248, 1 }, },
+    { { 187, 156, 228, 1 },
+      { 143, 188, 248, 0 },
+      { 147, 156, 238, 1 },
+      { 15, 158, 248, 1 }, },
+    { { 187, 156, 231, 0 },
+      { 135, 254, 248, 0 },
+      { 115, 156, 238, 1 },
+      { 15, 191, 240, 1 }, },
+    { { 76, 33, 8, 0 },
+      { 128, 1, 7, 1 },
+      { 8, 66, 25, 0 },
+      { 240, 64, 0, 1 }, },
+    { { 76, 33, 11, 1 },
+      { 136, 67, 7, 1 },
+      { 232, 66, 25, 0 },
+      { 240, 97, 8, 1 }, },
+    { { 76, 33, 4, 1 },
+      { 136, 1, 23, 0 },
+      { 144, 66, 25, 0 },
+      { 116, 64, 8, 1 }, },
+    { { 76, 33, 7, 0 },
+      { 128, 67, 23, 0 },
+      { 112, 66, 25, 0 },
+      { 116, 97, 0, 1 }, },
+    { { 76, 33, 120, 0 },
+      { 144, 133, 7, 1 },
+      { 15, 66, 25, 0 },
+      { 240, 80, 132, 1 }, },
+    { { 76, 33, 123, 1 },
+      { 152, 199, 7, 1 },
+      { 239, 66, 25, 0 },
+      { 240, 113, 140, 1 }, },
+    { { 76, 33, 116, 1 },
+      { 152, 133, 23, 0 },
+      { 151, 66, 25, 0 },
+      { 116, 80, 140, 1 }, },
+    { { 76, 33, 119, 0 },
+      { 144, 199, 23, 0 },
+      { 119, 66, 25, 0 },
+      { 116, 113, 132, 1 }, },
+    { { 76, 32, 152, 0 },
+      { 144, 1, 38, 1 },
+      { 12, 130, 25, 0 },
+      { 178, 64, 4, 1 }, },
+    { { 76, 32, 155, 1 },
+      { 152, 67, 38, 1 },
+      { 236, 130, 25, 0 },
+      { 178, 97, 12, 1 }, },
+    { { 76, 32, 148, 1 },
+      { 152, 1, 54, 0 },
+      { 148, 130, 25, 0 },
+      { 54, 64, 12, 1 }, },
+    { { 76, 32, 151, 0 },
+      { 144, 67, 54, 0 },
+      { 116, 130, 25, 0 },
+      { 54, 97, 4, 1 }, },
+    { { 76, 32, 232, 0 },
+      { 128, 133, 38, 1 },
+      { 11, 130, 25, 0 },
+      { 178, 80, 128, 1 }, },
+    { { 76, 32, 235, 1 },
+      { 136, 199, 38, 1 },
+      { 235, 130, 25, 0 },
+      { 178, 113, 136, 1 }, },
+    { { 76, 32, 228, 1 },
+      { 136, 133, 54, 0 },
+      { 147, 130, 25, 0 },
+      { 54, 80, 136, 1 }, },
+    { { 76, 32, 231, 0 },
+      { 128, 199, 54, 0 },
+      { 115, 130, 25, 0 },
+      { 54, 113, 128, 1 }, },
+    { { 76, 47, 8, 0 },
+      { 161, 9, 7, 1 },
+      { 8, 122, 25, 0 },
+      { 240, 72, 66, 1 }, },
+    { { 76, 47, 11, 1 },
+      { 169, 75, 7, 1 },
+      { 232, 122, 25, 0 },
+      { 240, 105, 74, 1 }, },
+    { { 76, 47, 4, 1 },
+      { 169, 9, 23, 0 },
+      { 144, 122, 25, 0 },
+      { 116, 72, 74, 1 }, },
+    { { 76, 47, 7, 0 },
+      { 161, 75, 23, 0 },
+      { 112, 122, 25, 0 },
+      { 116, 105, 66, 1 }, },
+    { { 76, 47, 120, 0 },
+      { 177, 141, 7, 1 },
+      { 15, 122, 25, 0 },
+      { 240, 88, 198, 1 }, },
+    { { 76, 47, 123, 1 },
+      { 185, 207, 7, 1 },
+      { 239, 122, 25, 0 },
+      { 240, 121, 206, 1 }, },
+    { { 76, 47, 116, 1 },
+      { 185, 141, 23, 0 },
+      { 151, 122, 25, 0 },
+      { 116, 88, 206, 1 }, },
+    { { 76, 47, 119, 0 },
+      { 177, 207, 23, 0 },
+      { 119, 122, 25, 0 },
+      { 116, 121, 198, 1 }, },
+    { { 76, 46, 152, 0 },
+      { 177, 9, 38, 1 },
+      { 12, 186, 25, 0 },
+      { 178, 72, 70, 1 }, },
+    { { 76, 46, 155, 1 },
+      { 185, 75, 38, 1 },
+      { 236, 186, 25, 0 },
+      { 178, 105, 78, 1 }, },
+    { { 76, 46, 148, 1 },
+      { 185, 9, 54, 0 },
+      { 148, 186, 25, 0 },
+      { 54, 72, 78, 1 }, },
+    { { 76, 46, 151, 0 },
+      { 177, 75, 54, 0 },
+      { 116, 186, 25, 0 },
+      { 54, 105, 70, 1 }, },
+    { { 76, 46, 232, 0 },
+      { 161, 141, 38, 1 },
+      { 11, 186, 25, 0 },
+      { 178, 88, 194, 1 }, },
+    { { 76, 46, 235, 1 },
+      { 169, 207, 38, 1 },
+      { 235, 186, 25, 0 },
+      { 178, 121, 202, 1 }, },
+    { { 76, 46, 228, 1 },
+      { 169, 141, 54, 0 },
+      { 147, 186, 25, 0 },
+      { 54, 88, 202, 1 }, },
+    { { 76, 46, 231, 0 },
+      { 161, 207, 54, 0 },
+      { 115, 186, 25, 0 },
+      { 54, 121, 194, 1 }, },
+    { { 76, 19, 8, 0 },
+      { 160, 1, 69, 1 },
+      { 8, 100, 25, 0 },
+      { 209, 64, 2, 1 }, },
+    { { 76, 19, 11, 1 },
+      { 168, 67, 69, 1 },
+      { 232, 100, 25, 0 },
+      { 209, 97, 10, 1 }, },
+    { { 76, 19, 4, 1 },
+      { 168, 1, 85, 0 },
+      { 144, 100, 25, 0 },
+      { 85, 64, 10, 1 }, },
+    { { 76, 19, 7, 0 },
+      { 160, 67, 85, 0 },
+      { 112, 100, 25, 0 },
+      { 85, 97, 2, 1 }, },
+    { { 76, 19, 120, 0 },
+      { 176, 133, 69, 1 },
+      { 15, 100, 25, 0 },
+      { 209, 80, 134, 1 }, },
+    { { 76, 19, 123, 1 },
+      { 184, 199, 69, 1 },
+      { 239, 100, 25, 0 },
+      { 209, 113, 142, 1 }, },
+    { { 76, 19, 116, 1 },
+      { 184, 133, 85, 0 },
+      { 151, 100, 25, 0 },
+      { 85, 80, 142, 1 }, },
+    { { 76, 19, 119, 0 },
+      { 176, 199, 85, 0 },
+      { 119, 100, 25, 0 },
+      { 85, 113, 134, 1 }, },
+    { { 76, 18, 152, 0 },
+      { 176, 1, 100, 1 },
+      { 12, 164, 25, 0 },
+      { 147, 64, 6, 1 }, },
+    { { 76, 18, 155, 1 },
+      { 184, 67, 100, 1 },
+      { 236, 164, 25, 0 },
+      { 147, 97, 14, 1 }, },
+    { { 76, 18, 148, 1 },
+      { 184, 1, 116, 0 },
+      { 148, 164, 25, 0 },
+      { 23, 64, 14, 1 }, },
+    { { 76, 18, 151, 0 },
+      { 176, 67, 116, 0 },
+      { 116, 164, 25, 0 },
+      { 23, 97, 6, 1 }, },
+    { { 76, 18, 232, 0 },
+      { 160, 133, 100, 1 },
+      { 11, 164, 25, 0 },
+      { 147, 80, 130, 1 }, },
+    { { 76, 18, 235, 1 },
+      { 168, 199, 100, 1 },
+      { 235, 164, 25, 0 },
+      { 147, 113, 138, 1 }, },
+    { { 76, 18, 228, 1 },
+      { 168, 133, 116, 0 },
+      { 147, 164, 25, 0 },
+      { 23, 80, 138, 1 }, },
+    { { 76, 18, 231, 0 },
+      { 160, 199, 116, 0 },
+      { 115, 164, 25, 0 },
+      { 23, 113, 130, 1 }, },
+    { { 76, 29, 8, 0 },
+      { 129, 9, 69, 1 },
+      { 8, 92, 25, 0 },
+      { 209, 72, 64, 1 }, },
+    { { 76, 29, 11, 1 },
+      { 137, 75, 69, 1 },
+      { 232, 92, 25, 0 },
+      { 209, 105, 72, 1 }, },
+    { { 76, 29, 4, 1 },
+      { 137, 9, 85, 0 },
+      { 144, 92, 25, 0 },
+      { 85, 72, 72, 1 }, },
+    { { 76, 29, 7, 0 },
+      { 129, 75, 85, 0 },
+      { 112, 92, 25, 0 },
+      { 85, 105, 64, 1 }, },
+    { { 76, 29, 120, 0 },
+      { 145, 141, 69, 1 },
+      { 15, 92, 25, 0 },
+      { 209, 88, 196, 1 }, },
+    { { 76, 29, 123, 1 },
+      { 153, 207, 69, 1 },
+      { 239, 92, 25, 0 },
+      { 209, 121, 204, 1 }, },
+    { { 76, 29, 116, 1 },
+      { 153, 141, 85, 0 },
+      { 151, 92, 25, 0 },
+      { 85, 88, 204, 1 }, },
+    { { 76, 29, 119, 0 },
+      { 145, 207, 85, 0 },
+      { 119, 92, 25, 0 },
+      { 85, 121, 196, 1 }, },
+    { { 76, 28, 152, 0 },
+      { 145, 9, 100, 1 },
+      { 12, 156, 25, 0 },
+      { 147, 72, 68, 1 }, },
+    { { 76, 28, 155, 1 },
+      { 153, 75, 100, 1 },
+      { 236, 156, 25, 0 },
+      { 147, 105, 76, 1 }, },
+    { { 76, 28, 148, 1 },
+      { 153, 9, 116, 0 },
+      { 148, 156, 25, 0 },
+      { 23, 72, 76, 1 }, },
+    { { 76, 28, 151, 0 },
+      { 145, 75, 116, 0 },
+      { 116, 156, 25, 0 },
+      { 23, 105, 68, 1 }, },
+    { { 76, 28, 232, 0 },
+      { 129, 141, 100, 1 },
+      { 11, 156, 25, 0 },
+      { 147, 88, 192, 1 }, },
+    { { 76, 28, 235, 1 },
+      { 137, 207, 100, 1 },
+      { 235, 156, 25, 0 },
+      { 147, 121, 200, 1 }, },
+    { { 76, 28, 228, 1 },
+      { 137, 141, 116, 0 },
+      { 147, 156, 25, 0 },
+      { 23, 88, 200, 1 }, },
+    { { 76, 28, 231, 0 },
+      { 129, 207, 116, 0 },
+      { 115, 156, 25, 0 },
+      { 23, 121, 192, 1 }, },
+    { { 77, 225, 8, 0 },
+      { 194, 17, 7, 1 },
+      { 8, 67, 217, 0 },
+      { 240, 68, 33, 1 }, },
+    { { 77, 225, 11, 1 },
+      { 202, 83, 7, 1 },
+      { 232, 67, 217, 0 },
+      { 240, 101, 41, 1 }, },
+    { { 77, 225, 4, 1 },
+      { 202, 17, 23, 0 },
+      { 144, 67, 217, 0 },
+      { 116, 68, 41, 1 }, },
+    { { 77, 225, 7, 0 },
+      { 194, 83, 23, 0 },
+      { 112, 67, 217, 0 },
+      { 116, 101, 33, 1 }, },
+    { { 77, 225, 120, 0 },
+      { 210, 149, 7, 1 },
+      { 15, 67, 217, 0 },
+      { 240, 84, 165, 1 }, },
+    { { 77, 225, 123, 1 },
+      { 218, 215, 7, 1 },
+      { 239, 67, 217, 0 },
+      { 240, 117, 173, 1 }, },
+    { { 77, 225, 116, 1 },
+      { 218, 149, 23, 0 },
+      { 151, 67, 217, 0 },
+      { 116, 84, 173, 1 }, },
+    { { 77, 225, 119, 0 },
+      { 210, 215, 23, 0 },
+      { 119, 67, 217, 0 },
+      { 116, 117, 165, 1 }, },
+    { { 77, 224, 152, 0 },
+      { 210, 17, 38, 1 },
+      { 12, 131, 217, 0 },
+      { 178, 68, 37, 1 }, },
+    { { 77, 224, 155, 1 },
+      { 218, 83, 38, 1 },
+      { 236, 131, 217, 0 },
+      { 178, 101, 45, 1 }, },
+    { { 77, 224, 148, 1 },
+      { 218, 17, 54, 0 },
+      { 148, 131, 217, 0 },
+      { 54, 68, 45, 1 }, },
+    { { 77, 224, 151, 0 },
+      { 210, 83, 54, 0 },
+      { 116, 131, 217, 0 },
+      { 54, 101, 37, 1 }, },
+    { { 77, 224, 232, 0 },
+      { 194, 149, 38, 1 },
+      { 11, 131, 217, 0 },
+      { 178, 84, 161, 1 }, },
+    { { 77, 224, 235, 1 },
+      { 202, 215, 38, 1 },
+      { 235, 131, 217, 0 },
+      { 178, 117, 169, 1 }, },
+    { { 77, 224, 228, 1 },
+      { 202, 149, 54, 0 },
+      { 147, 131, 217, 0 },
+      { 54, 84, 169, 1 }, },
+    { { 77, 224, 231, 0 },
+      { 194, 215, 54, 0 },
+      { 115, 131, 217, 0 },
+      { 54, 117, 161, 1 }, },
+    { { 77, 239, 8, 0 },
+      { 227, 25, 7, 1 },
+      { 8, 123, 217, 0 },
+      { 240, 76, 99, 1 }, },
+    { { 77, 239, 11, 1 },
+      { 235, 91, 7, 1 },
+      { 232, 123, 217, 0 },
+      { 240, 109, 107, 1 }, },
+    { { 77, 239, 4, 1 },
+      { 235, 25, 23, 0 },
+      { 144, 123, 217, 0 },
+      { 116, 76, 107, 1 }, },
+    { { 77, 239, 7, 0 },
+      { 227, 91, 23, 0 },
+      { 112, 123, 217, 0 },
+      { 116, 109, 99, 1 }, },
+    { { 77, 239, 120, 0 },
+      { 243, 157, 7, 1 },
+      { 15, 123, 217, 0 },
+      { 240, 92, 231, 1 }, },
+    { { 77, 239, 123, 1 },
+      { 251, 223, 7, 1 },
+      { 239, 123, 217, 0 },
+      { 240, 125, 239, 1 }, },
+    { { 77, 239, 116, 1 },
+      { 251, 157, 23, 0 },
+      { 151, 123, 217, 0 },
+      { 116, 92, 239, 1 }, },
+    { { 77, 239, 119, 0 },
+      { 243, 223, 23, 0 },
+      { 119, 123, 217, 0 },
+      { 116, 125, 231, 1 }, },
+    { { 77, 238, 152, 0 },
+      { 243, 25, 38, 1 },
+      { 12, 187, 217, 0 },
+      { 178, 76, 103, 1 }, },
+    { { 77, 238, 155, 1 },
+      { 251, 91, 38, 1 },
+      { 236, 187, 217, 0 },
+      { 178, 109, 111, 1 }, },
+    { { 77, 238, 148, 1 },
+      { 251, 25, 54, 0 },
+      { 148, 187, 217, 0 },
+      { 54, 76, 111, 1 }, },
+    { { 77, 238, 151, 0 },
+      { 243, 91, 54, 0 },
+      { 116, 187, 217, 0 },
+      { 54, 109, 103, 1 }, },
+    { { 77, 238, 232, 0 },
+      { 227, 157, 38, 1 },
+      { 11, 187, 217, 0 },
+      { 178, 92, 227, 1 }, },
+    { { 77, 238, 235, 1 },
+      { 235, 223, 38, 1 },
+      { 235, 187, 217, 0 },
+      { 178, 125, 235, 1 }, },
+    { { 77, 238, 228, 1 },
+      { 235, 157, 54, 0 },
+      { 147, 187, 217, 0 },
+      { 54, 92, 235, 1 }, },
+    { { 77, 238, 231, 0 },
+      { 227, 223, 54, 0 },
+      { 115, 187, 217, 0 },
+      { 54, 125, 227, 1 }, },
+    { { 77, 211, 8, 0 },
+      { 226, 17, 69, 1 },
+      { 8, 101, 217, 0 },
+      { 209, 68, 35, 1 }, },
+    { { 77, 211, 11, 1 },
+      { 234, 83, 69, 1 },
+      { 232, 101, 217, 0 },
+      { 209, 101, 43, 1 }, },
+    { { 77, 211, 4, 1 },
+      { 234, 17, 85, 0 },
+      { 144, 101, 217, 0 },
+      { 85, 68, 43, 1 }, },
+    { { 77, 211, 7, 0 },
+      { 226, 83, 85, 0 },
+      { 112, 101, 217, 0 },
+      { 85, 101, 35, 1 }, },
+    { { 77, 211, 120, 0 },
+      { 242, 149, 69, 1 },
+      { 15, 101, 217, 0 },
+      { 209, 84, 167, 1 }, },
+    { { 77, 211, 123, 1 },
+      { 250, 215, 69, 1 },
+      { 239, 101, 217, 0 },
+      { 209, 117, 175, 1 }, },
+    { { 77, 211, 116, 1 },
+      { 250, 149, 85, 0 },
+      { 151, 101, 217, 0 },
+      { 85, 84, 175, 1 }, },
+    { { 77, 211, 119, 0 },
+      { 242, 215, 85, 0 },
+      { 119, 101, 217, 0 },
+      { 85, 117, 167, 1 }, },
+    { { 77, 210, 152, 0 },
+      { 242, 17, 100, 1 },
+      { 12, 165, 217, 0 },
+      { 147, 68, 39, 1 }, },
+    { { 77, 210, 155, 1 },
+      { 250, 83, 100, 1 },
+      { 236, 165, 217, 0 },
+      { 147, 101, 47, 1 }, },
+    { { 77, 210, 148, 1 },
+      { 250, 17, 116, 0 },
+      { 148, 165, 217, 0 },
+      { 23, 68, 47, 1 }, },
+    { { 77, 210, 151, 0 },
+      { 242, 83, 116, 0 },
+      { 116, 165, 217, 0 },
+      { 23, 101, 39, 1 }, },
+    { { 77, 210, 232, 0 },
+      { 226, 149, 100, 1 },
+      { 11, 165, 217, 0 },
+      { 147, 84, 163, 1 }, },
+    { { 77, 210, 235, 1 },
+      { 234, 215, 100, 1 },
+      { 235, 165, 217, 0 },
+      { 147, 117, 171, 1 }, },
+    { { 77, 210, 228, 1 },
+      { 234, 149, 116, 0 },
+      { 147, 165, 217, 0 },
+      { 23, 84, 171, 1 }, },
+    { { 77, 210, 231, 0 },
+      { 226, 215, 116, 0 },
+      { 115, 165, 217, 0 },
+      { 23, 117, 163, 1 }, },
+    { { 77, 221, 8, 0 },
+      { 195, 25, 69, 1 },
+      { 8, 93, 217, 0 },
+      { 209, 76, 97, 1 }, },
+    { { 77, 221, 11, 1 },
+      { 203, 91, 69, 1 },
+      { 232, 93, 217, 0 },
+      { 209, 109, 105, 1 }, },
+    { { 77, 221, 4, 1 },
+      { 203, 25, 85, 0 },
+      { 144, 93, 217, 0 },
+      { 85, 76, 105, 1 }, },
+    { { 77, 221, 7, 0 },
+      { 195, 91, 85, 0 },
+      { 112, 93, 217, 0 },
+      { 85, 109, 97, 1 }, },
+    { { 77, 221, 120, 0 },
+      { 211, 157, 69, 1 },
+      { 15, 93, 217, 0 },
+      { 209, 92, 229, 1 }, },
+    { { 77, 221, 123, 1 },
+      { 219, 223, 69, 1 },
+      { 239, 93, 217, 0 },
+      { 209, 125, 237, 1 }, },
+    { { 77, 221, 116, 1 },
+      { 219, 157, 85, 0 },
+      { 151, 93, 217, 0 },
+      { 85, 92, 237, 1 }, },
+    { { 77, 221, 119, 0 },
+      { 211, 223, 85, 0 },
+      { 119, 93, 217, 0 },
+      { 85, 125, 229, 1 }, },
+    { { 77, 220, 152, 0 },
+      { 211, 25, 100, 1 },
+      { 12, 157, 217, 0 },
+      { 147, 76, 101, 1 }, },
+    { { 77, 220, 155, 1 },
+      { 219, 91, 100, 1 },
+      { 236, 157, 217, 0 },
+      { 147, 109, 109, 1 }, },
+    { { 77, 220, 148, 1 },
+      { 219, 25, 116, 0 },
+      { 148, 157, 217, 0 },
+      { 23, 76, 109, 1 }, },
+    { { 77, 220, 151, 0 },
+      { 211, 91, 116, 0 },
+      { 116, 157, 217, 0 },
+      { 23, 109, 101, 1 }, },
+    { { 77, 220, 232, 0 },
+      { 195, 157, 100, 1 },
+      { 11, 157, 217, 0 },
+      { 147, 92, 225, 1 }, },
+    { { 77, 220, 235, 1 },
+      { 203, 223, 100, 1 },
+      { 235, 157, 217, 0 },
+      { 147, 125, 233, 1 }, },
+    { { 77, 220, 228, 1 },
+      { 203, 157, 116, 0 },
+      { 147, 157, 217, 0 },
+      { 23, 92, 233, 1 }, },
+    { { 77, 220, 231, 0 },
+      { 195, 223, 116, 0 },
+      { 115, 157, 217, 0 },
+      { 23, 125, 225, 1 }, },
+    { { 74, 97, 8, 0 },
+      { 192, 1, 131, 1 },
+      { 8, 67, 41, 0 },
+      { 224, 192, 1, 1 }, },
+    { { 74, 97, 11, 1 },
+      { 200, 67, 131, 1 },
+      { 232, 67, 41, 0 },
+      { 224, 225, 9, 1 }, },
+    { { 74, 97, 4, 1 },
+      { 200, 1, 147, 0 },
+      { 144, 67, 41, 0 },
+      { 100, 192, 9, 1 }, },
+    { { 74, 97, 7, 0 },
+      { 192, 67, 147, 0 },
+      { 112, 67, 41, 0 },
+      { 100, 225, 1, 1 }, },
+    { { 74, 97, 120, 0 },
+      { 208, 133, 131, 1 },
+      { 15, 67, 41, 0 },
+      { 224, 208, 133, 1 }, },
+    { { 74, 97, 123, 1 },
+      { 216, 199, 131, 1 },
+      { 239, 67, 41, 0 },
+      { 224, 241, 141, 1 }, },
+    { { 74, 97, 116, 1 },
+      { 216, 133, 147, 0 },
+      { 151, 67, 41, 0 },
+      { 100, 208, 141, 1 }, },
+    { { 74, 97, 119, 0 },
+      { 208, 199, 147, 0 },
+      { 119, 67, 41, 0 },
+      { 100, 241, 133, 1 }, },
+    { { 74, 96, 152, 0 },
+      { 208, 1, 162, 1 },
+      { 12, 131, 41, 0 },
+      { 162, 192, 5, 1 }, },
+    { { 74, 96, 155, 1 },
+      { 216, 67, 162, 1 },
+      { 236, 131, 41, 0 },
+      { 162, 225, 13, 1 }, },
+    { { 74, 96, 148, 1 },
+      { 216, 1, 178, 0 },
+      { 148, 131, 41, 0 },
+      { 38, 192, 13, 1 }, },
+    { { 74, 96, 151, 0 },
+      { 208, 67, 178, 0 },
+      { 116, 131, 41, 0 },
+      { 38, 225, 5, 1 }, },
+    { { 74, 96, 232, 0 },
+      { 192, 133, 162, 1 },
+      { 11, 131, 41, 0 },
+      { 162, 208, 129, 1 }, },
+    { { 74, 96, 235, 1 },
+      { 200, 199, 162, 1 },
+      { 235, 131, 41, 0 },
+      { 162, 241, 137, 1 }, },
+    { { 74, 96, 228, 1 },
+      { 200, 133, 178, 0 },
+      { 147, 131, 41, 0 },
+      { 38, 208, 137, 1 }, },
+    { { 74, 96, 231, 0 },
+      { 192, 199, 178, 0 },
+      { 115, 131, 41, 0 },
+      { 38, 241, 129, 1 }, },
+    { { 74, 111, 8, 0 },
+      { 225, 9, 131, 1 },
+      { 8, 123, 41, 0 },
+      { 224, 200, 67, 1 }, },
+    { { 74, 111, 11, 1 },
+      { 233, 75, 131, 1 },
+      { 232, 123, 41, 0 },
+      { 224, 233, 75, 1 }, },
+    { { 74, 111, 4, 1 },
+      { 233, 9, 147, 0 },
+      { 144, 123, 41, 0 },
+      { 100, 200, 75, 1 }, },
+    { { 74, 111, 7, 0 },
+      { 225, 75, 147, 0 },
+      { 112, 123, 41, 0 },
+      { 100, 233, 67, 1 }, },
+    { { 74, 111, 120, 0 },
+      { 241, 141, 131, 1 },
+      { 15, 123, 41, 0 },
+      { 224, 216, 199, 1 }, },
+    { { 74, 111, 123, 1 },
+      { 249, 207, 131, 1 },
+      { 239, 123, 41, 0 },
+      { 224, 249, 207, 1 }, },
+    { { 74, 111, 116, 1 },
+      { 249, 141, 147, 0 },
+      { 151, 123, 41, 0 },
+      { 100, 216, 207, 1 }, },
+    { { 74, 111, 119, 0 },
+      { 241, 207, 147, 0 },
+      { 119, 123, 41, 0 },
+      { 100, 249, 199, 1 }, },
+    { { 74, 110, 152, 0 },
+      { 241, 9, 162, 1 },
+      { 12, 187, 41, 0 },
+      { 162, 200, 71, 1 }, },
+    { { 74, 110, 155, 1 },
+      { 249, 75, 162, 1 },
+      { 236, 187, 41, 0 },
+      { 162, 233, 79, 1 }, },
+    { { 74, 110, 148, 1 },
+      { 249, 9, 178, 0 },
+      { 148, 187, 41, 0 },
+      { 38, 200, 79, 1 }, },
+    { { 74, 110, 151, 0 },
+      { 241, 75, 178, 0 },
+      { 116, 187, 41, 0 },
+      { 38, 233, 71, 1 }, },
+    { { 74, 110, 232, 0 },
+      { 225, 141, 162, 1 },
+      { 11, 187, 41, 0 },
+      { 162, 216, 195, 1 }, },
+    { { 74, 110, 235, 1 },
+      { 233, 207, 162, 1 },
+      { 235, 187, 41, 0 },
+      { 162, 249, 203, 1 }, },
+    { { 74, 110, 228, 1 },
+      { 233, 141, 178, 0 },
+      { 147, 187, 41, 0 },
+      { 38, 216, 203, 1 }, },
+    { { 74, 110, 231, 0 },
+      { 225, 207, 178, 0 },
+      { 115, 187, 41, 0 },
+      { 38, 249, 195, 1 }, },
+    { { 74, 83, 8, 0 },
+      { 224, 1, 193, 1 },
+      { 8, 101, 41, 0 },
+      { 193, 192, 3, 1 }, },
+    { { 74, 83, 11, 1 },
+      { 232, 67, 193, 1 },
+      { 232, 101, 41, 0 },
+      { 193, 225, 11, 1 }, },
+    { { 74, 83, 4, 1 },
+      { 232, 1, 209, 0 },
+      { 144, 101, 41, 0 },
+      { 69, 192, 11, 1 }, },
+    { { 74, 83, 7, 0 },
+      { 224, 67, 209, 0 },
+      { 112, 101, 41, 0 },
+      { 69, 225, 3, 1 }, },
+    { { 74, 83, 120, 0 },
+      { 240, 133, 193, 1 },
+      { 15, 101, 41, 0 },
+      { 193, 208, 135, 1 }, },
+    { { 74, 83, 123, 1 },
+      { 248, 199, 193, 1 },
+      { 239, 101, 41, 0 },
+      { 193, 241, 143, 1 }, },
+    { { 74, 83, 116, 1 },
+      { 248, 133, 209, 0 },
+      { 151, 101, 41, 0 },
+      { 69, 208, 143, 1 }, },
+    { { 74, 83, 119, 0 },
+      { 240, 199, 209, 0 },
+      { 119, 101, 41, 0 },
+      { 69, 241, 135, 1 }, },
+    { { 74, 82, 152, 0 },
+      { 240, 1, 224, 1 },
+      { 12, 165, 41, 0 },
+      { 131, 192, 7, 1 }, },
+    { { 74, 82, 155, 1 },
+      { 248, 67, 224, 1 },
+      { 236, 165, 41, 0 },
+      { 131, 225, 15, 1 }, },
+    { { 74, 82, 148, 1 },
+      { 248, 1, 240, 0 },
+      { 148, 165, 41, 0 },
+      { 7, 192, 15, 1 }, },
+    { { 74, 82, 151, 0 },
+      { 240, 67, 240, 0 },
+      { 116, 165, 41, 0 },
+      { 7, 225, 7, 1 }, },
+    { { 74, 82, 232, 0 },
+      { 224, 133, 224, 1 },
+      { 11, 165, 41, 0 },
+      { 131, 208, 131, 1 }, },
+    { { 74, 82, 235, 1 },
+      { 232, 199, 224, 1 },
+      { 235, 165, 41, 0 },
+      { 131, 241, 139, 1 }, },
+    { { 74, 82, 228, 1 },
+      { 232, 133, 240, 0 },
+      { 147, 165, 41, 0 },
+      { 7, 208, 139, 1 }, },
+    { { 74, 82, 231, 0 },
+      { 224, 199, 240, 0 },
+      { 115, 165, 41, 0 },
+      { 7, 241, 131, 1 }, },
+    { { 74, 93, 8, 0 },
+      { 193, 9, 193, 1 },
+      { 8, 93, 41, 0 },
+      { 193, 200, 65, 1 }, },
+    { { 74, 93, 11, 1 },
+      { 201, 75, 193, 1 },
+      { 232, 93, 41, 0 },
+      { 193, 233, 73, 1 }, },
+    { { 74, 93, 4, 1 },
+      { 201, 9, 209, 0 },
+      { 144, 93, 41, 0 },
+      { 69, 200, 73, 1 }, },
+    { { 74, 93, 7, 0 },
+      { 193, 75, 209, 0 },
+      { 112, 93, 41, 0 },
+      { 69, 233, 65, 1 }, },
+    { { 74, 93, 120, 0 },
+      { 209, 141, 193, 1 },
+      { 15, 93, 41, 0 },
+      { 193, 216, 197, 1 }, },
+    { { 74, 93, 123, 1 },
+      { 217, 207, 193, 1 },
+      { 239, 93, 41, 0 },
+      { 193, 249, 205, 1 }, },
+    { { 74, 93, 116, 1 },
+      { 217, 141, 209, 0 },
+      { 151, 93, 41, 0 },
+      { 69, 216, 205, 1 }, },
+    { { 74, 93, 119, 0 },
+      { 209, 207, 209, 0 },
+      { 119, 93, 41, 0 },
+      { 69, 249, 197, 1 }, },
+    { { 74, 92, 152, 0 },
+      { 209, 9, 224, 1 },
+      { 12, 157, 41, 0 },
+      { 131, 200, 69, 1 }, },
+    { { 74, 92, 155, 1 },
+      { 217, 75, 224, 1 },
+      { 236, 157, 41, 0 },
+      { 131, 233, 77, 1 }, },
+    { { 74, 92, 148, 1 },
+      { 217, 9, 240, 0 },
+      { 148, 157, 41, 0 },
+      { 7, 200, 77, 1 }, },
+    { { 74, 92, 151, 0 },
+      { 209, 75, 240, 0 },
+      { 116, 157, 41, 0 },
+      { 7, 233, 69, 1 }, },
+    { { 74, 92, 232, 0 },
+      { 193, 141, 224, 1 },
+      { 11, 157, 41, 0 },
+      { 131, 216, 193, 1 }, },
+    { { 74, 92, 235, 1 },
+      { 201, 207, 224, 1 },
+      { 235, 157, 41, 0 },
+      { 131, 249, 201, 1 }, },
+    { { 74, 92, 228, 1 },
+      { 201, 141, 240, 0 },
+      { 147, 157, 41, 0 },
+      { 7, 216, 201, 1 }, },
+    { { 74, 92, 231, 0 },
+      { 193, 207, 240, 0 },
+      { 115, 157, 41, 0 },
+      { 7, 249, 193, 1 }, },
+    { { 75, 161, 8, 0 },
+      { 130, 17, 131, 1 },
+      { 8, 66, 233, 0 },
+      { 224, 196, 32, 1 }, },
+    { { 75, 161, 11, 1 },
+      { 138, 83, 131, 1 },
+      { 232, 66, 233, 0 },
+      { 224, 229, 40, 1 }, },
+    { { 75, 161, 4, 1 },
+      { 138, 17, 147, 0 },
+      { 144, 66, 233, 0 },
+      { 100, 196, 40, 1 }, },
+    { { 75, 161, 7, 0 },
+      { 130, 83, 147, 0 },
+      { 112, 66, 233, 0 },
+      { 100, 229, 32, 1 }, },
+    { { 75, 161, 120, 0 },
+      { 146, 149, 131, 1 },
+      { 15, 66, 233, 0 },
+      { 224, 212, 164, 1 }, },
+    { { 75, 161, 123, 1 },
+      { 154, 215, 131, 1 },
+      { 239, 66, 233, 0 },
+      { 224, 245, 172, 1 }, },
+    { { 75, 161, 116, 1 },
+      { 154, 149, 147, 0 },
+      { 151, 66, 233, 0 },
+      { 100, 212, 172, 1 }, },
+    { { 75, 161, 119, 0 },
+      { 146, 215, 147, 0 },
+      { 119, 66, 233, 0 },
+      { 100, 245, 164, 1 }, },
+    { { 75, 160, 152, 0 },
+      { 146, 17, 162, 1 },
+      { 12, 130, 233, 0 },
+      { 162, 196, 36, 1 }, },
+    { { 75, 160, 155, 1 },
+      { 154, 83, 162, 1 },
+      { 236, 130, 233, 0 },
+      { 162, 229, 44, 1 }, },
+    { { 75, 160, 148, 1 },
+      { 154, 17, 178, 0 },
+      { 148, 130, 233, 0 },
+      { 38, 196, 44, 1 }, },
+    { { 75, 160, 151, 0 },
+      { 146, 83, 178, 0 },
+      { 116, 130, 233, 0 },
+      { 38, 229, 36, 1 }, },
+    { { 75, 160, 232, 0 },
+      { 130, 149, 162, 1 },
+      { 11, 130, 233, 0 },
+      { 162, 212, 160, 1 }, },
+    { { 75, 160, 235, 1 },
+      { 138, 215, 162, 1 },
+      { 235, 130, 233, 0 },
+      { 162, 245, 168, 1 }, },
+    { { 75, 160, 228, 1 },
+      { 138, 149, 178, 0 },
+      { 147, 130, 233, 0 },
+      { 38, 212, 168, 1 }, },
+    { { 75, 160, 231, 0 },
+      { 130, 215, 178, 0 },
+      { 115, 130, 233, 0 },
+      { 38, 245, 160, 1 }, },
+    { { 75, 175, 8, 0 },
+      { 163, 25, 131, 1 },
+      { 8, 122, 233, 0 },
+      { 224, 204, 98, 1 }, },
+    { { 75, 175, 11, 1 },
+      { 171, 91, 131, 1 },
+      { 232, 122, 233, 0 },
+      { 224, 237, 106, 1 }, },
+    { { 75, 175, 4, 1 },
+      { 171, 25, 147, 0 },
+      { 144, 122, 233, 0 },
+      { 100, 204, 106, 1 }, },
+    { { 75, 175, 7, 0 },
+      { 163, 91, 147, 0 },
+      { 112, 122, 233, 0 },
+      { 100, 237, 98, 1 }, },
+    { { 75, 175, 120, 0 },
+      { 179, 157, 131, 1 },
+      { 15, 122, 233, 0 },
+      { 224, 220, 230, 1 }, },
+    { { 75, 175, 123, 1 },
+      { 187, 223, 131, 1 },
+      { 239, 122, 233, 0 },
+      { 224, 253, 238, 1 }, },
+    { { 75, 175, 116, 1 },
+      { 187, 157, 147, 0 },
+      { 151, 122, 233, 0 },
+      { 100, 220, 238, 1 }, },
+    { { 75, 175, 119, 0 },
+      { 179, 223, 147, 0 },
+      { 119, 122, 233, 0 },
+      { 100, 253, 230, 1 }, },
+    { { 75, 174, 152, 0 },
+      { 179, 25, 162, 1 },
+      { 12, 186, 233, 0 },
+      { 162, 204, 102, 1 }, },
+    { { 75, 174, 155, 1 },
+      { 187, 91, 162, 1 },
+      { 236, 186, 233, 0 },
+      { 162, 237, 110, 1 }, },
+    { { 75, 174, 148, 1 },
+      { 187, 25, 178, 0 },
+      { 148, 186, 233, 0 },
+      { 38, 204, 110, 1 }, },
+    { { 75, 174, 151, 0 },
+      { 179, 91, 178, 0 },
+      { 116, 186, 233, 0 },
+      { 38, 237, 102, 1 }, },
+    { { 75, 174, 232, 0 },
+      { 163, 157, 162, 1 },
+      { 11, 186, 233, 0 },
+      { 162, 220, 226, 1 }, },
+    { { 75, 174, 235, 1 },
+      { 171, 223, 162, 1 },
+      { 235, 186, 233, 0 },
+      { 162, 253, 234, 1 }, },
+    { { 75, 174, 228, 1 },
+      { 171, 157, 178, 0 },
+      { 147, 186, 233, 0 },
+      { 38, 220, 234, 1 }, },
+    { { 75, 174, 231, 0 },
+      { 163, 223, 178, 0 },
+      { 115, 186, 233, 0 },
+      { 38, 253, 226, 1 }, },
+    { { 75, 147, 8, 0 },
+      { 162, 17, 193, 1 },
+      { 8, 100, 233, 0 },
+      { 193, 196, 34, 1 }, },
+    { { 75, 147, 11, 1 },
+      { 170, 83, 193, 1 },
+      { 232, 100, 233, 0 },
+      { 193, 229, 42, 1 }, },
+    { { 75, 147, 4, 1 },
+      { 170, 17, 209, 0 },
+      { 144, 100, 233, 0 },
+      { 69, 196, 42, 1 }, },
+    { { 75, 147, 7, 0 },
+      { 162, 83, 209, 0 },
+      { 112, 100, 233, 0 },
+      { 69, 229, 34, 1 }, },
+    { { 75, 147, 120, 0 },
+      { 178, 149, 193, 1 },
+      { 15, 100, 233, 0 },
+      { 193, 212, 166, 1 }, },
+    { { 75, 147, 123, 1 },
+      { 186, 215, 193, 1 },
+      { 239, 100, 233, 0 },
+      { 193, 245, 174, 1 }, },
+    { { 75, 147, 116, 1 },
+      { 186, 149, 209, 0 },
+      { 151, 100, 233, 0 },
+      { 69, 212, 174, 1 }, },
+    { { 75, 147, 119, 0 },
+      { 178, 215, 209, 0 },
+      { 119, 100, 233, 0 },
+      { 69, 245, 166, 1 }, },
+    { { 75, 146, 152, 0 },
+      { 178, 17, 224, 1 },
+      { 12, 164, 233, 0 },
+      { 131, 196, 38, 1 }, },
+    { { 75, 146, 155, 1 },
+      { 186, 83, 224, 1 },
+      { 236, 164, 233, 0 },
+      { 131, 229, 46, 1 }, },
+    { { 75, 146, 148, 1 },
+      { 186, 17, 240, 0 },
+      { 148, 164, 233, 0 },
+      { 7, 196, 46, 1 }, },
+    { { 75, 146, 151, 0 },
+      { 178, 83, 240, 0 },
+      { 116, 164, 233, 0 },
+      { 7, 229, 38, 1 }, },
+    { { 75, 146, 232, 0 },
+      { 162, 149, 224, 1 },
+      { 11, 164, 233, 0 },
+      { 131, 212, 162, 1 }, },
+    { { 75, 146, 235, 1 },
+      { 170, 215, 224, 1 },
+      { 235, 164, 233, 0 },
+      { 131, 245, 170, 1 }, },
+    { { 75, 146, 228, 1 },
+      { 170, 149, 240, 0 },
+      { 147, 164, 233, 0 },
+      { 7, 212, 170, 1 }, },
+    { { 75, 146, 231, 0 },
+      { 162, 215, 240, 0 },
+      { 115, 164, 233, 0 },
+      { 7, 245, 162, 1 }, },
+    { { 75, 157, 8, 0 },
+      { 131, 25, 193, 1 },
+      { 8, 92, 233, 0 },
+      { 193, 204, 96, 1 }, },
+    { { 75, 157, 11, 1 },
+      { 139, 91, 193, 1 },
+      { 232, 92, 233, 0 },
+      { 193, 237, 104, 1 }, },
+    { { 75, 157, 4, 1 },
+      { 139, 25, 209, 0 },
+      { 144, 92, 233, 0 },
+      { 69, 204, 104, 1 }, },
+    { { 75, 157, 7, 0 },
+      { 131, 91, 209, 0 },
+      { 112, 92, 233, 0 },
+      { 69, 237, 96, 1 }, },
+    { { 75, 157, 120, 0 },
+      { 147, 157, 193, 1 },
+      { 15, 92, 233, 0 },
+      { 193, 220, 228, 1 }, },
+    { { 75, 157, 123, 1 },
+      { 155, 223, 193, 1 },
+      { 239, 92, 233, 0 },
+      { 193, 253, 236, 1 }, },
+    { { 75, 157, 116, 1 },
+      { 155, 157, 209, 0 },
+      { 151, 92, 233, 0 },
+      { 69, 220, 236, 1 }, },
+    { { 75, 157, 119, 0 },
+      { 147, 223, 209, 0 },
+      { 119, 92, 233, 0 },
+      { 69, 253, 228, 1 }, },
+    { { 75, 156, 152, 0 },
+      { 147, 25, 224, 1 },
+      { 12, 156, 233, 0 },
+      { 131, 204, 100, 1 }, },
+    { { 75, 156, 155, 1 },
+      { 155, 91, 224, 1 },
+      { 236, 156, 233, 0 },
+      { 131, 237, 108, 1 }, },
+    { { 75, 156, 148, 1 },
+      { 155, 25, 240, 0 },
+      { 148, 156, 233, 0 },
+      { 7, 204, 108, 1 }, },
+    { { 75, 156, 151, 0 },
+      { 147, 91, 240, 0 },
+      { 116, 156, 233, 0 },
+      { 7, 237, 100, 1 }, },
+    { { 75, 156, 232, 0 },
+      { 131, 157, 224, 1 },
+      { 11, 156, 233, 0 },
+      { 131, 220, 224, 1 }, },
+    { { 75, 156, 235, 1 },
+      { 139, 223, 224, 1 },
+      { 235, 156, 233, 0 },
+      { 131, 253, 232, 1 }, },
+    { { 75, 156, 228, 1 },
+      { 139, 157, 240, 0 },
+      { 147, 156, 233, 0 },
+      { 7, 220, 232, 1 }, },
+    { { 75, 156, 231, 0 },
+      { 131, 223, 240, 0 },
+      { 115, 156, 233, 0 },
+      { 7, 253, 224, 1 }, },
+    { { 116, 33, 8, 0 },
+      { 4, 33, 7, 1 },
+      { 8, 66, 23, 0 },
+      { 240, 66, 16, 0 }, },
+    { { 116, 33, 11, 1 },
+      { 12, 99, 7, 1 },
+      { 232, 66, 23, 0 },
+      { 240, 99, 24, 0 }, },
+    { { 116, 33, 4, 1 },
+      { 12, 33, 23, 0 },
+      { 144, 66, 23, 0 },
+      { 116, 66, 24, 0 }, },
+    { { 116, 33, 7, 0 },
+      { 4, 99, 23, 0 },
+      { 112, 66, 23, 0 },
+      { 116, 99, 16, 0 }, },
+    { { 116, 33, 120, 0 },
+      { 20, 165, 7, 1 },
+      { 15, 66, 23, 0 },
+      { 240, 82, 148, 0 }, },
+    { { 116, 33, 123, 1 },
+      { 28, 231, 7, 1 },
+      { 239, 66, 23, 0 },
+      { 240, 115, 156, 0 }, },
+    { { 116, 33, 116, 1 },
+      { 28, 165, 23, 0 },
+      { 151, 66, 23, 0 },
+      { 116, 82, 156, 0 }, },
+    { { 116, 33, 119, 0 },
+      { 20, 231, 23, 0 },
+      { 119, 66, 23, 0 },
+      { 116, 115, 148, 0 }, },
+    { { 116, 32, 152, 0 },
+      { 20, 33, 38, 1 },
+      { 12, 130, 23, 0 },
+      { 178, 66, 20, 0 }, },
+    { { 116, 32, 155, 1 },
+      { 28, 99, 38, 1 },
+      { 236, 130, 23, 0 },
+      { 178, 99, 28, 0 }, },
+    { { 116, 32, 148, 1 },
+      { 28, 33, 54, 0 },
+      { 148, 130, 23, 0 },
+      { 54, 66, 28, 0 }, },
+    { { 116, 32, 151, 0 },
+      { 20, 99, 54, 0 },
+      { 116, 130, 23, 0 },
+      { 54, 99, 20, 0 }, },
+    { { 116, 32, 232, 0 },
+      { 4, 165, 38, 1 },
+      { 11, 130, 23, 0 },
+      { 178, 82, 144, 0 }, },
+    { { 116, 32, 235, 1 },
+      { 12, 231, 38, 1 },
+      { 235, 130, 23, 0 },
+      { 178, 115, 152, 0 }, },
+    { { 116, 32, 228, 1 },
+      { 12, 165, 54, 0 },
+      { 147, 130, 23, 0 },
+      { 54, 82, 152, 0 }, },
+    { { 116, 32, 231, 0 },
+      { 4, 231, 54, 0 },
+      { 115, 130, 23, 0 },
+      { 54, 115, 144, 0 }, },
+    { { 116, 47, 8, 0 },
+      { 37, 41, 7, 1 },
+      { 8, 122, 23, 0 },
+      { 240, 74, 82, 0 }, },
+    { { 116, 47, 11, 1 },
+      { 45, 107, 7, 1 },
+      { 232, 122, 23, 0 },
+      { 240, 107, 90, 0 }, },
+    { { 116, 47, 4, 1 },
+      { 45, 41, 23, 0 },
+      { 144, 122, 23, 0 },
+      { 116, 74, 90, 0 }, },
+    { { 116, 47, 7, 0 },
+      { 37, 107, 23, 0 },
+      { 112, 122, 23, 0 },
+      { 116, 107, 82, 0 }, },
+    { { 116, 47, 120, 0 },
+      { 53, 173, 7, 1 },
+      { 15, 122, 23, 0 },
+      { 240, 90, 214, 0 }, },
+    { { 116, 47, 123, 1 },
+      { 61, 239, 7, 1 },
+      { 239, 122, 23, 0 },
+      { 240, 123, 222, 0 }, },
+    { { 116, 47, 116, 1 },
+      { 61, 173, 23, 0 },
+      { 151, 122, 23, 0 },
+      { 116, 90, 222, 0 }, },
+    { { 116, 47, 119, 0 },
+      { 53, 239, 23, 0 },
+      { 119, 122, 23, 0 },
+      { 116, 123, 214, 0 }, },
+    { { 116, 46, 152, 0 },
+      { 53, 41, 38, 1 },
+      { 12, 186, 23, 0 },
+      { 178, 74, 86, 0 }, },
+    { { 116, 46, 155, 1 },
+      { 61, 107, 38, 1 },
+      { 236, 186, 23, 0 },
+      { 178, 107, 94, 0 }, },
+    { { 116, 46, 148, 1 },
+      { 61, 41, 54, 0 },
+      { 148, 186, 23, 0 },
+      { 54, 74, 94, 0 }, },
+    { { 116, 46, 151, 0 },
+      { 53, 107, 54, 0 },
+      { 116, 186, 23, 0 },
+      { 54, 107, 86, 0 }, },
+    { { 116, 46, 232, 0 },
+      { 37, 173, 38, 1 },
+      { 11, 186, 23, 0 },
+      { 178, 90, 210, 0 }, },
+    { { 116, 46, 235, 1 },
+      { 45, 239, 38, 1 },
+      { 235, 186, 23, 0 },
+      { 178, 123, 218, 0 }, },
+    { { 116, 46, 228, 1 },
+      { 45, 173, 54, 0 },
+      { 147, 186, 23, 0 },
+      { 54, 90, 218, 0 }, },
+    { { 116, 46, 231, 0 },
+      { 37, 239, 54, 0 },
+      { 115, 186, 23, 0 },
+      { 54, 123, 210, 0 }, },
+    { { 116, 19, 8, 0 },
+      { 36, 33, 69, 1 },
+      { 8, 100, 23, 0 },
+      { 209, 66, 18, 0 }, },
+    { { 116, 19, 11, 1 },
+      { 44, 99, 69, 1 },
+      { 232, 100, 23, 0 },
+      { 209, 99, 26, 0 }, },
+    { { 116, 19, 4, 1 },
+      { 44, 33, 85, 0 },
+      { 144, 100, 23, 0 },
+      { 85, 66, 26, 0 }, },
+    { { 116, 19, 7, 0 },
+      { 36, 99, 85, 0 },
+      { 112, 100, 23, 0 },
+      { 85, 99, 18, 0 }, },
+    { { 116, 19, 120, 0 },
+      { 52, 165, 69, 1 },
+      { 15, 100, 23, 0 },
+      { 209, 82, 150, 0 }, },
+    { { 116, 19, 123, 1 },
+      { 60, 231, 69, 1 },
+      { 239, 100, 23, 0 },
+      { 209, 115, 158, 0 }, },
+    { { 116, 19, 116, 1 },
+      { 60, 165, 85, 0 },
+      { 151, 100, 23, 0 },
+      { 85, 82, 158, 0 }, },
+    { { 116, 19, 119, 0 },
+      { 52, 231, 85, 0 },
+      { 119, 100, 23, 0 },
+      { 85, 115, 150, 0 }, },
+    { { 116, 18, 152, 0 },
+      { 52, 33, 100, 1 },
+      { 12, 164, 23, 0 },
+      { 147, 66, 22, 0 }, },
+    { { 116, 18, 155, 1 },
+      { 60, 99, 100, 1 },
+      { 236, 164, 23, 0 },
+      { 147, 99, 30, 0 }, },
+    { { 116, 18, 148, 1 },
+      { 60, 33, 116, 0 },
+      { 148, 164, 23, 0 },
+      { 23, 66, 30, 0 }, },
+    { { 116, 18, 151, 0 },
+      { 52, 99, 116, 0 },
+      { 116, 164, 23, 0 },
+      { 23, 99, 22, 0 }, },
+    { { 116, 18, 232, 0 },
+      { 36, 165, 100, 1 },
+      { 11, 164, 23, 0 },
+      { 147, 82, 146, 0 }, },
+    { { 116, 18, 235, 1 },
+      { 44, 231, 100, 1 },
+      { 235, 164, 23, 0 },
+      { 147, 115, 154, 0 }, },
+    { { 116, 18, 228, 1 },
+      { 44, 165, 116, 0 },
+      { 147, 164, 23, 0 },
+      { 23, 82, 154, 0 }, },
+    { { 116, 18, 231, 0 },
+      { 36, 231, 116, 0 },
+      { 115, 164, 23, 0 },
+      { 23, 115, 146, 0 }, },
+    { { 116, 29, 8, 0 },
+      { 5, 41, 69, 1 },
+      { 8, 92, 23, 0 },
+      { 209, 74, 80, 0 }, },
+    { { 116, 29, 11, 1 },
+      { 13, 107, 69, 1 },
+      { 232, 92, 23, 0 },
+      { 209, 107, 88, 0 }, },
+    { { 116, 29, 4, 1 },
+      { 13, 41, 85, 0 },
+      { 144, 92, 23, 0 },
+      { 85, 74, 88, 0 }, },
+    { { 116, 29, 7, 0 },
+      { 5, 107, 85, 0 },
+      { 112, 92, 23, 0 },
+      { 85, 107, 80, 0 }, },
+    { { 116, 29, 120, 0 },
+      { 21, 173, 69, 1 },
+      { 15, 92, 23, 0 },
+      { 209, 90, 212, 0 }, },
+    { { 116, 29, 123, 1 },
+      { 29, 239, 69, 1 },
+      { 239, 92, 23, 0 },
+      { 209, 123, 220, 0 }, },
+    { { 116, 29, 116, 1 },
+      { 29, 173, 85, 0 },
+      { 151, 92, 23, 0 },
+      { 85, 90, 220, 0 }, },
+    { { 116, 29, 119, 0 },
+      { 21, 239, 85, 0 },
+      { 119, 92, 23, 0 },
+      { 85, 123, 212, 0 }, },
+    { { 116, 28, 152, 0 },
+      { 21, 41, 100, 1 },
+      { 12, 156, 23, 0 },
+      { 147, 74, 84, 0 }, },
+    { { 116, 28, 155, 1 },
+      { 29, 107, 100, 1 },
+      { 236, 156, 23, 0 },
+      { 147, 107, 92, 0 }, },
+    { { 116, 28, 148, 1 },
+      { 29, 41, 116, 0 },
+      { 148, 156, 23, 0 },
+      { 23, 74, 92, 0 }, },
+    { { 116, 28, 151, 0 },
+      { 21, 107, 116, 0 },
+      { 116, 156, 23, 0 },
+      { 23, 107, 84, 0 }, },
+    { { 116, 28, 232, 0 },
+      { 5, 173, 100, 1 },
+      { 11, 156, 23, 0 },
+      { 147, 90, 208, 0 }, },
+    { { 116, 28, 235, 1 },
+      { 13, 239, 100, 1 },
+      { 235, 156, 23, 0 },
+      { 147, 123, 216, 0 }, },
+    { { 116, 28, 228, 1 },
+      { 13, 173, 116, 0 },
+      { 147, 156, 23, 0 },
+      { 23, 90, 216, 0 }, },
+    { { 116, 28, 231, 0 },
+      { 5, 239, 116, 0 },
+      { 115, 156, 23, 0 },
+      { 23, 123, 208, 0 }, },
+    { { 117, 225, 8, 0 },
+      { 70, 49, 7, 1 },
+      { 8, 67, 215, 0 },
+      { 240, 70, 49, 0 }, },
+    { { 117, 225, 11, 1 },
+      { 78, 115, 7, 1 },
+      { 232, 67, 215, 0 },
+      { 240, 103, 57, 0 }, },
+    { { 117, 225, 4, 1 },
+      { 78, 49, 23, 0 },
+      { 144, 67, 215, 0 },
+      { 116, 70, 57, 0 }, },
+    { { 117, 225, 7, 0 },
+      { 70, 115, 23, 0 },
+      { 112, 67, 215, 0 },
+      { 116, 103, 49, 0 }, },
+    { { 117, 225, 120, 0 },
+      { 86, 181, 7, 1 },
+      { 15, 67, 215, 0 },
+      { 240, 86, 181, 0 }, },
+    { { 117, 225, 123, 1 },
+      { 94, 247, 7, 1 },
+      { 239, 67, 215, 0 },
+      { 240, 119, 189, 0 }, },
+    { { 117, 225, 116, 1 },
+      { 94, 181, 23, 0 },
+      { 151, 67, 215, 0 },
+      { 116, 86, 189, 0 }, },
+    { { 117, 225, 119, 0 },
+      { 86, 247, 23, 0 },
+      { 119, 67, 215, 0 },
+      { 116, 119, 181, 0 }, },
+    { { 117, 224, 152, 0 },
+      { 86, 49, 38, 1 },
+      { 12, 131, 215, 0 },
+      { 178, 70, 53, 0 }, },
+    { { 117, 224, 155, 1 },
+      { 94, 115, 38, 1 },
+      { 236, 131, 215, 0 },
+      { 178, 103, 61, 0 }, },
+    { { 117, 224, 148, 1 },
+      { 94, 49, 54, 0 },
+      { 148, 131, 215, 0 },
+      { 54, 70, 61, 0 }, },
+    { { 117, 224, 151, 0 },
+      { 86, 115, 54, 0 },
+      { 116, 131, 215, 0 },
+      { 54, 103, 53, 0 }, },
+    { { 117, 224, 232, 0 },
+      { 70, 181, 38, 1 },
+      { 11, 131, 215, 0 },
+      { 178, 86, 177, 0 }, },
+    { { 117, 224, 235, 1 },
+      { 78, 247, 38, 1 },
+      { 235, 131, 215, 0 },
+      { 178, 119, 185, 0 }, },
+    { { 117, 224, 228, 1 },
+      { 78, 181, 54, 0 },
+      { 147, 131, 215, 0 },
+      { 54, 86, 185, 0 }, },
+    { { 117, 224, 231, 0 },
+      { 70, 247, 54, 0 },
+      { 115, 131, 215, 0 },
+      { 54, 119, 177, 0 }, },
+    { { 117, 239, 8, 0 },
+      { 103, 57, 7, 1 },
+      { 8, 123, 215, 0 },
+      { 240, 78, 115, 0 }, },
+    { { 117, 239, 11, 1 },
+      { 111, 123, 7, 1 },
+      { 232, 123, 215, 0 },
+      { 240, 111, 123, 0 }, },
+    { { 117, 239, 4, 1 },
+      { 111, 57, 23, 0 },
+      { 144, 123, 215, 0 },
+      { 116, 78, 123, 0 }, },
+    { { 117, 239, 7, 0 },
+      { 103, 123, 23, 0 },
+      { 112, 123, 215, 0 },
+      { 116, 111, 115, 0 }, },
+    { { 117, 239, 120, 0 },
+      { 119, 189, 7, 1 },
+      { 15, 123, 215, 0 },
+      { 240, 94, 247, 0 }, },
+    { { 117, 239, 123, 1 },
+      { 127, 255, 7, 1 },
+      { 239, 123, 215, 0 },
+      { 240, 127, 255, 0 }, },
+    { { 117, 239, 116, 1 },
+      { 127, 189, 23, 0 },
+      { 151, 123, 215, 0 },
+      { 116, 94, 255, 0 }, },
+    { { 117, 239, 119, 0 },
+      { 119, 255, 23, 0 },
+      { 119, 123, 215, 0 },
+      { 116, 127, 247, 0 }, },
+    { { 117, 238, 152, 0 },
+      { 119, 57, 38, 1 },
+      { 12, 187, 215, 0 },
+      { 178, 78, 119, 0 }, },
+    { { 117, 238, 155, 1 },
+      { 127, 123, 38, 1 },
+      { 236, 187, 215, 0 },
+      { 178, 111, 127, 0 }, },
+    { { 117, 238, 148, 1 },
+      { 127, 57, 54, 0 },
+      { 148, 187, 215, 0 },
+      { 54, 78, 127, 0 }, },
+    { { 117, 238, 151, 0 },
+      { 119, 123, 54, 0 },
+      { 116, 187, 215, 0 },
+      { 54, 111, 119, 0 }, },
+    { { 117, 238, 232, 0 },
+      { 103, 189, 38, 1 },
+      { 11, 187, 215, 0 },
+      { 178, 94, 243, 0 }, },
+    { { 117, 238, 235, 1 },
+      { 111, 255, 38, 1 },
+      { 235, 187, 215, 0 },
+      { 178, 127, 251, 0 }, },
+    { { 117, 238, 228, 1 },
+      { 111, 189, 54, 0 },
+      { 147, 187, 215, 0 },
+      { 54, 94, 251, 0 }, },
+    { { 117, 238, 231, 0 },
+      { 103, 255, 54, 0 },
+      { 115, 187, 215, 0 },
+      { 54, 127, 243, 0 }, },
+    { { 117, 211, 8, 0 },
+      { 102, 49, 69, 1 },
+      { 8, 101, 215, 0 },
+      { 209, 70, 51, 0 }, },
+    { { 117, 211, 11, 1 },
+      { 110, 115, 69, 1 },
+      { 232, 101, 215, 0 },
+      { 209, 103, 59, 0 }, },
+    { { 117, 211, 4, 1 },
+      { 110, 49, 85, 0 },
+      { 144, 101, 215, 0 },
+      { 85, 70, 59, 0 }, },
+    { { 117, 211, 7, 0 },
+      { 102, 115, 85, 0 },
+      { 112, 101, 215, 0 },
+      { 85, 103, 51, 0 }, },
+    { { 117, 211, 120, 0 },
+      { 118, 181, 69, 1 },
+      { 15, 101, 215, 0 },
+      { 209, 86, 183, 0 }, },
+    { { 117, 211, 123, 1 },
+      { 126, 247, 69, 1 },
+      { 239, 101, 215, 0 },
+      { 209, 119, 191, 0 }, },
+    { { 117, 211, 116, 1 },
+      { 126, 181, 85, 0 },
+      { 151, 101, 215, 0 },
+      { 85, 86, 191, 0 }, },
+    { { 117, 211, 119, 0 },
+      { 118, 247, 85, 0 },
+      { 119, 101, 215, 0 },
+      { 85, 119, 183, 0 }, },
+    { { 117, 210, 152, 0 },
+      { 118, 49, 100, 1 },
+      { 12, 165, 215, 0 },
+      { 147, 70, 55, 0 }, },
+    { { 117, 210, 155, 1 },
+      { 126, 115, 100, 1 },
+      { 236, 165, 215, 0 },
+      { 147, 103, 63, 0 }, },
+    { { 117, 210, 148, 1 },
+      { 126, 49, 116, 0 },
+      { 148, 165, 215, 0 },
+      { 23, 70, 63, 0 }, },
+    { { 117, 210, 151, 0 },
+      { 118, 115, 116, 0 },
+      { 116, 165, 215, 0 },
+      { 23, 103, 55, 0 }, },
+    { { 117, 210, 232, 0 },
+      { 102, 181, 100, 1 },
+      { 11, 165, 215, 0 },
+      { 147, 86, 179, 0 }, },
+    { { 117, 210, 235, 1 },
+      { 110, 247, 100, 1 },
+      { 235, 165, 215, 0 },
+      { 147, 119, 187, 0 }, },
+    { { 117, 210, 228, 1 },
+      { 110, 181, 116, 0 },
+      { 147, 165, 215, 0 },
+      { 23, 86, 187, 0 }, },
+    { { 117, 210, 231, 0 },
+      { 102, 247, 116, 0 },
+      { 115, 165, 215, 0 },
+      { 23, 119, 179, 0 }, },
+    { { 117, 221, 8, 0 },
+      { 71, 57, 69, 1 },
+      { 8, 93, 215, 0 },
+      { 209, 78, 113, 0 }, },
+    { { 117, 221, 11, 1 },
+      { 79, 123, 69, 1 },
+      { 232, 93, 215, 0 },
+      { 209, 111, 121, 0 }, },
+    { { 117, 221, 4, 1 },
+      { 79, 57, 85, 0 },
+      { 144, 93, 215, 0 },
+      { 85, 78, 121, 0 }, },
+    { { 117, 221, 7, 0 },
+      { 71, 123, 85, 0 },
+      { 112, 93, 215, 0 },
+      { 85, 111, 113, 0 }, },
+    { { 117, 221, 120, 0 },
+      { 87, 189, 69, 1 },
+      { 15, 93, 215, 0 },
+      { 209, 94, 245, 0 }, },
+    { { 117, 221, 123, 1 },
+      { 95, 255, 69, 1 },
+      { 239, 93, 215, 0 },
+      { 209, 127, 253, 0 }, },
+    { { 117, 221, 116, 1 },
+      { 95, 189, 85, 0 },
+      { 151, 93, 215, 0 },
+      { 85, 94, 253, 0 }, },
+    { { 117, 221, 119, 0 },
+      { 87, 255, 85, 0 },
+      { 119, 93, 215, 0 },
+      { 85, 127, 245, 0 }, },
+    { { 117, 220, 152, 0 },
+      { 87, 57, 100, 1 },
+      { 12, 157, 215, 0 },
+      { 147, 78, 117, 0 }, },
+    { { 117, 220, 155, 1 },
+      { 95, 123, 100, 1 },
+      { 236, 157, 215, 0 },
+      { 147, 111, 125, 0 }, },
+    { { 117, 220, 148, 1 },
+      { 95, 57, 116, 0 },
+      { 148, 157, 215, 0 },
+      { 23, 78, 125, 0 }, },
+    { { 117, 220, 151, 0 },
+      { 87, 123, 116, 0 },
+      { 116, 157, 215, 0 },
+      { 23, 111, 117, 0 }, },
+    { { 117, 220, 232, 0 },
+      { 71, 189, 100, 1 },
+      { 11, 157, 215, 0 },
+      { 147, 94, 241, 0 }, },
+    { { 117, 220, 235, 1 },
+      { 79, 255, 100, 1 },
+      { 235, 157, 215, 0 },
+      { 147, 127, 249, 0 }, },
+    { { 117, 220, 228, 1 },
+      { 79, 189, 116, 0 },
+      { 147, 157, 215, 0 },
+      { 23, 94, 249, 0 }, },
+    { { 117, 220, 231, 0 },
+      { 71, 255, 116, 0 },
+      { 115, 157, 215, 0 },
+      { 23, 127, 241, 0 }, },
+    { { 114, 97, 8, 0 },
+      { 68, 33, 131, 1 },
+      { 8, 67, 39, 0 },
+      { 224, 194, 17, 0 }, },
+    { { 114, 97, 11, 1 },
+      { 76, 99, 131, 1 },
+      { 232, 67, 39, 0 },
+      { 224, 227, 25, 0 }, },
+    { { 114, 97, 4, 1 },
+      { 76, 33, 147, 0 },
+      { 144, 67, 39, 0 },
+      { 100, 194, 25, 0 }, },
+    { { 114, 97, 7, 0 },
+      { 68, 99, 147, 0 },
+      { 112, 67, 39, 0 },
+      { 100, 227, 17, 0 }, },
+    { { 114, 97, 120, 0 },
+      { 84, 165, 131, 1 },
+      { 15, 67, 39, 0 },
+      { 224, 210, 149, 0 }, },
+    { { 114, 97, 123, 1 },
+      { 92, 231, 131, 1 },
+      { 239, 67, 39, 0 },
+      { 224, 243, 157, 0 }, },
+    { { 114, 97, 116, 1 },
+      { 92, 165, 147, 0 },
+      { 151, 67, 39, 0 },
+      { 100, 210, 157, 0 }, },
+    { { 114, 97, 119, 0 },
+      { 84, 231, 147, 0 },
+      { 119, 67, 39, 0 },
+      { 100, 243, 149, 0 }, },
+    { { 114, 96, 152, 0 },
+      { 84, 33, 162, 1 },
+      { 12, 131, 39, 0 },
+      { 162, 194, 21, 0 }, },
+    { { 114, 96, 155, 1 },
+      { 92, 99, 162, 1 },
+      { 236, 131, 39, 0 },
+      { 162, 227, 29, 0 }, },
+    { { 114, 96, 148, 1 },
+      { 92, 33, 178, 0 },
+      { 148, 131, 39, 0 },
+      { 38, 194, 29, 0 }, },
+    { { 114, 96, 151, 0 },
+      { 84, 99, 178, 0 },
+      { 116, 131, 39, 0 },
+      { 38, 227, 21, 0 }, },
+    { { 114, 96, 232, 0 },
+      { 68, 165, 162, 1 },
+      { 11, 131, 39, 0 },
+      { 162, 210, 145, 0 }, },
+    { { 114, 96, 235, 1 },
+      { 76, 231, 162, 1 },
+      { 235, 131, 39, 0 },
+      { 162, 243, 153, 0 }, },
+    { { 114, 96, 228, 1 },
+      { 76, 165, 178, 0 },
+      { 147, 131, 39, 0 },
+      { 38, 210, 153, 0 }, },
+    { { 114, 96, 231, 0 },
+      { 68, 231, 178, 0 },
+      { 115, 131, 39, 0 },
+      { 38, 243, 145, 0 }, },
+    { { 114, 111, 8, 0 },
+      { 101, 41, 131, 1 },
+      { 8, 123, 39, 0 },
+      { 224, 202, 83, 0 }, },
+    { { 114, 111, 11, 1 },
+      { 109, 107, 131, 1 },
+      { 232, 123, 39, 0 },
+      { 224, 235, 91, 0 }, },
+    { { 114, 111, 4, 1 },
+      { 109, 41, 147, 0 },
+      { 144, 123, 39, 0 },
+      { 100, 202, 91, 0 }, },
+    { { 114, 111, 7, 0 },
+      { 101, 107, 147, 0 },
+      { 112, 123, 39, 0 },
+      { 100, 235, 83, 0 }, },
+    { { 114, 111, 120, 0 },
+      { 117, 173, 131, 1 },
+      { 15, 123, 39, 0 },
+      { 224, 218, 215, 0 }, },
+    { { 114, 111, 123, 1 },
+      { 125, 239, 131, 1 },
+      { 239, 123, 39, 0 },
+      { 224, 251, 223, 0 }, },
+    { { 114, 111, 116, 1 },
+      { 125, 173, 147, 0 },
+      { 151, 123, 39, 0 },
+      { 100, 218, 223, 0 }, },
+    { { 114, 111, 119, 0 },
+      { 117, 239, 147, 0 },
+      { 119, 123, 39, 0 },
+      { 100, 251, 215, 0 }, },
+    { { 114, 110, 152, 0 },
+      { 117, 41, 162, 1 },
+      { 12, 187, 39, 0 },
+      { 162, 202, 87, 0 }, },
+    { { 114, 110, 155, 1 },
+      { 125, 107, 162, 1 },
+      { 236, 187, 39, 0 },
+      { 162, 235, 95, 0 }, },
+    { { 114, 110, 148, 1 },
+      { 125, 41, 178, 0 },
+      { 148, 187, 39, 0 },
+      { 38, 202, 95, 0 }, },
+    { { 114, 110, 151, 0 },
+      { 117, 107, 178, 0 },
+      { 116, 187, 39, 0 },
+      { 38, 235, 87, 0 }, },
+    { { 114, 110, 232, 0 },
+      { 101, 173, 162, 1 },
+      { 11, 187, 39, 0 },
+      { 162, 218, 211, 0 }, },
+    { { 114, 110, 235, 1 },
+      { 109, 239, 162, 1 },
+      { 235, 187, 39, 0 },
+      { 162, 251, 219, 0 }, },
+    { { 114, 110, 228, 1 },
+      { 109, 173, 178, 0 },
+      { 147, 187, 39, 0 },
+      { 38, 218, 219, 0 }, },
+    { { 114, 110, 231, 0 },
+      { 101, 239, 178, 0 },
+      { 115, 187, 39, 0 },
+      { 38, 251, 211, 0 }, },
+    { { 114, 83, 8, 0 },
+      { 100, 33, 193, 1 },
+      { 8, 101, 39, 0 },
+      { 193, 194, 19, 0 }, },
+    { { 114, 83, 11, 1 },
+      { 108, 99, 193, 1 },
+      { 232, 101, 39, 0 },
+      { 193, 227, 27, 0 }, },
+    { { 114, 83, 4, 1 },
+      { 108, 33, 209, 0 },
+      { 144, 101, 39, 0 },
+      { 69, 194, 27, 0 }, },
+    { { 114, 83, 7, 0 },
+      { 100, 99, 209, 0 },
+      { 112, 101, 39, 0 },
+      { 69, 227, 19, 0 }, },
+    { { 114, 83, 120, 0 },
+      { 116, 165, 193, 1 },
+      { 15, 101, 39, 0 },
+      { 193, 210, 151, 0 }, },
+    { { 114, 83, 123, 1 },
+      { 124, 231, 193, 1 },
+      { 239, 101, 39, 0 },
+      { 193, 243, 159, 0 }, },
+    { { 114, 83, 116, 1 },
+      { 124, 165, 209, 0 },
+      { 151, 101, 39, 0 },
+      { 69, 210, 159, 0 }, },
+    { { 114, 83, 119, 0 },
+      { 116, 231, 209, 0 },
+      { 119, 101, 39, 0 },
+      { 69, 243, 151, 0 }, },
+    { { 114, 82, 152, 0 },
+      { 116, 33, 224, 1 },
+      { 12, 165, 39, 0 },
+      { 131, 194, 23, 0 }, },
+    { { 114, 82, 155, 1 },
+      { 124, 99, 224, 1 },
+      { 236, 165, 39, 0 },
+      { 131, 227, 31, 0 }, },
+    { { 114, 82, 148, 1 },
+      { 124, 33, 240, 0 },
+      { 148, 165, 39, 0 },
+      { 7, 194, 31, 0 }, },
+    { { 114, 82, 151, 0 },
+      { 116, 99, 240, 0 },
+      { 116, 165, 39, 0 },
+      { 7, 227, 23, 0 }, },
+    { { 114, 82, 232, 0 },
+      { 100, 165, 224, 1 },
+      { 11, 165, 39, 0 },
+      { 131, 210, 147, 0 }, },
+    { { 114, 82, 235, 1 },
+      { 108, 231, 224, 1 },
+      { 235, 165, 39, 0 },
+      { 131, 243, 155, 0 }, },
+    { { 114, 82, 228, 1 },
+      { 108, 165, 240, 0 },
+      { 147, 165, 39, 0 },
+      { 7, 210, 155, 0 }, },
+    { { 114, 82, 231, 0 },
+      { 100, 231, 240, 0 },
+      { 115, 165, 39, 0 },
+      { 7, 243, 147, 0 }, },
+    { { 114, 93, 8, 0 },
+      { 69, 41, 193, 1 },
+      { 8, 93, 39, 0 },
+      { 193, 202, 81, 0 }, },
+    { { 114, 93, 11, 1 },
+      { 77, 107, 193, 1 },
+      { 232, 93, 39, 0 },
+      { 193, 235, 89, 0 }, },
+    { { 114, 93, 4, 1 },
+      { 77, 41, 209, 0 },
+      { 144, 93, 39, 0 },
+      { 69, 202, 89, 0 }, },
+    { { 114, 93, 7, 0 },
+      { 69, 107, 209, 0 },
+      { 112, 93, 39, 0 },
+      { 69, 235, 81, 0 }, },
+    { { 114, 93, 120, 0 },
+      { 85, 173, 193, 1 },
+      { 15, 93, 39, 0 },
+      { 193, 218, 213, 0 }, },
+    { { 114, 93, 123, 1 },
+      { 93, 239, 193, 1 },
+      { 239, 93, 39, 0 },
+      { 193, 251, 221, 0 }, },
+    { { 114, 93, 116, 1 },
+      { 93, 173, 209, 0 },
+      { 151, 93, 39, 0 },
+      { 69, 218, 221, 0 }, },
+    { { 114, 93, 119, 0 },
+      { 85, 239, 209, 0 },
+      { 119, 93, 39, 0 },
+      { 69, 251, 213, 0 }, },
+    { { 114, 92, 152, 0 },
+      { 85, 41, 224, 1 },
+      { 12, 157, 39, 0 },
+      { 131, 202, 85, 0 }, },
+    { { 114, 92, 155, 1 },
+      { 93, 107, 224, 1 },
+      { 236, 157, 39, 0 },
+      { 131, 235, 93, 0 }, },
+    { { 114, 92, 148, 1 },
+      { 93, 41, 240, 0 },
+      { 148, 157, 39, 0 },
+      { 7, 202, 93, 0 }, },
+    { { 114, 92, 151, 0 },
+      { 85, 107, 240, 0 },
+      { 116, 157, 39, 0 },
+      { 7, 235, 85, 0 }, },
+    { { 114, 92, 232, 0 },
+      { 69, 173, 224, 1 },
+      { 11, 157, 39, 0 },
+      { 131, 218, 209, 0 }, },
+    { { 114, 92, 235, 1 },
+      { 77, 239, 224, 1 },
+      { 235, 157, 39, 0 },
+      { 131, 251, 217, 0 }, },
+    { { 114, 92, 228, 1 },
+      { 77, 173, 240, 0 },
+      { 147, 157, 39, 0 },
+      { 7, 218, 217, 0 }, },
+    { { 114, 92, 231, 0 },
+      { 69, 239, 240, 0 },
+      { 115, 157, 39, 0 },
+      { 7, 251, 209, 0 }, },
+    { { 115, 161, 8, 0 },
+      { 6, 49, 131, 1 },
+      { 8, 66, 231, 0 },
+      { 224, 198, 48, 0 }, },
+    { { 115, 161, 11, 1 },
+      { 14, 115, 131, 1 },
+      { 232, 66, 231, 0 },
+      { 224, 231, 56, 0 }, },
+    { { 115, 161, 4, 1 },
+      { 14, 49, 147, 0 },
+      { 144, 66, 231, 0 },
+      { 100, 198, 56, 0 }, },
+    { { 115, 161, 7, 0 },
+      { 6, 115, 147, 0 },
+      { 112, 66, 231, 0 },
+      { 100, 231, 48, 0 }, },
+    { { 115, 161, 120, 0 },
+      { 22, 181, 131, 1 },
+      { 15, 66, 231, 0 },
+      { 224, 214, 180, 0 }, },
+    { { 115, 161, 123, 1 },
+      { 30, 247, 131, 1 },
+      { 239, 66, 231, 0 },
+      { 224, 247, 188, 0 }, },
+    { { 115, 161, 116, 1 },
+      { 30, 181, 147, 0 },
+      { 151, 66, 231, 0 },
+      { 100, 214, 188, 0 }, },
+    { { 115, 161, 119, 0 },
+      { 22, 247, 147, 0 },
+      { 119, 66, 231, 0 },
+      { 100, 247, 180, 0 }, },
+    { { 115, 160, 152, 0 },
+      { 22, 49, 162, 1 },
+      { 12, 130, 231, 0 },
+      { 162, 198, 52, 0 }, },
+    { { 115, 160, 155, 1 },
+      { 30, 115, 162, 1 },
+      { 236, 130, 231, 0 },
+      { 162, 231, 60, 0 }, },
+    { { 115, 160, 148, 1 },
+      { 30, 49, 178, 0 },
+      { 148, 130, 231, 0 },
+      { 38, 198, 60, 0 }, },
+    { { 115, 160, 151, 0 },
+      { 22, 115, 178, 0 },
+      { 116, 130, 231, 0 },
+      { 38, 231, 52, 0 }, },
+    { { 115, 160, 232, 0 },
+      { 6, 181, 162, 1 },
+      { 11, 130, 231, 0 },
+      { 162, 214, 176, 0 }, },
+    { { 115, 160, 235, 1 },
+      { 14, 247, 162, 1 },
+      { 235, 130, 231, 0 },
+      { 162, 247, 184, 0 }, },
+    { { 115, 160, 228, 1 },
+      { 14, 181, 178, 0 },
+      { 147, 130, 231, 0 },
+      { 38, 214, 184, 0 }, },
+    { { 115, 160, 231, 0 },
+      { 6, 247, 178, 0 },
+      { 115, 130, 231, 0 },
+      { 38, 247, 176, 0 }, },
+    { { 115, 175, 8, 0 },
+      { 39, 57, 131, 1 },
+      { 8, 122, 231, 0 },
+      { 224, 206, 114, 0 }, },
+    { { 115, 175, 11, 1 },
+      { 47, 123, 131, 1 },
+      { 232, 122, 231, 0 },
+      { 224, 239, 122, 0 }, },
+    { { 115, 175, 4, 1 },
+      { 47, 57, 147, 0 },
+      { 144, 122, 231, 0 },
+      { 100, 206, 122, 0 }, },
+    { { 115, 175, 7, 0 },
+      { 39, 123, 147, 0 },
+      { 112, 122, 231, 0 },
+      { 100, 239, 114, 0 }, },
+    { { 115, 175, 120, 0 },
+      { 55, 189, 131, 1 },
+      { 15, 122, 231, 0 },
+      { 224, 222, 246, 0 }, },
+    { { 115, 175, 123, 1 },
+      { 63, 255, 131, 1 },
+      { 239, 122, 231, 0 },
+      { 224, 255, 254, 0 }, },
+    { { 115, 175, 116, 1 },
+      { 63, 189, 147, 0 },
+      { 151, 122, 231, 0 },
+      { 100, 222, 254, 0 }, },
+    { { 115, 175, 119, 0 },
+      { 55, 255, 147, 0 },
+      { 119, 122, 231, 0 },
+      { 100, 255, 246, 0 }, },
+    { { 115, 174, 152, 0 },
+      { 55, 57, 162, 1 },
+      { 12, 186, 231, 0 },
+      { 162, 206, 118, 0 }, },
+    { { 115, 174, 155, 1 },
+      { 63, 123, 162, 1 },
+      { 236, 186, 231, 0 },
+      { 162, 239, 126, 0 }, },
+    { { 115, 174, 148, 1 },
+      { 63, 57, 178, 0 },
+      { 148, 186, 231, 0 },
+      { 38, 206, 126, 0 }, },
+    { { 115, 174, 151, 0 },
+      { 55, 123, 178, 0 },
+      { 116, 186, 231, 0 },
+      { 38, 239, 118, 0 }, },
+    { { 115, 174, 232, 0 },
+      { 39, 189, 162, 1 },
+      { 11, 186, 231, 0 },
+      { 162, 222, 242, 0 }, },
+    { { 115, 174, 235, 1 },
+      { 47, 255, 162, 1 },
+      { 235, 186, 231, 0 },
+      { 162, 255, 250, 0 }, },
+    { { 115, 174, 228, 1 },
+      { 47, 189, 178, 0 },
+      { 147, 186, 231, 0 },
+      { 38, 222, 250, 0 }, },
+    { { 115, 174, 231, 0 },
+      { 39, 255, 178, 0 },
+      { 115, 186, 231, 0 },
+      { 38, 255, 242, 0 }, },
+    { { 115, 147, 8, 0 },
+      { 38, 49, 193, 1 },
+      { 8, 100, 231, 0 },
+      { 193, 198, 50, 0 }, },
+    { { 115, 147, 11, 1 },
+      { 46, 115, 193, 1 },
+      { 232, 100, 231, 0 },
+      { 193, 231, 58, 0 }, },
+    { { 115, 147, 4, 1 },
+      { 46, 49, 209, 0 },
+      { 144, 100, 231, 0 },
+      { 69, 198, 58, 0 }, },
+    { { 115, 147, 7, 0 },
+      { 38, 115, 209, 0 },
+      { 112, 100, 231, 0 },
+      { 69, 231, 50, 0 }, },
+    { { 115, 147, 120, 0 },
+      { 54, 181, 193, 1 },
+      { 15, 100, 231, 0 },
+      { 193, 214, 182, 0 }, },
+    { { 115, 147, 123, 1 },
+      { 62, 247, 193, 1 },
+      { 239, 100, 231, 0 },
+      { 193, 247, 190, 0 }, },
+    { { 115, 147, 116, 1 },
+      { 62, 181, 209, 0 },
+      { 151, 100, 231, 0 },
+      { 69, 214, 190, 0 }, },
+    { { 115, 147, 119, 0 },
+      { 54, 247, 209, 0 },
+      { 119, 100, 231, 0 },
+      { 69, 247, 182, 0 }, },
+    { { 115, 146, 152, 0 },
+      { 54, 49, 224, 1 },
+      { 12, 164, 231, 0 },
+      { 131, 198, 54, 0 }, },
+    { { 115, 146, 155, 1 },
+      { 62, 115, 224, 1 },
+      { 236, 164, 231, 0 },
+      { 131, 231, 62, 0 }, },
+    { { 115, 146, 148, 1 },
+      { 62, 49, 240, 0 },
+      { 148, 164, 231, 0 },
+      { 7, 198, 62, 0 }, },
+    { { 115, 146, 151, 0 },
+      { 54, 115, 240, 0 },
+      { 116, 164, 231, 0 },
+      { 7, 231, 54, 0 }, },
+    { { 115, 146, 232, 0 },
+      { 38, 181, 224, 1 },
+      { 11, 164, 231, 0 },
+      { 131, 214, 178, 0 }, },
+    { { 115, 146, 235, 1 },
+      { 46, 247, 224, 1 },
+      { 235, 164, 231, 0 },
+      { 131, 247, 186, 0 }, },
+    { { 115, 146, 228, 1 },
+      { 46, 181, 240, 0 },
+      { 147, 164, 231, 0 },
+      { 7, 214, 186, 0 }, },
+    { { 115, 146, 231, 0 },
+      { 38, 247, 240, 0 },
+      { 115, 164, 231, 0 },
+      { 7, 247, 178, 0 }, },
+    { { 115, 157, 8, 0 },
+      { 7, 57, 193, 1 },
+      { 8, 92, 231, 0 },
+      { 193, 206, 112, 0 }, },
+    { { 115, 157, 11, 1 },
+      { 15, 123, 193, 1 },
+      { 232, 92, 231, 0 },
+      { 193, 239, 120, 0 }, },
+    { { 115, 157, 4, 1 },
+      { 15, 57, 209, 0 },
+      { 144, 92, 231, 0 },
+      { 69, 206, 120, 0 }, },
+    { { 115, 157, 7, 0 },
+      { 7, 123, 209, 0 },
+      { 112, 92, 231, 0 },
+      { 69, 239, 112, 0 }, },
+    { { 115, 157, 120, 0 },
+      { 23, 189, 193, 1 },
+      { 15, 92, 231, 0 },
+      { 193, 222, 244, 0 }, },
+    { { 115, 157, 123, 1 },
+      { 31, 255, 193, 1 },
+      { 239, 92, 231, 0 },
+      { 193, 255, 252, 0 }, },
+    { { 115, 157, 116, 1 },
+      { 31, 189, 209, 0 },
+      { 151, 92, 231, 0 },
+      { 69, 222, 252, 0 }, },
+    { { 115, 157, 119, 0 },
+      { 23, 255, 209, 0 },
+      { 119, 92, 231, 0 },
+      { 69, 255, 244, 0 }, },
+    { { 115, 156, 152, 0 },
+      { 23, 57, 224, 1 },
+      { 12, 156, 231, 0 },
+      { 131, 206, 116, 0 }, },
+    { { 115, 156, 155, 1 },
+      { 31, 123, 224, 1 },
+      { 236, 156, 231, 0 },
+      { 131, 239, 124, 0 }, },
+    { { 115, 156, 148, 1 },
+      { 31, 57, 240, 0 },
+      { 148, 156, 231, 0 },
+      { 7, 206, 124, 0 }, },
+    { { 115, 156, 151, 0 },
+      { 23, 123, 240, 0 },
+      { 116, 156, 231, 0 },
+      { 7, 239, 116, 0 }, },
+    { { 115, 156, 232, 0 },
+      { 7, 189, 224, 1 },
+      { 11, 156, 231, 0 },
+      { 131, 222, 240, 0 }, },
+    { { 115, 156, 235, 1 },
+      { 15, 255, 224, 1 },
+      { 235, 156, 231, 0 },
+      { 131, 255, 248, 0 }, },
+    { { 115, 156, 228, 1 },
+      { 15, 189, 240, 0 },
+      { 147, 156, 231, 0 },
+      { 7, 222, 248, 0 }, },
+    { { 115, 156, 231, 0 },
+      { 7, 255, 240, 0 },
+      { 115, 156, 231, 0 },
+      { 7, 255, 240, 0 }, },
+};
+
+static unsigned char DICT_4X4_1000_BYTES[][4][2] =
+    { { { 181, 50 },
+        { 235, 72 },
+        { 76, 173 },
+        { 18, 215 }, },
+      { { 15, 154 },
+        { 101, 71 },
+        { 89, 240 },
+        { 226, 166 }, },
+      { { 51, 45 },
+        { 222, 17 },
+        { 180, 204 },
+        { 136, 123 }, },
+      { { 153, 70 },
+        { 193, 60 },
+        { 98, 153 },
+        { 60, 131 }, },
+      { { 84, 158 },
+        { 161, 211 },
+        { 121, 42 },
+        { 203, 133 }, },
+      { { 121, 205 },
+        { 216, 183 },
+        { 179, 158 },
+        { 237, 27 }, },
+      { { 158, 46 },
+        { 135, 93 },
+        { 116, 121 },
+        { 186, 225 }, },
+      { { 196, 242 },
+        { 35, 234 },
+        { 79, 35 },
+        { 87, 196 }, },
+      { { 254, 218 },
+        { 173, 239 },
+        { 91, 127 },
+        { 247, 181 }, },
+      { { 207, 86 },
+        { 101, 252 },
+        { 106, 243 },
+        { 63, 166 }, },
+      { { 249, 145 },
+        { 248, 142 },
+        { 137, 159 },
+        { 113, 31 }, },
+      { { 17, 167 },
+        { 211, 18 },
+        { 229, 136 },
+        { 72, 203 }, },
+      { { 14, 183 },
+        { 55, 86 },
+        { 237, 112 },
+        { 106, 236 }, },
+      { { 42, 15 },
+        { 29, 21 },
+        { 240, 84 },
+        { 168, 184 }, },
+      { { 36, 177 },
+        { 58, 66 },
+        { 141, 36 },
+        { 66, 92 }, },
+      { { 38, 62 },
+        { 47, 81 },
+        { 124, 100 },
+        { 138, 244 }, },
+      { { 70, 101 },
+        { 22, 240 },
+        { 166, 98 },
+        { 15, 104 }, },
+      { { 102, 0 },
+        { 12, 192 },
+        { 0, 102 },
+        { 3, 48 }, },
+      { { 108, 94 },
+        { 41, 245 },
+        { 122, 54 },
+        { 175, 148 }, },
+      { { 118, 175 },
+        { 159, 211 },
+        { 245, 110 },
+        { 203, 249 }, },
+      { { 134, 139 },
+        { 21, 75 },
+        { 209, 97 },
+        { 210, 168 }, },
+      { { 176, 43 },
+        { 155, 9 },
+        { 212, 13 },
+        { 144, 217 }, },
+      { { 204, 213 },
+        { 48, 254 },
+        { 171, 51 },
+        { 127, 12 }, },
+      { { 221, 130 },
+        { 193, 206 },
+        { 65, 187 },
+        { 115, 131 }, },
+      { { 254, 71 },
+        { 157, 252 },
+        { 226, 127 },
+        { 63, 185 }, },
+      { { 148, 113 },
+        { 178, 104 },
+        { 142, 41 },
+        { 22, 77 }, },
+      { { 172, 228 },
+        { 10, 126 },
+        { 39, 53 },
+        { 126, 80 }, },
+      { { 165, 84 },
+        { 104, 120 },
+        { 42, 165 },
+        { 30, 22 }, },
+      { { 33, 35 },
+        { 91, 0 },
+        { 196, 132 },
+        { 0, 218 }, },
+      { { 52, 111 },
+        { 155, 113 },
+        { 246, 44 },
+        { 142, 217 }, },
+      { { 68, 21 },
+        { 48, 208 },
+        { 168, 34 },
+        { 11, 12 }, },
+      { { 87, 178 },
+        { 231, 194 },
+        { 77, 234 },
+        { 67, 231 }, },
+      { { 158, 207 },
+        { 149, 127 },
+        { 243, 121 },
+        { 254, 169 }, },
+      { { 240, 203 },
+        { 153, 171 },
+        { 211, 15 },
+        { 213, 153 }, },
+      { { 8, 174 },
+        { 3, 23 },
+        { 117, 16 },
+        { 232, 192 }, },
+      { { 9, 41 },
+        { 82, 5 },
+        { 148, 144 },
+        { 160, 74 }, },
+      { { 24, 117 },
+        { 178, 52 },
+        { 174, 24 },
+        { 44, 77 }, },
+      { { 4, 255 },
+        { 51, 115 },
+        { 255, 32 },
+        { 206, 204 }, },
+      { { 13, 246 },
+        { 99, 118 },
+        { 111, 176 },
+        { 110, 198 }, },
+      { { 28, 90 },
+        { 161, 101 },
+        { 90, 56 },
+        { 166, 133 }, },
+      { { 23, 24 },
+        { 228, 65 },
+        { 24, 232 },
+        { 130, 39 }, },
+      { { 42, 40 },
+        { 14, 5 },
+        { 20, 84 },
+        { 160, 112 }, },
+      { { 50, 140 },
+        { 140, 19 },
+        { 49, 76 },
+        { 200, 49 }, },
+      { { 56, 178 },
+        { 171, 6 },
+        { 77, 28 },
+        { 96, 213 }, },
+      { { 36, 232 },
+        { 10, 99 },
+        { 23, 36 },
+        { 198, 80 }, },
+      { { 46, 235 },
+        { 31, 103 },
+        { 215, 116 },
+        { 230, 248 }, },
+      { { 45, 63 },
+        { 123, 85 },
+        { 252, 180 },
+        { 170, 222 }, },
+      { { 75, 100 },
+        { 70, 180 },
+        { 38, 210 },
+        { 45, 98 }, },
+      { { 80, 46 },
+        { 131, 145 },
+        { 116, 10 },
+        { 137, 193 }, },
+      { { 80, 19 },
+        { 177, 128 },
+        { 200, 10 },
+        { 1, 141 }, },
+      { { 81, 148 },
+        { 224, 146 },
+        { 41, 138 },
+        { 73, 7 }, },
+      { { 85, 104 },
+        { 194, 225 },
+        { 22, 170 },
+        { 135, 67 }, },
+      { { 93, 65 },
+        { 208, 228 },
+        { 130, 186 },
+        { 39, 11 }, },
+      { { 95, 151 },
+        { 245, 214 },
+        { 233, 250 },
+        { 107, 175 }, },
+      { { 104, 1 },
+        { 24, 132 },
+        { 128, 22 },
+        { 33, 24 }, },
+      { { 104, 103 },
+        { 27, 180 },
+        { 230, 22 },
+        { 45, 216 }, },
+      { { 97, 36 },
+        { 74, 144 },
+        { 36, 134 },
+        { 9, 82 }, },
+      { { 97, 233 },
+        { 90, 163 },
+        { 151, 134 },
+        { 197, 90 }, },
+      { { 107, 18 },
+        { 109, 132 },
+        { 72, 214 },
+        { 33, 182 }, },
+      { { 111, 229 },
+        { 94, 246 },
+        { 167, 246 },
+        { 111, 122 }, },
+      { { 103, 223 },
+        { 125, 243 },
+        { 251, 230 },
+        { 207, 190 }, },
+      { { 126, 27 },
+        { 189, 197 },
+        { 216, 126 },
+        { 163, 189 }, },
+      { { 128, 160 },
+        { 2, 10 },
+        { 5, 1 },
+        { 80, 64 }, },
+      { { 131, 68 },
+        { 68, 56 },
+        { 34, 193 },
+        { 28, 34 }, },
+      { { 139, 162 },
+        { 71, 14 },
+        { 69, 209 },
+        { 112, 226 }, },
+      { { 147, 122 },
+        { 231, 41 },
+        { 94, 201 },
+        { 148, 231 }, },
+      { { 132, 108 },
+        { 2, 121 },
+        { 54, 33 },
+        { 158, 64 }, },
+      { { 133, 42 },
+        { 67, 73 },
+        { 84, 161 },
+        { 146, 194 }, },
+      { { 133, 156 },
+        { 96, 91 },
+        { 57, 161 },
+        { 218, 6 }, },
+      { { 156, 137 },
+        { 144, 79 },
+        { 145, 57 },
+        { 242, 9 }, },
+      { { 159, 161 },
+        { 214, 78 },
+        { 133, 249 },
+        { 114, 107 }, },
+      { { 187, 124 },
+        { 238, 61 },
+        { 62, 221 },
+        { 188, 119 }, },
+      { { 188, 4 },
+        { 136, 92 },
+        { 32, 61 },
+        { 58, 17 }, },
+      { { 182, 91 },
+        { 189, 105 },
+        { 218, 109 },
+        { 150, 189 }, },
+      { { 191, 200 },
+        { 204, 111 },
+        { 19, 253 },
+        { 246, 51 }, },
+      { { 183, 171 },
+        { 223, 75 },
+        { 213, 237 },
+        { 210, 251 }, },
+      { { 202, 31 },
+        { 53, 157 },
+        { 248, 83 },
+        { 185, 172 }, },
+      { { 201, 98 },
+        { 67, 172 },
+        { 70, 147 },
+        { 53, 194 }, },
+      { { 217, 88 },
+        { 224, 173 },
+        { 26, 155 },
+        { 181, 7 }, },
+      { { 211, 213 },
+        { 244, 186 },
+        { 171, 203 },
+        { 93, 47 }, },
+      { { 204, 152 },
+        { 32, 207 },
+        { 25, 51 },
+        { 243, 4 }, },
+      { { 199, 160 },
+        { 70, 202 },
+        { 5, 227 },
+        { 83, 98 }, },
+      { { 197, 55 },
+        { 115, 216 },
+        { 236, 163 },
+        { 27, 206 }, },
+      { { 233, 93 },
+        { 120, 189 },
+        { 186, 151 },
+        { 189, 30 }, },
+      { { 249, 37 },
+        { 218, 156 },
+        { 164, 159 },
+        { 57, 91 }, },
+      { { 251, 187 },
+        { 255, 143 },
+        { 221, 223 },
+        { 241, 255 }, },
+      { { 238, 42 },
+        { 15, 205 },
+        { 84, 119 },
+        { 179, 240 }, },
+      { { 247, 77 },
+        { 220, 249 },
+        { 178, 239 },
+        { 159, 59 }, },
+      { { 53, 117 },
+        { 250, 112 },
+        { 174, 172 },
+        { 14, 95 }, },
+      { { 138, 173 },
+        { 22, 31 },
+        { 181, 81 },
+        { 248, 104 }, },
+      { { 118, 23 },
+        { 189, 208 },
+        { 232, 110 },
+        { 11, 189 }, },
+      { { 10, 207 },
+        { 21, 55 },
+        { 243, 80 },
+        { 236, 168 }, },
+      { { 6, 75 },
+        { 21, 97 },
+        { 210, 96 },
+        { 134, 168 }, },
+      { { 45, 193 },
+        { 88, 102 },
+        { 131, 180 },
+        { 102, 26 }, },
+      { { 73, 216 },
+        { 96, 167 },
+        { 27, 146 },
+        { 229, 6 }, },
+      { { 67, 244 },
+        { 102, 178 },
+        { 47, 194 },
+        { 77, 102 }, },
+      { { 79, 54 },
+        { 103, 212 },
+        { 108, 242 },
+        { 43, 230 }, },
+      { { 79, 211 },
+        { 117, 230 },
+        { 203, 242 },
+        { 103, 174 }, },
+      { { 105, 228 },
+        { 74, 182 },
+        { 39, 150 },
+        { 109, 82 }, },
+      { { 112, 199 },
+        { 153, 178 },
+        { 227, 14 },
+        { 77, 153 }, },
+      { { 122, 110 },
+        { 143, 181 },
+        { 118, 94 },
+        { 173, 241 }, },
+      { { 180, 234 },
+        { 139, 107 },
+        { 87, 45 },
+        { 214, 209 }, },
+      { { 237, 79 },
+        { 89, 253 },
+        { 242, 183 },
+        { 191, 154 }, },
+      { { 252, 231 },
+        { 155, 254 },
+        { 231, 63 },
+        { 127, 217 }, },
+      { { 254, 166 },
+        { 143, 222 },
+        { 101, 127 },
+        { 123, 241 }, },
+      { { 0, 37 },
+        { 18, 16 },
+        { 164, 0 },
+        { 8, 72 }, },
+      { { 0, 67 },
+        { 17, 32 },
+        { 194, 0 },
+        { 4, 136 }, },
+      { { 10, 136 },
+        { 4, 7 },
+        { 17, 80 },
+        { 224, 32 }, },
+      { { 10, 134 },
+        { 5, 22 },
+        { 97, 80 },
+        { 104, 160 }, },
+      { { 2, 111 },
+        { 23, 49 },
+        { 246, 64 },
+        { 140, 232 }, },
+      { { 0, 28 },
+        { 32, 17 },
+        { 56, 0 },
+        { 136, 4 }, },
+      { { 0, 151 },
+        { 49, 18 },
+        { 233, 0 },
+        { 72, 140 }, },
+      { { 8, 55 },
+        { 51, 20 },
+        { 236, 16 },
+        { 40, 204 }, },
+      { { 10, 49 },
+        { 54, 4 },
+        { 140, 80 },
+        { 32, 108 }, },
+      { { 9, 198 },
+        { 65, 54 },
+        { 99, 144 },
+        { 108, 130 }, },
+      { { 11, 1 },
+        { 84, 4 },
+        { 128, 208 },
+        { 32, 42 }, },
+      { { 9, 251 },
+        { 115, 39 },
+        { 223, 144 },
+        { 228, 206 }, },
+      { { 11, 88 },
+        { 100, 37 },
+        { 26, 208 },
+        { 164, 38 }, },
+      { { 16, 130 },
+        { 129, 2 },
+        { 65, 8 },
+        { 64, 129 }, },
+      { { 24, 45 },
+        { 146, 21 },
+        { 180, 24 },
+        { 168, 73 }, },
+      { { 16, 120 },
+        { 162, 33 },
+        { 30, 8 },
+        { 132, 69 }, },
+      { { 16, 115 },
+        { 179, 32 },
+        { 206, 8 },
+        { 4, 205 }, },
+      { { 18, 116 },
+        { 166, 48 },
+        { 46, 72 },
+        { 12, 101 }, },
+      { { 18, 177 },
+        { 182, 2 },
+        { 141, 72 },
+        { 64, 109 }, },
+      { { 26, 249 },
+        { 182, 39 },
+        { 159, 88 },
+        { 228, 109 }, },
+      { { 19, 6 },
+        { 197, 16 },
+        { 96, 200 },
+        { 8, 163 }, },
+      { { 12, 14 },
+        { 1, 85 },
+        { 112, 48 },
+        { 170, 128 }, },
+      { { 12, 241 },
+        { 50, 102 },
+        { 143, 48 },
+        { 102, 76 }, },
+      { { 4, 51 },
+        { 51, 64 },
+        { 204, 32 },
+        { 2, 204 }, },
+      { { 12, 159 },
+        { 49, 87 },
+        { 249, 48 },
+        { 234, 140 }, },
+      { { 14, 242 },
+        { 39, 102 },
+        { 79, 112 },
+        { 102, 228 }, },
+      { { 14, 253 },
+        { 54, 119 },
+        { 191, 112 },
+        { 238, 108 }, },
+      { { 7, 76 },
+        { 68, 113 },
+        { 50, 224 },
+        { 142, 34 }, },
+      { { 15, 164 },
+        { 70, 86 },
+        { 37, 240 },
+        { 106, 98 }, },
+      { { 7, 47 },
+        { 87, 81 },
+        { 244, 224 },
+        { 138, 234 }, },
+      { { 5, 181 },
+        { 114, 82 },
+        { 173, 160 },
+        { 74, 78 }, },
+      { { 15, 145 },
+        { 116, 70 },
+        { 137, 240 },
+        { 98, 46 }, },
+      { { 7, 219 },
+        { 117, 99 },
+        { 219, 224 },
+        { 198, 174 }, },
+      { { 30, 228 },
+        { 134, 118 },
+        { 39, 120 },
+        { 110, 97 }, },
+      { { 20, 57 },
+        { 178, 65 },
+        { 156, 40 },
+        { 130, 77 }, },
+      { { 29, 128 },
+        { 192, 70 },
+        { 1, 184 },
+        { 98, 3 }, },
+      { { 21, 200 },
+        { 192, 99 },
+        { 19, 168 },
+        { 198, 3 }, },
+      { { 31, 139 },
+        { 213, 71 },
+        { 209, 248 },
+        { 226, 171 }, },
+      { { 21, 186 },
+        { 227, 67 },
+        { 93, 168 },
+        { 194, 199 }, },
+      { { 29, 177 },
+        { 242, 70 },
+        { 141, 184 },
+        { 98, 79 }, },
+      { { 32, 128 },
+        { 8, 2 },
+        { 1, 4 },
+        { 64, 16 }, },
+      { { 40, 233 },
+        { 26, 39 },
+        { 151, 20 },
+        { 228, 88 }, },
+      { { 34, 162 },
+        { 15, 2 },
+        { 69, 68 },
+        { 64, 240 }, },
+      { { 40, 83 },
+        { 57, 36 },
+        { 202, 20 },
+        { 36, 156 }, },
+      { { 42, 240 },
+        { 46, 38 },
+        { 15, 84 },
+        { 100, 116 }, },
+      { { 34, 247 },
+        { 63, 50 },
+        { 239, 68 },
+        { 76, 252 }, },
+      { { 41, 64 },
+        { 72, 36 },
+        { 2, 148 },
+        { 36, 18 }, },
+      { { 33, 70 },
+        { 73, 48 },
+        { 98, 132 },
+        { 12, 146 }, },
+      { { 41, 185 },
+        { 122, 7 },
+        { 157, 148 },
+        { 224, 94 }, },
+      { { 43, 156 },
+        { 108, 23 },
+        { 57, 212 },
+        { 232, 54 }, },
+      { { 43, 178 },
+        { 111, 6 },
+        { 77, 212 },
+        { 96, 246 }, },
+      { { 56, 202 },
+        { 137, 39 },
+        { 83, 28 },
+        { 228, 145 }, },
+      { { 56, 46 },
+        { 139, 21 },
+        { 116, 28 },
+        { 168, 209 }, },
+      { { 48, 7 },
+        { 153, 16 },
+        { 224, 12 },
+        { 8, 153 }, },
+      { { 56, 231 },
+        { 155, 54 },
+        { 231, 28 },
+        { 108, 217 }, },
+      { { 58, 73 },
+        { 156, 37 },
+        { 146, 92 },
+        { 164, 57 }, },
+      { { 58, 101 },
+        { 158, 52 },
+        { 166, 92 },
+        { 44, 121 }, },
+      { { 50, 93 },
+        { 188, 49 },
+        { 186, 76 },
+        { 140, 61 }, },
+      { { 59, 136 },
+        { 204, 7 },
+        { 17, 220 },
+        { 224, 51 }, },
+      { { 57, 29 },
+        { 248, 21 },
+        { 184, 156 },
+        { 168, 31 }, },
+      { { 59, 211 },
+        { 253, 38 },
+        { 203, 220 },
+        { 100, 191 }, },
+      { { 38, 71 },
+        { 29, 112 },
+        { 226, 100 },
+        { 14, 184 }, },
+      { { 39, 128 },
+        { 76, 66 },
+        { 1, 228 },
+        { 66, 50 }, },
+      { { 47, 170 },
+        { 79, 71 },
+        { 85, 244 },
+        { 226, 242 }, },
+      { { 45, 20 },
+        { 104, 84 },
+        { 40, 180 },
+        { 42, 22 }, },
+      { { 37, 222 },
+        { 105, 115 },
+        { 123, 164 },
+        { 206, 150 }, },
+      { { 37, 83 },
+        { 121, 96 },
+        { 202, 164 },
+        { 6, 158 }, },
+      { { 47, 119 },
+        { 127, 116 },
+        { 238, 244 },
+        { 46, 254 }, },
+      { { 52, 72 },
+        { 136, 97 },
+        { 18, 44 },
+        { 134, 17 }, },
+      { { 60, 168 },
+        { 138, 71 },
+        { 21, 60 },
+        { 226, 81 }, },
+      { { 60, 65 },
+        { 152, 100 },
+        { 130, 60 },
+        { 38, 25 }, },
+      { { 52, 13 },
+        { 152, 81 },
+        { 176, 44 },
+        { 138, 25 }, },
+      { { 52, 251 },
+        { 187, 99 },
+        { 223, 44 },
+        { 198, 221 }, },
+      { { 54, 154 },
+        { 173, 67 },
+        { 89, 108 },
+        { 194, 181 }, },
+      { { 61, 224 },
+        { 202, 102 },
+        { 7, 188 },
+        { 102, 83 }, },
+      { { 53, 106 },
+        { 203, 97 },
+        { 86, 172 },
+        { 134, 211 }, },
+      { { 61, 9 },
+        { 216, 69 },
+        { 144, 188 },
+        { 162, 27 }, },
+      { { 61, 237 },
+        { 218, 119 },
+        { 183, 188 },
+        { 238, 91 }, },
+      { { 63, 196 },
+        { 204, 118 },
+        { 35, 252 },
+        { 110, 51 }, },
+      { { 63, 108 },
+        { 206, 117 },
+        { 54, 252 },
+        { 174, 115 }, },
+      { { 55, 206 },
+        { 205, 115 },
+        { 115, 236 },
+        { 206, 179 }, },
+      { { 61, 92 },
+        { 232, 117 },
+        { 58, 188 },
+        { 174, 23 }, },
+      { { 61, 118 },
+        { 235, 116 },
+        { 110, 188 },
+        { 46, 215 }, },
+      { { 55, 176 },
+        { 238, 66 },
+        { 13, 236 },
+        { 66, 119 }, },
+      { { 63, 23 },
+        { 253, 84 },
+        { 232, 252 },
+        { 42, 191 }, },
+      { { 63, 255 },
+        { 255, 119 },
+        { 255, 252 },
+        { 238, 255 }, },
+      { { 72, 229 },
+        { 18, 182 },
+        { 167, 18 },
+        { 109, 72 }, },
+      { { 66, 104 },
+        { 6, 161 },
+        { 22, 66 },
+        { 133, 96 }, },
+      { { 74, 45 },
+        { 22, 149 },
+        { 180, 82 },
+        { 169, 104 }, },
+      { { 65, 96 },
+        { 66, 160 },
+        { 6, 130 },
+        { 5, 66 }, },
+      { { 73, 81 },
+        { 112, 164 },
+        { 138, 146 },
+        { 37, 14 }, },
+      { { 65, 221 },
+        { 112, 179 },
+        { 187, 130 },
+        { 205, 14 }, },
+      { { 75, 223 },
+        { 117, 183 },
+        { 251, 210 },
+        { 237, 174 }, },
+      { { 88, 79 },
+        { 145, 181 },
+        { 242, 26 },
+        { 173, 137 }, },
+      { { 90, 72 },
+        { 132, 165 },
+        { 18, 90 },
+        { 165, 33 }, },
+      { { 88, 22 },
+        { 161, 148 },
+        { 104, 26 },
+        { 41, 133 }, },
+      { { 80, 93 },
+        { 176, 177 },
+        { 186, 10 },
+        { 141, 13 }, },
+      { { 90, 250 },
+        { 167, 167 },
+        { 95, 90 },
+        { 229, 229 }, },
+      { { 90, 181 },
+        { 182, 150 },
+        { 173, 90 },
+        { 105, 109 }, },
+      { { 81, 35 },
+        { 211, 128 },
+        { 196, 138 },
+        { 1, 203 }, },
+      { { 91, 138 },
+        { 197, 135 },
+        { 81, 218 },
+        { 225, 163 }, },
+      { { 89, 25 },
+        { 240, 133 },
+        { 152, 154 },
+        { 161, 15 }, },
+      { { 81, 53 },
+        { 242, 144 },
+        { 172, 138 },
+        { 9, 79 }, },
+      { { 76, 105 },
+        { 18, 229 },
+        { 150, 50 },
+        { 167, 72 }, },
+      { { 70, 193 },
+        { 20, 226 },
+        { 131, 98 },
+        { 71, 40 }, },
+      { { 78, 11 },
+        { 21, 197 },
+        { 208, 114 },
+        { 163, 168 }, },
+      { { 68, 95 },
+        { 49, 241 },
+        { 250, 34 },
+        { 143, 140 }, },
+      { { 78, 89 },
+        { 52, 229 },
+        { 154, 114 },
+        { 167, 44 }, },
+      { { 77, 131 },
+        { 81, 198 },
+        { 193, 178 },
+        { 99, 138 }, },
+      { { 77, 125 },
+        { 114, 245 },
+        { 190, 178 },
+        { 175, 78 }, },
+      { { 71, 216 },
+        { 100, 227 },
+        { 27, 226 },
+        { 199, 38 }, },
+      { { 71, 115 },
+        { 119, 224 },
+        { 206, 226 },
+        { 7, 238 }, },
+      { { 92, 133 },
+        { 144, 214 },
+        { 161, 58 },
+        { 107, 9 }, },
+      { { 94, 68 },
+        { 132, 244 },
+        { 34, 122 },
+        { 47, 33 }, },
+      { { 86, 43 },
+        { 151, 193 },
+        { 212, 106 },
+        { 131, 233 }, },
+      { { 92, 187 },
+        { 179, 199 },
+        { 221, 58 },
+        { 227, 205 }, },
+      { { 85, 195 },
+        { 209, 226 },
+        { 195, 170 },
+        { 71, 139 }, },
+      { { 95, 110 },
+        { 199, 245 },
+        { 118, 250 },
+        { 175, 227 }, },
+      { { 95, 235 },
+        { 215, 231 },
+        { 215, 250 },
+        { 231, 235 }, },
+      { { 93, 18 },
+        { 225, 196 },
+        { 72, 186 },
+        { 35, 135 }, },
+      { { 85, 94 },
+        { 225, 241 },
+        { 122, 170 },
+        { 143, 135 }, },
+      { { 98, 112 },
+        { 46, 160 },
+        { 14, 70 },
+        { 5, 116 }, },
+      { { 98, 21 },
+        { 60, 144 },
+        { 168, 70 },
+        { 9, 60 }, },
+      { { 97, 194 },
+        { 73, 162 },
+        { 67, 134 },
+        { 69, 146 }, },
+      { { 107, 32 },
+        { 78, 132 },
+        { 4, 214 },
+        { 33, 114 }, },
+      { { 99, 69 },
+        { 92, 176 },
+        { 162, 198 },
+        { 13, 58 }, },
+      { { 107, 92 },
+        { 108, 181 },
+        { 58, 214 },
+        { 173, 54 }, },
+      { { 107, 91 },
+        { 125, 165 },
+        { 218, 214 },
+        { 165, 190 }, },
+      { { 120, 12 },
+        { 136, 149 },
+        { 48, 30 },
+        { 169, 17 }, },
+      { { 122, 207 },
+        { 157, 183 },
+        { 243, 94 },
+        { 237, 185 }, },
+      { { 120, 127 },
+        { 187, 181 },
+        { 254, 30 },
+        { 173, 221 }, },
+      { { 121, 128 },
+        { 200, 134 },
+        { 1, 158 },
+        { 97, 19 }, },
+      { { 113, 229 },
+        { 218, 178 },
+        { 167, 142 },
+        { 77, 91 }, },
+      { { 113, 116 },
+        { 234, 176 },
+        { 46, 142 },
+        { 13, 87 }, },
+      { { 121, 182 },
+        { 235, 150 },
+        { 109, 158 },
+        { 105, 215 }, },
+      { { 113, 211 },
+        { 249, 162 },
+        { 203, 142 },
+        { 69, 159 }, },
+      { { 123, 51 },
+        { 255, 132 },
+        { 204, 222 },
+        { 33, 255 }, },
+      { { 100, 106 },
+        { 11, 225 },
+        { 86, 38 },
+        { 135, 208 }, },
+      { { 102, 168 },
+        { 14, 195 },
+        { 21, 102 },
+        { 195, 112 }, },
+      { { 110, 167 },
+        { 31, 214 },
+        { 229, 118 },
+        { 107, 248 }, },
+      { { 110, 145 },
+        { 60, 198 },
+        { 137, 118 },
+        { 99, 60 }, },
+      { { 101, 34 },
+        { 75, 192 },
+        { 68, 166 },
+        { 3, 210 }, },
+      { { 109, 203 },
+        { 89, 231 },
+        { 211, 182 },
+        { 231, 154 }, },
+      { { 103, 141 },
+        { 92, 211 },
+        { 177, 230 },
+        { 203, 58 }, },
+      { { 109, 49 },
+        { 122, 196 },
+        { 140, 182 },
+        { 35, 94 }, },
+      { { 126, 128 },
+        { 140, 198 },
+        { 1, 126 },
+        { 99, 49 }, },
+      { { 126, 226 },
+        { 143, 230 },
+        { 71, 126 },
+        { 103, 241 }, },
+      { { 126, 141 },
+        { 156, 215 },
+        { 177, 126 },
+        { 235, 57 }, },
+      { { 116, 210 },
+        { 169, 226 },
+        { 75, 46 },
+        { 71, 149 }, },
+      { { 124, 50 },
+        { 171, 196 },
+        { 76, 62 },
+        { 35, 213 }, },
+      { { 126, 53 },
+        { 190, 212 },
+        { 172, 126 },
+        { 43, 125 }, },
+      { { 117, 171 },
+        { 219, 195 },
+        { 213, 174 },
+        { 195, 219 }, },
+      { { 119, 5 },
+        { 220, 208 },
+        { 160, 238 },
+        { 11, 59 }, },
+      { { 127, 43 },
+        { 223, 197 },
+        { 212, 254 },
+        { 163, 251 }, },
+      { { 125, 218 },
+        { 233, 231 },
+        { 91, 190 },
+        { 231, 151 }, },
+      { { 127, 146 },
+        { 237, 198 },
+        { 73, 254 },
+        { 99, 183 }, },
+      { { 128, 117 },
+        { 50, 56 },
+        { 174, 1 },
+        { 28, 76 }, },
+      { { 128, 243 },
+        { 51, 42 },
+        { 207, 1 },
+        { 84, 204 }, },
+      { { 129, 166 },
+        { 67, 26 },
+        { 101, 129 },
+        { 88, 194 }, },
+      { { 137, 237 },
+        { 82, 63 },
+        { 183, 145 },
+        { 252, 74 }, },
+      { { 129, 252 },
+        { 98, 59 },
+        { 63, 129 },
+        { 220, 70 }, },
+      { { 152, 166 },
+        { 131, 30 },
+        { 101, 25 },
+        { 120, 193 }, },
+      { { 154, 32 },
+        { 134, 12 },
+        { 4, 89 },
+        { 48, 97 }, },
+      { { 145, 67 },
+        { 209, 40 },
+        { 194, 137 },
+        { 20, 139 }, },
+      { { 153, 249 },
+        { 242, 47 },
+        { 159, 153 },
+        { 244, 79 }, },
+      { { 145, 147 },
+        { 241, 10 },
+        { 201, 137 },
+        { 80, 143 }, },
+      { { 155, 212 },
+        { 228, 62 },
+        { 43, 217 },
+        { 124, 39 }, },
+      { { 132, 9 },
+        { 16, 73 },
+        { 144, 33 },
+        { 146, 8 }, },
+      { { 132, 107 },
+        { 19, 105 },
+        { 214, 33 },
+        { 150, 200 }, },
+      { { 134, 196 },
+        { 4, 122 },
+        { 35, 97 },
+        { 94, 32 }, },
+      { { 142, 100 },
+        { 6, 124 },
+        { 38, 113 },
+        { 62, 96 }, },
+      { { 134, 26 },
+        { 37, 73 },
+        { 88, 97 },
+        { 146, 164 }, },
+      { { 133, 78 },
+        { 65, 121 },
+        { 114, 161 },
+        { 158, 130 }, },
+      { { 141, 203 },
+        { 81, 111 },
+        { 211, 177 },
+        { 246, 138 }, },
+      { { 133, 103 },
+        { 83, 120 },
+        { 230, 161 },
+        { 30, 202 }, },
+      { { 133, 175 },
+        { 83, 91 },
+        { 245, 161 },
+        { 218, 202 }, },
+      { { 133, 215 },
+        { 113, 122 },
+        { 235, 161 },
+        { 94, 142 }, },
+      { { 135, 179 },
+        { 119, 74 },
+        { 205, 225 },
+        { 82, 238 }, },
+      { { 156, 225 },
+        { 146, 110 },
+        { 135, 57 },
+        { 118, 73 }, },
+      { { 156, 242 },
+        { 163, 110 },
+        { 79, 57 },
+        { 118, 197 }, },
+      { { 148, 23 },
+        { 177, 88 },
+        { 232, 41 },
+        { 26, 141 }, },
+      { { 149, 0 },
+        { 192, 72 },
+        { 0, 169 },
+        { 18, 3 }, },
+      { { 149, 162 },
+        { 195, 74 },
+        { 69, 169 },
+        { 82, 195 }, },
+      { { 157, 35 },
+        { 211, 76 },
+        { 196, 185 },
+        { 50, 203 }, },
+      { { 159, 98 },
+        { 199, 108 },
+        { 70, 249 },
+        { 54, 227 }, },
+      { { 157, 82 },
+        { 225, 108 },
+        { 74, 185 },
+        { 54, 135 }, },
+      { { 149, 218 },
+        { 225, 107 },
+        { 91, 169 },
+        { 214, 135 }, },
+      { { 160, 197 },
+        { 24, 58 },
+        { 163, 5 },
+        { 92, 24 }, },
+      { { 170, 205 },
+        { 28, 63 },
+        { 179, 85 },
+        { 252, 56 }, },
+      { { 162, 216 },
+        { 44, 43 },
+        { 27, 69 },
+        { 212, 52 }, },
+      { { 162, 87 },
+        { 61, 56 },
+        { 234, 69 },
+        { 28, 188 }, },
+      { { 169, 61 },
+        { 122, 29 },
+        { 188, 149 },
+        { 184, 94 }, },
+      { { 169, 87 },
+        { 121, 60 },
+        { 234, 149 },
+        { 60, 158 }, },
+      { { 171, 82 },
+        { 109, 44 },
+        { 74, 213 },
+        { 52, 182 }, },
+      { { 163, 54 },
+        { 111, 24 },
+        { 108, 197 },
+        { 24, 246 }, },
+      { { 163, 89 },
+        { 124, 41 },
+        { 154, 197 },
+        { 148, 62 }, },
+      { { 176, 244 },
+        { 170, 58 },
+        { 47, 13 },
+        { 92, 85 }, },
+      { { 184, 18 },
+        { 169, 12 },
+        { 72, 29 },
+        { 48, 149 }, },
+      { { 176, 191 },
+        { 187, 27 },
+        { 253, 13 },
+        { 216, 221 }, },
+      { { 178, 157 },
+        { 188, 27 },
+        { 185, 77 },
+        { 216, 61 }, },
+      { { 187, 237 },
+        { 222, 63 },
+        { 183, 221 },
+        { 252, 123 }, },
+      { { 185, 114 },
+        { 235, 44 },
+        { 78, 157 },
+        { 52, 215 }, },
+      { { 185, 150 },
+        { 233, 30 },
+        { 105, 157 },
+        { 120, 151 }, },
+      { { 164, 195 },
+        { 25, 106 },
+        { 195, 37 },
+        { 86, 152 }, },
+      { { 172, 210 },
+        { 41, 110 },
+        { 75, 53 },
+        { 118, 148 }, },
+      { { 174, 177 },
+        { 62, 78 },
+        { 141, 117 },
+        { 114, 124 }, },
+      { { 165, 130 },
+        { 73, 74 },
+        { 65, 165 },
+        { 82, 146 }, },
+      { { 175, 101 },
+        { 94, 124 },
+        { 166, 245 },
+        { 62, 122 }, },
+      { { 165, 123 },
+        { 123, 105 },
+        { 222, 165 },
+        { 150, 222 }, },
+      { { 175, 250 },
+        { 111, 111 },
+        { 95, 245 },
+        { 246, 246 }, },
+      { { 180, 100 },
+        { 138, 120 },
+        { 38, 45 },
+        { 30, 81 }, },
+      { { 188, 98 },
+        { 139, 108 },
+        { 70, 61 },
+        { 54, 209 }, },
+      { { 180, 129 },
+        { 152, 74 },
+        { 129, 45 },
+        { 82, 25 }, },
+      { { 182, 160 },
+        { 142, 74 },
+        { 5, 109 },
+        { 82, 113 }, },
+      { { 190, 238 },
+        { 143, 127 },
+        { 119, 125 },
+        { 254, 241 }, },
+      { { 190, 13 },
+        { 156, 93 },
+        { 176, 125 },
+        { 186, 57 }, },
+      { { 188, 217 },
+        { 184, 111 },
+        { 155, 61 },
+        { 246, 29 }, },
+      { { 190, 248 },
+        { 174, 111 },
+        { 31, 125 },
+        { 246, 117 }, },
+      { { 181, 40 },
+        { 202, 73 },
+        { 20, 173 },
+        { 146, 83 }, },
+      { { 183, 9 },
+        { 220, 73 },
+        { 144, 237 },
+        { 146, 59 }, },
+      { { 183, 210 },
+        { 237, 106 },
+        { 75, 237 },
+        { 86, 183 }, },
+      { { 192, 234 },
+        { 3, 171 },
+        { 87, 3 },
+        { 213, 192 }, },
+      { { 192, 25 },
+        { 48, 137 },
+        { 152, 3 },
+        { 145, 12 }, },
+      { { 192, 253 },
+        { 50, 187 },
+        { 191, 3 },
+        { 221, 76 }, },
+      { { 200, 211 },
+        { 49, 174 },
+        { 203, 19 },
+        { 117, 140 }, },
+      { { 202, 90 },
+        { 37, 173 },
+        { 90, 83 },
+        { 181, 164 }, },
+      { { 193, 77 },
+        { 80, 185 },
+        { 178, 131 },
+        { 157, 10 }, },
+      { { 201, 180 },
+        { 98, 158 },
+        { 45, 147 },
+        { 121, 70 }, },
+      { { 193, 87 },
+        { 113, 184 },
+        { 234, 131 },
+        { 29, 142 }, },
+      { { 195, 152 },
+        { 100, 139 },
+        { 25, 195 },
+        { 209, 38 }, },
+      { { 195, 29 },
+        { 116, 153 },
+        { 184, 195 },
+        { 153, 46 }, },
+      { { 216, 128 },
+        { 128, 142 },
+        { 1, 27 },
+        { 113, 1 }, },
+      { { 216, 239 },
+        { 147, 191 },
+        { 247, 27 },
+        { 253, 201 }, },
+      { { 218, 43 },
+        { 151, 141 },
+        { 212, 91 },
+        { 177, 233 }, },
+      { { 208, 30 },
+        { 161, 153 },
+        { 120, 11 },
+        { 153, 133 }, },
+      { { 209, 5 },
+        { 208, 152 },
+        { 160, 139 },
+        { 25, 11 }, },
+      { { 211, 173 },
+        { 214, 155 },
+        { 181, 203 },
+        { 217, 107 }, },
+      { { 219, 167 },
+        { 215, 158 },
+        { 229, 219 },
+        { 121, 235 }, },
+      { { 196, 201 },
+        { 16, 235 },
+        { 147, 35 },
+        { 215, 8 }, },
+      { { 204, 120 },
+        { 34, 237 },
+        { 30, 51 },
+        { 183, 68 }, },
+      { { 205, 69 },
+        { 80, 252 },
+        { 162, 179 },
+        { 63, 10 }, },
+      { { 197, 11 },
+        { 81, 201 },
+        { 208, 163 },
+        { 147, 138 }, },
+      { { 207, 207 },
+        { 85, 255 },
+        { 243, 243 },
+        { 255, 170 }, },
+      { { 220, 172 },
+        { 130, 223 },
+        { 53, 59 },
+        { 251, 65 }, },
+      { { 212, 2 },
+        { 129, 200 },
+        { 64, 43 },
+        { 19, 129 }, },
+      { { 220, 99 },
+        { 147, 236 },
+        { 198, 59 },
+        { 55, 201 }, },
+      { { 212, 39 },
+        { 147, 216 },
+        { 228, 43 },
+        { 27, 201 }, },
+      { { 212, 245 },
+        { 178, 250 },
+        { 175, 43 },
+        { 95, 77 }, },
+      { { 214, 120 },
+        { 166, 233 },
+        { 30, 107 },
+        { 151, 101 }, },
+      { { 222, 184 },
+        { 166, 207 },
+        { 29, 123 },
+        { 243, 101 }, },
+      { { 221, 230 },
+        { 195, 254 },
+        { 103, 187 },
+        { 127, 195 }, },
+      { { 213, 93 },
+        { 240, 249 },
+        { 186, 171 },
+        { 159, 15 }, },
+      { { 221, 189 },
+        { 242, 223 },
+        { 189, 187 },
+        { 251, 79 }, },
+      { { 223, 29 },
+        { 244, 221 },
+        { 184, 251 },
+        { 187, 47 }, },
+      { { 226, 202 },
+        { 13, 171 },
+        { 83, 71 },
+        { 213, 176 }, },
+      { { 234, 107 },
+        { 31, 173 },
+        { 214, 87 },
+        { 181, 248 }, },
+      { { 224, 180 },
+        { 42, 154 },
+        { 45, 7 },
+        { 89, 84 }, },
+      { { 226, 56 },
+        { 46, 137 },
+        { 28, 71 },
+        { 145, 116 }, },
+      { { 226, 212 },
+        { 44, 186 },
+        { 43, 71 },
+        { 93, 52 }, },
+      { { 227, 34 },
+        { 79, 136 },
+        { 68, 199 },
+        { 17, 242 }, },
+      { { 225, 216 },
+        { 104, 171 },
+        { 27, 135 },
+        { 213, 22 }, },
+      { { 240, 3 },
+        { 153, 136 },
+        { 192, 15 },
+        { 17, 153 }, },
+      { { 242, 204 },
+        { 140, 187 },
+        { 51, 79 },
+        { 221, 49 }, },
+      { { 248, 246 },
+        { 171, 190 },
+        { 111, 31 },
+        { 125, 213 }, },
+      { { 241, 73 },
+        { 216, 169 },
+        { 146, 143 },
+        { 149, 27 }, },
+      { { 243, 234 },
+        { 207, 171 },
+        { 87, 207 },
+        { 213, 243 }, },
+      { { 241, 156 },
+        { 232, 155 },
+        { 57, 143 },
+        { 217, 23 }, },
+      { { 249, 245 },
+        { 250, 190 },
+        { 175, 159 },
+        { 125, 95 }, },
+      { { 241, 59 },
+        { 251, 137 },
+        { 220, 143 },
+        { 145, 223 }, },
+      { { 236, 141 },
+        { 24, 223 },
+        { 177, 55 },
+        { 251, 24 }, },
+      { { 238, 201 },
+        { 28, 239 },
+        { 147, 119 },
+        { 247, 56 }, },
+      { { 230, 15 },
+        { 29, 217 },
+        { 240, 103 },
+        { 155, 184 }, },
+      { { 228, 247 },
+        { 59, 250 },
+        { 239, 39 },
+        { 95, 220 }, },
+      { { 231, 96 },
+        { 78, 232 },
+        { 6, 231 },
+        { 23, 114 }, },
+      { { 239, 232 },
+        { 78, 239 },
+        { 23, 247 },
+        { 247, 114 }, },
+      { { 237, 178 },
+        { 107, 206 },
+        { 77, 183 },
+        { 115, 214 }, },
+      { { 229, 21 },
+        { 120, 216 },
+        { 168, 167 },
+        { 27, 30 }, },
+      { { 239, 209 },
+        { 124, 238 },
+        { 139, 247 },
+        { 119, 62 }, },
+      { { 244, 134 },
+        { 137, 218 },
+        { 97, 47 },
+        { 91, 145 }, },
+      { { 252, 1 },
+        { 152, 204 },
+        { 128, 63 },
+        { 51, 25 }, },
+      { { 246, 195 },
+        { 157, 234 },
+        { 195, 111 },
+        { 87, 185 }, },
+      { { 244, 124 },
+        { 170, 249 },
+        { 62, 47 },
+        { 159, 85 }, },
+      { { 252, 147 },
+        { 185, 206 },
+        { 201, 63 },
+        { 115, 157 }, },
+      { { 245, 66 },
+        { 201, 232 },
+        { 66, 175 },
+        { 23, 147 }, },
+      { { 253, 152 },
+        { 232, 207 },
+        { 25, 191 },
+        { 243, 23 }, },
+      { { 245, 61 },
+        { 250, 217 },
+        { 188, 175 },
+        { 155, 95 }, },
+      { { 2, 189 },
+        { 54, 19 },
+        { 189, 64 },
+        { 200, 108 }, },
+      { { 0, 225 },
+        { 18, 34 },
+        { 135, 0 },
+        { 68, 72 }, },
+      { { 2, 226 },
+        { 7, 34 },
+        { 71, 64 },
+        { 68, 224 }, },
+      { { 2, 174 },
+        { 7, 19 },
+        { 117, 64 },
+        { 200, 224 }, },
+      { { 8, 120 },
+        { 34, 37 },
+        { 30, 16 },
+        { 164, 68 }, },
+      { { 0, 116 },
+        { 34, 48 },
+        { 46, 0 },
+        { 12, 68 }, },
+      { { 8, 158 },
+        { 33, 23 },
+        { 121, 16 },
+        { 232, 132 }, },
+      { { 8, 209 },
+        { 48, 38 },
+        { 139, 16 },
+        { 100, 12 }, },
+      { { 8, 125 },
+        { 50, 53 },
+        { 190, 16 },
+        { 172, 76 }, },
+      { { 10, 50 },
+        { 39, 4 },
+        { 76, 80 },
+        { 32, 228 }, },
+      { { 10, 222 },
+        { 37, 55 },
+        { 123, 80 },
+        { 236, 164 }, },
+      { { 2, 81 },
+        { 52, 32 },
+        { 138, 64 },
+        { 4, 44 }, },
+      { { 1, 162 },
+        { 67, 2 },
+        { 69, 128 },
+        { 64, 194 }, },
+      { { 3, 128 },
+        { 68, 2 },
+        { 1, 192 },
+        { 64, 34 }, },
+      { { 11, 131 },
+        { 85, 6 },
+        { 193, 208 },
+        { 96, 170 }, },
+      { { 11, 75 },
+        { 85, 37 },
+        { 210, 208 },
+        { 164, 170 }, },
+      { { 11, 39 },
+        { 87, 20 },
+        { 228, 208 },
+        { 40, 234 }, },
+      { { 11, 239 },
+        { 87, 55 },
+        { 247, 208 },
+        { 236, 234 }, },
+      { { 9, 182 },
+        { 99, 22 },
+        { 109, 144 },
+        { 104, 198 }, },
+      { { 9, 89 },
+        { 112, 37 },
+        { 154, 144 },
+        { 164, 14 }, },
+      { { 9, 147 },
+        { 113, 6 },
+        { 201, 144 },
+        { 96, 142 }, },
+      { { 11, 248 },
+        { 102, 39 },
+        { 31, 208 },
+        { 228, 102 }, },
+      { { 3, 217 },
+        { 116, 35 },
+        { 155, 192 },
+        { 196, 46 }, },
+      { { 3, 241 },
+        { 118, 34 },
+        { 143, 192 },
+        { 68, 110 }, },
+      { { 16, 196 },
+        { 128, 50 },
+        { 35, 8 },
+        { 76, 1 }, },
+      { { 24, 171 },
+        { 147, 7 },
+        { 213, 24 },
+        { 224, 201 }, },
+      { { 26, 160 },
+        { 134, 6 },
+        { 5, 88 },
+        { 96, 97 }, },
+      { { 26, 4 },
+        { 132, 20 },
+        { 32, 88 },
+        { 40, 33 }, },
+      { { 26, 108 },
+        { 134, 53 },
+        { 54, 88 },
+        { 172, 97 }, },
+      { { 26, 174 },
+        { 135, 23 },
+        { 117, 88 },
+        { 232, 225 }, },
+      { { 18, 137 },
+        { 148, 3 },
+        { 145, 72 },
+        { 192, 41 }, },
+      { { 16, 23 },
+        { 177, 16 },
+        { 232, 8 },
+        { 8, 141 }, },
+      { { 26, 243 },
+        { 183, 38 },
+        { 207, 88 },
+        { 100, 237 }, },
+      { { 25, 64 },
+        { 192, 36 },
+        { 2, 152 },
+        { 36, 3 }, },
+      { { 17, 2 },
+        { 193, 0 },
+        { 64, 136 },
+        { 0, 131 }, },
+      { { 17, 43 },
+        { 211, 1 },
+        { 212, 136 },
+        { 128, 203 }, },
+      { { 17, 207 },
+        { 209, 51 },
+        { 243, 136 },
+        { 204, 139 }, },
+      { { 27, 34 },
+        { 199, 4 },
+        { 68, 216 },
+        { 32, 227 }, },
+      { { 19, 46 },
+        { 199, 17 },
+        { 116, 200 },
+        { 136, 227 }, },
+      { { 17, 21 },
+        { 240, 16 },
+        { 168, 136 },
+        { 8, 15 }, },
+      { { 19, 187 },
+        { 247, 3 },
+        { 221, 200 },
+        { 192, 239 }, },
+      { { 12, 32 },
+        { 2, 68 },
+        { 4, 48 },
+        { 34, 64 }, },
+      { { 12, 201 },
+        { 16, 103 },
+        { 147, 48 },
+        { 230, 8 }, },
+      { { 12, 220 },
+        { 32, 119 },
+        { 59, 48 },
+        { 238, 4 }, },
+      { { 12, 54 },
+        { 35, 84 },
+        { 108, 48 },
+        { 42, 196 }, },
+      { { 6, 20 },
+        { 36, 80 },
+        { 40, 96 },
+        { 10, 36 }, },
+      { { 6, 114 },
+        { 39, 96 },
+        { 78, 96 },
+        { 6, 228 }, },
+      { { 13, 97 },
+        { 82, 100 },
+        { 134, 176 },
+        { 38, 74 }, },
+      { { 5, 13 },
+        { 80, 81 },
+        { 176, 160 },
+        { 138, 10 }, },
+      { { 13, 143 },
+        { 81, 87 },
+        { 241, 176 },
+        { 234, 138 }, },
+      { { 15, 224 },
+        { 70, 102 },
+        { 7, 240 },
+        { 102, 98 }, },
+      { { 15, 73 },
+        { 84, 101 },
+        { 146, 240 },
+        { 166, 42 }, },
+      { { 7, 133 },
+        { 84, 82 },
+        { 161, 224 },
+        { 74, 42 }, },
+      { { 5, 144 },
+        { 96, 66 },
+        { 9, 160 },
+        { 66, 6 }, },
+      { { 13, 51 },
+        { 115, 68 },
+        { 204, 176 },
+        { 34, 206 }, },
+      { { 15, 150 },
+        { 101, 86 },
+        { 105, 240 },
+        { 106, 166 }, },
+      { { 15, 118 },
+        { 103, 116 },
+        { 110, 240 },
+        { 46, 230 }, },
+      { { 20, 96 },
+        { 130, 96 },
+        { 6, 40 },
+        { 6, 65 }, },
+      { { 28, 141 },
+        { 144, 87 },
+        { 177, 56 },
+        { 234, 9 }, },
+      { { 20, 218 },
+        { 161, 99 },
+        { 91, 40 },
+        { 198, 133 }, },
+      { { 28, 115 },
+        { 179, 100 },
+        { 206, 56 },
+        { 38, 205 }, },
+      { { 30, 148 },
+        { 164, 86 },
+        { 41, 120 },
+        { 106, 37 }, },
+      { { 30, 186 },
+        { 167, 71 },
+        { 93, 120 },
+        { 226, 229 }, },
+      { { 22, 217 },
+        { 180, 99 },
+        { 155, 104 },
+        { 198, 45 }, },
+      { { 30, 61 },
+        { 182, 85 },
+        { 188, 120 },
+        { 170, 109 }, },
+      { { 22, 251 },
+        { 183, 99 },
+        { 223, 104 },
+        { 198, 237 }, },
+      { { 29, 233 },
+        { 210, 103 },
+        { 151, 184 },
+        { 230, 75 }, },
+      { { 29, 254 },
+        { 227, 119 },
+        { 127, 184 },
+        { 238, 199 }, },
+      { { 31, 159 },
+        { 245, 87 },
+        { 249, 248 },
+        { 234, 175 }, },
+      { { 40, 139 },
+        { 25, 7 },
+        { 209, 20 },
+        { 224, 152 }, },
+      { { 32, 175 },
+        { 27, 19 },
+        { 245, 4 },
+        { 200, 216 }, },
+      { { 34, 14 },
+        { 13, 17 },
+        { 112, 68 },
+        { 136, 176 }, },
+      { { 34, 169 },
+        { 30, 3 },
+        { 149, 68 },
+        { 192, 120 }, },
+      { { 42, 141 },
+        { 28, 23 },
+        { 177, 84 },
+        { 232, 56 }, },
+      { { 42, 163 },
+        { 31, 6 },
+        { 197, 84 },
+        { 96, 248 }, },
+      { { 42, 239 },
+        { 31, 55 },
+        { 247, 84 },
+        { 236, 248 }, },
+      { { 40, 144 },
+        { 40, 6 },
+        { 9, 20 },
+        { 96, 20 }, },
+      { { 40, 59 },
+        { 59, 5 },
+        { 220, 20 },
+        { 160, 220 }, },
+      { { 42, 88 },
+        { 44, 37 },
+        { 26, 84 },
+        { 164, 52 }, },
+      { { 34, 51 },
+        { 63, 0 },
+        { 204, 68 },
+        { 0, 252 }, },
+      { { 33, 160 },
+        { 74, 2 },
+        { 5, 132 },
+        { 64, 82 }, },
+      { { 33, 2 },
+        { 73, 0 },
+        { 64, 132 },
+        { 0, 146 }, },
+      { { 33, 165 },
+        { 90, 18 },
+        { 165, 132 },
+        { 72, 90 }, },
+      { { 33, 199 },
+        { 89, 50 },
+        { 227, 132 },
+        { 76, 154 }, },
+      { { 43, 3 },
+        { 93, 4 },
+        { 192, 212 },
+        { 32, 186 }, },
+      { { 35, 103 },
+        { 95, 48 },
+        { 230, 196 },
+        { 12, 250 }, },
+      { { 41, 48 },
+        { 106, 4 },
+        { 12, 148 },
+        { 32, 86 }, },
+      { { 41, 210 },
+        { 105, 38 },
+        { 75, 148 },
+        { 100, 150 }, },
+      { { 43, 25 },
+        { 124, 5 },
+        { 152, 212 },
+        { 160, 62 }, },
+      { { 43, 155 },
+        { 125, 7 },
+        { 217, 212 },
+        { 224, 190 }, },
+      { { 43, 151 },
+        { 125, 22 },
+        { 233, 212 },
+        { 104, 190 }, },
+      { { 56, 40 },
+        { 138, 5 },
+        { 20, 28 },
+        { 160, 81 }, },
+      { { 56, 165 },
+        { 154, 22 },
+        { 165, 28 },
+        { 104, 89 }, },
+      { { 58, 134 },
+        { 141, 22 },
+        { 97, 92 },
+        { 104, 177 }, },
+      { { 50, 1 },
+        { 156, 0 },
+        { 128, 76 },
+        { 0, 57 }, },
+      { { 56, 159 },
+        { 185, 23 },
+        { 249, 28 },
+        { 232, 157 }, },
+      { { 50, 210 },
+        { 173, 34 },
+        { 75, 76 },
+        { 68, 181 }, },
+      { { 58, 153 },
+        { 188, 7 },
+        { 153, 92 },
+        { 224, 61 }, },
+      { { 58, 213 },
+        { 188, 54 },
+        { 171, 92 },
+        { 108, 61 }, },
+      { { 57, 232 },
+        { 202, 39 },
+        { 23, 156 },
+        { 228, 83 }, },
+      { { 59, 193 },
+        { 220, 38 },
+        { 131, 220 },
+        { 100, 59 }, },
+      { { 51, 67 },
+        { 221, 32 },
+        { 194, 204 },
+        { 4, 187 }, },
+      { { 59, 231 },
+        { 223, 54 },
+        { 231, 220 },
+        { 108, 251 }, },
+      { { 49, 154 },
+        { 233, 3 },
+        { 89, 140 },
+        { 192, 151 }, },
+      { { 51, 144 },
+        { 236, 2 },
+        { 9, 204 },
+        { 64, 55 }, },
+      { { 59, 158 },
+        { 237, 23 },
+        { 121, 220 },
+        { 232, 183 }, },
+      { { 36, 196 },
+        { 8, 114 },
+        { 35, 36 },
+        { 78, 16 }, },
+      { { 44, 74 },
+        { 9, 101 },
+        { 82, 52 },
+        { 166, 144 }, },
+      { { 44, 173 },
+        { 26, 87 },
+        { 181, 52 },
+        { 234, 88 }, },
+      { { 44, 207 },
+        { 25, 119 },
+        { 243, 52 },
+        { 238, 152 }, },
+      { { 44, 103 },
+        { 27, 116 },
+        { 230, 52 },
+        { 46, 216 }, },
+      { { 38, 234 },
+        { 15, 99 },
+        { 87, 100 },
+        { 198, 240 }, },
+      { { 46, 229 },
+        { 30, 118 },
+        { 167, 116 },
+        { 110, 120 }, },
+      { { 44, 112 },
+        { 42, 100 },
+        { 14, 52 },
+        { 38, 84 }, },
+      { { 46, 18 },
+        { 45, 68 },
+        { 72, 116 },
+        { 34, 180 }, },
+      { { 46, 209 },
+        { 60, 102 },
+        { 139, 116 },
+        { 102, 60 }, },
+      { { 46, 57 },
+        { 62, 69 },
+        { 156, 116 },
+        { 162, 124 }, },
+      { { 37, 100 },
+        { 74, 112 },
+        { 38, 164 },
+        { 14, 82 }, },
+      { { 37, 231 },
+        { 91, 114 },
+        { 231, 164 },
+        { 78, 218 }, },
+      { { 47, 204 },
+        { 76, 119 },
+        { 51, 244 },
+        { 238, 50 }, },
+      { { 45, 188 },
+        { 106, 87 },
+        { 61, 180 },
+        { 234, 86 }, },
+      { { 45, 113 },
+        { 122, 100 },
+        { 142, 180 },
+        { 38, 94 }, },
+      { { 37, 213 },
+        { 120, 114 },
+        { 171, 164 },
+        { 78, 30 }, },
+      { { 37, 155 },
+        { 121, 67 },
+        { 217, 164 },
+        { 194, 158 }, },
+      { { 39, 16 },
+        { 108, 64 },
+        { 8, 228 },
+        { 2, 54 }, },
+      { { 47, 124 },
+        { 110, 117 },
+        { 62, 244 },
+        { 174, 118 }, },
+      { { 39, 242 },
+        { 111, 98 },
+        { 79, 228 },
+        { 70, 246 }, },
+      { { 39, 58 },
+        { 111, 65 },
+        { 92, 228 },
+        { 130, 246 }, },
+      { { 47, 182 },
+        { 111, 86 },
+        { 109, 244 },
+        { 106, 246 }, },
+      { { 39, 211 },
+        { 125, 98 },
+        { 203, 228 },
+        { 70, 190 }, },
+      { { 47, 179 },
+        { 127, 70 },
+        { 205, 244 },
+        { 98, 254 }, },
+      { { 39, 31 },
+        { 125, 81 },
+        { 248, 228 },
+        { 138, 190 }, },
+      { { 60, 75 },
+        { 153, 101 },
+        { 210, 60 },
+        { 166, 153 }, },
+      { { 54, 192 },
+        { 140, 98 },
+        { 3, 108 },
+        { 70, 49 }, },
+      { { 54, 238 },
+        { 143, 115 },
+        { 119, 108 },
+        { 206, 241 }, },
+      { { 62, 233 },
+        { 158, 103 },
+        { 151, 124 },
+        { 230, 121 }, },
+      { { 52, 184 },
+        { 170, 67 },
+        { 29, 44 },
+        { 194, 85 }, },
+      { { 60, 20 },
+        { 168, 84 },
+        { 40, 60 },
+        { 42, 21 }, },
+      { { 60, 82 },
+        { 169, 100 },
+        { 74, 60 },
+        { 38, 149 }, },
+      { { 52, 114 },
+        { 171, 96 },
+        { 78, 44 },
+        { 6, 213 }, },
+      { { 52, 126 },
+        { 171, 113 },
+        { 126, 44 },
+        { 142, 213 }, },
+      { { 52, 191 },
+        { 187, 83 },
+        { 253, 44 },
+        { 202, 221 }, },
+      { { 62, 113 },
+        { 190, 100 },
+        { 142, 124 },
+        { 38, 125 }, },
+      { { 62, 83 },
+        { 189, 100 },
+        { 202, 124 },
+        { 38, 189 }, },
+      { { 61, 140 },
+        { 200, 87 },
+        { 49, 188 },
+        { 234, 19 }, },
+      { { 53, 162 },
+        { 203, 66 },
+        { 69, 172 },
+        { 66, 211 }, },
+      { { 53, 46 },
+        { 203, 81 },
+        { 116, 172 },
+        { 138, 211 }, },
+      { { 53, 45 },
+        { 218, 81 },
+        { 180, 172 },
+        { 138, 91 }, },
+      { { 55, 172 },
+        { 206, 83 },
+        { 53, 236 },
+        { 202, 115 }, },
+      { { 53, 112 },
+        { 234, 96 },
+        { 14, 172 },
+        { 6, 87 }, },
+      { { 55, 250 },
+        { 239, 99 },
+        { 95, 236 },
+        { 198, 247 }, },
+      { { 63, 241 },
+        { 254, 102 },
+        { 143, 252 },
+        { 102, 127 }, },
+      { { 63, 219 },
+        { 253, 103 },
+        { 219, 252 },
+        { 230, 191 }, },
+      { { 72, 196 },
+        { 0, 182 },
+        { 35, 18 },
+        { 109, 0 }, },
+      { { 72, 233 },
+        { 18, 167 },
+        { 151, 18 },
+        { 229, 72 }, },
+      { { 74, 194 },
+        { 5, 166 },
+        { 67, 82 },
+        { 101, 160 }, },
+      { { 74, 65 },
+        { 20, 164 },
+        { 130, 82 },
+        { 37, 40 }, },
+      { { 66, 235 },
+        { 23, 163 },
+        { 215, 66 },
+        { 197, 232 }, },
+      { { 72, 19 },
+        { 49, 132 },
+        { 200, 18 },
+        { 33, 140 }, },
+      { { 74, 216 },
+        { 36, 167 },
+        { 27, 82 },
+        { 229, 36 }, },
+      { { 66, 253 },
+        { 54, 179 },
+        { 191, 66 },
+        { 205, 108 }, },
+      { { 74, 23 },
+        { 53, 148 },
+        { 232, 82 },
+        { 41, 172 }, },
+      { { 73, 99 },
+        { 83, 164 },
+        { 198, 146 },
+        { 37, 202 }, },
+      { { 67, 110 },
+        { 71, 177 },
+        { 118, 194 },
+        { 141, 226 }, },
+      { { 65, 58 },
+        { 99, 129 },
+        { 92, 130 },
+        { 129, 198 }, },
+      { { 73, 177 },
+        { 114, 134 },
+        { 141, 146 },
+        { 97, 78 }, },
+      { { 65, 61 },
+        { 114, 145 },
+        { 188, 130 },
+        { 137, 78 }, },
+      { { 75, 146 },
+        { 101, 134 },
+        { 73, 210 },
+        { 97, 166 }, },
+      { { 75, 155 },
+        { 117, 135 },
+        { 217, 210 },
+        { 225, 174 }, },
+      { { 67, 63 },
+        { 119, 145 },
+        { 252, 194 },
+        { 137, 238 }, },
+      { { 88, 34 },
+        { 131, 132 },
+        { 68, 26 },
+        { 33, 193 }, },
+      { { 80, 170 },
+        { 131, 131 },
+        { 85, 10 },
+        { 193, 193 }, },
+      { { 88, 39 },
+        { 147, 148 },
+        { 228, 26 },
+        { 41, 201 }, },
+      { { 82, 200 },
+        { 132, 163 },
+        { 19, 74 },
+        { 197, 33 }, },
+      { { 82, 132 },
+        { 132, 146 },
+        { 33, 74 },
+        { 73, 33 }, },
+      { { 82, 10 },
+        { 133, 129 },
+        { 80, 74 },
+        { 129, 161 }, },
+      { { 90, 15 },
+        { 149, 149 },
+        { 240, 90 },
+        { 169, 169 }, },
+      { { 88, 152 },
+        { 160, 135 },
+        { 25, 26 },
+        { 225, 5 }, },
+      { { 88, 92 },
+        { 160, 181 },
+        { 58, 26 },
+        { 173, 5 }, },
+      { { 80, 219 },
+        { 177, 163 },
+        { 219, 10 },
+        { 197, 141 }, },
+      { { 80, 247 },
+        { 179, 178 },
+        { 239, 10 },
+        { 77, 205 }, },
+      { { 90, 244 },
+        { 166, 182 },
+        { 47, 90 },
+        { 109, 101 }, },
+      { { 81, 236 },
+        { 194, 179 },
+        { 55, 138 },
+        { 205, 67 }, },
+      { { 81, 66 },
+        { 193, 160 },
+        { 66, 138 },
+        { 5, 131 }, },
+      { { 81, 13 },
+        { 208, 145 },
+        { 176, 138 },
+        { 137, 11 }, },
+      { { 91, 3 },
+        { 213, 132 },
+        { 192, 218 },
+        { 33, 171 }, },
+      { { 83, 235 },
+        { 215, 163 },
+        { 215, 202 },
+        { 197, 235 }, },
+      { { 81, 118 },
+        { 227, 176 },
+        { 110, 138 },
+        { 13, 199 }, },
+      { { 89, 113 },
+        { 242, 164 },
+        { 142, 154 },
+        { 37, 79 }, },
+      { { 81, 147 },
+        { 241, 130 },
+        { 201, 138 },
+        { 65, 143 }, },
+      { { 83, 249 },
+        { 246, 163 },
+        { 159, 202 },
+        { 197, 111 }, },
+      { { 91, 179 },
+        { 247, 134 },
+        { 205, 218 },
+        { 97, 239 }, },
+      { { 83, 151 },
+        { 245, 146 },
+        { 233, 202 },
+        { 73, 175 }, },
+      { { 76, 76 },
+        { 0, 245 },
+        { 50, 50 },
+        { 175, 0 }, },
+      { { 68, 75 },
+        { 17, 225 },
+        { 210, 34 },
+        { 135, 136 }, },
+      { { 76, 35 },
+        { 19, 196 },
+        { 196, 50 },
+        { 35, 200 }, },
+      { { 70, 140 },
+        { 4, 211 },
+        { 49, 98 },
+        { 203, 32 }, },
+      { { 78, 39 },
+        { 23, 212 },
+        { 228, 114 },
+        { 43, 232 }, },
+      { { 70, 144 },
+        { 36, 194 },
+        { 9, 98 },
+        { 67, 36 }, },
+      { { 78, 212 },
+        { 36, 246 },
+        { 43, 114 },
+        { 111, 36 }, },
+      { { 69, 206 },
+        { 65, 243 },
+        { 115, 162 },
+        { 207, 130 }, },
+      { { 69, 229 },
+        { 82, 242 },
+        { 167, 162 },
+        { 79, 74 }, },
+      { { 69, 39 },
+        { 83, 208 },
+        { 228, 162 },
+        { 11, 202 }, },
+      { { 79, 193 },
+        { 84, 230 },
+        { 131, 242 },
+        { 103, 42 }, },
+      { { 71, 5 },
+        { 84, 208 },
+        { 160, 226 },
+        { 11, 42 }, },
+      { { 69, 52 },
+        { 98, 208 },
+        { 44, 162 },
+        { 11, 70 }, },
+      { { 69, 114 },
+        { 99, 224 },
+        { 78, 162 },
+        { 7, 198 }, },
+      { { 92, 200 },
+        { 128, 231 },
+        { 19, 58 },
+        { 231, 1 }, },
+      { { 92, 14 },
+        { 129, 213 },
+        { 112, 58 },
+        { 171, 129 }, },
+      { { 84, 235 },
+        { 147, 227 },
+        { 215, 42 },
+        { 199, 201 }, },
+      { { 86, 137 },
+        { 148, 195 },
+        { 145, 106 },
+        { 195, 41 }, },
+      { { 86, 67 },
+        { 149, 224 },
+        { 194, 106 },
+        { 7, 169 }, },
+      { { 94, 231 },
+        { 151, 246 },
+        { 231, 122 },
+        { 111, 233 }, },
+      { { 92, 112 },
+        { 162, 228 },
+        { 14, 58 },
+        { 39, 69 }, },
+      { { 84, 178 },
+        { 163, 194 },
+        { 77, 42 },
+        { 67, 197 }, },
+      { { 94, 121 },
+        { 182, 229 },
+        { 158, 122 },
+        { 167, 109 }, },
+      { { 86, 243 },
+        { 183, 226 },
+        { 207, 106 },
+        { 71, 237 }, },
+      { { 93, 163 },
+        { 211, 198 },
+        { 197, 186 },
+        { 99, 203 }, },
+      { { 93, 242 },
+        { 227, 230 },
+        { 79, 186 },
+        { 103, 199 }, },
+      { { 85, 29 },
+        { 240, 209 },
+        { 184, 170 },
+        { 139, 15 }, },
+      { { 93, 157 },
+        { 240, 215 },
+        { 185, 186 },
+        { 235, 15 }, },
+      { { 87, 252 },
+        { 230, 243 },
+        { 63, 234 },
+        { 207, 103 }, },
+      { { 87, 210 },
+        { 229, 226 },
+        { 75, 234 },
+        { 71, 167 }, },
+      { { 95, 115 },
+        { 247, 228 },
+        { 206, 250 },
+        { 39, 239 }, },
+      { { 104, 45 },
+        { 26, 149 },
+        { 180, 22 },
+        { 169, 88 }, },
+      { { 104, 195 },
+        { 25, 166 },
+        { 195, 22 },
+        { 101, 152 }, },
+      { { 104, 135 },
+        { 25, 150 },
+        { 225, 22 },
+        { 105, 152 }, },
+      { { 106, 74 },
+        { 13, 165 },
+        { 82, 86 },
+        { 165, 176 }, },
+      { { 98, 105 },
+        { 30, 161 },
+        { 150, 70 },
+        { 133, 120 }, },
+      { { 96, 185 },
+        { 58, 131 },
+        { 157, 6 },
+        { 193, 92 }, },
+      { { 104, 255 },
+        { 59, 183 },
+        { 255, 22 },
+        { 237, 220 }, },
+      { { 106, 220 },
+        { 44, 183 },
+        { 59, 86 },
+        { 237, 52 }, },
+      { { 106, 218 },
+        { 45, 167 },
+        { 91, 86 },
+        { 229, 180 }, },
+      { { 106, 62 },
+        { 47, 149 },
+        { 124, 86 },
+        { 169, 244 }, },
+      { { 106, 81 },
+        { 60, 164 },
+        { 138, 86 },
+        { 37, 60 }, },
+      { { 106, 49 },
+        { 62, 132 },
+        { 140, 86 },
+        { 33, 124 }, },
+      { { 98, 215 },
+        { 61, 178 },
+        { 235, 70 },
+        { 77, 188 }, },
+      { { 97, 204 },
+        { 72, 179 },
+        { 51, 134 },
+        { 205, 18 }, },
+      { { 107, 130 },
+        { 77, 134 },
+        { 65, 214 },
+        { 97, 178 }, },
+      { { 107, 227 },
+        { 95, 166 },
+        { 199, 214 },
+        { 101, 250 }, },
+      { { 105, 58 },
+        { 107, 133 },
+        { 92, 150 },
+        { 161, 214 }, },
+      { { 97, 158 },
+        { 105, 147 },
+        { 121, 134 },
+        { 201, 150 }, },
+      { { 97, 149 },
+        { 120, 146 },
+        { 169, 134 },
+        { 73, 30 }, },
+      { { 97, 117 },
+        { 122, 176 },
+        { 174, 134 },
+        { 13, 94 }, },
+      { { 105, 95 },
+        { 121, 181 },
+        { 250, 150 },
+        { 173, 158 }, },
+      { { 105, 55 },
+        { 123, 148 },
+        { 236, 150 },
+        { 41, 222 }, },
+      { { 99, 218 },
+        { 109, 163 },
+        { 91, 198 },
+        { 197, 182 }, },
+      { { 112, 2 },
+        { 137, 128 },
+        { 64, 14 },
+        { 1, 145 }, },
+      { { 120, 99 },
+        { 155, 164 },
+        { 198, 30 },
+        { 37, 217 }, },
+      { { 112, 79 },
+        { 153, 177 },
+        { 242, 14 },
+        { 141, 153 }, },
+      { { 114, 202 },
+        { 141, 163 },
+        { 83, 78 },
+        { 197, 177 }, },
+      { { 122, 173 },
+        { 158, 151 },
+        { 181, 94 },
+        { 233, 121 }, },
+      { { 112, 123 },
+        { 187, 161 },
+        { 222, 14 },
+        { 133, 221 }, },
+      { { 122, 20 },
+        { 172, 148 },
+        { 40, 94 },
+        { 41, 53 }, },
+      { { 122, 249 },
+        { 190, 167 },
+        { 159, 94 },
+        { 229, 125 }, },
+      { { 122, 211 },
+        { 189, 166 },
+        { 203, 94 },
+        { 101, 189 }, },
+      { { 122, 187 },
+        { 191, 135 },
+        { 221, 94 },
+        { 225, 253 }, },
+      { { 121, 226 },
+        { 203, 166 },
+        { 71, 158 },
+        { 101, 211 }, },
+      { { 113, 41 },
+        { 218, 129 },
+        { 148, 142 },
+        { 129, 91 }, },
+      { { 123, 103 },
+        { 223, 180 },
+        { 230, 222 },
+        { 45, 251 }, },
+      { { 113, 208 },
+        { 232, 162 },
+        { 11, 142 },
+        { 69, 23 }, },
+      { { 121, 57 },
+        { 250, 133 },
+        { 156, 158 },
+        { 161, 95 }, },
+      { { 115, 48 },
+        { 238, 128 },
+        { 12, 206 },
+        { 1, 119 }, },
+      { { 115, 185 },
+        { 254, 131 },
+        { 157, 206 },
+        { 193, 127 }, },
+      { { 115, 83 },
+        { 253, 160 },
+        { 202, 206 },
+        { 5, 191 }, },
+      { { 115, 255 },
+        { 255, 179 },
+        { 255, 206 },
+        { 205, 255 }, },
+      { { 108, 136 },
+        { 8, 199 },
+        { 17, 54 },
+        { 227, 16 }, },
+      { { 100, 9 },
+        { 24, 193 },
+        { 144, 38 },
+        { 131, 24 }, },
+      { { 108, 67 },
+        { 25, 228 },
+        { 194, 54 },
+        { 39, 152 }, },
+      { { 102, 6 },
+        { 13, 208 },
+        { 96, 102 },
+        { 11, 176 }, },
+      { { 102, 131 },
+        { 29, 194 },
+        { 193, 102 },
+        { 67, 184 }, },
+      { { 100, 176 },
+        { 42, 194 },
+        { 13, 38 },
+        { 67, 84 }, },
+      { { 100, 218 },
+        { 41, 227 },
+        { 91, 38 },
+        { 199, 148 }, },
+      { { 110, 159 },
+        { 61, 215 },
+        { 249, 118 },
+        { 235, 188 }, },
+      { { 103, 200 },
+        { 76, 227 },
+        { 19, 230 },
+        { 199, 50 }, },
+      { { 111, 238 },
+        { 79, 247 },
+        { 119, 246 },
+        { 239, 242 }, },
+      { { 109, 59 },
+        { 123, 197 },
+        { 220, 182 },
+        { 163, 222 }, },
+      { { 111, 210 },
+        { 109, 230 },
+        { 75, 246 },
+        { 103, 182 }, },
+      { { 116, 128 },
+        { 136, 194 },
+        { 1, 46 },
+        { 67, 17 }, },
+      { { 124, 171 },
+        { 155, 199 },
+        { 213, 62 },
+        { 227, 217 }, },
+      { { 126, 104 },
+        { 142, 229 },
+        { 22, 126 },
+        { 167, 113 }, },
+      { { 126, 2 },
+        { 141, 196 },
+        { 64, 126 },
+        { 35, 177 }, },
+      { { 124, 156 },
+        { 168, 215 },
+        { 57, 62 },
+        { 235, 21 }, },
+      { { 116, 54 },
+        { 171, 208 },
+        { 108, 46 },
+        { 11, 213 }, },
+      { { 124, 17 },
+        { 184, 196 },
+        { 136, 62 },
+        { 35, 29 }, },
+      { { 126, 222 },
+        { 173, 247 },
+        { 123, 126 },
+        { 239, 181 }, },
+      { { 126, 182 },
+        { 175, 214 },
+        { 109, 126 },
+        { 107, 245 }, },
+      { { 118, 219 },
+        { 189, 227 },
+        { 219, 110 },
+        { 199, 189 }, },
+      { { 125, 196 },
+        { 200, 246 },
+        { 35, 190 },
+        { 111, 19 }, },
+      { { 125, 138 },
+        { 201, 199 },
+        { 81, 190 },
+        { 227, 147 }, },
+      { { 117, 109 },
+        { 218, 241 },
+        { 182, 174 },
+        { 143, 91 }, },
+      { { 119, 136 },
+        { 204, 195 },
+        { 17, 238 },
+        { 195, 51 }, },
+      { { 119, 32 },
+        { 206, 192 },
+        { 4, 238 },
+        { 3, 115 }, },
+      { { 119, 65 },
+        { 220, 224 },
+        { 130, 238 },
+        { 7, 59 }, },
+      { { 117, 56 },
+        { 234, 193 },
+        { 28, 174 },
+        { 131, 87 }, },
+      { { 117, 190 },
+        { 235, 211 },
+        { 125, 174 },
+        { 203, 215 }, },
+      { { 125, 155 },
+        { 249, 199 },
+        { 217, 190 },
+        { 227, 159 }, },
+      { { 119, 87 },
+        { 253, 240 },
+        { 234, 238 },
+        { 15, 191 }, },
+      { { 136, 40 },
+        { 2, 13 },
+        { 20, 17 },
+        { 176, 64 }, },
+      { { 128, 172 },
+        { 2, 27 },
+        { 53, 1 },
+        { 216, 64 }, },
+      { { 136, 13 },
+        { 16, 29 },
+        { 176, 17 },
+        { 184, 8 }, },
+      { { 136, 103 },
+        { 19, 60 },
+        { 230, 17 },
+        { 60, 200 }, },
+      { { 130, 78 },
+        { 5, 57 },
+        { 114, 65 },
+        { 156, 160 }, },
+      { { 138, 161 },
+        { 22, 14 },
+        { 133, 81 },
+        { 112, 104 }, },
+      { { 130, 43 },
+        { 23, 9 },
+        { 212, 65 },
+        { 144, 232 }, },
+      { { 128, 24 },
+        { 32, 9 },
+        { 24, 1 },
+        { 144, 4 }, },
+      { { 136, 249 },
+        { 50, 47 },
+        { 159, 17 },
+        { 244, 76 }, },
+      { { 128, 157 },
+        { 48, 27 },
+        { 185, 1 },
+        { 216, 12 }, },
+      { { 138, 156 },
+        { 36, 31 },
+        { 57, 81 },
+        { 248, 36 }, },
+      { { 130, 49 },
+        { 54, 8 },
+        { 140, 65 },
+        { 16, 108 }, },
+      { { 138, 117 },
+        { 54, 60 },
+        { 174, 81 },
+        { 60, 108 }, },
+      { { 130, 151 },
+        { 53, 26 },
+        { 233, 65 },
+        { 88, 172 }, },
+      { { 129, 9 },
+        { 80, 9 },
+        { 144, 129 },
+        { 144, 10 }, },
+      { { 129, 235 },
+        { 83, 43 },
+        { 215, 129 },
+        { 212, 202 }, },
+      { { 129, 7 },
+        { 81, 24 },
+        { 224, 129 },
+        { 24, 138 }, },
+      { { 139, 40 },
+        { 70, 13 },
+        { 20, 209 },
+        { 176, 98 }, },
+      { { 139, 172 },
+        { 70, 31 },
+        { 53, 209 },
+        { 248, 98 }, },
+      { { 131, 46 },
+        { 71, 25 },
+        { 116, 193 },
+        { 152, 226 }, },
+      { { 131, 229 },
+        { 86, 58 },
+        { 167, 193 },
+        { 92, 106 }, },
+      { { 129, 80 },
+        { 96, 40 },
+        { 10, 129 },
+        { 20, 6 }, },
+      { { 137, 50 },
+        { 99, 12 },
+        { 76, 145 },
+        { 48, 198 }, },
+      { { 139, 122 },
+        { 103, 45 },
+        { 94, 209 },
+        { 180, 230 }, },
+      { { 139, 150 },
+        { 101, 30 },
+        { 105, 209 },
+        { 120, 166 }, },
+      { { 131, 125 },
+        { 118, 57 },
+        { 190, 193 },
+        { 156, 110 }, },
+      { { 144, 135 },
+        { 145, 26 },
+        { 225, 9 },
+        { 88, 137 }, },
+      { { 154, 252 },
+        { 166, 63 },
+        { 63, 89 },
+        { 252, 101 }, },
+      { { 146, 245 },
+        { 182, 58 },
+        { 175, 73 },
+        { 92, 109 }, },
+      { { 145, 170 },
+        { 195, 11 },
+        { 85, 137 },
+        { 208, 195 }, },
+      { { 147, 65 },
+        { 212, 40 },
+        { 130, 201 },
+        { 20, 43 }, },
+      { { 147, 37 },
+        { 214, 24 },
+        { 164, 201 },
+        { 24, 107 }, },
+      { { 155, 235 },
+        { 215, 47 },
+        { 215, 217 },
+        { 244, 235 }, },
+      { { 153, 52 },
+        { 226, 28 },
+        { 44, 153 },
+        { 56, 71 }, },
+      { { 145, 247 },
+        { 243, 58 },
+        { 239, 137 },
+        { 92, 207 }, },
+      { { 155, 218 },
+        { 229, 47 },
+        { 91, 217 },
+        { 244, 167 }, },
+      { { 147, 86 },
+        { 229, 56 },
+        { 106, 201 },
+        { 28, 167 }, },
+      { { 132, 66 },
+        { 1, 104 },
+        { 66, 33 },
+        { 22, 128 }, },
+      { { 140, 129 },
+        { 16, 78 },
+        { 129, 49 },
+        { 114, 8 }, },
+      { { 140, 79 },
+        { 17, 125 },
+        { 242, 49 },
+        { 190, 136 }, },
+      { { 134, 72 },
+        { 4, 105 },
+        { 18, 97 },
+        { 150, 32 }, },
+      { { 134, 166 },
+        { 7, 90 },
+        { 101, 97 },
+        { 90, 224 }, },
+      { { 142, 3 },
+        { 21, 76 },
+        { 192, 113 },
+        { 50, 168 }, },
+      { { 134, 227 },
+        { 23, 106 },
+        { 199, 97 },
+        { 86, 232 }, },
+      { { 134, 111 },
+        { 23, 121 },
+        { 246, 97 },
+        { 158, 232 }, },
+      { { 142, 175 },
+        { 23, 95 },
+        { 245, 113 },
+        { 250, 232 }, },
+      { { 132, 94 },
+        { 33, 121 },
+        { 122, 33 },
+        { 158, 132 }, },
+      { { 132, 119 },
+        { 51, 120 },
+        { 238, 33 },
+        { 30, 204 }, },
+      { { 134, 250 },
+        { 39, 107 },
+        { 95, 97 },
+        { 214, 228 }, },
+      { { 142, 30 },
+        { 37, 93 },
+        { 120, 113 },
+        { 186, 164 }, },
+      { { 142, 55 },
+        { 55, 92 },
+        { 236, 113 },
+        { 58, 236 }, },
+      { { 135, 10 },
+        { 69, 73 },
+        { 80, 225 },
+        { 146, 162 }, },
+      { { 143, 138 },
+        { 69, 79 },
+        { 81, 241 },
+        { 242, 162 }, },
+      { { 143, 38 },
+        { 71, 92 },
+        { 100, 241 },
+        { 58, 226 }, },
+      { { 135, 33 },
+        { 86, 72 },
+        { 132, 225 },
+        { 18, 106 }, },
+      { { 135, 13 },
+        { 84, 89 },
+        { 176, 225 },
+        { 154, 42 }, },
+      { { 133, 114 },
+        { 99, 104 },
+        { 78, 161 },
+        { 22, 198 }, },
+      { { 135, 62 },
+        { 103, 89 },
+        { 124, 225 },
+        { 154, 230 }, },
+      { { 156, 67 },
+        { 145, 108 },
+        { 194, 57 },
+        { 54, 137 }, },
+      { { 158, 97 },
+        { 150, 108 },
+        { 134, 121 },
+        { 54, 105 }, },
+      { { 148, 88 },
+        { 160, 105 },
+        { 26, 41 },
+        { 150, 5 }, },
+      { { 148, 248 },
+        { 162, 107 },
+        { 31, 41 },
+        { 214, 69 }, },
+      { { 156, 50 },
+        { 163, 76 },
+        { 76, 57 },
+        { 50, 197 }, },
+      { { 148, 118 },
+        { 163, 120 },
+        { 110, 41 },
+        { 30, 197 }, },
+      { { 148, 177 },
+        { 178, 74 },
+        { 141, 41 },
+        { 82, 77 }, },
+      { { 148, 221 },
+        { 176, 123 },
+        { 187, 41 },
+        { 222, 13 }, },
+      { { 148, 155 },
+        { 177, 75 },
+        { 217, 41 },
+        { 210, 141 }, },
+      { { 156, 219 },
+        { 177, 111 },
+        { 219, 57 },
+        { 246, 141 }, },
+      { { 158, 156 },
+        { 164, 95 },
+        { 57, 121 },
+        { 250, 37 }, },
+      { { 158, 210 },
+        { 165, 110 },
+        { 75, 121 },
+        { 118, 165 }, },
+      { { 150, 25 },
+        { 180, 73 },
+        { 152, 105 },
+        { 146, 45 }, },
+      { { 158, 177 },
+        { 182, 78 },
+        { 141, 121 },
+        { 114, 109 }, },
+      { { 149, 105 },
+        { 210, 105 },
+        { 150, 169 },
+        { 150, 75 }, },
+      { { 159, 109 },
+        { 214, 125 },
+        { 182, 249 },
+        { 190, 107 }, },
+      { { 151, 43 },
+        { 215, 73 },
+        { 212, 233 },
+        { 146, 235 }, },
+      { { 149, 182 },
+        { 227, 90 },
+        { 109, 169 },
+        { 90, 199 }, },
+      { { 149, 185 },
+        { 242, 75 },
+        { 157, 169 },
+        { 210, 79 }, },
+      { { 157, 61 },
+        { 242, 93 },
+        { 188, 185 },
+        { 186, 79 }, },
+      { { 157, 87 },
+        { 241, 124 },
+        { 234, 185 },
+        { 62, 143 }, },
+      { { 168, 236 },
+        { 10, 63 },
+        { 55, 21 },
+        { 252, 80 }, },
+      { { 168, 37 },
+        { 26, 28 },
+        { 164, 21 },
+        { 56, 88 }, },
+      { { 162, 172 },
+        { 14, 27 },
+        { 53, 69 },
+        { 216, 112 }, },
+      { { 162, 2 },
+        { 13, 8 },
+        { 64, 69 },
+        { 16, 176 }, },
+      { { 170, 102 },
+        { 15, 60 },
+        { 102, 85 },
+        { 60, 240 }, },
+      { { 170, 143 },
+        { 29, 31 },
+        { 241, 85 },
+        { 248, 184 }, },
+      { { 170, 231 },
+        { 31, 62 },
+        { 231, 85 },
+        { 124, 248 }, },
+      { { 168, 48 },
+        { 42, 12 },
+        { 12, 21 },
+        { 48, 84 }, },
+      { { 168, 122 },
+        { 43, 45 },
+        { 94, 21 },
+        { 180, 212 }, },
+      { { 168, 246 },
+        { 43, 62 },
+        { 111, 21 },
+        { 124, 212 }, },
+      { { 168, 147 },
+        { 57, 14 },
+        { 201, 21 },
+        { 112, 156 }, },
+      { { 162, 20 },
+        { 44, 24 },
+        { 40, 69 },
+        { 24, 52 }, },
+      { { 170, 52 },
+        { 46, 28 },
+        { 44, 85 },
+        { 56, 116 }, },
+      { { 162, 114 },
+        { 47, 40 },
+        { 78, 69 },
+        { 20, 244 }, },
+      { { 170, 242 },
+        { 47, 46 },
+        { 79, 85 },
+        { 116, 244 }, },
+      { { 162, 241 },
+        { 62, 42 },
+        { 143, 69 },
+        { 84, 124 }, },
+      { { 161, 64 },
+        { 72, 40 },
+        { 2, 133 },
+        { 20, 18 }, },
+      { { 169, 10 },
+        { 73, 13 },
+        { 80, 149 },
+        { 176, 146 }, },
+      { { 161, 38 },
+        { 75, 24 },
+        { 100, 133 },
+        { 24, 210 }, },
+      { { 169, 197 },
+        { 88, 62 },
+        { 163, 149 },
+        { 124, 26 }, },
+      { { 169, 207 },
+        { 89, 63 },
+        { 243, 149 },
+        { 252, 154 }, },
+      { { 161, 52 },
+        { 106, 24 },
+        { 44, 133 },
+        { 24, 86 }, },
+      { { 169, 18 },
+        { 105, 12 },
+        { 72, 149 },
+        { 48, 150 }, },
+      { { 161, 250 },
+        { 107, 43 },
+        { 95, 133 },
+        { 212, 214 }, },
+      { { 171, 152 },
+        { 108, 15 },
+        { 25, 213 },
+        { 240, 54 }, },
+      { { 163, 247 },
+        { 127, 58 },
+        { 239, 197 },
+        { 92, 254 }, },
+      { { 176, 6 },
+        { 137, 24 },
+        { 96, 13 },
+        { 24, 145 }, },
+      { { 176, 69 },
+        { 152, 56 },
+        { 162, 13 },
+        { 28, 25 }, },
+      { { 184, 141 },
+        { 152, 31 },
+        { 177, 29 },
+        { 248, 25 }, },
+      { { 178, 132 },
+        { 140, 26 },
+        { 33, 77 },
+        { 88, 49 }, },
+      { { 184, 240 },
+        { 170, 46 },
+        { 15, 29 },
+        { 116, 85 }, },
+      { { 184, 85 },
+        { 184, 60 },
+        { 170, 29 },
+        { 60, 29 }, },
+      { { 178, 118 },
+        { 175, 56 },
+        { 110, 77 },
+        { 28, 245 }, },
+      { { 186, 145 },
+        { 188, 14 },
+        { 137, 93 },
+        { 112, 61 }, },
+      { { 178, 113 },
+        { 190, 40 },
+        { 142, 77 },
+        { 20, 125 }, },
+      { { 185, 192 },
+        { 200, 46 },
+        { 3, 157 },
+        { 116, 19 }, },
+      { { 185, 66 },
+        { 201, 44 },
+        { 66, 157 },
+        { 52, 147 }, },
+      { { 185, 42 },
+        { 203, 13 },
+        { 84, 157 },
+        { 176, 211 }, },
+      { { 179, 140 },
+        { 204, 27 },
+        { 49, 205 },
+        { 216, 51 }, },
+      { { 179, 202 },
+        { 205, 43 },
+        { 83, 205 },
+        { 212, 179 }, },
+      { { 187, 102 },
+        { 207, 60 },
+        { 102, 221 },
+        { 60, 243 }, },
+      { { 179, 15 },
+        { 221, 25 },
+        { 240, 205 },
+        { 152, 187 }, },
+      { { 177, 218 },
+        { 233, 43 },
+        { 91, 141 },
+        { 212, 151 }, },
+      { { 187, 20 },
+        { 236, 28 },
+        { 40, 221 },
+        { 56, 55 }, },
+      { { 187, 246 },
+        { 239, 62 },
+        { 111, 221 },
+        { 124, 247 }, },
+      { { 179, 19 },
+        { 253, 8 },
+        { 200, 205 },
+        { 16, 191 }, },
+      { { 164, 104 },
+        { 10, 105 },
+        { 22, 37 },
+        { 150, 80 }, },
+      { { 172, 44 },
+        { 10, 93 },
+        { 52, 53 },
+        { 186, 80 }, },
+      { { 172, 161 },
+        { 26, 78 },
+        { 133, 53 },
+        { 114, 88 }, },
+      { { 172, 235 },
+        { 27, 111 },
+        { 215, 53 },
+        { 246, 216 }, },
+      { { 172, 199 },
+        { 25, 126 },
+        { 227, 53 },
+        { 126, 152 }, },
+      { { 164, 103 },
+        { 27, 120 },
+        { 230, 37 },
+        { 30, 216 }, },
+      { { 166, 192 },
+        { 12, 106 },
+        { 3, 101 },
+        { 86, 48 }, },
+      { { 174, 224 },
+        { 14, 110 },
+        { 7, 117 },
+        { 118, 112 }, },
+      { { 166, 35 },
+        { 31, 72 },
+        { 196, 101 },
+        { 18, 248 }, },
+      { { 173, 232 },
+        { 74, 111 },
+        { 23, 181 },
+        { 246, 82 }, },
+      { { 165, 204 },
+        { 72, 123 },
+        { 51, 165 },
+        { 222, 18 }, },
+      { { 167, 236 },
+        { 78, 123 },
+        { 55, 229 },
+        { 222, 114 }, },
+      { { 173, 124 },
+        { 106, 125 },
+        { 62, 181 },
+        { 190, 86 }, },
+      { { 165, 26 },
+        { 105, 73 },
+        { 88, 165 },
+        { 146, 150 }, },
+      { { 165, 145 },
+        { 120, 74 },
+        { 137, 165 },
+        { 82, 30 }, },
+      { { 173, 25 },
+        { 120, 77 },
+        { 152, 181 },
+        { 178, 30 }, },
+      { { 165, 151 },
+        { 121, 90 },
+        { 233, 165 },
+        { 90, 158 }, },
+      { { 180, 109 },
+        { 154, 121 },
+        { 182, 45 },
+        { 158, 89 }, },
+      { { 190, 203 },
+        { 157, 111 },
+        { 211, 125 },
+        { 246, 185 }, },
+      { { 188, 58 },
+        { 171, 77 },
+        { 92, 61 },
+        { 178, 213 }, },
+      { { 188, 245 },
+        { 186, 126 },
+        { 175, 61 },
+        { 126, 93 }, },
+      { { 190, 189 },
+        { 190, 95 },
+        { 189, 125 },
+        { 250, 125 }, },
+      { { 190, 243 },
+        { 191, 110 },
+        { 207, 125 },
+        { 118, 253 }, },
+      { { 181, 37 },
+        { 218, 88 },
+        { 164, 173 },
+        { 26, 91 }, },
+      { { 181, 143 },
+        { 217, 91 },
+        { 241, 173 },
+        { 218, 155 }, },
+      { { 183, 104 },
+        { 206, 105 },
+        { 22, 237 },
+        { 150, 115 }, },
+      { { 191, 228 },
+        { 206, 126 },
+        { 39, 253 },
+        { 126, 115 }, },
+      { { 189, 254 },
+        { 235, 127 },
+        { 127, 189 },
+        { 254, 215 }, },
+      { { 189, 157 },
+        { 248, 95 },
+        { 185, 189 },
+        { 250, 31 }, },
+      { { 181, 245 },
+        { 250, 122 },
+        { 175, 173 },
+        { 94, 95 }, },
+      { { 181, 243 },
+        { 251, 106 },
+        { 207, 173 },
+        { 86, 223 }, },
+      { { 191, 176 },
+        { 238, 78 },
+        { 13, 253 },
+        { 114, 119 }, },
+      { { 183, 90 },
+        { 237, 105 },
+        { 90, 237 },
+        { 150, 183 }, },
+      { { 191, 62 },
+        { 239, 93 },
+        { 124, 253 },
+        { 186, 247 }, },
+      { { 183, 57 },
+        { 254, 73 },
+        { 156, 237 },
+        { 146, 127 }, },
+      { { 191, 213 },
+        { 252, 126 },
+        { 171, 253 },
+        { 126, 63 }, },
+      { { 183, 29 },
+        { 252, 89 },
+        { 184, 237 },
+        { 154, 63 }, },
+      { { 191, 53 },
+        { 254, 92 },
+        { 172, 253 },
+        { 58, 127 }, },
+      { { 183, 127 },
+        { 255, 121 },
+        { 254, 237 },
+        { 158, 255 }, },
+      { { 200, 1 },
+        { 16, 140 },
+        { 128, 19 },
+        { 49, 8 }, },
+      { { 192, 165 },
+        { 18, 154 },
+        { 165, 3 },
+        { 89, 72 }, },
+      { { 194, 130 },
+        { 5, 138 },
+        { 65, 67 },
+        { 81, 160 }, },
+      { { 200, 189 },
+        { 50, 159 },
+        { 189, 19 },
+        { 249, 76 }, },
+      { { 194, 252 },
+        { 38, 187 },
+        { 63, 67 },
+        { 221, 100 }, },
+      { { 202, 145 },
+        { 52, 142 },
+        { 137, 83 },
+        { 113, 44 }, },
+      { { 194, 91 },
+        { 53, 169 },
+        { 218, 67 },
+        { 149, 172 }, },
+      { { 201, 68 },
+        { 64, 188 },
+        { 34, 147 },
+        { 61, 2 }, },
+      { { 193, 42 },
+        { 67, 137 },
+        { 84, 131 },
+        { 145, 194 }, },
+      { { 195, 192 },
+        { 68, 170 },
+        { 3, 195 },
+        { 85, 34 }, },
+      { { 201, 122 },
+        { 99, 173 },
+        { 94, 147 },
+        { 181, 198 }, },
+      { { 193, 185 },
+        { 114, 139 },
+        { 157, 131 },
+        { 209, 78 }, },
+      { { 201, 117 },
+        { 114, 188 },
+        { 174, 147 },
+        { 61, 78 }, },
+      { { 193, 247 },
+        { 115, 186 },
+        { 239, 131 },
+        { 93, 206 }, },
+      { { 203, 177 },
+        { 118, 142 },
+        { 141, 211 },
+        { 113, 110 }, },
+      { { 208, 108 },
+        { 130, 185 },
+        { 54, 11 },
+        { 157, 65 }, },
+      { { 216, 135 },
+        { 145, 158 },
+        { 225, 27 },
+        { 121, 137 }, },
+      { { 208, 175 },
+        { 147, 155 },
+        { 245, 11 },
+        { 217, 201 }, },
+      { { 218, 196 },
+        { 132, 190 },
+        { 35, 91 },
+        { 125, 33 }, },
+      { { 210, 12 },
+        { 132, 153 },
+        { 48, 75 },
+        { 153, 33 }, },
+      { { 218, 9 },
+        { 148, 141 },
+        { 144, 91 },
+        { 177, 41 }, },
+      { { 208, 48 },
+        { 162, 136 },
+        { 12, 11 },
+        { 17, 69 }, },
+      { { 216, 148 },
+        { 160, 158 },
+        { 41, 27 },
+        { 121, 5 }, },
+      { { 208, 58 },
+        { 163, 137 },
+        { 92, 11 },
+        { 145, 197 }, },
+      { { 208, 182 },
+        { 163, 154 },
+        { 109, 11 },
+        { 89, 197 }, },
+      { { 208, 117 },
+        { 178, 184 },
+        { 174, 11 },
+        { 29, 77 }, },
+      { { 210, 118 },
+        { 167, 184 },
+        { 110, 75 },
+        { 29, 229 }, },
+      { { 218, 93 },
+        { 180, 189 },
+        { 186, 91 },
+        { 189, 45 }, },
+      { { 218, 53 },
+        { 182, 156 },
+        { 172, 91 },
+        { 57, 109 }, },
+      { { 210, 23 },
+        { 181, 152 },
+        { 232, 75 },
+        { 25, 173 }, },
+      { { 217, 2 },
+        { 193, 140 },
+        { 64, 155 },
+        { 49, 131 }, },
+      { { 211, 232 },
+        { 198, 171 },
+        { 23, 203 },
+        { 213, 99 }, },
+      { { 211, 229 },
+        { 214, 186 },
+        { 167, 203 },
+        { 93, 107 }, },
+      { { 209, 154 },
+        { 225, 139 },
+        { 89, 139 },
+        { 209, 135 }, },
+      { { 209, 246 },
+        { 227, 186 },
+        { 111, 139 },
+        { 93, 199 }, },
+      { { 209, 81 },
+        { 240, 168 },
+        { 138, 139 },
+        { 21, 15 }, },
+      { { 219, 20 },
+        { 228, 156 },
+        { 40, 219 },
+        { 57, 39 }, },
+      { { 211, 62 },
+        { 231, 153 },
+        { 124, 203 },
+        { 153, 231 }, },
+      { { 211, 211 },
+        { 245, 170 },
+        { 203, 203 },
+        { 85, 175 }, },
+      { { 196, 96 },
+        { 2, 232 },
+        { 6, 35 },
+        { 23, 64 }, },
+      { { 204, 167 },
+        { 19, 222 },
+        { 229, 51 },
+        { 123, 200 }, },
+      { { 198, 66 },
+        { 5, 232 },
+        { 66, 99 },
+        { 23, 160 }, },
+      { { 198, 71 },
+        { 21, 248 },
+        { 226, 99 },
+        { 31, 168 }, },
+      { { 206, 231 },
+        { 23, 254 },
+        { 231, 115 },
+        { 127, 232 }, },
+      { { 196, 92 },
+        { 32, 249 },
+        { 58, 35 },
+        { 159, 4 }, },
+      { { 204, 29 },
+        { 48, 221 },
+        { 184, 51 },
+        { 187, 12 }, },
+      { { 204, 53 },
+        { 50, 220 },
+        { 172, 51 },
+        { 59, 76 }, },
+      { { 198, 188 },
+        { 38, 219 },
+        { 61, 99 },
+        { 219, 100 }, },
+      { { 205, 168 },
+        { 66, 207 },
+        { 21, 179 },
+        { 243, 66 }, },
+      { { 197, 12 },
+        { 64, 217 },
+        { 48, 163 },
+        { 155, 2 }, },
+      { { 197, 228 },
+        { 66, 250 },
+        { 39, 163 },
+        { 95, 66 }, },
+      { { 197, 194 },
+        { 65, 234 },
+        { 67, 163 },
+        { 87, 130 }, },
+      { { 205, 45 },
+        { 82, 221 },
+        { 180, 179 },
+        { 187, 74 }, },
+      { { 205, 89 },
+        { 112, 237 },
+        { 154, 179 },
+        { 183, 14 }, },
+      { { 205, 149 },
+        { 112, 222 },
+        { 169, 179 },
+        { 123, 14 }, },
+      { { 197, 147 },
+        { 113, 202 },
+        { 201, 163 },
+        { 83, 142 }, },
+      { { 199, 95 },
+        { 117, 249 },
+        { 250, 227 },
+        { 159, 174 }, },
+      { { 212, 197 },
+        { 144, 250 },
+        { 163, 43 },
+        { 95, 9 }, },
+      { { 222, 136 },
+        { 132, 207 },
+        { 17, 123 },
+        { 243, 33 }, },
+      { { 214, 36 },
+        { 134, 216 },
+        { 36, 107 },
+        { 27, 97 }, },
+      { { 222, 236 },
+        { 134, 255 },
+        { 55, 123 },
+        { 255, 97 }, },
+      { { 214, 226 },
+        { 135, 234 },
+        { 71, 107 },
+        { 87, 225 }, },
+      { { 222, 198 },
+        { 133, 254 },
+        { 99, 123 },
+        { 127, 161 }, },
+      { { 222, 35 },
+        { 151, 204 },
+        { 196, 123 },
+        { 51, 233 }, },
+      { { 220, 220 },
+        { 160, 255 },
+        { 59, 59 },
+        { 255, 5 }, },
+      { { 220, 26 },
+        { 161, 205 },
+        { 88, 59 },
+        { 179, 133 }, },
+      { { 212, 17 },
+        { 176, 200 },
+        { 136, 43 },
+        { 19, 13 }, },
+      { { 222, 84 },
+        { 164, 252 },
+        { 42, 123 },
+        { 63, 37 }, },
+      { { 214, 148 },
+        { 164, 218 },
+        { 41, 107 },
+        { 91, 37 }, },
+      { { 222, 157 },
+        { 180, 223 },
+        { 185, 123 },
+        { 251, 45 }, },
+      { { 221, 129 },
+        { 208, 206 },
+        { 129, 187 },
+        { 115, 11 }, },
+      { { 213, 165 },
+        { 210, 218 },
+        { 165, 171 },
+        { 91, 75 }, },
+      { { 215, 172 },
+        { 198, 219 },
+        { 53, 235 },
+        { 219, 99 }, },
+      { { 215, 102 },
+        { 199, 248 },
+        { 102, 235 },
+        { 31, 227 }, },
+      { { 223, 169 },
+        { 214, 207 },
+        { 149, 251 },
+        { 243, 107 }, },
+      { { 213, 220 },
+        { 224, 251 },
+        { 59, 171 },
+        { 223, 7 }, },
+      { { 221, 31 },
+        { 241, 221 },
+        { 248, 187 },
+        { 187, 143 }, },
+      { { 223, 240 },
+        { 230, 238 },
+        { 15, 251 },
+        { 119, 103 }, },
+      { { 226, 72 },
+        { 12, 169 },
+        { 18, 71 },
+        { 149, 48 }, },
+      { { 226, 232 },
+        { 14, 171 },
+        { 23, 71 },
+        { 213, 112 }, },
+      { { 226, 7 },
+        { 29, 152 },
+        { 224, 71 },
+        { 25, 184 }, },
+      { { 224, 93 },
+        { 56, 185 },
+        { 186, 7 },
+        { 157, 28 }, },
+      { { 234, 245 },
+        { 62, 190 },
+        { 175, 87 },
+        { 125, 124 }, },
+      { { 235, 38 },
+        { 79, 156 },
+        { 100, 215 },
+        { 57, 242 }, },
+      { { 235, 237 },
+        { 94, 191 },
+        { 183, 215 },
+        { 253, 122 }, },
+      { { 225, 82 },
+        { 105, 168 },
+        { 74, 135 },
+        { 21, 150 }, },
+      { { 225, 126 },
+        { 107, 185 },
+        { 126, 135 },
+        { 157, 214 }, },
+      { { 233, 219 },
+        { 121, 175 },
+        { 219, 151 },
+        { 245, 158 }, },
+      { { 248, 6 },
+        { 137, 156 },
+        { 96, 31 },
+        { 57, 145 }, },
+      { { 240, 238 },
+        { 139, 187 },
+        { 119, 15 },
+        { 221, 209 }, },
+      { { 248, 161 },
+        { 154, 142 },
+        { 133, 31 },
+        { 113, 89 }, },
+      { { 250, 0 },
+        { 140, 140 },
+        { 0, 95 },
+        { 49, 49 }, },
+      { { 250, 194 },
+        { 141, 174 },
+        { 67, 95 },
+        { 117, 177 }, },
+      { { 240, 155 },
+        { 185, 139 },
+        { 217, 15 },
+        { 209, 157 }, },
+      { { 250, 244 },
+        { 174, 190 },
+        { 47, 95 },
+        { 125, 117 }, },
+      { { 250, 60 },
+        { 174, 157 },
+        { 60, 95 },
+        { 185, 117 }, },
+      { { 242, 252 },
+        { 174, 187 },
+        { 63, 79 },
+        { 221, 117 }, },
+      { { 242, 189 },
+        { 190, 155 },
+        { 189, 79 },
+        { 217, 125 }, },
+      { { 242, 147 },
+        { 189, 138 },
+        { 201, 79 },
+        { 81, 189 }, },
+      { { 241, 96 },
+        { 202, 168 },
+        { 6, 143 },
+        { 21, 83 }, },
+      { { 249, 236 },
+        { 202, 191 },
+        { 55, 159 },
+        { 253, 83 }, },
+      { { 241, 70 },
+        { 201, 184 },
+        { 98, 143 },
+        { 29, 147 }, },
+      { { 249, 225 },
+        { 218, 174 },
+        { 135, 159 },
+        { 117, 91 }, },
+      { { 243, 72 },
+        { 204, 169 },
+        { 18, 207 },
+        { 149, 51 }, },
+      { { 243, 174 },
+        { 207, 155 },
+        { 117, 207 },
+        { 217, 243 }, },
+      { { 243, 193 },
+        { 220, 170 },
+        { 131, 207 },
+        { 85, 59 }, },
+      { { 243, 139 },
+        { 221, 139 },
+        { 209, 207 },
+        { 209, 187 }, },
+      { { 243, 167 },
+        { 223, 154 },
+        { 229, 207 },
+        { 89, 251 }, },
+      { { 241, 115 },
+        { 251, 168 },
+        { 206, 143 },
+        { 21, 223 }, },
+      { { 241, 151 },
+        { 249, 154 },
+        { 233, 143 },
+        { 89, 159 }, },
+      { { 243, 244 },
+        { 238, 186 },
+        { 47, 207 },
+        { 93, 119 }, },
+      { { 251, 50 },
+        { 239, 140 },
+        { 76, 223 },
+        { 49, 247 }, },
+      { { 228, 7 },
+        { 25, 216 },
+        { 224, 39 },
+        { 27, 152 }, },
+      { { 230, 77 },
+        { 28, 249 },
+        { 178, 103 },
+        { 159, 56 }, },
+      { { 236, 85 },
+        { 56, 252 },
+        { 170, 55 },
+        { 63, 28 }, },
+      { { 237, 192 },
+        { 72, 238 },
+        { 3, 183 },
+        { 119, 18 }, },
+      { { 237, 133 },
+        { 88, 222 },
+        { 161, 183 },
+        { 123, 26 }, },
+      { { 239, 162 },
+        { 79, 206 },
+        { 69, 247 },
+        { 115, 242 }, },
+      { { 231, 78 },
+        { 77, 249 },
+        { 114, 231 },
+        { 159, 178 }, },
+      { { 229, 213 },
+        { 120, 250 },
+        { 171, 167 },
+        { 95, 30 }, },
+      { { 239, 80 },
+        { 108, 236 },
+        { 10, 247 },
+        { 55, 54 }, },
+      { { 244, 34 },
+        { 139, 200 },
+        { 68, 47 },
+        { 19, 209 }, },
+      { { 244, 137 },
+        { 152, 203 },
+        { 145, 47 },
+        { 211, 25 }, },
+      { { 244, 41 },
+        { 154, 201 },
+        { 148, 47 },
+        { 147, 89 }, },
+      { { 246, 106 },
+        { 143, 233 },
+        { 86, 111 },
+        { 151, 241 }, },
+      { { 254, 11 },
+        { 157, 205 },
+        { 208, 127 },
+        { 179, 185 }, },
+      { { 254, 111 },
+        { 159, 253 },
+        { 246, 127 },
+        { 191, 249 }, },
+      { { 244, 149 },
+        { 184, 218 },
+        { 169, 47 },
+        { 91, 29 }, },
+      { { 244, 53 },
+        { 186, 216 },
+        { 172, 47 },
+        { 27, 93 }, },
+      { { 244, 31 },
+        { 185, 217 },
+        { 248, 47 },
+        { 155, 157 }, },
+      { { 246, 176 },
+        { 174, 202 },
+        { 13, 111 },
+        { 83, 117 }, },
+      { { 245, 232 },
+        { 202, 235 },
+        { 23, 175 },
+        { 215, 83 }, },
+      { { 245, 197 },
+        { 216, 250 },
+        { 163, 175 },
+        { 95, 27 }, },
+      { { 253, 35 },
+        { 219, 204 },
+        { 196, 191 },
+        { 51, 219 }, },
+      { { 255, 192 },
+        { 204, 238 },
+        { 3, 255 },
+        { 119, 51 }, },
+      { { 247, 204 },
+        { 204, 251 },
+        { 51, 239 },
+        { 223, 51 }, },
+      { { 247, 233 },
+        { 222, 235 },
+        { 151, 239 },
+        { 215, 123 }, },
+      { { 245, 188 },
+        { 234, 219 },
+        { 61, 175 },
+        { 219, 87 }, },
+      { { 253, 246 },
+        { 235, 254 },
+        { 111, 191 },
+        { 127, 215 }, },
+      { { 245, 217 },
+        { 248, 235 },
+        { 155, 175 },
+        { 215, 31 }, },
+      { { 253, 151 },
+        { 249, 222 },
+        { 233, 191 },
+        { 123, 159 }, },
+      { { 253, 63 },
+        { 251, 221 },
+        { 252, 191 },
+        { 187, 223 }, },
+      { { 255, 156 },
+        { 236, 223 },
+        { 57, 255 },
+        { 251, 55 }, },
+      { { 255, 90 },
+        { 237, 237 },
+        { 90, 255 },
+        { 183, 183 }, },
+      { { 247, 254 },
+        { 239, 251 },
+        { 127, 239 },
+        { 223, 247 }, },
+      { { 255, 17 },
+        { 252, 204 },
+        { 136, 255 },
+        { 51, 63 }, },
+      { { 247, 191 },
+        { 255, 219 },
+        { 253, 239 },
+        { 219, 255 }, }, };
+
+static unsigned char DICT_5X5_1000_BYTES[][4][4] =
+    { { { 162, 217, 94, 0 },
+        { 82, 46, 217, 1 },
+        { 61, 77, 162, 1 },
+        { 205, 186, 37, 0 }, },
+      { { 14, 3, 115, 0 },
+        { 176, 198, 133, 0 },
+        { 103, 96, 56, 0 },
+        { 80, 177, 134, 1 }, },
+      { { 215, 135, 110, 1 },
+        { 47, 151, 157, 1 },
+        { 187, 112, 245, 1 },
+        { 220, 244, 250, 0 }, },
+      { { 129, 202, 251, 1 },
+        { 122, 222, 40, 1 },
+        { 239, 169, 192, 1 },
+        { 138, 61, 175, 0 }, },
+      { { 215, 90, 146, 0 },
+        { 116, 27, 236, 0 },
+        { 36, 173, 117, 1 },
+        { 27, 236, 23, 0 }, },
+      { { 234, 4, 22, 1 },
+        { 153, 35, 152, 0 },
+        { 180, 16, 43, 1 },
+        { 12, 226, 76, 1 }, },
+      { { 105, 235, 246, 0 },
+        { 242, 191, 51, 0 },
+        { 55, 235, 203, 0 },
+        { 102, 126, 167, 1 }, },
+      { { 113, 10, 53, 1 },
+        { 60, 249, 16, 0 },
+        { 214, 40, 71, 0 },
+        { 4, 79, 158, 0 }, },
+      { { 134, 176, 153, 0 },
+        { 18, 64, 238, 1 },
+        { 76, 134, 176, 1 },
+        { 187, 129, 36, 0 }, },
+      { { 152, 159, 210, 1 },
+        { 191, 14, 105, 0 },
+        { 165, 252, 140, 1 },
+        { 75, 56, 126, 1 }, },
+      { { 158, 119, 1, 1 },
+        { 237, 64, 207, 0 },
+        { 192, 119, 60, 1 },
+        { 121, 129, 91, 1 }, },
+      { { 209, 109, 96, 0 },
+        { 69, 157, 11, 0 },
+        { 3, 91, 69, 1 },
+        { 104, 92, 209, 0 }, },
+      { { 243, 21, 136, 1 },
+        { 13, 49, 233, 1 },
+        { 136, 212, 103, 1 },
+        { 203, 198, 88, 0 }, },
+      { { 47, 56, 179, 0 },
+        { 144, 250, 230, 0 },
+        { 102, 142, 122, 0 },
+        { 51, 175, 132, 1 }, },
+      { { 254, 126, 84, 0 },
+        { 245, 45, 222, 0 },
+        { 21, 63, 63, 1 },
+        { 61, 218, 87, 1 }, },
+      { { 40, 241, 191, 1 },
+        { 218, 226, 115, 1 },
+        { 254, 199, 138, 0 },
+        { 231, 35, 173, 1 }, },
+      { { 75, 211, 172, 0 },
+        { 226, 145, 241, 1 },
+        { 26, 229, 233, 0 },
+        { 199, 196, 163, 1 }, },
+      { { 95, 81, 55, 1 },
+        { 220, 211, 213, 0 },
+        { 246, 69, 125, 0 },
+        { 85, 229, 157, 1 }, },
+      { { 123, 38, 226, 0 },
+        { 165, 183, 162, 0 },
+        { 35, 178, 111, 0 },
+        { 34, 246, 210, 1 }, },
+      { { 131, 14, 244, 0 },
+        { 49, 156, 184, 0 },
+        { 23, 184, 96, 1 },
+        { 14, 156, 198, 0 }, },
+      { { 150, 237, 58, 1 },
+        { 95, 138, 143, 1 },
+        { 174, 91, 180, 1 },
+        { 248, 168, 253, 0 }, },
+      { { 168, 114, 32, 0 },
+        { 224, 160, 74, 0 },
+        { 2, 39, 10, 1 },
+        { 41, 2, 131, 1 }, },
+      { { 181, 134, 80, 1 },
+        { 63, 52, 12, 0 },
+        { 133, 48, 214, 1 },
+        { 24, 22, 126, 0 }, },
+      { { 93, 9, 111, 0 },
+        { 132, 223, 21, 1 },
+        { 123, 72, 93, 0 },
+        { 212, 125, 144, 1 }, },
+      { { 206, 104, 17, 1 },
+        { 216, 73, 142, 0 },
+        { 196, 11, 57, 1 },
+        { 56, 201, 13, 1 }, },
+      { { 210, 204, 185, 0 },
+        { 87, 201, 168, 1 },
+        { 78, 153, 165, 1 },
+        { 138, 201, 245, 0 }, },
+      { { 225, 231, 69, 1 },
+        { 107, 117, 27, 0 },
+        { 209, 115, 195, 1 },
+        { 108, 87, 107, 0 }, },
+      { { 17, 33, 35, 0 },
+        { 4, 210, 3, 0 },
+        { 98, 66, 68, 0 },
+        { 96, 37, 144, 0 }, },
+      { { 29, 203, 57, 0 },
+        { 246, 216, 5, 1 },
+        { 78, 105, 220, 0 },
+        { 208, 13, 183, 1 }, },
+      { { 18, 17, 29, 1 },
+        { 28, 64, 209, 1 },
+        { 220, 68, 36, 0 },
+        { 197, 129, 28, 0 }, },
+      { { 19, 155, 183, 0 },
+        { 54, 218, 241, 0 },
+        { 118, 236, 228, 0 },
+        { 71, 173, 182, 0 }, },
+      { { 27, 68, 57, 1 },
+        { 221, 208, 128, 1 },
+        { 206, 17, 108, 0 },
+        { 128, 133, 221, 1 }, },
+      { { 32, 104, 103, 0 },
+        { 64, 238, 18, 0 },
+        { 115, 11, 2, 0 },
+        { 36, 59, 129, 0 }, },
+      { { 37, 85, 100, 0 },
+        { 65, 180, 85, 0 },
+        { 19, 85, 82, 0 },
+        { 85, 22, 193, 0 }, },
+      { { 35, 33, 221, 0 },
+        { 16, 116, 179, 1 },
+        { 93, 194, 98, 0 },
+        { 230, 151, 4, 0 }, },
+      { { 61, 55, 245, 0 },
+        { 181, 244, 119, 0 },
+        { 87, 246, 94, 0 },
+        { 119, 23, 214, 1 }, },
+      { { 76, 197, 86, 0 },
+        { 211, 7, 21, 0 },
+        { 53, 81, 153, 0 },
+        { 84, 112, 101, 1 }, },
+      { { 65, 104, 128, 1 },
+        { 72, 25, 34, 0 },
+        { 128, 139, 65, 0 },
+        { 34, 76, 9, 0 }, },
+      { { 77, 86, 142, 1 },
+        { 233, 19, 116, 1 },
+        { 184, 181, 89, 0 },
+        { 151, 100, 75, 1 }, },
+      { { 67, 30, 57, 0 },
+        { 49, 217, 192, 1 },
+        { 78, 60, 97, 0 },
+        { 129, 205, 198, 0 }, },
+      { { 86, 148, 18, 1 },
+        { 31, 3, 196, 0 },
+        { 164, 20, 181, 0 },
+        { 17, 224, 124, 0 }, },
+      { { 82, 151, 207, 0 },
+        { 39, 71, 241, 1 },
+        { 121, 244, 165, 0 },
+        { 199, 241, 114, 0 }, },
+      { { 108, 36, 251, 1 },
+        { 153, 231, 38, 1 },
+        { 239, 146, 27, 0 },
+        { 178, 115, 204, 1 }, },
+      { { 97, 132, 236, 1 },
+        { 11, 181, 48, 1 },
+        { 155, 144, 195, 0 },
+        { 134, 86, 232, 0 }, },
+      { { 109, 63, 24, 1 },
+        { 185, 57, 71, 1 },
+        { 140, 126, 91, 0 },
+        { 241, 78, 78, 1 }, },
+      { { 116, 177, 61, 0 },
+        { 22, 225, 87, 1 },
+        { 94, 70, 151, 0 },
+        { 245, 67, 180, 0 }, },
+      { { 116, 220, 203, 1 },
+        { 79, 111, 100, 1 },
+        { 233, 157, 151, 0 },
+        { 147, 123, 121, 0 }, },
+      { { 124, 164, 3, 0 },
+        { 135, 99, 6, 0 },
+        { 96, 18, 159, 0 },
+        { 48, 99, 112, 1 }, },
+      { { 122, 200, 146, 1 },
+        { 222, 43, 160, 0 },
+        { 164, 137, 175, 0 },
+        { 2, 234, 61, 1 }, },
+      { { 123, 91, 235, 1 },
+        { 236, 255, 225, 1 },
+        { 235, 237, 111, 0 },
+        { 195, 255, 155, 1 }, },
+      { { 141, 172, 114, 0 },
+        { 147, 158, 14, 0 },
+        { 39, 26, 216, 1 },
+        { 56, 60, 228, 1 }, },
+      { { 141, 105, 60, 1 },
+        { 216, 152, 31, 1 },
+        { 158, 75, 88, 1 },
+        { 252, 12, 141, 1 }, },
+      { { 143, 28, 5, 1 },
+        { 137, 88, 220, 0 },
+        { 208, 28, 120, 1 },
+        { 29, 141, 72, 1 }, },
+      { { 139, 74, 34, 1 },
+        { 232, 154, 136, 0 },
+        { 162, 41, 104, 1 },
+        { 8, 172, 139, 1 }, },
+      { { 151, 253, 165, 0 },
+        { 71, 216, 255, 0 },
+        { 82, 223, 244, 1 },
+        { 127, 141, 241, 0 }, },
+      { { 172, 101, 198, 1 },
+        { 201, 38, 63, 0 },
+        { 177, 211, 26, 1 },
+        { 126, 50, 73, 1 }, },
+      { { 172, 195, 248, 0 },
+        { 242, 164, 45, 1 },
+        { 15, 225, 154, 1 },
+        { 218, 18, 167, 1 }, },
+      { { 161, 23, 239, 1 },
+        { 41, 246, 121, 1 },
+        { 251, 244, 66, 1 },
+        { 207, 55, 202, 0 }, },
+      { { 167, 9, 19, 1 },
+        { 24, 122, 141, 0 },
+        { 228, 72, 114, 1 },
+        { 88, 175, 12, 0 }, },
+      { { 171, 111, 145, 0 },
+        { 241, 120, 171, 0 },
+        { 68, 251, 106, 1 },
+        { 106, 143, 71, 1 }, },
+      { { 185, 237, 248, 1 },
+        { 223, 188, 43, 1 },
+        { 143, 219, 206, 1 },
+        { 234, 30, 253, 1 }, },
+      { { 178, 100, 158, 0 },
+        { 85, 34, 186, 1 },
+        { 60, 147, 38, 1 },
+        { 174, 162, 85, 0 }, },
+      { { 190, 93, 195, 0 },
+        { 197, 110, 237, 0 },
+        { 97, 221, 62, 1 },
+        { 91, 187, 81, 1 }, },
+      { { 196, 5, 67, 1 },
+        { 9, 71, 13, 0 },
+        { 225, 80, 17, 1 },
+        { 88, 113, 72, 0 }, },
+      { { 200, 163, 238, 1 },
+        { 170, 135, 59, 1 },
+        { 187, 226, 137, 1 },
+        { 238, 112, 170, 1 }, },
+      { { 194, 117, 197, 0 },
+        { 65, 69, 251, 0 },
+        { 81, 215, 33, 1 },
+        { 111, 209, 65, 0 }, },
+      { { 198, 194, 214, 1 },
+        { 122, 7, 188, 0 },
+        { 181, 161, 177, 1 },
+        { 30, 240, 47, 0 }, },
+      { { 217, 102, 212, 1 },
+        { 253, 21, 58, 0 },
+        { 149, 179, 77, 1 },
+        { 46, 84, 95, 1 }, },
+      { { 221, 94, 185, 1 },
+        { 253, 217, 108, 1 },
+        { 206, 189, 93, 1 },
+        { 155, 77, 223, 1 }, },
+      { { 244, 234, 25, 0 },
+        { 118, 105, 14, 1 },
+        { 76, 43, 151, 1 },
+        { 184, 75, 55, 0 }, },
+      { { 243, 178, 148, 0 },
+        { 54, 49, 250, 0 },
+        { 20, 166, 231, 1 },
+        { 47, 198, 54, 0 }, },
+      { { 122, 186, 5, 0 },
+        { 166, 105, 210, 0 },
+        { 80, 46, 175, 0 },
+        { 37, 203, 50, 1 }, },
+      { { 216, 141, 41, 1 },
+        { 143, 201, 9, 1 },
+        { 202, 88, 141, 1 },
+        { 200, 73, 248, 1 }, },
+      { { 12, 103, 50, 1 },
+        { 249, 130, 7, 0 },
+        { 166, 115, 24, 0 },
+        { 112, 32, 207, 1 }, },
+      { { 21, 89, 12, 1 },
+        { 76, 24, 85, 1 },
+        { 152, 77, 84, 0 },
+        { 213, 12, 25, 0 }, },
+      { { 76, 116, 192, 1 },
+        { 201, 5, 102, 0 },
+        { 129, 151, 25, 0 },
+        { 51, 80, 73, 1 }, },
+      { { 84, 3, 14, 0 },
+        { 36, 3, 21, 1 },
+        { 56, 96, 21, 0 },
+        { 212, 96, 18, 0 }, },
+      { { 160, 208, 172, 0 },
+        { 66, 160, 120, 1 },
+        { 26, 133, 130, 1 },
+        { 143, 2, 161, 0 }, },
+      { { 194, 152, 166, 0 },
+        { 2, 139, 248, 0 },
+        { 50, 140, 161, 1 },
+        { 15, 232, 160, 0 }, },
+      { { 203, 104, 150, 0 },
+        { 208, 27, 186, 0 },
+        { 52, 139, 105, 1 },
+        { 46, 236, 5, 1 }, },
+      { { 253, 105, 209, 0 },
+        { 212, 125, 47, 0 },
+        { 69, 203, 95, 1 },
+        { 122, 95, 21, 1 }, },
+      { { 4, 145, 90, 1 },
+        { 26, 6, 69, 1 },
+        { 173, 68, 144, 0 },
+        { 209, 48, 44, 0 }, },
+      { { 12, 222, 112, 0 },
+        { 243, 140, 68, 0 },
+        { 7, 61, 152, 0 },
+        { 17, 24, 231, 1 }, },
+      { { 5, 170, 62, 0 },
+        { 50, 154, 22, 1 },
+        { 62, 42, 208, 0 },
+        { 180, 44, 166, 0 }, },
+      { { 1, 99, 183, 1 },
+        { 120, 210, 51, 0 },
+        { 246, 227, 64, 0 },
+        { 102, 37, 143, 0 }, },
+      { { 9, 145, 68, 1 },
+        { 138, 20, 81, 0 },
+        { 145, 68, 200, 0 },
+        { 69, 20, 40, 1 }, },
+      { { 9, 105, 83, 1 },
+        { 216, 94, 3, 0 },
+        { 229, 75, 72, 0 },
+        { 96, 61, 13, 1 }, },
+      { { 6, 37, 161, 1 },
+        { 9, 192, 167, 0 },
+        { 194, 210, 48, 0 },
+        { 114, 129, 200, 0 }, },
+      { { 3, 61, 226, 1 },
+        { 9, 158, 227, 0 },
+        { 163, 222, 96, 0 },
+        { 99, 188, 200, 0 }, },
+      { { 7, 213, 6, 1 },
+        { 75, 18, 213, 0 },
+        { 176, 85, 240, 0 },
+        { 85, 164, 105, 0 }, },
+      { { 15, 143, 170, 0 },
+        { 163, 154, 165, 1 },
+        { 42, 248, 248, 0 },
+        { 210, 172, 226, 1 }, },
+      { { 28, 116, 60, 1 },
+        { 221, 128, 86, 1 },
+        { 158, 23, 28, 0 },
+        { 181, 0, 221, 1 }, },
+      { { 25, 29, 145, 1 },
+        { 157, 88, 97, 0 },
+        { 196, 220, 76, 0 },
+        { 67, 13, 92, 1 }, },
+      { { 22, 27, 35, 1 },
+        { 44, 202, 197, 0 },
+        { 226, 108, 52, 0 },
+        { 81, 169, 154, 0 }, },
+      { { 22, 210, 141, 1 },
+        { 110, 64, 244, 1 },
+        { 216, 165, 180, 0 },
+        { 151, 129, 59, 0 }, },
+      { { 23, 78, 198, 1 },
+        { 109, 30, 180, 0 },
+        { 177, 185, 116, 0 },
+        { 22, 188, 91, 0 }, },
+      { { 19, 226, 177, 0 },
+        { 118, 208, 162, 0 },
+        { 70, 163, 228, 0 },
+        { 34, 133, 183, 0 }, },
+      { { 31, 126, 250, 1 },
+        { 253, 158, 230, 1 },
+        { 175, 191, 124, 0 },
+        { 179, 188, 223, 1 }, },
+      { { 41, 15, 112, 0 },
+        { 177, 188, 1, 0 },
+        { 7, 120, 74, 0 },
+        { 64, 30, 198, 1 }, },
+      { { 34, 71, 126, 1 },
+        { 121, 166, 145, 1 },
+        { 191, 113, 34, 0 },
+        { 196, 178, 207, 0 }, },
+      { { 42, 23, 192, 1 },
+        { 169, 36, 225, 0 },
+        { 129, 244, 42, 0 },
+        { 67, 146, 74, 1 }, },
+      { { 42, 251, 100, 1 },
+        { 234, 172, 211, 0 },
+        { 147, 111, 170, 0 },
+        { 101, 154, 171, 1 }, },
+      { { 35, 240, 4, 0 },
+        { 66, 48, 210, 0 },
+        { 16, 7, 226, 0 },
+        { 37, 134, 33, 0 }, },
+      { { 39, 205, 252, 0 },
+        { 83, 188, 181, 1 },
+        { 31, 217, 242, 0 },
+        { 214, 158, 229, 0 }, },
+      { { 35, 106, 172, 0 },
+        { 96, 184, 178, 1 },
+        { 26, 171, 98, 0 },
+        { 166, 142, 131, 0 }, },
+      { { 47, 123, 47, 0 },
+        { 224, 250, 215, 1 },
+        { 122, 111, 122, 0 },
+        { 245, 175, 131, 1 }, },
+      { { 52, 144, 196, 0 },
+        { 6, 36, 116, 0 },
+        { 17, 132, 150, 0 },
+        { 23, 18, 48, 0 }, },
+      { { 48, 9, 214, 1 },
+        { 28, 46, 49, 0 },
+        { 181, 200, 6, 0 },
+        { 70, 58, 28, 0 }, },
+      { { 52, 94, 16, 1 },
+        { 125, 40, 68, 0 },
+        { 132, 61, 22, 0 },
+        { 17, 10, 95, 0 }, },
+      { { 57, 82, 232, 0 },
+        { 228, 180, 96, 1 },
+        { 11, 165, 78, 0 },
+        { 131, 22, 147, 1 }, },
+      { { 50, 0, 113, 0 },
+        { 20, 228, 128, 0 },
+        { 71, 0, 38, 0 },
+        { 0, 147, 148, 0 }, },
+      { { 54, 231, 29, 0 },
+        { 119, 96, 151, 1 },
+        { 92, 115, 182, 0 },
+        { 244, 131, 119, 0 }, },
+      { { 68, 138, 4, 1 },
+        { 42, 9, 20, 0 },
+        { 144, 40, 145, 0 },
+        { 20, 72, 42, 0 }, },
+      { { 68, 236, 254, 1 },
+        { 91, 143, 54, 1 },
+        { 191, 155, 145, 0 },
+        { 182, 120, 237, 0 }, },
+      { { 69, 31, 114, 1 },
+        { 57, 159, 69, 0 },
+        { 167, 124, 81, 0 },
+        { 81, 124, 206, 0 }, },
+      { { 69, 74, 149, 0 },
+        { 112, 89, 52, 0 },
+        { 84, 169, 81, 0 },
+        { 22, 77, 7, 0 }, },
+      { { 70, 19, 190, 1 },
+        { 56, 131, 245, 1 },
+        { 190, 228, 49, 0 },
+        { 215, 224, 142, 0 }, },
+      { { 78, 131, 9, 0 },
+        { 162, 65, 133, 1 },
+        { 72, 96, 185, 0 },
+        { 208, 193, 34, 1 }, },
+      { { 71, 114, 153, 1 },
+        { 120, 81, 230, 1 },
+        { 204, 167, 113, 0 },
+        { 179, 197, 15, 0 }, },
+      { { 79, 130, 125, 1 },
+        { 186, 213, 148, 1 },
+        { 223, 32, 249, 0 },
+        { 148, 213, 174, 1 }, },
+      { { 92, 55, 141, 1 },
+        { 173, 65, 119, 1 },
+        { 216, 246, 29, 0 },
+        { 247, 65, 90, 1 }, },
+      { { 88, 253, 119, 0 },
+        { 215, 207, 83, 0 },
+        { 119, 95, 141, 0 },
+        { 101, 121, 245, 1 }, },
+      { { 81, 183, 248, 0 },
+        { 55, 149, 99, 1 },
+        { 15, 246, 197, 0 },
+        { 227, 84, 246, 0 }, },
+      { { 89, 58, 251, 0 },
+        { 180, 223, 98, 1 },
+        { 111, 174, 77, 0 },
+        { 163, 125, 150, 1 }, },
+      { { 90, 153, 153, 0 },
+        { 150, 73, 225, 1 },
+        { 76, 204, 173, 0 },
+        { 195, 201, 52, 1 }, },
+      { { 83, 1, 240, 1 },
+        { 28, 149, 161, 0 },
+        { 135, 192, 101, 0 },
+        { 66, 212, 156, 0 }, },
+      { { 83, 204, 103, 1 },
+        { 79, 223, 144, 0 },
+        { 243, 25, 229, 0 },
+        { 4, 253, 249, 0 }, },
+      { { 83, 110, 1, 0 },
+        { 101, 89, 130, 0 },
+        { 64, 59, 101, 0 },
+        { 32, 205, 83, 0 }, },
+      { { 91, 37, 175, 1 },
+        { 141, 211, 179, 1 },
+        { 250, 210, 109, 0 },
+        { 230, 229, 216, 1 }, },
+      { { 95, 213, 204, 1 },
+        { 207, 21, 245, 1 },
+        { 153, 213, 253, 0 },
+        { 215, 212, 121, 1 }, },
+      { { 101, 102, 66, 1 },
+        { 105, 55, 6, 0 },
+        { 161, 51, 83, 0 },
+        { 48, 118, 75, 0 }, },
+      { { 101, 199, 175, 0 },
+        { 99, 243, 53, 1 },
+        { 122, 241, 211, 0 },
+        { 214, 103, 227, 0 }, },
+      { { 102, 55, 81, 0 },
+        { 49, 101, 199, 0 },
+        { 69, 118, 51, 0 },
+        { 113, 211, 70, 0 }, },
+      { { 103, 12, 197, 1 },
+        { 9, 125, 180, 0 },
+        { 209, 152, 115, 0 },
+        { 22, 223, 72, 0 }, },
+      { { 112, 150, 93, 1 },
+        { 63, 101, 80, 1 },
+        { 221, 52, 135, 0 },
+        { 133, 83, 126, 0 }, },
+      { { 124, 99, 128, 1 },
+        { 236, 33, 39, 0 },
+        { 128, 227, 31, 0 },
+        { 114, 66, 27, 1 }, },
+      { { 121, 171, 169, 0 },
+        { 166, 249, 35, 1 },
+        { 74, 234, 207, 0 },
+        { 226, 79, 178, 1 }, },
+      { { 114, 61, 70, 0 },
+        { 5, 47, 211, 0 },
+        { 49, 94, 39, 0 },
+        { 101, 250, 80, 0 }, },
+      { { 115, 229, 178, 1 },
+        { 95, 179, 163, 0 },
+        { 166, 211, 231, 0 },
+        { 98, 230, 253, 0 }, },
+      { { 132, 38, 140, 0 },
+        { 33, 0, 62, 1 },
+        { 24, 178, 16, 1 },
+        { 190, 0, 66, 0 }, },
+      { { 137, 241, 1, 0 },
+        { 194, 80, 75, 0 },
+        { 64, 71, 200, 1 },
+        { 105, 5, 33, 1 }, },
+      { { 134, 174, 233, 1 },
+        { 43, 204, 174, 1 },
+        { 203, 186, 176, 1 },
+        { 186, 153, 234, 0 }, },
+      { { 138, 35, 249, 1 },
+        { 184, 196, 171, 1 },
+        { 207, 226, 40, 1 },
+        { 234, 145, 142, 1 }, },
+      { { 148, 53, 113, 1 },
+        { 29, 196, 79, 0 },
+        { 199, 86, 20, 1 },
+        { 121, 17, 220, 0 }, },
+      { { 156, 69, 27, 0 },
+        { 213, 66, 13, 1 },
+        { 108, 81, 28, 1 },
+        { 216, 33, 85, 1 }, },
+      { { 149, 31, 164, 1 },
+        { 45, 152, 125, 0 },
+        { 146, 252, 84, 1 },
+        { 95, 12, 218, 0 }, },
+      { { 150, 141, 144, 0 },
+        { 23, 8, 173, 0 },
+        { 4, 216, 180, 1 },
+        { 90, 136, 116, 0 }, },
+      { { 151, 38, 183, 0 },
+        { 53, 210, 190, 0 },
+        { 118, 178, 116, 1 },
+        { 62, 165, 214, 0 }, },
+      { { 155, 55, 103, 0 },
+        { 165, 214, 219, 0 },
+        { 115, 118, 108, 1 },
+        { 109, 181, 210, 1 }, },
+      { { 155, 198, 224, 1 },
+        { 239, 148, 168, 0 },
+        { 131, 177, 236, 1 },
+        { 10, 148, 251, 1 }, },
+      { { 160, 154, 110, 1 },
+        { 42, 174, 88, 1 },
+        { 187, 44, 130, 1 },
+        { 141, 58, 170, 0 }, },
+      { { 164, 82, 134, 1 },
+        { 104, 34, 124, 0 },
+        { 176, 165, 18, 1 },
+        { 31, 34, 11, 0 }, },
+      { { 168, 176, 133, 1 },
+        { 138, 96, 122, 0 },
+        { 208, 134, 138, 1 },
+        { 47, 3, 40, 1 }, },
+      { { 173, 155, 66, 0 },
+        { 162, 62, 77, 0 },
+        { 33, 108, 218, 1 },
+        { 89, 62, 34, 1 }, },
+      { { 175, 240, 88, 1 },
+        { 218, 52, 206, 1 },
+        { 141, 7, 250, 1 },
+        { 185, 150, 45, 1 }, },
+      { { 176, 46, 99, 1 },
+        { 45, 238, 10, 0 },
+        { 227, 58, 6, 1 },
+        { 40, 59, 218, 0 }, },
+      { { 176, 15, 24, 0 },
+        { 53, 40, 9, 1 },
+        { 12, 120, 6, 1 },
+        { 200, 10, 86, 0 }, },
+      { { 188, 234, 178, 1 },
+        { 254, 170, 46, 0 },
+        { 166, 171, 158, 1 },
+        { 58, 42, 191, 1 }, },
+      { { 190, 196, 76, 1 },
+        { 207, 36, 156, 1 },
+        { 153, 17, 190, 1 },
+        { 156, 146, 121, 1 }, },
+      { { 179, 130, 250, 0 },
+        { 54, 182, 168, 1 },
+        { 47, 160, 230, 1 },
+        { 138, 182, 182, 0 }, },
+      { { 179, 88, 60, 1 },
+        { 92, 184, 216, 1 },
+        { 158, 13, 102, 1 },
+        { 141, 142, 157, 0 }, },
+      { { 191, 69, 238, 0 },
+        { 197, 182, 189, 1 },
+        { 59, 209, 126, 1 },
+        { 222, 182, 209, 1 }, },
+      { { 191, 86, 51, 1 },
+        { 253, 242, 204, 0 },
+        { 230, 53, 126, 1 },
+        { 25, 167, 223, 1 }, },
+      { { 196, 58, 240, 0 },
+        { 48, 141, 110, 0 },
+        { 7, 174, 17, 1 },
+        { 59, 88, 134, 0 }, },
+      { { 204, 233, 131, 0 },
+        { 194, 75, 47, 0 },
+        { 96, 203, 153, 1 },
+        { 122, 105, 33, 1 }, },
+      { { 197, 51, 0, 1 },
+        { 40, 17, 79, 0 },
+        { 128, 102, 81, 1 },
+        { 121, 68, 10, 0 }, },
+      { { 205, 34, 99, 1 },
+        { 168, 215, 14, 0 },
+        { 227, 34, 89, 1 },
+        { 56, 117, 138, 1 }, },
+      { { 198, 8, 138, 1 },
+        { 8, 11, 172, 1 },
+        { 168, 136, 49, 1 },
+        { 154, 232, 8, 0 }, },
+      { { 198, 148, 63, 0 },
+        { 19, 195, 220, 1 },
+        { 126, 20, 177, 1 },
+        { 157, 225, 228, 0 }, },
+      { { 202, 238, 132, 1 },
+        { 235, 9, 186, 0 },
+        { 144, 187, 169, 1 },
+        { 46, 200, 107, 1 }, },
+      { { 207, 167, 18, 1 },
+        { 187, 19, 143, 0 },
+        { 164, 114, 249, 1 },
+        { 120, 228, 110, 1 }, },
+      { { 203, 97, 226, 1 },
+        { 200, 151, 171, 0 },
+        { 163, 195, 105, 1 },
+        { 106, 244, 137, 1 }, },
+      { { 208, 2, 233, 0 },
+        { 36, 197, 40, 1 },
+        { 75, 160, 5, 1 },
+        { 138, 81, 146, 0 }, },
+      { { 220, 183, 70, 0 },
+        { 167, 7, 95, 0 },
+        { 49, 118, 157, 1 },
+        { 125, 112, 114, 1 }, },
+      { { 217, 139, 132, 1 },
+        { 174, 25, 57, 0 },
+        { 144, 232, 205, 1 },
+        { 78, 76, 58, 1 }, },
+      { { 217, 206, 178, 0 },
+        { 247, 155, 40, 0 },
+        { 38, 185, 205, 1 },
+        { 10, 108, 247, 1 }, },
+      { { 210, 153, 64, 1 },
+        { 14, 13, 201, 0 },
+        { 129, 76, 165, 1 },
+        { 73, 216, 56, 0 }, },
+      { { 210, 209, 23, 0 },
+        { 86, 67, 217, 0 },
+        { 116, 69, 165, 1 },
+        { 77, 225, 53, 0 }, },
+      { { 222, 90, 110, 1 },
+        { 236, 143, 220, 1 },
+        { 187, 45, 61, 1 },
+        { 157, 248, 155, 1 }, },
+      { { 218, 71, 66, 1 },
+        { 237, 7, 137, 0 },
+        { 161, 113, 45, 1 },
+        { 72, 240, 91, 1 }, },
+      { { 219, 60, 16, 0 },
+        { 149, 25, 202, 0 },
+        { 4, 30, 109, 1 },
+        { 41, 204, 84, 1 }, },
+      { { 219, 143, 201, 0 },
+        { 167, 93, 169, 1 },
+        { 73, 248, 237, 1 },
+        { 202, 221, 114, 1 }, },
+      { { 232, 24, 227, 1 },
+        { 136, 239, 104, 0 },
+        { 227, 140, 11, 1 },
+        { 11, 123, 136, 1 }, },
+      { { 229, 28, 111, 0 },
+        { 1, 255, 92, 1 },
+        { 123, 28, 83, 1 },
+        { 157, 127, 192, 0 }, },
+      { { 225, 174, 56, 1 },
+        { 59, 185, 10, 1 },
+        { 142, 58, 195, 1 },
+        { 168, 78, 238, 0 }, },
+      { { 237, 185, 123, 1 },
+        { 154, 255, 79, 1 },
+        { 239, 78, 219, 1 },
+        { 249, 127, 172, 1 }, },
+      { { 233, 224, 50, 0 },
+        { 210, 179, 10, 0 },
+        { 38, 3, 203, 1 },
+        { 40, 102, 165, 1 }, },
+      { { 235, 93, 12, 0 },
+        { 193, 57, 217, 1 },
+        { 24, 93, 107, 1 },
+        { 205, 206, 65, 1 }, },
+      { { 239, 249, 157, 0 },
+        { 210, 121, 255, 1 },
+        { 92, 207, 251, 1 },
+        { 255, 207, 37, 1 }, },
+      { { 248, 17, 1, 0 },
+        { 132, 97, 73, 0 },
+        { 64, 68, 15, 1 },
+        { 73, 67, 16, 1 }, },
+      { { 248, 7, 211, 0 },
+        { 181, 103, 41, 0 },
+        { 101, 240, 15, 1 },
+        { 74, 115, 86, 1 }, },
+      { { 246, 2, 32, 1 },
+        { 44, 161, 140, 0 },
+        { 130, 32, 55, 1 },
+        { 24, 194, 154, 0 }, },
+      { { 246, 27, 95, 1 },
+        { 60, 111, 221, 1 },
+        { 253, 108, 55, 1 },
+        { 221, 251, 30, 0 }, },
+      { { 254, 181, 237, 0 },
+        { 135, 229, 255, 1 },
+        { 91, 214, 191, 1 },
+        { 255, 211, 240, 1 }, },
+      { { 250, 51, 56, 1 },
+        { 188, 161, 203, 1 },
+        { 142, 102, 47, 1 },
+        { 233, 194, 158, 1 }, },
+      { { 250, 74, 193, 1 },
+        { 236, 109, 168, 0 },
+        { 193, 169, 47, 1 },
+        { 10, 219, 27, 1 }, },
+      { { 247, 47, 112, 1 },
+        { 61, 189, 143, 0 },
+        { 135, 122, 119, 1 },
+        { 120, 222, 222, 0 }, },
+      { { 247, 234, 252, 1 },
+        { 126, 189, 190, 1 },
+        { 159, 171, 247, 1 },
+        { 190, 222, 191, 0 }, },
+      { { 255, 24, 148, 1 },
+        { 156, 57, 252, 0 },
+        { 148, 140, 127, 1 },
+        { 31, 206, 28, 1 }, },
+      { { 251, 163, 94, 0 },
+        { 182, 55, 155, 1 },
+        { 61, 98, 239, 1 },
+        { 236, 246, 54, 1 }, },
+      { { 104, 184, 47, 0 },
+        { 130, 235, 82, 1 },
+        { 122, 14, 139, 0 },
+        { 165, 107, 160, 1 }, },
+      { { 153, 15, 11, 1 },
+        { 173, 90, 9, 1 },
+        { 232, 120, 76, 1 },
+        { 200, 45, 90, 1 }, },
+      { { 153, 216, 38, 1 },
+        { 206, 154, 88, 0 },
+        { 178, 13, 204, 1 },
+        { 13, 44, 185, 1 }, },
+      { { 228, 95, 14, 1 },
+        { 105, 43, 93, 1 },
+        { 184, 125, 19, 1 },
+        { 221, 106, 75, 0 }, },
+      { { 29, 16, 110, 1 },
+        { 140, 150, 84, 1 },
+        { 187, 4, 92, 0 },
+        { 149, 52, 152, 1 }, },
+      { { 42, 193, 48, 1 },
+        { 218, 160, 129, 0 },
+        { 134, 65, 170, 0 },
+        { 64, 130, 173, 1 }, },
+      { { 52, 65, 99, 1 },
+        { 76, 230, 5, 0 },
+        { 227, 65, 22, 0 },
+        { 80, 51, 153, 0 }, },
+      { { 55, 192, 116, 1 },
+        { 94, 180, 148, 0 },
+        { 151, 1, 246, 0 },
+        { 20, 150, 189, 0 }, },
+      { { 63, 53, 203, 1 },
+        { 141, 118, 231, 1 },
+        { 233, 214, 126, 0 },
+        { 243, 183, 88, 1 }, },
+      { { 86, 160, 76, 0 },
+        { 6, 5, 150, 1 },
+        { 25, 2, 181, 0 },
+        { 180, 208, 48, 0 }, },
+      { { 87, 56, 57, 1 },
+        { 28, 217, 198, 1 },
+        { 206, 14, 117, 0 },
+        { 177, 205, 156, 0 }, },
+      { { 102, 152, 184, 0 },
+        { 18, 169, 228, 1 },
+        { 14, 140, 179, 0 },
+        { 147, 202, 164, 0 }, },
+      { { 115, 165, 23, 0 },
+        { 23, 115, 147, 0 },
+        { 116, 82, 231, 0 },
+        { 100, 231, 116, 0 }, },
+      { { 127, 44, 253, 1 },
+        { 157, 253, 182, 1 },
+        { 223, 154, 127, 0 },
+        { 182, 223, 220, 1 }, },
+      { { 139, 71, 233, 0 },
+        { 225, 212, 169, 1 },
+        { 75, 241, 104, 1 },
+        { 202, 149, 195, 1 }, },
+      { { 165, 195, 151, 0 },
+        { 114, 114, 61, 0 },
+        { 116, 225, 210, 1 },
+        { 94, 39, 39, 0 }, },
+      { { 169, 169, 235, 0 },
+        { 130, 254, 43, 1 },
+        { 107, 202, 202, 1 },
+        { 234, 63, 160, 1 }, },
+      { { 181, 25, 183, 0 },
+        { 20, 250, 125, 0 },
+        { 118, 204, 86, 1 },
+        { 95, 47, 148, 0 }, },
+      { { 178, 218, 153, 1 },
+        { 126, 104, 232, 1 },
+        { 204, 173, 166, 1 },
+        { 139, 139, 63, 0 }, },
+      { { 196, 193, 244, 0 },
+        { 82, 133, 61, 0 },
+        { 23, 193, 145, 1 },
+        { 94, 80, 165, 0 }, },
+      { { 202, 185, 30, 0 },
+        { 146, 11, 219, 1 },
+        { 60, 78, 169, 1 },
+        { 237, 232, 36, 1 }, },
+      { { 216, 111, 163, 1 },
+        { 237, 203, 43, 0 },
+        { 226, 251, 13, 1 },
+        { 106, 105, 219, 1 }, },
+      { { 223, 141, 142, 0 },
+        { 135, 27, 189, 1 },
+        { 56, 216, 253, 1 },
+        { 222, 236, 112, 1 }, },
+      { { 229, 102, 143, 1 },
+        { 105, 115, 62, 1 },
+        { 248, 179, 83, 1 },
+        { 190, 103, 75, 0 }, },
+      { { 237, 71, 26, 1 },
+        { 249, 51, 13, 1 },
+        { 172, 113, 91, 1 },
+        { 216, 102, 79, 1 }, },
+      { { 240, 103, 134, 1 },
+        { 109, 35, 59, 0 },
+        { 176, 243, 7, 1 },
+        { 110, 98, 91, 0 }, },
+      { { 4, 41, 238, 1 },
+        { 8, 142, 55, 1 },
+        { 187, 202, 16, 0 },
+        { 246, 56, 136, 0 }, },
+      { { 0, 35, 71, 1 },
+        { 40, 70, 19, 0 },
+        { 241, 98, 0, 0 },
+        { 100, 49, 10, 0 }, },
+      { { 0, 162, 251, 0 },
+        { 50, 198, 34, 1 },
+        { 111, 162, 128, 0 },
+        { 162, 49, 166, 0 }, },
+      { { 4, 200, 206, 0 },
+        { 66, 14, 52, 1 },
+        { 57, 137, 144, 0 },
+        { 150, 56, 33, 0 }, },
+      { { 0, 210, 225, 1 },
+        { 106, 196, 96, 0 },
+        { 195, 165, 128, 0 },
+        { 3, 17, 171, 0 }, },
+      { { 12, 10, 15, 0 },
+        { 160, 74, 20, 1 },
+        { 120, 40, 24, 0 },
+        { 148, 41, 2, 1 }, },
+      { { 8, 139, 198, 0 },
+        { 162, 14, 49, 0 },
+        { 49, 232, 136, 0 },
+        { 70, 56, 34, 1 }, },
+      { { 12, 134, 91, 0 },
+        { 179, 70, 4, 1 },
+        { 109, 48, 152, 0 },
+        { 144, 49, 102, 1 }, },
+      { { 5, 129, 253, 0 },
+        { 18, 212, 53, 1 },
+        { 95, 192, 208, 0 },
+        { 214, 21, 164, 0 }, },
+      { { 1, 113, 30, 0 },
+        { 80, 18, 83, 1 },
+        { 60, 71, 64, 0 },
+        { 229, 36, 5, 0 }, },
+      { { 1, 194, 21, 1 },
+        { 122, 80, 16, 0 },
+        { 212, 33, 192, 0 },
+        { 4, 5, 47, 0 }, },
+      { { 1, 231, 113, 0 },
+        { 115, 212, 3, 0 },
+        { 71, 115, 192, 0 },
+        { 96, 21, 231, 0 }, },
+      { { 9, 41, 191, 0 },
+        { 144, 218, 51, 1 },
+        { 126, 202, 72, 0 },
+        { 230, 45, 132, 1 }, },
+      { { 13, 16, 27, 1 },
+        { 152, 82, 68, 1 },
+        { 236, 4, 88, 0 },
+        { 145, 37, 12, 1 }, },
+      { { 13, 5, 24, 0 },
+        { 145, 16, 5, 1 },
+        { 12, 80, 88, 0 },
+        { 208, 4, 68, 1 }, },
+      { { 13, 237, 47, 1 },
+        { 203, 218, 23, 1 },
+        { 250, 91, 216, 0 },
+        { 244, 45, 233, 1 }, },
+      { { 13, 102, 222, 0 },
+        { 241, 22, 54, 1 },
+        { 61, 179, 88, 0 },
+        { 182, 52, 71, 1 }, },
+      { { 9, 242, 118, 0 },
+        { 242, 150, 82, 0 },
+        { 55, 39, 200, 0 },
+        { 37, 52, 167, 1 }, },
+      { { 2, 208, 130, 1 },
+        { 74, 2, 224, 0 },
+        { 160, 133, 160, 0 },
+        { 3, 160, 41, 0 }, },
+      { { 2, 98, 201, 0 },
+        { 96, 68, 162, 1 },
+        { 73, 163, 32, 0 },
+        { 162, 145, 3, 0 }, },
+      { { 6, 243, 169, 0 },
+        { 98, 192, 231, 1 },
+        { 74, 231, 176, 0 },
+        { 243, 129, 163, 0 }, },
+      { { 6, 239, 35, 0 },
+        { 99, 202, 135, 0 },
+        { 98, 123, 176, 0 },
+        { 112, 169, 227, 0 }, },
+      { { 14, 62, 18, 0 },
+        { 177, 10, 198, 0 },
+        { 36, 62, 56, 0 },
+        { 49, 168, 70, 1 }, },
+      { { 10, 154, 221, 1 },
+        { 186, 76, 240, 1 },
+        { 221, 172, 168, 0 },
+        { 135, 153, 46, 1 }, },
+      { { 10, 97, 109, 1 },
+        { 200, 196, 147, 1 },
+        { 219, 67, 40, 0 },
+        { 228, 145, 137, 1 }, },
+      { { 10, 255, 81, 0 },
+        { 243, 76, 195, 0 },
+        { 69, 127, 168, 0 },
+        { 97, 153, 103, 1 }, },
+      { { 7, 230, 114, 1 },
+        { 123, 150, 134, 0 },
+        { 167, 51, 240, 0 },
+        { 48, 180, 239, 0 }, },
+      { { 11, 154, 1, 0 },
+        { 162, 88, 192, 0 },
+        { 64, 44, 232, 0 },
+        { 1, 141, 34, 1 }, },
+      { { 15, 208, 142, 0 },
+        { 194, 18, 244, 1 },
+        { 56, 133, 248, 0 },
+        { 151, 164, 33, 1 }, },
+      { { 15, 73, 147, 0 },
+        { 208, 90, 165, 0 },
+        { 100, 201, 120, 0 },
+        { 82, 173, 5, 1 }, },
+      { { 15, 247, 123, 0 },
+        { 243, 214, 199, 1 },
+        { 111, 119, 248, 0 },
+        { 241, 181, 231, 1 }, },
+      { { 16, 158, 96, 1 },
+        { 47, 140, 64, 0 },
+        { 131, 60, 132, 0 },
+        { 1, 24, 250, 0 }, },
+      { { 16, 81, 237, 0 },
+        { 68, 196, 113, 1 },
+        { 91, 197, 4, 0 },
+        { 199, 17, 145, 0 }, },
+      { { 20, 122, 222, 1 },
+        { 124, 14, 118, 1 },
+        { 189, 175, 20, 0 },
+        { 183, 56, 31, 0 }, },
+      { { 28, 133, 62, 1 },
+        { 159, 130, 21, 1 },
+        { 190, 80, 156, 0 },
+        { 212, 32, 252, 1 }, },
+      { { 28, 35, 104, 0 },
+        { 164, 132, 7, 1 },
+        { 11, 98, 28, 0 },
+        { 240, 16, 146, 1 }, },
+      { { 24, 199, 52, 0 },
+        { 247, 128, 17, 0 },
+        { 22, 113, 140, 0 },
+        { 68, 0, 247, 1 }, },
+      { { 21, 251, 130, 1 },
+        { 110, 26, 103, 0 },
+        { 160, 239, 212, 0 },
+        { 115, 44, 59, 0 }, },
+      { { 17, 78, 147, 1 },
+        { 125, 90, 32, 0 },
+        { 228, 185, 68, 0 },
+        { 2, 45, 95, 0 }, },
+      { { 25, 160, 234, 1 },
+        { 142, 150, 34, 1 },
+        { 171, 130, 204, 0 },
+        { 162, 52, 184, 1 }, },
+      { { 18, 24, 76, 0 },
+        { 4, 12, 208, 1 },
+        { 25, 12, 36, 0 },
+        { 133, 152, 16, 0 }, },
+      { { 18, 163, 174, 0 },
+        { 38, 130, 179, 1 },
+        { 58, 226, 164, 0 },
+        { 230, 160, 178, 0 }, },
+      { { 30, 172, 60, 0 },
+        { 151, 136, 150, 1 },
+        { 30, 26, 188, 0 },
+        { 180, 136, 244, 1 }, },
+      { { 30, 201, 108, 0 },
+        { 198, 140, 149, 1 },
+        { 27, 73, 188, 0 },
+        { 212, 152, 177, 1 }, },
+      { { 30, 233, 163, 1 },
+        { 206, 202, 167, 0 },
+        { 226, 203, 188, 0 },
+        { 114, 169, 185, 1 }, },
+      { { 26, 118, 216, 0 },
+        { 245, 4, 226, 1 },
+        { 13, 183, 44, 0 },
+        { 163, 144, 87, 1 }, },
+      { { 19, 182, 7, 1 },
+        { 47, 82, 210, 0 },
+        { 240, 54, 228, 0 },
+        { 37, 165, 122, 0 }, },
+      { { 23, 70, 188, 0 },
+        { 117, 144, 180, 1 },
+        { 30, 177, 116, 0 },
+        { 150, 132, 215, 0 }, },
+      { { 31, 21, 121, 0 },
+        { 149, 212, 197, 1 },
+        { 79, 84, 124, 0 },
+        { 209, 149, 212, 1 }, },
+      { { 27, 35, 125, 0 },
+        { 180, 212, 147, 1 },
+        { 95, 98, 108, 0 },
+        { 228, 149, 150, 1 }, },
+      { { 27, 191, 146, 0 },
+        { 183, 26, 227, 0 },
+        { 36, 254, 236, 0 },
+        { 99, 172, 118, 1 }, },
+      { { 31, 150, 154, 1 },
+        { 191, 18, 228, 1 },
+        { 172, 180, 252, 0 },
+        { 147, 164, 126, 1 }, },
+      { { 27, 72, 235, 0 },
+        { 196, 222, 160, 1 },
+        { 107, 137, 108, 0 },
+        { 130, 189, 145, 1 }, },
+      { { 32, 12, 253, 0 },
+        { 17, 236, 48, 1 },
+        { 95, 152, 2, 0 },
+        { 134, 27, 196, 0 }, },
+      { { 32, 23, 86, 0 },
+        { 49, 38, 81, 0 },
+        { 53, 116, 2, 0 },
+        { 69, 50, 70, 0 }, },
+      { { 40, 1, 153, 1 },
+        { 152, 96, 33, 1 },
+        { 204, 192, 10, 0 },
+        { 194, 3, 12, 1 }, },
+      { { 44, 50, 55, 1 },
+        { 184, 226, 86, 0 },
+        { 246, 38, 26, 0 },
+        { 53, 35, 142, 1 }, },
+      { { 37, 140, 230, 0 },
+        { 3, 190, 52, 0 },
+        { 51, 152, 210, 0 },
+        { 22, 62, 224, 0 }, },
+      { { 33, 30, 140, 0 },
+        { 33, 56, 112, 1 },
+        { 24, 188, 66, 0 },
+        { 135, 14, 66, 0 }, },
+      { { 45, 125, 105, 0 },
+        { 193, 252, 71, 1 },
+        { 75, 95, 90, 0 },
+        { 241, 31, 193, 1 }, },
+      { { 41, 192, 73, 0 },
+        { 194, 116, 0, 1 },
+        { 73, 1, 202, 0 },
+        { 128, 23, 33, 1 }, },
+      { { 38, 177, 32, 0 },
+        { 2, 160, 199, 0 },
+        { 2, 70, 178, 0 },
+        { 113, 130, 160, 0 }, },
+      { { 38, 128, 28, 1 },
+        { 26, 32, 148, 1 },
+        { 156, 0, 178, 0 },
+        { 148, 130, 44, 0 }, },
+      { { 34, 180, 26, 0 },
+        { 19, 34, 194, 1 },
+        { 44, 22, 162, 0 },
+        { 161, 162, 100, 0 }, },
+      { { 38, 42, 68, 1 },
+        { 40, 44, 150, 0 },
+        { 145, 42, 50, 0 },
+        { 52, 154, 10, 0 }, },
+      { { 38, 171, 89, 0 },
+        { 50, 108, 135, 1 },
+        { 77, 106, 178, 0 },
+        { 240, 155, 38, 0 }, },
+      { { 38, 201, 132, 0 },
+        { 66, 40, 181, 0 },
+        { 16, 201, 178, 0 },
+        { 86, 138, 33, 0 }, },
+      { { 42, 48, 98, 1 },
+        { 136, 166, 194, 0 },
+        { 163, 6, 42, 0 },
+        { 33, 178, 136, 1 }, },
+      { { 46, 50, 173, 0 },
+        { 160, 224, 246, 1 },
+        { 90, 166, 58, 0 },
+        { 183, 131, 130, 1 }, },
+      { { 35, 63, 1, 1 },
+        { 41, 120, 195, 0 },
+        { 192, 126, 98, 0 },
+        { 97, 143, 74, 0 }, },
+      { { 35, 131, 80, 0 },
+        { 50, 52, 129, 0 },
+        { 5, 96, 226, 0 },
+        { 64, 150, 38, 0 }, },
+      { { 39, 100, 46, 1 },
+        { 73, 178, 150, 1 },
+        { 186, 19, 114, 0 },
+        { 180, 166, 201, 0 }, },
+      { { 39, 212, 176, 1 },
+        { 91, 176, 228, 0 },
+        { 134, 149, 242, 0 },
+        { 19, 134, 237, 0 }, },
+      { { 47, 186, 44, 1 },
+        { 170, 184, 214, 1 },
+        { 154, 46, 250, 0 },
+        { 181, 142, 170, 1 }, },
+      { { 43, 38, 186, 1 },
+        { 185, 178, 162, 1 },
+        { 174, 178, 106, 0 },
+        { 162, 166, 206, 1 }, },
+      { { 48, 11, 141, 0 },
+        { 36, 104, 49, 1 },
+        { 88, 232, 6, 0 },
+        { 198, 11, 18, 0 }, },
+      { { 52, 38, 146, 1 },
+        { 61, 34, 38, 0 },
+        { 164, 178, 22, 0 },
+        { 50, 34, 94, 0 }, },
+      { { 48, 130, 25, 0 },
+        { 54, 96, 0, 1 },
+        { 76, 32, 134, 0 },
+        { 128, 3, 54, 0 }, },
+      { { 48, 123, 44, 1 },
+        { 108, 168, 83, 1 },
+        { 154, 111, 6, 0 },
+        { 229, 10, 155, 0 }, },
+      { { 60, 184, 59, 1 },
+        { 158, 234, 70, 1 },
+        { 238, 14, 158, 0 },
+        { 177, 43, 188, 1 }, },
+      { { 60, 38, 15, 1 },
+        { 173, 98, 22, 1 },
+        { 248, 50, 30, 0 },
+        { 180, 35, 90, 1 }, },
+      { { 56, 233, 220, 0 },
+        { 214, 44, 51, 1 },
+        { 29, 203, 142, 0 },
+        { 230, 26, 53, 1 }, },
+      { { 60, 192, 247, 0 },
+        { 214, 230, 52, 0 },
+        { 119, 129, 158, 0 },
+        { 22, 51, 181, 1 }, },
+      { { 56, 247, 84, 1 },
+        { 255, 36, 83, 0 },
+        { 149, 119, 142, 0 },
+        { 101, 18, 127, 1 }, },
+      { { 49, 5, 180, 1 },
+        { 29, 176, 49, 0 },
+        { 150, 208, 70, 0 },
+        { 70, 6, 220, 0 }, },
+      { { 53, 184, 254, 1 },
+        { 30, 190, 118, 1 },
+        { 191, 142, 214, 0 },
+        { 183, 62, 188, 0 }, },
+      { { 53, 178, 211, 1 },
+        { 62, 118, 102, 0 },
+        { 229, 166, 214, 0 },
+        { 51, 55, 62, 0 }, },
+      { { 57, 155, 206, 1 },
+        { 174, 62, 113, 1 },
+        { 185, 236, 206, 0 },
+        { 199, 62, 58, 1 }, },
+      { { 57, 109, 46, 0 },
+        { 197, 186, 19, 1 },
+        { 58, 91, 78, 0 },
+        { 228, 46, 209, 1 }, },
+      { { 61, 224, 131, 1 },
+        { 206, 114, 38, 0 },
+        { 224, 131, 222, 0 },
+        { 50, 39, 57, 1 }, },
+      { { 57, 244, 208, 0 },
+        { 215, 52, 98, 0 },
+        { 5, 151, 206, 0 },
+        { 35, 22, 117, 1 }, },
+      { { 57, 255, 32, 0 },
+        { 231, 184, 67, 0 },
+        { 2, 127, 206, 0 },
+        { 97, 14, 243, 1 }, },
+      { { 57, 199, 136, 1 },
+        { 239, 48, 33, 1 },
+        { 136, 241, 206, 0 },
+        { 194, 6, 123, 1 }, },
+      { { 54, 15, 36, 0 },
+        { 37, 168, 149, 0 },
+        { 18, 120, 54, 0 },
+        { 84, 138, 210, 0 }, },
+      { { 50, 30, 213, 0 },
+        { 53, 108, 240, 0 },
+        { 85, 188, 38, 0 },
+        { 7, 155, 86, 0 }, },
+      { { 54, 191, 209, 1 },
+        { 63, 108, 231, 0 },
+        { 197, 254, 182, 0 },
+        { 115, 155, 126, 0 }, },
+      { { 54, 70, 235, 0 },
+        { 101, 230, 164, 1 },
+        { 107, 177, 54, 0 },
+        { 146, 179, 211, 0 }, },
+      { { 58, 45, 168, 0 },
+        { 133, 168, 163, 1 },
+        { 10, 218, 46, 0 },
+        { 226, 138, 208, 1 }, },
+      { { 58, 147, 187, 0 },
+        { 182, 226, 225, 1 },
+        { 110, 228, 174, 0 },
+        { 195, 163, 182, 1 }, },
+      { { 55, 149, 173, 0 },
+        { 7, 240, 245, 1 },
+        { 90, 212, 246, 0 },
+        { 215, 135, 240, 0 }, },
+      { { 55, 4, 147, 0 },
+        { 21, 114, 164, 0 },
+        { 100, 144, 118, 0 },
+        { 18, 167, 84, 0 }, },
+      { { 51, 160, 216, 1 },
+        { 30, 52, 162, 1 },
+        { 141, 130, 230, 0 },
+        { 162, 150, 60, 0 }, },
+      { { 55, 67, 167, 0 },
+        { 100, 242, 181, 0 },
+        { 114, 225, 118, 0 },
+        { 86, 167, 147, 0 }, },
+      { { 51, 250, 92, 0 },
+        { 118, 60, 210, 1 },
+        { 29, 47, 230, 0 },
+        { 165, 158, 55, 0 }, },
+      { { 63, 131, 110, 0 },
+        { 166, 182, 149, 1 },
+        { 59, 96, 254, 0 },
+        { 212, 182, 178, 1 }, },
+      { { 63, 107, 96, 0 },
+        { 228, 188, 135, 0 },
+        { 3, 107, 126, 0 },
+        { 112, 158, 147, 1 }, },
+      { { 64, 225, 205, 0 },
+        { 66, 69, 51, 1 },
+        { 89, 195, 129, 0 },
+        { 230, 81, 33, 0 }, },
+      { { 76, 144, 234, 0 },
+        { 130, 135, 100, 1 },
+        { 43, 132, 153, 0 },
+        { 147, 112, 160, 1 }, },
+      { { 72, 154, 105, 1 },
+        { 170, 205, 64, 1 },
+        { 203, 44, 137, 0 },
+        { 129, 89, 170, 1 }, },
+      { { 76, 190, 247, 0 },
+        { 179, 207, 118, 0 },
+        { 119, 190, 153, 0 },
+        { 55, 121, 230, 1 }, },
+      { { 72, 235, 138, 1 },
+        { 234, 11, 35, 1 },
+        { 168, 235, 137, 0 },
+        { 226, 104, 43, 1 }, },
+      { { 72, 211, 7, 1 },
+        { 234, 67, 81, 0 },
+        { 240, 101, 137, 0 },
+        { 69, 97, 43, 1 }, },
+      { { 76, 90, 152, 1 },
+        { 248, 9, 100, 1 },
+        { 140, 173, 25, 0 },
+        { 147, 72, 15, 1 }, },
+      { { 65, 36, 19, 1 },
+        { 25, 83, 2, 0 },
+        { 228, 18, 65, 0 },
+        { 32, 101, 76, 0 }, },
+      { { 77, 11, 248, 0 },
+        { 176, 157, 37, 1 },
+        { 15, 232, 89, 0 },
+        { 210, 92, 134, 1 }, },
+      { { 73, 91, 189, 1 },
+        { 248, 217, 113, 1 },
+        { 222, 237, 73, 0 },
+        { 199, 77, 143, 1 }, },
+      { { 70, 141, 101, 0 },
+        { 3, 205, 149, 0 },
+        { 83, 88, 177, 0 },
+        { 84, 217, 224, 0 }, },
+      { { 66, 181, 107, 1 },
+        { 11, 199, 195, 1 },
+        { 235, 86, 161, 0 },
+        { 225, 241, 232, 0 }, },
+      { { 70, 92, 131, 0 },
+        { 65, 75, 228, 0 },
+        { 96, 157, 49, 0 },
+        { 19, 233, 65, 0 }, },
+      { { 70, 244, 103, 0 },
+        { 67, 199, 214, 0 },
+        { 115, 23, 177, 0 },
+        { 53, 241, 225, 0 }, },
+      { { 70, 121, 187, 0 },
+        { 80, 203, 231, 1 },
+        { 110, 207, 49, 0 },
+        { 243, 233, 133, 0 }, },
+      { { 74, 163, 157, 1 },
+        { 186, 65, 179, 1 },
+        { 220, 226, 169, 0 },
+        { 230, 193, 46, 1 }, },
+      { { 78, 65, 78, 1 },
+        { 200, 7, 149, 1 },
+        { 185, 65, 57, 0 },
+        { 212, 240, 9, 1 }, },
+      { { 78, 75, 194, 0 },
+        { 224, 15, 165, 0 },
+        { 33, 233, 57, 0 },
+        { 82, 248, 3, 1 }, },
+      { { 67, 137, 211, 1 },
+        { 26, 95, 161, 0 },
+        { 229, 200, 225, 0 },
+        { 66, 253, 44, 0 }, },
+      { { 71, 170, 200, 1 },
+        { 42, 29, 166, 1 },
+        { 137, 170, 241, 0 },
+        { 178, 220, 42, 0 }, },
+      { { 67, 59, 19, 0 },
+        { 48, 91, 195, 0 },
+        { 100, 110, 97, 0 },
+        { 97, 237, 6, 0 }, },
+      { { 71, 74, 105, 1 },
+        { 104, 221, 132, 1 },
+        { 203, 41, 113, 0 },
+        { 144, 221, 139, 0 }, },
+      { { 79, 22, 235, 1 },
+        { 169, 215, 228, 1 },
+        { 235, 180, 121, 0 },
+        { 147, 245, 202, 1 }, },
+      { { 79, 69, 160, 0 },
+        { 193, 145, 165, 0 },
+        { 2, 209, 121, 0 },
+        { 82, 196, 193, 1 }, },
+      { { 80, 145, 108, 1 },
+        { 14, 133, 81, 1 },
+        { 155, 68, 133, 0 },
+        { 197, 80, 184, 0 }, },
+      { { 84, 16, 187, 0 },
+        { 20, 195, 100, 1 },
+        { 110, 132, 21, 0 },
+        { 147, 97, 148, 0 }, },
+      { { 80, 90, 77, 1 },
+        { 108, 77, 80, 1 },
+        { 217, 45, 5, 0 },
+        { 133, 89, 27, 0 }, },
+      { { 80, 114, 212, 0 },
+        { 116, 5, 114, 0 },
+        { 21, 167, 5, 0 },
+        { 39, 80, 23, 0 }, },
+      { { 84, 234, 241, 1 },
+        { 126, 205, 38, 0 },
+        { 199, 171, 149, 0 },
+        { 50, 89, 191, 0 }, },
+      { { 88, 9, 195, 1 },
+        { 140, 79, 33, 0 },
+        { 225, 200, 13, 0 },
+        { 66, 121, 24, 1 }, },
+      { { 92, 89, 121, 0 },
+        { 212, 205, 69, 1 },
+        { 79, 77, 29, 0 },
+        { 209, 89, 149, 1 }, },
+      { { 88, 107, 27, 0 },
+        { 244, 75, 3, 1 },
+        { 108, 107, 13, 0 },
+        { 224, 105, 23, 1 }, },
+      { { 81, 52, 246, 1 },
+        { 29, 151, 114, 0 },
+        { 183, 150, 69, 0 },
+        { 39, 116, 220, 0 }, },
+      { { 85, 169, 118, 1 },
+        { 30, 159, 23, 0 },
+        { 183, 74, 213, 0 },
+        { 116, 124, 188, 0 }, },
+      { { 85, 151, 183, 1 },
+        { 63, 211, 117, 0 },
+        { 246, 244, 213, 0 },
+        { 87, 101, 254, 0 }, },
+      { { 85, 72, 67, 1 },
+        { 76, 95, 4, 0 },
+        { 225, 9, 85, 0 },
+        { 16, 125, 25, 0 }, },
+      { { 81, 203, 28, 0 },
+        { 118, 25, 17, 1 },
+        { 28, 105, 197, 0 },
+        { 196, 76, 55, 0 }, },
+      { { 89, 103, 105, 1 },
+        { 237, 213, 3, 1 },
+        { 203, 115, 77, 0 },
+        { 224, 85, 219, 1 }, },
+      { { 89, 87, 155, 0 },
+        { 245, 83, 97, 1 },
+        { 108, 245, 77, 0 },
+        { 195, 101, 87, 1 }, },
+      { { 86, 160, 171, 1 },
+        { 14, 195, 166, 1 },
+        { 234, 130, 181, 0 },
+        { 178, 225, 184, 0 }, },
+      { { 82, 76, 88, 0 },
+        { 85, 13, 128, 1 },
+        { 13, 25, 37, 0 },
+        { 128, 216, 85, 0 }, },
+      { { 86, 87, 68, 1 },
+        { 109, 5, 213, 0 },
+        { 145, 117, 53, 0 },
+        { 85, 208, 91, 0 }, },
+      { { 94, 1, 56, 0 },
+        { 148, 129, 133, 1 },
+        { 14, 64, 61, 0 },
+        { 208, 192, 148, 1 }, },
+      { { 90, 1, 255, 0 },
+        { 148, 199, 177, 1 },
+        { 127, 192, 45, 0 },
+        { 198, 241, 148, 1 }, },
+      { { 90, 53, 19, 1 },
+        { 157, 67, 195, 0 },
+        { 228, 86, 45, 0 },
+        { 97, 225, 92, 1 }, },
+      { { 94, 29, 215, 1 },
+        { 157, 79, 245, 0 },
+        { 245, 220, 61, 0 },
+        { 87, 249, 92, 1 }, },
+      { { 94, 146, 70, 1 },
+        { 174, 7, 212, 0 },
+        { 177, 36, 189, 0 },
+        { 21, 240, 58, 1 }, },
+      { { 90, 108, 162, 0 },
+        { 197, 139, 162, 0 },
+        { 34, 155, 45, 0 },
+        { 34, 232, 209, 1 }, },
+      { { 87, 57, 5, 0 },
+        { 4, 89, 215, 0 },
+        { 80, 78, 117, 0 },
+        { 117, 205, 16, 0 }, },
+      { { 87, 185, 238, 0 },
+        { 6, 159, 247, 1 },
+        { 59, 206, 245, 0 },
+        { 247, 252, 176, 0 }, },
+      { { 83, 27, 44, 1 },
+        { 44, 153, 209, 1 },
+        { 154, 108, 101, 0 },
+        { 197, 204, 154, 0 }, },
+      { { 87, 134, 8, 0 },
+        { 39, 17, 132, 1 },
+        { 8, 48, 245, 0 },
+        { 144, 196, 114, 0 }, },
+      { { 87, 179, 31, 1 },
+        { 62, 83, 215, 1 },
+        { 252, 102, 245, 0 },
+        { 245, 229, 62, 0 }, },
+      { { 87, 175, 125, 0 },
+        { 55, 221, 151, 1 },
+        { 95, 122, 245, 0 },
+        { 244, 221, 246, 0 }, },
+      { { 83, 240, 235, 0 },
+        { 70, 215, 226, 1 },
+        { 107, 135, 229, 0 },
+        { 163, 245, 177, 0 }, },
+      { { 91, 30, 236, 0 },
+        { 165, 157, 240, 1 },
+        { 27, 188, 109, 0 },
+        { 135, 220, 210, 1 }, },
+      { { 95, 6, 166, 1 },
+        { 173, 147, 180, 0 },
+        { 178, 176, 125, 0 },
+        { 22, 228, 218, 1 }, },
+      { { 95, 46, 87, 1 },
+        { 189, 95, 150, 0 },
+        { 245, 58, 125, 0 },
+        { 52, 253, 94, 1 }, },
+      { { 91, 89, 192, 0 },
+        { 196, 29, 225, 0 },
+        { 1, 205, 109, 0 },
+        { 67, 220, 17, 1 }, },
+      { { 91, 221, 125, 1 },
+        { 223, 221, 209, 1 },
+        { 223, 93, 237, 0 },
+        { 197, 221, 253, 1 }, },
+      { { 91, 78, 47, 0 },
+        { 229, 219, 144, 1 },
+        { 122, 57, 109, 0 },
+        { 132, 237, 211, 1 }, },
+      { { 95, 111, 137, 1 },
+        { 237, 89, 167, 1 },
+        { 200, 251, 125, 0 },
+        { 242, 205, 91, 1 }, },
+      { { 91, 99, 218, 0 },
+        { 244, 23, 163, 1 },
+        { 45, 227, 109, 0 },
+        { 226, 244, 23, 1 }, },
+      { { 96, 32, 36, 1 },
+        { 8, 161, 18, 0 },
+        { 146, 2, 3, 0 },
+        { 36, 66, 136, 0 }, },
+      { { 100, 167, 30, 1 },
+        { 59, 35, 23, 1 },
+        { 188, 114, 147, 0 },
+        { 244, 98, 110, 0 }, },
+      { { 96, 84, 84, 1 },
+        { 89, 37, 80, 0 },
+        { 149, 21, 3, 0 },
+        { 5, 82, 77, 0 }, },
+      { { 104, 166, 103, 0 },
+        { 163, 231, 18, 0 },
+        { 115, 50, 139, 0 },
+        { 36, 115, 226, 1 }, },
+      { { 108, 235, 188, 1 },
+        { 250, 169, 55, 1 },
+        { 158, 235, 155, 0 },
+        { 246, 74, 175, 1 }, },
+      { { 105, 70, 205, 1 },
+        { 233, 117, 48, 1 },
+        { 217, 177, 75, 0 },
+        { 134, 87, 75, 1 }, },
+      { { 109, 243, 169, 1 },
+        { 234, 241, 103, 1 },
+        { 202, 231, 219, 0 },
+        { 243, 71, 171, 1 }, },
+      { { 109, 94, 31, 0 },
+        { 241, 123, 84, 1 },
+        { 124, 61, 91, 0 },
+        { 149, 111, 71, 1 }, },
+      { { 102, 32, 99, 0 },
+        { 0, 231, 134, 0 },
+        { 99, 2, 51, 0 },
+        { 48, 243, 128, 0 }, },
+      { { 102, 219, 83, 1 },
+        { 122, 111, 197, 0 },
+        { 229, 109, 179, 0 },
+        { 81, 251, 47, 0 }, },
+      { { 98, 215, 16, 1 },
+        { 123, 33, 193, 0 },
+        { 132, 117, 163, 0 },
+        { 65, 194, 111, 0 }, },
+      { { 106, 165, 84, 1 },
+        { 155, 37, 147, 0 },
+        { 149, 82, 171, 0 },
+        { 100, 210, 108, 1 }, },
+      { { 110, 46, 41, 1 },
+        { 169, 233, 134, 1 },
+        { 202, 58, 59, 0 },
+        { 176, 203, 202, 1 }, },
+      { { 103, 54, 146, 0 },
+        { 49, 51, 230, 0 },
+        { 36, 182, 115, 0 },
+        { 51, 230, 70, 0 }, },
+      { { 103, 196, 202, 0 },
+        { 67, 55, 164, 1 },
+        { 41, 145, 243, 0 },
+        { 146, 246, 97, 0 }, },
+      { { 99, 83, 34, 1 },
+        { 104, 179, 193, 0 },
+        { 162, 101, 99, 0 },
+        { 65, 230, 139, 0 }, },
+      { { 107, 59, 196, 1 },
+        { 168, 61, 243, 0 },
+        { 145, 238, 107, 0 },
+        { 103, 222, 10, 1 }, },
+      { { 111, 22, 80, 1 },
+        { 185, 53, 196, 0 },
+        { 133, 52, 123, 0 },
+        { 17, 214, 78, 1 }, },
+      { { 107, 88, 37, 1 },
+        { 200, 249, 208, 0 },
+        { 210, 13, 107, 0 },
+        { 5, 207, 137, 1 }, },
+      { { 111, 99, 213, 1 },
+        { 248, 117, 183, 0 },
+        { 213, 227, 123, 0 },
+        { 118, 215, 15, 1 }, },
+      { { 112, 192, 248, 1 },
+        { 94, 165, 32, 1 },
+        { 143, 129, 135, 0 },
+        { 130, 82, 189, 0 }, },
+      { { 116, 215, 208, 0 },
+        { 119, 37, 101, 0 },
+        { 5, 245, 151, 0 },
+        { 83, 82, 119, 0 }, },
+      { { 113, 43, 110, 1 },
+        { 44, 191, 19, 1 },
+        { 187, 106, 71, 0 },
+        { 228, 126, 154, 0 }, },
+      { { 113, 121, 27, 1 },
+        { 92, 123, 67, 1 },
+        { 236, 79, 71, 0 },
+        { 225, 111, 29, 0 }, },
+      { { 113, 66, 210, 0 },
+        { 116, 55, 32, 0 },
+        { 37, 161, 71, 0 },
+        { 2, 118, 23, 0 }, },
+      { { 113, 99, 253, 0 },
+        { 116, 245, 51, 1 },
+        { 95, 227, 71, 0 },
+        { 230, 87, 151, 0 }, },
+      { { 117, 254, 122, 1 },
+        { 127, 191, 70, 1 },
+        { 175, 63, 215, 0 },
+        { 177, 126, 255, 0 }, },
+      { { 125, 152, 140, 0 },
+        { 134, 57, 116, 1 },
+        { 24, 140, 223, 0 },
+        { 151, 78, 48, 1 }, },
+      { { 125, 185, 247, 0 },
+        { 150, 255, 119, 0 },
+        { 119, 206, 223, 0 },
+        { 119, 127, 180, 1 }, },
+      { { 125, 19, 147, 1 },
+        { 188, 115, 101, 0 },
+        { 228, 228, 95, 0 },
+        { 83, 103, 30, 1 }, },
+      { { 121, 71, 103, 0 },
+        { 229, 247, 17, 0 },
+        { 115, 113, 79, 0 },
+        { 68, 119, 211, 1 }, },
+      { { 125, 223, 195, 0 },
+        { 231, 127, 101, 0 },
+        { 97, 253, 223, 0 },
+        { 83, 127, 115, 1 }, },
+      { { 121, 239, 82, 1 },
+        { 255, 63, 3, 0 },
+        { 165, 123, 207, 0 },
+        { 96, 126, 127, 1 }, },
+      { { 114, 0, 182, 0 },
+        { 20, 163, 176, 0 },
+        { 54, 128, 39, 0 },
+        { 6, 226, 148, 0 }, },
+      { { 118, 68, 152, 1 },
+        { 93, 33, 164, 1 },
+        { 140, 145, 55, 0 },
+        { 146, 194, 93, 0 }, },
+      { { 118, 122, 66, 0 },
+        { 100, 47, 198, 0 },
+        { 33, 47, 55, 0 },
+        { 49, 250, 19, 0 }, },
+      { { 126, 11, 181, 1 },
+        { 188, 233, 181, 0 },
+        { 214, 232, 63, 0 },
+        { 86, 203, 158, 1 }, },
+      { { 115, 58, 225, 1 },
+        { 44, 253, 226, 0 },
+        { 195, 174, 103, 0 },
+        { 35, 223, 154, 0 }, },
+      { { 119, 139, 59, 1 },
+        { 62, 251, 133, 1 },
+        { 238, 104, 247, 0 },
+        { 208, 239, 190, 0 }, },
+      { { 119, 93, 234, 0 },
+        { 69, 191, 229, 1 },
+        { 43, 221, 119, 0 },
+        { 211, 254, 209, 0 }, },
+      { { 127, 76, 0, 1 },
+        { 205, 57, 132, 0 },
+        { 128, 25, 127, 0 },
+        { 16, 206, 89, 1 }, },
+      { { 123, 117, 224, 1 },
+        { 205, 181, 227, 0 },
+        { 131, 215, 111, 0 },
+        { 99, 214, 217, 1 }, },
+      { { 127, 226, 186, 0 },
+        { 246, 179, 166, 1 },
+        { 46, 163, 255, 0 },
+        { 178, 230, 183, 1 }, },
+      { { 128, 176, 67, 1 },
+        { 10, 70, 74, 0 },
+        { 225, 6, 128, 1 },
+        { 41, 49, 40, 0 }, },
+      { { 128, 188, 61, 0 },
+        { 19, 200, 90, 1 },
+        { 94, 30, 128, 1 },
+        { 173, 9, 228, 0 }, },
+      { { 128, 50, 88, 0 },
+        { 48, 4, 74, 1 },
+        { 13, 38, 0, 1 },
+        { 169, 16, 6, 0 }, },
+      { { 128, 92, 26, 1 },
+        { 89, 10, 72, 1 },
+        { 172, 29, 0, 1 },
+        { 137, 40, 77, 0 }, },
+      { { 132, 251, 36, 0 },
+        { 98, 136, 95, 0 },
+        { 18, 111, 144, 1 },
+        { 125, 8, 163, 0 }, },
+      { { 128, 127, 245, 1 },
+        { 121, 204, 123, 0 },
+        { 215, 255, 0, 1 },
+        { 111, 25, 207, 0 }, },
+      { { 136, 45, 197, 1 },
+        { 137, 76, 59, 0 },
+        { 209, 218, 8, 1 },
+        { 110, 25, 72, 1 }, },
+      { { 136, 153, 224, 1 },
+        { 138, 140, 105, 0 },
+        { 131, 204, 136, 1 },
+        { 75, 24, 168, 1 }, },
+      { { 136, 25, 149, 0 },
+        { 144, 72, 121, 0 },
+        { 84, 204, 8, 1 },
+        { 79, 9, 4, 1 }, },
+      { { 133, 29, 199, 1 },
+        { 9, 94, 125, 0 },
+        { 241, 220, 80, 1 },
+        { 95, 61, 72, 0 }, },
+      { { 129, 187, 135, 0 },
+        { 34, 90, 123, 0 },
+        { 112, 238, 192, 1 },
+        { 111, 45, 34, 0 }, },
+      { { 129, 225, 96, 1 },
+        { 74, 148, 11, 0 },
+        { 131, 67, 192, 1 },
+        { 104, 20, 169, 0 }, },
+      { { 133, 126, 33, 1 },
+        { 105, 216, 78, 0 },
+        { 194, 63, 80, 1 },
+        { 57, 13, 203, 0 }, },
+      { { 129, 242, 146, 0 },
+        { 114, 18, 106, 0 },
+        { 36, 167, 192, 1 },
+        { 43, 36, 39, 0 }, },
+      { { 137, 61, 108, 1 },
+        { 137, 156, 91, 1 },
+        { 155, 94, 72, 1 },
+        { 237, 28, 200, 1 }, },
+      { { 137, 100, 178, 1 },
+        { 217, 146, 42, 0 },
+        { 166, 147, 72, 1 },
+        { 42, 36, 205, 1 }, },
+      { { 141, 212, 30, 1 },
+        { 219, 18, 92, 1 },
+        { 188, 21, 216, 1 },
+        { 157, 36, 109, 1 }, },
+      { { 137, 94, 209, 1 },
+        { 249, 92, 104, 0 },
+        { 197, 189, 72, 1 },
+        { 11, 29, 79, 1 }, },
+      { { 138, 4, 172, 0 },
+        { 129, 128, 184, 1 },
+        { 26, 144, 40, 1 },
+        { 142, 128, 192, 1 }, },
+      { { 142, 200, 22, 0 },
+        { 210, 10, 156, 0 },
+        { 52, 9, 184, 1 },
+        { 28, 168, 37, 1 }, },
+      { { 142, 242, 252, 1 },
+        { 250, 132, 254, 1 },
+        { 159, 167, 184, 1 },
+        { 191, 144, 175, 1 }, },
+      { { 131, 11, 137, 0 },
+        { 32, 88, 169, 1 },
+        { 72, 232, 96, 1 },
+        { 202, 141, 2, 0 }, },
+      { { 135, 43, 109, 0 },
+        { 32, 220, 159, 1 },
+        { 91, 106, 112, 1 },
+        { 252, 157, 130, 0 }, },
+      { { 135, 69, 49, 0 },
+        { 81, 208, 141, 0 },
+        { 70, 81, 112, 1 },
+        { 88, 133, 197, 0 }, },
+      { { 131, 108, 120, 1 },
+        { 89, 156, 138, 1 },
+        { 143, 27, 96, 1 },
+        { 168, 156, 205, 0 }, },
+      { { 135, 238, 13, 0 },
+        { 99, 88, 158, 1 },
+        { 88, 59, 240, 1 },
+        { 188, 141, 99, 0 }, },
+      { { 139, 177, 43, 1 },
+        { 138, 210, 203, 1 },
+        { 234, 70, 232, 1 },
+        { 233, 165, 168, 1 }, },
+      { { 139, 145, 216, 0 },
+        { 146, 20, 233, 1 },
+        { 13, 196, 232, 1 },
+        { 203, 148, 36, 1 }, },
+      { { 139, 89, 102, 0 },
+        { 192, 158, 217, 0 },
+        { 51, 77, 104, 1 },
+        { 77, 188, 129, 1 }, },
+      { { 143, 229, 85, 0 },
+        { 211, 84, 159, 0 },
+        { 85, 83, 248, 1 },
+        { 124, 149, 101, 1 }, },
+      { { 143, 243, 101, 1 },
+        { 234, 212, 223, 0 },
+        { 211, 103, 248, 1 },
+        { 125, 149, 171, 1 }, },
+      { { 148, 26, 21, 0 },
+        { 52, 72, 92, 0 },
+        { 84, 44, 20, 1 },
+        { 29, 9, 22, 0 }, },
+      { { 144, 225, 167, 0 },
+        { 70, 194, 59, 0 },
+        { 114, 195, 132, 1 },
+        { 110, 33, 177, 0 }, },
+      { { 144, 71, 255, 0 },
+        { 117, 198, 57, 1 },
+        { 127, 241, 4, 1 },
+        { 206, 49, 215, 0 }, },
+      { { 156, 188, 213, 0 },
+        { 151, 76, 126, 0 },
+        { 85, 158, 156, 1 },
+        { 63, 25, 116, 1 }, },
+      { { 152, 146, 244, 0 },
+        { 182, 132, 120, 0 },
+        { 23, 164, 140, 1 },
+        { 15, 16, 182, 1 }, },
+      { { 156, 83, 168, 1 },
+        { 236, 128, 109, 1 },
+        { 138, 229, 28, 1 },
+        { 219, 0, 155, 1 }, },
+      { { 152, 195, 107, 0 },
+        { 230, 198, 9, 1 },
+        { 107, 97, 140, 1 },
+        { 200, 49, 179, 1 }, },
+      { { 152, 114, 63, 1 },
+        { 252, 194, 90, 1 },
+        { 254, 39, 12, 1 },
+        { 173, 33, 159, 1 }, },
+      { { 145, 19, 213, 0 },
+        { 52, 84, 121, 0 },
+        { 85, 228, 68, 1 },
+        { 79, 21, 22, 0 }, },
+      { { 149, 191, 251, 0 },
+        { 55, 222, 111, 1 },
+        { 111, 254, 212, 1 },
+        { 251, 61, 246, 0 }, },
+      { { 149, 69, 22, 1 },
+        { 93, 18, 29, 0 },
+        { 180, 81, 84, 1 },
+        { 92, 36, 93, 0 }, },
+      { { 149, 238, 216, 0 },
+        { 119, 28, 46, 1 },
+        { 13, 187, 212, 1 },
+        { 186, 28, 119, 0 }, },
+      { { 157, 214, 4, 0 },
+        { 231, 16, 92, 0 },
+        { 16, 53, 220, 1 },
+        { 29, 4, 115, 1 }, },
+      { { 157, 98, 112, 0 },
+        { 244, 148, 14, 0 },
+        { 7, 35, 92, 1 },
+        { 56, 20, 151, 1 }, },
+      { { 150, 175, 206, 0 },
+        { 39, 14, 191, 1 },
+        { 57, 250, 180, 1 },
+        { 254, 184, 114, 0 }, },
+      { { 150, 186, 24, 1 },
+        { 62, 8, 206, 1 },
+        { 140, 46, 180, 1 },
+        { 185, 136, 62, 0 }, },
+      { { 150, 217, 61, 1 },
+        { 94, 200, 221, 1 },
+        { 222, 77, 180, 1 },
+        { 221, 137, 189, 0 }, },
+      { { 158, 33, 46, 0 },
+        { 132, 130, 159, 1 },
+        { 58, 66, 60, 1 },
+        { 252, 160, 144, 1 }, },
+      { { 154, 185, 132, 0 },
+        { 134, 8, 251, 0 },
+        { 16, 206, 172, 1 },
+        { 111, 136, 48, 1 }, },
+      { { 154, 129, 79, 1 },
+        { 142, 70, 153, 1 },
+        { 249, 64, 172, 1 },
+        { 204, 177, 56, 1 }, },
+      { { 154, 59, 54, 1 },
+        { 188, 138, 219, 0 },
+        { 182, 110, 44, 1 },
+        { 109, 168, 158, 1 }, },
+      { { 158, 195, 37, 0 },
+        { 230, 192, 157, 0 },
+        { 82, 97, 188, 1 },
+        { 92, 129, 179, 1 }, },
+      { { 147, 149, 40, 0 },
+        { 7, 144, 201, 1 },
+        { 10, 84, 228, 1 },
+        { 201, 132, 240, 0 }, },
+      { { 151, 50, 46, 1 },
+        { 44, 146, 222, 1 },
+        { 186, 38, 116, 1 },
+        { 189, 164, 154, 0 }, },
+      { { 151, 211, 152, 0 },
+        { 118, 16, 237, 1 },
+        { 12, 229, 244, 1 },
+        { 219, 132, 55, 0 }, },
+      { { 155, 157, 163, 1 },
+        { 143, 218, 233, 0 },
+        { 226, 220, 236, 1 },
+        { 75, 173, 248, 1 }, },
+      { { 159, 28, 240, 0 },
+        { 149, 156, 236, 0 },
+        { 7, 156, 124, 1 },
+        { 27, 156, 212, 1 }, },
+      { { 159, 51, 82, 1 },
+        { 188, 22, 207, 0 },
+        { 165, 102, 124, 1 },
+        { 121, 180, 30, 1 }, },
+      { { 155, 250, 202, 0 },
+        { 230, 30, 234, 1 },
+        { 41, 175, 236, 1 },
+        { 171, 188, 51, 1 }, },
+      { { 159, 250, 148, 0 },
+        { 246, 24, 254, 0 },
+        { 20, 175, 252, 1 },
+        { 63, 140, 55, 1 }, },
+      { { 160, 60, 203, 1 },
+        { 9, 110, 106, 1 },
+        { 233, 158, 2, 1 },
+        { 171, 59, 72, 0 }, },
+      { { 164, 168, 105, 0 },
+        { 2, 236, 14, 1 },
+        { 75, 10, 146, 1 },
+        { 184, 27, 160, 0 }, },
+      { { 160, 179, 245, 0 },
+        { 50, 228, 123, 0 },
+        { 87, 230, 130, 1 },
+        { 111, 19, 166, 0 }, },
+      { { 164, 106, 191, 0 },
+        { 112, 234, 62, 1 },
+        { 126, 171, 18, 1 },
+        { 190, 43, 135, 0 }, },
+      { { 160, 91, 120, 1 },
+        { 120, 172, 73, 1 },
+        { 143, 109, 2, 1 },
+        { 201, 26, 143, 0 }, },
+      { { 168, 104, 152, 1 },
+        { 216, 40, 42, 1 },
+        { 140, 139, 10, 1 },
+        { 170, 10, 13, 1 }, },
+      { { 172, 205, 54, 1 },
+        { 219, 170, 29, 0 },
+        { 182, 89, 154, 1 },
+        { 92, 42, 237, 1 }, },
+      { { 172, 220, 121, 1 },
+        { 219, 236, 76, 1 },
+        { 207, 29, 154, 1 },
+        { 153, 27, 237, 1 }, },
+      { { 161, 73, 35, 0 },
+        { 64, 250, 9, 0 },
+        { 98, 73, 66, 1 },
+        { 72, 47, 129, 0 }, },
+      { { 161, 67, 217, 0 },
+        { 112, 116, 41, 1 },
+        { 77, 225, 66, 1 },
+        { 202, 23, 7, 0 }, },
+      { { 173, 176, 209, 0 },
+        { 146, 116, 110, 0 },
+        { 69, 134, 218, 1 },
+        { 59, 23, 36, 1 }, },
+      { { 169, 155, 28, 1 },
+        { 186, 56, 89, 1 },
+        { 156, 108, 202, 1 },
+        { 205, 14, 46, 1 }, },
+      { { 169, 138, 215, 1 },
+        { 186, 126, 56, 0 },
+        { 245, 168, 202, 1 },
+        { 14, 63, 46, 1 }, },
+      { { 173, 84, 106, 1 },
+        { 201, 182, 76, 1 },
+        { 171, 21, 90, 1 },
+        { 153, 54, 201, 1 }, },
+      { { 173, 235, 81, 1 },
+        { 250, 124, 15, 0 },
+        { 197, 107, 218, 1 },
+        { 120, 31, 47, 1 }, },
+      { { 166, 29, 142, 0 },
+        { 1, 42, 253, 1 },
+        { 56, 220, 50, 1 },
+        { 223, 170, 64, 0 }, },
+      { { 166, 92, 102, 1 },
+        { 73, 174, 220, 0 },
+        { 179, 29, 50, 1 },
+        { 29, 186, 201, 0 }, },
+      { { 174, 188, 36, 0 },
+        { 131, 168, 222, 0 },
+        { 18, 30, 186, 1 },
+        { 61, 138, 224, 1 }, },
+      { { 170, 171, 48, 0 },
+        { 178, 168, 139, 0 },
+        { 6, 106, 170, 1 },
+        { 104, 138, 166, 1 }, },
+      { { 174, 204, 216, 0 },
+        { 211, 44, 172, 1 },
+        { 13, 153, 186, 1 },
+        { 154, 154, 101, 1 }, },
+      { { 170, 237, 187, 0 },
+        { 211, 234, 171, 1 },
+        { 110, 219, 170, 1 },
+        { 234, 171, 229, 1 }, },
+      { { 174, 227, 205, 1 },
+        { 234, 100, 191, 1 },
+        { 217, 227, 186, 1 },
+        { 254, 147, 43, 1 }, },
+      { { 167, 54, 8, 1 },
+        { 41, 48, 206, 1 },
+        { 136, 54, 114, 1 },
+        { 185, 134, 74, 0 }, },
+      { { 163, 236, 229, 0 },
+        { 67, 252, 186, 0 },
+        { 83, 155, 226, 1 },
+        { 46, 159, 225, 0 }, },
+      { { 163, 193, 155, 1 },
+        { 90, 114, 169, 1 },
+        { 236, 193, 226, 1 },
+        { 202, 167, 45, 0 }, },
+      { { 167, 250, 58, 0 },
+        { 114, 186, 206, 1 },
+        { 46, 47, 242, 1 },
+        { 185, 174, 167, 0 }, },
+      { { 175, 165, 105, 1 },
+        { 139, 244, 143, 1 },
+        { 203, 82, 250, 1 },
+        { 248, 151, 232, 1 }, },
+      { { 175, 200, 189, 1 },
+        { 218, 248, 188, 1 },
+        { 222, 137, 250, 1 },
+        { 158, 143, 173, 1 }, },
+      { { 175, 239, 164, 0 },
+        { 227, 184, 191, 0 },
+        { 18, 251, 250, 1 },
+        { 126, 142, 227, 1 }, },
+      { { 171, 103, 246, 0 },
+        { 241, 182, 187, 0 },
+        { 55, 243, 106, 1 },
+        { 110, 182, 199, 1 }, },
+      { { 180, 28, 82, 0 },
+        { 21, 46, 76, 0 },
+        { 37, 28, 22, 1 },
+        { 25, 58, 84, 0 }, },
+      { { 180, 63, 68, 1 },
+        { 45, 44, 95, 0 },
+        { 145, 126, 22, 1 },
+        { 125, 26, 90, 0 }, },
+      { { 180, 240, 202, 0 },
+        { 70, 38, 110, 1 },
+        { 41, 135, 150, 1 },
+        { 187, 50, 49, 0 }, },
+      { { 184, 24, 45, 0 },
+        { 132, 232, 88, 1 },
+        { 90, 12, 14, 1 },
+        { 141, 11, 144, 1 }, },
+      { { 188, 191, 136, 1 },
+        { 175, 40, 111, 1 },
+        { 136, 254, 158, 1 },
+        { 251, 10, 122, 1 }, },
+      { { 184, 142, 4, 1 },
+        { 175, 40, 24, 0 },
+        { 144, 56, 142, 1 },
+        { 12, 10, 122, 1 }, },
+      { { 188, 120, 40, 1 },
+        { 204, 168, 78, 1 },
+        { 138, 15, 30, 1 },
+        { 185, 10, 153, 1 }, },
+      { { 184, 200, 67, 1 },
+        { 206, 110, 8, 0 },
+        { 225, 9, 142, 1 },
+        { 8, 59, 57, 1 }, },
+      { { 188, 243, 60, 1 },
+        { 254, 160, 95, 1 },
+        { 158, 103, 158, 1 },
+        { 253, 2, 191, 1 }, },
+      { { 181, 19, 12, 0 },
+        { 36, 48, 93, 1 },
+        { 24, 100, 86, 1 },
+        { 221, 6, 18, 0 }, },
+      { { 177, 63, 106, 0 },
+        { 37, 190, 75, 1 },
+        { 43, 126, 70, 1 },
+        { 233, 62, 210, 0 }, },
+      { { 177, 101, 123, 1 },
+        { 93, 246, 11, 1 },
+        { 239, 83, 70, 1 },
+        { 232, 55, 221, 0 }, },
+      { { 177, 203, 237, 0 },
+        { 102, 252, 57, 1 },
+        { 91, 233, 198, 1 },
+        { 206, 31, 179, 0 }, },
+      { { 177, 194, 103, 1 },
+        { 110, 246, 24, 0 },
+        { 243, 33, 198, 1 },
+        { 12, 55, 187, 0 }, },
+      { { 177, 90, 242, 1 },
+        { 124, 190, 104, 0 },
+        { 167, 173, 70, 1 },
+        { 11, 62, 159, 0 }, },
+      { { 181, 238, 31, 1 },
+        { 127, 122, 30, 1 },
+        { 252, 59, 214, 1 },
+        { 188, 47, 127, 0 }, },
+      { { 185, 144, 112, 1 },
+        { 158, 180, 72, 0 },
+        { 135, 4, 206, 1 },
+        { 9, 22, 188, 1 }, },
+      { { 185, 163, 64, 1 },
+        { 174, 52, 11, 0 },
+        { 129, 98, 206, 1 },
+        { 104, 22, 58, 1 }, },
+      { { 185, 120, 90, 0 },
+        { 212, 62, 74, 1 },
+        { 45, 15, 78, 1 },
+        { 169, 62, 21, 1 }, },
+      { { 185, 247, 203, 0 },
+        { 231, 118, 107, 1 },
+        { 105, 247, 206, 1 },
+        { 235, 55, 115, 1 }, },
+      { { 182, 5, 1, 1 },
+        { 13, 96, 141, 0 },
+        { 192, 80, 54, 1 },
+        { 88, 131, 88, 0 }, },
+      { { 178, 255, 194, 0 },
+        { 103, 46, 235, 0 },
+        { 33, 255, 166, 1 },
+        { 107, 186, 115, 0 }, },
+      { { 178, 123, 21, 0 },
+        { 116, 104, 219, 0 },
+        { 84, 111, 38, 1 },
+        { 109, 139, 23, 0 }, },
+      { { 178, 110, 90, 1 },
+        { 125, 46, 138, 1 },
+        { 173, 59, 38, 1 },
+        { 168, 186, 95, 0 }, },
+      { { 190, 181, 243, 1 },
+        { 159, 230, 239, 0 },
+        { 231, 214, 190, 1 },
+        { 123, 179, 252, 1 }, },
+      { { 186, 167, 161, 0 },
+        { 167, 224, 171, 0 },
+        { 66, 242, 174, 1 },
+        { 106, 131, 242, 1 }, },
+      { { 186, 114, 10, 1 },
+        { 236, 34, 202, 1 },
+        { 168, 39, 46, 1 },
+        { 169, 162, 27, 1 }, },
+      { { 179, 48, 64, 0 },
+        { 4, 52, 202, 0 },
+        { 1, 6, 102, 1 },
+        { 41, 150, 16, 0 }, },
+      { { 183, 181, 52, 1 },
+        { 31, 176, 223, 0 },
+        { 150, 86, 246, 1 },
+        { 125, 134, 252, 0 }, },
+      { { 183, 105, 76, 0 },
+        { 68, 60, 159, 1 },
+        { 25, 75, 118, 1 },
+        { 252, 158, 17, 0 }, },
+      { { 183, 197, 193, 0 },
+        { 71, 116, 173, 0 },
+        { 65, 209, 246, 1 },
+        { 90, 151, 113, 0 }, },
+      { { 179, 87, 222, 0 },
+        { 117, 54, 249, 1 },
+        { 61, 245, 102, 1 },
+        { 207, 182, 87, 0 }, },
+      { { 187, 84, 251, 0 },
+        { 213, 246, 232, 1 },
+        { 111, 149, 110, 1 },
+        { 139, 183, 213, 1 }, },
+      { { 187, 202, 108, 1 },
+        { 238, 188, 152, 1 },
+        { 155, 41, 238, 1 },
+        { 140, 158, 187, 1 }, },
+      { { 187, 251, 225, 1 },
+        { 238, 252, 235, 0 },
+        { 195, 239, 238, 1 },
+        { 107, 159, 187, 1 }, },
+      { { 191, 246, 134, 1 },
+        { 239, 50, 254, 0 },
+        { 176, 183, 254, 1 },
+        { 63, 166, 123, 1 }, },
+      { { 196, 45, 124, 0 },
+        { 17, 141, 31, 1 },
+        { 31, 90, 17, 1 },
+        { 252, 88, 196, 0 }, },
+      { { 200, 28, 52, 0 },
+        { 145, 137, 88, 0 },
+        { 22, 28, 9, 1 },
+        { 13, 72, 196, 1 }, },
+      { { 204, 67, 229, 1 },
+        { 232, 197, 61, 0 },
+        { 211, 225, 25, 1 },
+        { 94, 81, 139, 1 }, },
+      { { 197, 53, 174, 1 },
+        { 9, 147, 127, 1 },
+        { 186, 214, 81, 1 },
+        { 255, 100, 200, 0 }, },
+      { { 193, 146, 192, 0 },
+        { 34, 21, 104, 0 },
+        { 1, 164, 193, 1 },
+        { 11, 84, 34, 0 }, },
+      { { 197, 35, 247, 0 },
+        { 48, 215, 63, 0 },
+        { 119, 226, 81, 1 },
+        { 126, 117, 134, 0 }, },
+      { { 193, 159, 254, 0 },
+        { 51, 159, 121, 1 },
+        { 63, 252, 193, 1 },
+        { 207, 124, 230, 0 }, },
+      { { 193, 84, 97, 0 },
+        { 65, 213, 72, 0 },
+        { 67, 21, 65, 1 },
+        { 9, 85, 193, 0 }, },
+      { { 193, 87, 130, 0 },
+        { 97, 19, 105, 0 },
+        { 32, 245, 65, 1 },
+        { 75, 100, 67, 0 }, },
+      { { 193, 199, 55, 1 },
+        { 123, 211, 25, 0 },
+        { 246, 113, 193, 1 },
+        { 76, 101, 239, 0 }, },
+      { { 201, 140, 239, 1 },
+        { 139, 223, 56, 1 },
+        { 251, 152, 201, 1 },
+        { 142, 125, 232, 1 }, },
+      { { 205, 240, 111, 0 },
+        { 194, 215, 94, 1 },
+        { 123, 7, 217, 1 },
+        { 189, 117, 161, 1 }, },
+      { { 201, 95, 103, 1 },
+        { 233, 223, 89, 0 },
+        { 243, 125, 73, 1 },
+        { 77, 125, 203, 1 }, },
+      { { 201, 119, 241, 0 },
+        { 241, 213, 107, 0 },
+        { 71, 247, 73, 1 },
+        { 107, 85, 199, 1 }, },
+      { { 205, 226, 149, 1 },
+        { 250, 81, 62, 0 },
+        { 212, 163, 217, 1 },
+        { 62, 69, 47, 1 }, },
+      { { 198, 191, 7, 1 },
+        { 43, 75, 223, 0 },
+        { 240, 126, 177, 1 },
+        { 125, 233, 106, 0 }, },
+      { { 198, 191, 184, 0 },
+        { 51, 137, 239, 1 },
+        { 14, 254, 177, 1 },
+        { 251, 200, 230, 0 }, },
+      { { 198, 219, 201, 1 },
+        { 106, 77, 237, 1 },
+        { 201, 237, 177, 1 },
+        { 219, 217, 43, 0 }, },
+      { { 202, 49, 136, 0 },
+        { 128, 1, 235, 1 },
+        { 8, 198, 41, 1 },
+        { 235, 192, 0, 1 }, },
+      { { 206, 222, 45, 1 },
+        { 235, 201, 220, 1 },
+        { 218, 61, 185, 1 },
+        { 157, 201, 235, 1 }, },
+      { { 199, 120, 44, 1 },
+        { 72, 153, 222, 1 },
+        { 154, 15, 113, 1 },
+        { 189, 204, 137, 0 }, },
+      { { 203, 171, 75, 1 },
+        { 170, 95, 139, 1 },
+        { 233, 106, 233, 1 },
+        { 232, 253, 42, 1 }, },
+      { { 207, 67, 191, 0 },
+        { 240, 211, 189, 1 },
+        { 126, 225, 121, 1 },
+        { 222, 229, 135, 1 }, },
+      { { 208, 174, 86, 1 },
+        { 63, 15, 26, 0 },
+        { 181, 58, 133, 1 },
+        { 44, 120, 126, 0 }, },
+      { { 208, 115, 51, 0 },
+        { 116, 195, 75, 0 },
+        { 102, 103, 5, 1 },
+        { 105, 97, 151, 0 }, },
+      { { 216, 20, 152, 0 },
+        { 149, 1, 104, 1 },
+        { 12, 148, 13, 1 },
+        { 139, 64, 84, 1 }, },
+      { { 220, 96, 159, 1 },
+        { 220, 67, 62, 1 },
+        { 252, 131, 29, 1 },
+        { 190, 97, 29, 1 }, },
+      { { 213, 117, 88, 0 },
+        { 85, 21, 79, 1 },
+        { 13, 87, 85, 1 },
+        { 249, 84, 85, 0 }, },
+      { { 209, 224, 215, 0 },
+        { 86, 87, 58, 0 },
+        { 117, 131, 197, 1 },
+        { 46, 117, 53, 0 }, },
+      { { 213, 251, 177, 0 },
+        { 118, 217, 111, 0 },
+        { 70, 239, 213, 1 },
+        { 123, 77, 183, 0 }, },
+      { { 213, 218, 116, 1 },
+        { 126, 157, 92, 0 },
+        { 151, 45, 213, 1 },
+        { 29, 92, 191, 0 }, },
+      { { 221, 60, 116, 1 },
+        { 157, 157, 94, 0 },
+        { 151, 30, 93, 1 },
+        { 61, 92, 220, 1 }, },
+      { { 221, 151, 109, 0 },
+        { 167, 213, 93, 1 },
+        { 91, 116, 221, 1 },
+        { 221, 85, 242, 1 }, },
+      { { 217, 27, 49, 0 },
+        { 180, 217, 73, 0 },
+        { 70, 108, 77, 1 },
+        { 73, 77, 150, 1 }, },
+      { { 217, 98, 166, 0 },
+        { 228, 147, 58, 0 },
+        { 50, 163, 77, 1 },
+        { 46, 100, 147, 1 }, },
+      { { 210, 171, 124, 1 },
+        { 62, 141, 155, 1 },
+        { 159, 106, 165, 1 },
+        { 236, 216, 190, 0 }, },
+      { { 210, 197, 236, 0 },
+        { 71, 133, 185, 1 },
+        { 27, 209, 165, 1 },
+        { 206, 208, 241, 0 }, },
+      { { 210, 202, 106, 0 },
+        { 102, 143, 136, 1 },
+        { 43, 41, 165, 1 },
+        { 136, 248, 179, 0 }, },
+      { { 210, 107, 214, 0 },
+        { 116, 15, 187, 0 },
+        { 53, 235, 37, 1 },
+        { 110, 248, 23, 0 }, },
+      { { 222, 155, 52, 0 },
+        { 182, 137, 221, 0 },
+        { 22, 108, 189, 1 },
+        { 93, 200, 182, 1 }, },
+      { { 222, 146, 158, 0 },
+        { 182, 3, 252, 1 },
+        { 60, 164, 189, 1 },
+        { 159, 224, 54, 1 }, },
+      { { 218, 96, 216, 1 },
+        { 220, 5, 170, 1 },
+        { 141, 131, 45, 1 },
+        { 170, 208, 29, 1 }, },
+      { { 215, 57, 178, 1 },
+        { 28, 155, 239, 0 },
+        { 166, 206, 117, 1 },
+        { 123, 236, 156, 0 }, },
+      { { 215, 95, 38, 0 },
+        { 101, 155, 221, 0 },
+        { 50, 125, 117, 1 },
+        { 93, 236, 211, 0 }, },
+      { { 223, 1, 65, 1 },
+        { 140, 85, 141, 0 },
+        { 193, 64, 125, 1 },
+        { 88, 213, 24, 1 }, },
+      { { 223, 121, 15, 1 },
+        { 204, 91, 223, 1 },
+        { 248, 79, 125, 1 },
+        { 253, 237, 25, 1 }, },
+      { { 219, 247, 116, 0 },
+        { 247, 149, 219, 0 },
+        { 23, 119, 237, 1 },
+        { 109, 212, 247, 1 }, },
+      { { 224, 67, 79, 1 },
+        { 104, 103, 25, 1 },
+        { 249, 97, 3, 1 },
+        { 204, 115, 11, 0 }, },
+      { { 224, 198, 227, 0 },
+        { 99, 231, 40, 0 },
+        { 99, 177, 131, 1 },
+        { 10, 115, 227, 0 }, },
+      { { 236, 56, 189, 1 },
+        { 152, 233, 126, 1 },
+        { 222, 142, 27, 1 },
+        { 191, 75, 140, 1 }, },
+      { { 236, 81, 253, 0 },
+        { 208, 229, 125, 1 },
+        { 95, 197, 27, 1 },
+        { 223, 83, 133, 1 }, },
+      { { 229, 141, 36, 0 },
+        { 3, 185, 29, 0 },
+        { 18, 88, 211, 1 },
+        { 92, 78, 224, 0 }, },
+      { { 229, 5, 121, 1 },
+        { 25, 245, 13, 1 },
+        { 207, 80, 83, 1 },
+        { 216, 87, 204, 0 }, },
+      { { 225, 78, 248, 0 },
+        { 113, 189, 40, 1 },
+        { 15, 185, 67, 1 },
+        { 138, 94, 199, 0 }, },
+      { { 229, 87, 220, 1 },
+        { 121, 53, 125, 1 },
+        { 157, 245, 83, 1 },
+        { 223, 86, 79, 0 }, },
+      { { 225, 247, 242, 1 },
+        { 123, 183, 107, 0 },
+        { 167, 247, 195, 1 },
+        { 107, 118, 239, 0 }, },
+      { { 226, 133, 77, 0 },
+        { 3, 101, 153, 1 },
+        { 89, 80, 163, 1 },
+        { 204, 211, 96, 0 }, },
+      { { 226, 24, 26, 0 },
+        { 16, 43, 200, 1 },
+        { 44, 12, 35, 1 },
+        { 137, 234, 4, 0 }, },
+      { { 226, 43, 203, 0 },
+        { 32, 111, 171, 1 },
+        { 105, 234, 35, 1 },
+        { 234, 251, 2, 0 }, },
+      { { 230, 236, 2, 0 },
+        { 67, 43, 142, 0 },
+        { 32, 27, 179, 1 },
+        { 56, 234, 97, 0 }, },
+      { { 230, 98, 129, 0 },
+        { 96, 97, 174, 0 },
+        { 64, 163, 51, 1 },
+        { 58, 195, 3, 0 }, },
+      { { 234, 38, 64, 0 },
+        { 161, 37, 138, 0 },
+        { 1, 50, 43, 1 },
+        { 40, 210, 66, 1 }, },
+      { { 234, 224, 196, 0 },
+        { 194, 37, 186, 0 },
+        { 17, 131, 171, 1 },
+        { 46, 210, 33, 1 }, },
+      { { 234, 114, 148, 1 },
+        { 248, 33, 250, 0 },
+        { 148, 167, 43, 1 },
+        { 47, 194, 15, 1 }, },
+      { { 227, 17, 63, 1 },
+        { 24, 243, 217, 1 },
+        { 254, 68, 99, 1 },
+        { 205, 231, 140, 0 }, },
+      { { 231, 11, 230, 1 },
+        { 40, 191, 189, 0 },
+        { 179, 232, 115, 1 },
+        { 94, 254, 138, 0 }, },
+      { { 227, 100, 241, 1 },
+        { 89, 245, 170, 0 },
+        { 199, 147, 99, 1 },
+        { 42, 215, 205, 0 }, },
+      { { 231, 250, 226, 1 },
+        { 106, 191, 238, 0 },
+        { 163, 175, 243, 1 },
+        { 59, 254, 171, 0 }, },
+      { { 227, 219, 243, 0 },
+        { 114, 255, 233, 0 },
+        { 103, 237, 227, 1 },
+        { 75, 255, 167, 0 }, },
+      { { 239, 135, 98, 0 },
+        { 163, 183, 141, 0 },
+        { 35, 112, 251, 1 },
+        { 88, 246, 226, 1 }, },
+      { { 239, 93, 112, 0 },
+        { 209, 189, 205, 0 },
+        { 7, 93, 123, 1 },
+        { 89, 222, 197, 1 }, },
+      { { 235, 102, 14, 0 },
+        { 225, 51, 154, 1 },
+        { 56, 51, 107, 1 },
+        { 172, 230, 67, 1 }, },
+      { { 239, 74, 60, 0 },
+        { 240, 185, 156, 1 },
+        { 30, 41, 123, 1 },
+        { 156, 206, 135, 1 }, },
+      { { 240, 178, 33, 1 },
+        { 46, 225, 74, 0 },
+        { 194, 38, 135, 1 },
+        { 41, 67, 186, 0 }, },
+      { { 240, 175, 79, 0 },
+        { 39, 111, 27, 1 },
+        { 121, 122, 135, 1 },
+        { 236, 123, 114, 0 }, },
+      { { 244, 159, 60, 1 },
+        { 63, 169, 93, 1 },
+        { 158, 124, 151, 1 },
+        { 221, 74, 254, 0 }, },
+      { { 240, 245, 4, 0 },
+        { 71, 33, 91, 0 },
+        { 16, 87, 135, 1 },
+        { 109, 66, 113, 0 }, },
+      { { 240, 242, 120, 0 },
+        { 118, 165, 74, 1 },
+        { 15, 39, 135, 1 },
+        { 169, 82, 183, 0 }, },
+      { { 248, 52, 99, 0 },
+        { 133, 231, 74, 0 },
+        { 99, 22, 15, 1 },
+        { 41, 115, 208, 1 }, },
+      { { 252, 219, 143, 0 },
+        { 230, 107, 125, 1 },
+        { 120, 237, 159, 1 },
+        { 223, 107, 51, 1 }, },
+      { { 252, 254, 77, 1 },
+        { 239, 109, 94, 1 },
+        { 217, 63, 159, 1 },
+        { 189, 91, 123, 1 }, },
+      { { 253, 176, 69, 1 },
+        { 142, 117, 94, 0 },
+        { 209, 6, 223, 1 },
+        { 61, 87, 56, 1 }, },
+      { { 253, 51, 235, 0 },
+        { 164, 247, 111, 1 },
+        { 107, 230, 95, 1 },
+        { 251, 119, 146, 1 }, },
+      { { 249, 196, 217, 1 },
+        { 223, 117, 40, 1 },
+        { 205, 145, 207, 1 },
+        { 138, 87, 125, 1 }, },
+      { { 242, 35, 145, 1 },
+        { 60, 97, 171, 0 },
+        { 196, 226, 39, 1 },
+        { 106, 195, 30, 0 }, },
+      { { 246, 210, 251, 1 },
+        { 126, 231, 236, 1 },
+        { 239, 165, 183, 1 },
+        { 155, 243, 191, 0 }, },
+      { { 254, 239, 211, 1 },
+        { 255, 111, 175, 0 },
+        { 229, 251, 191, 1 },
+        { 122, 251, 127, 1 }, },
+      { { 243, 176, 58, 1 },
+        { 30, 179, 202, 1 },
+        { 174, 6, 231, 1 },
+        { 169, 230, 188, 0 }, },
+      { { 247, 138, 77, 1 },
+        { 46, 125, 156, 1 },
+        { 217, 40, 247, 1 },
+        { 156, 223, 58, 0 }, },
+      { { 243, 143, 157, 1 },
+        { 63, 121, 185, 1 },
+        { 220, 248, 231, 1 },
+        { 206, 207, 126, 0 }, },
+      { { 247, 242, 39, 0 },
+        { 102, 243, 222, 0 },
+        { 114, 39, 247, 1 },
+        { 61, 231, 179, 0 }, },
+      { { 255, 189, 133, 1 },
+        { 143, 121, 255, 0 },
+        { 208, 222, 255, 1 },
+        { 127, 207, 120, 1 }, },
+      { { 255, 38, 197, 1 },
+        { 173, 117, 190, 0 },
+        { 209, 178, 127, 1 },
+        { 62, 215, 90, 1 }, },
+      { { 251, 224, 97, 0 },
+        { 198, 245, 138, 0 },
+        { 67, 3, 239, 1 },
+        { 40, 215, 177, 1 }, },
+      { { 255, 220, 26, 0 },
+        { 215, 59, 204, 1 },
+        { 44, 29, 255, 1 },
+        { 153, 238, 117, 1 }, },
+      { { 25, 248, 99, 1 },
+        { 206, 222, 66, 0 },
+        { 227, 15, 204, 0 },
+        { 33, 61, 185, 1 }, },
+      { { 169, 93, 31, 1 },
+        { 217, 122, 89, 1 },
+        { 252, 93, 74, 1 },
+        { 205, 47, 77, 1 }, },
+      { { 0, 184, 72, 1 },
+        { 10, 12, 66, 1 },
+        { 137, 14, 128, 0 },
+        { 161, 24, 40, 0 }, },
+      { { 0, 236, 225, 0 },
+        { 67, 204, 34, 0 },
+        { 67, 155, 128, 0 },
+        { 34, 25, 225, 0 }, },
+      { { 8, 97, 102, 0 },
+        { 192, 134, 19, 0 },
+        { 51, 67, 8, 0 },
+        { 100, 48, 129, 1 }, },
+      { { 8, 244, 131, 0 },
+        { 195, 66, 98, 0 },
+        { 96, 151, 136, 0 },
+        { 35, 33, 97, 1 }, },
+      { { 12, 248, 157, 0 },
+        { 210, 72, 118, 1 },
+        { 92, 143, 152, 0 },
+        { 183, 9, 37, 1 }, },
+      { { 8, 192, 62, 1 },
+        { 218, 130, 16, 1 },
+        { 190, 1, 136, 0 },
+        { 132, 32, 173, 1 }, },
+      { { 1, 57, 192, 0 },
+        { 0, 28, 99, 0 },
+        { 1, 206, 64, 0 },
+        { 99, 28, 0, 0 }, },
+      { { 1, 40, 10, 0 },
+        { 0, 26, 2, 1 },
+        { 40, 10, 64, 0 },
+        { 160, 44, 0, 0 }, },
+      { { 1, 190, 179, 1 },
+        { 59, 218, 98, 0 },
+        { 230, 190, 192, 0 },
+        { 35, 45, 238, 0 }, },
+      { { 13, 128, 85, 0 },
+        { 146, 84, 20, 0 },
+        { 85, 0, 216, 0 },
+        { 20, 21, 36, 1 }, },
+      { { 13, 175, 99, 1 },
+        { 171, 222, 7, 0 },
+        { 227, 122, 216, 0 },
+        { 112, 61, 234, 1 }, },
+      { { 6, 181, 236, 0 },
+        { 3, 132, 247, 1 },
+        { 27, 214, 176, 0 },
+        { 247, 144, 224, 0 }, },
+      { { 2, 153, 54, 1 },
+        { 26, 138, 209, 0 },
+        { 182, 76, 160, 0 },
+        { 69, 168, 172, 0 }, },
+      { { 6, 182, 143, 0 },
+        { 35, 66, 246, 1 },
+        { 120, 182, 176, 0 },
+        { 183, 161, 98, 0 }, },
+      { { 6, 125, 64, 1 },
+        { 73, 12, 199, 0 },
+        { 129, 95, 48, 0 },
+        { 113, 152, 73, 0 }, },
+      { { 2, 114, 104, 1 },
+        { 104, 132, 194, 1 },
+        { 139, 39, 32, 0 },
+        { 161, 144, 139, 0 }, },
+      { { 6, 203, 237, 1 },
+        { 106, 204, 181, 1 },
+        { 219, 233, 176, 0 },
+        { 214, 153, 171, 0 }, },
+      { { 14, 15, 61, 0 },
+        { 177, 200, 149, 1 },
+        { 94, 120, 56, 0 },
+        { 212, 137, 198, 1 }, },
+      { { 14, 213, 203, 0 },
+        { 195, 70, 229, 1 },
+        { 105, 213, 184, 0 },
+        { 211, 177, 97, 1 }, },
+      { { 3, 125, 39, 1 },
+        { 73, 218, 211, 0 },
+        { 242, 95, 96, 0 },
+        { 101, 173, 201, 0 }, },
+      { { 3, 233, 143, 0 },
+        { 66, 90, 179, 1 },
+        { 120, 203, 224, 0 },
+        { 230, 173, 33, 0 }, },
+      { { 7, 250, 159, 1 },
+        { 122, 90, 246, 1 },
+        { 252, 175, 240, 0 },
+        { 183, 173, 47, 0 }, },
+      { { 11, 76, 16, 0 },
+        { 209, 24, 128, 0 },
+        { 4, 25, 104, 0 },
+        { 0, 140, 69, 1 }, },
+      { { 16, 185, 87, 1 },
+        { 30, 78, 83, 0 },
+        { 245, 78, 132, 0 },
+        { 101, 57, 60, 0 }, },
+      { { 16, 22, 41, 0 },
+        { 37, 192, 64, 1 },
+        { 74, 52, 4, 0 },
+        { 129, 1, 210, 0 }, },
+      { { 16, 98, 139, 1 },
+        { 108, 66, 34, 1 },
+        { 232, 163, 4, 0 },
+        { 162, 33, 27, 0 }, },
+      { { 24, 157, 182, 0 },
+        { 151, 138, 113, 0 },
+        { 54, 220, 140, 0 },
+        { 71, 40, 244, 1 }, },
+      { { 24, 109, 0, 1 },
+        { 205, 8, 3, 0 },
+        { 128, 91, 12, 0 },
+        { 96, 8, 89, 1 }, },
+      { { 28, 118, 42, 0 },
+        { 229, 130, 70, 1 },
+        { 42, 55, 28, 0 },
+        { 177, 32, 211, 1 }, },
+      { { 24, 95, 228, 1 },
+        { 237, 140, 113, 0 },
+        { 147, 253, 12, 0 },
+        { 71, 24, 219, 1 }, },
+      { { 28, 66, 22, 0 },
+        { 244, 2, 20, 0 },
+        { 52, 33, 28, 0 },
+        { 20, 32, 23, 1 }, },
+      { { 17, 60, 169, 0 },
+        { 5, 216, 98, 1 },
+        { 74, 158, 68, 0 },
+        { 163, 13, 208, 0 }, },
+      { { 17, 152, 57, 1 },
+        { 30, 216, 64, 1 },
+        { 206, 12, 196, 0 },
+        { 129, 13, 188, 0 }, },
+      { { 21, 58, 99, 0 },
+        { 36, 222, 70, 0 },
+        { 99, 46, 84, 0 },
+        { 49, 61, 146, 0 }, },
+      { { 21, 18, 117, 1 },
+        { 60, 212, 84, 0 },
+        { 215, 36, 84, 0 },
+        { 21, 21, 158, 0 }, },
+      { { 21, 222, 162, 0 },
+        { 103, 154, 100, 0 },
+        { 34, 189, 212, 0 },
+        { 19, 44, 243, 0 }, },
+      { { 21, 106, 24, 1 },
+        { 124, 24, 6, 1 },
+        { 140, 43, 84, 0 },
+        { 176, 12, 31, 0 }, },
+      { { 29, 209, 40, 0 },
+        { 198, 144, 69, 1 },
+        { 10, 69, 220, 0 },
+        { 209, 4, 177, 1 }, },
+      { { 29, 113, 148, 1 },
+        { 220, 16, 119, 0 },
+        { 148, 199, 92, 0 },
+        { 119, 4, 29, 1 }, },
+      { { 18, 57, 139, 1 },
+        { 12, 74, 227, 1 },
+        { 232, 206, 36, 0 },
+        { 227, 169, 24, 0 }, },
+      { { 18, 5, 152, 0 },
+        { 21, 0, 161, 1 },
+        { 12, 208, 36, 0 },
+        { 194, 128, 84, 0 }, },
+      { { 22, 2, 152, 1 },
+        { 60, 0, 164, 1 },
+        { 140, 160, 52, 0 },
+        { 146, 128, 30, 0 }, },
+      { { 26, 52, 127, 1 },
+        { 157, 198, 210, 1 },
+        { 255, 22, 44, 0 },
+        { 165, 177, 220, 1 }, },
+      { { 30, 220, 239, 1 },
+        { 207, 206, 244, 1 },
+        { 251, 157, 188, 0 },
+        { 151, 185, 249, 1 }, },
+      { { 30, 112, 115, 0 },
+        { 212, 198, 198, 0 },
+        { 103, 7, 60, 0 },
+        { 49, 177, 149, 1 }, },
+      { { 26, 67, 149, 0 },
+        { 244, 64, 177, 0 },
+        { 84, 225, 44, 0 },
+        { 70, 129, 23, 1 }, },
+      { { 26, 126, 27, 1 },
+        { 253, 74, 194, 1 },
+        { 236, 63, 44, 0 },
+        { 161, 169, 95, 1 }, },
+      { { 23, 173, 194, 0 },
+        { 7, 30, 167, 0 },
+        { 33, 218, 244, 0 },
+        { 114, 188, 112, 0 }, },
+      { { 19, 25, 222, 1 },
+        { 28, 30, 241, 1 },
+        { 189, 204, 100, 0 },
+        { 199, 188, 28, 0 }, },
+      { { 27, 168, 147, 1 },
+        { 158, 90, 162, 0 },
+        { 228, 138, 236, 0 },
+        { 34, 173, 60, 1 }, },
+      { { 27, 147, 73, 1 },
+        { 174, 84, 193, 1 },
+        { 201, 100, 236, 0 },
+        { 193, 149, 58, 1 }, },
+      { { 27, 208, 27, 0 },
+        { 214, 82, 192, 1 },
+        { 108, 5, 236, 0 },
+        { 129, 165, 53, 1 }, },
+      { { 31, 66, 219, 1 },
+        { 252, 86, 164, 1 },
+        { 237, 161, 124, 0 },
+        { 146, 181, 31, 1 }, },
+      { { 32, 185, 170, 0 },
+        { 2, 170, 99, 1 },
+        { 42, 206, 130, 0 },
+        { 227, 42, 160, 0 }, },
+      { { 36, 196, 186, 0 },
+        { 83, 162, 36, 1 },
+        { 46, 145, 146, 0 },
+        { 146, 34, 229, 0 }, },
+      { { 40, 173, 5, 0 },
+        { 131, 104, 19, 0 },
+        { 80, 90, 138, 0 },
+        { 100, 11, 96, 1 }, },
+      { { 44, 35, 100, 1 },
+        { 168, 164, 23, 0 },
+        { 147, 98, 26, 0 },
+        { 116, 18, 138, 1 }, },
+      { { 44, 14, 154, 1 },
+        { 185, 42, 36, 1 },
+        { 172, 184, 26, 0 },
+        { 146, 42, 78, 1 }, },
+      { { 44, 81, 3, 1 },
+        { 200, 98, 69, 0 },
+        { 224, 69, 26, 0 },
+        { 81, 35, 9, 1 }, },
+      { { 37, 197, 207, 1 },
+        { 75, 118, 53, 1 },
+        { 249, 209, 210, 0 },
+        { 214, 55, 105, 0 }, },
+      { { 37, 200, 211, 1 },
+        { 90, 126, 36, 0 },
+        { 229, 137, 210, 0 },
+        { 18, 63, 45, 0 }, },
+      { { 33, 119, 232, 1 },
+        { 105, 180, 99, 1 },
+        { 139, 247, 66, 0 },
+        { 227, 22, 203, 0 }, },
+      { { 34, 141, 218, 1 },
+        { 27, 46, 161, 1 },
+        { 173, 216, 162, 0 },
+        { 194, 186, 108, 0 }, },
+      { { 34, 10, 238, 0 },
+        { 32, 174, 176, 1 },
+        { 59, 168, 34, 0 },
+        { 134, 186, 130, 0 }, },
+      { { 46, 134, 44, 0 },
+        { 163, 160, 148, 1 },
+        { 26, 48, 186, 0 },
+        { 148, 130, 226, 1 }, },
+      { { 42, 182, 47, 1 },
+        { 171, 226, 210, 1 },
+        { 250, 54, 170, 0 },
+        { 165, 163, 234, 1 }, },
+      { { 39, 60, 45, 0 },
+        { 1, 248, 214, 1 },
+        { 90, 30, 114, 0 },
+        { 181, 143, 192, 0 }, },
+      { { 39, 157, 74, 0 },
+        { 3, 62, 197, 1 },
+        { 41, 92, 242, 0 },
+        { 209, 190, 96, 0 }, },
+      { { 39, 155, 7, 1 },
+        { 42, 122, 213, 0 },
+        { 240, 108, 242, 0 },
+        { 85, 175, 42, 0 }, },
+      { { 35, 87, 132, 0 },
+        { 97, 48, 241, 0 },
+        { 16, 245, 98, 0 },
+        { 71, 134, 67, 0 }, },
+      { { 35, 78, 67, 1 },
+        { 105, 126, 128, 0 },
+        { 225, 57, 98, 0 },
+        { 0, 191, 75, 0 }, },
+      { { 47, 171, 185, 1 },
+        { 186, 248, 167, 1 },
+        { 206, 234, 250, 0 },
+        { 242, 143, 174, 1 }, },
+      { { 48, 176, 46, 1 },
+        { 14, 162, 82, 1 },
+        { 186, 6, 134, 0 },
+        { 165, 34, 184, 0 }, },
+      { { 48, 40, 122, 0 },
+        { 20, 174, 2, 1 },
+        { 47, 10, 6, 0 },
+        { 160, 58, 148, 0 }, },
+      { { 52, 253, 160, 1 },
+        { 79, 168, 103, 0 },
+        { 130, 223, 150, 0 },
+        { 115, 10, 249, 0 }, },
+      { { 60, 214, 137, 0 },
+        { 231, 96, 100, 1 },
+        { 72, 181, 158, 0 },
+        { 147, 3, 115, 1 }, },
+      { { 56, 126, 182, 0 },
+        { 245, 170, 114, 0 },
+        { 54, 191, 14, 0 },
+        { 39, 42, 215, 1 }, },
+      { { 49, 0, 109, 0 },
+        { 4, 244, 16, 1 },
+        { 91, 0, 70, 0 },
+        { 132, 23, 144, 0 }, },
+      { { 49, 23, 219, 1 },
+        { 61, 118, 97, 1 },
+        { 237, 244, 70, 0 },
+        { 195, 55, 94, 0 }, },
+      { { 49, 167, 119, 1 },
+        { 63, 246, 19, 0 },
+        { 247, 114, 198, 0 },
+        { 100, 55, 254, 0 }, },
+      { { 61, 128, 10, 1 },
+        { 142, 50, 4, 1 },
+        { 168, 0, 222, 0 },
+        { 144, 38, 56, 1 }, },
+      { { 61, 226, 157, 0 },
+        { 246, 112, 54, 1 },
+        { 92, 163, 222, 0 },
+        { 182, 7, 55, 1 }, },
+      { { 54, 106, 119, 1 },
+        { 124, 238, 150, 0 },
+        { 247, 43, 54, 0 },
+        { 52, 187, 159, 0 }, },
+      { { 54, 199, 190, 1 },
+        { 127, 162, 181, 1 },
+        { 190, 241, 182, 0 },
+        { 214, 162, 255, 0 }, },
+      { { 62, 187, 41, 0 },
+        { 166, 232, 199, 1 },
+        { 74, 110, 190, 0 },
+        { 241, 139, 178, 1 }, },
+      { { 62, 104, 154, 0 },
+        { 212, 42, 166, 1 },
+        { 44, 139, 62, 0 },
+        { 178, 170, 21, 1 }, },
+      { { 62, 95, 2, 1 },
+        { 237, 42, 197, 0 },
+        { 160, 125, 62, 0 },
+        { 81, 170, 91, 1 }, },
+      { { 58, 86, 206, 1 },
+        { 237, 38, 240, 1 },
+        { 185, 181, 46, 0 },
+        { 135, 178, 91, 1 }, },
+      { { 62, 95, 252, 0 },
+        { 245, 172, 245, 1 },
+        { 31, 253, 62, 0 },
+        { 215, 154, 215, 1 }, },
+      { { 51, 185, 172, 0 },
+        { 6, 184, 243, 1 },
+        { 26, 206, 230, 0 },
+        { 231, 142, 176, 0 }, },
+      { { 51, 84, 174, 0 },
+        { 69, 178, 240, 1 },
+        { 58, 149, 102, 0 },
+        { 135, 166, 209, 0 }, },
+      { { 63, 25, 160, 0 },
+        { 132, 184, 229, 0 },
+        { 2, 204, 126, 0 },
+        { 83, 142, 144, 1 }, },
+      { { 59, 173, 97, 1 },
+        { 143, 252, 131, 0 },
+        { 195, 90, 238, 0 },
+        { 96, 159, 248, 1 }, },
+      { { 59, 112, 47, 1 },
+        { 204, 242, 210, 1 },
+        { 250, 7, 110, 0 },
+        { 165, 167, 153, 1 }, },
+      { { 59, 235, 58, 1 },
+        { 254, 186, 131, 1 },
+        { 174, 107, 238, 0 },
+        { 224, 174, 191, 1 }, },
+      { { 64, 83, 90, 0 },
+        { 112, 7, 65, 1 },
+        { 45, 101, 1, 0 },
+        { 193, 112, 7, 0 }, },
+      { { 65, 152, 22, 0 },
+        { 18, 27, 80, 0 },
+        { 52, 12, 193, 0 },
+        { 5, 108, 36, 0 }, },
+      { { 65, 143, 177, 0 },
+        { 51, 217, 33, 0 },
+        { 70, 248, 193, 0 },
+        { 66, 77, 230, 0 }, },
+      { { 69, 217, 33, 1 },
+        { 74, 217, 69, 0 },
+        { 194, 77, 209, 0 },
+        { 81, 77, 169, 0 }, },
+      { { 69, 235, 1, 0 },
+        { 98, 89, 7, 0 },
+        { 64, 107, 209, 0 },
+        { 112, 77, 35, 0 }, },
+      { { 73, 157, 82, 0 },
+        { 147, 31, 65, 0 },
+        { 37, 92, 201, 0 },
+        { 65, 124, 100, 1 }, },
+      { { 66, 56, 79, 1 },
+        { 8, 79, 210, 1 },
+        { 249, 14, 33, 0 },
+        { 165, 249, 8, 0 }, },
+      { { 74, 166, 163, 1 },
+        { 171, 195, 162, 0 },
+        { 226, 178, 169, 0 },
+        { 34, 225, 234, 1 }, },
+      { { 74, 197, 42, 1 },
+        { 203, 131, 129, 1 },
+        { 170, 81, 169, 0 },
+        { 192, 224, 233, 1 }, },
+      { { 74, 200, 115, 0 },
+        { 210, 207, 128, 0 },
+        { 103, 9, 169, 0 },
+        { 0, 249, 165, 1 }, },
+      { { 71, 180, 198, 1 },
+        { 11, 23, 246, 0 },
+        { 177, 150, 241, 0 },
+        { 55, 244, 104, 0 }, },
+      { { 67, 147, 93, 0 },
+        { 50, 85, 209, 1 },
+        { 93, 100, 225, 0 },
+        { 197, 213, 38, 0 }, },
+      { { 67, 120, 117, 0 },
+        { 80, 221, 210, 0 },
+        { 87, 15, 97, 0 },
+        { 37, 221, 133, 0 }, },
+      { { 79, 58, 175, 1 },
+        { 168, 219, 246, 1 },
+        { 250, 174, 121, 0 },
+        { 183, 237, 138, 1 }, },
+      { { 79, 135, 68, 1 },
+        { 171, 21, 149, 0 },
+        { 145, 112, 249, 0 },
+        { 84, 212, 106, 1 }, },
+      { { 79, 135, 223, 0 },
+        { 179, 87, 181, 1 },
+        { 125, 240, 249, 0 },
+        { 214, 245, 102, 1 }, },
+      { { 79, 196, 222, 1 },
+        { 219, 23, 180, 1 },
+        { 189, 145, 249, 0 },
+        { 150, 244, 109, 1 }, },
+      { { 84, 31, 71, 0 },
+        { 37, 79, 85, 0 },
+        { 113, 124, 21, 0 },
+        { 85, 121, 82, 0 }, },
+      { { 80, 31, 148, 0 },
+        { 53, 9, 113, 0 },
+        { 20, 252, 5, 0 },
+        { 71, 72, 86, 0 }, },
+      { { 92, 145, 67, 0 },
+        { 134, 71, 69, 0 },
+        { 97, 68, 157, 0 },
+        { 81, 113, 48, 1 }, },
+      { { 88, 189, 239, 1 },
+        { 143, 207, 115, 1 },
+        { 251, 222, 141, 0 },
+        { 231, 121, 248, 1 }, },
+      { { 92, 221, 7, 1 },
+        { 207, 75, 85, 0 },
+        { 240, 93, 157, 0 },
+        { 85, 105, 121, 1 }, },
+      { { 92, 102, 88, 1 },
+        { 253, 5, 6, 1 },
+        { 141, 51, 29, 0 },
+        { 176, 80, 95, 1 }, },
+      { { 92, 219, 50, 1 },
+        { 254, 139, 69, 0 },
+        { 166, 109, 157, 0 },
+        { 81, 104, 191, 1 }, },
+      { { 85, 69, 212, 0 },
+        { 85, 21, 53, 0 },
+        { 21, 209, 85, 0 },
+        { 86, 84, 85, 0 }, },
+      { { 81, 68, 62, 0 },
+        { 85, 147, 16, 1 },
+        { 62, 17, 69, 0 },
+        { 132, 100, 213, 0 }, },
+      { { 81, 231, 230, 0 },
+        { 103, 151, 51, 0 },
+        { 51, 243, 197, 0 },
+        { 102, 116, 243, 0 }, },
+      { { 89, 11, 167, 0 },
+        { 164, 219, 49, 0 },
+        { 114, 232, 77, 0 },
+        { 70, 109, 146, 1 }, },
+      { { 93, 186, 56, 1 },
+        { 190, 153, 70, 1 },
+        { 142, 46, 221, 0 },
+        { 177, 76, 190, 1 }, },
+      { { 93, 166, 55, 1 },
+        { 191, 211, 22, 0 },
+        { 246, 50, 221, 0 },
+        { 52, 101, 254, 1 }, },
+      { { 89, 249, 149, 0 },
+        { 214, 89, 115, 0 },
+        { 84, 207, 205, 0 },
+        { 103, 77, 53, 1 }, },
+      { { 93, 255, 236, 0 },
+        { 231, 157, 119, 1 },
+        { 27, 255, 221, 0 },
+        { 247, 92, 243, 1 }, },
+      { { 82, 157, 58, 0 },
+        { 23, 139, 193, 1 },
+        { 46, 92, 165, 0 },
+        { 193, 232, 244, 0 }, },
+      { { 86, 58, 151, 0 },
+        { 52, 75, 246, 0 },
+        { 116, 174, 53, 0 },
+        { 55, 233, 22, 0 }, },
+      { { 82, 99, 34, 0 },
+        { 100, 131, 131, 0 },
+        { 34, 99, 37, 0 },
+        { 96, 224, 147, 0 }, },
+      { { 82, 203, 49, 1 },
+        { 126, 201, 129, 0 },
+        { 198, 105, 165, 0 },
+        { 64, 201, 191, 0 }, },
+      { { 90, 139, 204, 1 },
+        { 174, 13, 177, 1 },
+        { 153, 232, 173, 0 },
+        { 198, 216, 58, 1 }, },
+      { { 83, 33, 106, 0 },
+        { 4, 151, 131, 1 },
+        { 43, 66, 101, 0 },
+        { 224, 244, 144, 0 }, },
+      { { 87, 245, 17, 0 },
+        { 87, 81, 199, 0 },
+        { 68, 87, 245, 0 },
+        { 113, 197, 117, 0 }, },
+      { { 95, 220, 33, 0 },
+        { 199, 217, 196, 0 },
+        { 66, 29, 253, 0 },
+        { 17, 205, 241, 1 }, },
+      { { 96, 140, 28, 0 },
+        { 19, 41, 16, 1 },
+        { 28, 24, 131, 0 },
+        { 132, 74, 100, 0 }, },
+      { { 96, 162, 213, 1 },
+        { 58, 101, 50, 0 },
+        { 213, 162, 131, 0 },
+        { 38, 83, 46, 0 }, },
+      { { 96, 222, 5, 1 },
+        { 107, 105, 80, 0 },
+        { 208, 61, 131, 0 },
+        { 5, 75, 107, 0 }, },
+      { { 108, 76, 110, 0 },
+        { 193, 175, 20, 1 },
+        { 59, 25, 27, 0 },
+        { 148, 122, 193, 1 }, },
+      { { 104, 82, 12, 0 },
+        { 224, 33, 80, 1 },
+        { 24, 37, 11, 0 },
+        { 133, 66, 3, 1 }, },
+      { { 101, 59, 167, 0 },
+        { 32, 251, 119, 0 },
+        { 114, 238, 83, 0 },
+        { 119, 111, 130, 0 }, },
+      { { 97, 170, 234, 0 },
+        { 34, 191, 34, 1 },
+        { 43, 170, 195, 0 },
+        { 162, 126, 162, 0 }, },
+      { { 101, 113, 110, 1 },
+        { 72, 183, 87, 1 },
+        { 187, 71, 83, 0 },
+        { 245, 118, 137, 0 }, },
+      { { 101, 124, 89, 1 },
+        { 89, 125, 70, 1 },
+        { 205, 31, 83, 0 },
+        { 177, 95, 77, 0 }, },
+      { { 105, 131, 46, 1 },
+        { 170, 179, 17, 1 },
+        { 186, 96, 203, 0 },
+        { 196, 102, 170, 1 }, },
+      { { 109, 196, 12, 0 },
+        { 195, 49, 20, 1 },
+        { 24, 17, 219, 0 },
+        { 148, 70, 97, 1 }, },
+      { { 109, 210, 20, 1 },
+        { 250, 49, 84, 0 },
+        { 148, 37, 219, 0 },
+        { 21, 70, 47, 1 }, },
+      { { 98, 150, 165, 1 },
+        { 43, 225, 240, 0 },
+        { 210, 180, 163, 0 },
+        { 7, 195, 234, 0 }, },
+      { { 98, 117, 38, 1 },
+        { 73, 163, 211, 0 },
+        { 178, 87, 35, 0 },
+        { 101, 226, 201, 0 }, },
+      { { 98, 100, 214, 1 },
+        { 89, 39, 178, 0 },
+        { 181, 147, 35, 0 },
+        { 38, 242, 77, 0 }, },
+      { { 98, 91, 220, 1 },
+        { 120, 45, 241, 1 },
+        { 157, 237, 35, 0 },
+        { 199, 218, 15, 0 }, },
+      { { 110, 51, 2, 1 },
+        { 168, 35, 199, 0 },
+        { 160, 102, 59, 0 },
+        { 113, 226, 10, 1 }, },
+      { { 110, 90, 137, 0 },
+        { 224, 105, 228, 1 },
+        { 72, 173, 59, 0 },
+        { 147, 203, 3, 1 }, },
+      { { 99, 209, 212, 0 },
+        { 82, 53, 241, 0 },
+        { 21, 197, 227, 0 },
+        { 71, 214, 37, 0 }, },
+      { { 99, 75, 129, 1 },
+        { 104, 121, 161, 0 },
+        { 192, 233, 99, 0 },
+        { 66, 207, 11, 0 }, },
+      { { 107, 56, 145, 1 },
+        { 152, 121, 226, 0 },
+        { 196, 142, 107, 0 },
+        { 35, 207, 12, 1 }, },
+      { { 107, 122, 42, 0 },
+        { 224, 187, 194, 1 },
+        { 42, 47, 107, 0 },
+        { 161, 238, 131, 1 }, },
+      { { 116, 56, 51, 0 },
+        { 20, 235, 70, 0 },
+        { 102, 14, 23, 0 },
+        { 49, 107, 148, 0 }, },
+      { { 112, 6, 44, 0 },
+        { 37, 161, 16, 1 },
+        { 26, 48, 7, 0 },
+        { 132, 66, 210, 0 }, },
+      { { 116, 170, 141, 1 },
+        { 46, 105, 54, 1 },
+        { 216, 170, 151, 0 },
+        { 182, 75, 58, 0 }, },
+      { { 116, 76, 143, 0 },
+        { 69, 107, 52, 1 },
+        { 120, 153, 23, 0 },
+        { 150, 107, 81, 0 }, },
+      { { 124, 183, 167, 0 },
+        { 167, 227, 119, 0 },
+        { 114, 246, 159, 0 },
+        { 119, 99, 242, 1 }, },
+      { { 120, 3, 22, 1 },
+        { 188, 35, 17, 0 },
+        { 180, 96, 15, 0 },
+        { 68, 98, 30, 1 }, },
+      { { 124, 199, 198, 1 },
+        { 239, 39, 53, 0 },
+        { 177, 241, 159, 0 },
+        { 86, 114, 123, 1 }, },
+      { { 117, 182, 4, 1 },
+        { 47, 49, 86, 0 },
+        { 144, 54, 215, 0 },
+        { 53, 70, 122, 0 }, },
+      { { 113, 254, 101, 0 },
+        { 103, 253, 82, 0 },
+        { 83, 63, 199, 0 },
+        { 37, 95, 243, 0 }, },
+      { { 113, 79, 154, 1 },
+        { 125, 59, 33, 1 },
+        { 172, 249, 71, 0 },
+        { 194, 110, 95, 0 }, },
+      { { 121, 32, 119, 0 },
+        { 148, 247, 18, 0 },
+        { 119, 2, 79, 0 },
+        { 36, 119, 148, 1 }, },
+      { { 125, 121, 205, 0 },
+        { 196, 125, 119, 1 },
+        { 89, 207, 95, 0 },
+        { 247, 95, 17, 1 }, },
+      { { 125, 67, 92, 0 },
+        { 244, 53, 21, 1 },
+        { 29, 97, 95, 0 },
+        { 212, 86, 23, 1 }, },
+      { { 125, 127, 59, 0 },
+        { 245, 251, 71, 1 },
+        { 110, 127, 95, 0 },
+        { 241, 111, 215, 1 }, },
+      { { 118, 85, 8, 0 },
+        { 69, 33, 197, 1 },
+        { 8, 85, 55, 0 },
+        { 209, 194, 81, 0 }, },
+      { { 122, 152, 199, 0 },
+        { 134, 111, 240, 0 },
+        { 113, 140, 175, 0 },
+        { 7, 251, 48, 1 }, },
+      { { 126, 19, 192, 0 },
+        { 164, 37, 229, 0 },
+        { 1, 228, 63, 0 },
+        { 83, 210, 18, 1 }, },
+      { { 126, 94, 89, 1 },
+        { 253, 109, 196, 1 },
+        { 205, 61, 63, 0 },
+        { 145, 219, 95, 1 }, },
+      { { 115, 36, 132, 0 },
+        { 5, 49, 178, 0 },
+        { 16, 146, 103, 0 },
+        { 38, 198, 80, 0 }, },
+      { { 115, 46, 39, 1 },
+        { 45, 251, 146, 0 },
+        { 242, 58, 103, 0 },
+        { 36, 239, 218, 0 }, },
+      { { 115, 139, 84, 1 },
+        { 62, 61, 145, 0 },
+        { 149, 104, 231, 0 },
+        { 68, 222, 62, 0 }, },
+      { { 132, 4, 34, 0 },
+        { 1, 130, 12, 0 },
+        { 34, 16, 16, 1 },
+        { 24, 32, 192, 0 }, },
+      { { 128, 232, 46, 0 },
+        { 66, 138, 26, 1 },
+        { 58, 11, 128, 1 },
+        { 172, 40, 161, 0 }, },
+      { { 128, 237, 48, 0 },
+        { 83, 136, 11, 0 },
+        { 6, 91, 128, 1 },
+        { 104, 8, 229, 0 }, },
+      { { 140, 53, 96, 0 },
+        { 129, 132, 79, 0 },
+        { 3, 86, 24, 1 },
+        { 121, 16, 192, 1 }, },
+      { { 140, 120, 240, 1 },
+        { 216, 140, 110, 0 },
+        { 135, 143, 24, 1 },
+        { 59, 24, 141, 1 }, },
+      { { 136, 194, 128, 1 },
+        { 234, 0, 40, 0 },
+        { 128, 161, 136, 1 },
+        { 10, 0, 43, 1 }, },
+      { { 129, 26, 100, 1 },
+        { 40, 156, 88, 0 },
+        { 147, 44, 64, 1 },
+        { 13, 28, 138, 0 }, },
+      { { 129, 38, 163, 0 },
+        { 33, 210, 42, 0 },
+        { 98, 178, 64, 1 },
+        { 42, 37, 194, 0 }, },
+      { { 133, 154, 140, 1 },
+        { 42, 24, 124, 1 },
+        { 152, 172, 208, 1 },
+        { 159, 12, 42, 0 }, },
+      { { 137, 19, 23, 1 },
+        { 184, 82, 89, 0 },
+        { 244, 100, 72, 1 },
+        { 77, 37, 14, 1 }, },
+      { { 130, 9, 37, 0 },
+        { 0, 200, 153, 0 },
+        { 82, 72, 32, 1 },
+        { 76, 137, 128, 0 }, },
+      { { 130, 183, 201, 1 },
+        { 43, 68, 235, 1 },
+        { 201, 246, 160, 1 },
+        { 235, 145, 106, 0 }, },
+      { { 142, 185, 191, 1 },
+        { 154, 202, 255, 1 },
+        { 254, 206, 184, 1 },
+        { 255, 169, 172, 1 }, },
+      { { 138, 159, 236, 0 },
+        { 163, 140, 249, 1 },
+        { 27, 252, 168, 1 },
+        { 207, 152, 226, 1 }, },
+      { { 142, 228, 226, 0 },
+        { 195, 134, 174, 0 },
+        { 35, 147, 184, 1 },
+        { 58, 176, 225, 1 }, },
+      { { 135, 32, 232, 0 },
+        { 0, 148, 174, 1 },
+        { 11, 130, 112, 1 },
+        { 186, 148, 128, 0 }, },
+      { { 135, 205, 96, 1 },
+        { 75, 156, 141, 0 },
+        { 131, 89, 240, 1 },
+        { 88, 156, 233, 0 }, },
+      { { 135, 71, 172, 1 },
+        { 105, 144, 189, 1 },
+        { 154, 241, 112, 1 },
+        { 222, 132, 203, 0 }, },
+      { { 139, 10, 91, 0 },
+        { 176, 94, 136, 1 },
+        { 109, 40, 104, 1 },
+        { 136, 189, 6, 1 }, },
+      { { 139, 92, 190, 1 },
+        { 217, 154, 248, 1 },
+        { 190, 157, 104, 1 },
+        { 143, 172, 205, 1 }, },
+      { { 143, 213, 180, 0 },
+        { 211, 144, 253, 0 },
+        { 22, 213, 248, 1 },
+        { 95, 132, 229, 1 }, },
+      { { 139, 118, 41, 0 },
+        { 225, 208, 202, 1 },
+        { 74, 55, 104, 1 },
+        { 169, 133, 195, 1 }, },
+      { { 148, 51, 175, 0 },
+        { 36, 194, 127, 1 },
+        { 122, 230, 20, 1 },
+        { 255, 33, 146, 0 }, },
+      { { 144, 85, 72, 1 },
+        { 77, 4, 73, 1 },
+        { 137, 85, 4, 1 },
+        { 201, 16, 89, 0 }, },
+      { { 156, 62, 39, 0 },
+        { 165, 202, 94, 0 },
+        { 114, 62, 28, 1 },
+        { 61, 41, 210, 1 }, },
+      { { 152, 151, 159, 0 },
+        { 183, 66, 121, 1 },
+        { 124, 244, 140, 1 },
+        { 207, 33, 118, 1 }, },
+      { { 152, 88, 144, 1 },
+        { 220, 8, 104, 0 },
+        { 132, 141, 12, 1 },
+        { 11, 8, 29, 1 }, },
+      { { 149, 182, 31, 0 },
+        { 55, 82, 94, 1 },
+        { 124, 54, 212, 1 },
+        { 189, 37, 118, 0 }, },
+      { { 145, 64, 55, 0 },
+        { 84, 210, 24, 0 },
+        { 118, 1, 68, 1 },
+        { 12, 37, 149, 0 }, },
+      { { 157, 179, 128, 0 },
+        { 166, 16, 111, 0 },
+        { 0, 230, 220, 1 },
+        { 123, 4, 50, 1 }, },
+      { { 153, 65, 137, 1 },
+        { 204, 80, 41, 1 },
+        { 200, 193, 76, 1 },
+        { 202, 5, 25, 1 }, },
+      { { 146, 173, 38, 0 },
+        { 7, 138, 155, 0 },
+        { 50, 90, 164, 1 },
+        { 108, 168, 240, 0 }, },
+      { { 146, 101, 228, 1 },
+        { 77, 132, 187, 0 },
+        { 147, 211, 36, 1 },
+        { 110, 144, 217, 0 }, },
+      { { 146, 111, 141, 1 },
+        { 109, 72, 187, 1 },
+        { 216, 251, 36, 1 },
+        { 238, 137, 91, 0 }, },
+      { { 150, 94, 153, 0 },
+        { 117, 72, 236, 1 },
+        { 76, 189, 52, 1 },
+        { 155, 137, 87, 0 }, },
+      { { 154, 11, 77, 0 },
+        { 164, 76, 153, 1 },
+        { 89, 104, 44, 1 },
+        { 204, 153, 18, 1 }, },
+      { { 154, 221, 17, 0 },
+        { 215, 72, 201, 0 },
+        { 68, 93, 172, 1 },
+        { 73, 137, 117, 1 }, },
+      { { 147, 246, 156, 1 },
+        { 127, 16, 250, 1 },
+        { 156, 183, 228, 1 },
+        { 175, 132, 127, 0 }, },
+      { { 159, 52, 189, 1 },
+        { 157, 208, 254, 1 },
+        { 222, 150, 124, 1 },
+        { 191, 133, 220, 1 }, },
+      { { 159, 80, 9, 0 },
+        { 196, 80, 204, 1 },
+        { 72, 5, 124, 1 },
+        { 153, 133, 17, 1 }, },
+      { { 160, 153, 27, 1 },
+        { 26, 106, 73, 1 },
+        { 236, 76, 130, 1 },
+        { 201, 43, 44, 0 }, },
+      { { 164, 15, 234, 0 },
+        { 33, 174, 45, 1 },
+        { 43, 248, 18, 1 },
+        { 218, 58, 194, 0 }, },
+      { { 160, 15, 83, 1 },
+        { 57, 110, 9, 0 },
+        { 229, 120, 2, 1 },
+        { 72, 59, 78, 0 }, },
+      { { 168, 2, 105, 1 },
+        { 168, 228, 8, 1 },
+        { 203, 32, 10, 1 },
+        { 136, 19, 138, 1 }, },
+      { { 172, 27, 205, 1 },
+        { 168, 108, 125, 1 },
+        { 217, 236, 26, 1 },
+        { 223, 27, 10, 1 }, },
+      { { 172, 135, 77, 0 },
+        { 163, 100, 29, 1 },
+        { 89, 112, 154, 1 },
+        { 220, 19, 98, 1 }, },
+      { { 172, 118, 200, 0 },
+        { 225, 36, 110, 1 },
+        { 9, 183, 26, 1 },
+        { 187, 18, 67, 1 }, },
+      { { 165, 68, 167, 0 },
+        { 65, 242, 60, 0 },
+        { 114, 145, 82, 1 },
+        { 30, 39, 193, 0 }, },
+      { { 161, 244, 92, 0 },
+        { 83, 52, 90, 1 },
+        { 29, 23, 194, 1 },
+        { 173, 22, 101, 0 }, },
+      { { 169, 157, 169, 0 },
+        { 131, 248, 105, 1 },
+        { 74, 220, 202, 1 },
+        { 203, 15, 224, 1 }, },
+      { { 169, 135, 255, 0 },
+        { 179, 246, 57, 1 },
+        { 127, 240, 202, 1 },
+        { 206, 55, 230, 1 }, },
+      { { 169, 71, 98, 1 },
+        { 233, 182, 9, 0 },
+        { 163, 113, 74, 1 },
+        { 72, 54, 203, 1 }, },
+      { { 166, 129, 114, 1 },
+        { 26, 166, 141, 0 },
+        { 167, 64, 178, 1 },
+        { 88, 178, 172, 0 }, },
+      { { 166, 249, 172, 1 },
+        { 74, 168, 255, 1 },
+        { 154, 207, 178, 1 },
+        { 255, 138, 169, 0 }, },
+      { { 162, 196, 38, 0 },
+        { 67, 162, 152, 0 },
+        { 50, 17, 162, 1 },
+        { 12, 162, 225, 0 }, },
+      { { 170, 53, 101, 1 },
+        { 137, 228, 219, 0 },
+        { 211, 86, 42, 1 },
+        { 109, 147, 200, 1 }, },
+      { { 170, 168, 102, 0 },
+        { 130, 174, 154, 0 },
+        { 51, 10, 170, 1 },
+        { 44, 186, 160, 1 }, },
+      { { 170, 200, 143, 0 },
+        { 194, 106, 184, 1 },
+        { 120, 137, 170, 1 },
+        { 142, 171, 33, 1 }, },
+      { { 167, 110, 148, 1 },
+        { 121, 56, 190, 0 },
+        { 148, 187, 114, 1 },
+        { 62, 142, 79, 0 }, },
+      { { 175, 4, 36, 1 },
+        { 137, 176, 156, 0 },
+        { 146, 16, 122, 1 },
+        { 28, 134, 200, 1 }, },
+      { { 176, 65, 44, 0 },
+        { 68, 160, 25, 1 },
+        { 26, 65, 6, 1 },
+        { 204, 2, 145, 0 }, },
+      { { 176, 208, 227, 0 },
+        { 70, 230, 104, 0 },
+        { 99, 133, 134, 1 },
+        { 11, 51, 177, 0 }, },
+      { { 176, 237, 129, 1 },
+        { 79, 104, 43, 0 },
+        { 192, 219, 134, 1 },
+        { 106, 11, 121, 0 }, },
+      { { 180, 231, 236, 0 },
+        { 103, 164, 63, 1 },
+        { 27, 243, 150, 1 },
+        { 254, 18, 243, 0 }, },
+      { { 184, 160, 236, 1 },
+        { 142, 164, 58, 1 },
+        { 155, 130, 142, 1 },
+        { 174, 18, 184, 1 }, },
+      { { 184, 188, 60, 1 },
+        { 159, 168, 90, 1 },
+        { 158, 30, 142, 1 },
+        { 173, 10, 252, 1 }, },
+      { { 177, 102, 224, 1 },
+        { 109, 180, 42, 0 },
+        { 131, 179, 70, 1 },
+        { 42, 22, 219, 0 }, },
+      { { 189, 49, 10, 1 },
+        { 140, 50, 79, 1 },
+        { 168, 70, 94, 1 },
+        { 249, 38, 24, 1 }, },
+      { { 189, 63, 186, 1 },
+        { 189, 186, 111, 1 },
+        { 174, 254, 94, 1 },
+        { 251, 46, 222, 1 }, },
+      { { 185, 190, 220, 0 },
+        { 183, 60, 122, 1 },
+        { 29, 190, 206, 1 },
+        { 175, 30, 118, 1 }, },
+      { { 178, 58, 240, 1 },
+        { 60, 172, 234, 0 },
+        { 135, 174, 38, 1 },
+        { 43, 154, 158, 0 }, },
+      { { 182, 207, 169, 0 },
+        { 103, 232, 173, 1 },
+        { 74, 249, 182, 1 },
+        { 218, 139, 243, 0 }, },
+      { { 186, 35, 226, 1 },
+        { 172, 166, 171, 0 },
+        { 163, 226, 46, 1 },
+        { 106, 178, 154, 1 }, },
+      { { 183, 36, 171, 1 },
+        { 13, 242, 174, 1 },
+        { 234, 146, 118, 1 },
+        { 186, 167, 216, 0 }, },
+      { { 183, 41, 251, 0 },
+        { 20, 254, 175, 1 },
+        { 111, 202, 118, 1 },
+        { 250, 191, 148, 0 }, },
+      { { 179, 174, 8, 0 },
+        { 39, 56, 138, 1 },
+        { 8, 58, 230, 1 },
+        { 168, 142, 114, 0 }, },
+      { { 183, 86, 202, 1 },
+        { 109, 54, 236, 1 },
+        { 169, 181, 118, 1 },
+        { 155, 182, 91, 0 }, },
+      { { 191, 168, 244, 0 },
+        { 150, 188, 190, 0 },
+        { 23, 138, 254, 1 },
+        { 62, 158, 180, 1 }, },
+      { { 191, 148, 18, 1 },
+        { 159, 50, 204, 0 },
+        { 164, 20, 254, 1 },
+        { 25, 166, 124, 1 }, },
+      { { 191, 122, 64, 1 },
+        { 236, 60, 206, 0 },
+        { 129, 47, 126, 1 },
+        { 57, 158, 27, 1 }, },
+      { { 196, 133, 200, 0 },
+        { 3, 5, 45, 1 },
+        { 9, 208, 145, 1 },
+        { 218, 80, 96, 0 }, },
+      { { 192, 14, 9, 1 },
+        { 41, 73, 8, 1 },
+        { 200, 56, 1, 1 },
+        { 136, 73, 74, 0 }, },
+      { { 192, 112, 254, 0 },
+        { 80, 135, 122, 1 },
+        { 63, 135, 1, 1 },
+        { 175, 112, 133, 0 }, },
+      { { 204, 116, 17, 0 },
+        { 209, 65, 78, 0 },
+        { 68, 23, 25, 1 },
+        { 57, 65, 69, 1 }, },
+      { { 193, 8, 90, 1 },
+        { 24, 31, 8, 1 },
+        { 173, 8, 65, 1 },
+        { 136, 124, 12, 0 }, },
+      { { 193, 47, 130, 1 },
+        { 41, 27, 43, 0 },
+        { 160, 250, 65, 1 },
+        { 106, 108, 74, 0 }, },
+      { { 193, 35, 120, 0 },
+        { 48, 149, 11, 1 },
+        { 15, 98, 65, 1 },
+        { 232, 84, 134, 0 }, },
+      { { 198, 52, 219, 1 },
+        { 25, 71, 238, 1 },
+        { 237, 150, 49, 1 },
+        { 187, 241, 76, 0 }, },
+      { { 198, 164, 244, 1 },
+        { 27, 133, 190, 0 },
+        { 151, 146, 177, 1 },
+        { 62, 208, 236, 0 }, },
+      { { 194, 228, 25, 0 },
+        { 83, 65, 138, 1 },
+        { 76, 19, 161, 1 },
+        { 168, 193, 101, 0 }, },
+      { { 195, 29, 35, 0 },
+        { 1, 219, 201, 0 },
+        { 98, 92, 97, 1 },
+        { 73, 237, 192, 0 }, },
+      { { 195, 242, 196, 1 },
+        { 106, 21, 250, 0 },
+        { 145, 167, 225, 1 },
+        { 47, 212, 43, 0 }, },
+      { { 199, 95, 223, 0 },
+        { 113, 95, 253, 1 },
+        { 125, 253, 113, 1 },
+        { 223, 253, 71, 0 }, },
+      { { 203, 101, 189, 0 },
+        { 209, 209, 187, 1 },
+        { 94, 211, 105, 1 },
+        { 238, 197, 197, 1 }, },
+      { { 203, 199, 15, 1 },
+        { 235, 83, 153, 1 },
+        { 248, 113, 233, 1 },
+        { 204, 229, 107, 1 }, },
+      { { 207, 246, 185, 0 },
+        { 243, 209, 238, 1 },
+        { 78, 183, 249, 1 },
+        { 187, 197, 231, 1 }, },
+      { { 212, 84, 239, 0 },
+        { 69, 199, 124, 1 },
+        { 123, 149, 21, 1 },
+        { 159, 113, 209, 0 }, },
+      { { 212, 251, 220, 0 },
+        { 118, 13, 127, 1 },
+        { 29, 239, 149, 1 },
+        { 255, 88, 55, 0 }, },
+      { { 220, 232, 84, 0 },
+        { 214, 13, 30, 0 },
+        { 21, 11, 157, 1 },
+        { 60, 88, 53, 1 }, },
+      { { 213, 177, 150, 0 },
+        { 22, 19, 127, 0 },
+        { 52, 198, 213, 1 },
+        { 127, 100, 52, 0 }, },
+      { { 209, 159, 7, 1 },
+        { 47, 91, 89, 0 },
+        { 240, 124, 197, 1 },
+        { 77, 109, 122, 0 }, },
+      { { 209, 93, 126, 1 },
+        { 93, 159, 89, 1 },
+        { 191, 93, 69, 1 },
+        { 205, 124, 221, 0 }, },
+      { { 217, 164, 134, 1 },
+        { 143, 19, 58, 0 },
+        { 176, 146, 205, 1 },
+        { 46, 100, 120, 1 }, },
+      { { 221, 9, 48, 1 },
+        { 156, 153, 13, 0 },
+        { 134, 72, 93, 1 },
+        { 88, 76, 156, 1 }, },
+      { { 217, 180, 57, 1 },
+        { 159, 209, 74, 1 },
+        { 206, 22, 205, 1 },
+        { 169, 69, 252, 1 }, },
+      { { 221, 171, 105, 1 },
+        { 174, 221, 15, 1 },
+        { 203, 106, 221, 1 },
+        { 248, 93, 186, 1 }, },
+      { { 217, 203, 66, 0 },
+        { 230, 31, 9, 0 },
+        { 33, 105, 205, 1 },
+        { 72, 124, 51, 1 }, },
+      { { 210, 33, 13, 0 },
+        { 4, 65, 155, 1 },
+        { 88, 66, 37, 1 },
+        { 236, 193, 16, 0 }, },
+      { { 214, 73, 4, 0 },
+        { 68, 9, 157, 0 },
+        { 16, 73, 53, 1 },
+        { 92, 200, 17, 0 }, },
+      { { 210, 216, 219, 0 },
+        { 86, 79, 232, 1 },
+        { 109, 141, 165, 1 },
+        { 139, 249, 53, 0 }, },
+      { { 218, 63, 69, 1 },
+        { 173, 77, 219, 0 },
+        { 209, 126, 45, 1 },
+        { 109, 217, 90, 1 }, },
+      { { 218, 125, 218, 0 },
+        { 213, 15, 235, 1 },
+        { 45, 223, 45, 1 },
+        { 235, 248, 85, 1 }, },
+      { { 218, 211, 230, 0 },
+        { 230, 135, 249, 0 },
+        { 51, 229, 173, 1 },
+        { 79, 240, 179, 1 }, },
+      { { 211, 51, 189, 0 },
+        { 52, 209, 251, 1 },
+        { 94, 230, 101, 1 },
+        { 239, 197, 150, 0 }, },
+      { { 215, 225, 237, 1 },
+        { 78, 213, 191, 1 },
+        { 219, 195, 245, 1 },
+        { 254, 213, 185, 0 }, },
+      { { 219, 197, 122, 0 },
+        { 215, 151, 137, 1 },
+        { 47, 81, 237, 1 },
+        { 200, 244, 245, 1 }, },
+      { { 224, 128, 59, 1 },
+        { 26, 227, 8, 1 },
+        { 238, 0, 131, 1 },
+        { 136, 99, 172, 0 }, },
+      { { 224, 207, 105, 1 },
+        { 107, 237, 9, 1 },
+        { 203, 121, 131, 1 },
+        { 200, 91, 235, 0 }, },
+      { { 228, 71, 48, 1 },
+        { 121, 161, 13, 0 },
+        { 134, 113, 19, 1 },
+        { 88, 66, 207, 0 }, },
+      { { 232, 29, 86, 1 },
+        { 153, 47, 89, 0 },
+        { 181, 92, 11, 1 },
+        { 77, 122, 76, 1 }, },
+      { { 232, 243, 72, 1 },
+        { 234, 37, 75, 1 },
+        { 137, 103, 139, 1 },
+        { 233, 82, 43, 1 }, },
+      { { 232, 254, 175, 0 },
+        { 227, 235, 122, 1 },
+        { 122, 191, 139, 1 },
+        { 175, 107, 227, 1 }, },
+      { { 236, 231, 159, 0 },
+        { 243, 99, 63, 1 },
+        { 124, 243, 155, 1 },
+        { 254, 99, 103, 1 }, },
+      { { 225, 60, 212, 1 },
+        { 25, 61, 122, 0 },
+        { 149, 158, 67, 1 },
+        { 47, 94, 76, 0 }, },
+      { { 229, 204, 106, 1 },
+        { 75, 191, 12, 1 },
+        { 171, 25, 211, 1 },
+        { 152, 126, 233, 0 }, },
+      { { 233, 175, 154, 0 },
+        { 179, 59, 43, 1 },
+        { 44, 250, 203, 1 },
+        { 234, 110, 102, 1 }, },
+      { { 227, 0, 237, 0 },
+        { 0, 245, 184, 1 },
+        { 91, 128, 99, 1 },
+        { 142, 215, 128, 0 }, },
+      { { 231, 177, 14, 0 },
+        { 2, 51, 223, 1 },
+        { 56, 70, 243, 1 },
+        { 253, 230, 32, 0 }, },
+      { { 227, 192, 126, 0 },
+        { 82, 183, 152, 1 },
+        { 63, 1, 227, 1 },
+        { 140, 246, 165, 0 }, },
+      { { 235, 140, 163, 0 },
+        { 131, 251, 168, 0 },
+        { 98, 152, 235, 1 },
+        { 10, 239, 224, 1 }, },
+      { { 235, 159, 109, 1 },
+        { 171, 253, 217, 1 },
+        { 219, 124, 235, 1 },
+        { 205, 223, 234, 1 }, },
+      { { 239, 65, 11, 0 },
+        { 192, 115, 141, 1 },
+        { 104, 65, 123, 1 },
+        { 216, 231, 1, 1 }, },
+      { { 239, 194, 195, 0 },
+        { 226, 119, 172, 0 },
+        { 97, 161, 251, 1 },
+        { 26, 247, 35, 1 }, },
+      { { 240, 168, 32, 0 },
+        { 6, 169, 10, 0 },
+        { 2, 10, 135, 1 },
+        { 40, 74, 176, 0 }, },
+      { { 244, 25, 211, 0 },
+        { 20, 111, 109, 0 },
+        { 101, 204, 23, 1 },
+        { 91, 123, 20, 0 }, },
+      { { 244, 133, 191, 1 },
+        { 31, 227, 61, 1 },
+        { 254, 208, 151, 1 },
+        { 222, 99, 252, 0 }, },
+      { { 240, 106, 204, 0 },
+        { 100, 45, 58, 1 },
+        { 25, 171, 7, 1 },
+        { 174, 90, 19, 0 }, },
+      { { 240, 123, 107, 1 },
+        { 108, 239, 75, 1 },
+        { 235, 111, 7, 1 },
+        { 233, 123, 155, 0 }, },
+      { { 244, 251, 170, 0 },
+        { 102, 171, 111, 1 },
+        { 42, 239, 151, 1 },
+        { 251, 106, 179, 0 }, },
+      { { 252, 198, 47, 0 },
+        { 231, 227, 28, 1 },
+        { 122, 49, 159, 1 },
+        { 156, 99, 243, 1 }, },
+      { { 248, 111, 16, 0 },
+        { 245, 41, 11, 0 },
+        { 4, 123, 15, 1 },
+        { 104, 74, 87, 1 }, },
+      { { 252, 127, 120, 1 },
+        { 253, 173, 79, 1 },
+        { 143, 127, 31, 1 },
+        { 249, 90, 223, 1 }, },
+      { { 241, 171, 217, 0 },
+        { 54, 125, 43, 1 },
+        { 77, 234, 199, 1 },
+        { 234, 95, 54, 0 }, },
+      { { 245, 81, 143, 1 },
+        { 76, 115, 125, 1 },
+        { 248, 197, 87, 1 },
+        { 223, 103, 25, 0 }, },
+      { { 241, 248, 166, 1 },
+        { 78, 187, 122, 0 },
+        { 178, 143, 199, 1 },
+        { 47, 110, 185, 0 }, },
+      { { 241, 86, 24, 0 },
+        { 117, 49, 72, 1 },
+        { 12, 53, 71, 1 },
+        { 137, 70, 87, 0 }, },
+      { { 253, 132, 196, 0 },
+        { 135, 53, 60, 0 },
+        { 17, 144, 223, 1 },
+        { 30, 86, 112, 1 }, },
+      { { 249, 141, 114, 1 },
+        { 159, 191, 9, 0 },
+        { 167, 88, 207, 1 },
+        { 72, 126, 252, 1 }, },
+      { { 253, 15, 85, 1 },
+        { 189, 125, 29, 0 },
+        { 213, 120, 95, 1 },
+        { 92, 95, 94, 1 }, },
+      { { 242, 156, 111, 1 },
+        { 15, 239, 216, 1 },
+        { 251, 28, 167, 1 },
+        { 141, 251, 248, 0 }, },
+      { { 246, 136, 24, 1 },
+        { 30, 41, 140, 1 },
+        { 140, 8, 183, 1 },
+        { 152, 202, 60, 0 }, },
+      { { 246, 7, 197, 0 },
+        { 37, 101, 189, 0 },
+        { 81, 240, 55, 1 },
+        { 94, 211, 82, 0 }, },
+      { { 242, 65, 215, 0 },
+        { 84, 103, 185, 0 },
+        { 117, 193, 39, 1 },
+        { 78, 243, 21, 0 }, },
+      { { 246, 241, 27, 0 },
+        { 86, 99, 207, 1 },
+        { 108, 71, 183, 1 },
+        { 249, 227, 53, 0 }, },
+      { { 242, 230, 203, 1 },
+        { 111, 103, 170, 1 },
+        { 233, 179, 167, 1 },
+        { 170, 243, 123, 0 }, },
+      { { 250, 213, 32, 1 },
+        { 207, 161, 201, 0 },
+        { 130, 85, 175, 1 },
+        { 73, 194, 249, 1 }, },
+      { { 254, 67, 233, 0 },
+        { 228, 229, 173, 1 },
+        { 75, 225, 63, 1 },
+        { 218, 211, 147, 1 }, },
+      { { 243, 251, 142, 0 },
+        { 102, 59, 251, 1 },
+        { 56, 239, 231, 1 },
+        { 239, 238, 51, 0 }, },
+      { { 255, 187, 218, 0 },
+        { 182, 63, 239, 1 },
+        { 45, 238, 255, 1 },
+        { 251, 254, 54, 1 }, },
+      { { 251, 201, 14, 1 },
+        { 206, 59, 153, 1 },
+        { 184, 73, 239, 1 },
+        { 204, 238, 57, 1 }, }, };
+
+static unsigned char DICT_6X6_1000_BYTES[][4][5] =
+    { { { 30, 61, 216, 42, 6 },
+        { 227, 186, 70, 49, 9 },
+        { 101, 65, 187, 199, 8 },
+        { 152, 198, 37, 220, 7 }, },
+      { { 14, 251, 163, 137, 1 },
+        { 215, 230, 24, 5, 14 },
+        { 137, 28, 93, 247, 0 },
+        { 122, 1, 134, 126, 11 }, },
+      { { 21, 144, 126, 172, 13 },
+        { 236, 105, 87, 80, 6 },
+        { 179, 87, 224, 154, 8 },
+        { 96, 174, 169, 99, 7 }, },
+      { { 201, 27, 48, 105, 14 },
+        { 66, 50, 75, 222, 12 },
+        { 121, 96, 205, 137, 3 },
+        { 55, 189, 36, 196, 2 }, },
+      { { 214, 7, 214, 225, 5 },
+        { 164, 203, 74, 191, 2 },
+        { 168, 118, 190, 6, 11 },
+        { 79, 213, 45, 50, 5 }, },
+      { { 216, 232, 224, 230, 8 },
+        { 43, 140, 19, 138, 15 },
+        { 22, 112, 113, 113, 11 },
+        { 245, 28, 131, 29, 4 }, },
+      { { 66, 104, 180, 31, 5 },
+        { 13, 165, 192, 149, 13 },
+        { 175, 130, 209, 100, 2 },
+        { 186, 144, 58, 91, 0 }, },
+      { { 136, 165, 15, 41, 10 },
+        { 19, 115, 23, 38, 0 },
+        { 89, 79, 10, 81, 1 },
+        { 6, 78, 140, 236, 8 }, },
+      { { 48, 125, 82, 79, 13 },
+        { 109, 110, 97, 60, 9 },
+        { 191, 36, 171, 224, 12 },
+        { 147, 200, 103, 107, 6 }, },
+      { { 60, 47, 52, 179, 12 },
+        { 131, 11, 235, 52, 15 },
+        { 60, 210, 207, 67, 12 },
+        { 242, 205, 125, 12, 1 }, },
+      { { 69, 223, 199, 78, 3 },
+        { 252, 247, 24, 232, 9 },
+        { 199, 46, 63, 186, 2 },
+        { 145, 113, 142, 243, 15 }, },
+      { { 72, 216, 91, 37, 7 },
+        { 126, 84, 86, 148, 8 },
+        { 234, 77, 161, 177, 2 },
+        { 18, 150, 162, 167, 14 }, },
+      { { 113, 5, 88, 252, 6 },
+        { 40, 58, 230, 248, 2 },
+        { 99, 241, 170, 8, 14 },
+        { 65, 246, 117, 193, 4 }, },
+      { { 134, 220, 250, 208, 7 },
+        { 228, 212, 212, 59, 14 },
+        { 224, 181, 243, 182, 1 },
+        { 125, 194, 178, 178, 7 }, },
+      { { 141, 114, 169, 63, 6 },
+        { 219, 180, 206, 70, 5 },
+        { 111, 201, 84, 235, 1 },
+        { 166, 39, 50, 221, 11 }, },
+      { { 162, 184, 157, 205, 14 },
+        { 89, 177, 117, 31, 10 },
+        { 123, 59, 145, 212, 5 },
+        { 95, 138, 232, 217, 10 }, },
+      { { 9, 253, 30, 156, 4 },
+        { 75, 103, 212, 112, 10 },
+        { 35, 151, 139, 249, 0 },
+        { 80, 226, 190, 109, 2 }, },
+      { { 21, 77, 189, 24, 15 },
+        { 148, 191, 197, 112, 12 },
+        { 241, 139, 219, 42, 8 },
+        { 48, 234, 63, 210, 9 }, },
+      { { 48, 10, 49, 14, 2 },
+        { 24, 56, 40, 16, 13 },
+        { 71, 8, 197, 0, 12 },
+        { 176, 129, 65, 193, 8 }, },
+      { { 72, 7, 239, 175, 13 },
+        { 62, 227, 79, 164, 7 },
+        { 191, 95, 126, 1, 2 },
+        { 226, 95, 44, 119, 12 }, },
+      { { 86, 223, 17, 219, 6 },
+        { 208, 62, 216, 189, 11 },
+        { 109, 184, 143, 182, 10 },
+        { 219, 209, 183, 192, 11 }, },
+      { { 102, 136, 50, 116, 12 },
+        { 136, 64, 243, 153, 12 },
+        { 50, 228, 193, 22, 6 },
+        { 57, 156, 240, 33, 1 }, },
+      { { 118, 232, 203, 120, 1 },
+        { 181, 236, 182, 137, 8 },
+        { 129, 237, 49, 118, 14 },
+        { 25, 22, 211, 122, 13 }, },
+      { { 154, 83, 217, 207, 3 },
+        { 126, 190, 12, 31, 3 },
+        { 207, 57, 188, 165, 9 },
+        { 207, 131, 7, 215, 14 }, },
+      { { 169, 203, 132, 2, 4 },
+        { 2, 135, 120, 66, 9 },
+        { 36, 2, 29, 57, 5 },
+        { 148, 33, 238, 20, 0 }, },
+      { { 198, 117, 73, 73, 0 },
+        { 241, 38, 4, 175, 0 },
+        { 9, 41, 42, 230, 3 },
+        { 15, 82, 6, 72, 15 }, },
+      { { 193, 210, 136, 148, 1 },
+        { 76, 132, 156, 194, 2 },
+        { 130, 145, 20, 184, 3 },
+        { 68, 51, 146, 19, 2 }, },
+      { { 231, 72, 8, 82, 11 },
+        { 132, 20, 165, 203, 9 },
+        { 212, 161, 1, 46, 7 },
+        { 157, 58, 82, 130, 1 }, },
+      { { 234, 47, 202, 132, 8 },
+        { 43, 194, 45, 163, 10 },
+        { 18, 21, 63, 69, 7 },
+        { 92, 91, 68, 61, 4 }, },
+      { { 233, 99, 183, 123, 1 },
+        { 23, 231, 170, 222, 5 },
+        { 141, 238, 220, 105, 7 },
+        { 167, 181, 94, 126, 8 }, },
+      { { 250, 54, 101, 42, 15 },
+        { 119, 57, 107, 163, 5 },
+        { 245, 74, 102, 197, 15 },
+        { 172, 93, 105, 206, 14 }, },
+      { { 6, 91, 255, 123, 13 },
+        { 244, 231, 207, 29, 13 },
+        { 189, 239, 253, 166, 0 },
+        { 187, 143, 62, 114, 15 }, },
+      { { 5, 65, 215, 45, 6 },
+        { 184, 247, 66, 84, 0 },
+        { 107, 78, 184, 42, 0 },
+        { 2, 164, 46, 241, 13 }, },
+      { { 12, 247, 36, 106, 2 },
+        { 195, 55, 26, 40, 5 },
+        { 69, 98, 78, 243, 0 },
+        { 161, 69, 142, 204, 3 }, },
+      { { 19, 56, 163, 158, 11 },
+        { 93, 248, 129, 65, 15 },
+        { 215, 156, 81, 204, 8 },
+        { 248, 40, 17, 251, 10 }, },
+      { { 21, 168, 147, 231, 4 },
+        { 153, 200, 82, 92, 11 },
+        { 46, 124, 145, 90, 8 },
+        { 211, 164, 161, 57, 9 }, },
+      { { 58, 65, 126, 233, 14 },
+        { 34, 127, 103, 29, 6 },
+        { 121, 119, 232, 37, 12 },
+        { 107, 142, 111, 228, 4 }, },
+      { { 79, 17, 226, 108, 0 },
+        { 234, 226, 2, 201, 4 },
+        { 3, 100, 120, 143, 2 },
+        { 41, 52, 4, 117, 7 }, },
+      { { 83, 13, 182, 210, 0 },
+        { 0, 203, 128, 249, 15 },
+        { 4, 182, 219, 12, 10 },
+        { 249, 240, 29, 48, 0 }, },
+      { { 88, 155, 250, 227, 4 },
+        { 98, 202, 94, 156, 15 },
+        { 44, 117, 253, 145, 10 },
+        { 243, 151, 165, 52, 6 }, },
+      { { 100, 9, 232, 160, 11 },
+        { 164, 146, 39, 128, 14 },
+        { 208, 81, 121, 2, 6 },
+        { 112, 30, 68, 146, 5 }, },
+      { { 96, 83, 122, 137, 1 },
+        { 100, 102, 44, 148, 6 },
+        { 137, 21, 236, 160, 6 },
+        { 98, 147, 70, 98, 6 }, },
+      { { 97, 89, 6, 155, 10 },
+        { 64, 119, 161, 196, 11 },
+        { 93, 150, 9, 168, 6 },
+        { 210, 56, 94, 224, 2 }, },
+      { { 107, 255, 120, 215, 11 },
+        { 111, 22, 189, 253, 15 },
+        { 222, 177, 239, 253, 6 },
+        { 251, 251, 214, 143, 6 }, },
+      { { 112, 173, 150, 164, 15 },
+        { 13, 219, 115, 176, 10 },
+        { 242, 86, 155, 80, 14 },
+        { 80, 220, 237, 187, 0 }, },
+      { { 117, 132, 111, 113, 10 },
+        { 176, 89, 183, 236, 4 },
+        { 88, 239, 98, 26, 14 },
+        { 35, 126, 217, 160, 13 }, },
+      { { 122, 149, 25, 47, 12 },
+        { 90, 42, 119, 181, 1 },
+        { 63, 73, 138, 149, 14 },
+        { 138, 222, 229, 69, 10 }, },
+      { { 134, 9, 118, 10, 10 },
+        { 160, 115, 1, 19, 13 },
+        { 85, 6, 233, 6, 1 },
+        { 188, 136, 12, 224, 5 }, },
+      { { 138, 45, 68, 195, 15 },
+        { 39, 19, 65, 47, 11 },
+        { 252, 50, 43, 69, 1 },
+        { 223, 72, 44, 142, 4 }, },
+      { { 147, 235, 120, 177, 4 },
+        { 33, 14, 222, 87, 14 },
+        { 40, 209, 237, 124, 9 },
+        { 126, 167, 183, 8, 4 }, },
+      { { 152, 141, 168, 77, 4 },
+        { 10, 170, 84, 46, 12 },
+        { 43, 33, 91, 17, 9 },
+        { 55, 66, 165, 85, 0 }, },
+      { { 158, 222, 43, 60, 8 },
+        { 218, 108, 159, 35, 12 },
+        { 19, 205, 71, 183, 9 },
+        { 60, 79, 147, 101, 11 }, },
+      { { 165, 41, 224, 123, 8 },
+        { 161, 162, 163, 78, 13 },
+        { 29, 224, 121, 74, 5 },
+        { 183, 44, 84, 88, 5 }, },
+      { { 181, 147, 184, 85, 15 },
+        { 204, 154, 253, 94, 4 },
+        { 250, 161, 220, 154, 13 },
+        { 39, 171, 245, 147, 3 }, },
+      { { 183, 248, 228, 38, 15 },
+        { 237, 157, 115, 67, 13 },
+        { 246, 66, 113, 254, 13 },
+        { 188, 44, 235, 155, 7 }, },
+      { { 188, 32, 82, 37, 14 },
+        { 171, 88, 99, 22, 0 },
+        { 122, 68, 160, 67, 13 },
+        { 6, 140, 97, 173, 5 }, },
+      { { 192, 68, 135, 118, 5 },
+        { 28, 197, 194, 170, 1 },
+        { 166, 238, 18, 32, 3 },
+        { 133, 84, 58, 51, 8 }, },
+      { { 196, 195, 36, 37, 9 },
+        { 140, 7, 27, 134, 4 },
+        { 154, 66, 76, 50, 3 },
+        { 38, 29, 142, 3, 1 }, },
+      { { 197, 169, 27, 216, 13 },
+        { 149, 98, 213, 218, 10 },
+        { 177, 189, 137, 90, 3 },
+        { 85, 186, 180, 106, 9 }, },
+      { { 206, 115, 230, 178, 12 },
+        { 227, 199, 203, 131, 7 },
+        { 52, 214, 124, 231, 3 },
+        { 236, 29, 62, 60, 7 }, },
+      { { 205, 12, 166, 39, 2 },
+        { 138, 209, 2, 230, 13 },
+        { 78, 70, 83, 11, 3 },
+        { 182, 116, 8, 181, 1 }, },
+      { { 201, 67, 93, 68, 13 },
+        { 62, 7, 77, 218, 0 },
+        { 178, 43, 172, 41, 3 },
+        { 5, 187, 46, 7, 12 }, },
+      { { 207, 190, 128, 243, 4 },
+        { 195, 128, 218, 239, 11 },
+        { 44, 240, 23, 223, 3 },
+        { 223, 117, 176, 28, 3 }, },
+      { { 229, 125, 21, 135, 7 },
+        { 221, 23, 96, 246, 11 },
+        { 238, 26, 139, 234, 7 },
+        { 214, 240, 110, 139, 11 }, },
+      { { 239, 198, 133, 142, 9 },
+        { 158, 165, 57, 227, 3 },
+        { 151, 26, 22, 63, 7 },
+        { 204, 121, 202, 87, 9 }, },
+      { { 247, 126, 243, 119, 2 },
+        { 249, 220, 170, 255, 13 },
+        { 78, 236, 247, 238, 15 },
+        { 191, 245, 83, 185, 15 }, },
+      { { 44, 228, 63, 37, 4 },
+        { 155, 69, 118, 52, 4 },
+        { 42, 79, 194, 115, 4 },
+        { 34, 198, 234, 45, 9 }, },
+      { { 43, 220, 255, 75, 3 },
+        { 118, 245, 52, 125, 13 },
+        { 205, 47, 243, 189, 4 },
+        { 187, 226, 202, 246, 14 }, },
+      { { 55, 199, 221, 189, 10 },
+        { 184, 191, 191, 117, 2 },
+        { 91, 219, 190, 62, 12 },
+        { 74, 239, 223, 209, 13 }, },
+      { { 161, 162, 84, 224, 15 },
+        { 37, 17, 123, 90, 2 },
+        { 240, 114, 164, 88, 5 },
+        { 69, 173, 232, 138, 4 }, },
+      { { 169, 130, 193, 187, 5 },
+        { 54, 160, 250, 70, 3 },
+        { 173, 216, 52, 25, 5 },
+        { 198, 37, 240, 86, 12 }, },
+      { { 216, 27, 73, 176, 8 },
+        { 114, 10, 143, 130, 10 },
+        { 16, 217, 45, 129, 11 },
+        { 84, 31, 21, 4, 14 }, },
+      { { 3, 88, 41, 248, 6 },
+        { 80, 52, 198, 73, 14 },
+        { 97, 249, 65, 172, 0 },
+        { 121, 38, 50, 192, 10 }, },
+      { { 7, 196, 9, 95, 12 },
+        { 152, 36, 213, 109, 1 },
+        { 63, 169, 2, 62, 0 },
+        { 139, 106, 178, 65, 9 }, },
+      { { 15, 226, 102, 23, 11 },
+        { 175, 85, 153, 69, 5 },
+        { 222, 134, 100, 127, 0 },
+        { 170, 41, 154, 175, 5 }, },
+      { { 20, 72, 54, 68, 1 },
+        { 140, 77, 0, 24, 12 },
+        { 130, 38, 193, 34, 8 },
+        { 49, 128, 11, 35, 1 }, },
+      { { 16, 173, 95, 251, 7 },
+        { 53, 123, 214, 60, 11 },
+        { 237, 255, 171, 80, 8 },
+        { 211, 198, 189, 234, 12 }, },
+      { { 18, 130, 149, 83, 15 },
+        { 20, 153, 217, 29, 1 },
+        { 252, 170, 148, 20, 8 },
+        { 139, 137, 185, 146, 8 }, },
+      { { 22, 225, 49, 132, 12 },
+        { 153, 14, 81, 17, 6 },
+        { 50, 24, 200, 118, 8 },
+        { 104, 136, 167, 9, 9 }, },
+      { { 24, 122, 73, 107, 0 },
+        { 115, 44, 14, 12, 9 },
+        { 13, 105, 37, 225, 8 },
+        { 147, 7, 3, 76, 14 }, },
+      { { 26, 232, 134, 17, 2 },
+        { 3, 221, 144, 5, 8 },
+        { 72, 134, 17, 117, 8 },
+        { 26, 0, 155, 188, 0 }, },
+      { { 25, 19, 174, 10, 1 },
+        { 70, 235, 12, 64, 5 },
+        { 133, 7, 92, 137, 8 },
+        { 160, 35, 13, 118, 2 }, },
+      { { 27, 103, 181, 161, 7 },
+        { 23, 159, 74, 117, 6 },
+        { 232, 90, 222, 109, 8 },
+        { 106, 229, 47, 158, 8 }, },
+      { { 37, 220, 149, 240, 11 },
+        { 212, 149, 179, 120, 10 },
+        { 208, 250, 147, 186, 4 },
+        { 81, 236, 218, 146, 11 }, },
+      { { 40, 137, 97, 247, 6 },
+        { 58, 18, 242, 12, 15 },
+        { 110, 248, 105, 17, 4 },
+        { 243, 4, 244, 133, 12 }, },
+      { { 51, 84, 20, 106, 10 },
+        { 64, 61, 35, 121, 1 },
+        { 85, 98, 130, 172, 12 },
+        { 137, 236, 75, 192, 2 }, },
+      { { 49, 193, 108, 31, 7 },
+        { 44, 63, 244, 68, 5 },
+        { 239, 131, 104, 56, 12 },
+        { 162, 34, 255, 195, 4 }, },
+      { { 51, 203, 24, 198, 6 },
+        { 8, 30, 124, 89, 11 },
+        { 102, 49, 141, 60, 12 },
+        { 217, 163, 231, 129, 0 }, },
+      { { 62, 207, 228, 144, 15 },
+        { 166, 159, 249, 33, 14 },
+        { 240, 146, 127, 55, 12 },
+        { 120, 73, 255, 150, 5 }, },
+      { { 70, 69, 24, 163, 15 },
+        { 132, 22, 71, 181, 3 },
+        { 252, 81, 138, 38, 2 },
+        { 202, 222, 38, 130, 1 }, },
+      { { 68, 186, 112, 182, 7 },
+        { 237, 16, 218, 144, 15 },
+        { 230, 208, 229, 210, 2 },
+        { 240, 149, 176, 139, 7 }, },
+      { { 65, 156, 98, 62, 8 },
+        { 104, 96, 147, 224, 13 },
+        { 23, 196, 99, 152, 2 },
+        { 176, 124, 144, 97, 6 }, },
+      { { 72, 209, 145, 74, 1 },
+        { 86, 166, 16, 152, 1 },
+        { 133, 40, 152, 177, 2 },
+        { 129, 144, 134, 86, 10 }, },
+      { { 84, 244, 153, 246, 13 },
+        { 221, 140, 215, 184, 3 },
+        { 182, 249, 146, 242, 10 },
+        { 193, 222, 179, 27, 11 }, },
+      { { 87, 90, 156, 129, 3 },
+        { 196, 157, 12, 213, 10 },
+        { 200, 19, 149, 174, 10 },
+        { 90, 179, 11, 146, 3 }, },
+      { { 85, 131, 85, 178, 12 },
+        { 176, 11, 219, 208, 3 },
+        { 52, 218, 172, 26, 10 },
+        { 192, 189, 189, 0, 13 }, },
+      { { 87, 183, 118, 16, 15 },
+        { 229, 91, 217, 241, 4 },
+        { 240, 134, 238, 222, 10 },
+        { 40, 249, 189, 170, 7 }, },
+      { { 92, 52, 54, 254, 4 },
+        { 203, 105, 194, 184, 7 },
+        { 39, 246, 194, 195, 10 },
+        { 225, 212, 57, 109, 3 }, },
+      { { 92, 72, 252, 119, 14 },
+        { 170, 157, 199, 156, 13 },
+        { 126, 227, 241, 35, 10 },
+        { 179, 158, 59, 149, 5 }, },
+      { { 94, 110, 239, 64, 2 },
+        { 179, 221, 12, 169, 12 },
+        { 64, 47, 119, 103, 10 },
+        { 57, 83, 11, 188, 13 }, },
+      { { 95, 35, 59, 111, 15 },
+        { 159, 122, 79, 221, 5 },
+        { 255, 109, 204, 79, 10 },
+        { 171, 191, 37, 239, 9 }, },
+      { { 91, 116, 42, 99, 2 },
+        { 67, 92, 6, 237, 5 },
+        { 76, 101, 66, 237, 10 },
+        { 171, 118, 3, 172, 2 }, },
+      { { 101, 15, 163, 58, 14 },
+        { 144, 242, 235, 224, 13 },
+        { 117, 204, 95, 10, 6 },
+        { 176, 125, 116, 240, 9 }, },
+      { { 101, 211, 23, 92, 12 },
+        { 216, 103, 249, 216, 0 },
+        { 51, 174, 140, 186, 6 },
+        { 1, 185, 254, 97, 11 }, },
+      { { 106, 156, 36, 90, 14 },
+        { 66, 49, 241, 169, 13 },
+        { 117, 162, 67, 149, 6 },
+        { 185, 88, 248, 196, 2 }, },
+      { { 105, 197, 243, 4, 2 },
+        { 58, 214, 48, 240, 4 },
+        { 66, 12, 250, 57, 6 },
+        { 32, 240, 198, 181, 12 }, },
+      { { 105, 210, 72, 78, 10 },
+        { 106, 52, 61, 200, 1 },
+        { 87, 33, 36, 185, 6 },
+        { 129, 59, 194, 197, 6 }, },
+      { { 116, 121, 226, 222, 6 },
+        { 233, 254, 224, 136, 15 },
+        { 103, 180, 121, 226, 14 },
+        { 241, 16, 119, 249, 7 }, },
+      { { 114, 207, 35, 234, 11 },
+        { 20, 126, 59, 169, 15 },
+        { 213, 124, 79, 52, 14 },
+        { 249, 93, 199, 226, 8 }, },
+      { { 119, 177, 220, 65, 4 },
+        { 225, 139, 116, 221, 0 },
+        { 40, 35, 184, 222, 14 },
+        { 11, 178, 237, 24, 7 }, },
+      { { 126, 12, 7, 33, 7 },
+        { 150, 89, 98, 165, 8 },
+        { 232, 78, 3, 7, 14 },
+        { 26, 84, 105, 166, 9 }, },
+      { { 122, 105, 112, 100, 7 },
+        { 47, 30, 98, 153, 12 },
+        { 226, 96, 233, 101, 14 },
+        { 57, 148, 103, 143, 4 }, },
+      { { 120, 178, 216, 112, 7 },
+        { 103, 152, 254, 152, 0 },
+        { 224, 225, 180, 209, 14 },
+        { 1, 151, 241, 158, 6 }, },
+      { { 121, 197, 133, 121, 4 },
+        { 18, 175, 242, 236, 0 },
+        { 41, 234, 26, 57, 14 },
+        { 3, 116, 255, 84, 8 }, },
+      { { 134, 111, 89, 252, 6 },
+        { 185, 54, 206, 59, 10 },
+        { 99, 249, 175, 102, 1 },
+        { 93, 199, 54, 201, 13 }, },
+      { { 130, 246, 114, 127, 5 },
+        { 109, 100, 218, 63, 5 },
+        { 175, 228, 230, 244, 1 },
+        { 175, 197, 178, 107, 6 }, },
+      { { 133, 78, 47, 65, 4 },
+        { 144, 69, 76, 110, 12 },
+        { 40, 47, 71, 42, 1 },
+        { 55, 99, 42, 32, 9 }, },
+      { { 154, 17, 133, 147, 4 },
+        { 82, 139, 192, 7, 3 },
+        { 44, 154, 24, 133, 9 },
+        { 206, 0, 61, 20, 10 }, },
+      { { 156, 113, 96, 201, 7 },
+        { 231, 62, 64, 14, 6 },
+        { 233, 48, 104, 227, 9 },
+        { 103, 0, 39, 206, 7 }, },
+      { { 157, 209, 148, 253, 8 },
+        { 202, 175, 147, 94, 2 },
+        { 27, 242, 152, 187, 9 },
+        { 71, 172, 159, 85, 3 }, },
+      { { 162, 30, 18, 227, 8 },
+        { 64, 64, 43, 63, 11 },
+        { 28, 116, 135, 132, 5 },
+        { 223, 205, 64, 32, 2 }, },
+      { { 174, 112, 28, 130, 12 },
+        { 195, 5, 101, 19, 3 },
+        { 52, 19, 128, 231, 5 },
+        { 204, 138, 106, 12, 3 }, },
+      { { 173, 1, 33, 156, 1 },
+        { 158, 34, 160, 66, 6 },
+        { 131, 152, 72, 11, 5 },
+        { 100, 32, 84, 71, 9 }, },
+      { { 176, 53, 31, 158, 14 },
+        { 89, 123, 229, 50, 3 },
+        { 119, 159, 138, 192, 13 },
+        { 196, 202, 125, 233, 10 }, },
+      { { 182, 74, 216, 13, 4 },
+        { 168, 172, 108, 23, 8 },
+        { 43, 1, 181, 38, 13 },
+        { 30, 131, 99, 81, 5 }, },
+      { { 181, 55, 49, 75, 4 },
+        { 209, 42, 104, 126, 5 },
+        { 45, 40, 206, 202, 13 },
+        { 167, 225, 101, 72, 11 }, },
+      { { 190, 170, 199, 227, 11 },
+        { 183, 217, 59, 15, 11 },
+        { 220, 126, 53, 87, 13 },
+        { 223, 13, 201, 190, 13 }, },
+      { { 187, 104, 61, 188, 15 },
+        { 31, 61, 231, 83, 14 },
+        { 243, 219, 193, 109, 13 },
+        { 124, 174, 123, 207, 8 }, },
+      { { 198, 114, 247, 44, 1 },
+        { 253, 229, 10, 147, 4 },
+        { 131, 78, 244, 230, 3 },
+        { 44, 149, 10, 123, 15 }, },
+      { { 193, 231, 77, 186, 11 },
+        { 53, 55, 159, 226, 3 },
+        { 213, 219, 46, 120, 3 },
+        { 196, 127, 158, 202, 12 }, },
+      { { 203, 85, 238, 89, 13 },
+        { 102, 231, 197, 239, 4 },
+        { 185, 167, 122, 173, 3 },
+        { 47, 122, 62, 118, 6 }, },
+      { { 203, 160, 83, 114, 4 },
+        { 51, 64, 210, 219, 1 },
+        { 36, 236, 160, 93, 3 },
+        { 141, 180, 176, 44, 12 }, },
+      { { 208, 9, 15, 207, 1 },
+        { 28, 107, 4, 142, 11 },
+        { 143, 63, 9, 0, 11 },
+        { 215, 18, 13, 99, 8 }, },
+      { { 208, 108, 58, 213, 4 },
+        { 9, 76, 196, 190, 14 },
+        { 42, 181, 195, 96, 11 },
+        { 119, 210, 51, 41, 0 }, },
+      { { 211, 241, 32, 87, 4 },
+        { 73, 14, 208, 207, 5 },
+        { 46, 160, 72, 252, 11 },
+        { 175, 48, 183, 9, 2 }, },
+      { { 230, 227, 59, 26, 7 },
+        { 149, 118, 252, 147, 5 },
+        { 229, 141, 204, 118, 7 },
+        { 172, 147, 246, 234, 9 }, },
+      { { 227, 83, 62, 164, 10 },
+        { 72, 87, 47, 211, 6 },
+        { 82, 87, 204, 172, 7 },
+        { 108, 191, 78, 161, 2 }, },
+      { { 232, 6, 142, 177, 4 },
+        { 2, 193, 238, 166, 2 },
+        { 40, 215, 22, 1, 7 },
+        { 70, 87, 120, 52, 0 }, },
+      { { 236, 7, 192, 89, 7 },
+        { 166, 178, 232, 174, 0 },
+        { 233, 160, 62, 3, 7 },
+        { 7, 81, 116, 214, 5 }, },
+      { { 234, 243, 128, 61, 10 },
+        { 75, 182, 187, 135, 0 },
+        { 91, 192, 28, 245, 7 },
+        { 14, 29, 214, 221, 2 }, },
+      { { 246, 59, 39, 216, 8 },
+        { 209, 107, 169, 139, 14 },
+        { 17, 190, 77, 198, 15 },
+        { 125, 25, 93, 104, 11 }, },
+      { { 243, 7, 152, 55, 9 },
+        { 12, 138, 175, 247, 1 },
+        { 158, 193, 158, 12, 15 },
+        { 142, 255, 85, 19, 0 }, },
+      { { 254, 75, 186, 155, 9 },
+        { 134, 238, 173, 151, 15 },
+        { 157, 149, 221, 39, 15 },
+        { 254, 155, 87, 118, 1 }, },
+      { { 171, 165, 125, 134, 11 },
+        { 63, 19, 53, 115, 7 },
+        { 214, 27, 234, 93, 5 },
+        { 236, 234, 204, 143, 12 }, },
+      { { 192, 209, 98, 90, 11 },
+        { 100, 118, 145, 138, 5 },
+        { 213, 164, 104, 176, 3 },
+        { 165, 24, 150, 226, 6 }, },
+      { { 19, 206, 123, 174, 7 },
+        { 60, 124, 94, 113, 15 },
+        { 231, 93, 231, 60, 8 },
+        { 248, 231, 163, 227, 12 }, },
+      { { 78, 129, 253, 97, 7 },
+        { 182, 147, 86, 157, 4 },
+        { 232, 107, 248, 23, 2 },
+        { 43, 150, 172, 150, 13 }, },
+      { { 86, 224, 118, 50, 0 },
+        { 161, 77, 146, 145, 5 },
+        { 4, 198, 224, 118, 10 },
+        { 168, 148, 155, 40, 5 }, },
+      { { 106, 112, 138, 84, 0 },
+        { 75, 196, 164, 137, 0 },
+        { 2, 165, 16, 229, 6 },
+        { 9, 18, 82, 61, 2 }, },
+      { { 114, 168, 152, 161, 8 },
+        { 1, 136, 55, 149, 10 },
+        { 24, 81, 145, 84, 14 },
+        { 90, 158, 193, 24, 0 }, },
+      { { 129, 93, 66, 248, 0 },
+        { 96, 102, 130, 106, 10 },
+        { 1, 244, 43, 168, 1 },
+        { 85, 100, 22, 96, 6 }, },
+      { { 207, 76, 195, 213, 15 },
+        { 190, 212, 193, 239, 10 },
+        { 250, 188, 51, 47, 3 },
+        { 95, 120, 50, 183, 13 }, },
+      { { 214, 187, 101, 134, 4 },
+        { 249, 11, 88, 131, 15 },
+        { 38, 26, 109, 214, 11 },
+        { 252, 17, 173, 9, 15 }, },
+      { { 236, 211, 19, 163, 1 },
+        { 214, 70, 58, 150, 3 },
+        { 140, 92, 140, 179, 7 },
+        { 198, 149, 198, 38, 11 }, },
+      { { 245, 33, 245, 32, 7 },
+        { 181, 155, 98, 210, 4 },
+        { 224, 74, 248, 74, 15 },
+        { 36, 180, 109, 154, 13 }, },
+      { { 249, 31, 165, 223, 7 },
+        { 94, 187, 232, 238, 15 },
+        { 239, 186, 95, 137, 15 },
+        { 247, 113, 125, 215, 10 }, },
+      { { 0, 36, 244, 122, 7 },
+        { 37, 177, 194, 56, 5 },
+        { 229, 226, 242, 64, 0 },
+        { 161, 196, 56, 218, 4 }, },
+      { { 0, 8, 77, 136, 2 },
+        { 48, 49, 4, 0, 10 },
+        { 65, 27, 33, 0, 0 },
+        { 80, 2, 8, 192, 12 }, },
+      { { 4, 60, 194, 242, 9 },
+        { 229, 192, 131, 40, 11 },
+        { 148, 244, 51, 194, 0 },
+        { 209, 76, 16, 58, 7 }, },
+      { { 4, 123, 80, 33, 1 },
+        { 229, 6, 10, 20, 8 },
+        { 136, 64, 173, 226, 0 },
+        { 18, 133, 6, 10, 7 }, },
+      { { 6, 122, 228, 193, 13 },
+        { 229, 133, 73, 13, 14 },
+        { 184, 50, 117, 230, 0 },
+        { 123, 9, 42, 26, 7 }, },
+      { { 0, 170, 150, 138, 3 },
+        { 5, 241, 24, 16, 11 },
+        { 197, 22, 149, 80, 0 },
+        { 208, 129, 136, 250, 0 }, },
+      { { 4, 209, 56, 233, 4 },
+        { 192, 38, 86, 28, 6 },
+        { 41, 113, 200, 178, 0 },
+        { 99, 134, 166, 64, 3 }, },
+      { { 5, 16, 168, 13, 10 },
+        { 200, 176, 5, 68, 4 },
+        { 91, 1, 80, 138, 0 },
+        { 34, 42, 0, 209, 3 }, },
+      { { 1, 64, 176, 0, 7 },
+        { 4, 148, 64, 80, 4 },
+        { 224, 0, 208, 40, 0 },
+        { 32, 160, 34, 146, 0 }, },
+      { { 1, 157, 156, 238, 1 },
+        { 76, 163, 22, 120, 11 },
+        { 135, 115, 155, 152, 0 },
+        { 209, 230, 140, 83, 2 }, },
+      { { 8, 16, 87, 227, 11 },
+        { 118, 81, 3, 28, 3 },
+        { 220, 126, 160, 129, 0 },
+        { 195, 140, 8, 166, 14 }, },
+      { { 8, 107, 151, 182, 6 },
+        { 27, 215, 202, 16, 11 },
+        { 102, 222, 157, 97, 0 },
+        { 208, 133, 62, 189, 8 }, },
+      { { 14, 232, 184, 96, 10 },
+        { 131, 148, 23, 25, 12 },
+        { 80, 97, 209, 119, 0 },
+        { 57, 142, 130, 156, 1 }, },
+      { { 11, 108, 118, 185, 11 },
+        { 39, 117, 131, 117, 14 },
+        { 217, 214, 227, 109, 0 },
+        { 122, 236, 26, 238, 4 }, },
+      { { 15, 220, 185, 140, 11 },
+        { 222, 180, 21, 113, 14 },
+        { 211, 25, 211, 191, 0 },
+        { 120, 234, 130, 215, 11 }, },
+      { { 15, 202, 207, 58, 0 },
+        { 178, 229, 158, 65, 9 },
+        { 5, 207, 53, 63, 0 },
+        { 152, 39, 154, 116, 13 }, },
+      { { 20, 36, 159, 217, 8 },
+        { 145, 233, 133, 60, 2 },
+        { 25, 191, 146, 66, 8 },
+        { 67, 202, 25, 120, 9 }, },
+      { { 20, 7, 32, 31, 13 },
+        { 140, 42, 201, 36, 5 },
+        { 191, 128, 78, 2, 8 },
+        { 162, 73, 53, 67, 1 }, },
+      { { 21, 9, 16, 213, 7 },
+        { 140, 26, 192, 92, 10 },
+        { 234, 176, 137, 10, 8 },
+        { 83, 160, 53, 131, 1 }, },
+      { { 19, 92, 215, 48, 7 },
+        { 116, 221, 194, 113, 8 },
+        { 224, 206, 179, 172, 8 },
+        { 24, 228, 59, 178, 14 }, },
+      { { 17, 71, 154, 187, 6 },
+        { 0, 254, 206, 116, 3 },
+        { 109, 213, 158, 40, 8 },
+        { 194, 231, 55, 240, 0 }, },
+      { { 28, 185, 169, 35, 8 },
+        { 211, 138, 23, 4, 13 },
+        { 28, 73, 89, 211, 8 },
+        { 178, 14, 133, 28, 11 }, },
+      { { 28, 221, 7, 118, 6 },
+        { 218, 95, 210, 40, 9 },
+        { 102, 238, 11, 179, 8 },
+        { 145, 68, 191, 165, 11 }, },
+      { { 31, 46, 124, 36, 11 },
+        { 175, 25, 15, 113, 12 },
+        { 210, 67, 231, 79, 8 },
+        { 56, 239, 9, 143, 5 }, },
+      { { 25, 102, 66, 71, 7 },
+        { 47, 92, 72, 108, 1 },
+        { 238, 36, 38, 105, 8 },
+        { 131, 97, 35, 175, 4 }, },
+      { { 25, 87, 212, 200, 4 },
+        { 98, 175, 72, 120, 2 },
+        { 33, 50, 190, 169, 8 },
+        { 65, 225, 47, 84, 6 }, },
+      { { 31, 168, 244, 240, 4 },
+        { 163, 137, 210, 89, 14 },
+        { 32, 242, 241, 95, 8 },
+        { 121, 164, 185, 28, 5 }, },
+      { { 27, 130, 70, 237, 8 },
+        { 42, 105, 27, 77, 2 },
+        { 27, 118, 36, 29, 8 },
+        { 75, 45, 137, 101, 4 }, },
+      { { 27, 174, 225, 15, 14 },
+        { 59, 184, 89, 101, 13 },
+        { 127, 8, 119, 93, 8 },
+        { 186, 105, 161, 221, 12 }, },
+      { { 34, 164, 182, 60, 10 },
+        { 9, 241, 179, 49, 4 },
+        { 83, 198, 210, 84, 4 },
+        { 40, 204, 216, 249, 0 }, },
+      { { 34, 191, 144, 18, 15 },
+        { 69, 146, 249, 49, 9 },
+        { 244, 128, 159, 212, 4 },
+        { 152, 201, 244, 154, 2 }, },
+      { { 35, 44, 21, 180, 0 },
+        { 25, 1, 162, 113, 10 },
+        { 2, 218, 131, 76, 4 },
+        { 88, 228, 88, 9, 8 }, },
+      { { 37, 90, 169, 102, 12 },
+        { 216, 132, 111, 72, 13 },
+        { 54, 105, 85, 170, 4 },
+        { 177, 47, 98, 17, 11 }, },
+      { { 39, 165, 175, 169, 7 },
+        { 149, 243, 118, 101, 6 },
+        { 233, 95, 90, 94, 4 },
+        { 106, 102, 236, 250, 9 }, },
+      { { 37, 244, 14, 66, 5 },
+        { 197, 69, 116, 104, 1 },
+        { 164, 39, 2, 250, 4 },
+        { 129, 98, 234, 42, 3 }, },
+      { { 40, 102, 85, 205, 14 },
+        { 59, 53, 105, 60, 2 },
+        { 123, 58, 166, 97, 4 },
+        { 67, 201, 106, 205, 12 }, },
+      { { 44, 66, 126, 14, 0 },
+        { 170, 101, 44, 16, 5 },
+        { 7, 7, 228, 35, 4 },
+        { 160, 131, 74, 101, 5 }, },
+      { { 42, 185, 124, 189, 0 },
+        { 107, 35, 182, 21, 14 },
+        { 11, 211, 233, 213, 4 },
+        { 122, 134, 220, 77, 6 }, },
+      { { 41, 70, 225, 210, 3 },
+        { 54, 148, 168, 104, 7 },
+        { 196, 184, 118, 41, 4 },
+        { 225, 97, 82, 150, 12 }, },
+      { { 45, 166, 40, 65, 0 },
+        { 131, 0, 60, 108, 4 },
+        { 8, 33, 70, 91, 4 },
+        { 35, 99, 192, 12, 1 }, },
+      { { 43, 251, 32, 154, 6 },
+        { 67, 54, 248, 65, 15 },
+        { 101, 144, 77, 253, 4 },
+        { 248, 33, 246, 204, 2 }, },
+      { { 54, 140, 214, 107, 12 },
+        { 160, 233, 115, 61, 9 },
+        { 61, 102, 179, 22, 12 },
+        { 155, 204, 233, 112, 5 }, },
+      { { 52, 135, 119, 124, 7 },
+        { 188, 123, 250, 56, 4 },
+        { 227, 238, 238, 18, 12 },
+        { 33, 197, 253, 227, 13 }, },
+      { { 52, 221, 235, 132, 0 },
+        { 248, 206, 52, 32, 14 },
+        { 2, 29, 123, 178, 12 },
+        { 112, 66, 199, 49, 15 }, },
+      { { 55, 145, 247, 111, 1 },
+        { 252, 235, 50, 93, 5 },
+        { 143, 110, 248, 158, 12 },
+        { 171, 164, 205, 115, 15 }, },
+      { { 58, 34, 142, 23, 5 },
+        { 15, 201, 236, 5, 1 },
+        { 174, 135, 20, 69, 12 },
+        { 138, 3, 121, 63, 0 }, },
+      { { 62, 19, 189, 64, 8 },
+        { 210, 139, 45, 25, 4 },
+        { 16, 43, 220, 135, 12 },
+        { 41, 139, 77, 20, 11 }, },
+      { { 60, 152, 67, 202, 2 },
+        { 242, 120, 48, 8, 11 },
+        { 69, 60, 33, 147, 12 },
+        { 209, 0, 193, 228, 15 }, },
+      { { 57, 88, 157, 23, 9 },
+        { 94, 141, 165, 84, 9 },
+        { 158, 139, 145, 169, 12 },
+        { 146, 170, 91, 23, 10 }, },
+      { { 57, 116, 218, 238, 11 },
+        { 111, 252, 39, 120, 3 },
+        { 215, 117, 178, 233, 12 },
+        { 193, 238, 67, 255, 6 }, },
+      { { 63, 109, 188, 115, 1 },
+        { 135, 143, 166, 125, 13 },
+        { 140, 227, 219, 111, 12 },
+        { 187, 230, 95, 30, 1 }, },
+      { { 61, 107, 192, 80, 12 },
+        { 163, 142, 233, 72, 8 },
+        { 48, 160, 61, 107, 12 },
+        { 17, 41, 119, 28, 5 }, },
+      { { 57, 171, 39, 73, 7 },
+        { 23, 123, 120, 76, 12 },
+        { 233, 46, 77, 89, 12 },
+        { 51, 33, 237, 238, 8 }, },
+      { { 70, 2, 78, 37, 14 },
+        { 168, 81, 79, 133, 0 },
+        { 122, 71, 36, 6, 2 },
+        { 10, 31, 40, 161, 5 }, },
+      { { 70, 130, 186, 11, 12 },
+        { 128, 224, 93, 149, 5 },
+        { 61, 5, 212, 22, 2 },
+        { 170, 155, 160, 112, 1 }, },
+      { { 66, 233, 205, 90, 14 },
+        { 49, 183, 213, 137, 9 },
+        { 117, 171, 57, 116, 2 },
+        { 153, 26, 190, 216, 12 }, },
+      { { 68, 201, 183, 179, 15 },
+        { 148, 215, 211, 148, 15 },
+        { 252, 222, 217, 50, 2 },
+        { 242, 156, 190, 178, 9 }, },
+      { { 64, 199, 212, 30, 9 },
+        { 44, 167, 153, 176, 1 },
+        { 151, 130, 190, 48, 2 },
+        { 128, 217, 158, 83, 4 }, },
+      { { 70, 210, 180, 204, 14 },
+        { 200, 181, 89, 153, 6 },
+        { 115, 50, 212, 182, 2 },
+        { 105, 153, 170, 209, 3 }, },
+      { { 67, 25, 83, 86, 11 },
+        { 124, 82, 129, 217, 9 },
+        { 214, 172, 169, 140, 2 },
+        { 153, 184, 20, 163, 14 }, },
+      { { 65, 34, 230, 221, 9 },
+        { 45, 225, 137, 204, 6 },
+        { 155, 182, 116, 72, 2 },
+        { 99, 57, 24, 123, 4 }, },
+      { { 71, 83, 165, 154, 11 },
+        { 212, 183, 137, 193, 7 },
+        { 213, 154, 92, 174, 2 },
+        { 232, 57, 30, 210, 11 }, },
+      { { 78, 30, 241, 224, 8 },
+        { 242, 128, 11, 185, 14 },
+        { 16, 120, 247, 135, 2 },
+        { 121, 221, 0, 20, 15 }, },
+      { { 78, 74, 192, 150, 0 },
+        { 170, 132, 136, 129, 11 },
+        { 6, 144, 53, 39, 2 },
+        { 216, 17, 18, 21, 5 }, },
+      { { 78, 95, 170, 6, 15 },
+        { 206, 214, 77, 161, 13 },
+        { 246, 5, 95, 167, 2 },
+        { 184, 91, 38, 183, 3 }, },
+      { { 74, 141, 50, 148, 3 },
+        { 14, 82, 144, 177, 14 },
+        { 194, 148, 203, 21, 2 },
+        { 120, 208, 148, 167, 0 }, },
+      { { 73, 21, 148, 179, 9 },
+        { 70, 131, 131, 244, 3 },
+        { 156, 210, 154, 137, 2 },
+        { 194, 252, 28, 22, 2 }, },
+      { { 77, 77, 219, 98, 1 },
+        { 182, 198, 6, 248, 9 },
+        { 132, 109, 187, 43, 2 },
+        { 145, 246, 6, 54, 13 }, },
+      { { 75, 167, 97, 232, 1 },
+        { 55, 34, 26, 233, 6 },
+        { 129, 120, 110, 93, 2 },
+        { 105, 117, 132, 78, 12 }, },
+      { { 73, 212, 131, 216, 14 },
+        { 82, 244, 209, 232, 2 },
+        { 113, 188, 18, 185, 2 },
+        { 65, 120, 178, 244, 10 }, },
+      { { 86, 41, 14, 246, 12 },
+        { 137, 75, 199, 137, 11 },
+        { 54, 247, 9, 70, 10 },
+        { 217, 30, 61, 41, 1 }, },
+      { { 83, 126, 213, 255, 12 },
+        { 121, 173, 203, 253, 11 },
+        { 63, 250, 183, 236, 10 },
+        { 219, 253, 59, 89, 14 }, },
+      { { 85, 245, 167, 175, 10 },
+        { 217, 255, 19, 228, 7 },
+        { 95, 94, 90, 250, 10 },
+        { 226, 124, 143, 249, 11 }, },
+      { { 85, 213, 234, 100, 15 },
+        { 236, 222, 87, 232, 4 },
+        { 242, 101, 122, 186, 10 },
+        { 33, 126, 167, 179, 7 }, },
+      { { 88, 27, 171, 29, 10 },
+        { 90, 250, 141, 132, 12 },
+        { 91, 141, 93, 129, 10 },
+        { 50, 27, 21, 245, 10 }, },
+      { { 94, 190, 146, 109, 13 },
+        { 207, 232, 91, 189, 8 },
+        { 187, 100, 151, 215, 10 },
+        { 27, 221, 161, 127, 3 }, },
+      { { 95, 16, 249, 155, 5 },
+        { 246, 168, 196, 213, 7 },
+        { 173, 153, 240, 143, 10 },
+        { 234, 178, 49, 86, 15 }, },
+      { { 93, 30, 223, 165, 12 },
+        { 250, 201, 79, 244, 10 },
+        { 58, 95, 183, 139, 10 },
+        { 82, 255, 41, 53, 15 }, },
+      { { 95, 113, 141, 240, 2 },
+        { 211, 159, 134, 201, 2 },
+        { 64, 251, 24, 239, 10 },
+        { 73, 54, 31, 156, 11 }, },
+      { { 93, 225, 30, 70, 8 },
+        { 139, 79, 21, 216, 1 },
+        { 22, 39, 136, 123, 10 },
+        { 129, 186, 143, 45, 1 }, },
+      { { 96, 51, 187, 36, 7 },
+        { 93, 210, 110, 144, 4 },
+        { 226, 77, 220, 192, 6 },
+        { 32, 151, 100, 187, 10 }, },
+      { { 100, 88, 26, 254, 1 },
+        { 204, 100, 166, 152, 11 },
+        { 135, 245, 129, 162, 6 },
+        { 209, 150, 82, 99, 3 }, },
+      { { 99, 200, 221, 167, 6 },
+        { 56, 149, 118, 213, 11 },
+        { 110, 91, 177, 60, 6 },
+        { 218, 182, 234, 145, 12 }, },
+      { { 97, 218, 61, 143, 13 },
+        { 92, 37, 125, 212, 15 },
+        { 191, 27, 197, 184, 6 },
+        { 242, 187, 234, 67, 10 }, },
+      { { 110, 58, 34, 175, 10 },
+        { 203, 112, 43, 133, 15 },
+        { 95, 84, 69, 199, 6 },
+        { 250, 29, 64, 237, 3 }, },
+      { { 110, 97, 5, 183, 1 },
+        { 159, 7, 162, 133, 3 },
+        { 142, 218, 8, 103, 6 },
+        { 202, 20, 94, 15, 9 }, },
+      { { 106, 137, 169, 232, 12 },
+        { 18, 162, 119, 137, 14 },
+        { 49, 121, 89, 21, 6 },
+        { 121, 30, 228, 84, 8 }, },
+      { { 106, 151, 34, 79, 5 },
+        { 78, 98, 120, 173, 5 },
+        { 175, 36, 78, 149, 6 },
+        { 171, 81, 228, 103, 2 }, },
+      { { 107, 18, 195, 128, 1 },
+        { 118, 192, 40, 193, 2 },
+        { 128, 28, 52, 141, 6 },
+        { 72, 49, 64, 54, 14 }, },
+      { { 107, 104, 75, 34, 10 },
+        { 51, 84, 39, 193, 9 },
+        { 84, 77, 33, 109, 6 },
+        { 152, 62, 66, 172, 12 }, },
+      { { 111, 148, 193, 87, 9 },
+        { 254, 128, 177, 237, 1 },
+        { 158, 168, 50, 159, 6 },
+        { 139, 120, 208, 23, 15 }, },
+      { { 109, 166, 254, 160, 13 },
+        { 167, 193, 127, 240, 6 },
+        { 176, 87, 246, 91, 6 },
+        { 96, 255, 232, 62, 5 }, },
+      { { 111, 234, 202, 69, 7 },
+        { 175, 212, 124, 205, 8 },
+        { 234, 37, 53, 127, 6 },
+        { 27, 51, 226, 191, 5 }, },
+      { { 112, 61, 56, 166, 0 },
+        { 73, 10, 38, 176, 15 },
+        { 6, 81, 203, 192, 14 },
+        { 240, 214, 69, 9, 2 }, },
+      { { 118, 108, 53, 231, 8 },
+        { 153, 13, 35, 189, 15 },
+        { 30, 122, 195, 102, 14 },
+        { 251, 220, 75, 9, 9 }, },
+      { { 112, 74, 13, 255, 6 },
+        { 24, 61, 238, 140, 11 },
+        { 111, 251, 5, 32, 14 },
+        { 211, 23, 123, 193, 8 }, },
+      { { 117, 120, 169, 200, 0 },
+        { 209, 172, 36, 200, 14 },
+        { 1, 57, 81, 234, 14 },
+        { 113, 50, 67, 88, 11 }, },
+      { { 113, 74, 112, 19, 8 },
+        { 32, 12, 169, 212, 13 },
+        { 28, 128, 229, 40, 14 },
+        { 178, 185, 83, 0, 4 }, },
+      { { 117, 127, 140, 187, 9 },
+        { 197, 175, 175, 228, 11 },
+        { 157, 211, 31, 234, 14 },
+        { 210, 127, 95, 90, 3 }, },
+      { { 124, 35, 104, 51, 1 },
+        { 167, 10, 174, 132, 5 },
+        { 140, 193, 108, 67, 14 },
+        { 162, 23, 85, 14, 5 }, },
+      { { 124, 181, 167, 211, 1 },
+        { 215, 203, 176, 172, 7 },
+        { 140, 190, 90, 211, 14 },
+        { 227, 80, 221, 62, 11 }, },
+      { { 124, 248, 44, 237, 14 },
+        { 203, 61, 119, 140, 14 },
+        { 123, 115, 65, 243, 14 },
+        { 115, 30, 235, 205, 3 }, },
+      { { 127, 36, 226, 52, 15 },
+        { 175, 216, 227, 225, 4 },
+        { 242, 196, 114, 79, 14 },
+        { 40, 124, 113, 191, 5 }, },
+      { { 127, 71, 41, 141, 8 },
+        { 154, 46, 45, 229, 6 },
+        { 27, 25, 78, 47, 14 },
+        { 106, 123, 71, 69, 9 }, },
+      { { 134, 216, 3, 209, 9 },
+        { 212, 68, 145, 15, 10 },
+        { 152, 188, 1, 182, 1 },
+        { 95, 8, 146, 34, 11 }, },
+      { { 131, 139, 27, 161, 3 },
+        { 20, 82, 30, 87, 10 },
+        { 200, 93, 141, 28, 1 },
+        { 94, 167, 132, 162, 8 }, },
+      { { 135, 162, 121, 197, 9 },
+        { 189, 0, 29, 95, 6 },
+        { 154, 57, 228, 94, 1 },
+        { 111, 171, 128, 11, 13 }, },
+      { { 138, 67, 100, 140, 14 },
+        { 42, 55, 73, 3, 6 },
+        { 115, 18, 108, 37, 1 },
+        { 108, 9, 46, 197, 4 }, },
+      { { 136, 147, 59, 76, 8 },
+        { 90, 98, 29, 26, 4 },
+        { 19, 45, 204, 145, 1 },
+        { 37, 139, 132, 101, 10 }, },
+      { { 143, 33, 223, 78, 3 },
+        { 191, 243, 4, 91, 1 },
+        { 199, 47, 184, 79, 1 },
+        { 141, 162, 12, 255, 13 }, },
+      { { 141, 132, 53, 114, 9 },
+        { 150, 1, 147, 122, 5 },
+        { 148, 234, 194, 27, 1 },
+        { 165, 236, 152, 6, 9 }, },
+      { { 141, 136, 215, 31, 13 },
+        { 190, 225, 209, 86, 9 },
+        { 191, 142, 177, 27, 1 },
+        { 150, 168, 184, 119, 13 }, },
+      { { 137, 159, 120, 252, 13 },
+        { 110, 34, 223, 122, 14 },
+        { 179, 241, 239, 153, 1 },
+        { 117, 239, 180, 71, 6 }, },
+      { { 146, 107, 22, 121, 12 },
+        { 1, 111, 203, 31, 8 },
+        { 57, 230, 141, 100, 9 },
+        { 31, 141, 63, 104, 0 }, },
+      { { 148, 142, 34, 241, 2 },
+        { 128, 88, 154, 46, 14 },
+        { 72, 244, 71, 18, 9 },
+        { 119, 69, 145, 160, 1 }, },
+      { { 144, 229, 230, 49, 7 },
+        { 37, 223, 210, 38, 4 },
+        { 232, 198, 122, 112, 9 },
+        { 38, 68, 191, 186, 4 }, },
+      { { 150, 216, 133, 42, 1 },
+        { 212, 173, 18, 3, 9 },
+        { 133, 74, 17, 182, 9 },
+        { 156, 4, 139, 82, 11 }, },
+      { { 149, 57, 59, 164, 6 },
+        { 217, 90, 70, 82, 14 },
+        { 98, 93, 201, 202, 9 },
+        { 116, 166, 37, 169, 11 }, },
+      { { 149, 60, 251, 77, 13 },
+        { 253, 232, 69, 126, 12 },
+        { 187, 45, 243, 202, 9 },
+        { 55, 234, 33, 123, 15 }, },
+      { { 145, 62, 170, 18, 6 },
+        { 65, 216, 204, 98, 13 },
+        { 100, 133, 87, 200, 9 },
+        { 180, 99, 49, 184, 2 }, },
+      { { 151, 111, 90, 175, 9 },
+        { 173, 110, 15, 119, 11 },
+        { 159, 85, 175, 110, 9 },
+        { 222, 239, 7, 107, 5 }, },
+      { { 145, 178, 41, 253, 10 },
+        { 89, 56, 159, 78, 6 },
+        { 91, 249, 68, 216, 9 },
+        { 103, 47, 145, 201, 10 }, },
+      { { 145, 211, 250, 118, 1 },
+        { 108, 206, 158, 90, 5 },
+        { 134, 229, 252, 184, 9 },
+        { 165, 167, 151, 51, 6 }, },
+      { { 154, 112, 134, 200, 8 },
+        { 67, 237, 1, 11, 2 },
+        { 17, 54, 16, 229, 9 },
+        { 77, 8, 11, 124, 2 }, },
+      { { 152, 142, 205, 3, 1 },
+        { 54, 137, 28, 38, 9 },
+        { 140, 11, 55, 17, 9 },
+        { 150, 67, 137, 22, 12 }, },
+      { { 152, 199, 16, 151, 10 },
+        { 10, 30, 153, 54, 3 },
+        { 94, 144, 142, 49, 9 },
+        { 198, 201, 151, 133, 0 }, },
+      { { 157, 203, 235, 70, 6 },
+        { 186, 222, 92, 74, 13 },
+        { 102, 45, 125, 59, 9 },
+        { 181, 35, 167, 181, 13 }, },
+      { { 164, 40, 245, 182, 14 },
+        { 185, 145, 227, 18, 15 },
+        { 118, 218, 241, 66, 5 },
+        { 244, 140, 120, 153, 13 }, },
+      { { 163, 55, 241, 121, 3 },
+        { 117, 178, 170, 127, 4 },
+        { 201, 232, 254, 204, 5 },
+        { 47, 229, 84, 218, 14 }, },
+      { { 163, 68, 64, 245, 10 },
+        { 40, 20, 163, 111, 2 },
+        { 90, 240, 34, 44, 5 },
+        { 79, 108, 82, 129, 4 }, },
+      { { 161, 127, 173, 133, 8 },
+        { 89, 135, 45, 102, 14 },
+        { 26, 27, 95, 232, 5 },
+        { 118, 107, 78, 25, 10 }, },
+      { { 167, 210, 150, 35, 13 },
+        { 196, 197, 123, 87, 1 },
+        { 188, 70, 148, 190, 5 },
+        { 142, 173, 234, 50, 3 }, },
+      { { 168, 69, 112, 43, 11 },
+        { 38, 54, 35, 54, 5 },
+        { 221, 64, 234, 33, 5 },
+        { 166, 204, 70, 198, 4 }, },
+      { { 174, 72, 127, 160, 9 },
+        { 182, 69, 39, 19, 14 },
+        { 144, 95, 225, 39, 5 },
+        { 124, 142, 74, 38, 13 }, },
+      { { 172, 79, 182, 214, 8 },
+        { 138, 199, 169, 58, 15 },
+        { 22, 182, 223, 35, 5 },
+        { 245, 201, 94, 53, 1 }, },
+      { { 168, 168, 211, 133, 3 },
+        { 63, 208, 48, 22, 10 },
+        { 202, 28, 177, 81, 5 },
+        { 86, 128, 192, 191, 12 }, },
+      { { 169, 139, 10, 203, 8 },
+        { 2, 98, 61, 78, 11 },
+        { 29, 53, 13, 25, 5 },
+        { 215, 43, 196, 100, 0 }, },
+      { { 173, 254, 140, 222, 2 },
+        { 203, 181, 188, 106, 11 },
+        { 71, 179, 23, 251, 5 },
+        { 213, 99, 218, 221, 3 }, },
+      { { 180, 239, 46, 46, 14 },
+        { 137, 127, 127, 34, 13 },
+        { 119, 71, 79, 114, 13 },
+        { 180, 79, 239, 233, 1 }, },
+      { { 183, 153, 137, 199, 0 },
+        { 216, 138, 52, 79, 11 },
+        { 14, 57, 25, 158, 13 },
+        { 223, 34, 197, 17, 11 }, },
+      { { 190, 12, 162, 14, 12 },
+        { 138, 232, 97, 35, 13 },
+        { 55, 4, 83, 7, 13 },
+        { 188, 72, 97, 117, 1 }, },
+      { { 188, 112, 34, 122, 9 },
+        { 199, 108, 163, 10, 5 },
+        { 149, 228, 64, 227, 13 },
+        { 165, 12, 83, 110, 3 }, },
+      { { 190, 188, 47, 145, 10 },
+        { 211, 89, 181, 39, 14 },
+        { 88, 159, 67, 215, 13 },
+        { 126, 74, 217, 172, 11 }, },
+      { { 184, 233, 10, 152, 3 },
+        { 7, 126, 180, 2, 10 },
+        { 193, 149, 9, 113, 13 },
+        { 84, 2, 215, 238, 0 }, },
+      { { 189, 10, 48, 236, 8 },
+        { 138, 40, 43, 90, 14 },
+        { 19, 112, 197, 11, 13 },
+        { 117, 173, 65, 69, 1 }, },
+      { { 194, 2, 224, 243, 1 },
+        { 36, 128, 138, 143, 7 },
+        { 140, 240, 116, 4, 3 },
+        { 239, 21, 16, 18, 4 }, },
+      { { 194, 107, 50, 227, 7 },
+        { 5, 86, 74, 159, 15 },
+        { 236, 116, 205, 100, 3 },
+        { 255, 149, 38, 170, 0 }, },
+      { { 198, 202, 66, 106, 8 },
+        { 160, 100, 27, 139, 9 },
+        { 21, 100, 37, 54, 3 },
+        { 157, 29, 130, 96, 5 }, },
+      { { 199, 30, 238, 104, 14 },
+        { 224, 241, 79, 235, 12 },
+        { 113, 103, 119, 142, 3 },
+        { 61, 127, 40, 240, 7 }, },
+      { { 199, 125, 46, 145, 3 },
+        { 197, 87, 132, 231, 14 },
+        { 200, 151, 75, 238, 3 },
+        { 126, 114, 30, 170, 3 }, },
+      { { 206, 60, 32, 116, 2 },
+        { 203, 16, 130, 171, 12 },
+        { 66, 224, 67, 199, 3 },
+        { 61, 84, 16, 141, 3 }, },
+      { { 204, 74, 185, 197, 7 },
+        { 158, 148, 76, 158, 14 },
+        { 234, 57, 213, 35, 3 },
+        { 119, 147, 34, 151, 9 }, },
+      { { 206, 247, 99, 220, 13 },
+        { 255, 102, 217, 171, 6 },
+        { 179, 188, 110, 247, 3 },
+        { 109, 89, 182, 111, 15 }, },
+      { { 205, 67, 34, 202, 2 },
+        { 130, 118, 8, 202, 7 },
+        { 69, 52, 76, 43, 3 },
+        { 229, 49, 6, 228, 1 }, },
+      { { 207, 183, 204, 29, 0 },
+        { 235, 163, 156, 231, 0 },
+        { 11, 131, 62, 223, 3 },
+        { 14, 115, 156, 93, 7 }, },
+      { { 201, 206, 200, 53, 10 },
+        { 42, 148, 159, 230, 8 },
+        { 90, 193, 55, 57, 3 },
+        { 22, 127, 146, 149, 4 }, },
+      { { 207, 243, 75, 113, 3 },
+        { 247, 86, 158, 207, 0 },
+        { 200, 237, 44, 255, 3 },
+        { 15, 55, 150, 174, 15 }, },
+      { { 214, 46, 123, 112, 13 },
+        { 181, 72, 207, 187, 12 },
+        { 176, 237, 231, 70, 11 },
+        { 61, 223, 49, 42, 13 }, },
+      { { 212, 23, 75, 59, 4 },
+        { 240, 106, 206, 166, 1 },
+        { 45, 205, 46, 130, 11 },
+        { 134, 87, 53, 96, 15 }, },
+      { { 215, 141, 250, 151, 14 },
+        { 168, 218, 213, 247, 15 },
+        { 126, 149, 251, 30, 11 },
+        { 254, 250, 181, 177, 5 }, },
+      { { 209, 216, 245, 85, 1 },
+        { 124, 141, 144, 222, 12 },
+        { 138, 170, 241, 184, 11 },
+        { 55, 176, 155, 19, 14 }, },
+      { { 213, 207, 225, 211, 9 },
+        { 180, 142, 153, 238, 15 },
+        { 156, 184, 127, 58, 11 },
+        { 247, 121, 151, 18, 13 }, },
+      { { 218, 22, 168, 204, 9 },
+        { 78, 168, 13, 171, 6 },
+        { 147, 49, 86, 133, 11 },
+        { 109, 91, 1, 87, 2 }, },
+      { { 216, 76, 68, 133, 9 },
+        { 46, 13, 1, 166, 10 },
+        { 154, 18, 35, 33, 11 },
+        { 86, 88, 11, 7, 4 }, },
+      { { 220, 217, 114, 142, 13 },
+        { 238, 110, 81, 146, 15 },
+        { 183, 20, 233, 179, 11 },
+        { 244, 152, 167, 103, 7 }, },
+      { { 223, 103, 17, 126, 8 },
+        { 155, 46, 139, 251, 1 },
+        { 23, 232, 142, 111, 11 },
+        { 141, 253, 23, 77, 9 }, },
+      { { 219, 153, 125, 230, 7 },
+        { 126, 27, 86, 219, 15 },
+        { 230, 123, 233, 157, 11 },
+        { 253, 182, 173, 135, 14 }, },
+      { { 221, 171, 142, 49, 14 },
+        { 131, 219, 223, 198, 8 },
+        { 120, 199, 29, 91, 11 },
+        { 22, 63, 189, 188, 1 }, },
+      { { 224, 25, 8, 76, 13 },
+        { 76, 34, 101, 138, 8 },
+        { 179, 33, 9, 128, 7 },
+        { 21, 26, 100, 67, 2 }, },
+      { { 230, 54, 218, 82, 1 },
+        { 229, 192, 172, 187, 1 },
+        { 132, 165, 182, 198, 7 },
+        { 141, 211, 80, 58, 7 }, },
+      { { 226, 172, 199, 155, 0 },
+        { 49, 225, 176, 167, 11 },
+        { 13, 158, 51, 84, 7 },
+        { 222, 80, 216, 120, 12 }, },
+      { { 228, 141, 33, 98, 0 },
+        { 144, 2, 50, 170, 13 },
+        { 4, 104, 75, 18, 7 },
+        { 181, 84, 196, 0, 9 }, },
+      { { 226, 254, 208, 197, 1 },
+        { 109, 132, 56, 191, 10 },
+        { 138, 48, 183, 244, 7 },
+        { 95, 209, 194, 27, 6 }, },
+      { { 225, 58, 125, 2, 10 },
+        { 113, 17, 45, 210, 13 },
+        { 84, 11, 229, 200, 7 },
+        { 180, 187, 72, 136, 14 }, },
+      { { 231, 208, 91, 142, 5 },
+        { 252, 100, 116, 211, 3 },
+        { 167, 29, 160, 190, 7 },
+        { 204, 178, 226, 99, 15 }, },
+      { { 236, 48, 156, 107, 5 },
+        { 199, 161, 102, 158, 1 },
+        { 173, 99, 144, 195, 7 },
+        { 135, 150, 104, 94, 3 }, },
+      { { 236, 170, 73, 210, 0 },
+        { 179, 0, 188, 138, 11 },
+        { 4, 185, 37, 83, 7 },
+        { 213, 19, 208, 12, 13 }, },
+      { { 238, 179, 122, 196, 6 },
+        { 235, 82, 124, 155, 6 },
+        { 98, 53, 236, 215, 7 },
+        { 109, 147, 228, 173, 7 }, },
+      { { 232, 224, 103, 46, 2 },
+        { 59, 117, 50, 130, 5 },
+        { 71, 78, 96, 113, 7 },
+        { 164, 20, 202, 237, 12 }, },
+      { { 234, 229, 213, 36, 12 },
+        { 59, 135, 115, 179, 0 },
+        { 50, 74, 186, 117, 7 },
+        { 12, 220, 238, 29, 12 }, },
+      { { 237, 107, 28, 44, 2 },
+        { 139, 55, 46, 210, 8 },
+        { 67, 67, 141, 107, 7 },
+        { 20, 183, 78, 205, 1 }, },
+      { { 235, 200, 175, 29, 6 },
+        { 26, 245, 244, 199, 12 },
+        { 107, 143, 81, 61, 7 },
+        { 62, 50, 250, 245, 8 }, },
+      { { 242, 5, 98, 212, 5 },
+        { 44, 74, 224, 171, 6 },
+        { 162, 180, 106, 4, 15 },
+        { 109, 80, 117, 35, 4 }, },
+      { { 246, 25, 188, 251, 2 },
+        { 192, 187, 166, 159, 15 },
+        { 77, 243, 217, 134, 15 },
+        { 255, 150, 93, 208, 3 }, },
+      { { 246, 163, 92, 109, 11 },
+        { 173, 59, 63, 159, 0 },
+        { 219, 99, 172, 86, 15 },
+        { 15, 159, 205, 203, 5 }, },
+      { { 244, 241, 189, 15, 0 },
+        { 217, 175, 52, 150, 5 },
+        { 15, 11, 216, 242, 15 },
+        { 166, 146, 207, 89, 11 }, },
+      { { 241, 106, 155, 67, 5 },
+        { 21, 204, 108, 222, 9 },
+        { 172, 45, 149, 104, 15 },
+        { 151, 179, 99, 58, 8 }, },
+      { { 241, 178, 145, 41, 14 },
+        { 81, 184, 123, 214, 0 },
+        { 121, 72, 148, 216, 15 },
+        { 6, 189, 225, 216, 10 }, },
+      { { 250, 84, 91, 243, 5 },
+        { 118, 76, 230, 191, 3 },
+        { 172, 253, 162, 165, 15 },
+        { 207, 214, 115, 38, 14 }, },
+      { { 254, 110, 134, 124, 6 },
+        { 139, 253, 234, 171, 8 },
+        { 99, 230, 23, 103, 15 },
+        { 29, 85, 123, 253, 1 }, },
+      { { 249, 13, 185, 67, 2 },
+        { 18, 154, 36, 254, 13 },
+        { 76, 41, 219, 9, 15 },
+        { 183, 242, 69, 148, 8 }, },
+      { { 249, 105, 102, 43, 13 },
+        { 39, 111, 99, 198, 13 },
+        { 189, 70, 105, 105, 15 },
+        { 182, 60, 111, 110, 4 }, },
+      { { 251, 65, 203, 72, 4 },
+        { 50, 238, 100, 203, 0 },
+        { 33, 45, 56, 45, 15 },
+        { 13, 50, 103, 116, 12 }, },
+      { { 253, 87, 191, 152, 5 },
+        { 214, 239, 236, 242, 6 },
+        { 161, 159, 222, 171, 15 },
+        { 100, 243, 127, 118, 11 }, },
+      { { 251, 152, 144, 126, 6 },
+        { 74, 184, 242, 219, 9 },
+        { 103, 224, 145, 157, 15 },
+        { 157, 180, 241, 213, 2 }, },
+      { { 255, 234, 33, 198, 3 },
+        { 159, 28, 56, 203, 15 },
+        { 198, 56, 69, 127, 15 },
+        { 253, 49, 195, 143, 9 }, },
+      { { 163, 165, 111, 69, 0 },
+        { 57, 67, 52, 111, 4 },
+        { 10, 47, 106, 92, 5 },
+        { 47, 98, 204, 41, 12 }, },
+      { { 161, 152, 104, 48, 2 },
+        { 96, 16, 182, 66, 12 },
+        { 64, 193, 97, 152, 5 },
+        { 52, 38, 208, 128, 6 }, },
+      { { 15, 55, 131, 43, 0 },
+        { 211, 226, 10, 101, 1 },
+        { 13, 76, 30, 207, 0 },
+        { 138, 101, 4, 124, 11 }, },
+      { { 38, 236, 72, 39, 2 },
+        { 169, 20, 54, 37, 9 },
+        { 78, 65, 35, 118, 4 },
+        { 154, 70, 194, 137, 5 }, },
+      { { 65, 152, 184, 168, 15 },
+        { 68, 176, 87, 208, 14 },
+        { 241, 81, 209, 152, 2 },
+        { 112, 190, 160, 210, 2 }, },
+      { { 78, 181, 67, 138, 4 },
+        { 243, 98, 80, 161, 3 },
+        { 37, 28, 42, 215, 2 },
+        { 200, 80, 164, 108, 15 }, },
+      { { 99, 197, 227, 123, 10 },
+        { 48, 246, 179, 237, 5 },
+        { 93, 236, 122, 60, 6 },
+        { 171, 124, 214, 240, 12 }, },
+      { { 110, 89, 221, 230, 12 },
+        { 250, 135, 103, 153, 11 },
+        { 54, 123, 185, 167, 6 },
+        { 217, 158, 110, 21, 15 }, },
+      { { 128, 212, 89, 240, 8 },
+        { 112, 4, 151, 58, 2 },
+        { 16, 249, 162, 176, 1 },
+        { 69, 206, 146, 0, 14 }, },
+      { { 152, 8, 136, 159, 13 },
+        { 14, 168, 197, 6, 11 },
+        { 191, 145, 17, 1, 9 },
+        { 214, 10, 49, 87, 0 }, },
+      { { 163, 6, 103, 166, 15 },
+        { 60, 81, 107, 99, 7 },
+        { 246, 94, 102, 12, 5 },
+        { 236, 109, 104, 163, 12 }, },
+      { { 2, 25, 166, 20, 7 },
+        { 76, 211, 192, 1, 12 },
+        { 226, 134, 89, 132, 0 },
+        { 56, 0, 60, 179, 2 }, },
+      { { 2, 21, 202, 78, 2 },
+        { 104, 242, 4, 41, 1 },
+        { 71, 37, 58, 132, 0 },
+        { 137, 66, 4, 241, 6 }, },
+      { { 0, 104, 204, 57, 9 },
+        { 37, 165, 135, 4, 8 },
+        { 153, 195, 49, 96, 0 },
+        { 18, 14, 26, 90, 4 }, },
+      { { 0, 161, 19, 254, 8 },
+        { 25, 98, 147, 24, 3 },
+        { 23, 252, 136, 80, 0 },
+        { 193, 140, 148, 105, 8 }, },
+      { { 2, 185, 86, 117, 5 },
+        { 109, 67, 210, 29, 8 },
+        { 170, 230, 169, 212, 0 },
+        { 27, 132, 188, 43, 6 }, },
+      { { 2, 198, 187, 83, 2 },
+        { 16, 212, 156, 61, 5 },
+        { 76, 173, 214, 52, 0 },
+        { 171, 195, 146, 176, 8 }, },
+      { { 2, 243, 31, 29, 9 },
+        { 93, 103, 157, 21, 0 },
+        { 155, 143, 140, 244, 0 },
+        { 10, 139, 158, 107, 10 }, },
+      { { 7, 42, 193, 126, 3 },
+        { 189, 176, 138, 73, 9 },
+        { 199, 232, 53, 78, 0 },
+        { 153, 37, 16, 219, 13 }, },
+      { { 7, 55, 141, 151, 2 },
+        { 217, 147, 140, 101, 3 },
+        { 78, 155, 30, 206, 0 },
+        { 202, 99, 28, 153, 11 }, },
+      { { 1, 111, 31, 231, 5 },
+        { 29, 71, 78, 124, 11 },
+        { 174, 127, 143, 104, 0 },
+        { 211, 231, 46, 43, 8 }, },
+      { { 1, 119, 48, 21, 5 },
+        { 77, 6, 200, 116, 4 },
+        { 170, 128, 206, 232, 0 },
+        { 34, 225, 54, 11, 2 }, },
+      { { 7, 149, 114, 65, 10 },
+        { 224, 82, 17, 125, 4 },
+        { 88, 36, 234, 158, 0 },
+        { 43, 232, 132, 160, 7 }, },
+      { { 7, 200, 163, 134, 14 },
+        { 152, 212, 81, 65, 15 },
+        { 118, 28, 81, 62, 0 },
+        { 248, 40, 162, 177, 9 }, },
+      { { 5, 254, 251, 247, 9 },
+        { 253, 196, 159, 124, 15 },
+        { 158, 253, 247, 250, 0 },
+        { 243, 239, 146, 59, 15 }, },
+      { { 12, 21, 243, 16, 1 },
+        { 246, 194, 128, 48, 4 },
+        { 128, 140, 250, 131, 0 },
+        { 32, 192, 20, 54, 15 }, },
+      { { 10, 68, 98, 226, 14 },
+        { 34, 84, 67, 41, 7 },
+        { 116, 116, 98, 37, 0 },
+        { 233, 76, 34, 164, 4 }, },
+      { { 8, 94, 55, 238, 9 },
+        { 94, 101, 11, 56, 15 },
+        { 151, 126, 199, 161, 0 },
+        { 241, 205, 10, 103, 10 }, },
+      { { 8, 82, 222, 18, 13 },
+        { 102, 197, 205, 16, 1 },
+        { 180, 135, 180, 161, 0 },
+        { 128, 139, 58, 54, 6 }, },
+      { { 12, 102, 136, 3, 9 },
+        { 135, 132, 13, 36, 1 },
+        { 156, 1, 22, 99, 0 },
+        { 130, 75, 2, 30, 1 }, },
+      { { 8, 140, 186, 71, 15 },
+        { 14, 208, 85, 60, 13 },
+        { 254, 37, 211, 17, 0 },
+        { 179, 202, 160, 183, 0 }, },
+      { { 12, 172, 39, 30, 5 },
+        { 159, 97, 208, 32, 13 },
+        { 167, 142, 67, 83, 0 },
+        { 176, 64, 184, 111, 9 }, },
+      { { 8, 179, 56, 11, 15 },
+        { 71, 50, 93, 20, 5 },
+        { 253, 1, 204, 209, 0 },
+        { 162, 139, 164, 206, 2 }, },
+      { { 12, 162, 165, 217, 4 },
+        { 147, 161, 216, 12, 6 },
+        { 41, 186, 84, 83, 0 },
+        { 99, 1, 184, 92, 9 }, },
+      { { 8, 227, 82, 192, 1 },
+        { 39, 70, 24, 24, 2 },
+        { 128, 52, 172, 113, 0 },
+        { 65, 129, 134, 46, 4 }, },
+      { { 14, 255, 68, 245, 14 },
+        { 235, 23, 219, 45, 10 },
+        { 122, 242, 47, 247, 0 },
+        { 91, 77, 190, 141, 7 }, },
+      { { 14, 255, 93, 234, 11 },
+        { 247, 55, 31, 57, 11 },
+        { 213, 123, 175, 247, 0 },
+        { 217, 207, 142, 206, 15 }, },
+      { { 11, 52, 109, 201, 14 },
+        { 115, 49, 69, 109, 6 },
+        { 121, 59, 98, 205, 0 },
+        { 107, 106, 40, 204, 14 }, },
+      { { 13, 9, 254, 187, 3 },
+        { 166, 243, 134, 84, 15 },
+        { 205, 215, 249, 11, 0 },
+        { 242, 166, 28, 246, 5 }, },
+      { { 15, 16, 170, 146, 6 },
+        { 194, 208, 196, 65, 7 },
+        { 100, 149, 80, 143, 0 },
+        { 232, 34, 48, 180, 3 }, },
+      { { 13, 31, 101, 167, 14 },
+        { 250, 19, 75, 100, 15 },
+        { 126, 90, 111, 139, 0 },
+        { 242, 109, 44, 133, 15 }, },
+      { { 15, 177, 95, 160, 0 },
+        { 243, 67, 22, 81, 2 },
+        { 0, 95, 168, 223, 0 },
+        { 72, 166, 140, 44, 15 }, },
+      { { 13, 162, 5, 35, 3 },
+        { 151, 17, 26, 68, 1 },
+        { 204, 74, 4, 91, 0 },
+        { 130, 37, 136, 142, 9 }, },
+      { { 13, 175, 35, 219, 11 },
+        { 151, 114, 153, 108, 15 },
+        { 221, 188, 79, 91, 0 },
+        { 243, 105, 148, 238, 9 }, },
+      { { 11, 240, 165, 238, 4 },
+        { 91, 165, 82, 73, 7 },
+        { 39, 122, 80, 253, 0 },
+        { 233, 36, 170, 93, 10 }, },
+      { { 13, 200, 153, 251, 14 },
+        { 146, 180, 215, 92, 11 },
+        { 125, 249, 145, 59, 0 },
+        { 211, 174, 178, 212, 9 }, },
+      { { 15, 253, 48, 39, 7 },
+        { 207, 22, 82, 117, 13 },
+        { 238, 64, 203, 255, 0 },
+        { 186, 228, 166, 143, 3 }, },
+      { { 11, 199, 93, 86, 2 },
+        { 58, 23, 156, 121, 1 },
+        { 70, 171, 174, 61, 0 },
+        { 137, 227, 158, 133, 12 }, },
+      { { 18, 47, 163, 1, 13 },
+        { 21, 202, 73, 37, 12 },
+        { 184, 12, 95, 68, 8 },
+        { 58, 73, 37, 58, 8 }, },
+      { { 18, 117, 72, 114, 5 },
+        { 101, 14, 198, 41, 1 },
+        { 164, 225, 42, 228, 8 },
+        { 137, 70, 55, 10, 6 }, },
+      { { 16, 79, 174, 98, 7 },
+        { 4, 223, 78, 40, 13 },
+        { 228, 103, 95, 32, 8 },
+        { 177, 71, 47, 178, 0 }, },
+      { { 16, 140, 138, 232, 11 },
+        { 4, 248, 23, 40, 10 },
+        { 209, 117, 19, 16, 8 },
+        { 81, 78, 129, 242, 0 }, },
+      { { 16, 243, 244, 46, 14 },
+        { 105, 191, 91, 16, 5 },
+        { 119, 66, 252, 240, 8 },
+        { 160, 141, 175, 217, 6 }, },
+      { { 19, 55, 238, 112, 2 },
+        { 97, 219, 142, 105, 4 },
+        { 64, 231, 126, 204, 8 },
+        { 41, 103, 29, 184, 6 }, },
+      { { 23, 11, 35, 235, 0 },
+        { 144, 106, 10, 77, 15 },
+        { 13, 124, 77, 14, 8 },
+        { 251, 37, 5, 96, 9 }, },
+      { { 21, 2, 111, 27, 11 },
+        { 180, 121, 141, 68, 5 },
+        { 221, 143, 100, 10, 8 },
+        { 162, 43, 25, 226, 13 }, },
+      { { 17, 161, 171, 203, 2 },
+        { 17, 250, 20, 76, 7 },
+        { 77, 61, 88, 88, 8 },
+        { 227, 34, 133, 248, 8 }, },
+      { { 19, 166, 74, 200, 13 },
+        { 37, 104, 93, 105, 2 },
+        { 177, 53, 38, 92, 8 },
+        { 73, 107, 161, 106, 4 }, },
+      { { 23, 142, 53, 205, 3 },
+        { 156, 57, 24, 125, 14 },
+        { 203, 58, 199, 30, 8 },
+        { 123, 225, 137, 195, 9 }, },
+      { { 21, 139, 229, 157, 12 },
+        { 184, 171, 217, 68, 14 },
+        { 59, 154, 125, 26, 8 },
+        { 114, 41, 189, 81, 13 }, },
+      { { 23, 166, 249, 125, 4 },
+        { 185, 168, 222, 125, 4 },
+        { 43, 233, 246, 94, 8 },
+        { 43, 231, 177, 89, 13 }, },
+      { { 21, 220, 164, 180, 4 },
+        { 200, 141, 210, 96, 14 },
+        { 34, 210, 83, 186, 8 },
+        { 112, 100, 187, 17, 3 }, },
+      { { 17, 223, 5, 67, 12 },
+        { 80, 15, 89, 108, 9 },
+        { 60, 42, 15, 184, 8 },
+        { 147, 105, 175, 0, 10 }, },
+      { { 21, 210, 1, 147, 5 },
+        { 212, 12, 216, 68, 3 },
+        { 172, 152, 4, 186, 8 },
+        { 194, 33, 179, 2, 11 }, },
+      { { 24, 31, 173, 250, 10 },
+        { 82, 187, 143, 40, 15 },
+        { 85, 251, 95, 129, 8 },
+        { 241, 79, 29, 212, 10 }, },
+      { { 28, 64, 14, 171, 13 },
+        { 134, 109, 71, 4, 3 },
+        { 189, 87, 0, 35, 8 },
+        { 194, 14, 43, 102, 1 }, },
+      { { 30, 76, 93, 61, 2 },
+        { 186, 61, 134, 53, 8 },
+        { 75, 203, 163, 39, 8 },
+        { 26, 198, 27, 197, 13 }, },
+      { { 24, 111, 246, 127, 9 },
+        { 47, 239, 139, 60, 13 },
+        { 159, 230, 255, 97, 8 },
+        { 179, 205, 31, 127, 4 }, },
+      { { 24, 87, 52, 184, 15 },
+        { 70, 63, 203, 48, 6 },
+        { 241, 210, 206, 161, 8 },
+        { 96, 205, 63, 198, 2 }, },
+      { { 30, 86, 137, 227, 4 },
+        { 210, 140, 78, 45, 3 },
+        { 44, 121, 22, 167, 8 },
+        { 203, 71, 35, 20, 11 }, },
+      { { 26, 149, 209, 132, 5 },
+        { 126, 138, 80, 49, 2 },
+        { 162, 24, 186, 149, 8 },
+        { 72, 192, 165, 23, 14 }, },
+      { { 24, 167, 255, 2, 10 },
+        { 51, 219, 29, 48, 5 },
+        { 84, 15, 254, 81, 8 },
+        { 160, 203, 141, 188, 12 }, },
+      { { 24, 158, 177, 201, 14 },
+        { 82, 184, 89, 60, 14 },
+        { 121, 56, 215, 145, 8 },
+        { 115, 201, 161, 212, 10 }, },
+      { { 28, 178, 10, 96, 10 },
+        { 195, 88, 31, 8, 0 },
+        { 80, 101, 4, 211, 8 },
+        { 1, 15, 129, 172, 3 }, },
+      { { 28, 146, 53, 136, 1 },
+        { 214, 41, 24, 16, 6 },
+        { 129, 26, 196, 147, 8 },
+        { 96, 129, 137, 70, 11 }, },
+      { { 28, 147, 183, 214, 13 },
+        { 222, 203, 217, 24, 7 },
+        { 182, 190, 220, 147, 8 },
+        { 225, 137, 189, 55, 11 }, },
+      { { 26, 202, 188, 88, 1 },
+        { 6, 173, 156, 25, 12 },
+        { 129, 163, 213, 53, 8 },
+        { 57, 131, 155, 86, 0 }, },
+      { { 28, 226, 172, 181, 8 },
+        { 139, 141, 159, 4, 6 },
+        { 26, 211, 84, 115, 8 },
+        { 98, 15, 155, 29, 1 }, },
+      { { 27, 121, 237, 6, 4 },
+        { 123, 143, 68, 65, 13 },
+        { 38, 11, 121, 237, 8 },
+        { 184, 34, 47, 29, 14 }, },
+      { { 31, 106, 57, 19, 2 },
+        { 147, 28, 140, 85, 13 },
+        { 76, 137, 197, 111, 8 },
+        { 186, 163, 19, 140, 9 }, },
+      { { 29, 152, 56, 117, 0 },
+        { 202, 8, 150, 92, 12 },
+        { 10, 225, 193, 155, 8 },
+        { 51, 166, 145, 5, 3 }, },
+      { { 32, 13, 193, 3, 15 },
+        { 52, 146, 97, 36, 9 },
+        { 252, 8, 59, 0, 4 },
+        { 146, 72, 100, 146, 12 }, },
+      { { 38, 53, 212, 232, 0 },
+        { 225, 163, 34, 57, 2 },
+        { 1, 114, 186, 198, 4 },
+        { 73, 196, 76, 88, 7 }, },
+      { { 38, 117, 44, 47, 8 },
+        { 201, 39, 39, 37, 5 },
+        { 31, 67, 74, 230, 4 },
+        { 170, 78, 78, 73, 3 }, },
+      { { 32, 83, 133, 143, 6 },
+        { 88, 183, 104, 4, 3 },
+        { 111, 26, 28, 160, 4 },
+        { 194, 1, 110, 209, 10 }, },
+      { { 34, 136, 31, 122, 3 },
+        { 20, 113, 182, 25, 9 },
+        { 197, 239, 129, 20, 4 },
+        { 153, 134, 216, 226, 8 }, },
+      { { 39, 44, 250, 229, 5 },
+        { 173, 192, 102, 125, 14 },
+        { 170, 117, 243, 78, 4 },
+        { 123, 230, 96, 59, 5 }, },
+      { { 33, 107, 76, 67, 11 },
+        { 37, 23, 45, 76, 9 },
+        { 220, 35, 45, 104, 4 },
+        { 147, 43, 78, 138, 4 }, },
+      { { 37, 188, 103, 11, 10 },
+        { 241, 113, 49, 100, 13 },
+        { 93, 14, 99, 218, 4 },
+        { 178, 104, 200, 232, 15 }, },
+      { { 33, 163, 233, 176, 14 },
+        { 49, 146, 255, 64, 6 },
+        { 112, 217, 124, 88, 4 },
+        { 96, 47, 244, 152, 12 }, },
+      { { 33, 150, 242, 145, 15 },
+        { 100, 208, 249, 116, 6 },
+        { 248, 148, 246, 152, 4 },
+        { 98, 233, 240, 178, 6 }, },
+      { { 39, 162, 43, 140, 10 },
+        { 153, 112, 61, 65, 6 },
+        { 83, 29, 68, 94, 4 },
+        { 104, 43, 192, 233, 9 }, },
+      { { 39, 159, 72, 50, 8 },
+        { 224, 2, 191, 97, 9 },
+        { 20, 193, 47, 158, 4 },
+        { 152, 111, 212, 0, 7 }, },
+      { { 35, 226, 188, 201, 7 },
+        { 5, 181, 124, 93, 6 },
+        { 233, 51, 212, 124, 4 },
+        { 107, 163, 234, 218, 0 }, },
+      { { 33, 194, 87, 244, 1 },
+        { 60, 69, 186, 88, 2 },
+        { 130, 254, 164, 56, 4 },
+        { 65, 165, 218, 35, 12 }, },
+      { { 39, 207, 186, 248, 11 },
+        { 132, 246, 191, 121, 14 },
+        { 209, 245, 223, 62, 4 },
+        { 121, 239, 214, 242, 1 }, },
+      { { 42, 47, 189, 228, 11 },
+        { 31, 147, 47, 57, 14 },
+        { 210, 123, 223, 69, 4 },
+        { 121, 207, 76, 159, 8 }, },
+      { { 42, 84, 58, 140, 12 },
+        { 74, 100, 101, 49, 6 },
+        { 51, 21, 194, 165, 4 },
+        { 104, 202, 98, 101, 2 }, },
+      { { 42, 209, 187, 151, 15 },
+        { 94, 214, 245, 21, 7 },
+        { 254, 157, 216, 181, 4 },
+        { 234, 138, 246, 183, 10 }, },
+      { { 40, 255, 58, 99, 1 },
+        { 71, 70, 62, 60, 13 },
+        { 140, 101, 207, 241, 4 },
+        { 179, 199, 198, 46, 2 }, },
+      { { 43, 84, 197, 185, 8 },
+        { 114, 165, 163, 101, 2 },
+        { 25, 218, 50, 173, 4 },
+        { 74, 108, 90, 84, 14 }, },
+      { { 45, 97, 175, 26, 10 },
+        { 147, 247, 165, 64, 5 },
+        { 85, 143, 88, 107, 4 },
+        { 160, 42, 94, 252, 9 }, },
+      { { 43, 188, 219, 62, 6 },
+        { 123, 240, 246, 113, 9 },
+        { 103, 205, 179, 221, 4 },
+        { 152, 230, 240, 253, 14 }, },
+      { { 45, 159, 154, 13, 2 },
+        { 202, 242, 60, 116, 8 },
+        { 75, 5, 159, 155, 4 },
+        { 18, 227, 196, 245, 3 }, },
+      { { 47, 187, 114, 106, 3 },
+        { 231, 114, 58, 89, 13 },
+        { 197, 100, 237, 223, 4 },
+        { 185, 165, 196, 238, 7 }, },
+      { { 43, 217, 204, 255, 7 },
+        { 110, 183, 246, 77, 11 },
+        { 239, 243, 57, 189, 4 },
+        { 219, 38, 254, 215, 6 }, },
+      { { 41, 198, 223, 142, 12 },
+        { 58, 229, 125, 112, 3 },
+        { 55, 31, 182, 57, 4 },
+        { 192, 235, 234, 117, 12 }, },
+      { { 52, 12, 63, 195, 5 },
+        { 148, 73, 100, 60, 15 },
+        { 172, 63, 195, 2, 12 },
+        { 243, 194, 105, 34, 9 }, },
+      { { 48, 3, 27, 40, 14 },
+        { 16, 122, 111, 16, 0 },
+        { 113, 77, 140, 0, 12 },
+        { 0, 143, 101, 224, 8 }, },
+      { { 48, 113, 29, 236, 3 },
+        { 93, 63, 38, 24, 2 },
+        { 195, 123, 136, 224, 12 },
+        { 65, 134, 79, 203, 10 }, },
+      { { 52, 76, 222, 162, 10 },
+        { 160, 221, 39, 48, 11 },
+        { 84, 87, 179, 34, 12 },
+        { 208, 206, 75, 176, 5 }, },
+      { { 50, 122, 138, 139, 12 },
+        { 65, 236, 109, 5, 11 },
+        { 61, 21, 21, 228, 12 },
+        { 218, 11, 99, 120, 2 }, },
+      { { 54, 87, 99, 215, 2 },
+        { 248, 94, 168, 45, 7 },
+        { 78, 188, 110, 166, 12 },
+        { 235, 65, 87, 161, 15 }, },
+      { { 52, 141, 50, 170, 6 },
+        { 128, 122, 114, 48, 15 },
+        { 101, 84, 203, 18, 12 },
+        { 240, 196, 229, 224, 1 }, },
+      { { 54, 129, 250, 177, 1 },
+        { 164, 202, 182, 21, 6 },
+        { 136, 213, 248, 22, 12 },
+        { 106, 134, 213, 50, 5 }, },
+      { { 54, 153, 111, 21, 13 },
+        { 252, 75, 245, 5, 12 },
+        { 186, 143, 105, 150, 12 },
+        { 58, 10, 253, 35, 15 }, },
+      { { 50, 204, 108, 49, 14 },
+        { 32, 29, 247, 37, 12 },
+        { 120, 195, 99, 52, 12 },
+        { 58, 78, 251, 128, 4 }, },
+      { { 54, 224, 7, 77, 4 },
+        { 153, 109, 112, 13, 0 },
+        { 43, 46, 0, 118, 12 },
+        { 11, 0, 235, 105, 9 }, },
+      { { 51, 64, 141, 156, 5 },
+        { 28, 173, 228, 65, 2 },
+        { 163, 155, 16, 44, 12 },
+        { 72, 34, 123, 83, 8 }, },
+      { { 51, 125, 174, 182, 10 },
+        { 73, 223, 167, 97, 15 },
+        { 86, 215, 91, 236, 12 },
+        { 248, 110, 95, 185, 2 }, },
+      { { 49, 94, 255, 61, 1 },
+        { 124, 237, 174, 116, 12 },
+        { 139, 207, 247, 168, 12 },
+        { 50, 231, 91, 115, 14 }, },
+      { { 53, 164, 249, 40, 11 },
+        { 181, 184, 55, 112, 4 },
+        { 209, 73, 242, 90, 12 },
+        { 32, 238, 193, 218, 13 }, },
+      { { 51, 134, 161, 198, 4 },
+        { 24, 136, 120, 105, 7 },
+        { 38, 56, 86, 28, 12 },
+        { 233, 97, 225, 17, 8 }, },
+      { { 53, 232, 26, 158, 12 },
+        { 137, 108, 245, 80, 11 },
+        { 55, 149, 129, 122, 12 },
+        { 208, 170, 243, 105, 1 }, },
+      { { 55, 216, 88, 186, 3 },
+        { 228, 60, 182, 81, 11 },
+        { 197, 209, 161, 190, 12 },
+        { 216, 166, 211, 194, 7 }, },
+      { { 56, 21, 51, 89, 12 },
+        { 82, 106, 225, 60, 4 },
+        { 57, 172, 202, 129, 12 },
+        { 35, 200, 117, 100, 10 }, },
+      { { 56, 27, 98, 106, 12 },
+        { 98, 106, 107, 8, 13 },
+        { 53, 100, 109, 129, 12 },
+        { 177, 13, 101, 100, 6 }, },
+      { { 58, 54, 80, 219, 10 },
+        { 99, 56, 169, 61, 3 },
+        { 93, 176, 166, 197, 12 },
+        { 203, 201, 81, 204, 6 }, },
+      { { 56, 136, 209, 242, 9 },
+        { 54, 136, 179, 24, 11 },
+        { 148, 248, 177, 17, 12 },
+        { 209, 140, 209, 22, 12 }, },
+      { { 58, 204, 141, 200, 2 },
+        { 18, 189, 52, 41, 10 },
+        { 65, 59, 19, 53, 12 },
+        { 89, 66, 203, 212, 8 }, },
+      { { 60, 252, 249, 7, 11 },
+        { 255, 156, 53, 52, 13 },
+        { 222, 9, 243, 243, 12 },
+        { 178, 202, 195, 159, 15 }, },
+      { { 60, 246, 137, 57, 12 },
+        { 211, 172, 255, 36, 0 },
+        { 57, 201, 22, 243, 12 },
+        { 2, 79, 243, 92, 11 }, },
+      { { 59, 15, 174, 199, 9 },
+        { 14, 203, 45, 109, 15 },
+        { 158, 55, 95, 13, 12 },
+        { 251, 107, 77, 55, 0 }, },
+      { { 61, 11, 95, 245, 6 },
+        { 186, 91, 238, 92, 10 },
+        { 106, 255, 173, 11, 12 },
+        { 83, 167, 125, 165, 13 }, },
+      { { 57, 73, 131, 170, 6 },
+        { 18, 254, 98, 64, 11 },
+        { 101, 92, 25, 41, 12 },
+        { 208, 36, 103, 244, 8 }, },
+      { { 61, 92, 175, 229, 6 },
+        { 218, 221, 102, 108, 14 },
+        { 106, 127, 83, 171, 12 },
+        { 115, 102, 107, 181, 11 }, },
+      { { 59, 111, 209, 254, 2 },
+        { 59, 190, 170, 121, 11 },
+        { 71, 248, 191, 109, 12 },
+        { 217, 229, 87, 221, 12 }, },
+      { { 61, 114, 229, 206, 7 },
+        { 255, 189, 104, 72, 7 },
+        { 231, 58, 116, 235, 12 },
+        { 225, 33, 107, 223, 15 }, },
+      { { 59, 165, 24, 48, 4 },
+        { 3, 10, 246, 113, 0 },
+        { 32, 193, 138, 93, 12 },
+        { 8, 230, 245, 12, 0 }, },
+      { { 59, 215, 215, 116, 14 },
+        { 122, 223, 251, 121, 0 },
+        { 114, 238, 190, 189, 12 },
+        { 9, 237, 255, 181, 14 }, },
+      { { 66, 21, 7, 134, 1 },
+        { 92, 67, 0, 161, 3 },
+        { 134, 30, 10, 132, 2 },
+        { 200, 80, 12, 35, 10 }, },
+      { { 68, 42, 51, 204, 5 },
+        { 157, 96, 72, 152, 14 },
+        { 163, 60, 197, 66, 2 },
+        { 113, 145, 32, 107, 9 }, },
+      { { 64, 105, 62, 32, 12 },
+        { 1, 71, 71, 144, 12 },
+        { 48, 71, 201, 96, 2 },
+        { 48, 158, 46, 40, 0 }, },
+      { { 68, 76, 84, 241, 12 },
+        { 160, 5, 195, 188, 10 },
+        { 56, 242, 163, 34, 2 },
+        { 83, 220, 58, 0, 5 }, },
+      { { 64, 78, 207, 5, 5 },
+        { 60, 197, 76, 164, 8 },
+        { 170, 15, 55, 32, 2 },
+        { 18, 83, 42, 51, 12 }, },
+      { { 64, 223, 74, 196, 6 },
+        { 104, 86, 92, 168, 10 },
+        { 98, 53, 47, 176, 2 },
+        { 81, 83, 166, 161, 6 }, },
+      { { 70, 218, 103, 26, 14 },
+        { 240, 117, 217, 129, 13 },
+        { 117, 142, 101, 182, 2 },
+        { 184, 25, 186, 224, 15 }, },
+      { { 67, 32, 239, 178, 13 },
+        { 53, 193, 199, 193, 7 },
+        { 180, 223, 112, 76, 2 },
+        { 232, 62, 56, 58, 12 }, },
+      { { 65, 99, 121, 242, 7 },
+        { 53, 22, 206, 216, 7 },
+        { 228, 249, 236, 104, 2 },
+        { 225, 183, 54, 138, 12 }, },
+      { { 71, 127, 169, 44, 10 },
+        { 217, 182, 15, 225, 12 },
+        { 83, 73, 95, 238, 2 },
+        { 56, 127, 6, 217, 11 }, },
+      { { 67, 168, 36, 115, 10 },
+        { 1, 17, 147, 205, 13 },
+        { 92, 226, 65, 92, 2 },
+        { 187, 60, 152, 136, 0 }, },
+      { { 69, 174, 2, 166, 1 },
+        { 141, 64, 26, 224, 11 },
+        { 134, 84, 7, 90, 2 },
+        { 208, 117, 128, 43, 1 }, },
+      { { 72, 29, 125, 107, 6 },
+        { 114, 51, 70, 188, 13 },
+        { 109, 107, 235, 129, 2 },
+        { 179, 214, 44, 196, 14 }, },
+      { { 72, 68, 41, 14, 4 },
+        { 26, 36, 68, 160, 5 },
+        { 39, 9, 66, 33, 2 },
+        { 160, 82, 34, 69, 8 }, },
+      { { 76, 93, 176, 242, 6 },
+        { 194, 150, 194, 184, 15 },
+        { 100, 240, 219, 163, 2 },
+        { 241, 212, 54, 148, 3 }, },
+      { { 72, 79, 166, 76, 0 },
+        { 10, 231, 8, 168, 12 },
+        { 3, 38, 95, 33, 2 },
+        { 49, 81, 14, 117, 0 }, },
+      { { 72, 129, 242, 45, 11 },
+        { 46, 242, 19, 148, 4 },
+        { 219, 68, 248, 17, 2 },
+        { 34, 156, 132, 247, 4 }, },
+      { { 72, 140, 105, 154, 11 },
+        { 54, 48, 149, 160, 15 },
+        { 213, 153, 99, 17, 2 },
+        { 240, 90, 144, 198, 12 }, },
+      { { 76, 230, 39, 197, 2 },
+        { 155, 85, 24, 172, 6 },
+        { 74, 62, 70, 115, 2 },
+        { 99, 81, 138, 173, 9 }, },
+      { { 79, 61, 163, 205, 7 },
+        { 223, 242, 64, 237, 14 },
+        { 235, 60, 91, 207, 2 },
+        { 123, 112, 36, 255, 11 }, },
+      { { 73, 73, 253, 184, 8 },
+        { 50, 167, 135, 208, 14 },
+        { 17, 219, 249, 41, 2 },
+        { 112, 190, 30, 84, 12 }, },
+      { { 77, 89, 111, 25, 7 },
+        { 246, 119, 196, 196, 12 },
+        { 233, 143, 105, 171, 2 },
+        { 50, 50, 62, 230, 15 }, },
+      { { 79, 79, 213, 39, 11 },
+        { 190, 151, 11, 245, 9 },
+        { 222, 74, 191, 47, 2 },
+        { 154, 253, 14, 151, 13 }, },
+      { { 75, 148, 100, 228, 11 },
+        { 110, 17, 19, 233, 6 },
+        { 210, 114, 98, 157, 2 },
+        { 105, 124, 136, 135, 6 }, },
+      { { 77, 160, 106, 169, 14 },
+        { 163, 112, 87, 196, 6 },
+        { 121, 85, 96, 91, 2 },
+        { 98, 62, 160, 236, 5 }, },
+      { { 75, 146, 209, 251, 2 },
+        { 114, 176, 154, 221, 3 },
+        { 77, 248, 180, 157, 2 },
+        { 203, 181, 144, 212, 14 }, },
+      { { 79, 237, 128, 190, 11 },
+        { 143, 182, 147, 225, 11 },
+        { 215, 208, 27, 127, 2 },
+        { 216, 124, 150, 223, 1 }, },
+      { { 73, 250, 110, 175, 3 },
+        { 111, 117, 30, 196, 15 },
+        { 207, 87, 101, 249, 2 },
+        { 242, 55, 138, 239, 6 }, },
+      { { 84, 32, 172, 167, 7 },
+        { 141, 153, 70, 132, 7 },
+        { 238, 83, 80, 66, 10 },
+        { 226, 22, 41, 155, 1 }, },
+      { { 84, 25, 164, 142, 8 },
+        { 200, 171, 1, 128, 15 },
+        { 23, 18, 89, 130, 10 },
+        { 240, 24, 13, 81, 3 }, },
+      { { 86, 116, 218, 31, 8 },
+        { 233, 236, 133, 181, 1 },
+        { 31, 133, 178, 230, 10 },
+        { 138, 218, 19, 121, 7 }, },
+      { { 82, 70, 69, 212, 11 },
+        { 60, 29, 137, 169, 2 },
+        { 210, 186, 38, 36, 10 },
+        { 73, 89, 27, 131, 12 }, },
+      { { 80, 153, 112, 192, 3 },
+        { 100, 26, 16, 152, 14 },
+        { 192, 48, 233, 144, 10 },
+        { 113, 144, 133, 130, 6 }, },
+      { { 82, 162, 196, 106, 5 },
+        { 37, 169, 90, 137, 1 },
+        { 165, 98, 52, 84, 10 },
+        { 137, 21, 169, 90, 4 }, },
+      { { 80, 232, 170, 66, 4 },
+        { 1, 204, 84, 136, 13 },
+        { 36, 37, 81, 112, 10 },
+        { 177, 18, 163, 56, 0 }, },
+      { { 82, 242, 173, 89, 8 },
+        { 81, 173, 157, 141, 4 },
+        { 25, 171, 84, 244, 10 },
+        { 43, 27, 155, 88, 10 }, },
+      { { 82, 218, 235, 246, 10 },
+        { 120, 220, 159, 137, 15 },
+        { 86, 253, 117, 180, 10 },
+        { 249, 31, 147, 177, 14 }, },
+      { { 85, 46, 248, 226, 2 },
+        { 161, 152, 14, 248, 15 },
+        { 68, 113, 247, 74, 10 },
+        { 241, 247, 1, 152, 5 }, },
+      { { 81, 65, 96, 182, 2 },
+        { 40, 30, 130, 192, 7 },
+        { 70, 208, 104, 40, 10 },
+        { 224, 52, 23, 129, 4 }, },
+      { { 85, 104, 6, 21, 8 },
+        { 137, 77, 129, 196, 8 },
+        { 26, 134, 1, 106, 10 },
+        { 18, 56, 27, 41, 1 }, },
+      { { 83, 74, 126, 75, 13 },
+        { 36, 109, 77, 221, 13 },
+        { 189, 39, 229, 44, 10 },
+        { 187, 187, 43, 98, 4 }, },
+      { { 83, 107, 211, 224, 11 },
+        { 53, 222, 11, 217, 10 },
+        { 208, 124, 189, 108, 10 },
+        { 89, 189, 7, 186, 12 }, },
+      { { 87, 114, 130, 210, 7 },
+        { 197, 220, 200, 201, 3 },
+        { 228, 180, 20, 238, 10 },
+        { 201, 49, 51, 186, 3 }, },
+      { { 87, 129, 213, 88, 2 },
+        { 176, 187, 144, 217, 0 },
+        { 65, 170, 184, 30, 10 },
+        { 9, 176, 157, 208, 13 }, },
+      { { 87, 164, 195, 74, 8 },
+        { 177, 232, 17, 233, 1 },
+        { 21, 44, 50, 94, 10 },
+        { 137, 120, 129, 120, 13 }, },
+      { { 81, 151, 175, 148, 8 },
+        { 88, 203, 157, 224, 6 },
+        { 18, 159, 94, 152, 10 },
+        { 96, 123, 157, 49, 10 }, },
+      { { 87, 143, 23, 115, 11 },
+        { 148, 91, 155, 253, 9 },
+        { 220, 238, 143, 30, 10 },
+        { 155, 253, 157, 162, 9 }, },
+      { { 85, 194, 224, 207, 0 },
+        { 168, 172, 24, 204, 7 },
+        { 15, 48, 116, 58, 10 },
+        { 227, 49, 131, 81, 5 }, },
+      { { 87, 246, 164, 229, 1 },
+        { 205, 141, 26, 237, 6 },
+        { 138, 114, 86, 254, 10 },
+        { 107, 117, 139, 27, 3 }, },
+      { { 92, 5, 94, 2, 5 },
+        { 166, 75, 68, 176, 1 },
+        { 164, 7, 170, 3, 10 },
+        { 128, 210, 45, 38, 5 }, },
+      { { 94, 56, 204, 77, 0 },
+        { 235, 169, 4, 141, 8 },
+        { 11, 35, 49, 199, 10 },
+        { 27, 18, 9, 93, 7 }, },
+      { { 94, 101, 102, 31, 5 },
+        { 175, 111, 192, 165, 5 },
+        { 175, 134, 106, 103, 10 },
+        { 170, 80, 63, 111, 5 }, },
+      { { 90, 165, 235, 123, 5 },
+        { 55, 234, 214, 173, 5 },
+        { 173, 237, 122, 85, 10 },
+        { 171, 86, 181, 126, 12 }, },
+      { { 94, 173, 81, 224, 13 },
+        { 183, 10, 83, 185, 10 },
+        { 176, 120, 171, 87, 10 },
+        { 89, 220, 165, 14, 13 }, },
+      { { 88, 179, 133, 252, 1 },
+        { 95, 171, 154, 136, 2 },
+        { 131, 250, 28, 209, 10 },
+        { 65, 21, 157, 95, 10 }, },
+      { { 90, 197, 248, 110, 0 },
+        { 42, 174, 22, 185, 5 },
+        { 7, 97, 250, 53, 10 },
+        { 169, 214, 135, 85, 4 }, },
+      { { 88, 241, 107, 96, 0 },
+        { 115, 78, 22, 136, 4 },
+        { 0, 109, 104, 241, 10 },
+        { 33, 22, 135, 44, 14 }, },
+      { { 91, 48, 177, 32, 8 },
+        { 83, 136, 3, 209, 4 },
+        { 16, 72, 208, 205, 10 },
+        { 40, 188, 1, 28, 10 }, },
+      { { 95, 52, 239, 231, 11 },
+        { 255, 217, 7, 237, 7 },
+        { 222, 127, 114, 207, 10 },
+        { 235, 126, 9, 191, 15 }, },
+      { { 89, 64, 115, 102, 9 },
+        { 62, 76, 3, 216, 5 },
+        { 150, 108, 224, 41, 10 },
+        { 161, 188, 3, 39, 12 }, },
+      { { 93, 105, 19, 173, 1 },
+        { 159, 110, 2, 212, 10 },
+        { 139, 92, 137, 107, 10 },
+        { 82, 180, 7, 111, 9 }, },
+      { { 89, 82, 185, 227, 11 },
+        { 86, 156, 15, 220, 7 },
+        { 220, 121, 212, 169, 10 },
+        { 227, 191, 3, 150, 10 }, },
+      { { 93, 70, 244, 172, 2 },
+        { 170, 189, 10, 240, 6 },
+        { 67, 82, 246, 43, 10 },
+        { 96, 245, 11, 213, 5 }, },
+      { { 95, 128, 157, 46, 8 },
+        { 154, 169, 23, 209, 1 },
+        { 23, 75, 144, 31, 10 },
+        { 136, 190, 137, 85, 9 }, },
+      { { 95, 224, 251, 80, 14 },
+        { 179, 220, 213, 217, 4 },
+        { 112, 173, 240, 127, 10 },
+        { 41, 186, 179, 188, 13 }, },
+      { { 95, 235, 211, 215, 0 },
+        { 187, 206, 152, 221, 11 },
+        { 14, 188, 189, 127, 10 },
+        { 219, 177, 151, 61, 13 }, },
+      { { 100, 105, 134, 115, 5 },
+        { 133, 199, 226, 140, 9 },
+        { 172, 230, 25, 98, 6 },
+        { 147, 20, 126, 58, 1 }, },
+      { { 96, 188, 232, 205, 8 },
+        { 105, 160, 53, 172, 14 },
+        { 27, 49, 115, 208, 6 },
+        { 115, 90, 192, 89, 6 }, },
+      { { 100, 158, 227, 5, 6 },
+        { 248, 208, 120, 164, 12 },
+        { 106, 12, 119, 146, 6 },
+        { 50, 81, 224, 177, 15 }, },
+      { { 98, 212, 165, 37, 13 },
+        { 92, 133, 115, 165, 4 },
+        { 186, 74, 82, 180, 6 },
+        { 42, 92, 234, 19, 10 }, },
+      { { 98, 246, 143, 142, 3 },
+        { 93, 245, 60, 161, 3 },
+        { 199, 31, 22, 244, 6 },
+        { 200, 83, 202, 251, 10 }, },
+      { { 101, 96, 72, 36, 7 },
+        { 173, 20, 102, 192, 0 },
+        { 226, 65, 32, 106, 6 },
+        { 0, 54, 98, 139, 5 }, },
+      { { 99, 180, 12, 145, 8 },
+        { 65, 1, 181, 229, 2 },
+        { 24, 147, 2, 220, 6 },
+        { 74, 122, 216, 8, 2 }, },
+      { { 99, 159, 233, 153, 13 },
+        { 116, 162, 253, 229, 14 },
+        { 185, 153, 127, 156, 6 },
+        { 122, 123, 244, 82, 14 }, },
+      { { 101, 237, 229, 156, 7 },
+        { 189, 183, 240, 224, 14 },
+        { 227, 154, 123, 122, 6 },
+        { 112, 112, 254, 219, 13 }, },
+      { { 103, 235, 231, 112, 4 },
+        { 177, 199, 250, 201, 12 },
+        { 32, 238, 125, 126, 6 },
+        { 57, 53, 254, 56, 13 }, },
+      { { 106, 1, 200, 157, 4 },
+        { 42, 162, 228, 133, 2 },
+        { 43, 145, 56, 5, 6 },
+        { 74, 18, 116, 85, 4 }, },
+      { { 104, 61, 242, 11, 0 },
+        { 99, 226, 32, 180, 13 },
+        { 13, 4, 251, 193, 6 },
+        { 178, 208, 68, 124, 6 }, },
+      { { 104, 24, 102, 125, 13 },
+        { 110, 97, 227, 140, 12 },
+        { 187, 230, 97, 129, 6 },
+        { 51, 28, 120, 103, 6 }, },
+      { { 108, 84, 97, 80, 15 },
+        { 246, 20, 225, 168, 4 },
+        { 240, 168, 98, 163, 6 },
+        { 33, 88, 114, 134, 15 }, },
+      { { 104, 75, 24, 245, 13 },
+        { 14, 6, 239, 156, 10 },
+        { 186, 241, 141, 33, 6 },
+        { 83, 159, 118, 7, 0 }, },
+      { { 104, 79, 21, 129, 0 },
+        { 18, 7, 40, 180, 10 },
+        { 8, 26, 143, 33, 6 },
+        { 82, 209, 78, 4, 8 }, },
+      { { 110, 110, 244, 89, 0 },
+        { 163, 165, 168, 189, 12 },
+        { 9, 162, 247, 103, 6 },
+        { 59, 209, 90, 92, 5 }, },
+      { { 110, 152, 128, 38, 5 },
+        { 206, 128, 114, 129, 9 },
+        { 166, 64, 17, 151, 6 },
+        { 152, 20, 224, 23, 3 }, },
+      { { 110, 144, 99, 51, 3 },
+        { 246, 80, 178, 133, 5 },
+        { 204, 204, 96, 151, 6 },
+        { 170, 20, 208, 166, 15 }, },
+      { { 110, 241, 228, 10, 7 },
+        { 231, 183, 112, 129, 5 },
+        { 229, 2, 120, 247, 6 },
+        { 168, 16, 238, 222, 7 }, },
+      { { 108, 195, 36, 252, 0 },
+        { 138, 39, 186, 136, 6 },
+        { 3, 242, 76, 51, 6 },
+        { 97, 21, 222, 69, 1 }, },
+      { { 105, 0, 81, 91, 15 },
+        { 54, 48, 225, 220, 1 },
+        { 253, 168, 160, 9, 6 },
+        { 131, 184, 112, 198, 12 }, },
+      { { 107, 64, 14, 250, 12 },
+        { 2, 101, 231, 201, 3 },
+        { 53, 247, 0, 45, 6 },
+        { 201, 62, 122, 100, 0 }, },
+      { { 107, 124, 181, 68, 7 },
+        { 95, 149, 96, 249, 12 },
+        { 226, 42, 211, 237, 6 },
+        { 57, 240, 106, 159, 10 }, },
+      { { 105, 172, 245, 202, 2 },
+        { 51, 177, 48, 248, 15 },
+        { 69, 58, 243, 89, 6 },
+        { 241, 240, 200, 220, 12 }, },
+      { { 105, 167, 102, 247, 12 },
+        { 43, 67, 251, 236, 7 },
+        { 62, 246, 110, 89, 6 },
+        { 227, 125, 252, 45, 4 }, },
+      { { 109, 235, 50, 140, 11 },
+        { 143, 118, 57, 208, 14 },
+        { 211, 20, 205, 123, 6 },
+        { 112, 185, 198, 239, 1 }, },
+      { { 116, 23, 252, 110, 12 },
+        { 232, 171, 111, 184, 5 },
+        { 55, 99, 254, 130, 14 },
+        { 161, 223, 109, 81, 7 }, },
+      { { 112, 97, 170, 185, 4 },
+        { 1, 238, 230, 132, 6 },
+        { 41, 213, 88, 96, 14 },
+        { 98, 22, 119, 120, 0 }, },
+      { { 116, 67, 17, 82, 1 },
+        { 148, 14, 168, 152, 1 },
+        { 132, 168, 140, 34, 14 },
+        { 129, 145, 87, 2, 9 }, },
+      { { 112, 185, 187, 138, 9 },
+        { 85, 234, 53, 144, 15 },
+        { 149, 29, 217, 208, 14 },
+        { 240, 154, 197, 122, 10 }, },
+      { { 118, 148, 62, 229, 4 },
+        { 200, 73, 118, 189, 6 },
+        { 42, 119, 194, 150, 14 },
+        { 107, 214, 233, 33, 3 }, },
+      { { 118, 188, 96, 18, 9 },
+        { 229, 8, 177, 161, 13 },
+        { 148, 128, 99, 214, 14 },
+        { 184, 88, 209, 10, 7 }, },
+      { { 112, 155, 7, 165, 4 },
+        { 88, 75, 122, 132, 10 },
+        { 42, 94, 13, 144, 14 },
+        { 82, 21, 237, 33, 10 }, },
+      { { 116, 139, 191, 1, 3 },
+        { 148, 219, 60, 148, 12 },
+        { 200, 15, 221, 18, 14 },
+        { 50, 147, 205, 178, 9 }, },
+      { { 114, 248, 93, 79, 11 },
+        { 125, 61, 53, 157, 9 },
+        { 223, 43, 161, 244, 14 },
+        { 155, 154, 203, 203, 14 }, },
+      { { 118, 211, 218, 167, 15 },
+        { 236, 222, 127, 149, 3 },
+        { 254, 85, 188, 182, 14 },
+        { 202, 159, 231, 179, 7 }, },
+      { { 117, 36, 208, 249, 9 },
+        { 165, 168, 163, 252, 2 },
+        { 153, 240, 178, 74, 14 },
+        { 67, 252, 81, 90, 5 }, },
+      { { 117, 60, 188, 48, 6 },
+        { 193, 153, 230, 240, 12 },
+        { 96, 195, 211, 202, 14 },
+        { 48, 246, 121, 152, 3 }, },
+      { { 119, 3, 201, 213, 15 },
+        { 188, 154, 237, 205, 2 },
+        { 250, 185, 60, 14, 14 },
+        { 75, 59, 117, 147, 13 }, },
+      { { 113, 69, 59, 42, 5 },
+        { 20, 110, 102, 240, 5 },
+        { 165, 77, 202, 40, 14 },
+        { 160, 246, 103, 98, 8 }, },
+      { { 115, 108, 25, 223, 1 },
+        { 29, 44, 164, 253, 11 },
+        { 143, 185, 131, 108, 14 },
+        { 219, 242, 83, 75, 8 }, },
+      { { 113, 72, 238, 44, 10 },
+        { 40, 253, 39, 192, 12 },
+        { 83, 71, 113, 40, 14 },
+        { 48, 62, 75, 241, 4 }, },
+      { { 115, 111, 34, 124, 0 },
+        { 9, 110, 170, 233, 12 },
+        { 3, 228, 79, 108, 14 },
+        { 57, 117, 87, 105, 0 }, },
+      { { 115, 145, 99, 174, 14 },
+        { 120, 122, 115, 193, 7 },
+        { 119, 92, 104, 156, 14 },
+        { 232, 60, 229, 225, 14 }, },
+      { { 117, 131, 158, 142, 9 },
+        { 140, 235, 61, 208, 3 },
+        { 151, 23, 156, 26, 14 },
+        { 192, 187, 205, 115, 1 }, },
+      { { 119, 191, 100, 123, 6 },
+        { 225, 59, 250, 237, 13 },
+        { 109, 226, 111, 222, 14 },
+        { 187, 117, 253, 200, 7 }, },
+      { { 115, 229, 189, 18, 10 },
+        { 17, 159, 181, 241, 5 },
+        { 84, 139, 218, 124, 14 },
+        { 168, 250, 223, 152, 8 }, },
+      { { 115, 207, 104, 128, 3 },
+        { 36, 30, 60, 225, 14 },
+        { 192, 17, 111, 60, 14 },
+        { 120, 115, 199, 130, 4 }, },
+      { { 113, 247, 74, 10, 0 },
+        { 97, 110, 60, 224, 1 },
+        { 5, 5, 46, 248, 14 },
+        { 128, 115, 199, 104, 6 }, },
+      { { 120, 45, 207, 39, 6 },
+        { 59, 219, 102, 164, 9 },
+        { 110, 79, 59, 65, 14 },
+        { 146, 86, 109, 189, 12 }, },
+      { { 124, 2, 58, 157, 7 },
+        { 142, 120, 236, 148, 6 },
+        { 235, 149, 196, 3, 14 },
+        { 98, 147, 113, 231, 1 }, },
+      { { 122, 92, 206, 58, 4 },
+        { 98, 237, 230, 161, 9 },
+        { 37, 199, 51, 165, 14 },
+        { 152, 86, 123, 116, 6 }, },
+      { { 122, 114, 16, 7, 7 },
+        { 79, 28, 104, 149, 1 },
+        { 238, 0, 132, 229, 14 },
+        { 138, 145, 99, 143, 2 }, },
+      { { 126, 178, 36, 208, 11 },
+        { 199, 25, 185, 137, 6 },
+        { 208, 178, 68, 215, 14 },
+        { 105, 25, 217, 142, 3 }, },
+      { { 120, 253, 197, 213, 2 },
+        { 123, 159, 176, 172, 10 },
+        { 74, 186, 59, 241, 14 },
+        { 83, 80, 223, 157, 14 }, },
+      { { 126, 232, 117, 158, 9 },
+        { 191, 45, 177, 145, 15 },
+        { 151, 154, 225, 119, 14 },
+        { 248, 152, 219, 79, 13 }, },
+      { { 123, 28, 43, 68, 14 },
+        { 90, 88, 101, 233, 12 },
+        { 114, 45, 67, 141, 14 },
+        { 57, 122, 97, 165, 10 }, },
+      { { 127, 4, 160, 250, 2 },
+        { 130, 184, 162, 233, 7 },
+        { 69, 240, 82, 15, 14 },
+        { 233, 116, 81, 212, 1 }, },
+      { { 123, 39, 78, 235, 3 },
+        { 39, 123, 46, 237, 3 },
+        { 205, 119, 46, 77, 14 },
+        { 203, 119, 77, 238, 4 }, },
+      { { 125, 38, 127, 122, 1 },
+        { 183, 105, 174, 248, 5 },
+        { 133, 239, 230, 75, 14 },
+        { 161, 247, 89, 110, 13 }, },
+      { { 127, 50, 169, 94, 10 },
+        { 219, 184, 173, 201, 5 },
+        { 87, 169, 84, 207, 14 },
+        { 169, 59, 81, 221, 11 }, },
+      { { 121, 180, 170, 170, 7 },
+        { 71, 248, 118, 224, 7 },
+        { 229, 85, 82, 217, 14 },
+        { 224, 118, 225, 254, 2 }, },
+      { { 125, 176, 215, 37, 3 },
+        { 255, 217, 50, 212, 0 },
+        { 202, 78, 176, 219, 14 },
+        { 2, 180, 201, 191, 15 }, },
+      { { 127, 147, 79, 12, 2 },
+        { 250, 123, 60, 193, 0 },
+        { 67, 15, 44, 159, 14 },
+        { 8, 51, 205, 229, 15 }, },
+      { { 125, 252, 16, 66, 2 },
+        { 195, 28, 48, 248, 9 },
+        { 68, 32, 131, 251, 14 },
+        { 145, 240, 195, 140, 3 }, },
+      { { 125, 213, 216, 211, 15 },
+        { 230, 158, 245, 252, 3 },
+        { 252, 177, 186, 187, 14 },
+        { 195, 250, 247, 150, 7 }, },
+      { { 128, 56, 32, 103, 11 },
+        { 77, 16, 3, 14, 13 },
+        { 222, 96, 65, 192, 1 },
+        { 183, 12, 0, 139, 2 }, },
+      { { 132, 17, 185, 214, 3 },
+        { 220, 146, 132, 26, 7 },
+        { 198, 185, 216, 130, 1 },
+        { 229, 130, 20, 147, 11 }, },
+      { { 128, 3, 252, 100, 10 },
+        { 40, 147, 15, 26, 4 },
+        { 82, 99, 252, 0, 1 },
+        { 37, 143, 12, 145, 4 }, },
+      { { 130, 59, 15, 187, 10 },
+        { 81, 115, 143, 7, 11 },
+        { 93, 223, 13, 196, 1 },
+        { 222, 15, 28, 232, 10 }, },
+      { { 134, 42, 167, 117, 10 },
+        { 153, 209, 139, 15, 12 },
+        { 90, 238, 85, 70, 1 },
+        { 63, 13, 24, 185, 9 }, },
+      { { 132, 27, 89, 75, 7 },
+        { 244, 50, 76, 30, 9 },
+        { 237, 41, 173, 130, 1 },
+        { 151, 131, 36, 194, 15 }, },
+      { { 130, 68, 49, 200, 10 },
+        { 16, 52, 1, 59, 6 },
+        { 81, 56, 194, 36, 1 },
+        { 109, 200, 2, 192, 8 }, },
+      { { 130, 89, 216, 117, 3 },
+        { 108, 150, 134, 31, 8 },
+        { 202, 225, 185, 164, 1 },
+        { 31, 134, 22, 147, 6 }, },
+      { { 132, 72, 31, 220, 14 },
+        { 152, 117, 197, 26, 10 },
+        { 115, 191, 129, 34, 1 },
+        { 85, 138, 58, 225, 9 }, },
+      { { 130, 181, 229, 107, 4 },
+        { 113, 163, 82, 47, 5 },
+        { 45, 106, 122, 212, 1 },
+        { 175, 68, 172, 88, 14 }, },
+      { { 128, 183, 10, 183, 0 },
+        { 73, 66, 158, 38, 3 },
+        { 14, 213, 14, 208, 1 },
+        { 198, 71, 148, 41, 2 }, },
+      { { 134, 178, 80, 25, 10 },
+        { 225, 48, 153, 23, 0 },
+        { 89, 128, 164, 214, 1 },
+        { 14, 137, 144, 200, 7 }, },
+      { { 128, 204, 47, 123, 8 },
+        { 16, 101, 151, 46, 13 },
+        { 29, 239, 67, 48, 1 },
+        { 183, 78, 154, 96, 8 }, },
+      { { 134, 253, 182, 100, 8 },
+        { 201, 199, 19, 59, 12 },
+        { 18, 102, 219, 246, 1 },
+        { 61, 204, 142, 57, 3 }, },
+      { { 129, 121, 60, 62, 9 },
+        { 77, 39, 135, 82, 13 },
+        { 151, 195, 201, 232, 1 },
+        { 180, 174, 30, 75, 2 }, },
+      { { 133, 96, 132, 133, 11 },
+        { 141, 149, 1, 70, 2 },
+        { 218, 18, 16, 106, 1 },
+        { 70, 40, 10, 155, 1 }, },
+      { { 131, 98, 22, 146, 5 },
+        { 5, 69, 200, 83, 3 },
+        { 164, 150, 132, 108, 1 },
+        { 204, 161, 58, 42, 0 }, },
+      { { 131, 128, 229, 221, 15 },
+        { 60, 177, 209, 79, 6 },
+        { 251, 186, 112, 28, 1 },
+        { 111, 40, 184, 211, 12 }, },
+      { { 135, 160, 76, 203, 2 },
+        { 161, 49, 20, 79, 3 },
+        { 77, 51, 32, 94, 1 },
+        { 207, 34, 136, 200, 5 }, },
+      { { 135, 184, 138, 180, 13 },
+        { 205, 192, 215, 67, 10 },
+        { 178, 213, 17, 222, 1 },
+        { 92, 46, 176, 59, 3 }, },
+      { { 142, 2, 6, 56, 4 },
+        { 130, 97, 202, 3, 0 },
+        { 33, 198, 4, 7, 1 },
+        { 12, 5, 56, 100, 1 }, },
+      { { 140, 54, 125, 172, 7 },
+        { 255, 49, 78, 50, 6 },
+        { 227, 91, 230, 195, 1 },
+        { 100, 199, 40, 207, 15 }, },
+      { { 140, 65, 233, 44, 2 },
+        { 186, 182, 6, 2, 4 },
+        { 67, 73, 120, 35, 1 },
+        { 36, 6, 6, 213, 13 }, },
+      { { 140, 152, 59, 175, 12 },
+        { 218, 96, 87, 22, 15 },
+        { 63, 93, 193, 147, 1 },
+        { 246, 142, 160, 101, 11 }, },
+      { { 136, 244, 107, 79, 11 },
+        { 127, 116, 21, 46, 5 },
+        { 223, 45, 98, 241, 1 },
+        { 167, 74, 130, 239, 14 }, },
+      { { 143, 44, 197, 204, 4 },
+        { 187, 161, 64, 107, 10 },
+        { 35, 58, 51, 79, 1 },
+        { 93, 96, 40, 93, 13 }, },
+      { { 141, 55, 126, 115, 3 },
+        { 231, 83, 142, 126, 5 },
+        { 204, 231, 238, 203, 1 },
+        { 167, 231, 28, 174, 7 }, },
+      { { 139, 69, 79, 63, 7 },
+        { 62, 119, 198, 103, 1 },
+        { 239, 207, 42, 45, 1 },
+        { 142, 102, 62, 231, 12 }, },
+      { { 141, 86, 37, 150, 0 },
+        { 218, 5, 136, 98, 7 },
+        { 6, 154, 70, 171, 1 },
+        { 228, 97, 26, 5, 11 }, },
+      { { 139, 191, 24, 57, 2 },
+        { 67, 50, 158, 119, 8 },
+        { 73, 193, 143, 221, 1 },
+        { 30, 231, 148, 204, 2 }, },
+      { { 141, 166, 67, 9, 4 },
+        { 179, 96, 88, 102, 0 },
+        { 41, 12, 38, 91, 1 },
+        { 6, 97, 160, 108, 13 }, },
+      { { 141, 208, 202, 166, 8 },
+        { 234, 196, 23, 66, 3 },
+        { 22, 85, 48, 187, 1 },
+        { 196, 46, 130, 53, 7 }, },
+      { { 139, 246, 152, 79, 4 },
+        { 75, 164, 92, 127, 1 },
+        { 47, 33, 150, 253, 1 },
+        { 143, 227, 162, 93, 2 }, },
+      { { 144, 18, 153, 165, 4 },
+        { 88, 136, 78, 22, 2 },
+        { 42, 89, 148, 128, 9 },
+        { 70, 135, 33, 17, 10 }, },
+      { { 150, 46, 4, 135, 5 },
+        { 141, 9, 72, 39, 11 },
+        { 174, 18, 7, 70, 9 },
+        { 222, 65, 41, 11, 1 }, },
+      { { 146, 92, 163, 212, 0 },
+        { 88, 204, 128, 43, 14 },
+        { 2, 188, 83, 164, 9 },
+        { 125, 64, 19, 49, 10 }, },
+      { { 146, 133, 143, 119, 10 },
+        { 24, 219, 151, 47, 1 },
+        { 94, 239, 26, 20, 9 },
+        { 143, 78, 157, 177, 8 }, },
+      { { 148, 169, 61, 69, 10 },
+        { 153, 27, 21, 30, 12 },
+        { 90, 43, 201, 82, 9 },
+        { 55, 138, 141, 137, 9 }, },
+      { { 145, 32, 243, 51, 2 },
+        { 49, 216, 130, 86, 5 },
+        { 76, 204, 240, 72, 9 },
+        { 166, 164, 17, 184, 12 }, },
+      { { 145, 39, 109, 79, 3 },
+        { 61, 59, 12, 110, 5 },
+        { 207, 43, 110, 72, 9 },
+        { 167, 99, 13, 203, 12 }, },
+      { { 151, 51, 253, 233, 10 },
+        { 241, 187, 15, 95, 6 },
+        { 89, 123, 252, 206, 9 },
+        { 111, 175, 13, 216, 15 }, },
+      { { 151, 72, 243, 129, 3 },
+        { 180, 220, 0, 87, 14 },
+        { 200, 28, 241, 46, 9 },
+        { 126, 160, 3, 178, 13 }, },
+      { { 151, 159, 160, 6, 9 },
+        { 204, 138, 25, 99, 13 },
+        { 150, 0, 95, 158, 9 },
+        { 188, 105, 133, 19, 3 }, },
+      { { 147, 208, 63, 215, 12 },
+        { 88, 77, 213, 95, 7 },
+        { 62, 191, 192, 188, 9 },
+        { 239, 170, 187, 33, 10 }, },
+      { { 149, 252, 208, 110, 0 },
+        { 233, 172, 18, 122, 9 },
+        { 7, 96, 179, 250, 9 },
+        { 149, 228, 131, 89, 7 }, },
+      { { 147, 195, 178, 11, 1 },
+        { 4, 238, 24, 87, 5 },
+        { 141, 4, 220, 60, 9 },
+        { 174, 161, 135, 114, 0 }, },
+      { { 145, 195, 66, 1, 14 },
+        { 32, 94, 89, 70, 0 },
+        { 120, 4, 44, 56, 9 },
+        { 6, 41, 167, 160, 4 }, },
+      { { 158, 10, 212, 208, 9 },
+        { 166, 137, 137, 27, 10 },
+        { 144, 178, 181, 7, 9 },
+        { 93, 137, 25, 22, 5 }, },
+      { { 158, 62, 24, 70, 8 },
+        { 203, 8, 13, 59, 9 },
+        { 22, 33, 135, 199, 9 },
+        { 157, 203, 1, 13, 3 }, },
+      { { 154, 97, 122, 220, 9 },
+        { 47, 110, 133, 27, 6 },
+        { 147, 181, 232, 101, 9 },
+        { 109, 138, 23, 111, 4 }, },
+      { { 152, 200, 135, 101, 13 },
+        { 30, 205, 83, 14, 8 },
+        { 186, 110, 17, 49, 9 },
+        { 23, 12, 171, 55, 8 }, },
+      { { 152, 193, 223, 48, 9 },
+        { 54, 207, 151, 18, 0 },
+        { 144, 207, 184, 49, 9 },
+        { 4, 142, 159, 54, 12 }, },
+      { { 158, 249, 40, 250, 12 },
+        { 195, 46, 215, 11, 15 },
+        { 53, 241, 73, 247, 9 },
+        { 253, 14, 183, 76, 3 }, },
+      { { 158, 240, 171, 22, 1 },
+        { 223, 204, 148, 3, 5 },
+        { 134, 141, 80, 247, 9 },
+        { 172, 2, 147, 63, 11 }, },
+      { { 152, 251, 117, 9, 13 },
+        { 119, 47, 89, 22, 12 },
+        { 185, 10, 237, 241, 9 },
+        { 54, 137, 175, 78, 14 }, },
+      { { 159, 32, 1, 53, 4 },
+        { 155, 8, 194, 71, 0 },
+        { 42, 200, 0, 79, 9 },
+        { 14, 36, 49, 13, 9 }, },
+      { { 153, 18, 120, 7, 12 },
+        { 106, 8, 77, 86, 5 },
+        { 62, 1, 228, 137, 9 },
+        { 166, 171, 33, 5, 6 }, },
+      { { 155, 131, 245, 126, 11 },
+        { 62, 187, 155, 91, 5 },
+        { 215, 234, 252, 29, 9 },
+        { 173, 173, 157, 215, 12 }, },
+      { { 153, 249, 200, 173, 5 },
+        { 111, 174, 86, 70, 10 },
+        { 171, 81, 57, 249, 9 },
+        { 86, 38, 167, 95, 6 }, },
+      { { 157, 228, 46, 236, 2 },
+        { 139, 125, 22, 106, 6 },
+        { 67, 119, 66, 123, 9 },
+        { 101, 102, 139, 237, 1 }, },
+      { { 155, 219, 144, 210, 3 },
+        { 70, 158, 152, 91, 11 },
+        { 196, 176, 157, 189, 9 },
+        { 221, 161, 151, 150, 2 }, },
+      { { 159, 254, 132, 153, 15 },
+        { 199, 189, 217, 103, 10 },
+        { 249, 146, 23, 255, 9 },
+        { 94, 105, 187, 222, 3 }, },
+      { { 162, 66, 140, 215, 9 },
+        { 12, 133, 173, 15, 3 },
+        { 158, 179, 20, 36, 5 },
+        { 207, 11, 90, 19, 0 }, },
+      { { 164, 205, 25, 53, 7 },
+        { 156, 22, 246, 54, 8 },
+        { 234, 201, 139, 50, 5 },
+        { 22, 198, 246, 131, 9 }, },
+      { { 166, 213, 162, 25, 0 },
+        { 192, 230, 176, 39, 4 },
+        { 9, 132, 90, 182, 5 },
+        { 46, 64, 214, 112, 3 }, },
+      { { 160, 223, 192, 176, 6 },
+        { 96, 150, 250, 34, 10 },
+        { 96, 208, 63, 176, 5 },
+        { 84, 69, 246, 144, 6 }, },
+      { { 163, 49, 180, 144, 4 },
+        { 65, 131, 224, 83, 6 },
+        { 32, 146, 216, 204, 5 },
+        { 108, 160, 124, 24, 2 }, },
+      { { 167, 32, 134, 58, 15 },
+        { 133, 241, 227, 67, 1 },
+        { 245, 198, 16, 78, 5 },
+        { 140, 44, 120, 250, 1 }, },
+      { { 167, 56, 45, 40, 13 },
+        { 213, 33, 103, 67, 12 },
+        { 177, 75, 65, 206, 5 },
+        { 60, 46, 104, 74, 11 }, },
+      { { 163, 63, 204, 220, 14 },
+        { 105, 179, 237, 107, 10 },
+        { 115, 179, 63, 204, 5 },
+        { 93, 107, 124, 217, 6 }, },
+      { { 165, 62, 179, 132, 11 },
+        { 221, 208, 41, 114, 14 },
+        { 210, 28, 215, 202, 5 },
+        { 116, 233, 64, 187, 11 }, },
+      { { 161, 112, 26, 189, 7 },
+        { 77, 116, 230, 86, 2 },
+        { 235, 213, 128, 232, 5 },
+        { 70, 166, 114, 235, 2 }, },
+      { { 167, 103, 101, 55, 9 },
+        { 189, 7, 171, 103, 5 },
+        { 158, 202, 110, 110, 5 },
+        { 174, 109, 94, 11, 13 }, },
+      { { 165, 123, 102, 174, 4 },
+        { 233, 103, 106, 66, 15 },
+        { 39, 86, 109, 234, 5 },
+        { 244, 37, 110, 105, 7 }, },
+      { { 161, 213, 29, 147, 2 },
+        { 80, 23, 180, 118, 3 },
+        { 76, 155, 138, 184, 5 },
+        { 198, 226, 222, 128, 10 }, },
+      { { 163, 248, 233, 155, 14 },
+        { 113, 180, 245, 71, 15 },
+        { 125, 153, 113, 252, 5 },
+        { 254, 42, 242, 216, 14 }, },
+      { { 165, 211, 131, 218, 3 },
+        { 212, 246, 184, 74, 3 },
+        { 197, 188, 28, 186, 5 },
+        { 197, 33, 214, 242, 11 }, },
+      { { 165, 214, 235, 188, 6 },
+        { 248, 244, 254, 98, 6 },
+        { 99, 221, 118, 186, 5 },
+        { 100, 103, 242, 241, 15 }, },
+      { { 170, 38, 227, 151, 9 },
+        { 63, 192, 169, 39, 7 },
+        { 158, 156, 118, 69, 5 },
+        { 238, 73, 80, 63, 12 }, },
+      { { 174, 30, 201, 63, 12 },
+        { 250, 160, 239, 39, 9 },
+        { 63, 201, 55, 135, 5 },
+        { 158, 79, 112, 85, 15 }, },
+      { { 172, 119, 184, 237, 2 },
+        { 203, 182, 46, 62, 6 },
+        { 75, 113, 222, 227, 5 },
+        { 103, 199, 70, 221, 3 }, },
+      { { 170, 169, 238, 77, 15 },
+        { 47, 243, 117, 15, 12 },
+        { 251, 39, 121, 85, 5 },
+        { 63, 10, 236, 255, 4 }, },
+      { { 170, 128, 121, 170, 6 },
+        { 50, 48, 118, 19, 7 },
+        { 101, 89, 224, 21, 5 },
+        { 236, 134, 224, 196, 12 }, },
+      { { 174, 194, 96, 202, 1 },
+        { 166, 36, 56, 11, 7 },
+        { 133, 48, 100, 55, 5 },
+        { 237, 1, 194, 70, 5 }, },
+      { { 169, 58, 152, 98, 11 },
+        { 71, 144, 47, 90, 9 },
+        { 212, 97, 149, 201, 5 },
+        { 149, 175, 64, 158, 2 }, },
+      { { 171, 18, 81, 200, 12 },
+        { 114, 32, 105, 91, 2 },
+        { 49, 56, 164, 141, 5 },
+        { 77, 169, 96, 68, 14 }, },
+      { { 173, 102, 219, 216, 13 },
+        { 183, 228, 237, 122, 2 },
+        { 177, 189, 182, 107, 5 },
+        { 69, 235, 114, 126, 13 }, },
+      { { 173, 82, 221, 74, 1 },
+        { 246, 165, 44, 90, 1 },
+        { 133, 43, 180, 171, 5 },
+        { 133, 163, 74, 86, 15 }, },
+      { { 169, 182, 113, 16, 8 },
+        { 115, 0, 185, 114, 4 },
+        { 16, 136, 230, 217, 5 },
+        { 36, 233, 208, 12, 14 }, },
+      { { 173, 186, 226, 53, 0 },
+        { 235, 192, 186, 70, 12 },
+        { 10, 196, 117, 219, 5 },
+        { 54, 37, 208, 61, 7 }, },
+      { { 173, 151, 65, 223, 12 },
+        { 250, 34, 249, 110, 3 },
+        { 63, 184, 46, 155, 5 },
+        { 199, 105, 244, 69, 15 }, },
+      { { 171, 243, 182, 44, 7 },
+        { 79, 247, 122, 83, 4 },
+        { 227, 70, 220, 253, 5 },
+        { 44, 165, 238, 255, 2 }, },
+      { { 182, 34, 108, 113, 12 },
+        { 161, 9, 239, 15, 4 },
+        { 56, 227, 100, 70, 13 },
+        { 47, 15, 121, 8, 5 }, },
+      { { 180, 30, 37, 122, 7 },
+        { 212, 57, 234, 42, 13 },
+        { 229, 234, 71, 130, 13 },
+        { 181, 69, 121, 194, 11 }, },
+      { { 182, 55, 195, 138, 3 },
+        { 245, 250, 40, 35, 3 },
+        { 197, 28, 62, 198, 13 },
+        { 204, 65, 69, 250, 15 }, },
+      { { 176, 76, 212, 55, 0 },
+        { 40, 141, 162, 54, 9 },
+        { 14, 194, 179, 32, 13 },
+        { 150, 196, 91, 17, 4 }, },
+      { { 178, 127, 139, 5, 3 },
+        { 93, 222, 44, 39, 8 },
+        { 202, 13, 31, 228, 13 },
+        { 30, 67, 71, 187, 10 }, },
+      { { 176, 173, 216, 34, 5 },
+        { 37, 138, 118, 50, 9 },
+        { 164, 65, 187, 80, 13 },
+        { 148, 198, 229, 26, 4 }, },
+      { { 180, 155, 130, 43, 11 },
+        { 196, 250, 59, 6, 9 },
+        { 221, 68, 29, 146, 13 },
+        { 150, 13, 197, 242, 3 }, },
+      { { 176, 211, 78, 194, 3 },
+        { 100, 95, 60, 10, 3 },
+        { 196, 55, 44, 176, 13 },
+        { 197, 3, 207, 162, 6 }, },
+      { { 177, 61, 126, 195, 14 },
+        { 97, 91, 101, 126, 15 },
+        { 124, 55, 235, 200, 13 },
+        { 247, 234, 109, 168, 6 }, },
+      { { 177, 6, 164, 99, 14 },
+        { 0, 153, 107, 110, 5 },
+        { 124, 98, 86, 8, 13 },
+        { 167, 109, 105, 144, 0 }, },
+      { { 179, 43, 116, 63, 14 },
+        { 41, 59, 235, 87, 13 },
+        { 127, 194, 237, 76, 13 },
+        { 190, 173, 125, 201, 4 }, },
+      { { 183, 31, 214, 70, 15 },
+        { 236, 219, 105, 123, 9 },
+        { 246, 38, 191, 142, 13 },
+        { 157, 233, 109, 179, 7 }, },
+      { { 177, 110, 241, 244, 5 },
+        { 61, 140, 234, 122, 14 },
+        { 162, 248, 247, 104, 13 },
+        { 117, 229, 115, 27, 12 }, },
+      { { 177, 126, 83, 138, 14 },
+        { 113, 124, 105, 114, 11 },
+        { 117, 28, 167, 232, 13 },
+        { 212, 233, 99, 232, 14 }, },
+      { { 183, 98, 223, 55, 7 },
+        { 189, 221, 238, 87, 1 },
+        { 238, 207, 180, 110, 13 },
+        { 142, 167, 123, 187, 13 }, },
+      { { 177, 169, 248, 148, 9 },
+        { 45, 138, 181, 82, 14 },
+        { 146, 145, 249, 88, 13 },
+        { 116, 170, 213, 27, 4 }, },
+      { { 179, 183, 217, 210, 4 },
+        { 113, 138, 252, 123, 3 },
+        { 36, 185, 190, 220, 13 },
+        { 205, 227, 245, 24, 14 }, },
+      { { 179, 238, 187, 76, 6 },
+        { 25, 252, 124, 123, 12 },
+        { 99, 45, 215, 124, 13 },
+        { 61, 227, 227, 249, 8 }, },
+      { { 184, 44, 165, 82, 4 },
+        { 19, 137, 224, 42, 13 },
+        { 36, 170, 83, 65, 13 },
+        { 181, 64, 121, 28, 8 }, },
+      { { 184, 20, 13, 235, 15 },
+        { 86, 57, 103, 46, 3 },
+        { 253, 123, 2, 129, 13 },
+        { 199, 78, 105, 198, 10 }, },
+      { { 188, 25, 220, 199, 7 },
+        { 238, 155, 100, 30, 11 },
+        { 238, 51, 185, 131, 13 },
+        { 215, 130, 109, 151, 7 }, },
+      { { 188, 84, 38, 185, 6 },
+        { 194, 125, 226, 38, 6 },
+        { 105, 214, 66, 163, 13 },
+        { 102, 68, 123, 228, 3 }, },
+      { { 190, 103, 55, 196, 5 },
+        { 159, 79, 104, 59, 6 },
+        { 162, 62, 206, 103, 13 },
+        { 109, 193, 111, 47, 9 }, },
+      { { 184, 250, 232, 211, 5 },
+        { 103, 140, 252, 14, 15 },
+        { 172, 177, 117, 241, 13 },
+        { 247, 3, 243, 30, 6 }, },
+      { { 190, 194, 26, 55, 8 },
+        { 138, 76, 191, 23, 1 },
+        { 30, 197, 132, 55, 13 },
+        { 142, 143, 211, 37, 1 }, },
+      { { 187, 24, 207, 164, 11 },
+        { 126, 217, 39, 67, 10 },
+        { 210, 95, 49, 141, 13 },
+        { 92, 46, 73, 183, 14 }, },
+      { { 189, 1, 126, 246, 13 },
+        { 174, 75, 231, 90, 7 },
+        { 182, 247, 232, 11, 13 },
+        { 229, 174, 125, 39, 5 }, },
+      { { 189, 34, 47, 210, 7 },
+        { 151, 89, 236, 74, 7 },
+        { 228, 191, 68, 75, 13 },
+        { 229, 35, 121, 174, 9 }, },
+      { { 189, 2, 85, 133, 5 },
+        { 190, 9, 104, 86, 2 },
+        { 170, 26, 164, 11, 13 },
+        { 70, 161, 105, 7, 13 }, },
+      { { 185, 114, 78, 96, 5 },
+        { 103, 77, 110, 74, 0 },
+        { 160, 103, 36, 233, 13 },
+        { 5, 39, 107, 46, 6 }, },
+      { { 189, 119, 92, 22, 15 },
+        { 239, 31, 237, 114, 1 },
+        { 246, 131, 174, 235, 13 },
+        { 132, 235, 127, 143, 7 }, },
+      { { 185, 136, 172, 46, 1 },
+        { 14, 169, 54, 66, 13 },
+        { 135, 67, 81, 25, 13 },
+        { 180, 38, 201, 87, 0 }, },
+      { { 191, 160, 38, 103, 5 },
+        { 143, 73, 114, 79, 5 },
+        { 174, 102, 64, 95, 13 },
+        { 175, 36, 233, 47, 1 }, },
+      { { 185, 130, 150, 168, 6 },
+        { 2, 249, 122, 82, 2 },
+        { 97, 86, 148, 25, 13 },
+        { 68, 165, 233, 244, 0 }, },
+      { { 189, 135, 23, 24, 10 },
+        { 146, 123, 185, 114, 0 },
+        { 81, 142, 142, 27, 13 },
+        { 4, 233, 221, 228, 9 }, },
+      { { 191, 190, 239, 45, 7 },
+        { 255, 249, 126, 103, 12 },
+        { 235, 79, 119, 223, 13 },
+        { 62, 103, 233, 255, 15 }, },
+      { { 189, 250, 159, 0, 7 },
+        { 215, 221, 124, 82, 8 },
+        { 224, 15, 149, 251, 13 },
+        { 20, 163, 235, 190, 11 }, },
+      { { 194, 112, 53, 187, 8 },
+        { 81, 37, 131, 151, 7 },
+        { 29, 218, 192, 228, 3 },
+        { 238, 156, 26, 72, 10 }, },
+      { { 196, 108, 5, 172, 13 },
+        { 157, 37, 67, 162, 10 },
+        { 179, 90, 3, 98, 3 },
+        { 84, 92, 42, 75, 9 }, },
+      { { 196, 121, 84, 220, 3 },
+        { 237, 55, 128, 154, 10 },
+        { 195, 178, 169, 226, 3 },
+        { 85, 144, 30, 203, 7 }, },
+      { { 194, 106, 81, 13, 8 },
+        { 57, 36, 9, 151, 8 },
+        { 27, 8, 165, 100, 3 },
+        { 30, 153, 2, 73, 12 }, },
+      { { 198, 164, 159, 104, 4 },
+        { 145, 225, 86, 187, 0 },
+        { 33, 111, 146, 86, 3 },
+        { 13, 214, 168, 120, 9 }, },
+      { { 192, 158, 44, 235, 4 },
+        { 64, 33, 94, 174, 15 },
+        { 45, 115, 71, 144, 3 },
+        { 247, 87, 168, 64, 2 }, },
+      { { 198, 146, 33, 73, 13 },
+        { 212, 32, 89, 143, 4 },
+        { 185, 40, 68, 150, 3 },
+        { 47, 25, 160, 66, 11 }, },
+      { { 196, 186, 131, 207, 8 },
+        { 217, 224, 25, 142, 11 },
+        { 31, 60, 21, 210, 3 },
+        { 215, 25, 128, 121, 11 }, },
+      { { 198, 231, 133, 67, 11 },
+        { 149, 151, 25, 175, 1 },
+        { 220, 42, 30, 118, 3 },
+        { 143, 89, 142, 154, 9 }, },
+      { { 198, 215, 175, 70, 4 },
+        { 216, 199, 92, 171, 5 },
+        { 38, 47, 94, 182, 3 },
+        { 173, 83, 174, 49, 11 }, },
+      { { 197, 54, 85, 77, 11 },
+        { 253, 49, 9, 254, 0 },
+        { 219, 42, 166, 202, 3 },
+        { 7, 249, 8, 203, 15 }, },
+      { { 195, 147, 255, 13, 7 },
+        { 124, 243, 92, 215, 4 },
+        { 235, 15, 252, 156, 3 },
+        { 46, 179, 172, 243, 14 }, },
+      { { 193, 245, 112, 165, 10 },
+        { 105, 22, 19, 246, 6 },
+        { 90, 80, 234, 248, 3 },
+        { 102, 252, 134, 137, 6 }, },
+      { { 204, 57, 113, 197, 0 },
+        { 251, 2, 0, 158, 14 },
+        { 10, 56, 233, 195, 3 },
+        { 119, 144, 4, 13, 15 }, },
+      { { 200, 2, 137, 73, 2 },
+        { 18, 176, 12, 142, 0 },
+        { 73, 41, 20, 1, 3 },
+        { 7, 19, 0, 212, 8 }, },
+      { { 200, 124, 100, 74, 5 },
+        { 103, 37, 64, 170, 13 },
+        { 165, 34, 99, 225, 3 },
+        { 181, 80, 42, 78, 6 }, },
+      { { 202, 103, 225, 13, 7 },
+        { 63, 182, 72, 167, 4 },
+        { 235, 8, 126, 101, 3 },
+        { 46, 81, 38, 223, 12 }, },
+      { { 200, 153, 231, 66, 2 },
+        { 114, 211, 16, 138, 13 },
+        { 68, 46, 121, 145, 3 },
+        { 181, 16, 140, 180, 14 }, },
+      { { 200, 170, 178, 16, 5 },
+        { 7, 192, 216, 146, 12 },
+        { 160, 132, 213, 81, 3 },
+        { 52, 145, 176, 62, 0 }, },
+      { { 204, 166, 213, 159, 3 },
+        { 191, 177, 152, 182, 3 },
+        { 207, 154, 182, 83, 3 },
+        { 198, 209, 152, 223, 13 }, },
+      { { 202, 229, 134, 251, 14 },
+        { 3, 247, 211, 175, 3 },
+        { 125, 246, 26, 117, 3 },
+        { 207, 92, 190, 252, 0 }, },
+      { { 202, 217, 124, 49, 15 },
+        { 102, 23, 215, 151, 12 },
+        { 248, 195, 233, 181, 3 },
+        { 62, 158, 190, 134, 6 }, },
+      { { 206, 228, 202, 14, 6 },
+        { 171, 244, 84, 163, 1 },
+        { 103, 5, 50, 119, 3 },
+        { 140, 82, 162, 253, 5 }, },
+      { { 203, 45, 164, 50, 12 },
+        { 3, 131, 195, 227, 13 },
+        { 52, 194, 91, 77, 3 },
+        { 188, 124, 60, 28, 0 }, },
+      { { 203, 87, 214, 130, 2 },
+        { 98, 215, 8, 243, 3 },
+        { 68, 22, 190, 173, 3 },
+        { 204, 241, 14, 180, 6 }, },
+      { { 201, 144, 33, 177, 0 },
+        { 82, 0, 146, 198, 6 },
+        { 8, 216, 64, 153, 3 },
+        { 102, 52, 144, 4, 10 }, },
+      { { 201, 130, 95, 176, 10 },
+        { 50, 81, 159, 210, 2 },
+        { 80, 223, 164, 25, 3 },
+        { 68, 191, 152, 164, 12 }, },
+      { { 203, 158, 212, 36, 7 },
+        { 110, 145, 90, 243, 8 },
+        { 226, 66, 183, 157, 3 },
+        { 28, 245, 168, 151, 6 }, },
+      { { 205, 134, 171, 157, 13 },
+        { 158, 224, 221, 230, 6 },
+        { 187, 157, 86, 27, 3 },
+        { 102, 123, 176, 119, 9 }, },
+      { { 201, 201, 176, 119, 5 },
+        { 14, 134, 210, 222, 13 },
+        { 174, 224, 217, 57, 3 },
+        { 183, 180, 182, 23, 0 }, },
+      { { 201, 250, 31, 99, 2 },
+        { 83, 85, 30, 222, 9 },
+        { 76, 111, 133, 249, 3 },
+        { 151, 183, 138, 172, 10 }, },
+      { { 203, 247, 64, 6, 9 },
+        { 111, 6, 25, 227, 1 },
+        { 150, 0, 46, 253, 3 },
+        { 140, 121, 134, 15, 6 }, },
+      { { 205, 218, 13, 28, 15 },
+        { 222, 53, 221, 194, 8 },
+        { 243, 139, 5, 187, 3 },
+        { 20, 59, 186, 199, 11 }, },
+      { { 208, 11, 130, 83, 15 },
+        { 4, 218, 201, 142, 9 },
+        { 252, 164, 29, 0, 11 },
+        { 151, 25, 53, 178, 0 }, },
+      { { 212, 59, 207, 214, 15 },
+        { 253, 219, 205, 138, 11 },
+        { 246, 191, 61, 194, 11 },
+        { 213, 27, 61, 187, 15 }, },
+      { { 214, 98, 171, 209, 11 },
+        { 149, 220, 141, 143, 6 },
+        { 216, 189, 84, 102, 11 },
+        { 111, 27, 19, 186, 9 }, },
+      { { 212, 102, 200, 58, 15 },
+        { 165, 188, 207, 162, 1 },
+        { 245, 193, 54, 98, 11 },
+        { 132, 95, 51, 218, 5 }, },
+      { { 209, 32, 28, 120, 10 },
+        { 1, 57, 135, 218, 0 },
+        { 81, 227, 128, 72, 11 },
+        { 5, 190, 25, 200, 0 }, },
+      { { 211, 57, 65, 195, 9 },
+        { 117, 10, 1, 207, 11 },
+        { 156, 56, 41, 204, 11 },
+        { 223, 56, 5, 10, 14 }, },
+      { { 209, 7, 160, 253, 4 },
+        { 8, 170, 202, 238, 6 },
+        { 43, 240, 94, 8, 11 },
+        { 103, 117, 53, 81, 0 }, },
+      { { 209, 149, 58, 14, 2 },
+        { 72, 122, 20, 242, 5 },
+        { 71, 5, 202, 152, 11 },
+        { 164, 242, 133, 225, 2 }, },
+      { { 215, 189, 66, 29, 13 },
+        { 237, 106, 209, 231, 8 },
+        { 187, 132, 43, 222, 11 },
+        { 30, 120, 181, 107, 7 }, },
+      { { 215, 192, 166, 80, 13 },
+        { 132, 205, 209, 203, 4 },
+        { 176, 166, 80, 62, 11 },
+        { 45, 56, 187, 50, 1 }, },
+      { { 215, 229, 141, 245, 12 },
+        { 153, 143, 215, 239, 2 },
+        { 58, 251, 26, 126, 11 },
+        { 79, 126, 191, 25, 9 }, },
+      { { 215, 197, 83, 246, 7 },
+        { 188, 94, 210, 251, 3 },
+        { 230, 252, 170, 62, 11 },
+        { 205, 244, 183, 163, 13 }, },
+      { { 213, 254, 112, 184, 8 },
+        { 225, 44, 155, 242, 14 },
+        { 17, 208, 231, 250, 11 },
+        { 116, 253, 147, 72, 7 }, },
+      { { 216, 12, 185, 190, 6 },
+        { 26, 184, 198, 178, 15 },
+        { 103, 217, 211, 1, 11 },
+        { 244, 214, 49, 213, 8 }, },
+      { { 222, 52, 186, 37, 6 },
+        { 203, 216, 70, 183, 4 },
+        { 106, 69, 210, 199, 11 },
+        { 46, 214, 33, 189, 3 }, },
+      { { 220, 14, 198, 139, 14 },
+        { 162, 249, 73, 166, 11 },
+        { 125, 22, 55, 3, 11 },
+        { 214, 89, 41, 244, 5 }, },
+      { { 222, 3, 247, 164, 11 },
+        { 190, 219, 11, 147, 6 },
+        { 210, 94, 252, 7, 11 },
+        { 108, 157, 13, 183, 13 }, },
+      { { 218, 93, 11, 138, 2 },
+        { 82, 126, 4, 163, 11 },
+        { 69, 29, 11, 165, 11 },
+        { 220, 82, 7, 228, 10 }, },
+      { { 216, 113, 249, 127, 15 },
+        { 127, 190, 199, 158, 5 },
+        { 255, 233, 248, 225, 11 },
+        { 167, 158, 55, 223, 14 }, },
+      { { 220, 189, 130, 231, 2 },
+        { 203, 218, 18, 174, 11 },
+        { 78, 116, 27, 211, 11 },
+        { 215, 84, 133, 189, 3 }, },
+      { { 220, 176, 90, 229, 5 },
+        { 239, 72, 86, 158, 2 },
+        { 170, 117, 160, 211, 11 },
+        { 71, 150, 161, 47, 7 }, },
+      { { 218, 147, 222, 80, 0 },
+        { 98, 203, 156, 155, 0 },
+        { 0, 167, 188, 149, 11 },
+        { 13, 147, 157, 52, 6 }, },
+      { { 218, 183, 241, 191, 8 },
+        { 123, 170, 155, 183, 7 },
+        { 31, 216, 254, 213, 11 },
+        { 238, 221, 149, 93, 14 }, },
+      { { 222, 159, 2, 50, 14 },
+        { 194, 90, 219, 163, 9 },
+        { 116, 196, 15, 151, 11 },
+        { 156, 93, 181, 164, 3 }, },
+      { { 218, 196, 13, 85, 0 },
+        { 26, 13, 148, 175, 0 },
+        { 10, 171, 2, 53, 11 },
+        { 15, 82, 155, 5, 8 }, },
+      { { 220, 197, 171, 128, 14 },
+        { 146, 222, 85, 162, 6 },
+        { 112, 29, 90, 51, 11 },
+        { 100, 90, 167, 180, 9 }, },
+      { { 218, 194, 178, 58, 10 },
+        { 2, 252, 155, 147, 5 },
+        { 85, 196, 212, 53, 11 },
+        { 172, 157, 147, 244, 0 }, },
+      { { 218, 218, 88, 253, 0 },
+        { 106, 44, 158, 159, 10 },
+        { 11, 241, 165, 181, 11 },
+        { 95, 151, 147, 69, 6 }, },
+      { { 217, 37, 142, 168, 1 },
+        { 7, 235, 6, 226, 2 },
+        { 129, 87, 26, 73, 11 },
+        { 68, 118, 13, 126, 0 }, },
+      { { 221, 5, 118, 59, 14 },
+        { 162, 123, 195, 246, 5 },
+        { 125, 198, 234, 11, 11 },
+        { 166, 252, 61, 228, 5 }, },
+      { { 221, 46, 153, 8, 12 },
+        { 147, 168, 77, 242, 8 },
+        { 49, 9, 151, 75, 11 },
+        { 20, 251, 33, 92, 9 }, },
+      { { 217, 85, 104, 199, 5 },
+        { 110, 14, 68, 238, 7 },
+        { 174, 49, 106, 169, 11 },
+        { 231, 114, 39, 7, 6 }, },
+      { { 219, 80, 109, 76, 3 },
+        { 126, 61, 4, 203, 4 },
+        { 195, 43, 96, 173, 11 },
+        { 45, 50, 11, 199, 14 }, },
+      { { 223, 104, 170, 56, 8 },
+        { 131, 236, 135, 195, 12 },
+        { 17, 197, 81, 111, 11 },
+        { 60, 62, 19, 124, 1 }, },
+      { { 219, 66, 135, 167, 5 },
+        { 30, 205, 74, 199, 3 },
+        { 174, 94, 20, 45, 11 },
+        { 206, 53, 43, 55, 8 }, },
+      { { 219, 129, 40, 179, 13 },
+        { 6, 10, 215, 199, 7 },
+        { 188, 209, 72, 29, 11 },
+        { 238, 62, 181, 6, 0 }, },
+      { { 217, 163, 194, 250, 13 },
+        { 39, 234, 219, 202, 3 },
+        { 181, 244, 60, 89, 11 },
+        { 197, 61, 181, 126, 4 }, },
+      { { 221, 179, 56, 211, 8 },
+        { 195, 10, 157, 222, 7 },
+        { 28, 177, 204, 219, 11 },
+        { 231, 187, 149, 12, 3 }, },
+      { { 217, 202, 123, 155, 1 },
+        { 54, 108, 156, 214, 15 },
+        { 141, 157, 229, 57, 11 },
+        { 246, 179, 147, 102, 12 }, },
+      { { 219, 246, 158, 176, 7 },
+        { 71, 221, 222, 243, 2 },
+        { 224, 215, 150, 253, 11 },
+        { 76, 247, 187, 190, 2 }, },
+      { { 226, 8, 108, 175, 8 },
+        { 40, 33, 39, 135, 15 },
+        { 31, 83, 97, 4, 7 },
+        { 254, 30, 72, 65, 4 }, },
+      { { 224, 27, 171, 150, 4 },
+        { 88, 194, 236, 130, 15 },
+        { 38, 157, 93, 128, 7 },
+        { 244, 19, 116, 49, 10 }, },
+      { { 224, 72, 115, 243, 0 },
+        { 48, 68, 162, 158, 15 },
+        { 12, 252, 225, 32, 7 },
+        { 247, 148, 82, 32, 12 }, },
+      { { 228, 117, 169, 91, 14 },
+        { 209, 182, 229, 174, 5 },
+        { 125, 169, 90, 226, 7 },
+        { 167, 90, 118, 216, 11 }, },
+      { { 230, 128, 236, 116, 9 },
+        { 172, 129, 183, 139, 4 },
+        { 146, 227, 112, 22, 7 },
+        { 45, 30, 216, 19, 5 }, },
+      { { 226, 175, 118, 72, 7 },
+        { 37, 115, 120, 187, 12 },
+        { 225, 38, 239, 84, 7 },
+        { 61, 209, 236, 234, 4 }, },
+      { { 224, 162, 200, 17, 13 },
+        { 37, 128, 253, 134, 0 },
+        { 184, 129, 52, 80, 7 },
+        { 6, 27, 240, 26, 4 }, },
+      { { 226, 203, 113, 80, 12 },
+        { 48, 6, 249, 155, 12 },
+        { 48, 168, 237, 52, 7 },
+        { 61, 153, 246, 0, 12 }, },
+      { { 224, 210, 73, 197, 15 },
+        { 124, 20, 125, 142, 2 },
+        { 250, 57, 36, 176, 7 },
+        { 71, 27, 226, 131, 14 }, },
+      { { 225, 12, 194, 130, 9 },
+        { 36, 192, 33, 226, 11 },
+        { 148, 20, 51, 8, 7 },
+        { 212, 120, 64, 50, 4 }, },
+      { { 225, 127, 68, 52, 3 },
+        { 109, 23, 170, 226, 8 },
+        { 194, 194, 47, 232, 7 },
+        { 20, 117, 94, 139, 6 }, },
+      { { 231, 173, 69, 177, 14 },
+        { 177, 19, 243, 231, 10 },
+        { 120, 218, 43, 94, 7 },
+        { 94, 124, 252, 136, 13 }, },
+      { { 225, 182, 90, 159, 9 },
+        { 109, 96, 189, 246, 3 },
+        { 159, 149, 166, 216, 7 },
+        { 198, 251, 208, 107, 6 }, },
+      { { 231, 252, 32, 65, 12 },
+        { 193, 4, 113, 239, 12 },
+        { 56, 32, 67, 254, 7 },
+        { 63, 120, 226, 8, 3 }, },
+      { { 238, 51, 65, 56, 1 },
+        { 247, 34, 170, 131, 0 },
+        { 129, 200, 44, 199, 7 },
+        { 12, 21, 84, 78, 15 }, },
+      { { 238, 124, 54, 51, 4 },
+        { 195, 69, 226, 183, 13 },
+        { 44, 198, 195, 231, 7 },
+        { 190, 212, 122, 44, 3 }, },
+      { { 236, 112, 123, 248, 10 },
+        { 243, 116, 167, 154, 6 },
+        { 81, 253, 224, 227, 7 },
+        { 101, 158, 82, 236, 15 }, },
+      { { 232, 123, 59, 230, 14 },
+        { 91, 86, 111, 154, 15 },
+        { 118, 125, 205, 225, 7 },
+        { 245, 159, 102, 173, 10 }, },
+      { { 232, 149, 232, 57, 1 },
+        { 102, 162, 182, 166, 4 },
+        { 137, 193, 122, 145, 7 },
+        { 38, 86, 212, 86, 6 }, },
+      { { 238, 172, 9, 125, 5 },
+        { 159, 32, 246, 175, 8 },
+        { 171, 233, 3, 87, 7 },
+        { 31, 86, 240, 79, 9 }, },
+      { { 236, 161, 201, 55, 4 },
+        { 187, 130, 246, 134, 1 },
+        { 46, 201, 56, 83, 7 },
+        { 134, 22, 244, 29, 13 }, },
+      { { 232, 151, 189, 197, 5 },
+        { 94, 131, 124, 190, 6 },
+        { 170, 59, 222, 145, 7 },
+        { 103, 211, 236, 23, 10 }, },
+      { { 232, 204, 18, 29, 0 },
+        { 10, 100, 176, 182, 8 },
+        { 11, 132, 131, 49, 7 },
+        { 22, 208, 210, 101, 0 }, },
+      { { 238, 193, 29, 105, 8 },
+        { 146, 39, 55, 159, 0 },
+        { 25, 107, 136, 55, 7 },
+        { 15, 158, 206, 68, 9 }, },
+      { { 237, 7, 255, 219, 10 },
+        { 178, 243, 173, 254, 7 },
+        { 93, 191, 254, 11, 7 },
+        { 231, 251, 92, 244, 13 }, },
+      { { 237, 105, 243, 54, 11 },
+        { 191, 214, 163, 210, 13 },
+        { 214, 204, 249, 107, 7 },
+        { 180, 188, 86, 191, 13 }, },
+      { { 237, 118, 20, 181, 12 },
+        { 203, 5, 235, 246, 2 },
+        { 58, 210, 134, 235, 7 },
+        { 70, 253, 122, 13, 3 }, },
+      { { 239, 132, 33, 209, 7 },
+        { 150, 16, 240, 239, 6 },
+        { 232, 184, 66, 31, 7 },
+        { 111, 112, 240, 134, 9 }, },
+      { { 235, 245, 218, 120, 2 },
+        { 99, 246, 182, 251, 0 },
+        { 65, 229, 186, 253, 7 },
+        { 13, 246, 214, 252, 6 }, },
+      { { 233, 249, 229, 214, 13 },
+        { 127, 135, 241, 202, 15 },
+        { 182, 186, 121, 249, 7 },
+        { 245, 56, 254, 31, 14 }, },
+      { { 235, 211, 15, 145, 9 },
+        { 86, 71, 189, 199, 2 },
+        { 152, 159, 12, 189, 7 },
+        { 78, 59, 222, 38, 10 }, },
+      { { 233, 219, 241, 32, 9 },
+        { 118, 134, 59, 210, 12 },
+        { 144, 72, 253, 185, 7 },
+        { 52, 189, 198, 22, 14 }, },
+      { { 244, 41, 139, 109, 8 },
+        { 153, 234, 39, 142, 8 },
+        { 27, 109, 25, 66, 15 },
+        { 23, 30, 69, 121, 9 }, },
+      { { 246, 10, 52, 34, 5 },
+        { 132, 9, 106, 147, 13 },
+        { 164, 66, 197, 6, 15 },
+        { 188, 149, 105, 2, 1 }, },
+      { { 244, 88, 85, 155, 1 },
+        { 244, 45, 160, 150, 11 },
+        { 141, 154, 161, 162, 15 },
+        { 214, 144, 91, 66, 15 }, },
+      { { 242, 118, 55, 97, 3 },
+        { 85, 93, 42, 191, 4 },
+        { 200, 110, 198, 228, 15 },
+        { 47, 213, 75, 170, 10 }, },
+      { { 244, 75, 10, 224, 6 },
+        { 128, 94, 110, 138, 10 },
+        { 96, 117, 13, 34, 15 },
+        { 85, 23, 103, 160, 1 }, },
+      { { 246, 110, 129, 75, 12 },
+        { 145, 172, 105, 175, 9 },
+        { 61, 40, 23, 102, 15 },
+        { 159, 89, 99, 88, 9 }, },
+      { { 246, 67, 29, 76, 6 },
+        { 152, 63, 108, 155, 0 },
+        { 99, 43, 140, 38, 15 },
+        { 13, 147, 111, 193, 9 }, },
+      { { 244, 87, 34, 238, 1 },
+        { 204, 110, 42, 170, 7 },
+        { 135, 116, 78, 162, 15 },
+        { 229, 85, 71, 99, 3 }, },
+      { { 244, 153, 83, 229, 11 },
+        { 252, 90, 51, 158, 10 },
+        { 218, 124, 169, 146, 15 },
+        { 87, 156, 197, 163, 15 }, },
+      { { 240, 252, 47, 27, 5 },
+        { 85, 109, 244, 166, 13 },
+        { 173, 143, 67, 240, 15 },
+        { 182, 82, 251, 106, 10 }, },
+      { { 247, 9, 30, 9, 12 },
+        { 128, 107, 101, 215, 8 },
+        { 57, 7, 137, 14, 15 },
+        { 30, 186, 109, 96, 1 }, },
+      { { 247, 38, 87, 194, 0 },
+        { 177, 73, 40, 251, 3 },
+        { 4, 62, 166, 78, 15 },
+        { 205, 241, 73, 40, 13 }, },
+      { { 241, 133, 27, 198, 13 },
+        { 28, 74, 117, 250, 3 },
+        { 182, 61, 138, 24, 15 },
+        { 197, 250, 229, 35, 8 }, },
+      { { 243, 136, 98, 232, 1 },
+        { 36, 104, 50, 203, 14 },
+        { 129, 116, 97, 28, 15 },
+        { 125, 52, 193, 98, 4 }, },
+      { { 247, 169, 183, 234, 6 },
+        { 145, 251, 114, 219, 15 },
+        { 101, 126, 217, 94, 15 },
+        { 253, 180, 237, 248, 9 }, },
+      { { 247, 138, 138, 92, 2 },
+        { 136, 248, 188, 203, 8 },
+        { 67, 165, 21, 30, 15 },
+        { 29, 51, 209, 241, 1 }, },
+      { { 243, 237, 194, 21, 2 },
+        { 41, 222, 176, 231, 8 },
+        { 74, 132, 59, 124, 15 },
+        { 30, 112, 215, 185, 4 }, },
+      { { 245, 245, 148, 242, 4 },
+        { 193, 143, 242, 250, 3 },
+        { 36, 242, 154, 250, 15 },
+        { 197, 244, 255, 24, 3 }, },
+      { { 248, 15, 62, 15, 4 },
+        { 10, 107, 108, 182, 13 },
+        { 47, 7, 207, 1, 15 },
+        { 182, 211, 109, 101, 0 }, },
+      { { 252, 190, 99, 125, 14 },
+        { 251, 120, 251, 174, 12 },
+        { 123, 236, 103, 211, 15 },
+        { 55, 93, 241, 237, 15 }, },
+      { { 248, 237, 33, 73, 11 },
+        { 23, 62, 49, 174, 12 },
+        { 217, 40, 75, 113, 15 },
+        { 55, 88, 199, 206, 8 }, },
+      { { 250, 216, 194, 128, 14 },
+        { 98, 220, 113, 131, 10 },
+        { 112, 20, 49, 181, 15 },
+        { 92, 24, 227, 180, 6 }, },
+      { { 254, 229, 5, 156, 6 },
+        { 155, 63, 240, 163, 2 },
+        { 99, 154, 10, 119, 15 },
+        { 76, 80, 255, 205, 9 }, },
+      { { 254, 196, 253, 27, 8 },
+        { 178, 173, 181, 183, 5 },
+        { 29, 139, 242, 55, 15 },
+        { 174, 218, 219, 84, 13 }, },
+      { { 250, 210, 225, 31, 4 },
+        { 122, 172, 248, 135, 5 },
+        { 47, 136, 116, 181, 15 },
+        { 174, 17, 243, 85, 14 }, },
+      { { 252, 195, 230, 115, 2 },
+        { 162, 223, 186, 142, 5 },
+        { 76, 230, 124, 51, 15 },
+        { 167, 21, 223, 180, 5 }, },
+      { { 249, 63, 162, 110, 11 },
+        { 79, 250, 43, 234, 13 },
+        { 215, 100, 95, 201, 15 },
+        { 181, 125, 69, 255, 2 }, },
+      { { 251, 86, 194, 94, 3 },
+        { 110, 252, 168, 235, 1 },
+        { 199, 164, 54, 173, 15 },
+        { 141, 113, 83, 247, 6 }, },
+      { { 255, 78, 140, 162, 15 },
+        { 134, 157, 111, 227, 11 },
+        { 244, 83, 23, 47, 15 },
+        { 220, 127, 107, 150, 1 }, },
+      { { 255, 79, 112, 226, 4 },
+        { 162, 14, 106, 251, 15 },
+        { 36, 112, 239, 47, 15 },
+        { 253, 245, 103, 4, 5 }, },
+      { { 249, 177, 42, 52, 9 },
+        { 79, 74, 183, 194, 4 },
+        { 146, 197, 72, 217, 15 },
+        { 36, 62, 213, 47, 2 }, },
+      { { 255, 135, 146, 120, 1 },
+        { 134, 234, 186, 251, 0 },
+        { 129, 228, 158, 31, 15 },
+        { 13, 245, 213, 118, 1 }, },
+      { { 249, 195, 188, 9, 10 },
+        { 2, 191, 61, 214, 4 },
+        { 89, 3, 220, 57, 15 },
+        { 38, 187, 207, 212, 0 }, },
+      { { 255, 202, 25, 209, 12 },
+        { 146, 12, 253, 223, 10 },
+        { 56, 185, 133, 63, 15 },
+        { 95, 187, 243, 4, 9 }, },
+      { { 255, 239, 23, 165, 10 },
+        { 155, 95, 59, 247, 10 },
+        { 90, 94, 143, 127, 15 },
+        { 94, 253, 207, 173, 9 }, },
+      { { 253, 254, 218, 140, 1 },
+        { 239, 236, 60, 242, 10 },
+        { 131, 21, 183, 251, 15 },
+        { 84, 243, 195, 127, 7 }, },
+      { { 6, 66, 233, 9, 7 },
+        { 180, 180, 76, 5, 4 },
+        { 233, 9, 116, 38, 0 },
+        { 42, 3, 34, 210, 13 }, },
+      { { 3, 36, 36, 70, 13 },
+        { 13, 1, 65, 105, 5 },
+        { 182, 34, 66, 76, 0 },
+        { 169, 104, 40, 11, 0 }, },
+      { { 7, 94, 92, 135, 12 },
+        { 232, 5, 77, 117, 11 },
+        { 62, 19, 167, 174, 0 },
+        { 218, 235, 42, 1, 7 }, },
+      { { 7, 136, 66, 250, 6 },
+        { 160, 112, 210, 73, 11 },
+        { 101, 244, 33, 30, 0 },
+        { 217, 36, 176, 224, 5 }, },
+      { { 10, 7, 178, 27, 11 },
+        { 6, 242, 137, 53, 5 },
+        { 221, 132, 222, 5, 0 },
+        { 170, 201, 20, 246, 0 }, },
+      { { 16, 148, 220, 241, 14 },
+        { 96, 153, 215, 60, 2 },
+        { 120, 243, 178, 144, 8 },
+        { 67, 206, 185, 144, 6 }, },
+      { { 22, 162, 90, 176, 15 },
+        { 165, 88, 223, 17, 2 },
+        { 240, 213, 164, 86, 8 },
+        { 72, 143, 177, 170, 5 }, },
+      { { 16, 253, 203, 109, 14 },
+        { 121, 254, 87, 44, 8 },
+        { 123, 109, 59, 240, 8 },
+        { 19, 78, 167, 249, 14 }, },
+      { { 17, 52, 172, 162, 12 },
+        { 65, 137, 71, 96, 7 },
+        { 52, 83, 82, 200, 8 },
+        { 224, 110, 41, 24, 2 }, },
+      { { 17, 166, 62, 16, 1 },
+        { 5, 73, 156, 112, 4 },
+        { 128, 135, 198, 88, 8 },
+        { 32, 227, 153, 42, 0 }, },
+      { { 30, 88, 44, 226, 2 },
+        { 194, 29, 6, 9, 15 },
+        { 68, 115, 65, 167, 8 },
+        { 249, 6, 11, 132, 3 }, },
+      { { 24, 99, 58, 139, 0 },
+        { 3, 110, 12, 20, 7 },
+        { 13, 21, 204, 97, 8 },
+        { 226, 131, 7, 108, 0 }, },
+      { { 26, 99, 1, 47, 13 },
+        { 31, 46, 75, 5, 1 },
+        { 191, 72, 12, 101, 8 },
+        { 138, 13, 39, 79, 8 }, },
+      { { 26, 241, 71, 206, 15 },
+        { 127, 127, 81, 9, 3 },
+        { 247, 62, 40, 245, 8 },
+        { 201, 8, 175, 239, 14 }, },
+      { { 25, 108, 177, 139, 1 },
+        { 23, 172, 0, 116, 15 },
+        { 141, 24, 211, 105, 8 },
+        { 242, 224, 3, 94, 8 }, },
+      { { 29, 149, 207, 92, 12 },
+        { 250, 235, 213, 104, 0 },
+        { 51, 175, 58, 155, 8 },
+        { 1, 106, 189, 117, 15 }, },
+      { { 25, 158, 56, 146, 2 },
+        { 66, 24, 156, 112, 15 },
+        { 68, 145, 199, 153, 8 },
+        { 240, 227, 145, 132, 2 }, },
+      { { 31, 252, 86, 35, 10 },
+        { 227, 93, 19, 117, 9 },
+        { 92, 70, 163, 255, 8 },
+        { 154, 236, 139, 172, 7 }, },
+      { { 36, 27, 41, 179, 3 },
+        { 212, 18, 174, 4, 15 },
+        { 204, 217, 77, 130, 4 },
+        { 242, 7, 84, 130, 11 }, },
+      { { 38, 231, 136, 133, 0 },
+        { 137, 134, 60, 37, 2 },
+        { 10, 17, 30, 118, 4 },
+        { 74, 67, 198, 25, 1 }, },
+      { { 33, 7, 54, 188, 1 },
+        { 12, 99, 170, 112, 6 },
+        { 131, 214, 206, 8, 4 },
+        { 96, 229, 92, 99, 0 }, },
+      { { 40, 77, 70, 86, 10 },
+        { 42, 87, 161, 40, 9 },
+        { 86, 166, 43, 33, 4 },
+        { 145, 72, 94, 165, 4 }, },
+      { { 46, 236, 227, 69, 8 },
+        { 187, 196, 49, 45, 12 },
+        { 26, 44, 115, 119, 4 },
+        { 59, 72, 194, 61, 13 }, },
+      { { 45, 79, 225, 77, 4 },
+        { 186, 166, 104, 108, 12 },
+        { 43, 40, 127, 43, 4 },
+        { 51, 97, 102, 85, 13 }, },
+      { { 45, 138, 40, 60, 7 },
+        { 142, 48, 254, 64, 12 },
+        { 227, 193, 69, 27, 4 },
+        { 48, 39, 240, 199, 1 }, },
+      { { 52, 248, 62, 55, 1 },
+        { 205, 77, 182, 20, 13 },
+        { 142, 199, 193, 242, 12 },
+        { 178, 134, 219, 43, 3 }, },
+      { { 56, 99, 93, 125, 8 },
+        { 59, 47, 175, 28, 0 },
+        { 27, 235, 172, 97, 12 },
+        { 3, 143, 95, 77, 12 }, },
+      { { 63, 162, 28, 196, 12 },
+        { 139, 9, 125, 89, 2 },
+        { 50, 51, 132, 95, 12 },
+        { 73, 171, 233, 13, 1 }, },
+      { { 66, 221, 151, 174, 14 },
+        { 88, 247, 83, 177, 11 },
+        { 119, 94, 155, 180, 2 },
+        { 216, 220, 174, 241, 10 }, },
+      { { 68, 223, 18, 214, 11 },
+        { 204, 86, 153, 184, 11 },
+        { 214, 180, 143, 178, 2 },
+        { 209, 217, 150, 163, 3 }, },
+      { { 65, 58, 205, 236, 8 },
+        { 121, 161, 15, 200, 10 },
+        { 19, 123, 53, 200, 2 },
+        { 81, 63, 8, 89, 14 }, },
+      { { 65, 192, 219, 73, 4 },
+        { 48, 228, 84, 220, 0 },
+        { 41, 45, 176, 56, 2 },
+        { 3, 178, 162, 112, 12 }, },
+      { { 76, 180, 0, 200, 13 },
+        { 199, 32, 81, 168, 2 },
+        { 177, 48, 2, 211, 2 },
+        { 65, 88, 160, 78, 3 }, },
+      { { 73, 35, 72, 149, 2 },
+        { 43, 18, 140, 196, 2 },
+        { 74, 145, 44, 73, 2 },
+        { 66, 51, 20, 141, 4 }, },
+      { { 82, 55, 185, 92, 6 },
+        { 89, 186, 204, 185, 4 },
+        { 99, 169, 222, 196, 10 },
+        { 41, 211, 53, 217, 10 }, },
+      { { 82, 81, 56, 221, 10 },
+        { 72, 62, 133, 157, 6 },
+        { 91, 177, 200, 164, 10 },
+        { 107, 154, 23, 193, 2 }, },
+      { { 94, 113, 146, 65, 3 },
+        { 199, 222, 0, 157, 0 },
+        { 200, 36, 152, 231, 10 },
+        { 11, 144, 7, 190, 3 }, },
+      { { 92, 178, 113, 235, 13 },
+        { 247, 40, 91, 156, 7 },
+        { 189, 120, 228, 211, 10 },
+        { 227, 157, 161, 78, 15 }, },
+      { { 91, 238, 55, 54, 6 },
+        { 27, 93, 218, 241, 13 },
+        { 102, 206, 199, 125, 10 },
+        { 184, 245, 187, 173, 8 }, },
+      { { 96, 5, 132, 21, 2 },
+        { 8, 147, 160, 164, 0 },
+        { 74, 130, 26, 0, 6 },
+        { 2, 80, 92, 145, 0 }, },
+      { { 100, 8, 128, 51, 8 },
+        { 128, 128, 163, 132, 9 },
+        { 28, 192, 17, 2, 6 },
+        { 146, 28, 80, 16, 1 }, },
+      { { 110, 40, 135, 140, 3 },
+        { 159, 241, 32, 129, 10 },
+        { 195, 30, 17, 71, 6 },
+        { 88, 16, 72, 255, 9 }, },
+      { { 108, 85, 84, 181, 7 },
+        { 238, 23, 226, 180, 2 },
+        { 234, 210, 170, 163, 6 },
+        { 66, 212, 126, 135, 7 }, },
+      { { 104, 186, 254, 70, 1 },
+        { 111, 193, 60, 152, 13 },
+        { 134, 39, 245, 209, 6 },
+        { 177, 147, 200, 63, 6 }, },
+      { { 104, 179, 85, 202, 7 },
+        { 119, 51, 120, 152, 3 },
+        { 229, 58, 172, 209, 6 },
+        { 193, 145, 236, 206, 14 }, },
+      { { 117, 156, 155, 102, 9 },
+        { 220, 200, 55, 248, 9 },
+        { 150, 109, 147, 154, 14 },
+        { 145, 254, 193, 51, 11 }, },
+      { { 124, 11, 200, 10, 0 },
+        { 162, 170, 44, 128, 9 },
+        { 5, 1, 61, 3, 14 },
+        { 144, 19, 69, 84, 5 }, },
+      { { 126, 89, 104, 196, 9 },
+        { 238, 14, 37, 137, 14 },
+        { 146, 49, 105, 167, 14 },
+        { 121, 26, 71, 7, 7 }, },
+      { { 120, 111, 61, 52, 5 },
+        { 31, 15, 238, 176, 12 },
+        { 162, 203, 207, 97, 14 },
+        { 48, 215, 127, 15, 8 }, },
+      { { 120, 193, 191, 255, 10 },
+        { 26, 255, 183, 156, 7 },
+        { 95, 255, 216, 49, 14 },
+        { 227, 158, 223, 245, 8 }, },
+      { { 122, 218, 185, 69, 10 },
+        { 90, 156, 61, 157, 12 },
+        { 90, 41, 213, 181, 14 },
+        { 59, 155, 195, 149, 10 }, },
+      { { 128, 60, 123, 156, 0 },
+        { 121, 96, 132, 50, 14 },
+        { 3, 157, 227, 192, 1 },
+        { 116, 194, 16, 105, 14 }, },
+      { { 135, 20, 88, 249, 7 },
+        { 228, 48, 198, 127, 2 },
+        { 233, 241, 162, 142, 1 },
+        { 79, 230, 48, 194, 7 }, },
+      { { 131, 27, 5, 165, 13 },
+        { 92, 3, 75, 71, 10 },
+        { 186, 90, 13, 140, 1 },
+        { 94, 45, 44, 3, 10 }, },
+      { { 136, 59, 180, 103, 4 },
+        { 75, 131, 74, 30, 13 },
+        { 46, 98, 221, 193, 1 },
+        { 183, 133, 44, 29, 2 }, },
+      { { 140, 169, 136, 156, 0 },
+        { 139, 162, 148, 2, 10 },
+        { 3, 145, 25, 83, 1 },
+        { 84, 2, 148, 93, 1 }, },
+      { { 142, 177, 3, 26, 11 },
+        { 215, 114, 145, 3, 1 },
+        { 213, 140, 8, 215, 1 },
+        { 140, 8, 148, 238, 11 }, },
+      { { 143, 39, 191, 54, 4 },
+        { 155, 195, 206, 115, 5 },
+        { 38, 207, 222, 79, 1 },
+        { 172, 231, 60, 61, 9 }, },
+      { { 143, 22, 179, 202, 0 },
+        { 210, 224, 8, 123, 7 },
+        { 5, 60, 214, 143, 1 },
+        { 237, 225, 0, 116, 11 }, },
+      { { 148, 24, 222, 74, 0 },
+        { 224, 233, 4, 26, 9 },
+        { 5, 39, 177, 130, 9 },
+        { 149, 130, 9, 112, 7 }, },
+      { { 147, 69, 36, 197, 0 },
+        { 8, 15, 0, 111, 6 },
+        { 10, 50, 74, 44, 9 },
+        { 111, 96, 15, 1, 0 }, },
+      { { 156, 253, 156, 216, 5 },
+        { 199, 175, 212, 58, 10 },
+        { 161, 179, 155, 243, 9 },
+        { 85, 194, 191, 94, 3 }, },
+      { { 155, 34, 55, 120, 13 },
+        { 23, 105, 203, 91, 4 },
+        { 177, 238, 196, 77, 9 },
+        { 45, 173, 57, 110, 8 }, },
+      { { 153, 250, 163, 209, 6 },
+        { 83, 220, 216, 78, 14 },
+        { 104, 188, 85, 249, 9 },
+        { 119, 33, 179, 188, 10 }, },
+      { { 162, 159, 28, 84, 3 },
+        { 76, 19, 188, 59, 8 },
+        { 194, 163, 143, 148, 5 },
+        { 29, 195, 220, 131, 2 }, },
+      { { 172, 79, 91, 26, 11 },
+        { 182, 118, 173, 50, 9 },
+        { 213, 141, 175, 35, 5 },
+        { 148, 203, 86, 230, 13 }, },
+      { { 172, 191, 109, 54, 6 },
+        { 251, 19, 254, 34, 13 },
+        { 102, 203, 111, 211, 5 },
+        { 180, 71, 252, 141, 15 }, },
+      { { 169, 185, 76, 64, 8 },
+        { 99, 3, 53, 74, 8 },
+        { 16, 35, 41, 217, 5 },
+        { 21, 42, 204, 12, 6 }, },
+      { { 182, 40, 233, 2, 12 },
+        { 177, 136, 101, 3, 13 },
+        { 52, 9, 113, 70, 13 },
+        { 188, 10, 97, 24, 13 }, },
+      { { 180, 109, 218, 222, 0 },
+        { 169, 238, 164, 58, 11 },
+        { 7, 181, 187, 98, 13 },
+        { 213, 194, 87, 121, 5 }, },
+      { { 178, 110, 246, 10, 1 },
+        { 37, 237, 40, 51, 13 },
+        { 133, 6, 247, 100, 13 },
+        { 188, 193, 75, 122, 4 }, },
+      { { 179, 37, 153, 105, 14 },
+        { 17, 186, 103, 127, 0 },
+        { 121, 105, 154, 76, 13 },
+        { 15, 238, 101, 216, 8 }, },
+      { { 179, 80, 40, 17, 5 },
+        { 68, 12, 228, 71, 4 },
+        { 168, 129, 64, 172, 13 },
+        { 46, 34, 115, 2, 2 }, },
+      { { 190, 28, 27, 59, 6 },
+        { 210, 120, 230, 55, 9 },
+        { 109, 205, 131, 135, 13 },
+        { 158, 198, 113, 228, 11 }, },
+      { { 188, 127, 85, 99, 14 },
+        { 243, 31, 107, 62, 9 },
+        { 124, 106, 175, 227, 13 },
+        { 151, 205, 111, 140, 15 }, },
+      { { 188, 175, 230, 141, 5 },
+        { 175, 235, 120, 38, 14 },
+        { 171, 22, 127, 83, 13 },
+        { 118, 65, 237, 127, 5 }, },
+      { { 189, 37, 146, 140, 4 },
+        { 139, 234, 96, 114, 2 },
+        { 35, 20, 154, 75, 13 },
+        { 68, 224, 101, 125, 1 }, },
+      { { 196, 27, 214, 183, 1 },
+        { 236, 195, 138, 150, 11 },
+        { 142, 214, 189, 130, 3 },
+        { 214, 149, 28, 51, 7 }, },
+      { { 198, 99, 190, 252, 14 },
+        { 137, 247, 207, 155, 6 },
+        { 115, 247, 220, 102, 3 },
+        { 109, 159, 62, 249, 1 }, },
+      { { 198, 86, 130, 19, 13 },
+        { 196, 196, 201, 167, 1 },
+        { 188, 132, 22, 166, 3 },
+        { 142, 89, 50, 50, 3 }, },
+      { { 198, 139, 73, 36, 10 },
+        { 184, 18, 31, 131, 8 },
+        { 82, 73, 45, 22, 3 },
+        { 28, 31, 132, 129, 13 }, },
+      { { 193, 61, 206, 190, 2 },
+        { 105, 243, 134, 226, 11 },
+        { 71, 215, 59, 200, 3 },
+        { 212, 118, 28, 249, 6 }, },
+      { { 197, 25, 109, 109, 1 },
+        { 252, 35, 6, 206, 12 },
+        { 139, 107, 105, 138, 3 },
+        { 55, 54, 12, 67, 15 }, },
+      { { 199, 77, 61, 239, 11 },
+        { 156, 55, 7, 255, 15 },
+        { 223, 123, 203, 46, 3 },
+        { 255, 254, 14, 195, 9 }, },
+      { { 193, 90, 43, 220, 9 },
+        { 92, 100, 141, 202, 14 },
+        { 147, 189, 69, 168, 3 },
+        { 117, 59, 18, 99, 10 }, },
+      { { 202, 35, 114, 33, 12 },
+        { 35, 66, 75, 151, 4 },
+        { 56, 68, 236, 69, 3 },
+        { 46, 157, 36, 44, 4 }, },
+      { { 207, 199, 244, 213, 9 },
+        { 174, 135, 153, 255, 6 },
+        { 154, 178, 254, 63, 3 },
+        { 111, 249, 158, 23, 5 }, },
+      { { 208, 49, 39, 226, 6 },
+        { 81, 91, 66, 138, 7 },
+        { 100, 126, 72, 192, 11 },
+        { 229, 20, 45, 168, 10 }, },
+      { { 212, 119, 84, 14, 0 },
+        { 233, 47, 8, 178, 1 },
+        { 7, 2, 174, 226, 11 },
+        { 132, 209, 15, 73, 7 }, },
+      { { 209, 134, 49, 90, 2 },
+        { 16, 56, 152, 250, 5 },
+        { 69, 168, 198, 24, 11 },
+        { 165, 241, 145, 192, 8 }, },
+      { { 219, 76, 100, 122, 11 },
+        { 38, 61, 131, 235, 13 },
+        { 213, 226, 99, 45, 11 },
+        { 189, 124, 27, 198, 4 }, },
+      { { 219, 132, 135, 144, 8 },
+        { 18, 201, 145, 227, 2 },
+        { 16, 158, 18, 29, 11 },
+        { 76, 120, 153, 52, 8 }, },
+      { { 223, 222, 6, 112, 0 },
+        { 194, 77, 154, 235, 8 },
+        { 0, 230, 7, 191, 11 },
+        { 29, 117, 155, 36, 3 }, },
+      { { 226, 41, 186, 96, 0 },
+        { 1, 194, 38, 155, 12 },
+        { 0, 101, 217, 68, 7 },
+        { 61, 150, 68, 56, 0 }, },
+      { { 225, 64, 224, 141, 6 },
+        { 40, 180, 96, 198, 6 },
+        { 107, 16, 112, 40, 7 },
+        { 102, 48, 98, 209, 4 }, },
+      { { 225, 154, 144, 165, 2 },
+        { 72, 144, 58, 214, 10 },
+        { 74, 80, 149, 152, 7 },
+        { 86, 181, 192, 145, 2 }, },
+      { { 231, 242, 192, 250, 9 },
+        { 229, 164, 187, 203, 3 },
+        { 149, 240, 52, 254, 7 },
+        { 205, 61, 210, 90, 7 }, },
+      { { 238, 173, 190, 131, 8 },
+        { 131, 195, 53, 183, 15 },
+        { 28, 23, 219, 87, 7 },
+        { 254, 218, 204, 60, 1 }, },
+      { { 240, 28, 242, 124, 1 },
+        { 108, 232, 162, 186, 12 },
+        { 131, 228, 243, 128, 15 },
+        { 53, 212, 81, 115, 6 }, },
+      { { 247, 101, 168, 38, 4 },
+        { 137, 142, 102, 227, 5 },
+        { 38, 65, 90, 110, 15 },
+        { 172, 118, 103, 25, 1 }, },
+      { { 247, 236, 195, 164, 13 },
+        { 189, 204, 115, 227, 10 },
+        { 178, 92, 51, 126, 15 },
+        { 92, 124, 227, 59, 13 }, },
+      { { 248, 45, 84, 113, 4 },
+        { 35, 11, 226, 190, 8 },
+        { 40, 226, 171, 65, 15 },
+        { 23, 212, 125, 12, 4 }, },
+      { { 254, 133, 143, 205, 11 },
+        { 158, 251, 53, 175, 2 },
+        { 219, 63, 26, 23, 15 },
+        { 79, 90, 205, 247, 9 }, },
+      { { 248, 227, 91, 11, 6 },
+        { 51, 126, 124, 150, 1 },
+        { 109, 13, 172, 113, 15 },
+        { 134, 147, 231, 236, 12 }, },
+      { { 254, 214, 62, 31, 15 },
+        { 206, 125, 253, 183, 5 },
+        { 255, 135, 198, 183, 15 },
+        { 174, 219, 251, 231, 3 }, }, };
+
+static unsigned char DICT_7X7_1000_BYTES[][4][7] =
+    { { { 221, 92, 108, 165, 202, 10, 1 },
+        { 99, 179, 173, 228, 49, 180, 0 },
+        { 168, 41, 210, 155, 29, 93, 1 },
+        { 22, 198, 19, 218, 230, 227, 0 }, },
+      { { 228, 27, 241, 62, 64, 171, 0 },
+        { 17, 253, 137, 11, 181, 42, 1 },
+        { 106, 129, 62, 71, 236, 19, 1 },
+        { 170, 86, 232, 72, 223, 196, 0 }, },
+      { { 158, 170, 43, 172, 93, 39, 1 },
+        { 163, 182, 158, 145, 75, 171, 1 },
+        { 242, 93, 26, 234, 42, 188, 1 },
+        { 234, 233, 68, 188, 182, 226, 1 }, },
+      { { 166, 103, 5, 183, 233, 76, 0 },
+        { 221, 48, 50, 221, 165, 172, 0 },
+        { 25, 75, 246, 208, 115, 50, 1 },
+        { 26, 210, 221, 166, 6, 93, 1 }, },
+      { { 198, 188, 123, 19, 50, 86, 0 },
+        { 253, 193, 139, 113, 154, 97, 0 },
+        { 53, 38, 100, 111, 30, 177, 1 },
+        { 67, 44, 199, 104, 193, 223, 1 }, },
+      { { 88, 128, 20, 35, 89, 238, 0 },
+        { 4, 122, 28, 80, 184, 133, 1 },
+        { 59, 205, 98, 20, 0, 141, 0 },
+        { 208, 142, 133, 28, 47, 16, 0 }, },
+      { { 211, 107, 190, 111, 84, 72, 0 },
+        { 164, 240, 198, 70, 247, 63, 0 },
+        { 9, 21, 123, 62, 235, 101, 1 },
+        { 126, 119, 177, 49, 135, 146, 1 }, },
+      { { 60, 161, 109, 136, 139, 219, 0 },
+        { 37, 14, 191, 169, 44, 198, 0 },
+        { 109, 232, 136, 219, 66, 158, 0 },
+        { 49, 154, 74, 254, 184, 82, 0 }, },
+      { { 137, 7, 31, 86, 150, 158, 0 },
+        { 112, 74, 104, 49, 231, 125, 0 },
+        { 60, 180, 181, 124, 112, 72, 1 },
+        { 95, 115, 198, 11, 41, 7, 0 }, },
+      { { 187, 101, 177, 141, 110, 63, 0 },
+        { 200, 86, 142, 255, 101, 242, 1 },
+        { 126, 59, 88, 198, 211, 110, 1 },
+        { 167, 211, 127, 184, 181, 9, 1 }, },
+      { { 245, 0, 209, 130, 244, 144, 1 },
+        { 11, 88, 37, 139, 208, 113, 0 },
+        { 132, 151, 160, 197, 128, 87, 1 },
+        { 71, 5, 232, 210, 13, 104, 0 }, },
+      { { 2, 38, 112, 184, 84, 26, 0 },
+        { 208, 112, 139, 128, 96, 75, 0 },
+        { 44, 21, 14, 135, 50, 32, 0 },
+        { 105, 3, 0, 232, 135, 5, 1 }, },
+      { { 84, 243, 107, 151, 72, 240, 1 },
+        { 55, 25, 135, 197, 159, 200, 1 },
+        { 135, 137, 116, 235, 103, 149, 0 },
+        { 137, 252, 209, 240, 204, 118, 0 }, },
+      { { 158, 36, 136, 70, 35, 153, 1 },
+        { 235, 14, 86, 34, 161, 96, 0 },
+        { 204, 226, 49, 8, 146, 60, 1 },
+        { 3, 66, 162, 53, 56, 107, 1 }, },
+      { { 189, 255, 50, 107, 201, 203, 1 },
+        { 71, 255, 254, 76, 174, 186, 0 },
+        { 233, 201, 235, 38, 127, 222, 1 },
+        { 46, 186, 153, 63, 255, 241, 0 }, },
+      { { 206, 17, 5, 176, 90, 151, 1 },
+        { 147, 63, 8, 177, 20, 229, 0 },
+        { 244, 173, 6, 208, 68, 57, 1 },
+        { 83, 148, 70, 136, 126, 100, 1 }, },
+      { { 211, 240, 97, 114, 31, 139, 0 },
+        { 144, 45, 223, 37, 248, 177, 0 },
+        { 104, 252, 39, 67, 7, 229, 1 },
+        { 70, 143, 210, 125, 218, 4, 1 }, },
+      { { 1, 225, 158, 206, 200, 237, 1 },
+        { 38, 92, 98, 150, 175, 150, 1 },
+        { 219, 137, 185, 188, 195, 192, 0 },
+        { 180, 250, 180, 163, 29, 50, 0 }, },
+      { { 38, 203, 204, 42, 112, 120, 1 },
+        { 175, 176, 1, 14, 172, 79, 1 },
+        { 143, 7, 42, 25, 233, 178, 0 },
+        { 249, 26, 184, 64, 6, 250, 1 }, },
+      { { 56, 125, 77, 118, 65, 19, 0 },
+        { 112, 183, 95, 13, 133, 68, 0 },
+        { 100, 65, 55, 89, 95, 14, 0 },
+        { 17, 80, 216, 125, 118, 135, 0 }, },
+      { { 58, 144, 74, 233, 225, 233, 1 },
+        { 174, 63, 117, 200, 42, 2, 1 },
+        { 203, 195, 203, 169, 4, 174, 0 },
+        { 160, 42, 9, 215, 126, 58, 1 }, },
+      { { 70, 212, 132, 123, 60, 221, 0 },
+        { 221, 45, 64, 86, 248, 199, 0 },
+        { 93, 158, 111, 16, 149, 177, 0 },
+        { 113, 143, 181, 1, 90, 93, 1 }, },
+      { { 72, 146, 167, 222, 158, 43, 1 },
+        { 18, 7, 232, 163, 251, 143, 1 },
+        { 234, 60, 189, 242, 164, 137, 0 },
+        { 248, 239, 226, 139, 240, 36, 0 }, },
+      { { 94, 118, 195, 228, 152, 168, 0 },
+        { 193, 43, 103, 135, 51, 137, 1 },
+        { 10, 140, 147, 225, 183, 61, 0 },
+        { 200, 230, 112, 243, 106, 65, 1 }, },
+      { { 116, 162, 222, 250, 47, 136, 1 },
+        { 59, 104, 87, 170, 250, 142, 0 },
+        { 136, 250, 47, 189, 162, 151, 0 },
+        { 56, 175, 170, 245, 11, 110, 0 }, },
+      { { 148, 93, 226, 40, 19, 89, 0 },
+        { 69, 165, 149, 38, 38, 99, 0 },
+        { 77, 100, 10, 35, 221, 20, 1 },
+        { 99, 50, 50, 84, 210, 209, 0 }, },
+      { { 155, 18, 149, 100, 237, 163, 1 },
+        { 138, 127, 124, 3, 65, 188, 1 },
+        { 226, 219, 147, 84, 164, 108, 1 },
+        { 158, 193, 96, 31, 127, 40, 1 }, },
+      { { 161, 212, 148, 45, 130, 248, 0 },
+        { 68, 105, 32, 110, 41, 118, 1 },
+        { 15, 160, 218, 20, 149, 194, 1 },
+        { 183, 74, 59, 2, 75, 17, 0 }, },
+      { { 187, 120, 230, 49, 108, 208, 1 },
+        { 158, 187, 135, 78, 66, 244, 0 },
+        { 133, 155, 70, 51, 143, 110, 1 },
+        { 23, 161, 57, 112, 238, 188, 1 }, },
+      { { 203, 181, 221, 203, 219, 24, 0 },
+        { 224, 83, 115, 227, 188, 247, 0 },
+        { 12, 109, 233, 221, 214, 233, 1 },
+        { 119, 158, 227, 231, 101, 3, 1 }, },
+      { { 211, 229, 238, 183, 131, 51, 0 },
+        { 240, 36, 191, 230, 159, 116, 1 },
+        { 102, 96, 246, 187, 211, 229, 1 },
+        { 151, 124, 179, 254, 146, 7, 1 }, },
+      { { 242, 148, 35, 63, 209, 156, 1 },
+        { 210, 57, 180, 89, 187, 99, 0 },
+        { 156, 197, 254, 98, 20, 167, 1 },
+        { 99, 110, 205, 22, 206, 37, 1 }, },
+      { { 253, 214, 209, 159, 59, 230, 1 },
+        { 95, 75, 29, 255, 153, 187, 1 },
+        { 179, 238, 124, 197, 181, 223, 1 },
+        { 238, 204, 255, 220, 105, 125, 0 }, },
+      { { 58, 70, 36, 238, 132, 238, 1 },
+        { 198, 42, 236, 156, 225, 14, 1 },
+        { 187, 144, 187, 146, 49, 46, 0 },
+        { 184, 67, 156, 155, 170, 49, 1 }, },
+      { { 98, 24, 126, 36, 59, 15, 0 },
+        { 168, 229, 153, 56, 51, 133, 0 },
+        { 120, 110, 18, 63, 12, 35, 0 },
+        { 80, 230, 14, 76, 211, 138, 1 }, },
+      { { 10, 205, 67, 111, 157, 195, 0 },
+        { 196, 174, 121, 69, 207, 131, 0 },
+        { 97, 220, 251, 97, 89, 168, 0 },
+        { 96, 249, 209, 79, 58, 145, 1 }, },
+      { { 14, 64, 212, 195, 142, 2, 0 },
+        { 129, 66, 105, 230, 192, 132, 0 },
+        { 32, 56, 225, 149, 129, 56, 0 },
+        { 16, 129, 179, 203, 33, 64, 1 }, },
+      { { 20, 159, 217, 160, 98, 36, 0 },
+        { 105, 241, 5, 179, 12, 8, 1 },
+        { 18, 35, 2, 205, 252, 148, 0 },
+        { 136, 24, 102, 208, 71, 203, 0 }, },
+      { { 25, 162, 225, 26, 101, 237, 0 },
+        { 28, 30, 151, 19, 232, 26, 1 },
+        { 91, 211, 44, 67, 162, 204, 0 },
+        { 172, 11, 228, 116, 188, 28, 0 }, },
+      { { 43, 80, 130, 126, 27, 52, 0 },
+        { 144, 35, 80, 62, 131, 211, 1 },
+        { 22, 108, 63, 32, 133, 106, 0 },
+        { 229, 224, 190, 5, 98, 4, 1 }, },
+      { { 41, 105, 56, 146, 159, 163, 0 },
+        { 48, 206, 186, 172, 196, 145, 1 },
+        { 98, 252, 164, 142, 75, 74, 0 },
+        { 196, 145, 154, 174, 185, 134, 0 }, },
+      { { 44, 247, 84, 219, 244, 86, 1 },
+        { 95, 83, 107, 220, 204, 79, 0 },
+        { 181, 23, 237, 149, 119, 154, 0 },
+        { 121, 25, 157, 235, 101, 125, 0 }, },
+      { { 53, 233, 63, 158, 54, 124, 0 },
+        { 61, 192, 134, 189, 239, 87, 1 },
+        { 31, 54, 60, 254, 75, 214, 0 },
+        { 245, 123, 222, 176, 129, 222, 0 }, },
+      { { 63, 116, 171, 216, 61, 243, 1 },
+        { 255, 15, 222, 143, 66, 211, 1 },
+        { 231, 222, 13, 234, 151, 126, 0 },
+        { 229, 161, 120, 189, 248, 127, 1 }, },
+      { { 68, 208, 41, 244, 255, 64, 0 },
+        { 61, 49, 240, 165, 89, 129, 0 },
+        { 1, 127, 151, 202, 5, 145, 0 },
+        { 64, 205, 82, 135, 198, 94, 0 }, },
+      { { 72, 64, 228, 132, 42, 245, 0 },
+        { 12, 14, 129, 182, 17, 196, 1 },
+        { 87, 170, 16, 147, 129, 9, 0 },
+        { 145, 196, 54, 192, 184, 24, 0 }, },
+      { { 95, 25, 19, 104, 52, 2, 0 },
+        { 137, 227, 76, 1, 86, 19, 0 },
+        { 32, 22, 11, 100, 76, 125, 0 },
+        { 100, 53, 64, 25, 99, 200, 1 }, },
+      { { 94, 178, 114, 64, 61, 93, 1 },
+        { 143, 71, 215, 16, 122, 201, 0 },
+        { 221, 94, 1, 39, 38, 189, 0 },
+        { 73, 175, 4, 117, 241, 120, 1 }, },
+      { { 111, 155, 36, 31, 21, 194, 0 },
+        { 149, 139, 152, 72, 221, 31, 0 },
+        { 33, 212, 124, 18, 108, 251, 0 },
+        { 124, 93, 137, 12, 232, 212, 1 }, },
+      { { 114, 170, 249, 32, 168, 227, 1 },
+        { 174, 236, 175, 11, 24, 136, 1 },
+        { 227, 138, 130, 79, 170, 167, 0 },
+        { 136, 140, 104, 122, 155, 186, 1 }, },
+      { { 121, 136, 117, 59, 134, 54, 1 },
+        { 18, 226, 173, 121, 216, 86, 1 },
+        { 182, 48, 238, 87, 8, 207, 0 },
+        { 181, 13, 207, 90, 163, 164, 0 }, },
+      { { 123, 231, 19, 174, 121, 81, 1 },
+        { 206, 118, 22, 141, 159, 219, 0 },
+        { 197, 79, 58, 228, 115, 239, 0 },
+        { 109, 252, 216, 180, 55, 57, 1 }, },
+      { { 133, 106, 70, 201, 89, 224, 0 },
+        { 5, 152, 83, 196, 2, 191, 1 },
+        { 3, 205, 73, 177, 43, 80, 1 },
+        { 254, 160, 17, 229, 12, 208, 0 }, },
+      { { 142, 63, 238, 242, 217, 81, 1 },
+        { 247, 183, 243, 130, 134, 237, 0 },
+        { 197, 77, 167, 187, 254, 56, 1 },
+        { 91, 176, 160, 231, 246, 247, 1 }, },
+      { { 173, 56, 205, 33, 115, 103, 1 },
+        { 47, 183, 27, 123, 0, 53, 1 },
+        { 243, 103, 66, 89, 142, 90, 1 },
+        { 214, 0, 111, 108, 118, 250, 0 }, },
+      { { 177, 55, 37, 48, 185, 63, 1 },
+        { 90, 37, 190, 25, 36, 253, 1 },
+        { 254, 78, 134, 82, 118, 70, 1 },
+        { 223, 146, 76, 62, 210, 45, 0 }, },
+      { { 186, 195, 128, 210, 81, 219, 0 },
+        { 148, 30, 92, 142, 172, 105, 0 },
+        { 109, 197, 37, 128, 225, 174, 1 },
+        { 75, 26, 184, 157, 60, 20, 1 }, },
+      { { 193, 117, 109, 93, 24, 166, 1 },
+        { 114, 9, 203, 85, 21, 183, 1 },
+        { 178, 140, 93, 91, 87, 65, 1 },
+        { 246, 212, 85, 105, 200, 39, 0 }, },
+      { { 206, 97, 211, 126, 229, 17, 0 },
+        { 153, 118, 115, 7, 215, 98, 0 },
+        { 68, 83, 191, 101, 195, 57, 1 },
+        { 35, 117, 240, 103, 55, 76, 1 }, },
+      { { 210, 92, 152, 54, 221, 91, 1 },
+        { 246, 245, 60, 6, 241, 225, 0 },
+        { 237, 93, 182, 12, 157, 37, 1 },
+        { 67, 199, 176, 30, 87, 183, 1 }, },
+      { { 208, 106, 145, 233, 239, 206, 1 },
+        { 14, 248, 126, 247, 112, 170, 0 },
+        { 185, 251, 203, 196, 171, 5, 1 },
+        { 42, 135, 119, 191, 15, 184, 0 }, },
+      { { 73, 228, 227, 141, 169, 90, 1 },
+        { 78, 2, 187, 199, 59, 210, 0 },
+        { 173, 74, 216, 227, 147, 201, 0 },
+        { 37, 238, 113, 238, 160, 57, 0 }, },
+      { { 82, 209, 159, 40, 31, 179, 0 },
+        { 160, 109, 28, 39, 94, 199, 1 },
+        { 102, 252, 10, 124, 197, 165, 0 },
+        { 241, 189, 114, 28, 91, 2, 1 }, },
+      { { 2, 24, 175, 24, 115, 160, 1 },
+        { 186, 153, 144, 35, 2, 7, 1 },
+        { 130, 231, 12, 122, 140, 32, 0 },
+        { 240, 32, 98, 4, 204, 174, 1 }, },
+      { { 5, 192, 75, 56, 81, 119, 0 },
+        { 53, 52, 25, 21, 10, 83, 1 },
+        { 119, 69, 14, 105, 1, 208, 0 },
+        { 229, 40, 84, 76, 22, 86, 0 }, },
+      { { 15, 88, 169, 33, 137, 159, 0 },
+        { 161, 175, 184, 87, 32, 208, 0 },
+        { 124, 200, 194, 74, 141, 120, 0 },
+        { 5, 130, 117, 14, 250, 194, 1 }, },
+      { { 15, 206, 165, 68, 68, 26, 0 },
+        { 193, 146, 200, 7, 105, 92, 0 },
+        { 44, 17, 17, 82, 185, 248, 0 },
+        { 29, 75, 112, 9, 164, 193, 1 }, },
+      { { 21, 238, 211, 115, 20, 216, 1 },
+        { 87, 232, 71, 71, 234, 89, 0 },
+        { 141, 148, 103, 101, 187, 212, 0 },
+        { 77, 43, 241, 113, 11, 245, 0 }, },
+      { { 22, 241, 226, 252, 69, 158, 1 },
+        { 147, 57, 223, 150, 111, 66, 0 },
+        { 188, 209, 31, 163, 199, 180, 0 },
+        { 33, 123, 52, 253, 206, 100, 1 }, },
+      { { 30, 94, 76, 65, 59, 115, 0 },
+        { 237, 135, 93, 100, 0, 205, 1 },
+        { 103, 110, 65, 25, 61, 60, 0 },
+        { 217, 128, 19, 93, 112, 219, 1 }, },
+      { { 31, 194, 82, 102, 200, 118, 1 },
+        { 135, 114, 109, 20, 139, 216, 1 },
+        { 183, 9, 179, 37, 33, 252, 0 },
+        { 141, 232, 148, 91, 39, 112, 1 }, },
+      { { 39, 33, 22, 246, 49, 159, 1 },
+        { 155, 108, 90, 152, 167, 85, 0 },
+        { 252, 198, 55, 180, 66, 114, 0 },
+        { 85, 114, 140, 173, 27, 108, 1 }, },
+      { { 39, 155, 122, 137, 27, 220, 0 },
+        { 165, 201, 145, 248, 46, 219, 0 },
+        { 29, 236, 72, 175, 108, 242, 0 },
+        { 109, 186, 15, 196, 201, 210, 1 }, },
+      { { 46, 12, 48, 75, 106, 108, 0 },
+        { 205, 210, 192, 120, 160, 130, 1 },
+        { 27, 43, 105, 6, 24, 58, 0 },
+        { 160, 130, 143, 1, 165, 217, 1 }, },
+      { { 47, 169, 226, 121, 230, 43, 0 },
+        { 153, 182, 235, 106, 110, 18, 1 },
+        { 106, 51, 207, 35, 202, 250, 0 },
+        { 164, 59, 43, 107, 182, 204, 1 }, },
+      { { 44, 207, 211, 2, 147, 19, 1 },
+        { 67, 198, 57, 47, 142, 73, 0 },
+        { 228, 100, 160, 101, 249, 154, 0 },
+        { 73, 56, 250, 78, 49, 225, 0 }, },
+      { { 49, 83, 3, 2, 18, 230, 1 },
+        { 6, 9, 12, 61, 134, 25, 1 },
+        { 179, 164, 32, 96, 101, 70, 0 },
+        { 204, 48, 222, 24, 72, 48, 0 }, },
+      { { 48, 120, 115, 90, 253, 41, 1 },
+        { 26, 213, 247, 13, 226, 131, 1 },
+        { 202, 95, 173, 103, 15, 6, 0 },
+        { 224, 163, 216, 119, 213, 172, 0 }, },
+      { { 55, 226, 67, 44, 167, 160, 1 },
+        { 139, 40, 55, 45, 75, 26, 1 },
+        { 130, 242, 154, 97, 35, 246, 0 },
+        { 172, 105, 90, 118, 10, 104, 1 }, },
+      { { 76, 11, 79, 138, 255, 84, 0 },
+        { 45, 146, 49, 177, 214, 207, 0 },
+        { 21, 127, 168, 249, 104, 25, 0 },
+        { 121, 181, 198, 198, 36, 218, 0 }, },
+      { { 78, 218, 184, 202, 73, 33, 1 },
+        { 163, 215, 208, 134, 152, 138, 1 },
+        { 194, 73, 41, 142, 173, 185, 0 },
+        { 168, 140, 176, 133, 245, 226, 1 }, },
+      { { 76, 218, 221, 21, 152, 110, 0 },
+        { 53, 195, 41, 87, 57, 141, 1 },
+        { 59, 12, 212, 93, 173, 153, 0 },
+        { 216, 206, 117, 74, 97, 214, 0 }, },
+      { { 86, 123, 85, 187, 37, 96, 1 },
+        { 159, 225, 23, 197, 212, 14, 1 },
+        { 131, 82, 110, 213, 111, 53, 0 },
+        { 184, 21, 209, 244, 67, 252, 1 }, },
+      { { 84, 151, 117, 241, 41, 203, 0 },
+        { 93, 109, 221, 193, 60, 140, 0 },
+        { 105, 202, 71, 215, 116, 149, 0 },
+        { 24, 158, 65, 221, 219, 93, 0 }, },
+      { { 84, 152, 140, 205, 4, 162, 0 },
+        { 33, 137, 76, 194, 89, 6, 1 },
+        { 34, 144, 89, 152, 140, 149, 0 },
+        { 176, 77, 33, 153, 72, 194, 0 }, },
+      { { 94, 110, 164, 168, 119, 169, 0 },
+        { 201, 190, 150, 166, 112, 15, 1 },
+        { 74, 247, 10, 146, 187, 61, 0 },
+        { 248, 7, 50, 180, 190, 201, 1 }, },
+      { { 99, 4, 81, 119, 99, 178, 0 },
+        { 216, 120, 89, 105, 145, 80, 1 },
+        { 38, 227, 119, 69, 16, 99, 0 },
+        { 133, 68, 203, 77, 15, 13, 1 }, },
+      { { 105, 226, 58, 120, 116, 228, 1 },
+        { 62, 122, 194, 28, 90, 27, 1 },
+        { 147, 151, 15, 46, 35, 203, 0 },
+        { 236, 45, 28, 33, 175, 62, 0 }, },
+      { { 109, 23, 226, 74, 80, 28, 1 },
+        { 67, 19, 193, 26, 182, 91, 0 },
+        { 156, 5, 41, 35, 244, 91, 0 },
+        { 109, 54, 172, 65, 228, 97, 0 }, },
+      { { 112, 62, 128, 226, 203, 177, 0 },
+        { 64, 189, 118, 170, 144, 200, 1 },
+        { 70, 233, 163, 128, 190, 7, 0 },
+        { 137, 132, 170, 183, 94, 129, 0 }, },
+      { { 119, 80, 90, 139, 20, 43, 1 },
+        { 163, 69, 13, 204, 242, 19, 1 },
+        { 234, 20, 104, 173, 5, 119, 0 },
+        { 228, 39, 153, 216, 81, 98, 1 }, },
+      { { 130, 100, 225, 43, 36, 151, 1 },
+        { 202, 44, 139, 87, 192, 98, 0 },
+        { 244, 146, 106, 67, 147, 32, 1 },
+        { 35, 1, 245, 104, 154, 41, 1 }, },
+      { { 131, 253, 167, 209, 241, 197, 0 },
+        { 220, 157, 242, 215, 14, 53, 0 },
+        { 81, 199, 197, 242, 223, 224, 1 },
+        { 86, 56, 117, 167, 220, 157, 1 }, },
+      { { 147, 189, 107, 77, 96, 125, 1 },
+        { 238, 149, 199, 81, 47, 114, 1 },
+        { 223, 3, 89, 107, 94, 228, 1 },
+        { 167, 122, 69, 113, 212, 187, 1 }, },
+      { { 148, 216, 165, 194, 122, 237, 1 },
+        { 15, 157, 196, 183, 168, 165, 1 },
+        { 219, 175, 33, 210, 141, 148, 1 },
+        { 210, 138, 246, 145, 220, 248, 0 }, },
+      { { 148, 247, 189, 26, 15, 79, 1 },
+        { 119, 69, 158, 55, 236, 174, 0 },
+        { 249, 120, 44, 94, 247, 148, 1 },
+        { 58, 155, 246, 60, 209, 119, 0 }, },
+      { { 152, 241, 170, 62, 148, 248, 0 },
+        { 52, 43, 166, 6, 239, 99, 1 },
+        { 15, 148, 190, 42, 199, 140, 1 },
+        { 227, 123, 176, 50, 234, 22, 0 }, },
+      { { 169, 138, 223, 140, 87, 40, 0 },
+        { 32, 210, 17, 171, 107, 63, 1 },
+        { 10, 117, 24, 253, 168, 202, 1 },
+        { 254, 107, 106, 196, 37, 130, 0 }, },
+      { { 177, 14, 54, 223, 65, 63, 0 },
+        { 80, 212, 220, 216, 163, 126, 1 },
+        { 126, 65, 125, 182, 56, 70, 1 },
+        { 191, 98, 141, 157, 149, 133, 0 }, },
+      { { 185, 234, 28, 100, 226, 107, 0 },
+        { 44, 246, 110, 44, 41, 60, 1 },
+        { 107, 35, 147, 28, 43, 206, 1 },
+        { 158, 74, 26, 59, 55, 154, 0 }, },
+      { { 188, 38, 74, 240, 242, 183, 1 },
+        { 123, 62, 111, 184, 2, 105, 1 },
+        { 246, 167, 135, 169, 50, 30, 1 },
+        { 203, 32, 14, 251, 62, 111, 0 }, },
+      { { 189, 63, 146, 218, 126, 170, 0 },
+        { 89, 219, 78, 170, 230, 187, 1 },
+        { 42, 191, 45, 164, 254, 94, 1 },
+        { 238, 179, 170, 185, 109, 205, 0 }, },
+      { { 192, 53, 46, 74, 202, 87, 0 },
+        { 100, 21, 234, 48, 150, 230, 0 },
+        { 117, 41, 169, 58, 86, 1, 1 },
+        { 51, 180, 134, 43, 212, 19, 0 }, },
+      { { 194, 54, 220, 36, 22, 128, 1 },
+        { 226, 105, 3, 34, 81, 45, 0 },
+        { 128, 180, 18, 29, 182, 33, 1 },
+        { 90, 69, 34, 96, 75, 35, 1 }, },
+      { { 211, 79, 245, 172, 136, 118, 1 },
+        { 198, 224, 173, 151, 21, 254, 1 },
+        { 183, 8, 154, 215, 249, 101, 1 },
+        { 191, 212, 116, 218, 131, 177, 1 }, },
+      { { 215, 6, 210, 240, 31, 150, 0 },
+        { 209, 104, 93, 178, 82, 249, 0 },
+        { 52, 252, 7, 165, 176, 117, 1 },
+        { 79, 165, 38, 221, 11, 69, 1 }, },
+      { { 216, 50, 245, 201, 86, 5, 0 },
+        { 0, 87, 199, 243, 80, 47, 0 },
+        { 80, 53, 73, 215, 166, 13, 1 },
+        { 122, 5, 103, 241, 245, 0, 0 }, },
+      { { 216, 217, 65, 4, 131, 170, 0 },
+        { 0, 139, 61, 37, 61, 32, 1 },
+        { 42, 224, 144, 65, 77, 141, 1 },
+        { 130, 94, 82, 94, 104, 128, 0 }, },
+      { { 224, 211, 100, 108, 77, 209, 1 },
+        { 6, 61, 209, 12, 93, 238, 0 },
+        { 197, 217, 27, 19, 101, 131, 1 },
+        { 59, 221, 24, 69, 222, 48, 0 }, },
+      { { 225, 232, 37, 60, 152, 205, 0 },
+        { 20, 172, 162, 29, 57, 183, 0 },
+        { 89, 140, 158, 82, 11, 195, 1 },
+        { 118, 206, 92, 34, 154, 148, 0 }, },
+      { { 229, 118, 79, 139, 232, 157, 1 },
+        { 107, 29, 35, 221, 178, 254, 0 },
+        { 220, 139, 232, 249, 55, 83, 1 },
+        { 63, 166, 221, 226, 92, 107, 0 }, },
+      { { 232, 80, 250, 159, 250, 74, 0 },
+        { 60, 83, 169, 238, 179, 163, 0 },
+        { 41, 47, 252, 175, 133, 11, 1 },
+        { 98, 230, 187, 202, 229, 30, 0 }, },
+      { { 235, 128, 234, 240, 130, 92, 1 },
+        { 182, 34, 225, 186, 58, 112, 0 },
+        { 157, 32, 135, 171, 128, 235, 1 },
+        { 7, 46, 46, 195, 162, 54, 1 }, },
+      { { 239, 108, 113, 174, 69, 200, 1 },
+        { 199, 250, 147, 141, 241, 50, 0 },
+        { 137, 209, 58, 199, 27, 123, 1 },
+        { 38, 71, 216, 228, 175, 241, 1 }, },
+      { { 247, 217, 64, 237, 177, 12, 0 },
+        { 137, 161, 117, 220, 61, 51, 0 },
+        { 24, 70, 219, 129, 77, 247, 1 },
+        { 102, 94, 29, 215, 66, 200, 1 }, },
+      { { 254, 214, 40, 241, 92, 60, 1 },
+        { 243, 51, 196, 220, 120, 233, 1 },
+        { 158, 29, 71, 138, 53, 191, 1 },
+        { 203, 143, 29, 145, 230, 103, 1 }, },
+      { { 20, 199, 225, 220, 124, 3, 1 },
+        { 91, 20, 205, 135, 77, 139, 0 },
+        { 224, 31, 29, 195, 241, 148, 0 },
+        { 104, 217, 112, 217, 148, 109, 0 }, },
+      { { 34, 236, 79, 160, 255, 225, 0 },
+        { 236, 188, 51, 173, 74, 133, 1 },
+        { 67, 255, 130, 249, 27, 162, 0 },
+        { 208, 169, 90, 230, 30, 155, 1 }, },
+      { { 164, 134, 72, 34, 231, 234, 0 },
+        { 109, 56, 57, 40, 232, 40, 1 },
+        { 43, 243, 162, 9, 48, 146, 1 },
+        { 138, 11, 138, 78, 14, 91, 0 }, },
+      { { 179, 172, 156, 128, 134, 12, 1 },
+        { 226, 192, 38, 186, 104, 52, 0 },
+        { 152, 48, 128, 156, 154, 230, 1 },
+        { 22, 11, 46, 178, 1, 163, 1 }, },
+      { { 235, 197, 247, 106, 12, 68, 0 },
+        { 196, 98, 193, 31, 222, 182, 0 },
+        { 17, 24, 43, 119, 209, 235, 1 },
+        { 54, 189, 252, 65, 163, 17, 1 }, },
+      { { 0, 36, 28, 209, 199, 244, 0 },
+        { 116, 88, 114, 240, 64, 68, 1 },
+        { 23, 241, 197, 156, 18, 0, 0 },
+        { 145, 1, 7, 167, 13, 23, 0 }, },
+      { { 0, 65, 85, 60, 228, 236, 0 },
+        { 28, 120, 33, 21, 101, 6, 1 },
+        { 27, 147, 158, 85, 65, 0, 0 },
+        { 176, 83, 84, 66, 15, 28, 0 }, },
+      { { 2, 119, 133, 135, 91, 48, 1 },
+        { 194, 17, 18, 231, 133, 205, 1 },
+        { 134, 109, 112, 208, 247, 32, 0 },
+        { 217, 208, 243, 164, 68, 33, 1 }, },
+      { { 1, 218, 232, 155, 2, 227, 0 },
+        { 52, 141, 137, 230, 136, 26, 1 },
+        { 99, 160, 108, 139, 173, 192, 0 },
+        { 172, 8, 179, 200, 216, 150, 0 }, },
+      { { 4, 40, 5, 26, 111, 159, 0 },
+        { 25, 156, 26, 49, 224, 198, 0 },
+        { 124, 251, 44, 80, 10, 16, 0 },
+        { 49, 131, 198, 44, 28, 204, 0 }, },
+      { { 7, 145, 0, 75, 83, 171, 0 },
+        { 129, 29, 88, 96, 172, 19, 1 },
+        { 106, 229, 105, 0, 68, 240, 0 },
+        { 228, 26, 131, 13, 92, 64, 1 }, },
+      { { 10, 89, 153, 210, 227, 215, 1 },
+        { 190, 223, 120, 183, 132, 64, 0 },
+        { 245, 227, 165, 204, 205, 40, 0 },
+        { 1, 16, 246, 143, 125, 190, 1 }, },
+      { { 9, 178, 243, 249, 248, 177, 1 },
+        { 26, 127, 227, 195, 10, 219, 1 },
+        { 198, 143, 207, 231, 166, 200, 0 },
+        { 237, 168, 97, 227, 255, 44, 0 }, },
+      { { 13, 49, 205, 127, 92, 218, 1 },
+        { 55, 59, 75, 67, 229, 215, 0 },
+        { 173, 157, 127, 89, 198, 88, 0 },
+        { 117, 211, 225, 105, 110, 118, 0 }, },
+      { { 14, 110, 159, 79, 116, 37, 1 },
+        { 235, 214, 66, 87, 195, 15, 1 },
+        { 210, 23, 121, 124, 187, 56, 0 },
+        { 248, 97, 245, 33, 53, 235, 1 }, },
+      { { 23, 114, 128, 242, 245, 110, 0 },
+        { 157, 49, 126, 150, 224, 25, 1 },
+        { 59, 87, 167, 128, 167, 116, 0 },
+        { 204, 3, 180, 191, 70, 92, 1 }, },
+      { { 22, 255, 97, 63, 186, 238, 0 },
+        { 221, 169, 175, 117, 173, 139, 1 },
+        { 59, 174, 254, 67, 127, 180, 0 },
+        { 232, 218, 215, 122, 202, 221, 1 }, },
+      { { 25, 50, 221, 83, 147, 173, 1 },
+        { 50, 79, 119, 115, 160, 29, 1 },
+        { 218, 228, 229, 93, 166, 76, 0 },
+        { 220, 2, 231, 119, 121, 38, 0 }, },
+      { { 30, 55, 90, 161, 138, 28, 1 },
+        { 227, 99, 39, 240, 38, 200, 0 },
+        { 156, 40, 194, 173, 118, 60, 0 },
+        { 9, 178, 7, 242, 99, 99, 1 }, },
+      { { 30, 243, 155, 67, 46, 40, 0 },
+        { 169, 67, 70, 103, 238, 136, 1 },
+        { 10, 58, 97, 108, 231, 188, 0 },
+        { 136, 187, 243, 49, 97, 74, 1 }, },
+      { { 35, 152, 218, 66, 102, 77, 0 },
+        { 172, 213, 65, 58, 234, 16, 0 },
+        { 89, 51, 33, 45, 140, 226, 0 },
+        { 4, 43, 174, 65, 85, 154, 1 }, },
+      { { 35, 183, 98, 39, 73, 166, 1 },
+        { 194, 57, 155, 88, 143, 152, 1 },
+        { 178, 201, 114, 35, 118, 226, 0 },
+        { 140, 248, 141, 108, 206, 33, 1 }, },
+      { { 39, 232, 89, 247, 30, 7, 0 },
+        { 177, 228, 75, 253, 201, 145, 0 },
+        { 112, 60, 119, 205, 11, 242, 0 },
+        { 68, 201, 223, 233, 19, 198, 1 }, },
+      { { 41, 207, 36, 233, 56, 245, 0 },
+        { 76, 174, 192, 220, 12, 223, 1 },
+        { 87, 142, 75, 146, 121, 202, 0 },
+        { 253, 152, 29, 129, 186, 153, 0 }, },
+      { { 43, 202, 225, 232, 241, 71, 1 },
+        { 142, 182, 249, 159, 8, 27, 0 },
+        { 241, 71, 139, 195, 169, 234, 0 },
+        { 108, 8, 124, 207, 182, 184, 1 }, },
+      { { 46, 52, 167, 60, 136, 145, 0 },
+        { 209, 47, 162, 11, 3, 198, 0 },
+        { 68, 136, 158, 114, 150, 58, 0 },
+        { 49, 224, 104, 34, 250, 69, 1 }, },
+      { { 44, 130, 54, 130, 20, 241, 1 },
+        { 7, 78, 128, 136, 202, 77, 1 },
+        { 199, 148, 32, 182, 32, 154, 0 },
+        { 217, 41, 136, 128, 185, 112, 0 }, },
+      { { 52, 119, 39, 34, 124, 128, 0 },
+        { 73, 57, 134, 13, 198, 141, 0 },
+        { 0, 159, 34, 114, 119, 22, 0 },
+        { 88, 177, 216, 48, 206, 73, 0 }, },
+      { { 62, 106, 78, 239, 207, 36, 0 },
+        { 161, 178, 119, 252, 195, 142, 1 },
+        { 18, 121, 251, 185, 43, 62, 0 },
+        { 184, 225, 159, 247, 38, 194, 1 }, },
+      { { 61, 189, 0, 186, 135, 236, 0 },
+        { 85, 171, 54, 184, 236, 18, 1 },
+        { 27, 240, 174, 128, 94, 222, 0 },
+        { 164, 27, 142, 182, 106, 213, 0 }, },
+      { { 65, 89, 70, 17, 248, 154, 0 },
+        { 24, 153, 41, 68, 54, 213, 0 },
+        { 44, 143, 196, 49, 77, 65, 0 },
+        { 85, 182, 17, 74, 76, 140, 0 }, },
+      { { 66, 160, 192, 80, 251, 19, 1 },
+        { 154, 20, 123, 34, 24, 193, 0 },
+        { 228, 111, 133, 1, 130, 161, 0 },
+        { 65, 140, 34, 111, 20, 44, 1 }, },
+      { { 66, 215, 59, 80, 17, 218, 1 },
+        { 246, 73, 216, 5, 62, 73, 0 },
+        { 173, 196, 5, 110, 117, 161, 0 },
+        { 73, 62, 80, 13, 201, 55, 1 }, },
+      { { 71, 21, 159, 236, 40, 89, 1 },
+        { 239, 101, 64, 131, 55, 214, 0 },
+        { 205, 10, 27, 252, 212, 113, 0 },
+        { 53, 246, 96, 129, 83, 123, 1 }, },
+      { { 72, 72, 74, 156, 121, 141, 1 },
+        { 58, 158, 17, 148, 51, 131, 0 },
+        { 216, 207, 28, 169, 9, 9, 0 },
+        { 96, 230, 20, 196, 60, 174, 0 }, },
+      { { 75, 141, 239, 56, 120, 19, 0 },
+        { 248, 182, 137, 3, 30, 215, 0 },
+        { 100, 15, 14, 123, 216, 233, 0 },
+        { 117, 188, 96, 72, 182, 143, 1 }, },
+      { { 72, 197, 79, 119, 42, 255, 1 },
+        { 126, 46, 73, 117, 191, 196, 1 },
+        { 255, 170, 119, 121, 81, 137, 0 },
+        { 145, 254, 215, 73, 58, 63, 0 }, },
+      { { 73, 205, 149, 222, 250, 38, 0 },
+        { 88, 210, 104, 183, 157, 151, 1 },
+        { 50, 47, 189, 212, 217, 201, 0 },
+        { 244, 220, 246, 139, 37, 141, 0 }, },
+      { { 74, 248, 19, 154, 40, 250, 0 },
+        { 156, 203, 10, 133, 186, 194, 1 },
+        { 47, 138, 44, 228, 15, 169, 0 },
+        { 161, 174, 208, 168, 105, 156, 1 }, },
+      { { 76, 39, 45, 47, 65, 165, 0 },
+        { 97, 62, 146, 81, 149, 14, 1 },
+        { 82, 193, 122, 90, 114, 25, 0 },
+        { 184, 84, 197, 36, 190, 67, 0 }, },
+      { { 76, 63, 202, 163, 60, 106, 1 },
+        { 111, 163, 11, 194, 246, 137, 1 },
+        { 171, 30, 98, 169, 254, 25, 0 },
+        { 200, 183, 161, 232, 98, 251, 0 }, },
+      { { 76, 105, 150, 233, 240, 91, 0 },
+        { 13, 246, 106, 198, 54, 71, 0 },
+        { 109, 7, 203, 180, 203, 25, 0 },
+        { 113, 54, 49, 171, 55, 216, 0 }, },
+      { { 83, 59, 100, 210, 198, 162, 0 },
+        { 144, 153, 239, 160, 212, 28, 1 },
+        { 34, 177, 165, 147, 110, 101, 0 },
+        { 156, 21, 130, 251, 204, 132, 1 }, },
+      { { 81, 70, 77, 104, 180, 53, 1 },
+        { 106, 36, 101, 21, 80, 95, 1 },
+        { 214, 22, 139, 89, 49, 69, 0 },
+        { 253, 5, 84, 83, 18, 43, 0 }, },
+      { { 81, 86, 86, 98, 113, 201, 1 },
+        { 78, 125, 85, 4, 178, 29, 0 },
+        { 201, 199, 35, 53, 53, 69, 0 },
+        { 92, 38, 144, 85, 95, 57, 0 }, },
+      { { 80, 115, 53, 140, 113, 223, 1 },
+        { 14, 93, 158, 149, 53, 79, 0 },
+        { 253, 199, 24, 214, 103, 5, 0 },
+        { 121, 86, 84, 188, 221, 56, 0 }, },
+      { { 84, 74, 231, 46, 2, 158, 1 },
+        { 3, 168, 141, 55, 179, 78, 0 },
+        { 188, 160, 58, 115, 169, 21, 0 },
+        { 57, 102, 246, 88, 138, 224, 0 }, },
+      { { 84, 219, 22, 238, 94, 71, 0 },
+        { 5, 245, 76, 180, 223, 143, 0 },
+        { 113, 61, 59, 180, 109, 149, 0 },
+        { 120, 253, 150, 153, 87, 208, 0 }, },
+      { { 86, 240, 240, 30, 140, 100, 1 },
+        { 151, 65, 167, 22, 217, 130, 1 },
+        { 147, 24, 188, 7, 135, 181, 0 },
+        { 160, 205, 180, 114, 193, 116, 1 }, },
+      { { 91, 106, 3, 196, 23, 123, 1 },
+        { 134, 134, 94, 165, 115, 89, 1 },
+        { 239, 116, 17, 224, 43, 109, 0 },
+        { 205, 103, 82, 189, 48, 176, 1 }, },
+      { { 91, 249, 239, 82, 25, 108, 1 },
+        { 182, 131, 215, 23, 190, 149, 1 },
+        { 155, 76, 37, 123, 207, 237, 0 },
+        { 212, 190, 244, 117, 224, 182, 1 }, },
+      { { 92, 116, 249, 2, 251, 190, 0 },
+        { 105, 91, 191, 55, 176, 193, 1 },
+        { 62, 239, 160, 79, 151, 29, 0 },
+        { 193, 134, 246, 126, 237, 75, 0 }, },
+      { { 94, 157, 11, 47, 79, 122, 1 },
+        { 231, 179, 28, 97, 255, 194, 1 },
+        { 175, 121, 122, 104, 92, 189, 0 },
+        { 161, 255, 195, 28, 102, 243, 1 }, },
+      { { 99, 67, 213, 185, 201, 130, 0 },
+        { 144, 120, 57, 207, 20, 158, 0 },
+        { 32, 201, 206, 213, 225, 99, 0 },
+        { 60, 148, 121, 206, 15, 4, 1 }, },
+      { { 96, 93, 164, 245, 22, 155, 1 },
+        { 82, 173, 200, 238, 117, 69, 0 },
+        { 236, 180, 87, 146, 221, 3, 0 },
+        { 81, 87, 59, 137, 218, 165, 0 }, },
+      { { 100, 136, 47, 135, 72, 47, 0 },
+        { 33, 148, 136, 217, 187, 132, 1 },
+        { 122, 9, 112, 250, 8, 147, 0 },
+        { 144, 238, 205, 136, 148, 194, 0 }, },
+      { { 104, 106, 145, 148, 102, 64, 0 },
+        { 28, 210, 2, 175, 81, 8, 0 },
+        { 1, 51, 20, 196, 171, 11, 0 },
+        { 8, 69, 122, 160, 37, 156, 0 }, },
+      { { 108, 55, 209, 238, 204, 101, 1 },
+        { 71, 119, 99, 155, 213, 138, 1 },
+        { 211, 25, 187, 197, 246, 27, 0 },
+        { 168, 213, 236, 227, 119, 113, 0 }, },
+      { { 109, 89, 245, 135, 43, 42, 0 },
+        { 9, 195, 153, 239, 181, 148, 1 },
+        { 42, 106, 112, 215, 205, 91, 0 },
+        { 148, 214, 251, 204, 225, 200, 0 }, },
+      { { 115, 31, 7, 158, 40, 12, 0 },
+        { 216, 129, 4, 153, 183, 158, 0 },
+        { 24, 10, 60, 240, 124, 103, 0 },
+        { 60, 246, 204, 144, 64, 141, 1 }, },
+      { { 114, 38, 22, 146, 200, 199, 1 },
+        { 214, 92, 46, 152, 146, 140, 0 },
+        { 241, 137, 164, 180, 50, 39, 0 },
+        { 24, 164, 140, 186, 29, 53, 1 }, },
+      { { 115, 131, 239, 207, 199, 93, 1 },
+        { 166, 20, 245, 251, 255, 94, 0 },
+        { 221, 113, 249, 251, 224, 231, 0 },
+        { 61, 127, 239, 215, 148, 50, 1 }, },
+      { { 113, 246, 244, 181, 170, 13, 0 },
+        { 88, 101, 167, 254, 57, 156, 0 },
+        { 88, 42, 214, 151, 183, 199, 0 },
+        { 28, 206, 63, 242, 211, 13, 0 }, },
+      { { 118, 16, 2, 241, 170, 59, 0 },
+        { 153, 37, 108, 232, 50, 192, 1 },
+        { 110, 42, 199, 160, 4, 55, 0 },
+        { 129, 166, 11, 155, 82, 76, 1 }, },
+      { { 118, 84, 255, 84, 38, 33, 0 },
+        { 249, 69, 197, 47, 83, 4, 1 },
+        { 66, 50, 21, 127, 149, 55, 0 },
+        { 144, 101, 122, 81, 209, 79, 1 }, },
+      { { 122, 227, 200, 30, 38, 54, 0 },
+        { 184, 2, 15, 62, 221, 74, 1 },
+        { 54, 50, 60, 9, 227, 175, 0 },
+        { 169, 93, 190, 120, 32, 14, 1 }, },
+      { { 126, 32, 91, 27, 109, 102, 0 },
+        { 189, 82, 31, 89, 210, 130, 1 },
+        { 51, 91, 108, 109, 2, 63, 0 },
+        { 160, 165, 205, 124, 37, 94, 1 }, },
+      { { 124, 113, 102, 127, 179, 75, 1 },
+        { 31, 39, 255, 108, 183, 7, 0 },
+        { 233, 102, 255, 51, 71, 31, 0 },
+        { 112, 118, 155, 127, 242, 124, 0 }, },
+      { { 126, 136, 249, 129, 71, 26, 0 },
+        { 161, 210, 157, 235, 120, 64, 0 },
+        { 44, 113, 64, 207, 136, 191, 0 },
+        { 1, 15, 107, 220, 165, 194, 1 }, },
+      { { 127, 189, 182, 243, 152, 70, 0 },
+        { 213, 227, 238, 218, 158, 149, 0 },
+        { 49, 12, 231, 182, 222, 255, 0 },
+        { 84, 188, 173, 187, 227, 213, 1 }, },
+      { { 131, 186, 63, 66, 156, 103, 0 },
+        { 164, 197, 234, 17, 202, 189, 1 },
+        { 115, 28, 161, 126, 46, 224, 1 },
+        { 222, 169, 196, 43, 209, 146, 1 }, },
+      { { 131, 179, 163, 188, 159, 85, 1 },
+        { 150, 37, 178, 179, 79, 251, 0 },
+        { 213, 124, 158, 226, 230, 224, 1 },
+        { 111, 249, 102, 166, 210, 52, 1 }, },
+      { { 134, 184, 56, 238, 195, 91, 1 },
+        { 167, 245, 250, 160, 169, 98, 0 },
+        { 237, 97, 187, 142, 14, 176, 1 },
+        { 35, 74, 130, 175, 215, 242, 1 }, },
+      { { 138, 251, 116, 46, 23, 43, 0 },
+        { 128, 231, 155, 36, 237, 47, 1 },
+        { 106, 116, 58, 23, 111, 168, 1 },
+        { 250, 91, 146, 108, 243, 128, 1 }, },
+      { { 142, 5, 134, 252, 131, 42, 0 },
+        { 209, 34, 120, 162, 39, 38, 1 },
+        { 42, 96, 159, 176, 208, 56, 1 },
+        { 178, 114, 34, 143, 34, 69, 1 }, },
+      { { 143, 72, 60, 30, 32, 231, 0 },
+        { 189, 206, 136, 20, 129, 54, 1 },
+        { 115, 130, 60, 30, 9, 120, 1 },
+        { 182, 64, 148, 8, 185, 222, 1 }, },
+      { { 142, 83, 181, 252, 28, 224, 0 },
+        { 149, 107, 192, 135, 69, 175, 1 },
+        { 3, 156, 31, 214, 229, 56, 1 },
+        { 250, 209, 112, 129, 235, 84, 1 }, },
+      { { 141, 157, 35, 130, 73, 96, 0 },
+        { 69, 147, 144, 129, 142, 176, 1 },
+        { 3, 73, 32, 226, 92, 216, 1 },
+        { 134, 184, 192, 132, 228, 209, 0 }, },
+      { { 141, 185, 144, 117, 146, 156, 1 },
+        { 19, 235, 98, 114, 45, 113, 0 },
+        { 156, 164, 215, 4, 206, 216, 1 },
+        { 71, 90, 39, 35, 107, 228, 0 }, },
+      { { 144, 19, 230, 225, 162, 176, 0 },
+        { 8, 41, 229, 226, 6, 108, 1 },
+        { 6, 162, 195, 179, 228, 4, 1 },
+        { 155, 48, 35, 211, 202, 8, 0 }, },
+      { { 147, 155, 55, 123, 26, 144, 1 },
+        { 146, 233, 196, 97, 142, 255, 0 },
+        { 132, 172, 111, 118, 108, 228, 1 },
+        { 127, 184, 195, 17, 203, 164, 1 }, },
+      { { 151, 14, 49, 237, 242, 168, 1 },
+        { 203, 248, 228, 225, 33, 59, 1 },
+        { 138, 167, 219, 198, 56, 116, 1 },
+        { 238, 66, 67, 147, 143, 233, 1 }, },
+      { { 151, 52, 94, 59, 153, 170, 0 },
+        { 241, 105, 63, 64, 162, 183, 1 },
+        { 42, 204, 238, 61, 22, 116, 1 },
+        { 246, 162, 129, 126, 75, 71, 1 }, },
+      { { 149, 122, 253, 44, 125, 85, 0 },
+        { 45, 245, 151, 23, 65, 255, 0 },
+        { 85, 95, 26, 95, 175, 84, 1 },
+        { 127, 193, 116, 116, 215, 218, 0 }, },
+      { { 151, 221, 14, 6, 20, 80, 1 },
+        { 231, 129, 4, 4, 207, 117, 0 },
+        { 133, 20, 48, 56, 93, 244, 1 },
+        { 87, 121, 144, 16, 64, 243, 1 }, },
+      { { 154, 154, 4, 227, 189, 68, 1 },
+        { 142, 163, 116, 208, 200, 173, 0 },
+        { 145, 94, 227, 144, 44, 172, 1 },
+        { 90, 137, 133, 151, 98, 184, 1 }, },
+      { { 155, 190, 173, 173, 13, 248, 1 },
+        { 230, 171, 150, 195, 105, 254, 1 },
+        { 143, 216, 90, 218, 190, 236, 1 },
+        { 191, 203, 97, 180, 234, 179, 1 }, },
+      { { 157, 103, 144, 38, 24, 93, 0 },
+        { 69, 102, 6, 22, 165, 249, 0 },
+        { 93, 12, 50, 4, 243, 92, 1 },
+        { 79, 210, 180, 48, 51, 81, 0 }, },
+      { { 159, 129, 201, 246, 175, 127, 0 },
+        { 189, 38, 125, 179, 237, 240, 1 },
+        { 127, 122, 183, 201, 192, 252, 1 },
+        { 135, 219, 230, 223, 50, 94, 1 }, },
+      { { 159, 247, 196, 109, 149, 97, 1 },
+        { 199, 39, 119, 70, 77, 63, 1 },
+        { 195, 84, 219, 17, 247, 252, 1 },
+        { 254, 89, 49, 119, 114, 113, 1 }, },
+      { { 167, 3, 62, 38, 186, 122, 0 },
+        { 173, 96, 168, 40, 167, 253, 1 },
+        { 47, 46, 178, 62, 96, 114, 1 },
+        { 223, 242, 138, 10, 131, 90, 1 }, },
+      { { 166, 79, 109, 144, 30, 111, 0 },
+        { 245, 132, 137, 189, 100, 173, 1 },
+        { 123, 60, 4, 219, 121, 50, 1 },
+        { 218, 147, 94, 200, 144, 215, 1 }, },
+      { { 166, 84, 136, 155, 103, 3, 0 },
+        { 249, 21, 24, 238, 192, 34, 0 },
+        { 96, 115, 108, 136, 149, 50, 1 },
+        { 34, 1, 187, 140, 84, 79, 1 }, },
+      { { 164, 250, 171, 52, 23, 138, 0 },
+        { 49, 169, 154, 47, 107, 41, 0 },
+        { 40, 244, 22, 106, 175, 146, 1 },
+        { 74, 107, 122, 44, 202, 198, 0 }, },
+      { { 169, 35, 165, 79, 219, 255, 1 },
+        { 6, 30, 250, 123, 165, 255, 1 },
+        { 255, 237, 249, 82, 226, 74, 1 },
+        { 255, 210, 239, 47, 188, 48, 0 }, },
+      { { 175, 22, 89, 55, 116, 14, 1 },
+        { 251, 115, 9, 89, 225, 57, 0 },
+        { 184, 23, 118, 77, 52, 122, 1 },
+        { 78, 67, 205, 72, 103, 111, 1 }, },
+      { { 174, 60, 2, 96, 17, 226, 1 },
+        { 199, 171, 90, 8, 2, 33, 1 },
+        { 163, 196, 3, 32, 30, 58, 1 },
+        { 194, 32, 8, 45, 106, 241, 1 }, },
+      { { 174, 166, 70, 29, 70, 134, 0 },
+        { 209, 26, 11, 120, 75, 46, 0 },
+        { 48, 177, 92, 49, 50, 186, 1 },
+        { 58, 105, 15, 104, 44, 69, 1 }, },
+      { { 174, 169, 188, 206, 254, 64, 0 },
+        { 173, 210, 226, 170, 205, 167, 0 },
+        { 1, 63, 185, 158, 202, 186, 1 },
+        { 114, 217, 170, 163, 165, 218, 1 }, },
+      { { 177, 170, 233, 41, 210, 190, 0 },
+        { 32, 184, 175, 123, 40, 123, 1 },
+        { 62, 165, 202, 75, 170, 198, 1 },
+        { 239, 10, 111, 122, 142, 130, 0 }, },
+      { { 179, 236, 199, 247, 61, 40, 0 },
+        { 216, 160, 87, 207, 235, 181, 1 },
+        { 10, 94, 119, 241, 155, 230, 1 },
+        { 214, 235, 249, 245, 2, 141, 1 }, },
+      { { 179, 242, 249, 209, 5, 96, 1 },
+        { 182, 65, 215, 207, 72, 56, 1 },
+        { 131, 80, 69, 207, 167, 230, 1 },
+        { 142, 9, 121, 245, 193, 54, 1 }, },
+      { { 183, 83, 178, 95, 132, 147, 0 },
+        { 145, 77, 236, 78, 199, 122, 0 },
+        { 100, 144, 253, 38, 229, 118, 1 },
+        { 47, 113, 185, 27, 217, 68, 1 }, },
+      { { 180, 99, 115, 84, 106, 222, 0 },
+        { 29, 88, 207, 61, 39, 232, 0 },
+        { 61, 171, 21, 103, 99, 22, 1 },
+        { 11, 242, 94, 121, 141, 92, 0 }, },
+      { { 182, 97, 89, 33, 192, 136, 0 },
+        { 161, 120, 39, 77, 36, 32, 0 },
+        { 8, 129, 194, 77, 67, 54, 1 },
+        { 2, 18, 89, 114, 15, 66, 1 }, },
+      { { 186, 184, 208, 95, 68, 186, 1 },
+        { 146, 219, 79, 74, 233, 98, 1 },
+        { 174, 145, 125, 5, 142, 174, 1 },
+        { 163, 75, 169, 121, 109, 164, 1 }, },
+      { { 186, 192, 40, 124, 16, 3, 1 },
+        { 178, 38, 204, 12, 9, 35, 0 },
+        { 224, 4, 31, 10, 1, 174, 1 },
+        { 98, 72, 24, 25, 178, 38, 1 }, },
+      { { 188, 9, 19, 77, 135, 103, 0 },
+        { 5, 198, 124, 121, 71, 34, 1 },
+        { 115, 112, 217, 100, 72, 30, 1 },
+        { 162, 113, 79, 31, 49, 208, 0 }, },
+      { { 190, 60, 15, 68, 249, 12, 0 },
+        { 233, 147, 118, 25, 35, 165, 0 },
+        { 24, 79, 145, 120, 30, 62, 1 },
+        { 82, 226, 76, 55, 100, 203, 1 }, },
+      { { 193, 39, 249, 24, 172, 4, 0 },
+        { 120, 64, 163, 19, 84, 186, 0 },
+        { 16, 26, 140, 79, 242, 65, 1 },
+        { 46, 149, 100, 98, 129, 15, 0 }, },
+      { { 194, 54, 103, 175, 248, 99, 1 },
+        { 206, 53, 171, 193, 147, 175, 1 },
+        { 227, 15, 250, 243, 54, 33, 1 },
+        { 250, 228, 193, 234, 214, 57, 1 }, },
+      { { 194, 202, 232, 228, 90, 50, 0 },
+        { 160, 176, 201, 166, 25, 233, 1 },
+        { 38, 45, 19, 139, 169, 161, 1 },
+        { 203, 204, 50, 201, 134, 130, 1 }, },
+      { { 198, 18, 22, 32, 228, 28, 0 },
+        { 137, 113, 32, 16, 114, 108, 0 },
+        { 28, 19, 130, 52, 36, 49, 1 },
+        { 27, 39, 4, 2, 71, 72, 1 }, },
+      { { 199, 229, 93, 208, 65, 150, 0 },
+        { 241, 88, 91, 149, 28, 116, 0 },
+        { 52, 193, 5, 221, 83, 241, 1 },
+        { 23, 28, 84, 237, 13, 71, 1 }, },
+      { { 202, 89, 204, 102, 248, 236, 0 },
+        { 172, 187, 97, 22, 181, 165, 1 },
+        { 27, 143, 179, 25, 205, 41, 1 },
+        { 210, 214, 180, 67, 110, 154, 1 }, },
+      { { 200, 251, 13, 58, 124, 119, 1 },
+        { 62, 183, 10, 21, 220, 239, 1 },
+        { 247, 31, 46, 88, 111, 137, 1 },
+        { 251, 157, 212, 40, 118, 190, 0 }, },
+      { { 204, 35, 191, 4, 244, 230, 0 },
+        { 45, 90, 170, 19, 87, 45, 1 },
+        { 51, 151, 144, 126, 226, 25, 1 },
+        { 218, 117, 100, 42, 173, 90, 0 }, },
+      { { 204, 185, 29, 222, 17, 77, 0 },
+        { 53, 199, 82, 145, 189, 39, 0 },
+        { 89, 68, 61, 220, 78, 153, 1 },
+        { 114, 94, 196, 165, 113, 214, 0 }, },
+      { { 214, 71, 53, 203, 221, 81, 1 },
+        { 199, 84, 244, 197, 212, 239, 0 },
+        { 197, 93, 233, 214, 113, 53, 1 },
+        { 123, 149, 209, 151, 149, 113, 1 }, },
+      { { 212, 80, 13, 82, 140, 243, 1 },
+        { 55, 13, 108, 5, 208, 228, 1 },
+        { 231, 152, 165, 88, 5, 21, 1 },
+        { 147, 133, 208, 27, 88, 118, 0 }, },
+      { { 214, 126, 50, 1, 136, 117, 0 },
+        { 197, 197, 166, 84, 18, 232, 1 },
+        { 87, 8, 192, 38, 63, 53, 1 },
+        { 139, 164, 21, 50, 209, 209, 1 }, },
+      { { 214, 239, 103, 48, 199, 69, 1 },
+        { 215, 180, 183, 53, 94, 44, 0 },
+        { 209, 113, 134, 115, 123, 181, 1 },
+        { 26, 61, 86, 118, 150, 245, 1 }, },
+      { { 217, 10, 193, 255, 8, 72, 0 },
+        { 20, 162, 69, 195, 177, 186, 0 },
+        { 9, 8, 127, 193, 168, 77, 1 },
+        { 46, 198, 225, 209, 34, 148, 0 }, },
+      { { 218, 68, 144, 181, 192, 149, 0 },
+        { 208, 126, 36, 214, 17, 96, 0 },
+        { 84, 129, 214, 132, 145, 45, 1 },
+        { 3, 68, 53, 146, 63, 5, 1 }, },
+      { { 218, 142, 240, 138, 31, 78, 1 },
+        { 198, 194, 157, 178, 248, 171, 0 },
+        { 185, 124, 40, 135, 184, 173, 1 },
+        { 106, 143, 166, 220, 161, 177, 1 }, },
+      { { 226, 186, 72, 154, 71, 244, 1 },
+        { 182, 153, 19, 184, 216, 106, 1 },
+        { 151, 241, 44, 137, 46, 163, 1 },
+        { 171, 13, 142, 228, 76, 182, 1 }, },
+      { { 226, 251, 142, 197, 152, 25, 0 },
+        { 160, 133, 98, 206, 63, 237, 0 },
+        { 76, 12, 209, 184, 239, 163, 1 },
+        { 91, 254, 57, 163, 80, 130, 1 }, },
+      { { 229, 62, 6, 191, 131, 16, 1 },
+        { 83, 161, 50, 232, 147, 126, 0 },
+        { 132, 96, 254, 176, 62, 83, 1 },
+        { 63, 100, 139, 166, 66, 229, 0 }, },
+      { { 230, 135, 176, 105, 180, 112, 0 },
+        { 205, 96, 224, 74, 92, 107, 1 },
+        { 7, 22, 203, 6, 240, 179, 1 },
+        { 235, 29, 41, 3, 131, 89, 1 }, },
+      { { 229, 161, 35, 223, 231, 210, 0 },
+        { 29, 24, 250, 233, 223, 114, 0 },
+        { 37, 243, 253, 226, 66, 211, 1 },
+        { 39, 125, 203, 175, 140, 92, 0 }, },
+      { { 228, 231, 74, 54, 176, 3, 0 },
+        { 121, 36, 43, 12, 159, 41, 0 },
+        { 96, 6, 182, 41, 115, 147, 1 },
+        { 74, 124, 152, 106, 18, 79, 0 }, },
+      { { 235, 25, 74, 181, 219, 227, 0 },
+        { 180, 191, 57, 232, 23, 177, 1 },
+        { 99, 237, 214, 169, 76, 107, 1 },
+        { 198, 244, 11, 206, 126, 150, 1 }, },
+      { { 235, 104, 214, 214, 135, 188, 0 },
+        { 144, 202, 115, 190, 243, 116, 1 },
+        { 30, 240, 181, 181, 139, 107, 1 },
+        { 151, 103, 190, 231, 41, 132, 1 }, },
+      { { 239, 76, 157, 25, 92, 242, 0 },
+        { 245, 218, 8, 79, 80, 247, 1 },
+        { 39, 157, 76, 92, 153, 123, 1 },
+        { 247, 133, 121, 8, 45, 215, 1 }, },
+      { { 240, 140, 65, 178, 161, 79, 1 },
+        { 94, 164, 61, 153, 184, 32, 0 },
+        { 249, 66, 166, 193, 24, 135, 1 },
+        { 2, 14, 204, 222, 18, 189, 0 }, },
+      { { 245, 42, 227, 102, 145, 91, 0 },
+        { 5, 164, 255, 11, 179, 121, 0 },
+        { 109, 68, 179, 99, 170, 87, 1 },
+        { 79, 102, 232, 127, 146, 208, 0 }, },
+      { { 247, 127, 207, 238, 89, 167, 0 },
+        { 225, 189, 95, 159, 151, 191, 1 },
+        { 114, 205, 59, 249, 255, 119, 1 },
+        { 254, 244, 252, 253, 94, 195, 1 }, },
+      { { 248, 218, 47, 9, 127, 235, 0 },
+        { 44, 159, 156, 109, 122, 175, 1 },
+        { 107, 255, 72, 122, 45, 143, 1 },
+        { 250, 175, 91, 28, 252, 154, 0 }, },
+      { { 252, 25, 236, 171, 9, 228, 1 },
+        { 39, 171, 149, 218, 148, 166, 1 },
+        { 147, 200, 106, 155, 204, 31, 1 },
+        { 178, 148, 173, 212, 234, 242, 0 }, },
+      { { 147, 75, 97, 136, 48, 21, 0 },
+        { 136, 132, 133, 149, 4, 123, 0 },
+        { 84, 6, 8, 195, 105, 100, 1 },
+        { 111, 16, 84, 208, 144, 136, 1 }, },
+      { { 200, 173, 102, 37, 128, 21, 1 },
+        { 66, 166, 163, 80, 31, 100, 0 },
+        { 212, 0, 210, 51, 90, 137, 1 },
+        { 19, 124, 5, 98, 178, 161, 0 }, },
+      { { 28, 218, 21, 111, 160, 160, 1 },
+        { 11, 235, 100, 69, 137, 14, 1 },
+        { 130, 130, 251, 84, 45, 156, 0 },
+        { 184, 72, 209, 19, 107, 232, 0 }, },
+      { { 35, 147, 244, 147, 165, 30, 0 },
+        { 152, 65, 185, 218, 236, 92, 0 },
+        { 60, 82, 228, 151, 228, 226, 0 },
+        { 29, 27, 173, 206, 193, 12, 1 }, },
+      { { 47, 88, 146, 189, 228, 140, 1 },
+        { 155, 251, 32, 222, 99, 18, 0 },
+        { 152, 147, 222, 164, 141, 122, 0 },
+        { 36, 99, 61, 130, 111, 236, 1 }, },
+      { { 67, 161, 247, 150, 104, 223, 0 },
+        { 156, 92, 139, 147, 191, 212, 0 },
+        { 125, 139, 52, 247, 194, 225, 0 },
+        { 21, 254, 228, 232, 157, 28, 1 }, },
+      { { 73, 80, 111, 179, 116, 206, 1 },
+        { 62, 59, 137, 213, 242, 21, 0 },
+        { 185, 151, 102, 251, 5, 73, 0 },
+        { 84, 39, 213, 200, 238, 62, 0 }, },
+      { { 82, 96, 94, 14, 152, 127, 0 },
+        { 164, 68, 47, 20, 179, 199, 1 },
+        { 127, 12, 184, 61, 3, 37, 0 },
+        { 241, 230, 148, 122, 17, 18, 1 }, },
+      { { 82, 145, 24, 227, 252, 161, 0 },
+        { 168, 125, 100, 192, 220, 129, 1 },
+        { 66, 159, 227, 140, 68, 165, 0 },
+        { 192, 157, 129, 147, 95, 10, 1 }, },
+      { { 101, 223, 133, 82, 42, 63, 1 },
+        { 91, 133, 72, 63, 188, 220, 1 },
+        { 254, 42, 37, 80, 253, 211, 0 },
+        { 157, 158, 254, 9, 80, 237, 0 }, },
+      { { 113, 72, 12, 215, 43, 160, 0 },
+        { 56, 136, 84, 236, 145, 148, 1 },
+        { 2, 234, 117, 152, 9, 71, 0 },
+        { 148, 196, 155, 149, 8, 142, 0 }, },
+      { { 142, 6, 96, 125, 160, 37, 0 },
+        { 217, 38, 225, 80, 1, 42, 1 },
+        { 82, 2, 223, 3, 48, 56, 1 },
+        { 170, 64, 5, 67, 178, 77, 1 }, },
+      { { 150, 170, 33, 3, 84, 112, 1 },
+        { 135, 144, 134, 65, 200, 105, 1 },
+        { 135, 21, 96, 66, 42, 180, 1 },
+        { 203, 9, 193, 48, 132, 240, 1 }, },
+      { { 161, 37, 174, 137, 93, 100, 1 },
+        { 102, 16, 146, 218, 70, 183, 1 },
+        { 147, 93, 72, 186, 210, 66, 1 },
+        { 246, 177, 45, 164, 132, 51, 0 }, },
+      { { 188, 234, 86, 10, 46, 231, 1 },
+        { 15, 206, 15, 60, 202, 174, 1 },
+        { 243, 186, 40, 53, 43, 158, 1 },
+        { 186, 169, 158, 120, 57, 248, 0 }, },
+      { { 194, 210, 70, 164, 139, 68, 0 },
+        { 132, 33, 49, 180, 27, 172, 0 },
+        { 17, 104, 146, 177, 37, 161, 1 },
+        { 26, 236, 22, 198, 66, 16, 1 }, },
+      { { 218, 226, 149, 139, 69, 176, 0 },
+        { 128, 90, 22, 199, 216, 110, 1 },
+        { 6, 209, 104, 212, 163, 173, 1 },
+        { 187, 13, 241, 180, 45, 0, 1 }, },
+      { { 236, 63, 99, 213, 29, 216, 0 },
+        { 85, 139, 211, 201, 119, 233, 0 },
+        { 13, 220, 85, 227, 126, 27, 1 },
+        { 75, 247, 73, 229, 232, 213, 0 }, },
+      { { 255, 105, 45, 60, 107, 15, 0 },
+        { 185, 182, 158, 61, 53, 182, 0 },
+        { 120, 107, 30, 90, 75, 127, 1 },
+        { 54, 214, 94, 60, 182, 206, 1 }, },
+      { { 0, 28, 79, 167, 70, 146, 1 },
+        { 98, 185, 9, 225, 195, 68, 0 },
+        { 164, 177, 114, 249, 28, 0, 0 },
+        { 17, 97, 195, 200, 78, 163, 0 }, },
+      { { 2, 24, 244, 93, 202, 150, 0 },
+        { 144, 217, 233, 114, 1, 198, 0 },
+        { 52, 169, 221, 23, 140, 32, 0 },
+        { 49, 192, 39, 75, 205, 132, 1 }, },
+      { { 3, 209, 163, 72, 235, 88, 0 },
+        { 140, 17, 240, 39, 46, 210, 0 },
+        { 13, 107, 137, 98, 197, 224, 0 },
+        { 37, 186, 114, 7, 196, 24, 1 }, },
+      { { 4, 27, 131, 253, 41, 154, 1 },
+        { 27, 169, 88, 195, 39, 202, 0 },
+        { 172, 202, 95, 224, 236, 16, 0 },
+        { 41, 242, 97, 141, 74, 236, 0 }, },
+      { { 9, 141, 142, 139, 148, 215, 1 },
+        { 102, 142, 40, 210, 206, 87, 0 },
+        { 245, 148, 232, 184, 216, 200, 0 },
+        { 117, 57, 165, 138, 56, 179, 0 }, },
+      { { 8, 163, 222, 26, 89, 139, 0 },
+        { 48, 94, 27, 2, 174, 143, 0 },
+        { 104, 205, 44, 61, 226, 136, 0 },
+        { 120, 186, 160, 108, 61, 6, 0 }, },
+      { { 11, 188, 12, 8, 32, 24, 0 },
+        { 232, 131, 2, 0, 40, 86, 0 },
+        { 12, 2, 8, 24, 30, 232, 0 },
+        { 53, 10, 0, 32, 96, 139, 1 }, },
+      { { 8, 180, 118, 44, 124, 199, 0 },
+        { 76, 127, 139, 16, 75, 135, 0 },
+        { 113, 159, 26, 55, 22, 136, 0 },
+        { 112, 233, 4, 104, 255, 25, 0 }, },
+      { { 8, 252, 181, 200, 85, 47, 1 },
+        { 66, 215, 218, 151, 104, 7, 1 },
+        { 250, 85, 9, 214, 159, 136, 0 },
+        { 240, 11, 116, 173, 245, 161, 0 }, },
+      { { 14, 22, 54, 84, 254, 34, 0 },
+        { 217, 83, 232, 32, 67, 141, 1 },
+        { 34, 63, 149, 54, 52, 56, 0 },
+        { 216, 225, 2, 11, 229, 77, 1 }, },
+      { { 18, 44, 177, 159, 7, 34, 1 },
+        { 210, 192, 158, 227, 193, 2, 1 },
+        { 162, 112, 124, 198, 154, 36, 0 },
+        { 160, 65, 227, 188, 129, 165, 1 }, },
+      { { 18, 69, 156, 171, 22, 232, 0 },
+        { 228, 104, 4, 230, 228, 7, 1 },
+        { 11, 180, 106, 156, 209, 36, 0 },
+        { 240, 19, 179, 144, 11, 19, 1 }, },
+      { { 19, 147, 126, 245, 174, 67, 1 },
+        { 190, 101, 237, 224, 79, 156, 0 },
+        { 225, 58, 215, 191, 100, 228, 0 },
+        { 28, 249, 3, 219, 211, 62, 1 }, },
+      { { 22, 41, 244, 18, 48, 140, 0 },
+        { 153, 200, 135, 18, 164, 5, 0 },
+        { 24, 134, 36, 23, 202, 52, 0 },
+        { 80, 18, 164, 112, 137, 204, 1 }, },
+      { { 21, 124, 103, 88, 122, 66, 0 },
+        { 93, 145, 207, 37, 2, 151, 0 },
+        { 33, 47, 13, 115, 31, 84, 0 },
+        { 116, 160, 82, 121, 196, 221, 0 }, },
+      { { 21, 204, 177, 89, 131, 214, 1 },
+        { 87, 200, 252, 119, 8, 82, 0 },
+        { 181, 224, 205, 70, 153, 212, 0 },
+        { 37, 8, 119, 31, 137, 245, 0 }, },
+      { { 23, 227, 47, 161, 221, 185, 0 },
+        { 161, 60, 182, 197, 110, 221, 1 },
+        { 78, 221, 194, 250, 99, 244, 0 },
+        { 221, 187, 81, 182, 158, 66, 1 }, },
+      { { 27, 70, 90, 142, 239, 10, 1 },
+        { 234, 82, 61, 164, 227, 154, 0 },
+        { 168, 123, 184, 173, 49, 108, 0 },
+        { 44, 227, 146, 222, 37, 43, 1 }, },
+      { { 27, 105, 78, 73, 179, 188, 1 },
+        { 170, 138, 119, 116, 38, 87, 1 },
+        { 158, 230, 201, 57, 75, 108, 0 },
+        { 245, 50, 23, 119, 40, 170, 1 }, },
+      { { 27, 196, 203, 219, 144, 138, 1 },
+        { 242, 10, 109, 199, 170, 19, 0 },
+        { 168, 132, 237, 233, 145, 236, 0 },
+        { 100, 42, 241, 219, 40, 39, 1 }, },
+      { { 31, 44, 109, 141, 119, 17, 1 },
+        { 235, 150, 151, 225, 65, 87, 0 },
+        { 196, 119, 88, 219, 26, 124, 0 },
+        { 117, 65, 67, 244, 180, 235, 1 }, },
+      { { 31, 87, 63, 15, 8, 234, 1 },
+        { 231, 75, 140, 69, 167, 158, 1 },
+        { 171, 136, 120, 126, 117, 124, 0 },
+        { 188, 242, 209, 24, 233, 115, 1 }, },
+      { { 28, 109, 100, 176, 216, 126, 1 },
+        { 87, 178, 175, 148, 36, 197, 1 },
+        { 191, 13, 134, 147, 91, 28, 0 },
+        { 209, 146, 20, 250, 166, 245, 0 }, },
+      { { 31, 214, 51, 233, 39, 78, 1 },
+        { 207, 99, 220, 245, 106, 26, 0 },
+        { 185, 114, 75, 230, 53, 252, 0 },
+        { 44, 43, 87, 157, 227, 121, 1 }, },
+      { { 31, 237, 94, 0, 105, 171, 1 },
+        { 235, 222, 31, 4, 46, 148, 1 },
+        { 234, 203, 0, 61, 91, 252, 0 },
+        { 148, 186, 16, 124, 61, 235, 1 }, },
+      { { 32, 25, 133, 43, 191, 166, 0 },
+        { 8, 169, 56, 123, 196, 135, 1 },
+        { 50, 254, 234, 80, 204, 2, 0 },
+        { 240, 145, 239, 14, 74, 136, 0 }, },
+      { { 34, 61, 51, 120, 7, 207, 0 },
+        { 212, 237, 218, 57, 102, 2, 0 },
+        { 121, 240, 15, 102, 94, 34, 0 },
+        { 32, 51, 78, 45, 219, 149, 1 }, },
+      { { 32, 99, 33, 28, 107, 49, 0 },
+        { 24, 20, 146, 45, 5, 202, 1 },
+        { 70, 107, 28, 66, 99, 2, 0 },
+        { 169, 208, 90, 36, 148, 12, 0 }, },
+      { { 34, 110, 87, 72, 118, 216, 1 },
+        { 206, 216, 67, 45, 98, 79, 0 },
+        { 141, 183, 9, 117, 59, 34, 0 },
+        { 121, 35, 90, 97, 13, 185, 1 }, },
+      { { 32, 116, 241, 178, 248, 194, 1 },
+        { 94, 121, 171, 143, 128, 129, 0 },
+        { 161, 143, 166, 199, 151, 2, 0 },
+        { 64, 128, 248, 234, 207, 61, 0 }, },
+      { { 33, 172, 61, 93, 237, 110, 0 },
+        { 124, 208, 250, 89, 105, 150, 1 },
+        { 59, 91, 221, 94, 26, 194, 0 },
+        { 180, 203, 77, 47, 133, 159, 0 }, },
+      { { 33, 195, 23, 29, 144, 62, 1 },
+        { 18, 64, 40, 93, 47, 95, 1 },
+        { 190, 4, 220, 116, 97, 194, 0 },
+        { 253, 122, 93, 10, 1, 36, 0 }, },
+      { { 39, 47, 226, 196, 67, 84, 0 },
+        { 197, 144, 211, 186, 7, 88, 0 },
+        { 21, 97, 17, 163, 250, 114, 0 },
+        { 13, 112, 46, 229, 132, 209, 1 }, },
+      { { 39, 159, 50, 224, 232, 133, 0 },
+        { 201, 253, 224, 152, 14, 152, 0 },
+        { 80, 139, 131, 166, 124, 242, 0 },
+        { 12, 184, 12, 131, 223, 201, 1 }, },
+      { { 38, 190, 33, 114, 154, 9, 1 },
+        { 211, 165, 226, 41, 168, 137, 0 },
+        { 200, 44, 167, 66, 62, 178, 0 },
+        { 72, 138, 202, 35, 210, 229, 1 }, },
+      { { 42, 3, 57, 247, 158, 125, 1 },
+        { 182, 102, 224, 249, 229, 201, 1 },
+        { 223, 60, 247, 206, 96, 42, 0 },
+        { 201, 211, 207, 131, 179, 54, 1 }, },
+      { { 43, 24, 147, 239, 72, 235, 0 },
+        { 132, 255, 72, 203, 163, 146, 1 },
+        { 107, 137, 123, 228, 140, 106, 0 },
+        { 164, 226, 233, 137, 127, 144, 1 }, },
+      { { 41, 20, 232, 100, 42, 8, 0 },
+        { 104, 35, 193, 42, 33, 144, 0 },
+        { 8, 42, 19, 11, 148, 74, 0 },
+        { 4, 194, 42, 65, 226, 11, 0 }, },
+      { { 41, 104, 166, 84, 120, 185, 0 },
+        { 24, 158, 194, 14, 35, 213, 1 },
+        { 78, 143, 21, 50, 139, 74, 0 },
+        { 213, 226, 56, 33, 188, 140, 0 }, },
+      { { 42, 193, 129, 37, 248, 55, 0 },
+        { 136, 54, 40, 95, 13, 193, 1 },
+        { 118, 15, 210, 64, 193, 170, 0 },
+        { 193, 216, 125, 10, 54, 8, 1 }, },
+      { { 40, 212, 32, 190, 102, 221, 1 },
+        { 94, 63, 128, 188, 233, 66, 0 },
+        { 221, 179, 62, 130, 21, 138, 0 },
+        { 33, 75, 158, 128, 254, 61, 0 }, },
+      { { 41, 251, 7, 40, 147, 64, 0 },
+        { 4, 163, 50, 45, 14, 31, 0 },
+        { 1, 100, 138, 112, 111, 202, 0 },
+        { 124, 56, 90, 38, 98, 144, 0 }, },
+      { { 45, 79, 27, 209, 68, 171, 0 },
+        { 113, 222, 72, 205, 102, 24, 1 },
+        { 106, 145, 69, 236, 121, 90, 0 },
+        { 140, 51, 89, 137, 61, 199, 0 }, },
+      { { 44, 77, 58, 93, 125, 209, 0 },
+        { 125, 222, 208, 76, 71, 195, 0 },
+        { 69, 223, 93, 46, 89, 26, 0 },
+        { 97, 241, 25, 5, 189, 223, 0 }, },
+      { { 46, 201, 163, 115, 80, 78, 1 },
+        { 151, 178, 200, 95, 174, 1, 0 },
+        { 185, 5, 103, 98, 201, 186, 0 },
+        { 64, 58, 253, 9, 166, 244, 1 }, },
+      { { 47, 242, 157, 56, 166, 39, 0 },
+        { 185, 103, 42, 63, 72, 30, 1 },
+        { 114, 50, 142, 92, 167, 250, 0 },
+        { 188, 9, 126, 42, 115, 78, 1 }, },
+      { { 51, 14, 242, 29, 118, 78, 0 },
+        { 220, 208, 141, 122, 99, 27, 0 },
+        { 57, 55, 92, 39, 184, 102, 0 },
+        { 108, 99, 47, 88, 133, 157, 1 }, },
+      { { 51, 46, 161, 171, 153, 4, 0 },
+        { 192, 160, 182, 219, 128, 155, 0 },
+        { 16, 76, 234, 194, 186, 102, 0 },
+        { 108, 128, 237, 182, 130, 129, 1 }, },
+      { { 49, 41, 200, 243, 224, 220, 1 },
+        { 62, 184, 103, 218, 164, 80, 0 },
+        { 157, 131, 231, 137, 202, 70, 0 },
+        { 5, 18, 173, 243, 14, 190, 0 }, },
+      { { 53, 0, 254, 245, 196, 8, 0 },
+        { 49, 112, 229, 202, 99, 20, 0 },
+        { 8, 17, 215, 191, 128, 86, 0 },
+        { 20, 99, 41, 211, 135, 70, 0 }, },
+      { { 55, 36, 110, 62, 36, 63, 0 },
+        { 249, 36, 143, 24, 227, 86, 1 },
+        { 126, 18, 62, 59, 18, 118, 0 },
+        { 181, 99, 140, 120, 146, 79, 1 }, },
+      { { 53, 81, 121, 197, 146, 92, 1 },
+        { 39, 65, 229, 253, 37, 81, 0 },
+        { 157, 36, 209, 207, 69, 86, 0 },
+        { 69, 82, 95, 211, 193, 114, 0 }, },
+      { { 54, 184, 189, 91, 81, 60, 0 },
+        { 177, 209, 214, 91, 168, 71, 1 },
+        { 30, 69, 109, 94, 142, 182, 0 },
+        { 241, 10, 237, 53, 197, 198, 1 }, },
+      { { 54, 221, 188, 202, 44, 119, 0 },
+        { 237, 197, 204, 158, 204, 198, 1 },
+        { 119, 26, 41, 158, 221, 182, 0 },
+        { 177, 153, 188, 153, 209, 219, 1 }, },
+      { { 55, 221, 249, 250, 116, 140, 0 },
+        { 249, 249, 197, 159, 236, 19, 0 },
+        { 24, 151, 47, 207, 221, 246, 0 },
+        { 100, 27, 252, 209, 207, 207, 1 }, },
+      { { 57, 8, 64, 158, 68, 97, 1 },
+        { 22, 150, 5, 136, 193, 18, 1 },
+        { 195, 17, 60, 129, 8, 78, 0 },
+        { 164, 65, 136, 208, 52, 180, 0 }, },
+      { { 59, 1, 93, 14, 177, 201, 1 },
+        { 174, 78, 53, 9, 165, 23, 0 },
+        { 201, 198, 184, 93, 64, 110, 0 },
+        { 116, 82, 200, 86, 57, 58, 1 }, },
+      { { 58, 14, 216, 225, 88, 0, 1 },
+        { 226, 242, 69, 202, 0, 137, 0 },
+        { 128, 13, 67, 141, 184, 46, 0 },
+        { 72, 128, 41, 209, 39, 163, 1 }, },
+      { { 56, 110, 40, 10, 241, 243, 1 },
+        { 110, 158, 190, 12, 128, 75, 1 },
+        { 231, 199, 168, 10, 59, 14, 0 },
+        { 233, 0, 152, 62, 188, 187, 0 }, },
+      { { 57, 97, 243, 168, 199, 88, 1 },
+        { 6, 114, 183, 175, 102, 82, 0 },
+        { 141, 113, 138, 231, 195, 78, 0 },
+        { 37, 51, 122, 246, 167, 48, 0 }, },
+      { { 57, 175, 5, 221, 138, 171, 1 },
+        { 82, 142, 110, 233, 45, 158, 1 },
+        { 234, 168, 221, 208, 122, 206, 0 },
+        { 188, 218, 75, 187, 56, 165, 0 }, },
+      { { 57, 172, 253, 140, 32, 166, 1 },
+        { 106, 202, 143, 155, 9, 22, 1 },
+        { 178, 130, 24, 223, 154, 206, 0 },
+        { 180, 72, 108, 248, 169, 171, 0 }, },
+      { { 56, 215, 227, 25, 189, 206, 1 },
+        { 94, 11, 189, 95, 110, 139, 0 },
+        { 185, 222, 204, 99, 245, 142, 0 },
+        { 104, 187, 125, 94, 232, 61, 0 }, },
+      { { 62, 29, 177, 174, 155, 223, 1 },
+        { 199, 239, 188, 187, 165, 195, 0 },
+        { 253, 236, 186, 198, 220, 62, 0 },
+        { 97, 210, 238, 158, 251, 241, 1 }, },
+      { { 63, 57, 54, 16, 131, 58, 1 },
+        { 147, 195, 190, 40, 38, 84, 1 },
+        { 174, 96, 132, 54, 78, 126, 0 },
+        { 149, 50, 10, 62, 225, 228, 1 }, },
+      { { 61, 68, 172, 103, 73, 121, 1 },
+        { 103, 54, 212, 78, 161, 212, 1 },
+        { 207, 73, 115, 26, 145, 94, 0 },
+        { 149, 194, 185, 21, 182, 115, 0 }, },
+      { { 62, 216, 120, 160, 212, 247, 1 },
+        { 167, 255, 173, 156, 72, 65, 1 },
+        { 247, 149, 130, 143, 13, 190, 0 },
+        { 193, 9, 28, 218, 255, 242, 1 }, },
+      { { 67, 45, 92, 111, 10, 140, 0 },
+        { 224, 232, 67, 112, 181, 150, 0 },
+        { 24, 168, 123, 29, 90, 97, 0 },
+        { 52, 214, 135, 97, 11, 131, 1 }, },
+      { { 66, 52, 3, 145, 156, 82, 1 },
+        { 214, 1, 42, 193, 82, 193, 0 },
+        { 165, 28, 196, 224, 22, 33, 0 },
+        { 65, 165, 65, 170, 64, 53, 1 }, },
+      { { 64, 59, 107, 130, 137, 239, 0 },
+        { 36, 141, 187, 145, 182, 136, 1 },
+        { 123, 200, 160, 235, 110, 1, 0 },
+        { 136, 182, 196, 238, 216, 146, 0 }, },
+      { { 67, 109, 145, 73, 70, 116, 0 },
+        { 196, 208, 66, 119, 84, 82, 1 },
+        { 23, 49, 73, 68, 219, 97, 0 },
+        { 165, 21, 119, 33, 5, 145, 1 }, },
+      { { 67, 151, 133, 107, 233, 44, 1 },
+        { 202, 49, 112, 83, 188, 158, 1 },
+        { 154, 75, 235, 80, 244, 225, 0 },
+        { 188, 158, 229, 7, 70, 41, 1 }, },
+      { { 71, 29, 159, 177, 209, 0, 1 },
+        { 243, 241, 48, 195, 22, 21, 0 },
+        { 128, 69, 198, 252, 220, 113, 0 },
+        { 84, 52, 97, 134, 71, 231, 1 }, },
+      { { 70, 43, 251, 166, 87, 121, 0 },
+        { 165, 244, 147, 163, 247, 73, 1 },
+        { 79, 117, 50, 239, 234, 49, 0 },
+        { 201, 119, 226, 228, 151, 210, 1 }, },
+      { { 70, 92, 73, 248, 0, 58, 1 },
+        { 243, 161, 73, 133, 48, 66, 1 },
+        { 174, 0, 15, 201, 29, 49, 0 },
+        { 161, 6, 80, 201, 66, 231, 1 }, },
+      { { 69, 118, 247, 32, 48, 38, 1 },
+        { 75, 97, 139, 23, 18, 29, 1 },
+        { 178, 6, 2, 119, 183, 81, 0 },
+        { 220, 36, 116, 104, 195, 105, 0 }, },
+      { { 70, 168, 40, 69, 154, 252, 0 },
+        { 165, 136, 226, 112, 57, 193, 1 },
+        { 31, 172, 209, 10, 10, 177, 0 },
+        { 193, 206, 7, 35, 136, 210, 1 }, },
+      { { 68, 160, 107, 94, 1, 10, 0 },
+        { 49, 0, 219, 1, 187, 2, 0 },
+        { 40, 64, 61, 107, 2, 145, 0 },
+        { 32, 110, 192, 109, 128, 70, 0 }, },
+      { { 69, 185, 78, 113, 53, 37, 0 },
+        { 57, 165, 83, 80, 94, 21, 1 },
+        { 82, 86, 71, 57, 78, 209, 0 },
+        { 212, 61, 5, 101, 82, 206, 0 }, },
+      { { 75, 113, 215, 160, 253, 197, 1 },
+        { 142, 127, 51, 151, 86, 149, 0 },
+        { 209, 223, 130, 245, 199, 105, 0 },
+        { 84, 181, 116, 230, 127, 56, 1 }, },
+      { { 79, 60, 121, 82, 108, 209, 1 },
+        { 255, 223, 195, 1, 208, 208, 0 },
+        { 197, 155, 37, 79, 30, 121, 0 },
+        { 5, 133, 192, 97, 253, 255, 1 }, },
+      { { 79, 178, 80, 33, 70, 98, 0 },
+        { 133, 115, 11, 96, 88, 24, 1 },
+        { 35, 49, 66, 5, 38, 249, 0 },
+        { 140, 13, 3, 104, 103, 80, 1 }, },
+      { { 79, 239, 177, 247, 108, 238, 1 },
+        { 223, 250, 202, 215, 253, 152, 1 },
+        { 187, 155, 119, 198, 251, 249, 0 },
+        { 140, 223, 245, 169, 175, 253, 1 }, },
+      { { 82, 75, 82, 250, 189, 204, 0 },
+        { 156, 232, 117, 148, 246, 139, 0 },
+        { 25, 222, 175, 165, 105, 37, 0 },
+        { 104, 183, 148, 215, 11, 156, 1 }, },
+      { { 83, 200, 244, 221, 123, 200, 1 },
+        { 158, 216, 213, 230, 57, 151, 0 },
+        { 137, 239, 93, 151, 137, 229, 0 },
+        { 116, 206, 51, 213, 141, 188, 1 }, },
+      { { 87, 5, 99, 141, 134, 48, 0 },
+        { 193, 0, 165, 225, 87, 82, 1 },
+        { 6, 48, 216, 227, 80, 117, 0 },
+        { 165, 117, 67, 210, 128, 65, 1 }, },
+      { { 85, 75, 225, 85, 227, 0, 0 },
+        { 25, 144, 245, 103, 21, 24, 0 },
+        { 0, 99, 213, 67, 233, 85, 0 },
+        { 12, 84, 115, 87, 132, 204, 0 }, },
+      { { 85, 138, 47, 175, 183, 98, 0 },
+        { 45, 160, 188, 225, 219, 31, 1 },
+        { 35, 118, 250, 250, 40, 213, 0 },
+        { 252, 109, 195, 158, 130, 218, 0 }, },
+      { { 84, 153, 49, 31, 160, 83, 0 },
+        { 29, 197, 172, 65, 157, 66, 0 },
+        { 101, 2, 252, 70, 76, 149, 0 },
+        { 33, 92, 193, 26, 209, 220, 0 }, },
+      { { 88, 13, 255, 122, 69, 176, 1 },
+        { 114, 250, 213, 3, 214, 70, 1 },
+        { 134, 209, 47, 127, 216, 13, 0 },
+        { 177, 53, 224, 85, 175, 167, 0 }, },
+      { { 90, 18, 17, 208, 247, 52, 1 },
+        { 154, 83, 116, 177, 80, 73, 1 },
+        { 150, 119, 133, 196, 36, 45, 0 },
+        { 201, 5, 70, 151, 101, 44, 1 }, },
+      { { 95, 17, 24, 22, 24, 164, 0 },
+        { 177, 75, 4, 16, 149, 145, 1 },
+        { 18, 140, 52, 12, 68, 125, 0 },
+        { 196, 212, 132, 16, 105, 70, 1 }, },
+      { { 93, 61, 87, 179, 227, 47, 0 },
+        { 89, 247, 63, 241, 182, 20, 1 },
+        { 122, 99, 230, 245, 94, 93, 0 },
+        { 148, 54, 199, 254, 119, 205, 0 }, },
+      { { 93, 74, 155, 244, 162, 166, 0 },
+        { 57, 234, 108, 183, 19, 24, 1 },
+        { 50, 162, 151, 236, 169, 93, 0 },
+        { 140, 100, 118, 155, 43, 206, 0 }, },
+      { { 94, 137, 78, 179, 16, 89, 0 },
+        { 181, 166, 5, 192, 190, 69, 0 },
+        { 77, 4, 102, 185, 72, 189, 0 },
+        { 81, 62, 129, 208, 50, 214, 1 }, },
+      { { 95, 182, 4, 116, 142, 30, 1 },
+        { 211, 35, 110, 48, 121, 220, 0 },
+        { 188, 56, 151, 16, 54, 253, 0 },
+        { 29, 207, 6, 59, 98, 101, 1 }, },
+      { { 95, 252, 162, 7, 10, 47, 1 },
+        { 195, 135, 142, 118, 187, 144, 1 },
+        { 250, 40, 112, 34, 159, 253, 0 },
+        { 132, 238, 183, 56, 240, 225, 1 }, },
+      { { 98, 20, 52, 163, 198, 43, 1 },
+        { 194, 117, 168, 232, 240, 4, 1 },
+        { 234, 49, 226, 150, 20, 35, 0 },
+        { 144, 7, 139, 138, 215, 33, 1 }, },
+      { { 96, 69, 249, 159, 75, 213, 0 },
+        { 116, 92, 145, 255, 149, 194, 0 },
+        { 85, 233, 124, 207, 209, 3, 0 },
+        { 33, 212, 255, 196, 157, 23, 0 }, },
+      { { 96, 94, 235, 202, 23, 75, 1 },
+        { 102, 133, 217, 175, 242, 11, 0 },
+        { 233, 116, 41, 235, 189, 3, 0 },
+        { 104, 39, 250, 205, 208, 179, 0 }, },
+      { { 97, 111, 101, 43, 244, 79, 0 },
+        { 76, 180, 171, 93, 244, 31, 0 },
+        { 121, 23, 234, 83, 123, 67, 0 },
+        { 124, 23, 221, 106, 150, 153, 0 }, },
+      { { 96, 111, 231, 237, 175, 53, 0 },
+        { 72, 164, 243, 255, 87, 206, 1 },
+        { 86, 122, 219, 243, 251, 3, 0 },
+        { 185, 245, 127, 231, 146, 137, 0 }, },
+      { { 98, 227, 54, 39, 167, 213, 0 },
+        { 140, 108, 178, 124, 223, 76, 0 },
+        { 85, 242, 242, 54, 99, 163, 0 },
+        { 25, 125, 159, 38, 155, 24, 1 }, },
+      { { 101, 50, 13, 146, 242, 6, 0 },
+        { 57, 17, 42, 185, 144, 29, 0 },
+        { 48, 39, 164, 216, 38, 83, 0 },
+        { 92, 4, 206, 170, 68, 78, 0 }, },
+      { { 101, 174, 116, 178, 81, 246, 0 },
+        { 85, 248, 155, 152, 152, 93, 1 },
+        { 55, 197, 38, 151, 58, 211, 0 },
+        { 221, 12, 140, 236, 143, 213, 0 }, },
+      { { 106, 37, 233, 73, 31, 2, 1 },
+        { 226, 2, 219, 107, 84, 131, 0 },
+        { 160, 124, 73, 75, 210, 43, 0 },
+        { 96, 149, 107, 109, 160, 35, 1 }, },
+      { { 105, 154, 22, 139, 171, 78, 0 },
+        { 12, 195, 56, 248, 186, 158, 0 },
+        { 57, 106, 232, 180, 44, 203, 0 },
+        { 60, 174, 143, 142, 97, 152, 0 }, },
+      { { 104, 159, 185, 186, 26, 80, 0 },
+        { 116, 227, 128, 171, 156, 203, 0 },
+        { 5, 44, 46, 206, 252, 139, 0 },
+        { 105, 156, 234, 128, 227, 151, 0 }, },
+      { { 104, 172, 27, 248, 226, 27, 1 },
+        { 122, 246, 106, 169, 58, 66, 0 },
+        { 236, 35, 143, 236, 26, 139, 0 },
+        { 33, 46, 74, 171, 55, 175, 0 }, },
+      { { 107, 204, 220, 27, 224, 85, 0 },
+        { 252, 214, 33, 94, 152, 86, 0 },
+        { 85, 3, 236, 29, 153, 235, 0 },
+        { 53, 12, 189, 66, 53, 159, 1 }, },
+      { { 110, 70, 68, 174, 42, 27, 1 },
+        { 203, 38, 9, 172, 177, 206, 0 },
+        { 236, 42, 58, 145, 49, 59, 0 },
+        { 57, 198, 154, 200, 50, 105, 1 }, },
+      { { 110, 91, 221, 156, 85, 145, 1 },
+        { 179, 223, 17, 143, 85, 79, 0 },
+        { 196, 213, 28, 221, 237, 59, 0 },
+        { 121, 85, 120, 196, 125, 230, 1 }, },
+      { { 110, 114, 103, 14, 62, 109, 0 },
+        { 141, 7, 131, 61, 243, 143, 1 },
+        { 91, 62, 56, 115, 39, 59, 0 },
+        { 248, 231, 222, 96, 240, 88, 1 }, },
+      { { 111, 134, 147, 35, 45, 171, 0 },
+        { 201, 110, 24, 75, 250, 152, 1 },
+        { 106, 218, 98, 100, 176, 251, 0 },
+        { 140, 175, 233, 12, 59, 73, 1 }, },
+      { { 108, 137, 244, 64, 218, 114, 1 },
+        { 7, 210, 233, 42, 28, 197, 1 },
+        { 167, 45, 129, 23, 200, 155, 0 },
+        { 209, 156, 42, 75, 165, 240, 0 }, },
+      { { 111, 156, 82, 187, 178, 211, 1 },
+        { 223, 239, 41, 232, 154, 83, 0 },
+        { 229, 166, 238, 165, 28, 251, 0 },
+        { 101, 44, 139, 202, 123, 253, 1 }, },
+      { { 111, 148, 127, 90, 90, 175, 1 },
+        { 243, 95, 201, 57, 186, 151, 1 },
+        { 250, 173, 45, 127, 20, 251, 0 },
+        { 244, 174, 206, 73, 253, 103, 1 }, },
+      { { 110, 168, 22, 55, 188, 108, 1 },
+        { 159, 226, 34, 88, 251, 133, 1 },
+        { 155, 30, 246, 52, 10, 187, 0 },
+        { 208, 239, 141, 34, 35, 252, 1 }, },
+      { { 110, 177, 138, 108, 23, 81, 0 },
+        { 165, 39, 82, 42, 95, 67, 0 },
+        { 69, 116, 27, 40, 198, 187, 0 },
+        { 97, 125, 42, 37, 114, 82, 1 }, },
+      { { 111, 200, 142, 200, 247, 162, 0 },
+        { 169, 154, 120, 174, 90, 23, 1 },
+        { 34, 247, 137, 184, 137, 251, 0 },
+        { 244, 45, 58, 143, 44, 202, 1 }, },
+      { { 115, 81, 80, 190, 35, 239, 0 },
+        { 156, 109, 29, 188, 181, 18, 1 },
+        { 123, 226, 62, 133, 69, 103, 0 },
+        { 164, 86, 158, 220, 91, 28, 1 }, },
+      { { 112, 139, 71, 240, 27, 189, 0 },
+        { 16, 172, 85, 185, 62, 205, 1 },
+        { 94, 236, 7, 241, 104, 135, 0 },
+        { 217, 190, 78, 213, 26, 132, 0 }, },
+      { { 112, 149, 37, 251, 26, 110, 1 },
+        { 86, 33, 204, 249, 188, 135, 1 },
+        { 187, 44, 111, 210, 84, 135, 0 },
+        { 240, 158, 207, 153, 194, 53, 0 }, },
+      { { 114, 158, 255, 114, 99, 90, 0 },
+        { 252, 241, 221, 43, 186, 76, 0 },
+        { 45, 99, 39, 127, 188, 167, 0 },
+        { 25, 46, 234, 93, 199, 159, 1 }, },
+      { { 112, 171, 227, 124, 150, 208, 1 },
+        { 22, 168, 231, 43, 95, 75, 0 },
+        { 133, 180, 159, 99, 234, 135, 0 },
+        { 105, 125, 106, 115, 138, 180, 0 }, },
+      { { 114, 245, 151, 82, 179, 142, 0 },
+        { 216, 73, 126, 63, 190, 5, 0 },
+        { 56, 230, 165, 116, 215, 167, 0 },
+        { 80, 62, 254, 63, 73, 13, 1 }, },
+      { { 118, 5, 164, 230, 226, 221, 0 },
+        { 205, 60, 228, 186, 181, 68, 0 },
+        { 93, 163, 179, 146, 208, 55, 0 },
+        { 17, 86, 174, 147, 158, 89, 1 }, },
+      { { 116, 17, 6, 76, 105, 165, 0 },
+        { 9, 29, 84, 24, 23, 134, 1 },
+        { 82, 203, 25, 48, 68, 23, 0 },
+        { 176, 244, 12, 21, 92, 72, 0 }, },
+      { { 118, 36, 17, 60, 244, 246, 1 },
+        { 223, 120, 46, 25, 81, 67, 1 },
+        { 183, 151, 158, 68, 18, 55, 0 },
+        { 225, 69, 76, 58, 15, 125, 1 }, },
+      { { 116, 101, 193, 88, 187, 101, 1 },
+        { 95, 4, 119, 63, 20, 131, 1 },
+        { 211, 110, 141, 65, 211, 23, 0 },
+        { 224, 148, 126, 119, 16, 125, 0 }, },
+      { { 119, 125, 91, 58, 188, 225, 0 },
+        { 253, 237, 39, 13, 214, 147, 1 },
+        { 67, 158, 174, 109, 95, 119, 0 },
+        { 228, 181, 216, 114, 91, 223, 1 }, },
+      { { 119, 182, 15, 188, 123, 59, 0 },
+        { 249, 53, 30, 169, 59, 223, 1 },
+        { 110, 111, 30, 248, 54, 247, 0 },
+        { 253, 238, 74, 188, 86, 79, 1 }, },
+      { { 118, 180, 133, 0, 61, 168, 1 },
+        { 203, 9, 22, 11, 120, 133, 1 },
+        { 138, 222, 0, 80, 150, 183, 0 },
+        { 208, 143, 104, 52, 72, 105, 1 }, },
+      { { 117, 238, 187, 75, 14, 98, 1 },
+        { 103, 192, 206, 111, 218, 154, 1 },
+        { 163, 56, 105, 110, 187, 215, 0 },
+        { 172, 173, 251, 57, 129, 243, 0 }, },
+      { { 118, 250, 208, 216, 178, 184, 0 },
+        { 153, 201, 103, 174, 56, 75, 1 },
+        { 14, 166, 141, 133, 175, 183, 0 },
+        { 233, 14, 58, 243, 73, 204, 1 }, },
+      { { 120, 75, 97, 130, 218, 8, 1 },
+        { 2, 146, 165, 173, 180, 137, 0 },
+        { 136, 45, 160, 195, 105, 15, 0 },
+        { 72, 150, 218, 210, 164, 160, 0 }, },
+      { { 122, 187, 251, 47, 52, 31, 1 },
+        { 170, 231, 143, 91, 255, 75, 0 },
+        { 252, 22, 122, 111, 238, 175, 0 },
+        { 105, 127, 237, 120, 243, 170, 1 }, },
+      { { 127, 39, 5, 215, 84, 100, 0 },
+        { 213, 18, 70, 217, 213, 29, 1 },
+        { 19, 21, 117, 208, 114, 127, 0 },
+        { 220, 85, 205, 177, 36, 85, 1 }, },
+      { { 125, 227, 180, 31, 248, 152, 0 },
+        { 25, 90, 166, 78, 189, 223, 0 },
+        { 12, 143, 252, 22, 227, 223, 0 },
+        { 125, 222, 185, 50, 173, 76, 0 }, },
+      { { 127, 237, 141, 135, 251, 207, 1 },
+        { 239, 158, 62, 255, 189, 149, 0 },
+        { 249, 239, 240, 216, 219, 255, 0 },
+        { 84, 222, 255, 190, 60, 251, 1 }, },
+      { { 126, 246, 82, 55, 17, 197, 0 },
+        { 213, 111, 23, 92, 155, 9, 0 },
+        { 81, 196, 118, 37, 55, 191, 0 },
+        { 72, 108, 157, 116, 123, 85, 1 }, },
+      { { 129, 31, 240, 203, 185, 104, 1 },
+        { 78, 193, 241, 194, 164, 187, 1 },
+        { 139, 78, 233, 135, 252, 64, 1 },
+        { 238, 146, 161, 199, 193, 185, 0 }, },
+      { { 128, 46, 234, 6, 149, 52, 0 },
+        { 96, 128, 179, 18, 195, 105, 1 },
+        { 22, 84, 176, 43, 186, 0, 1 },
+        { 203, 97, 164, 102, 128, 131, 0 }, },
+      { { 130, 73, 255, 59, 138, 203, 1 },
+        { 182, 236, 169, 103, 166, 166, 0 },
+        { 233, 168, 238, 127, 201, 32, 1 },
+        { 50, 178, 243, 74, 155, 182, 1 }, },
+      { { 129, 200, 212, 49, 219, 37, 0 },
+        { 16, 244, 49, 118, 8, 181, 1 },
+        { 82, 109, 198, 21, 137, 192, 1 },
+        { 214, 136, 55, 70, 23, 132, 0 }, },
+      { { 132, 43, 15, 88, 160, 122, 0 },
+        { 61, 128, 106, 1, 38, 110, 1 },
+        { 47, 2, 141, 120, 106, 16, 1 },
+        { 187, 50, 64, 43, 0, 222, 0 }, },
+      { { 133, 43, 127, 179, 216, 14, 0 },
+        { 49, 240, 171, 209, 166, 189, 0 },
+        { 56, 13, 230, 255, 106, 80, 1 },
+        { 94, 178, 197, 234, 135, 198, 0 }, },
+      { { 134, 32, 167, 236, 235, 192, 1 },
+        { 143, 56, 242, 163, 3, 166, 0 },
+        { 129, 235, 155, 242, 130, 48, 1 },
+        { 50, 224, 98, 167, 142, 120, 1 }, },
+      { { 134, 89, 195, 75, 94, 119, 1 },
+        { 135, 149, 73, 119, 198, 227, 1 },
+        { 247, 61, 105, 97, 205, 48, 1 },
+        { 227, 177, 247, 73, 84, 240, 1 }, },
+      { { 135, 96, 6, 117, 87, 9, 0 },
+        { 145, 52, 82, 100, 99, 53, 0 },
+        { 72, 117, 87, 48, 3, 112, 1 },
+        { 86, 99, 19, 37, 22, 68, 1 }, },
+      { { 132, 219, 148, 26, 247, 200, 0 },
+        { 29, 217, 48, 38, 236, 47, 0 },
+        { 9, 247, 172, 20, 237, 144, 1 },
+        { 122, 27, 178, 6, 77, 220, 0 }, },
+      { { 138, 22, 181, 10, 57, 125, 0 },
+        { 204, 71, 144, 19, 160, 239, 1 },
+        { 95, 78, 40, 86, 180, 40, 1 },
+        { 251, 130, 228, 4, 241, 25, 1 }, },
+      { { 138, 63, 78, 17, 183, 8, 0 },
+        { 248, 131, 51, 96, 102, 45, 0 },
+        { 8, 118, 196, 57, 126, 40, 1 },
+        { 90, 51, 3, 102, 96, 143, 1 }, },
+      { { 137, 70, 134, 138, 98, 190, 0 },
+        { 72, 26, 8, 182, 162, 126, 1 },
+        { 62, 163, 40, 176, 177, 72, 1 },
+        { 191, 34, 182, 136, 44, 9, 0 }, },
+      { { 139, 122, 129, 163, 127, 219, 0 },
+        { 140, 191, 26, 231, 224, 249, 0 },
+        { 109, 255, 98, 192, 175, 104, 1 },
+        { 79, 131, 243, 172, 126, 152, 1 }, },
+      { { 137, 134, 220, 73, 174, 214, 0 },
+        { 108, 74, 105, 114, 72, 254, 0 },
+        { 53, 186, 201, 29, 176, 200, 1 },
+        { 63, 137, 39, 75, 41, 27, 0 }, },
+      { { 137, 153, 52, 70, 112, 178, 1 },
+        { 10, 219, 200, 0, 141, 117, 1 },
+        { 166, 135, 49, 22, 76, 200, 1 },
+        { 215, 88, 128, 9, 237, 168, 0 }, },
+      { { 139, 205, 202, 224, 85, 9, 1 },
+        { 226, 182, 81, 134, 110, 49, 0 },
+        { 200, 85, 3, 169, 217, 232, 1 },
+        { 70, 59, 48, 197, 54, 163, 1 }, },
+      { { 139, 222, 241, 118, 82, 104, 1 },
+        { 214, 243, 193, 39, 169, 57, 1 },
+        { 139, 37, 55, 71, 189, 232, 1 },
+        { 206, 74, 242, 65, 231, 181, 1 }, },
+      { { 142, 18, 98, 26, 198, 81, 1 },
+        { 151, 23, 161, 32, 194, 106, 0 },
+        { 197, 49, 172, 35, 36, 56, 1 },
+        { 43, 33, 130, 66, 244, 116, 1 }, },
+      { { 141, 46, 148, 181, 204, 168, 0 },
+        { 81, 250, 34, 194, 97, 188, 1 },
+        { 10, 153, 214, 148, 186, 88, 1 },
+        { 158, 195, 33, 162, 47, 197, 0 }, },
+      { { 140, 75, 185, 11, 82, 34, 0 },
+        { 33, 210, 136, 103, 132, 43, 1 },
+        { 34, 37, 104, 78, 233, 24, 1 },
+        { 234, 16, 243, 8, 165, 194, 0 }, },
+      { { 141, 153, 201, 208, 216, 171, 1 },
+        { 51, 159, 105, 131, 44, 177, 1 },
+        { 234, 141, 133, 201, 204, 216, 1 },
+        { 198, 154, 96, 203, 124, 230, 0 }, },
+      { { 144, 17, 129, 73, 60, 185, 1 },
+        { 10, 13, 68, 67, 100, 227, 1 },
+        { 206, 158, 73, 64, 196, 4, 1 },
+        { 227, 147, 97, 17, 88, 40, 0 }, },
+      { { 146, 45, 168, 84, 94, 84, 1 },
+        { 246, 144, 198, 50, 69, 225, 0 },
+        { 149, 61, 21, 10, 218, 36, 1 },
+        { 67, 209, 38, 49, 132, 183, 1 }, },
+      { { 144, 78, 120, 161, 56, 250, 1 },
+        { 110, 232, 141, 196, 32, 233, 1 },
+        { 175, 142, 66, 143, 57, 4, 1 },
+        { 203, 130, 17, 216, 139, 187, 0 }, },
+      { { 144, 151, 90, 16, 127, 241, 0 },
+        { 124, 93, 21, 32, 78, 233, 1 },
+        { 71, 255, 4, 45, 116, 132, 1 },
+        { 203, 185, 2, 84, 93, 31, 0 }, },
+      { { 144, 179, 61, 187, 100, 42, 0 },
+        { 56, 113, 142, 193, 236, 46, 1 },
+        { 42, 19, 110, 222, 102, 132, 1 },
+        { 186, 27, 193, 184, 199, 14, 0 }, },
+      { { 147, 192, 227, 79, 19, 241, 0 },
+        { 132, 12, 213, 103, 139, 115, 1 },
+        { 71, 228, 121, 99, 129, 228, 1 },
+        { 231, 104, 243, 85, 152, 16, 1 }, },
+      { { 151, 73, 34, 81, 12, 38, 0 },
+        { 145, 128, 204, 84, 70, 176, 1 },
+        { 50, 24, 69, 34, 73, 116, 1 },
+        { 134, 177, 21, 25, 128, 196, 1 }, },
+      { { 151, 74, 87, 164, 6, 195, 0 },
+        { 133, 236, 13, 165, 67, 60, 0 },
+        { 97, 176, 18, 245, 41, 116, 1 },
+        { 30, 97, 82, 216, 27, 208, 1 }, },
+      { { 150, 115, 104, 38, 246, 150, 1 },
+        { 171, 57, 175, 52, 197, 105, 0 },
+        { 180, 183, 178, 11, 103, 52, 1 },
+        { 75, 81, 150, 122, 206, 106, 1 }, },
+      { { 149, 138, 223, 218, 96, 3, 1 },
+        { 59, 212, 77, 131, 138, 62, 0 },
+        { 224, 3, 45, 253, 168, 212, 1 },
+        { 62, 40, 224, 217, 21, 238, 0 }, },
+      { { 150, 175, 46, 35, 58, 45, 0 },
+        { 233, 164, 134, 112, 174, 173, 1 },
+        { 90, 46, 98, 58, 122, 180, 1 },
+        { 218, 186, 135, 48, 146, 203, 1 }, },
+      { { 155, 7, 68, 229, 222, 47, 0 },
+        { 192, 54, 109, 240, 101, 189, 1 },
+        { 122, 61, 211, 145, 112, 108, 1 },
+        { 222, 211, 7, 219, 54, 1, 1 }, },
+      { { 152, 75, 88, 148, 206, 180, 0 },
+        { 48, 218, 37, 180, 69, 232, 1 },
+        { 22, 185, 148, 141, 105, 12, 1 },
+        { 139, 209, 22, 210, 45, 134, 0 }, },
+      { { 153, 122, 202, 55, 11, 119, 1 },
+        { 54, 167, 31, 118, 131, 248, 1 },
+        { 247, 104, 118, 41, 175, 76, 1 },
+        { 143, 224, 183, 124, 114, 182, 0 }, },
+      { { 156, 0, 144, 208, 133, 65, 1 },
+        { 23, 70, 116, 130, 64, 32, 0 },
+        { 193, 80, 133, 132, 128, 28, 1 },
+        { 2, 1, 32, 151, 49, 116, 0 }, },
+      { { 157, 117, 4, 69, 227, 242, 1 },
+        { 79, 27, 126, 100, 5, 116, 1 },
+        { 167, 227, 209, 16, 87, 92, 1 },
+        { 151, 80, 19, 63, 108, 121, 0 }, },
+      { { 160, 66, 244, 31, 20, 137, 1 },
+        { 18, 76, 129, 78, 225, 47, 0 },
+        { 200, 148, 124, 23, 161, 2, 1 },
+        { 122, 67, 185, 64, 153, 36, 0 }, },
+      { { 160, 154, 32, 41, 137, 97, 0 },
+        { 4, 165, 176, 72, 8, 170, 1 },
+        { 67, 72, 202, 2, 44, 130, 1 },
+        { 170, 136, 9, 6, 210, 144, 0 }, },
+      { { 161, 151, 65, 181, 6, 20, 0 },
+        { 80, 33, 1, 249, 77, 120, 0 },
+        { 20, 48, 86, 193, 116, 194, 1 },
+        { 15, 89, 79, 192, 66, 5, 0 }, },
+      { { 162, 199, 179, 237, 218, 219, 0 },
+        { 196, 124, 232, 239, 47, 235, 0 },
+        { 109, 173, 219, 230, 241, 162, 1 },
+        { 107, 250, 123, 139, 159, 17, 1 }, },
+      { { 163, 237, 115, 3, 171, 156, 0 },
+        { 200, 200, 179, 125, 174, 240, 0 },
+        { 28, 234, 224, 103, 91, 226, 1 },
+        { 7, 186, 223, 102, 137, 137, 1 }, },
+      { { 164, 14, 153, 123, 197, 24, 0 },
+        { 113, 240, 112, 75, 224, 106, 0 },
+        { 12, 81, 239, 76, 184, 18, 1 },
+        { 43, 3, 233, 7, 7, 199, 0 }, },
+      { { 166, 46, 211, 181, 170, 239, 0 },
+        { 221, 236, 43, 251, 35, 168, 1 },
+        { 123, 170, 214, 229, 186, 50, 1 },
+        { 138, 226, 111, 234, 27, 221, 1 }, },
+      { { 166, 72, 83, 81, 97, 91, 1 },
+        { 159, 212, 89, 77, 34, 96, 0 },
+        { 237, 67, 69, 101, 9, 50, 1 },
+        { 3, 34, 89, 77, 21, 252, 1 }, },
+      { { 166, 88, 46, 241, 183, 120, 1 },
+        { 191, 161, 240, 236, 98, 101, 1 },
+        { 143, 118, 199, 186, 13, 50, 1 },
+        { 211, 35, 27, 135, 194, 254, 1 }, },
+      { { 167, 125, 62, 203, 3, 105, 0 },
+        { 229, 197, 210, 236, 166, 54, 1 },
+        { 75, 96, 105, 190, 95, 114, 1 },
+        { 182, 50, 155, 165, 209, 211, 1 }, },
+      { { 165, 183, 40, 12, 100, 157, 0 },
+        { 105, 29, 130, 24, 109, 122, 0 },
+        { 92, 147, 24, 10, 118, 210, 1 },
+        { 47, 91, 12, 32, 220, 75, 0 }, },
+      { { 164, 207, 91, 78, 212, 244, 0 },
+        { 101, 216, 97, 29, 207, 107, 1 },
+        { 23, 149, 185, 109, 121, 146, 1 },
+        { 235, 121, 220, 67, 13, 211, 0 }, },
+      { { 171, 21, 211, 205, 48, 133, 0 },
+        { 200, 79, 65, 219, 7, 51, 0 },
+        { 80, 134, 89, 229, 212, 106, 1 },
+        { 102, 112, 109, 193, 121, 9, 1 }, },
+      { { 171, 47, 103, 30, 208, 8, 1 },
+        { 210, 146, 163, 9, 167, 63, 0 },
+        { 136, 5, 188, 115, 122, 106, 1 },
+        { 126, 114, 200, 98, 164, 165, 1 }, },
+      { { 168, 43, 177, 100, 80, 17, 1 },
+        { 2, 246, 194, 11, 5, 105, 0 },
+        { 196, 5, 19, 70, 234, 10, 1 },
+        { 75, 80, 104, 33, 183, 160, 0 }, },
+      { { 168, 67, 58, 121, 199, 250, 1 },
+        { 54, 122, 248, 108, 102, 106, 1 },
+        { 175, 241, 207, 46, 97, 10, 1 },
+        { 171, 51, 27, 15, 175, 54, 0 }, },
+      { { 168, 95, 145, 245, 169, 81, 0 },
+        { 92, 231, 112, 207, 5, 232, 0 },
+        { 69, 74, 215, 196, 253, 10, 1 },
+        { 11, 208, 121, 135, 115, 157, 0 }, },
+      { { 168, 126, 123, 132, 128, 94, 1 },
+        { 102, 195, 171, 157, 35, 104, 0 },
+        { 189, 0, 144, 239, 63, 10, 1 },
+        { 11, 98, 92, 234, 225, 179, 0 }, },
+      { { 168, 132, 121, 195, 96, 56, 1 },
+        { 106, 82, 193, 201, 168, 96, 1 },
+        { 142, 3, 97, 207, 16, 138, 1 },
+        { 131, 10, 201, 193, 165, 43, 0 }, },
+      { { 171, 163, 68, 207, 130, 112, 0 },
+        { 132, 2, 99, 232, 141, 126, 1 },
+        { 7, 32, 249, 145, 98, 234, 1 },
+        { 191, 88, 139, 227, 32, 16, 1 }, },
+      { { 171, 230, 49, 247, 179, 118, 0 },
+        { 220, 98, 250, 253, 137, 121, 1 },
+        { 55, 102, 247, 198, 51, 234, 1 },
+        { 207, 72, 223, 175, 163, 29, 1 }, },
+      { { 172, 22, 16, 22, 73, 151, 0 },
+        { 81, 95, 24, 24, 129, 232, 0 },
+        { 116, 201, 52, 4, 52, 26, 1 },
+        { 11, 192, 140, 12, 125, 69, 0 }, },
+      { { 174, 39, 216, 18, 235, 36, 1 },
+        { 251, 82, 51, 58, 132, 168, 1 },
+        { 146, 107, 164, 13, 242, 58, 1 },
+        { 138, 144, 174, 102, 37, 111, 1 }, },
+      { { 175, 59, 230, 2, 186, 159, 1 },
+        { 139, 143, 171, 58, 166, 253, 0 },
+        { 252, 174, 160, 51, 238, 122, 1 },
+        { 95, 178, 174, 106, 248, 232, 1 }, },
+      { { 174, 70, 26, 234, 137, 71, 1 },
+        { 231, 102, 120, 156, 130, 170, 0 },
+        { 241, 72, 171, 172, 49, 58, 1 },
+        { 42, 160, 156, 143, 51, 115, 1 }, },
+      { { 173, 66, 113, 218, 119, 159, 1 },
+        { 27, 94, 217, 189, 224, 123, 0 },
+        { 252, 247, 45, 199, 33, 90, 1 },
+        { 111, 3, 222, 205, 189, 108, 0 }, },
+      { { 173, 88, 23, 206, 43, 193, 1 },
+        { 15, 207, 80, 173, 131, 182, 0 },
+        { 193, 234, 57, 244, 13, 90, 1 },
+        { 54, 224, 218, 133, 121, 248, 0 }, },
+      { { 172, 151, 210, 208, 179, 77, 0 },
+        { 93, 71, 113, 186, 46, 41, 0 },
+        { 89, 102, 133, 165, 244, 154, 1 },
+        { 74, 58, 46, 199, 113, 93, 0 }, },
+      { { 173, 190, 197, 66, 11, 202, 0 },
+        { 69, 139, 91, 43, 168, 188, 0 },
+        { 41, 232, 33, 81, 190, 218, 1 },
+        { 30, 138, 234, 109, 104, 209, 0 }, },
+      { { 175, 250, 80, 85, 120, 101, 0 },
+        { 157, 215, 67, 92, 9, 185, 1 },
+        { 83, 15, 85, 5, 47, 250, 1 },
+        { 206, 200, 29, 97, 117, 220, 1 }, },
+      { { 176, 31, 206, 26, 12, 146, 1 },
+        { 114, 137, 13, 10, 198, 238, 0 },
+        { 164, 152, 44, 57, 252, 6, 1 },
+        { 59, 177, 168, 88, 72, 167, 0 }, },
+      { { 177, 112, 134, 190, 143, 137, 0 },
+        { 16, 45, 54, 174, 227, 182, 0 },
+        { 72, 248, 190, 176, 135, 70, 1 },
+        { 54, 227, 186, 182, 90, 4, 0 }, },
+      { { 183, 222, 54, 61, 41, 2, 0 },
+        { 217, 225, 156, 76, 11, 190, 0 },
+        { 32, 74, 94, 54, 61, 246, 1 },
+        { 62, 232, 25, 28, 195, 205, 1 }, },
+      { { 180, 229, 14, 234, 89, 126, 0 },
+        { 101, 48, 94, 156, 174, 231, 1 },
+        { 63, 77, 43, 184, 83, 150, 1 },
+        { 243, 186, 156, 189, 6, 83, 0 }, },
+      { { 186, 59, 44, 235, 91, 138, 0 },
+        { 160, 187, 222, 232, 164, 175, 0 },
+        { 40, 237, 107, 154, 110, 46, 1 },
+        { 122, 146, 139, 189, 238, 130, 1 }, },
+      { { 187, 123, 82, 243, 209, 20, 0 },
+        { 144, 243, 119, 220, 134, 121, 0 },
+        { 20, 69, 231, 165, 111, 110, 1 },
+        { 79, 48, 157, 247, 103, 132, 1 }, },
+      { { 186, 116, 182, 71, 89, 86, 1 },
+        { 198, 83, 222, 94, 131, 229, 0 },
+        { 181, 77, 113, 54, 151, 46, 1 },
+        { 83, 224, 189, 61, 229, 49, 1 }, },
+      { { 186, 139, 73, 97, 25, 111, 1 },
+        { 166, 166, 93, 89, 44, 169, 1 },
+        { 251, 76, 67, 73, 104, 174, 1 },
+        { 202, 154, 77, 93, 50, 178, 1 }, },
+      { { 187, 152, 233, 200, 28, 89, 0 },
+        { 164, 135, 197, 139, 104, 243, 0 },
+        { 77, 28, 9, 203, 140, 238, 1 },
+        { 103, 139, 104, 209, 240, 146, 1 }, },
+      { { 188, 30, 177, 81, 156, 163, 1 },
+        { 83, 207, 236, 75, 64, 169, 1 },
+        { 226, 156, 197, 70, 188, 30, 1 },
+        { 202, 129, 105, 27, 249, 229, 0 }, },
+      { { 188, 42, 52, 17, 27, 68, 1 },
+        { 23, 194, 150, 120, 0, 173, 0 },
+        { 145, 108, 68, 22, 42, 30, 1 },
+        { 90, 128, 15, 52, 161, 244, 0 }, },
+      { { 189, 81, 101, 27, 30, 213, 0 },
+        { 21, 15, 133, 125, 196, 247, 0 },
+        { 85, 188, 108, 83, 69, 94, 1 },
+        { 119, 145, 223, 80, 248, 84, 0 }, },
+      { { 190, 112, 117, 173, 51, 180, 1 },
+        { 139, 107, 151, 253, 1, 103, 1 },
+        { 150, 230, 90, 215, 7, 62, 1 },
+        { 243, 64, 95, 244, 235, 104, 1 }, },
+      { { 189, 255, 164, 161, 70, 198, 1 },
+        { 71, 187, 142, 254, 76, 60, 0 },
+        { 177, 177, 66, 146, 255, 222, 1 },
+        { 30, 25, 63, 184, 238, 241, 0 }, },
+      { { 193, 4, 151, 159, 155, 192, 0 },
+        { 84, 72, 48, 227, 147, 183, 0 },
+        { 1, 236, 252, 244, 144, 65, 1 },
+        { 118, 228, 227, 134, 9, 21, 0 }, },
+      { { 193, 30, 33, 36, 254, 38, 1 },
+        { 74, 177, 168, 49, 81, 185, 1 },
+        { 178, 63, 146, 66, 60, 65, 1 },
+        { 206, 197, 70, 10, 198, 169, 0 }, },
+      { { 192, 237, 72, 64, 106, 165, 0 },
+        { 104, 156, 67, 52, 28, 160, 1 },
+        { 82, 171, 1, 9, 91, 129, 1 },
+        { 130, 156, 22, 97, 28, 139, 0 }, },
+      { { 192, 234, 184, 166, 4, 229, 0 },
+        { 36, 236, 130, 150, 217, 40, 1 },
+        { 83, 144, 50, 142, 171, 129, 1 },
+        { 138, 77, 180, 160, 155, 146, 0 }, },
+      { { 198, 87, 250, 41, 77, 82, 1 },
+        { 231, 113, 153, 70, 86, 234, 0 },
+        { 165, 89, 74, 47, 245, 49, 1 },
+        { 43, 181, 49, 76, 199, 115, 1 }, },
+      { { 200, 111, 63, 193, 206, 104, 0 },
+        { 100, 210, 226, 229, 118, 172, 1 },
+        { 11, 57, 193, 254, 123, 9, 1 },
+        { 154, 183, 83, 163, 165, 147, 0 }, },
+      { { 200, 99, 86, 204, 12, 4, 1 },
+        { 2, 66, 67, 148, 87, 174, 0 },
+        { 144, 24, 25, 181, 99, 9, 1 },
+        { 58, 245, 20, 225, 33, 32, 0 }, },
+      { { 201, 215, 21, 97, 151, 171, 1 },
+        { 66, 111, 120, 101, 124, 61, 1 },
+        { 234, 244, 195, 84, 117, 201, 1 },
+        { 222, 31, 83, 15, 123, 33, 0 }, },
+      { { 203, 227, 118, 18, 26, 242, 1 },
+        { 150, 74, 139, 36, 158, 253, 1 },
+        { 167, 172, 36, 55, 99, 233, 1 },
+        { 223, 188, 146, 104, 169, 52, 1 }, },
+      { { 204, 23, 188, 202, 55, 164, 1 },
+        { 107, 75, 208, 178, 212, 47, 1 },
+        { 146, 246, 41, 158, 244, 25, 1 },
+        { 250, 21, 166, 133, 233, 107, 0 }, },
+      { { 204, 223, 166, 39, 145, 190, 0 },
+        { 65, 171, 184, 86, 191, 109, 1 },
+        { 62, 196, 242, 50, 253, 153, 1 },
+        { 219, 126, 181, 14, 234, 193, 0 }, },
+      { { 204, 235, 235, 67, 36, 93, 0 },
+        { 45, 134, 195, 87, 254, 104, 0 },
+        { 93, 18, 97, 107, 235, 153, 1 },
+        { 11, 63, 245, 97, 176, 218, 0 }, },
+      { { 209, 53, 155, 82, 5, 119, 0 },
+        { 116, 69, 94, 19, 214, 112, 1 },
+        { 119, 80, 37, 108, 214, 69, 1 },
+        { 135, 53, 228, 61, 81, 23, 0 }, },
+      { { 209, 91, 212, 112, 60, 106, 0 },
+        { 28, 225, 77, 6, 116, 189, 1 },
+        { 43, 30, 7, 21, 237, 69, 1 },
+        { 222, 151, 48, 89, 67, 156, 0 }, },
+      { { 215, 26, 117, 66, 163, 79, 1 },
+        { 143, 197, 253, 49, 176, 60, 0 },
+        { 249, 98, 161, 87, 44, 117, 1 },
+        { 30, 6, 198, 95, 209, 248, 1 }, },
+      { { 215, 230, 123, 63, 234, 215, 1 },
+        { 255, 124, 175, 117, 155, 250, 0 },
+        { 245, 171, 254, 111, 51, 245, 1 },
+        { 47, 236, 215, 122, 159, 127, 1 }, },
+      { { 219, 2, 186, 238, 81, 189, 1 },
+        { 162, 126, 212, 146, 179, 123, 1 },
+        { 222, 197, 59, 174, 160, 109, 1 },
+        { 239, 102, 164, 149, 191, 34, 1 }, },
+      { { 216, 126, 223, 70, 165, 187, 1 },
+        { 106, 207, 127, 7, 243, 108, 1 },
+        { 238, 210, 177, 125, 191, 13, 1 },
+        { 155, 103, 240, 127, 121, 171, 0 }, },
+      { { 216, 131, 133, 71, 132, 38, 1 },
+        { 2, 2, 108, 83, 221, 44, 1 },
+        { 178, 16, 241, 80, 224, 141, 1 },
+        { 154, 93, 229, 27, 32, 32, 0 }, },
+      { { 218, 189, 22, 192, 207, 231, 0 },
+        { 196, 223, 126, 176, 94, 164, 1 },
+        { 115, 249, 129, 180, 94, 173, 1 },
+        { 146, 189, 6, 191, 125, 145, 1 }, },
+      { { 219, 226, 77, 128, 236, 124, 1 },
+        { 174, 18, 39, 149, 120, 252, 1 },
+        { 159, 27, 128, 217, 35, 237, 1 },
+        { 159, 143, 84, 242, 36, 58, 1 }, },
+      { { 217, 244, 154, 237, 44, 69, 0 },
+        { 108, 103, 70, 214, 91, 178, 0 },
+        { 81, 26, 91, 172, 151, 205, 1 },
+        { 38, 237, 53, 177, 115, 27, 0 }, },
+      { { 222, 24, 187, 178, 78, 206, 1 },
+        { 183, 251, 140, 179, 242, 160, 0 },
+        { 185, 185, 38, 238, 140, 61, 1 },
+        { 2, 167, 230, 152, 239, 246, 1 }, },
+      { { 221, 25, 226, 31, 178, 162, 1 },
+        { 27, 139, 173, 98, 151, 51, 1 },
+        { 162, 166, 252, 35, 204, 93, 1 },
+        { 230, 116, 163, 90, 232, 236, 0 }, },
+      { { 222, 44, 65, 181, 149, 43, 0 },
+        { 209, 166, 63, 193, 113, 33, 1 },
+        { 106, 84, 214, 193, 26, 61, 1 },
+        { 194, 71, 65, 254, 50, 197, 1 }, },
+      { { 220, 75, 143, 150, 13, 97, 0 },
+        { 53, 134, 20, 135, 215, 172, 1 },
+        { 67, 88, 52, 248, 233, 29, 1 },
+        { 154, 245, 240, 148, 48, 214, 0 }, },
+      { { 221, 148, 173, 142, 18, 115, 1 },
+        { 103, 7, 140, 163, 153, 119, 1 },
+        { 231, 36, 56, 218, 148, 221, 1 },
+        { 247, 76, 226, 152, 240, 115, 0 }, },
+      { { 221, 209, 152, 178, 105, 248, 1 },
+        { 63, 123, 20, 134, 188, 240, 1 },
+        { 143, 203, 38, 140, 197, 221, 1 },
+        { 135, 158, 176, 148, 111, 126, 0 }, },
+      { { 225, 16, 129, 210, 125, 199, 0 },
+        { 28, 29, 88, 155, 208, 177, 0 },
+        { 113, 223, 37, 192, 132, 67, 1 },
+        { 70, 133, 236, 141, 92, 28, 0 }, },
+      { { 226, 29, 244, 60, 230, 69, 1 },
+        { 222, 245, 161, 58, 85, 38, 0 },
+        { 209, 51, 158, 23, 220, 35, 1 },
+        { 50, 85, 46, 66, 215, 189, 1 }, },
+      { { 227, 42, 142, 26, 117, 17, 0 },
+        { 184, 148, 18, 10, 210, 127, 0 },
+        { 68, 87, 44, 56, 170, 99, 1 },
+        { 127, 37, 168, 36, 20, 142, 1 }, },
+      { { 230, 127, 34, 189, 228, 63, 1 },
+        { 219, 181, 170, 220, 119, 106, 1 },
+        { 254, 19, 222, 162, 127, 51, 1 },
+        { 171, 119, 29, 170, 214, 237, 1 }, },
+      { { 230, 201, 244, 50, 47, 175, 1 },
+        { 155, 236, 153, 62, 252, 164, 1 },
+        { 250, 250, 38, 23, 201, 179, 1 },
+        { 146, 159, 190, 76, 155, 236, 1 }, },
+      { { 233, 65, 95, 6, 96, 115, 0 },
+        { 44, 86, 9, 13, 151, 116, 1 },
+        { 103, 3, 48, 125, 65, 75, 1 },
+        { 151, 116, 216, 72, 53, 26, 0 }, },
+      { { 232, 162, 221, 84, 147, 113, 0 },
+        { 52, 70, 115, 43, 25, 109, 1 },
+        { 71, 100, 149, 93, 162, 139, 1 },
+        { 219, 76, 106, 103, 49, 22, 0 }, },
+      { { 232, 216, 146, 243, 185, 171, 1 },
+        { 26, 239, 120, 206, 186, 161, 1 },
+        { 234, 206, 231, 164, 141, 139, 1 },
+        { 194, 174, 185, 143, 123, 172, 0 }, },
+      { { 234, 224, 242, 13, 25, 46, 0 },
+        { 128, 66, 155, 94, 59, 163, 1 },
+        { 58, 76, 88, 39, 131, 171, 1 },
+        { 226, 238, 61, 108, 161, 0, 1 }, },
+      { { 237, 183, 135, 120, 221, 244, 0 },
+        { 85, 59, 114, 27, 94, 255, 1 },
+        { 23, 221, 143, 112, 246, 219, 1 },
+        { 255, 189, 108, 39, 110, 85, 0 }, },
+      { { 237, 243, 41, 3, 202, 39, 1 },
+        { 35, 23, 170, 125, 156, 184, 1 },
+        { 242, 41, 224, 74, 103, 219, 1 },
+        { 142, 156, 223, 42, 244, 98, 0 }, },
+      { { 242, 9, 23, 170, 178, 81, 0 },
+        { 140, 228, 36, 169, 150, 103, 0 },
+        { 69, 38, 170, 244, 72, 39, 1 },
+        { 115, 52, 202, 146, 19, 152, 1 }, },
+      { { 242, 87, 191, 49, 98, 230, 1 },
+        { 254, 121, 140, 127, 22, 44, 1 },
+        { 179, 163, 70, 126, 245, 39, 1 },
+        { 154, 52, 127, 24, 207, 63, 1 }, },
+      { { 240, 161, 59, 114, 216, 194, 0 },
+        { 52, 120, 238, 9, 158, 161, 0 },
+        { 33, 141, 167, 110, 66, 135, 1 },
+        { 66, 188, 200, 59, 143, 22, 0 }, },
+      { { 242, 204, 10, 145, 3, 251, 0 },
+        { 244, 140, 28, 236, 58, 96, 1 },
+        { 111, 224, 68, 168, 25, 167, 1 },
+        { 131, 46, 27, 156, 24, 151, 1 }, },
+      { { 240, 197, 80, 127, 169, 160, 1 },
+        { 90, 104, 117, 76, 157, 162, 1 },
+        { 130, 202, 255, 5, 81, 135, 1 },
+        { 162, 220, 153, 87, 11, 45, 0 }, },
+      { { 241, 197, 159, 71, 93, 153, 1 },
+        { 98, 92, 84, 79, 255, 245, 0 },
+        { 204, 221, 113, 124, 209, 199, 1 },
+        { 87, 255, 249, 21, 29, 35, 0 }, },
+      { { 240, 244, 101, 147, 182, 176, 1 },
+        { 90, 9, 167, 237, 216, 101, 1 },
+        { 134, 182, 228, 211, 23, 135, 1 },
+        { 211, 13, 219, 242, 200, 45, 0 }, },
+      { { 244, 0, 37, 19, 37, 72, 0 },
+        { 29, 0, 148, 73, 240, 36, 0 },
+        { 9, 82, 100, 82, 0, 23, 1 },
+        { 18, 7, 201, 20, 128, 92, 0 }, },
+      { { 244, 111, 108, 190, 223, 216, 1 },
+        { 119, 184, 183, 172, 245, 239, 0 },
+        { 141, 253, 190, 155, 123, 23, 1 },
+        { 123, 215, 154, 246, 142, 247, 0 }, },
+      { { 247, 104, 114, 223, 78, 225, 0 },
+        { 149, 220, 199, 236, 211, 178, 1 },
+        { 67, 185, 125, 167, 11, 119, 1 },
+        { 166, 229, 155, 241, 157, 212, 1 }, },
+      { { 251, 140, 211, 46, 207, 23, 0 },
+        { 192, 246, 61, 59, 219, 242, 0 },
+        { 116, 121, 186, 101, 152, 239, 1 },
+        { 39, 237, 238, 94, 55, 129, 1 }, },
+      { { 249, 145, 73, 232, 47, 176, 0 },
+        { 40, 43, 85, 169, 92, 242, 1 },
+        { 6, 250, 11, 201, 68, 207, 1 },
+        { 167, 157, 74, 213, 106, 10, 0 }, },
+      { { 251, 204, 144, 194, 16, 228, 0 },
+        { 196, 202, 68, 158, 152, 49, 1 },
+        { 19, 132, 33, 132, 153, 239, 1 },
+        { 198, 12, 188, 145, 41, 145, 1 }, },
+      { { 248, 252, 106, 92, 170, 113, 1 },
+        { 126, 135, 231, 44, 27, 226, 1 },
+        { 199, 42, 157, 43, 31, 143, 1 },
+        { 163, 236, 26, 115, 240, 191, 0 }, },
+      { { 254, 15, 171, 22, 40, 191, 1 },
+        { 251, 142, 140, 27, 183, 232, 1 },
+        { 254, 138, 52, 106, 248, 63, 1 },
+        { 139, 246, 236, 24, 184, 239, 1 }, },
+      { { 252, 66, 14, 134, 208, 220, 0 },
+        { 37, 26, 36, 156, 179, 109, 0 },
+        { 29, 133, 176, 184, 33, 31, 1 },
+        { 91, 102, 156, 146, 44, 82, 0 }, },
+      { { 252, 124, 113, 120, 44, 31, 0 },
+        { 89, 231, 207, 29, 112, 226, 0 },
+        { 124, 26, 15, 71, 31, 31, 1 },
+        { 35, 135, 92, 121, 243, 205, 0 }, },
+      { { 255, 159, 183, 150, 227, 134, 1 },
+        { 219, 219, 188, 187, 159, 60, 0 },
+        { 176, 227, 180, 246, 252, 255, 1 },
+        { 30, 124, 238, 158, 237, 237, 1 }, },
+      { { 112, 127, 0, 71, 111, 110, 0 },
+        { 76, 145, 94, 124, 245, 136, 1 },
+        { 59, 123, 113, 0, 127, 7, 0 },
+        { 136, 215, 159, 61, 68, 153, 0 }, },
+      { { 131, 238, 196, 68, 55, 228, 0 },
+        { 204, 136, 83, 54, 73, 61, 1 },
+        { 19, 246, 17, 17, 187, 224, 1 },
+        { 222, 73, 54, 101, 8, 153, 1 }, },
+      { { 1, 32, 180, 5, 180, 95, 1 },
+        { 14, 68, 170, 82, 97, 85, 0 },
+        { 253, 22, 208, 22, 130, 64, 0 },
+        { 85, 67, 37, 42, 145, 56, 0 }, },
+      { { 0, 59, 124, 20, 69, 167, 0 },
+        { 48, 221, 155, 16, 69, 12, 1 },
+        { 114, 209, 20, 31, 110, 0, 0 },
+        { 152, 81, 4, 108, 221, 134, 0 }, },
+      { { 3, 79, 186, 190, 163, 12, 0 },
+        { 248, 224, 176, 182, 167, 26, 0 },
+        { 24, 98, 190, 174, 249, 96, 0 },
+        { 44, 114, 182, 134, 131, 143, 1 }, },
+      { { 1, 86, 37, 1, 21, 142, 0 },
+        { 64, 9, 152, 85, 96, 29, 0 },
+        { 56, 212, 64, 82, 53, 64, 0 },
+        { 92, 3, 85, 12, 200, 1, 0 }, },
+      { { 1, 143, 230, 168, 33, 42, 0 },
+        { 72, 160, 153, 130, 46, 30, 1 },
+        { 42, 66, 10, 179, 248, 192, 0 },
+        { 188, 58, 32, 204, 130, 137, 0 }, },
+      { { 0, 175, 103, 1, 210, 134, 0 },
+        { 64, 152, 171, 113, 14, 13, 0 },
+        { 48, 165, 192, 115, 122, 128, 0 },
+        { 88, 56, 71, 106, 140, 129, 0 }, },
+      { { 0, 217, 16, 247, 55, 249, 0 },
+        { 28, 237, 80, 228, 237, 65, 1 },
+        { 79, 246, 119, 132, 77, 128, 0 },
+        { 193, 91, 147, 133, 91, 156, 0 }, },
+      { { 3, 240, 9, 255, 186, 56, 0 },
+        { 184, 33, 98, 229, 169, 211, 1 },
+        { 14, 46, 255, 200, 7, 224, 0 },
+        { 229, 202, 211, 163, 66, 14, 1 }, },
+      { { 5, 92, 205, 107, 57, 177, 1 },
+        { 107, 173, 81, 71, 128, 215, 1 },
+        { 198, 206, 107, 89, 157, 80, 0 },
+        { 245, 128, 241, 69, 90, 235, 0 }, },
+      { { 6, 109, 146, 36, 128, 158, 1 },
+        { 195, 232, 42, 22, 39, 64, 0 },
+        { 188, 128, 146, 36, 219, 48, 0 },
+        { 1, 114, 52, 42, 11, 225, 1 }, },
+      { { 4, 166, 38, 247, 185, 66, 1 },
+        { 95, 32, 250, 192, 139, 141, 0 },
+        { 161, 78, 247, 178, 50, 144, 0 },
+        { 88, 232, 129, 175, 130, 125, 0 }, },
+      { { 4, 196, 160, 187, 5, 176, 0 },
+        { 81, 40, 144, 198, 200, 66, 1 },
+        { 6, 208, 110, 130, 145, 144, 0 },
+        { 161, 9, 177, 132, 138, 69, 0 }, },
+      { { 9, 4, 240, 102, 157, 166, 0 },
+        { 64, 106, 249, 18, 193, 145, 1 },
+        { 50, 220, 179, 7, 144, 72, 0 },
+        { 196, 193, 164, 79, 171, 1, 0 }, },
+      { { 8, 63, 162, 23, 251, 204, 1 },
+        { 94, 155, 178, 114, 167, 137, 0 },
+        { 153, 239, 244, 34, 254, 8, 0 },
+        { 72, 242, 167, 38, 236, 189, 0 }, },
+      { { 10, 107, 164, 59, 63, 71, 1 },
+        { 158, 166, 154, 118, 196, 143, 0 },
+        { 241, 126, 110, 18, 235, 40, 0 },
+        { 120, 145, 183, 44, 178, 188, 1 }, },
+      { { 9, 147, 68, 160, 208, 252, 0 },
+        { 4, 59, 33, 144, 44, 93, 1 },
+        { 31, 133, 130, 145, 100, 200, 0 },
+        { 221, 26, 4, 194, 110, 16, 0 }, },
+      { { 8, 210, 94, 4, 114, 98, 1 },
+        { 46, 83, 9, 36, 11, 13, 1 },
+        { 163, 39, 16, 61, 37, 136, 0 },
+        { 216, 104, 18, 72, 101, 58, 0 }, },
+      { { 14, 39, 43, 135, 201, 75, 1 },
+        { 231, 22, 186, 193, 167, 136, 0 },
+        { 233, 73, 240, 234, 114, 56, 0 },
+        { 8, 242, 193, 174, 180, 115, 1 }, },
+      { { 15, 42, 254, 150, 218, 227, 0 },
+        { 181, 222, 171, 162, 131, 157, 1 },
+        { 99, 173, 180, 191, 170, 120, 0 },
+        { 220, 224, 162, 234, 189, 214, 1 }, },
+      { { 13, 94, 114, 56, 152, 3, 0 },
+        { 81, 231, 169, 4, 2, 155, 0 },
+        { 96, 12, 142, 39, 61, 88, 0 },
+        { 108, 160, 16, 74, 243, 197, 0 }, },
+      { { 14, 87, 112, 167, 99, 99, 1 },
+        { 207, 119, 153, 228, 133, 8, 1 },
+        { 227, 99, 114, 135, 117, 56, 0 },
+        { 136, 80, 147, 204, 247, 121, 1 }, },
+      { { 13, 106, 169, 220, 27, 63, 0 },
+        { 49, 134, 218, 183, 33, 219, 1 },
+        { 126, 108, 29, 202, 171, 88, 0 },
+        { 237, 194, 118, 173, 176, 198, 0 }, },
+      { { 13, 118, 154, 128, 113, 208, 1 },
+        { 111, 91, 18, 134, 2, 89, 0 },
+        { 133, 199, 0, 172, 183, 88, 0 },
+        { 77, 32, 48, 164, 109, 123, 0 }, },
+      { { 14, 124, 197, 35, 226, 204, 1 },
+        { 207, 187, 35, 119, 160, 4, 0 },
+        { 153, 163, 226, 81, 159, 56, 0 },
+        { 16, 2, 247, 98, 110, 249, 1 }, },
+      { { 15, 139, 106, 20, 246, 21, 0 },
+        { 185, 150, 161, 48, 79, 89, 0 },
+        { 84, 55, 148, 43, 104, 248, 0 },
+        { 77, 121, 6, 66, 180, 206, 1 }, },
+      { { 13, 171, 134, 215, 206, 17, 1 },
+        { 19, 150, 98, 226, 207, 220, 0 },
+        { 196, 57, 245, 176, 234, 216, 0 },
+        { 29, 249, 163, 163, 52, 228, 0 }, },
+      { { 15, 203, 199, 97, 60, 150, 1 },
+        { 139, 170, 73, 87, 78, 221, 0 },
+        { 180, 158, 67, 113, 233, 248, 0 },
+        { 93, 185, 117, 73, 42, 232, 1 }, },
+      { { 14, 236, 63, 51, 174, 17, 1 },
+        { 251, 230, 162, 101, 202, 196, 0 },
+        { 196, 58, 230, 126, 27, 184, 0 },
+        { 17, 169, 211, 34, 179, 239, 1 }, },
+      { { 17, 15, 152, 165, 71, 82, 0 },
+        { 100, 240, 28, 226, 69, 88, 0 },
+        { 37, 113, 82, 140, 248, 68, 0 },
+        { 13, 81, 35, 156, 7, 147, 0 }, },
+      { { 17, 119, 210, 131, 226, 153, 0 },
+        { 72, 93, 39, 230, 166, 88, 0 },
+        { 76, 163, 224, 165, 247, 68, 0 },
+        { 13, 50, 179, 242, 93, 9, 0 }, },
+      { { 17, 151, 181, 190, 81, 161, 0 },
+        { 80, 125, 148, 131, 141, 31, 1 },
+        { 66, 197, 62, 214, 244, 196, 0 },
+        { 252, 88, 224, 148, 223, 5, 0 }, },
+      { { 18, 155, 152, 58, 105, 111, 1 },
+        { 190, 245, 28, 18, 172, 138, 1 },
+        { 251, 75, 46, 12, 236, 164, 0 },
+        { 168, 154, 164, 28, 87, 190, 1 }, },
+      { { 19, 233, 65, 189, 245, 218, 0 },
+        { 156, 184, 63, 197, 109, 83, 0 },
+        { 45, 215, 222, 193, 75, 228, 0 },
+        { 101, 91, 81, 254, 14, 156, 1 }, },
+      { { 22, 13, 83, 212, 169, 87, 0 },
+        { 221, 196, 125, 145, 7, 192, 0 },
+        { 117, 74, 149, 229, 88, 52, 0 },
+        { 1, 240, 68, 223, 17, 221, 1 }, },
+      { { 22, 61, 21, 111, 231, 73, 0 },
+        { 205, 245, 118, 97, 229, 6, 0 },
+        { 73, 115, 251, 84, 94, 52, 0 },
+        { 48, 83, 195, 55, 87, 217, 1 }, },
+      { { 20, 130, 100, 0, 95, 151, 1 },
+        { 3, 28, 157, 48, 72, 205, 0 },
+        { 244, 253, 0, 19, 32, 148, 0 },
+        { 89, 137, 6, 92, 156, 96, 0 }, },
+      { { 21, 130, 161, 143, 42, 56, 1 },
+        { 11, 0, 132, 227, 169, 218, 1 },
+        { 142, 42, 120, 194, 160, 212, 0 },
+        { 173, 202, 227, 144, 128, 104, 0 }, },
+      { { 21, 153, 34, 53, 74, 250, 0 },
+        { 21, 185, 140, 96, 47, 208, 1 },
+        { 47, 169, 86, 34, 76, 212, 0 },
+        { 133, 250, 3, 24, 206, 212, 0 }, },
+      { { 23, 156, 89, 25, 214, 46, 0 },
+        { 241, 209, 45, 113, 104, 19, 1 },
+        { 58, 53, 204, 77, 28, 244, 0 },
+        { 228, 11, 71, 90, 69, 199, 1 }, },
+      { { 21, 165, 87, 175, 25, 244, 1 },
+        { 71, 104, 23, 209, 143, 215, 1 },
+        { 151, 204, 122, 245, 82, 212, 0 },
+        { 245, 248, 197, 244, 11, 113, 0 }, },
+      { { 22, 185, 129, 147, 151, 243, 0 },
+        { 149, 141, 62, 227, 204, 65, 1 },
+        { 103, 244, 228, 192, 206, 180, 0 },
+        { 193, 25, 227, 190, 88, 212, 1 }, },
+      { { 20, 212, 174, 31, 83, 198, 0 },
+        { 117, 25, 156, 118, 139, 7, 0 },
+        { 49, 229, 124, 58, 149, 148, 0 },
+        { 112, 104, 183, 28, 204, 87, 0 }, },
+      { { 22, 222, 188, 166, 177, 46, 1 },
+        { 235, 225, 188, 150, 169, 13, 1 },
+        { 186, 70, 178, 158, 189, 180, 0 },
+        { 216, 74, 180, 158, 195, 235, 1 }, },
+      { { 21, 215, 231, 50, 136, 117, 0 },
+        { 85, 37, 165, 23, 142, 220, 1 },
+        { 87, 8, 166, 115, 245, 212, 0 },
+        { 157, 184, 244, 82, 210, 85, 0 }, },
+      { { 27, 5, 137, 184, 14, 199, 1 },
+        { 246, 46, 12, 179, 68, 146, 0 },
+        { 241, 184, 14, 200, 208, 108, 0 },
+        { 36, 145, 102, 152, 58, 55, 1 }, },
+      { { 24, 76, 13, 17, 16, 216, 1 },
+        { 118, 138, 4, 69, 32, 69, 0 },
+        { 141, 132, 68, 88, 25, 12, 0 },
+        { 81, 2, 81, 16, 40, 183, 0 }, },
+      { { 27, 80, 19, 3, 222, 147, 1 },
+        { 130, 95, 44, 101, 194, 209, 0 },
+        { 228, 189, 224, 100, 5, 108, 0 },
+        { 69, 161, 211, 26, 125, 32, 1 }, },
+      { { 26, 117, 67, 117, 230, 58, 0 },
+        { 216, 51, 111, 101, 103, 64, 1 },
+        { 46, 51, 215, 97, 87, 44, 0 },
+        { 129, 115, 83, 123, 102, 13, 1 }, },
+      { { 25, 139, 44, 109, 101, 206, 0 },
+        { 44, 186, 220, 80, 109, 30, 0 },
+        { 57, 211, 91, 26, 104, 204, 0 },
+        { 60, 91, 5, 29, 174, 154, 0 }, },
+      { { 24, 157, 237, 154, 191, 3, 0 },
+        { 120, 135, 189, 163, 204, 135, 0 },
+        { 96, 126, 172, 219, 220, 140, 0 },
+        { 112, 153, 226, 222, 240, 143, 0 }, },
+      { { 26, 163, 189, 21, 22, 74, 1 },
+        { 182, 66, 142, 99, 109, 13, 0 },
+        { 169, 52, 84, 94, 226, 172, 0 },
+        { 88, 91, 99, 56, 161, 54, 1 }, },
+      { { 24, 191, 221, 217, 136, 80, 1 },
+        { 118, 195, 103, 195, 12, 206, 0 },
+        { 133, 8, 205, 221, 254, 140, 0 },
+        { 57, 152, 97, 243, 97, 183, 0 }, },
+      { { 26, 187, 197, 128, 248, 166, 1 },
+        { 138, 155, 47, 147, 12, 141, 1 },
+        { 178, 143, 128, 209, 238, 172, 0 },
+        { 216, 152, 100, 250, 108, 168, 1 }, },
+      { { 24, 202, 200, 115, 174, 12, 1 },
+        { 58, 162, 101, 118, 232, 136, 0 },
+        { 152, 58, 231, 9, 169, 140, 0 },
+        { 8, 139, 183, 83, 34, 174, 0 }, },
+      { { 26, 251, 85, 224, 195, 153, 1 },
+        { 130, 255, 119, 165, 44, 76, 0 },
+        { 204, 225, 131, 213, 111, 172, 0 },
+        { 25, 26, 82, 247, 127, 160, 1 }, },
+      { { 25, 252, 172, 250, 123, 235, 0 },
+        { 124, 191, 222, 166, 168, 151, 1 },
+        { 107, 239, 47, 154, 159, 204, 0 },
+        { 244, 138, 178, 189, 254, 159, 0 }, },
+      { { 31, 33, 77, 51, 43, 129, 0 },
+        { 185, 46, 23, 97, 132, 148, 0 },
+        { 64, 234, 102, 89, 66, 124, 0 },
+        { 20, 144, 195, 116, 58, 78, 1 }, },
+      { { 29, 104, 97, 97, 80, 45, 1 },
+        { 3, 182, 199, 85, 32, 17, 1 },
+        { 218, 5, 67, 67, 11, 92, 0 },
+        { 196, 2, 85, 113, 182, 224, 0 }, },
+      { { 29, 113, 17, 105, 159, 205, 1 },
+        { 7, 111, 118, 117, 100, 147, 0 },
+        { 217, 252, 203, 68, 71, 92, 0 },
+        { 100, 147, 87, 55, 123, 112, 0 }, },
+      { { 28, 115, 52, 93, 58, 61, 1 },
+        { 27, 71, 198, 116, 37, 207, 1 },
+        { 222, 46, 93, 22, 103, 28, 0 },
+        { 249, 210, 23, 49, 241, 108, 0 }, },
+      { { 30, 167, 7, 22, 61, 22, 1 },
+        { 219, 2, 30, 17, 207, 205, 0 },
+        { 180, 94, 52, 112, 114, 188, 0 },
+        { 89, 249, 196, 60, 32, 109, 1 }, },
+      { { 32, 22, 241, 69, 239, 16, 1 },
+        { 74, 81, 241, 107, 65, 200, 0 },
+        { 132, 123, 209, 71, 180, 2, 0 },
+        { 9, 193, 107, 71, 197, 41, 0 }, },
+      { { 33, 37, 79, 144, 49, 77, 0 },
+        { 124, 4, 19, 153, 38, 21, 0 },
+        { 89, 70, 4, 249, 82, 66, 0 },
+        { 84, 50, 76, 228, 16, 31, 0 }, },
+      { { 35, 45, 115, 235, 220, 62, 1 },
+        { 194, 240, 235, 217, 230, 211, 1 },
+        { 190, 29, 235, 231, 90, 98, 0 },
+        { 229, 179, 205, 235, 135, 161, 1 }, },
+      { { 35, 72, 62, 43, 100, 184, 1 },
+        { 170, 248, 128, 76, 226, 86, 1 },
+        { 142, 147, 106, 62, 9, 98, 0 },
+        { 181, 35, 153, 0, 143, 170, 1 }, },
+      { { 35, 86, 58, 73, 248, 94, 1 },
+        { 238, 81, 232, 92, 34, 219, 0 },
+        { 189, 15, 201, 46, 53, 98, 0 },
+        { 109, 162, 29, 11, 197, 59, 1 }, },
+      { { 34, 138, 184, 17, 107, 194, 0 },
+        { 188, 216, 152, 106, 8, 136, 0 },
+        { 33, 235, 68, 14, 168, 162, 0 },
+        { 8, 136, 43, 12, 141, 158, 1 }, },
+      { { 32, 167, 72, 150, 66, 82, 1 },
+        { 118, 16, 11, 168, 141, 72, 0 },
+        { 165, 33, 52, 137, 114, 130, 0 },
+        { 9, 88, 138, 232, 4, 55, 0 }, },
+      { { 34, 164, 248, 245, 231, 39, 1 },
+        { 250, 116, 251, 250, 73, 0, 1 },
+        { 242, 115, 215, 143, 146, 162, 0 },
+        { 128, 73, 47, 239, 151, 47, 1 }, },
+      { { 33, 239, 227, 53, 220, 27, 1 },
+        { 82, 180, 171, 79, 111, 217, 0 },
+        { 236, 29, 214, 99, 251, 194, 0 },
+        { 77, 251, 121, 106, 150, 165, 0 }, },
+      { { 33, 255, 170, 148, 240, 254, 0 },
+        { 124, 153, 170, 158, 47, 89, 1 },
+        { 63, 135, 148, 170, 255, 194, 0 },
+        { 205, 122, 60, 170, 204, 159, 0 }, },
+      { { 37, 48, 68, 183, 73, 106, 0 },
+        { 21, 49, 27, 200, 161, 148, 1 },
+        { 43, 73, 118, 145, 6, 82, 0 },
+        { 148, 194, 137, 236, 70, 84, 0 }, },
+      { { 38, 55, 142, 202, 57, 200, 0 },
+        { 237, 9, 82, 138, 166, 143, 0 },
+        { 9, 206, 41, 184, 246, 50, 0 },
+        { 120, 178, 168, 165, 72, 91, 1 }, },
+      { { 39, 67, 65, 27, 226, 165, 0 },
+        { 153, 28, 33, 125, 132, 26, 1 },
+        { 82, 163, 236, 65, 97, 114, 0 },
+        { 172, 16, 223, 66, 28, 76, 1 }, },
+      { { 39, 119, 180, 37, 12, 229, 0 },
+        { 197, 109, 130, 94, 69, 156, 1 },
+        { 83, 152, 82, 22, 247, 114, 0 },
+        { 156, 209, 61, 32, 219, 81, 1 }, },
+      { { 36, 140, 97, 44, 211, 5, 0 },
+        { 65, 180, 177, 57, 9, 3, 0 },
+        { 80, 101, 154, 67, 24, 146, 0 },
+        { 96, 72, 78, 70, 150, 193, 0 }, },
+      { { 39, 181, 134, 58, 242, 110, 1 },
+        { 223, 49, 42, 58, 174, 23, 1 },
+        { 187, 39, 174, 48, 214, 242, 0 },
+        { 244, 58, 174, 42, 70, 125, 1 }, },
+      { { 37, 192, 47, 169, 170, 233, 1 },
+        { 47, 44, 160, 237, 42, 150, 1 },
+        { 203, 170, 202, 250, 1, 210, 0 },
+        { 180, 170, 91, 130, 154, 122, 0 }, },
+      { { 37, 193, 244, 243, 24, 172, 1 },
+        { 19, 104, 193, 222, 172, 149, 1 },
+        { 154, 140, 103, 151, 193, 210, 0 },
+        { 212, 154, 189, 193, 139, 100, 0 }, },
+      { { 38, 223, 180, 89, 168, 216, 1 },
+        { 223, 201, 224, 78, 44, 206, 0 },
+        { 141, 138, 205, 22, 253, 178, 0 },
+        { 57, 154, 57, 3, 201, 253, 1 }, },
+      { { 36, 229, 181, 254, 134, 140, 0 },
+        { 81, 104, 226, 191, 237, 6, 0 },
+        { 24, 176, 191, 214, 211, 146, 0 },
+        { 48, 91, 254, 163, 139, 69, 0 }, },
+      { { 36, 250, 147, 106, 49, 84, 1 },
+        { 15, 225, 82, 31, 138, 75, 0 },
+        { 149, 70, 43, 100, 175, 146, 0 },
+        { 105, 40, 252, 37, 67, 248, 0 }, },
+      { { 41, 33, 120, 64, 98, 223, 1 },
+        { 46, 94, 203, 56, 36, 80, 0 },
+        { 253, 163, 1, 15, 66, 74, 0 },
+        { 5, 18, 14, 105, 189, 58, 0 }, },
+      { { 42, 47, 218, 50, 70, 201, 1 },
+        { 246, 254, 3, 42, 230, 8, 0 },
+        { 201, 177, 38, 45, 250, 42, 0 },
+        { 8, 51, 170, 96, 63, 183, 1 }, },
+      { { 40, 62, 63, 42, 103, 4, 0 },
+        { 104, 243, 146, 57, 194, 14, 0 },
+        { 16, 115, 42, 126, 62, 10, 0 },
+        { 56, 33, 206, 36, 231, 139, 0 }, },
+      { { 43, 205, 185, 118, 1, 186, 0 },
+        { 240, 234, 216, 15, 173, 80, 1 },
+        { 46, 192, 55, 78, 217, 234, 0 },
+        { 133, 90, 248, 13, 171, 135, 1 }, },
+      { { 40, 234, 218, 205, 222, 126, 1 },
+        { 38, 210, 107, 254, 107, 203, 1 },
+        { 191, 61, 217, 173, 171, 138, 0 },
+        { 233, 235, 63, 235, 37, 178, 0 }, },
+      { { 44, 77, 140, 242, 231, 58, 1 },
+        { 123, 178, 120, 174, 228, 68, 1 },
+        { 174, 115, 167, 152, 217, 26, 0 },
+        { 145, 19, 186, 143, 38, 239, 0 }, },
+      { { 46, 88, 0, 228, 62, 206, 0 },
+        { 141, 171, 72, 188, 97, 129, 0 },
+        { 57, 190, 19, 128, 13, 58, 0 },
+        { 64, 195, 30, 137, 106, 216, 1 }, },
+      { { 45, 129, 187, 116, 79, 227, 1 },
+        { 55, 126, 216, 43, 79, 144, 1 },
+        { 227, 249, 23, 110, 192, 218, 0 },
+        { 132, 249, 106, 13, 191, 118, 0 }, },
+      { { 44, 145, 67, 129, 237, 29, 0 },
+        { 9, 23, 49, 217, 110, 192, 0 },
+        { 92, 91, 192, 225, 68, 154, 0 },
+        { 1, 187, 77, 198, 116, 72, 0 }, },
+      { { 45, 180, 8, 215, 116, 177, 1 },
+        { 123, 31, 66, 200, 201, 81, 1 },
+        { 198, 151, 117, 136, 22, 218, 0 },
+        { 197, 73, 137, 161, 124, 111, 0 }, },
+      { { 44, 224, 23, 61, 89, 3, 1 },
+        { 19, 118, 26, 77, 11, 135, 0 },
+        { 224, 77, 94, 116, 3, 154, 0 },
+        { 112, 232, 89, 44, 55, 100, 0 }, },
+      { { 48, 9, 23, 86, 236, 208, 1 },
+        { 30, 216, 100, 9, 199, 196, 0 },
+        { 133, 155, 181, 116, 72, 6, 0 },
+        { 17, 241, 200, 19, 13, 188, 0 }, },
+      { { 51, 70, 13, 15, 126, 150, 0 },
+        { 232, 24, 12, 125, 193, 223, 0 },
+        { 52, 191, 120, 88, 49, 102, 0 },
+        { 125, 193, 223, 24, 12, 11, 1 }, },
+      { { 50, 113, 60, 116, 164, 89, 0 },
+        { 188, 101, 230, 12, 101, 68, 0 },
+        { 77, 18, 151, 30, 71, 38, 0 },
+        { 17, 83, 24, 51, 211, 30, 1 }, },
+      { { 48, 167, 239, 179, 52, 231, 1 },
+        { 126, 44, 143, 219, 206, 13, 1 },
+        { 243, 150, 102, 251, 242, 134, 0 },
+        { 216, 57, 237, 248, 154, 63, 0 }, },
+      { { 48, 183, 244, 73, 95, 202, 0 },
+        { 68, 89, 223, 106, 108, 143, 0 },
+        { 41, 253, 73, 23, 246, 134, 0 },
+        { 120, 155, 43, 125, 205, 17, 0 }, },
+      { { 51, 236, 16, 56, 154, 82, 0 },
+        { 212, 224, 46, 44, 8, 211, 0 },
+        { 37, 44, 142, 4, 27, 230, 0 },
+        { 101, 136, 26, 58, 3, 149, 1 }, },
+      { { 53, 106, 133, 153, 65, 91, 0 },
+        { 21, 148, 30, 207, 32, 94, 0 },
+        { 109, 65, 76, 208, 171, 86, 0 },
+        { 61, 2, 121, 188, 20, 212, 0 }, },
+      { { 54, 125, 199, 249, 16, 137, 1 },
+        { 211, 173, 71, 207, 38, 7, 0 },
+        { 200, 132, 79, 241, 223, 54, 0 },
+        { 112, 50, 121, 241, 90, 229, 1 }, },
+      { { 53, 145, 236, 15, 52, 5, 1 },
+        { 43, 5, 133, 90, 205, 23, 0 },
+        { 208, 22, 120, 27, 196, 214, 0 },
+        { 116, 89, 173, 80, 208, 106, 0 }, },
+      { { 58, 31, 122, 71, 185, 141, 0 },
+        { 232, 207, 245, 88, 167, 137, 0 },
+        { 88, 206, 241, 47, 124, 46, 0 },
+        { 72, 242, 141, 87, 249, 139, 1 }, },
+      { { 58, 86, 77, 209, 166, 203, 1 },
+        { 254, 15, 109, 237, 96, 12, 0 },
+        { 233, 178, 197, 217, 53, 46, 0 },
+        { 24, 3, 91, 219, 120, 63, 1 }, },
+      { { 57, 105, 99, 159, 57, 176, 1 },
+        { 26, 138, 151, 205, 135, 211, 1 },
+        { 134, 206, 124, 227, 75, 78, 0 },
+        { 229, 240, 217, 244, 168, 172, 0 }, },
+      { { 59, 96, 103, 17, 227, 243, 0 },
+        { 156, 30, 191, 109, 2, 84, 1 },
+        { 103, 227, 196, 115, 3, 110, 0 },
+        { 149, 32, 91, 126, 188, 28, 1 }, },
+      { { 57, 204, 214, 65, 214, 205, 1 },
+        { 70, 222, 101, 126, 106, 21, 0 },
+        { 217, 181, 193, 53, 153, 206, 0 },
+        { 84, 43, 63, 83, 61, 177, 0 }, },
+      { { 60, 51, 21, 240, 128, 231, 0 },
+        { 21, 111, 110, 153, 4, 12, 1 },
+        { 115, 128, 135, 212, 102, 30, 0 },
+        { 152, 16, 76, 187, 123, 84, 0 }, },
+      { { 60, 51, 197, 75, 3, 115, 1 },
+        { 7, 7, 95, 107, 132, 78, 1 },
+        { 231, 96, 105, 81, 230, 30, 0 },
+        { 185, 16, 235, 125, 112, 112, 0 }, },
+      { { 61, 98, 186, 75, 99, 200, 0 },
+        { 45, 90, 214, 110, 162, 26, 0 },
+        { 9, 227, 105, 46, 163, 94, 0 },
+        { 44, 34, 187, 53, 173, 90, 0 }, },
+      { { 61, 117, 9, 162, 109, 95, 1 },
+        { 111, 55, 30, 157, 228, 208, 0 },
+        { 253, 91, 34, 200, 87, 94, 0 },
+        { 5, 147, 220, 188, 118, 123, 0 }, },
+      { { 63, 152, 179, 12, 62, 51, 1 },
+        { 139, 199, 140, 43, 75, 211, 1 },
+        { 230, 62, 24, 102, 140, 254, 0 },
+        { 229, 233, 106, 24, 241, 232, 1 }, },
+      { { 62, 205, 175, 189, 212, 43, 0 },
+        { 241, 182, 172, 207, 111, 7, 1 },
+        { 106, 21, 222, 250, 217, 190, 0 },
+        { 240, 123, 121, 154, 182, 199, 1 }, },
+      { { 63, 213, 180, 83, 119, 231, 1 },
+        { 223, 95, 220, 126, 204, 21, 1 },
+        { 243, 247, 101, 22, 213, 254, 0 },
+        { 212, 25, 191, 29, 253, 125, 1 }, },
+      { { 60, 233, 181, 48, 105, 180, 0 },
+        { 25, 250, 150, 31, 12, 196, 1 },
+        { 22, 203, 6, 86, 203, 158, 0 },
+        { 145, 152, 124, 52, 175, 204, 0 }, },
+      { { 64, 3, 93, 254, 66, 40, 1 },
+        { 50, 112, 65, 161, 181, 14, 1 },
+        { 138, 33, 63, 221, 96, 1, 0 },
+        { 184, 86, 194, 193, 7, 38, 0 }, },
+      { { 67, 106, 171, 8, 205, 110, 1 },
+        { 166, 144, 186, 23, 114, 154, 1 },
+        { 187, 89, 136, 106, 171, 97, 0 },
+        { 172, 167, 116, 46, 132, 178, 1 }, },
+      { { 67, 113, 229, 169, 206, 30, 1 },
+        { 130, 49, 171, 247, 116, 214, 0 },
+        { 188, 57, 202, 211, 199, 97, 0 },
+        { 53, 151, 119, 234, 198, 32, 1 }, },
+      { { 65, 168, 233, 191, 52, 145, 0 },
+        { 56, 172, 131, 195, 217, 83, 0 },
+        { 68, 150, 126, 203, 138, 193, 0 },
+        { 101, 77, 225, 224, 154, 142, 0 }, },
+      { { 65, 202, 197, 166, 227, 19, 0 },
+        { 8, 180, 57, 167, 153, 92, 0 },
+        { 100, 99, 178, 209, 169, 193, 0 },
+        { 29, 76, 242, 206, 22, 136, 0 }, },
+      { { 66, 247, 60, 189, 2, 52, 0 },
+        { 240, 97, 130, 244, 29, 78, 1 },
+        { 22, 32, 94, 158, 119, 161, 0 },
+        { 185, 92, 23, 160, 195, 7, 1 }, },
+      { { 68, 39, 29, 179, 182, 219, 1 },
+        { 127, 108, 42, 225, 244, 77, 0 },
+        { 237, 182, 230, 220, 114, 17, 0 },
+        { 89, 23, 195, 170, 27, 127, 0 }, },
+      { { 68, 76, 27, 64, 24, 97, 1 },
+        { 103, 196, 64, 5, 18, 129, 1 },
+        { 195, 12, 1, 108, 25, 17, 0 },
+        { 192, 164, 80, 1, 17, 243, 0 }, },
+      { { 70, 74, 152, 175, 201, 220, 0 },
+        { 165, 248, 48, 214, 177, 202, 0 },
+        { 29, 201, 250, 140, 169, 49, 0 },
+        { 41, 198, 181, 134, 15, 210, 1 }, },
+      { { 70, 131, 6, 249, 199, 224, 1 },
+        { 151, 56, 112, 224, 94, 14, 1 },
+        { 131, 241, 207, 176, 96, 177, 0 },
+        { 184, 61, 3, 135, 14, 116, 1 }, },
+      { { 68, 140, 202, 221, 114, 250, 1 },
+        { 127, 152, 73, 226, 59, 67, 1 },
+        { 175, 167, 93, 169, 152, 145, 0 },
+        { 225, 110, 35, 201, 12, 255, 0 }, },
+      { { 70, 158, 58, 59, 116, 65, 1 },
+        { 255, 245, 128, 64, 218, 11, 0 },
+        { 193, 23, 110, 46, 60, 177, 0 },
+        { 104, 45, 129, 0, 215, 255, 1 }, },
+      { { 73, 31, 143, 197, 190, 227, 0 },
+        { 108, 143, 104, 227, 87, 157, 1 },
+        { 99, 190, 209, 248, 252, 73, 0 },
+        { 220, 245, 99, 139, 120, 155, 0 }, },
+      { { 73, 75, 34, 203, 253, 35, 1 },
+        { 10, 150, 248, 196, 214, 155, 1 },
+        { 226, 95, 233, 162, 105, 73, 0 },
+        { 236, 181, 145, 143, 180, 168, 0 }, },
+      { { 73, 91, 8, 111, 19, 202, 1 },
+        { 38, 171, 88, 100, 181, 27, 0 },
+        { 169, 228, 123, 8, 109, 73, 0 },
+        { 108, 86, 147, 13, 106, 178, 0 }, },
+      { { 74, 177, 68, 70, 10, 33, 1 },
+        { 130, 7, 67, 32, 157, 132, 1 },
+        { 194, 40, 49, 17, 70, 169, 0 },
+        { 144, 220, 130, 97, 112, 32, 1 }, },
+      { { 75, 195, 24, 213, 28, 201, 0 },
+        { 180, 78, 64, 196, 125, 153, 0 },
+        { 73, 156, 85, 140, 97, 233, 0 },
+        { 76, 223, 17, 129, 57, 22, 1 }, },
+      { { 76, 116, 244, 77, 39, 23, 1 },
+        { 75, 71, 219, 118, 81, 70, 0 },
+        { 244, 114, 89, 23, 151, 25, 0 },
+        { 49, 69, 55, 109, 241, 105, 0 }, },
+      { { 78, 157, 120, 2, 250, 136, 1 },
+        { 235, 219, 161, 32, 188, 129, 0 },
+        { 136, 175, 160, 15, 92, 185, 0 },
+        { 64, 158, 130, 66, 237, 235, 1 }, },
+      { { 79, 168, 131, 36, 88, 72, 0 },
+        { 133, 178, 2, 3, 59, 145, 0 },
+        { 9, 13, 18, 96, 138, 249, 0 },
+        { 68, 238, 96, 32, 38, 208, 1 }, },
+      { { 77, 204, 62, 66, 47, 44, 0 },
+        { 105, 194, 208, 52, 250, 148, 1 },
+        { 26, 122, 33, 62, 25, 217, 0 },
+        { 148, 175, 150, 5, 161, 203, 0 }, },
+      { { 77, 205, 182, 47, 105, 192, 1 },
+        { 79, 250, 144, 70, 159, 150, 0 },
+        { 129, 203, 122, 54, 217, 217, 0 },
+        { 52, 252, 177, 4, 175, 249, 0 }, },
+      { { 76, 252, 81, 246, 35, 2, 0 },
+        { 89, 227, 91, 165, 153, 0, 0 },
+        { 32, 98, 55, 197, 31, 153, 0 },
+        { 0, 76, 210, 237, 99, 205, 0 }, },
+      { { 77, 248, 189, 181, 78, 179, 0 },
+        { 49, 255, 138, 231, 89, 212, 1 },
+        { 102, 185, 86, 222, 143, 217, 0 },
+        { 149, 205, 115, 168, 255, 198, 0 }, },
+      { { 78, 254, 206, 197, 81, 2, 1 },
+        { 227, 147, 91, 198, 27, 13, 0 },
+        { 160, 69, 81, 185, 191, 185, 0 },
+        { 88, 108, 49, 237, 100, 227, 1 }, },
+      { { 83, 45, 244, 148, 190, 11, 1 },
+        { 218, 196, 175, 162, 117, 149, 0 },
+        { 232, 62, 148, 151, 218, 101, 0 },
+        { 84, 215, 34, 250, 145, 173, 1 }, },
+      { { 83, 55, 48, 177, 237, 76, 1 },
+        { 222, 113, 182, 208, 116, 152, 0 },
+        { 153, 91, 198, 134, 118, 101, 0 },
+        { 12, 151, 5, 182, 199, 61, 1 }, },
+      { { 81, 138, 115, 76, 78, 26, 0 },
+        { 0, 208, 205, 33, 123, 218, 0 },
+        { 44, 57, 25, 103, 40, 197, 0 },
+        { 45, 239, 66, 89, 133, 128, 0 }, },
+      { { 81, 173, 41, 83, 250, 51, 0 },
+        { 120, 148, 238, 97, 156, 209, 1 },
+        { 102, 47, 229, 74, 90, 197, 0 },
+        { 197, 156, 195, 59, 148, 143, 0 }, },
+      { { 80, 244, 139, 181, 87, 23, 1 },
+        { 114, 53, 30, 247, 91, 65, 0 },
+        { 244, 117, 86, 232, 151, 133, 0 },
+        { 65, 109, 119, 188, 86, 39, 0 }, },
+      { { 83, 242, 216, 169, 125, 63, 0 },
+        { 168, 117, 31, 214, 120, 219, 1 },
+        { 126, 95, 74, 141, 167, 229, 0 },
+        { 237, 143, 53, 252, 87, 10, 1 }, },
+      { { 87, 46, 51, 92, 65, 229, 1 },
+        { 215, 220, 214, 17, 19, 26, 1 },
+        { 211, 193, 29, 102, 58, 117, 0 },
+        { 172, 100, 68, 53, 157, 245, 1 }, },
+      { { 85, 97, 138, 153, 243, 43, 1 },
+        { 59, 20, 62, 230, 54, 19, 1 },
+        { 234, 103, 204, 168, 195, 85, 0 },
+        { 228, 54, 51, 190, 20, 110, 0 }, },
+      { { 84, 114, 176, 221, 66, 144, 1 },
+        { 19, 89, 198, 230, 17, 74, 0 },
+        { 132, 161, 93, 134, 167, 21, 0 },
+        { 41, 68, 51, 177, 205, 100, 0 }, },
+      { { 87, 120, 188, 172, 178, 210, 1 },
+        { 175, 233, 174, 166, 17, 87, 0 },
+        { 165, 166, 154, 158, 143, 117, 0 },
+        { 117, 68, 50, 186, 203, 250, 1 }, },
+      { { 85, 178, 111, 85, 255, 238, 1 },
+        { 63, 25, 255, 113, 123, 157, 1 },
+        { 187, 255, 213, 123, 38, 213, 0 },
+        { 220, 239, 71, 127, 204, 126, 0 }, },
+      { { 87, 215, 193, 128, 15, 12, 1 },
+        { 195, 1, 21, 183, 124, 152, 0 },
+        { 152, 120, 0, 193, 245, 245, 0 },
+        { 12, 159, 118, 212, 64, 97, 1 }, },
+      { { 85, 243, 37, 159, 247, 53, 0 },
+        { 25, 21, 182, 245, 221, 95, 1 },
+        { 86, 119, 252, 210, 103, 213, 0 },
+        { 253, 93, 215, 182, 212, 76, 0 }, },
+      { { 90, 0, 169, 237, 210, 158, 0 },
+        { 160, 58, 236, 243, 49, 67, 0 },
+        { 60, 165, 219, 202, 128, 45, 0 },
+        { 97, 70, 103, 155, 174, 2, 1 }, },
+      { { 89, 39, 61, 104, 89, 78, 1 },
+        { 102, 114, 222, 17, 52, 159, 0 },
+        { 185, 77, 11, 94, 114, 77, 0 },
+        { 124, 150, 68, 61, 167, 51, 0 }, },
+      { { 89, 73, 179, 211, 30, 79, 0 },
+        { 20, 198, 204, 247, 246, 145, 0 },
+        { 121, 60, 101, 230, 201, 77, 0 },
+        { 68, 183, 247, 153, 177, 148, 0 }, },
+      { { 91, 92, 30, 37, 185, 241, 1 },
+        { 238, 239, 52, 68, 19, 213, 1 },
+        { 199, 206, 210, 60, 29, 109, 0 },
+        { 213, 228, 17, 22, 123, 187, 1 }, },
+      { { 89, 81, 133, 145, 139, 249, 0 },
+        { 20, 15, 52, 231, 52, 212, 1 },
+        { 79, 232, 196, 208, 197, 77, 0 },
+        { 149, 150, 115, 150, 120, 20, 0 }, },
+      { { 91, 156, 92, 115, 202, 248, 1 },
+        { 246, 251, 101, 96, 184, 212, 1 },
+        { 143, 169, 231, 29, 28, 237, 0 },
+        { 149, 142, 131, 83, 111, 183, 1 }, },
+      { { 90, 148, 209, 233, 34, 152, 1 },
+        { 202, 107, 69, 227, 56, 66, 0 },
+        { 140, 162, 75, 197, 148, 173, 0 },
+        { 33, 14, 99, 209, 107, 41, 1 }, },
+      { { 88, 170, 155, 107, 27, 52, 0 },
+        { 32, 226, 86, 115, 154, 203, 1 },
+        { 22, 108, 107, 108, 170, 141, 0 },
+        { 233, 172, 231, 53, 35, 130, 0 }, },
+      { { 90, 202, 163, 22, 250, 87, 1 },
+        { 158, 150, 172, 55, 155, 201, 0 },
+        { 245, 47, 180, 98, 169, 173, 0 },
+        { 73, 236, 246, 26, 180, 188, 1 }, },
+      { { 88, 216, 190, 3, 241, 57, 0 },
+        { 40, 215, 180, 70, 186, 69, 1 },
+        { 78, 71, 224, 62, 141, 141, 0 },
+        { 209, 46, 177, 22, 245, 138, 0 }, },
+      { { 90, 253, 27, 96, 216, 252, 0 },
+        { 228, 251, 102, 21, 62, 193, 1 },
+        { 31, 141, 131, 108, 95, 173, 0 },
+        { 193, 190, 84, 51, 111, 147, 1 }, },
+      { { 93, 40, 12, 244, 83, 170, 1 },
+        { 51, 186, 94, 160, 49, 21, 1 },
+        { 170, 229, 23, 152, 10, 93, 0 },
+        { 212, 70, 2, 189, 46, 230, 0 }, },
+      { { 94, 52, 215, 24, 145, 91, 0 },
+        { 213, 71, 63, 3, 50, 71, 0 },
+        { 109, 68, 140, 117, 150, 61, 0 },
+        { 113, 38, 96, 126, 113, 85, 1 }, },
+      { { 94, 140, 231, 129, 51, 103, 0 },
+        { 205, 134, 157, 243, 26, 5, 1 },
+        { 115, 102, 64, 243, 152, 189, 0 },
+        { 208, 44, 103, 220, 176, 217, 1 }, },
+      { { 92, 240, 52, 170, 32, 5, 0 },
+        { 9, 103, 134, 148, 152, 6, 0 },
+        { 80, 2, 42, 150, 7, 157, 0 },
+        { 48, 12, 148, 176, 243, 72, 0 }, },
+      { { 99, 47, 8, 198, 1, 227, 0 },
+        { 228, 140, 90, 136, 149, 24, 1 },
+        { 99, 192, 49, 136, 122, 99, 0 },
+        { 140, 84, 136, 173, 24, 147, 1 }, },
+      { { 97, 34, 240, 131, 154, 222, 0 },
+        { 4, 72, 171, 250, 176, 217, 0 },
+        { 61, 172, 224, 135, 162, 67, 0 },
+        { 77, 134, 175, 234, 137, 16, 0 }, },
+      { { 97, 64, 6, 28, 66, 91, 1 },
+        { 22, 20, 8, 44, 51, 86, 0 },
+        { 237, 33, 28, 48, 1, 67, 0 },
+        { 53, 102, 26, 8, 20, 52, 0 }, },
+      { { 99, 104, 252, 248, 31, 16, 0 },
+        { 176, 224, 211, 174, 80, 215, 0 },
+        { 4, 124, 15, 159, 139, 99, 0 },
+        { 117, 133, 58, 229, 131, 134, 1 }, },
+      { { 98, 163, 80, 160, 5, 206, 1 },
+        { 134, 104, 27, 152, 124, 8, 0 },
+        { 185, 208, 2, 133, 98, 163, 0 },
+        { 8, 31, 12, 236, 11, 48, 1 }, },
+      { { 96, 207, 8, 137, 207, 134, 1 },
+        { 98, 152, 56, 252, 92, 138, 0 },
+        { 176, 249, 200, 136, 121, 131, 0 },
+        { 40, 157, 31, 142, 12, 163, 0 }, },
+      { { 100, 31, 102, 147, 38, 250, 0 },
+        { 93, 137, 137, 232, 246, 76, 1 },
+        { 47, 178, 100, 179, 124, 19, 0 },
+        { 153, 55, 139, 200, 200, 221, 0 }, },
+      { { 103, 84, 36, 66, 155, 194, 1 },
+        { 199, 9, 248, 44, 144, 149, 0 },
+        { 161, 236, 161, 18, 21, 115, 0 },
+        { 84, 132, 154, 15, 200, 113, 1 }, },
+      { { 103, 94, 109, 245, 161, 167, 0 },
+        { 249, 173, 249, 221, 17, 28, 1 },
+        { 114, 194, 215, 219, 61, 115, 0 },
+        { 156, 68, 93, 207, 218, 207, 1 }, },
+      { { 100, 112, 128, 63, 112, 33, 0 },
+        { 25, 53, 2, 78, 145, 3, 1 },
+        { 66, 7, 126, 0, 135, 19, 0 },
+        { 224, 68, 185, 32, 86, 76, 0 }, },
+      { { 101, 113, 143, 62, 145, 182, 1 },
+        { 51, 41, 58, 31, 151, 87, 1 },
+        { 182, 196, 190, 120, 199, 83, 0 },
+        { 245, 116, 252, 46, 74, 102, 0 }, },
+      { { 103, 153, 192, 236, 194, 232, 1 },
+        { 135, 185, 97, 170, 61, 18, 1 },
+        { 139, 161, 155, 129, 204, 243, 0 },
+        { 164, 94, 42, 195, 78, 240, 1 }, },
+      { { 102, 181, 191, 1, 79, 214, 0 },
+        { 229, 89, 154, 123, 94, 196, 0 },
+        { 53, 249, 64, 126, 214, 179, 0 },
+        { 17, 189, 111, 44, 205, 83, 1 }, },
+      { { 103, 209, 57, 91, 135, 184, 0 },
+        { 177, 73, 240, 109, 252, 82, 1 },
+        { 14, 240, 237, 78, 69, 243, 0 },
+        { 165, 31, 219, 7, 201, 70, 1 }, },
+      { { 101, 214, 185, 83, 116, 18, 0 },
+        { 121, 81, 200, 79, 216, 89, 0 },
+        { 36, 23, 101, 78, 181, 211, 0 },
+        { 77, 13, 249, 9, 197, 79, 0 }, },
+      { { 107, 53, 69, 174, 190, 183, 0 },
+        { 200, 47, 43, 185, 213, 215, 1 },
+        { 118, 190, 186, 209, 86, 107, 0 },
+        { 245, 213, 206, 234, 122, 9, 1 }, },
+      { { 106, 85, 31, 116, 156, 15, 1 },
+        { 242, 103, 104, 29, 119, 133, 0 },
+        { 248, 28, 151, 124, 85, 43, 0 },
+        { 80, 247, 92, 11, 115, 39, 1 }, },
+      { { 105, 214, 240, 35, 1, 52, 0 },
+        { 64, 99, 145, 94, 152, 88, 1 },
+        { 22, 64, 98, 7, 181, 203, 0 },
+        { 141, 12, 189, 68, 227, 1, 0 }, },
+      { { 107, 214, 206, 166, 84, 232, 1 },
+        { 230, 59, 1, 142, 251, 29, 1 },
+        { 139, 149, 50, 185, 181, 235, 0 },
+        { 220, 111, 184, 192, 110, 51, 1 }, },
+      { { 108, 83, 126, 168, 65, 235, 0 },
+        { 37, 127, 153, 140, 54, 14, 1 },
+        { 107, 193, 10, 191, 101, 27, 0 },
+        { 184, 54, 24, 204, 255, 82, 0 }, },
+      { { 110, 99, 164, 20, 64, 36, 1 },
+        { 147, 18, 130, 30, 21, 12, 1 },
+        { 146, 1, 20, 18, 227, 59, 0 },
+        { 152, 84, 60, 32, 164, 100, 1 }, },
+      { { 108, 120, 204, 22, 132, 88, 1 },
+        { 55, 131, 35, 14, 241, 68, 0 },
+        { 141, 16, 180, 25, 143, 27, 0 },
+        { 17, 71, 184, 98, 96, 246, 0 }, },
+      { { 108, 206, 226, 122, 51, 47, 0 },
+        { 89, 166, 217, 62, 186, 11, 1 },
+        { 122, 102, 47, 35, 185, 155, 0 },
+        { 232, 46, 190, 77, 178, 205, 0 }, },
+      { { 111, 226, 98, 8, 71, 155, 0 },
+        { 129, 30, 155, 44, 122, 90, 0 },
+        { 108, 241, 8, 35, 35, 251, 0 },
+        { 45, 47, 26, 108, 188, 64, 1 }, },
+      { { 113, 2, 15, 225, 198, 243, 0 },
+        { 36, 60, 108, 233, 82, 92, 1 },
+        { 103, 177, 195, 248, 32, 71, 0 },
+        { 157, 37, 75, 155, 30, 18, 0 }, },
+      { { 113, 1, 66, 223, 219, 44, 0 },
+        { 16, 16, 117, 248, 183, 147, 1 },
+        { 26, 109, 253, 161, 64, 71, 0 },
+        { 228, 246, 143, 215, 4, 4, 0 }, },
+      { { 114, 10, 186, 206, 130, 96, 0 },
+        { 164, 192, 228, 170, 147, 10, 1 },
+        { 3, 32, 185, 174, 168, 39, 0 },
+        { 168, 100, 170, 147, 129, 146, 1 }, },
+      { { 114, 76, 255, 13, 215, 153, 0 },
+        { 224, 220, 181, 111, 115, 71, 0 },
+        { 76, 245, 216, 127, 153, 39, 0 },
+        { 113, 103, 123, 86, 157, 131, 1 }, },
+      { { 112, 148, 200, 167, 175, 228, 0 },
+        { 108, 41, 53, 250, 217, 128, 1 },
+        { 19, 250, 242, 137, 148, 135, 0 },
+        { 128, 205, 175, 214, 74, 27, 0 }, },
+      { { 115, 219, 92, 88, 31, 37, 1 },
+        { 178, 197, 85, 60, 92, 159, 1 },
+        { 210, 124, 13, 29, 109, 231, 0 },
+        { 252, 157, 30, 85, 81, 166, 1 }, },
+      { { 113, 220, 240, 226, 63, 213, 1 },
+        { 78, 237, 213, 190, 216, 209, 0 },
+        { 213, 254, 35, 135, 157, 199, 0 },
+        { 69, 141, 190, 213, 219, 185, 0 }, },
+      { { 115, 240, 217, 222, 113, 35, 1 },
+        { 186, 85, 95, 143, 153, 19, 1 },
+        { 226, 71, 61, 205, 135, 231, 0 },
+        { 228, 76, 248, 253, 85, 46, 1 }, },
+      { { 117, 16, 178, 106, 60, 109, 0 },
+        { 13, 101, 196, 26, 242, 147, 1 },
+        { 91, 30, 43, 38, 132, 87, 0 },
+        { 228, 167, 172, 17, 211, 88, 0 }, },
+      { { 117, 125, 232, 146, 6, 63, 0 },
+        { 113, 133, 143, 190, 244, 80, 1 },
+        { 126, 48, 36, 139, 223, 87, 0 },
+        { 133, 23, 190, 248, 208, 199, 0 }, },
+      { { 116, 159, 153, 133, 17, 253, 0 },
+        { 101, 205, 20, 219, 61, 73, 1 },
+        { 95, 196, 80, 204, 252, 151, 0 },
+        { 201, 94, 109, 148, 89, 211, 0 }, },
+      { { 122, 14, 219, 24, 154, 237, 0 },
+        { 244, 206, 37, 59, 50, 139, 1 },
+        { 91, 172, 140, 109, 184, 47, 0 },
+        { 232, 166, 110, 82, 57, 151, 1 }, },
+      { { 121, 22, 143, 58, 72, 165, 1 },
+        { 114, 63, 4, 27, 146, 158, 1 },
+        { 210, 137, 46, 120, 180, 79, 0 },
+        { 188, 164, 236, 16, 126, 39, 0 }, },
+      { { 121, 188, 129, 6, 112, 53, 0 },
+        { 72, 151, 6, 27, 153, 81, 1 },
+        { 86, 7, 48, 64, 158, 207, 0 },
+        { 197, 76, 236, 48, 116, 137, 0 }, },
+      { { 125, 77, 194, 163, 143, 129, 1 },
+        { 67, 174, 53, 238, 214, 144, 0 },
+        { 192, 248, 226, 161, 217, 95, 0 },
+        { 4, 181, 187, 214, 58, 225, 0 }, },
+      { { 124, 135, 26, 99, 181, 78, 0 },
+        { 109, 98, 124, 88, 254, 9, 0 },
+        { 57, 86, 227, 44, 112, 159, 0 },
+        { 72, 63, 141, 31, 35, 91, 0 }, },
+      { { 127, 162, 123, 214, 2, 146, 1 },
+        { 179, 74, 207, 169, 155, 88, 0 },
+        { 164, 160, 53, 239, 34, 255, 0 },
+        { 13, 108, 202, 249, 169, 102, 1 }, },
+      { { 125, 171, 223, 59, 221, 197, 1 },
+        { 55, 254, 55, 91, 222, 159, 0 },
+        { 209, 221, 238, 125, 234, 223, 0 },
+        { 124, 189, 237, 118, 63, 246, 0 }, },
+      { { 125, 187, 65, 173, 85, 124, 1 },
+        { 7, 179, 23, 217, 125, 91, 1 },
+        { 159, 85, 90, 193, 110, 223, 0 },
+        { 237, 95, 77, 244, 102, 240, 0 }, },
+      { { 131, 4, 66, 138, 233, 199, 0 },
+        { 204, 28, 57, 144, 130, 178, 0 },
+        { 113, 203, 168, 161, 16, 96, 1 },
+        { 38, 160, 132, 206, 28, 25, 1 }, },
+      { { 131, 43, 42, 216, 218, 107, 1 },
+        { 182, 148, 234, 160, 38, 187, 1 },
+        { 235, 45, 141, 170, 106, 96, 1 },
+        { 238, 178, 2, 171, 148, 182, 1 }, },
+      { { 129, 42, 82, 146, 228, 127, 0 },
+        { 28, 212, 43, 144, 226, 120, 1 },
+        { 127, 19, 164, 165, 42, 64, 1 },
+        { 143, 35, 132, 234, 21, 156, 0 }, },
+      { { 129, 56, 22, 164, 149, 242, 0 },
+        { 4, 233, 58, 128, 67, 117, 1 },
+        { 39, 212, 146, 180, 14, 64, 1 },
+        { 215, 97, 0, 174, 75, 144, 0 }, },
+      { { 129, 100, 221, 191, 156, 110, 1 },
+        { 118, 96, 43, 215, 225, 183, 1 },
+        { 187, 28, 254, 221, 147, 64, 1 },
+        { 246, 195, 245, 234, 3, 55, 0 }, },
+      { { 129, 123, 93, 252, 187, 253, 1 },
+        { 62, 237, 115, 181, 37, 255, 1 },
+        { 223, 238, 159, 221, 111, 64, 1 },
+        { 255, 210, 86, 231, 91, 190, 0 }, },
+      { { 130, 178, 225, 68, 80, 78, 0 },
+        { 132, 17, 203, 19, 41, 41, 0 },
+        { 57, 5, 17, 67, 166, 160, 1 },
+        { 74, 74, 100, 105, 196, 16, 1 }, },
+      { { 128, 247, 188, 97, 25, 21, 0 },
+        { 96, 101, 210, 86, 12, 237, 0 },
+        { 84, 76, 67, 30, 247, 128, 1 },
+        { 91, 152, 53, 37, 211, 3, 0 }, },
+      { { 135, 52, 106, 165, 125, 200, 0 },
+        { 237, 57, 147, 192, 99, 177, 0 },
+        { 9, 223, 82, 171, 22, 112, 1 },
+        { 70, 227, 1, 228, 206, 91, 1 }, },
+      { { 132, 140, 23, 210, 149, 239, 1 },
+        { 87, 204, 120, 145, 234, 37, 1 },
+        { 251, 212, 165, 244, 24, 144, 1 },
+        { 210, 43, 196, 143, 25, 245, 0 }, },
+      { { 132, 150, 182, 186, 170, 44, 0 },
+        { 89, 97, 160, 178, 170, 174, 1 },
+        { 26, 42, 174, 182, 180, 144, 1 },
+        { 186, 170, 166, 130, 195, 77, 0 }, },
+      { { 135, 156, 185, 242, 219, 180, 0 },
+        { 241, 249, 240, 179, 136, 241, 1 },
+        { 22, 237, 167, 206, 156, 240, 1 },
+        { 199, 136, 230, 135, 207, 199, 1 }, },
+      { { 132, 196, 118, 79, 240, 21, 1 },
+        { 75, 84, 225, 84, 139, 103, 0 },
+        { 212, 7, 249, 55, 17, 144, 1 },
+        { 115, 104, 149, 67, 149, 105, 0 }, },
+      { { 135, 196, 142, 129, 238, 18, 1 },
+        { 235, 16, 40, 230, 74, 244, 0 },
+        { 164, 59, 192, 184, 145, 240, 1 },
+        { 23, 169, 51, 138, 4, 107, 1 }, },
+      { { 133, 225, 245, 45, 64, 89, 1 },
+        { 7, 116, 131, 71, 45, 118, 0 },
+        { 205, 1, 90, 87, 195, 208, 1 },
+        { 55, 90, 113, 96, 151, 112, 0 }, },
+      { { 137, 14, 35, 66, 210, 193, 1 },
+        { 70, 158, 224, 33, 130, 57, 0 },
+        { 193, 165, 161, 98, 56, 72, 1 },
+        { 78, 32, 194, 3, 188, 177, 0 }, },
+      { { 138, 56, 218, 197, 237, 134, 1 },
+        { 170, 219, 123, 210, 67, 160, 0 },
+        { 176, 219, 209, 173, 142, 40, 1 },
+        { 2, 225, 37, 239, 109, 170, 1 }, },
+      { { 138, 149, 152, 168, 110, 21, 0 },
+        { 232, 119, 0, 178, 76, 226, 0 },
+        { 84, 59, 10, 140, 212, 168, 1 },
+        { 35, 153, 38, 128, 119, 11, 1 }, },
+      { { 141, 29, 47, 20, 46, 123, 1 },
+        { 127, 135, 136, 33, 103, 244, 1 },
+        { 239, 58, 20, 122, 92, 88, 1 },
+        { 151, 243, 66, 8, 240, 255, 0 }, },
+      { { 141, 111, 99, 41, 14, 170, 1 },
+        { 67, 170, 139, 101, 102, 186, 1 },
+        { 170, 184, 74, 99, 123, 88, 1 },
+        { 174, 179, 83, 104, 170, 225, 0 }, },
+      { { 142, 178, 140, 83, 176, 124, 1 },
+        { 191, 3, 98, 82, 168, 109, 1 },
+        { 159, 6, 229, 24, 166, 184, 1 },
+        { 219, 10, 165, 35, 96, 126, 1 }, },
+      { { 142, 222, 235, 43, 219, 30, 1 },
+        { 227, 179, 185, 119, 170, 235, 0 },
+        { 188, 109, 234, 107, 189, 184, 1 },
+        { 107, 170, 247, 78, 230, 227, 1 }, },
+      { { 141, 245, 6, 243, 158, 250, 0 },
+        { 85, 43, 106, 228, 238, 245, 1 },
+        { 47, 188, 231, 176, 87, 216, 1 },
+        { 215, 187, 147, 171, 106, 85, 0 }, },
+      { { 144, 23, 149, 47, 152, 143, 0 },
+        { 64, 109, 44, 83, 165, 175, 0 },
+        { 120, 140, 250, 84, 244, 4, 1 },
+        { 122, 210, 229, 26, 91, 1, 0 }, },
+      { { 145, 35, 7, 27, 254, 232, 0 },
+        { 28, 24, 38, 97, 230, 191, 1 },
+        { 11, 191, 236, 112, 98, 68, 1 },
+        { 254, 179, 195, 50, 12, 28, 0 }, },
+      { { 144, 37, 85, 177, 206, 2, 1 },
+        { 82, 112, 47, 225, 68, 164, 0 },
+        { 160, 57, 198, 213, 82, 4, 1 },
+        { 18, 145, 67, 250, 7, 37, 0 }, },
+      { { 144, 40, 188, 66, 77, 232, 0 },
+        { 36, 216, 214, 2, 224, 164, 1 },
+        { 11, 217, 33, 30, 138, 4, 1 },
+        { 146, 131, 160, 53, 141, 146, 0 }, },
+      { { 144, 57, 208, 138, 32, 54, 1 },
+        { 10, 193, 15, 146, 132, 98, 1 },
+        { 182, 2, 40, 133, 206, 4, 1 },
+        { 163, 16, 164, 248, 65, 168, 0 }, },
+      { { 147, 79, 149, 211, 130, 90, 0 },
+        { 212, 192, 108, 231, 164, 124, 0 },
+        { 45, 32, 229, 212, 249, 100, 1 },
+        { 31, 18, 243, 155, 1, 149, 1 }, },
+      { { 146, 164, 210, 234, 226, 74, 0 },
+        { 204, 112, 111, 162, 170, 34, 0 },
+        { 41, 35, 171, 165, 146, 164, 1 },
+        { 34, 42, 162, 251, 7, 25, 1 }, },
+      { { 145, 180, 112, 9, 138, 92, 1 },
+        { 70, 65, 167, 112, 40, 242, 0 },
+        { 157, 40, 200, 7, 22, 196, 1 },
+        { 39, 138, 7, 114, 193, 49, 0 }, },
+      { { 147, 222, 25, 219, 41, 219, 1 },
+        { 254, 205, 92, 197, 168, 250, 0 },
+        { 237, 202, 109, 204, 61, 228, 1 },
+        { 47, 138, 209, 157, 89, 191, 1 }, },
+      { { 145, 229, 150, 87, 118, 92, 0 },
+        { 92, 80, 70, 118, 239, 117, 0 },
+        { 29, 55, 117, 52, 211, 196, 1 },
+        { 87, 123, 183, 49, 5, 29, 0 }, },
+      { { 146, 236, 144, 218, 63, 135, 0 },
+        { 216, 204, 94, 182, 200, 163, 0 },
+        { 112, 254, 45, 132, 155, 164, 1 },
+        { 98, 137, 182, 189, 25, 141, 1 }, },
+      { { 146, 252, 112, 168, 201, 176, 0 },
+        { 192, 249, 183, 132, 8, 226, 1 },
+        { 6, 201, 138, 135, 31, 164, 1 },
+        { 163, 136, 16, 246, 207, 129, 1 }, },
+      { { 149, 25, 170, 136, 106, 158, 1 },
+        { 43, 153, 140, 178, 38, 242, 0 },
+        { 188, 171, 8, 170, 204, 84, 1 },
+        { 39, 178, 38, 152, 204, 234, 0 }, },
+      { { 148, 82, 41, 183, 65, 127, 0 },
+        { 53, 53, 156, 213, 161, 104, 1 },
+        { 127, 65, 118, 202, 37, 20, 1 },
+        { 139, 66, 213, 156, 214, 86, 0 }, },
+      { { 148, 87, 59, 92, 68, 38, 1 },
+        { 115, 81, 204, 21, 71, 42, 1 },
+        { 178, 17, 29, 110, 117, 20, 1 },
+        { 170, 113, 84, 25, 197, 103, 0 }, },
+      { { 151, 82, 5, 249, 168, 20, 0 },
+        { 153, 33, 100, 213, 0, 254, 0 },
+        { 20, 10, 207, 208, 37, 116, 1 },
+        { 63, 128, 85, 147, 66, 76, 1 }, },
+      { { 150, 156, 251, 61, 143, 160, 1 },
+        { 243, 233, 181, 99, 75, 162, 1 },
+        { 130, 248, 222, 111, 156, 180, 1 },
+        { 162, 233, 99, 86, 203, 231, 1 }, },
+      { { 151, 163, 111, 26, 69, 144, 1 },
+        { 179, 24, 151, 1, 206, 126, 0 },
+        { 132, 209, 44, 123, 98, 244, 1 },
+        { 63, 57, 192, 116, 140, 102, 1 }, },
+      { { 151, 170, 229, 229, 236, 98, 0 },
+        { 141, 176, 239, 195, 73, 188, 1 },
+        { 35, 27, 211, 211, 170, 244, 1 },
+        { 158, 201, 97, 251, 134, 216, 1 }, },
+      { { 151, 229, 170, 59, 113, 88, 1 },
+        { 255, 48, 150, 70, 174, 115, 0 },
+        { 141, 71, 110, 42, 211, 244, 1 },
+        { 103, 58, 177, 52, 134, 127, 1 }, },
+      { { 154, 32, 49, 130, 105, 146, 1 },
+        { 138, 90, 158, 129, 128, 224, 0 },
+        { 164, 203, 32, 198, 2, 44, 1 },
+        { 3, 128, 192, 188, 173, 40, 1 }, },
+      { { 153, 69, 56, 75, 61, 53, 1 },
+        { 106, 70, 212, 84, 196, 243, 1 },
+        { 214, 94, 105, 14, 81, 76, 1 },
+        { 231, 145, 149, 21, 177, 43, 0 }, },
+      { { 154, 177, 236, 143, 208, 111, 1 },
+        { 166, 23, 175, 210, 173, 39, 1 },
+        { 251, 5, 248, 155, 198, 172, 1 },
+        { 242, 90, 165, 250, 244, 50, 1 }, },
+      { { 154, 213, 151, 178, 63, 108, 1 },
+        { 222, 99, 20, 183, 238, 165, 1 },
+        { 155, 126, 38, 244, 213, 172, 1 },
+        { 210, 187, 246, 148, 99, 61, 1 }, },
+      { { 153, 249, 19, 79, 121, 230, 0 },
+        { 12, 219, 94, 85, 143, 179, 1 },
+        { 51, 207, 121, 100, 79, 204, 1 },
+        { 230, 248, 213, 61, 109, 152, 0 }, },
+      { { 158, 24, 232, 0, 191, 106, 1 },
+        { 175, 131, 189, 34, 96, 161, 1 },
+        { 171, 126, 128, 11, 140, 60, 1 },
+        { 194, 131, 34, 94, 224, 250, 1 }, },
+      { { 159, 72, 93, 163, 29, 40, 1 },
+        { 163, 226, 21, 197, 224, 181, 1 },
+        { 138, 92, 98, 221, 9, 124, 1 },
+        { 214, 131, 209, 212, 35, 226, 1 }, },
+      { { 159, 84, 21, 142, 137, 140, 0 },
+        { 193, 75, 52, 149, 161, 182, 0 },
+        { 24, 200, 184, 212, 21, 124, 1 },
+        { 54, 194, 212, 150, 105, 65, 1 }, },
+      { { 157, 106, 155, 82, 57, 78, 1 },
+        { 63, 194, 94, 23, 162, 185, 0 },
+        { 185, 78, 37, 108, 171, 92, 1 },
+        { 78, 162, 244, 61, 33, 254, 0 }, },
+      { { 158, 111, 156, 10, 159, 118, 0 },
+        { 229, 194, 62, 54, 196, 239, 1 },
+        { 55, 124, 168, 28, 251, 60, 1 },
+        { 251, 145, 182, 62, 33, 211, 1 }, },
+      { { 160, 9, 100, 5, 91, 91, 0 },
+        { 4, 148, 153, 104, 37, 229, 0 },
+        { 109, 109, 80, 19, 72, 2, 1 },
+        { 83, 210, 11, 76, 148, 144, 0 }, },
+      { { 162, 60, 219, 252, 54, 178, 0 },
+        { 248, 233, 75, 171, 67, 99, 1 },
+        { 38, 182, 31, 237, 158, 34, 1 },
+        { 227, 97, 106, 233, 75, 143, 1 }, },
+      { { 163, 91, 247, 118, 247, 143, 0 },
+        { 152, 253, 249, 63, 231, 61, 0 },
+        { 120, 247, 183, 119, 237, 98, 1 },
+        { 94, 115, 254, 79, 223, 140, 1 }, },
+      { { 162, 157, 115, 18, 132, 59, 0 },
+        { 208, 197, 169, 9, 238, 96, 1 },
+        { 110, 16, 164, 103, 92, 162, 1 },
+        { 131, 59, 200, 74, 209, 133, 1 }, },
+      { { 160, 206, 10, 169, 116, 87, 0 },
+        { 108, 180, 8, 220, 74, 107, 0 },
+        { 117, 23, 74, 168, 57, 130, 1 },
+        { 107, 41, 29, 136, 22, 155, 0 }, },
+      { { 160, 220, 172, 38, 43, 179, 1 },
+        { 106, 173, 152, 46, 137, 228, 1 },
+        { 230, 234, 50, 26, 157, 130, 1 },
+        { 147, 200, 186, 12, 218, 171, 0 }, },
+      { { 162, 245, 118, 116, 106, 43, 1 },
+        { 218, 117, 203, 44, 47, 164, 1 },
+        { 234, 43, 23, 55, 87, 162, 1 },
+        { 146, 250, 26, 105, 215, 45, 1 }, },
+      { { 166, 47, 214, 238, 159, 142, 1 },
+        { 195, 232, 123, 186, 231, 175, 0 },
+        { 184, 252, 187, 181, 250, 50, 1 },
+        { 122, 243, 174, 239, 11, 225, 1 }, },
+      { { 165, 56, 116, 248, 96, 115, 1 },
+        { 31, 245, 203, 136, 0, 118, 1 },
+        { 231, 3, 15, 151, 14, 82, 1 },
+        { 183, 0, 8, 233, 215, 252, 0 }, },
+      { { 164, 94, 71, 141, 231, 74, 0 },
+        { 77, 145, 57, 237, 99, 46, 0 },
+        { 41, 115, 216, 241, 61, 18, 1 },
+        { 58, 99, 91, 206, 68, 217, 0 }, },
+      { { 167, 93, 87, 124, 48, 116, 1 },
+        { 223, 225, 65, 29, 7, 119, 1 },
+        { 151, 6, 31, 117, 93, 114, 1 },
+        { 247, 112, 92, 65, 67, 253, 1 }, },
+      { { 166, 114, 149, 34, 69, 134, 0 },
+        { 129, 121, 26, 31, 192, 44, 0 },
+        { 48, 209, 34, 84, 167, 50, 1 },
+        { 26, 1, 252, 44, 79, 64, 1 }, },
+      { { 165, 131, 104, 82, 20, 90, 0 },
+        { 53, 0, 201, 8, 236, 121, 0 },
+        { 45, 20, 37, 11, 96, 210, 1 },
+        { 79, 27, 136, 73, 128, 86, 0 }, },
+      { { 164, 155, 84, 147, 194, 3, 0 },
+        { 17, 213, 41, 232, 140, 44, 0 },
+        { 96, 33, 228, 149, 108, 146, 1 },
+        { 26, 24, 139, 202, 85, 196, 0 }, },
+      { { 166, 189, 42, 131, 213, 14, 0 },
+        { 225, 145, 186, 216, 238, 33, 0 },
+        { 56, 85, 224, 170, 94, 178, 1 },
+        { 66, 59, 141, 174, 196, 195, 1 }, },
+      { { 169, 7, 89, 5, 251, 125, 0 },
+        { 108, 86, 49, 121, 37, 249, 1 },
+        { 95, 111, 208, 77, 112, 74, 1 },
+        { 207, 210, 79, 70, 53, 27, 0 }, },
+      { { 169, 21, 217, 154, 37, 235, 1 },
+        { 126, 79, 25, 139, 228, 50, 1 },
+        { 235, 210, 44, 205, 212, 74, 1 },
+        { 166, 19, 232, 204, 121, 63, 0 }, },
+      { { 171, 34, 146, 112, 50, 2, 0 },
+        { 152, 98, 74, 42, 2, 57, 0 },
+        { 32, 38, 7, 36, 162, 106, 1 },
+        { 78, 32, 42, 41, 35, 12, 1 }, },
+      { { 169, 55, 228, 166, 33, 245, 1 },
+        { 78, 47, 147, 154, 133, 124, 1 },
+        { 215, 194, 50, 147, 246, 74, 1 },
+        { 159, 80, 172, 228, 250, 57, 0 }, },
+      { { 170, 114, 189, 81, 74, 123, 0 },
+        { 180, 87, 202, 111, 32, 236, 1 },
+        { 111, 41, 69, 94, 167, 42, 1 },
+        { 155, 130, 123, 41, 245, 22, 1 }, },
+      { { 168, 137, 199, 107, 240, 9, 0 },
+        { 8, 182, 97, 75, 174, 39, 0 },
+        { 72, 7, 235, 113, 200, 138, 1 },
+        { 114, 58, 233, 67, 54, 136, 0 }, },
+      { { 170, 213, 171, 110, 131, 212, 1 },
+        { 230, 43, 240, 63, 143, 98, 0 },
+        { 149, 224, 187, 106, 213, 170, 1 },
+        { 35, 120, 254, 7, 234, 51, 1 }, },
+      { { 168, 211, 200, 181, 190, 175, 0 },
+        { 56, 47, 41, 254, 109, 169, 1 },
+        { 122, 190, 214, 137, 229, 138, 1 },
+        { 202, 219, 63, 202, 122, 14, 0 }, },
+      { { 174, 20, 19, 54, 167, 164, 0 },
+        { 217, 107, 48, 57, 195, 32, 1 },
+        { 18, 242, 182, 100, 20, 58, 1 },
+        { 130, 97, 206, 6, 107, 77, 1 }, },
+      { { 173, 100, 135, 249, 112, 220, 1 },
+        { 95, 58, 66, 223, 34, 119, 0 },
+        { 157, 135, 79, 240, 147, 90, 1 },
+        { 119, 34, 125, 161, 46, 125, 0 }, },
+      { { 175, 121, 76, 217, 234, 209, 1 },
+        { 191, 159, 99, 236, 4, 246, 0 },
+        { 197, 171, 205, 153, 79, 122, 1 },
+        { 55, 144, 27, 227, 124, 254, 1 }, },
+      { { 173, 154, 157, 184, 0, 254, 1 },
+        { 55, 235, 8, 155, 40, 126, 1 },
+        { 191, 128, 14, 220, 172, 218, 1 },
+        { 191, 10, 108, 136, 107, 246, 0 }, },
+      { { 175, 156, 136, 245, 213, 82, 0 },
+        { 245, 179, 120, 202, 73, 113, 0 },
+        { 37, 85, 215, 136, 156, 250, 1 },
+        { 71, 73, 41, 143, 102, 215, 1 }, },
+      { { 173, 207, 238, 79, 108, 35, 0 },
+        { 105, 150, 201, 78, 207, 190, 1 },
+        { 98, 27, 121, 59, 249, 218, 1 },
+        { 190, 249, 185, 73, 180, 203, 0 }, },
+      { { 173, 247, 163, 231, 58, 61, 1 },
+        { 75, 39, 194, 255, 175, 249, 1 },
+        { 222, 46, 115, 226, 247, 218, 1 },
+        { 207, 250, 255, 161, 242, 105, 0 }, },
+      { { 178, 65, 252, 215, 31, 187, 0 },
+        { 176, 76, 221, 238, 229, 229, 1 },
+        { 110, 252, 117, 159, 193, 38, 1 },
+        { 211, 211, 187, 221, 153, 6, 1 }, },
+      { { 179, 66, 216, 120, 217, 241, 1 },
+        { 182, 124, 117, 14, 0, 251, 1 },
+        { 199, 205, 143, 13, 161, 102, 1 },
+        { 239, 128, 56, 87, 31, 54, 1 }, },
+      { { 178, 97, 81, 226, 141, 99, 0 },
+        { 132, 100, 127, 141, 196, 160, 1 },
+        { 99, 88, 163, 197, 67, 38, 1 },
+        { 130, 145, 216, 255, 19, 16, 1 }, },
+      { { 179, 99, 173, 194, 60, 10, 1 },
+        { 170, 0, 206, 143, 228, 189, 0 },
+        { 168, 30, 33, 218, 227, 102, 1 },
+        { 94, 147, 248, 185, 128, 42, 1 }, },
+      { { 179, 122, 143, 78, 111, 189, 1 },
+        { 170, 157, 86, 63, 227, 254, 1 },
+        { 222, 251, 57, 120, 175, 102, 1 },
+        { 191, 227, 254, 53, 92, 170, 1 }, },
+      { { 176, 177, 13, 218, 203, 9, 1 },
+        { 50, 21, 118, 169, 172, 166, 0 },
+        { 200, 105, 173, 216, 70, 134, 1 },
+        { 50, 154, 202, 183, 84, 38, 0 }, },
+      { { 176, 187, 235, 133, 79, 183, 0 },
+        { 32, 157, 159, 251, 79, 232, 1 },
+        { 118, 249, 80, 235, 238, 134, 1 },
+        { 139, 249, 111, 252, 220, 130, 0 }, },
+      { { 177, 195, 46, 176, 79, 2, 0 },
+        { 48, 48, 156, 172, 78, 188, 0 },
+        { 32, 121, 6, 186, 97, 198, 1 },
+        { 30, 185, 26, 156, 134, 6, 0 }, },
+      { { 177, 202, 162, 122, 198, 206, 0 },
+        { 20, 184, 236, 62, 234, 58, 0 },
+        { 57, 177, 175, 34, 169, 198, 1 },
+        { 46, 43, 190, 27, 142, 148, 0 }, },
+      { { 180, 119, 47, 73, 43, 245, 0 },
+        { 109, 13, 214, 125, 6, 238, 1 },
+        { 87, 234, 73, 122, 119, 22, 1 },
+        { 187, 176, 95, 53, 216, 91, 0 }, },
+      { { 181, 174, 77, 39, 89, 131, 1 },
+        { 99, 188, 31, 73, 137, 189, 0 },
+        { 224, 205, 114, 89, 58, 214, 1 },
+        { 94, 200, 201, 124, 30, 227, 0 }, },
+      { { 183, 210, 205, 142, 206, 219, 0 },
+        { 165, 29, 45, 175, 233, 254, 0 },
+        { 109, 185, 184, 217, 165, 246, 1 },
+        { 63, 203, 250, 218, 92, 82, 1 }, },
+      { { 182, 235, 156, 93, 104, 151, 0 },
+        { 185, 220, 78, 94, 13, 238, 0 },
+        { 116, 139, 93, 28, 235, 182, 1 },
+        { 59, 216, 61, 57, 29, 206, 1 }, },
+      { { 180, 244, 103, 243, 78, 87, 0 },
+        { 85, 53, 207, 253, 202, 228, 0 },
+        { 117, 57, 103, 243, 23, 150, 1 },
+        { 19, 169, 223, 249, 214, 85, 0 }, },
+      { { 184, 15, 212, 222, 49, 7, 1 },
+        { 90, 198, 93, 154, 133, 47, 0 },
+        { 240, 70, 61, 149, 248, 14, 1 },
+        { 122, 80, 172, 221, 49, 173, 0 }, },
+      { { 184, 57, 126, 65, 128, 2, 0 },
+        { 32, 195, 239, 72, 6, 36, 0 },
+        { 32, 0, 193, 63, 78, 14, 1 },
+        { 18, 48, 9, 123, 225, 130, 0 }, },
+      { { 184, 56, 131, 182, 233, 190, 0 },
+        { 24, 187, 62, 155, 163, 224, 1 },
+        { 62, 203, 182, 224, 142, 14, 1 },
+        { 131, 226, 236, 190, 110, 140, 0 }, },
+      { { 184, 108, 6, 172, 40, 232, 0 },
+        { 76, 170, 6, 140, 35, 166, 1 },
+        { 11, 138, 26, 176, 27, 14, 1 },
+        { 178, 226, 24, 176, 42, 153, 0 }, },
+      { { 185, 136, 183, 154, 126, 192, 1 },
+        { 30, 218, 132, 171, 202, 183, 0 },
+        { 129, 191, 44, 246, 136, 206, 1 },
+        { 118, 169, 234, 144, 173, 188, 0 }, },
+      { { 184, 156, 165, 183, 60, 206, 0 },
+        { 92, 171, 140, 219, 233, 165, 0 },
+        { 57, 158, 118, 210, 156, 142, 1 },
+        { 82, 203, 237, 152, 234, 157, 0 }, },
+      { { 186, 207, 131, 167, 229, 28, 1 },
+        { 202, 178, 52, 223, 239, 104, 0 },
+        { 156, 83, 242, 224, 249, 174, 1 },
+        { 11, 123, 253, 150, 38, 169, 1 }, },
+      { { 184, 231, 17, 147, 88, 172, 1 },
+        { 82, 90, 6, 221, 172, 169, 1 },
+        { 154, 141, 100, 196, 115, 142, 1 },
+        { 202, 154, 221, 176, 45, 37, 0 }, },
+      { { 189, 114, 116, 100, 13, 206, 1 },
+        { 7, 107, 223, 28, 97, 188, 0 },
+        { 185, 216, 19, 23, 39, 94, 1 },
+        { 30, 195, 28, 125, 235, 112, 0 }, },
+      { { 188, 125, 134, 57, 75, 186, 1 },
+        { 83, 187, 30, 110, 38, 230, 1 },
+        { 174, 233, 78, 48, 223, 30, 1 },
+        { 179, 178, 59, 60, 110, 229, 0 }, },
+      { { 195, 30, 73, 175, 1, 169, 1 },
+        { 226, 173, 17, 193, 177, 58, 1 },
+        { 202, 192, 122, 201, 60, 97, 1 },
+        { 174, 70, 193, 196, 90, 163, 1 }, },
+      { { 192, 46, 91, 239, 41, 95, 0 },
+        { 108, 228, 91, 209, 179, 234, 0 },
+        { 125, 74, 123, 237, 58, 1, 1 },
+        { 43, 230, 197, 237, 19, 155, 0 }, },
+      { { 193, 78, 242, 15, 34, 121, 1 },
+        { 78, 196, 129, 102, 179, 122, 1 },
+        { 207, 34, 120, 39, 185, 65, 1 },
+        { 175, 102, 179, 64, 145, 185, 0 }, },
+      { { 193, 129, 72, 108, 154, 70, 1 },
+        { 38, 32, 105, 48, 29, 179, 0 },
+        { 177, 44, 155, 9, 64, 193, 1 },
+        { 102, 220, 6, 75, 2, 50, 0 }, },
+      { { 193, 153, 177, 237, 205, 191, 1 },
+        { 2, 253, 248, 211, 125, 242, 1 },
+        { 254, 217, 219, 198, 204, 193, 1 },
+        { 167, 223, 101, 143, 223, 160, 0 }, },
+      { { 193, 146, 177, 38, 19, 223, 1 },
+        { 6, 109, 152, 51, 185, 121, 0 },
+        { 253, 228, 50, 70, 164, 193, 1 },
+        { 79, 78, 230, 12, 219, 48, 0 }, },
+      { { 195, 183, 213, 56, 210, 51, 1 },
+        { 210, 117, 43, 35, 28, 127, 1 },
+        { 230, 37, 142, 85, 246, 225, 1 },
+        { 255, 28, 98, 106, 87, 37, 1 }, },
+      { { 193, 215, 25, 188, 235, 129, 1 },
+        { 122, 125, 48, 165, 29, 186, 0 },
+        { 192, 235, 158, 204, 117, 193, 1 },
+        { 46, 220, 82, 134, 95, 47, 0 }, },
+      { { 193, 246, 67, 78, 186, 232, 1 },
+        { 78, 9, 99, 37, 187, 187, 1 },
+        { 139, 174, 185, 97, 55, 193, 1 },
+        { 238, 238, 210, 99, 72, 57, 0 }, },
+      { { 196, 56, 145, 7, 35, 108, 1 },
+        { 15, 193, 18, 115, 177, 32, 1 },
+        { 155, 98, 112, 68, 142, 17, 1 },
+        { 130, 70, 231, 36, 65, 248, 0 }, },
+      { { 198, 77, 74, 227, 205, 183, 0 },
+        { 225, 188, 121, 212, 214, 224, 1 },
+        { 118, 217, 227, 169, 89, 49, 1 },
+        { 131, 181, 149, 207, 30, 195, 1 }, },
+      { { 199, 83, 172, 246, 95, 75, 1 },
+        { 183, 53, 216, 166, 245, 189, 0 },
+        { 233, 125, 55, 154, 229, 113, 1 },
+        { 94, 215, 178, 141, 214, 118, 1 }, },
+      { { 197, 126, 74, 113, 2, 75, 0 },
+        { 117, 165, 75, 100, 50, 56, 0 },
+        { 105, 32, 71, 41, 63, 81, 1 },
+        { 14, 38, 19, 105, 82, 215, 0 }, },
+      { { 198, 116, 217, 128, 138, 199, 1 },
+        { 231, 77, 43, 183, 16, 160, 0 },
+        { 241, 168, 128, 205, 151, 49, 1 },
+        { 2, 132, 118, 234, 89, 115, 1 }, },
+      { { 197, 136, 152, 47, 230, 202, 1 },
+        { 47, 248, 40, 98, 249, 50, 0 },
+        { 169, 179, 250, 12, 136, 209, 1 },
+        { 38, 79, 163, 10, 15, 250, 0 }, },
+      { { 197, 174, 39, 8, 53, 94, 1 },
+        { 79, 128, 154, 17, 122, 127, 0 },
+        { 189, 86, 8, 114, 58, 209, 1 },
+        { 127, 47, 68, 44, 128, 249, 0 }, },
+      { { 199, 188, 103, 248, 187, 33, 1 },
+        { 219, 165, 243, 161, 26, 183, 1 },
+        { 194, 110, 143, 243, 30, 241, 1 },
+        { 246, 172, 66, 231, 210, 237, 1 }, },
+      { { 196, 190, 140, 164, 243, 99, 0 },
+        { 109, 181, 58, 162, 25, 45, 1 },
+        { 99, 103, 146, 152, 190, 145, 1 },
+        { 218, 76, 34, 174, 86, 219, 0 }, },
+      { { 203, 15, 36, 114, 82, 53, 0 },
+        { 208, 182, 192, 48, 148, 125, 1 },
+        { 86, 37, 39, 18, 120, 105, 1 },
+        { 223, 20, 134, 1, 182, 133, 1 }, },
+      { { 201, 72, 89, 111, 111, 39, 1 },
+        { 42, 246, 89, 117, 209, 178, 1 },
+        { 242, 123, 123, 77, 9, 73, 1 },
+        { 166, 197, 215, 77, 55, 170, 0 }, },
+      { { 200, 85, 15, 64, 161, 129, 0 },
+        { 104, 15, 112, 5, 22, 36, 0 },
+        { 64, 194, 129, 120, 85, 9, 1 },
+        { 18, 52, 80, 7, 120, 11, 0 }, },
+      { { 203, 90, 139, 223, 86, 169, 0 },
+        { 176, 159, 64, 231, 243, 59, 1 },
+        { 74, 181, 125, 232, 173, 105, 1 },
+        { 238, 103, 243, 129, 124, 134, 1 }, },
+      { { 200, 115, 24, 175, 214, 16, 0 },
+        { 32, 115, 34, 228, 213, 107, 0 },
+        { 4, 53, 250, 140, 103, 9, 1 },
+        { 107, 85, 147, 162, 103, 2, 0 }, },
+      { { 201, 159, 158, 95, 56, 56, 0 },
+        { 120, 195, 64, 66, 191, 255, 1 },
+        { 14, 14, 125, 60, 252, 201, 1 },
+        { 255, 254, 161, 1, 97, 143, 0 }, },
+      { { 202, 191, 51, 44, 49, 240, 0 },
+        { 204, 235, 146, 1, 31, 107, 1 },
+        { 7, 198, 26, 102, 126, 169, 1 },
+        { 235, 124, 64, 36, 235, 153, 1 }, },
+      { { 201, 233, 181, 7, 221, 84, 0 },
+        { 4, 210, 178, 87, 221, 245, 0 },
+        { 21, 93, 240, 86, 203, 201, 1 },
+        { 87, 221, 245, 38, 165, 144, 0 }, },
+      { { 203, 240, 30, 59, 146, 129, 0 },
+        { 176, 111, 34, 100, 154, 55, 0 },
+        { 64, 164, 238, 60, 7, 233, 1 },
+        { 118, 44, 147, 34, 123, 6, 1 }, },
+      { { 204, 2, 72, 129, 217, 10, 0 },
+        { 33, 18, 57, 192, 48, 169, 0 },
+        { 40, 77, 192, 137, 32, 25, 1 },
+        { 74, 134, 1, 206, 36, 66, 0 }, },
+      { { 206, 44, 78, 124, 45, 3, 1 },
+        { 251, 166, 91, 0, 83, 166, 0 },
+        { 224, 90, 31, 57, 26, 57, 1 },
+        { 50, 229, 0, 109, 50, 239, 1 }, },
+      { { 205, 131, 179, 65, 153, 204, 1 },
+        { 7, 74, 240, 83, 62, 185, 0 },
+        { 153, 204, 193, 102, 224, 217, 1 },
+        { 78, 190, 101, 7, 169, 112, 0 }, },
+      { { 206, 128, 171, 157, 219, 17, 1 },
+        { 179, 22, 176, 227, 27, 227, 0 },
+        { 196, 109, 220, 234, 128, 185, 1 },
+        { 99, 236, 99, 134, 180, 102, 1 }, },
+      { { 204, 183, 70, 234, 75, 14, 1 },
+        { 67, 51, 91, 176, 190, 174, 0 },
+        { 184, 105, 43, 177, 118, 153, 1 },
+        { 58, 190, 134, 237, 102, 97, 0 }, },
+      { { 207, 228, 35, 113, 192, 123, 1 },
+        { 215, 54, 234, 69, 58, 112, 1 },
+        { 239, 1, 199, 98, 19, 249, 1 },
+        { 135, 46, 81, 43, 182, 117, 1 }, },
+      { { 205, 246, 59, 148, 188, 171, 1 },
+        { 123, 79, 170, 133, 123, 185, 1 },
+        { 234, 158, 148, 238, 55, 217, 1 },
+        { 206, 239, 80, 170, 249, 111, 0 }, },
+      { { 211, 23, 149, 186, 69, 222, 1 },
+        { 214, 121, 28, 147, 244, 126, 0 },
+        { 189, 209, 46, 212, 244, 101, 1 },
+        { 63, 23, 228, 156, 79, 53, 1 }, },
+      { { 208, 58, 34, 105, 80, 179, 0 },
+        { 0, 189, 206, 64, 18, 107, 1 },
+        { 102, 133, 75, 34, 46, 5, 1 },
+        { 235, 36, 1, 57, 222, 128, 0 }, },
+      { { 211, 54, 150, 219, 2, 36, 1 },
+        { 210, 65, 70, 242, 146, 62, 1 },
+        { 146, 32, 109, 180, 182, 101, 1 },
+        { 190, 36, 167, 177, 65, 37, 1 }, },
+      { { 210, 86, 224, 221, 145, 27, 0 },
+        { 208, 5, 253, 198, 49, 107, 0 },
+        { 108, 68, 221, 131, 181, 37, 1 },
+        { 107, 70, 49, 223, 208, 5, 1 }, },
+      { { 210, 188, 170, 228, 3, 129, 0 },
+        { 224, 173, 214, 162, 27, 32, 0 },
+        { 64, 224, 19, 170, 158, 165, 1 },
+        { 2, 108, 34, 181, 218, 131, 1 }, },
+      { { 211, 196, 238, 80, 249, 166, 0 },
+        { 248, 24, 253, 22, 26, 181, 1 },
+        { 50, 207, 133, 59, 145, 229, 1 },
+        { 214, 172, 52, 95, 140, 15, 1 }, },
+      { { 211, 228, 7, 252, 5, 226, 1 },
+        { 214, 40, 94, 133, 91, 54, 1 },
+        { 163, 208, 31, 240, 19, 229, 1 },
+        { 182, 109, 80, 189, 10, 53, 1 }, },
+      { { 211, 252, 28, 167, 191, 2, 0 },
+        { 232, 225, 62, 228, 217, 181, 0 },
+        { 32, 126, 242, 156, 31, 229, 1 },
+        { 86, 205, 147, 190, 67, 139, 1 }, },
+      { { 215, 68, 167, 168, 172, 223, 0 },
+        { 205, 44, 172, 151, 114, 246, 0 },
+        { 125, 154, 138, 242, 145, 117, 1 },
+        { 55, 167, 116, 154, 154, 89, 1 }, },
+      { { 214, 159, 244, 68, 89, 83, 0 },
+        { 197, 213, 221, 2, 29, 237, 0 },
+        { 101, 77, 17, 23, 252, 181, 1 },
+        { 91, 220, 32, 93, 213, 209, 1 }, },
+      { { 212, 175, 147, 230, 193, 68, 0 },
+        { 69, 240, 118, 147, 159, 40, 0 },
+        { 17, 65, 179, 228, 250, 149, 1 },
+        { 10, 124, 228, 183, 7, 209, 0 }, },
+      { { 217, 18, 102, 139, 15, 210, 1 },
+        { 6, 11, 157, 224, 210, 254, 0 },
+        { 165, 248, 104, 179, 36, 77, 1 },
+        { 63, 165, 131, 220, 232, 48, 0 }, },
+      { { 216, 81, 88, 45, 224, 190, 1 },
+        { 42, 123, 45, 84, 53, 98, 1 },
+        { 190, 131, 218, 13, 69, 13, 1 },
+        { 163, 86, 21, 90, 111, 42, 0 }, },
+      { { 216, 99, 102, 115, 129, 229, 0 },
+        { 20, 46, 247, 84, 150, 44, 1 },
+        { 83, 192, 231, 51, 99, 13, 1 },
+        { 154, 52, 149, 119, 186, 20, 0 }, },
+      { { 219, 108, 88, 112, 132, 206, 1 },
+        { 246, 234, 111, 20, 112, 48, 0 },
+        { 185, 144, 135, 13, 27, 109, 1 },
+        { 6, 7, 20, 123, 43, 183, 1 }, },
+      { { 217, 99, 155, 60, 255, 211, 0 },
+        { 60, 126, 62, 39, 87, 251, 0 },
+        { 101, 255, 158, 108, 227, 77, 1 },
+        { 111, 245, 114, 62, 63, 30, 0 }, },
+      { { 216, 138, 98, 229, 71, 244, 0 },
+        { 4, 186, 213, 240, 91, 104, 1 },
+        { 23, 241, 83, 163, 40, 141, 1 },
+        { 139, 109, 7, 213, 174, 144, 0 }, },
+      { { 217, 153, 210, 99, 213, 126, 1 },
+        { 6, 243, 125, 82, 254, 113, 1 },
+        { 191, 85, 227, 37, 204, 205, 1 },
+        { 199, 63, 165, 95, 103, 176, 0 }, },
+      { { 217, 162, 40, 145, 224, 209, 0 },
+        { 60, 30, 166, 192, 24, 120, 0 },
+        { 69, 131, 196, 138, 34, 205, 1 },
+        { 15, 12, 1, 178, 188, 30, 0 }, },
+      { { 219, 244, 50, 154, 65, 205, 0 },
+        { 212, 95, 150, 148, 186, 50, 0 },
+        { 89, 193, 44, 166, 23, 237, 1 },
+        { 38, 46, 148, 180, 253, 21, 1 }, },
+      { { 220, 29, 107, 96, 189, 237, 0 },
+        { 109, 175, 245, 17, 118, 161, 1 },
+        { 91, 222, 131, 107, 92, 29, 1 },
+        { 194, 183, 68, 87, 250, 219, 0 }, },
+      { { 222, 26, 217, 103, 197, 109, 0 },
+        { 165, 247, 117, 83, 241, 40, 1 },
+        { 91, 81, 243, 77, 172, 61, 1 },
+        { 138, 71, 229, 87, 119, 210, 1 }, },
+      { { 221, 114, 161, 214, 214, 204, 1 },
+        { 23, 27, 230, 183, 241, 57, 0 },
+        { 153, 181, 181, 194, 167, 93, 1 },
+        { 78, 71, 246, 179, 236, 116, 0 }, },
+      { { 221, 116, 213, 91, 237, 200, 1 },
+        { 95, 91, 119, 71, 240, 182, 0 },
+        { 137, 219, 237, 85, 151, 93, 1 },
+        { 54, 135, 241, 119, 109, 125, 0 }, },
+      { { 221, 134, 26, 161, 4, 19, 1 },
+        { 99, 102, 12, 192, 90, 120, 0 },
+        { 228, 16, 66, 172, 48, 221, 1 },
+        { 15, 45, 1, 152, 51, 99, 0 }, },
+      { { 223, 175, 27, 5, 181, 189, 1 },
+        { 235, 206, 54, 81, 127, 121, 1 },
+        { 222, 214, 208, 108, 122, 253, 1 },
+        { 207, 127, 69, 54, 57, 235, 1 }, },
+      { { 222, 176, 237, 214, 204, 22, 1 },
+        { 179, 19, 239, 147, 217, 228, 0 },
+        { 180, 25, 181, 219, 134, 189, 1 },
+        { 19, 205, 228, 251, 228, 102, 1 }, },
+      { { 223, 230, 10, 66, 93, 241, 0 },
+        { 229, 30, 86, 4, 218, 249, 1 },
+        { 71, 221, 33, 40, 51, 253, 1 },
+        { 207, 173, 144, 53, 60, 83, 1 }, },
+      { { 221, 251, 88, 81, 243, 143, 0 },
+        { 57, 223, 127, 116, 60, 57, 0 },
+        { 120, 231, 197, 13, 111, 221, 1 },
+        { 78, 30, 23, 127, 125, 206, 0 }, },
+      { { 227, 22, 68, 69, 140, 160, 0 },
+        { 192, 9, 97, 72, 81, 188, 1 },
+        { 2, 152, 209, 17, 52, 99, 1 },
+        { 158, 197, 9, 67, 72, 1, 1 }, },
+      { { 226, 26, 171, 99, 248, 21, 1 },
+        { 170, 181, 224, 91, 146, 233, 0 },
+        { 212, 15, 227, 106, 172, 35, 1 },
+        { 75, 164, 237, 3, 214, 170, 1 }, },
+      { { 226, 90, 168, 144, 16, 221, 1 },
+        { 182, 141, 128, 158, 48, 105, 0 },
+        { 221, 132, 4, 138, 173, 35, 1 },
+        { 75, 6, 60, 128, 216, 182, 1 }, },
+      { { 224, 126, 198, 224, 106, 118, 1 },
+        { 78, 177, 75, 190, 18, 236, 1 },
+        { 183, 43, 3, 177, 191, 3, 1 },
+        { 155, 164, 62, 233, 70, 185, 0 }, },
+      { { 225, 117, 204, 107, 230, 146, 0 },
+        { 104, 57, 107, 110, 212, 118, 0 },
+        { 36, 179, 235, 25, 215, 67, 1 },
+        { 55, 21, 187, 107, 78, 11, 0 }, },
+      { { 224, 221, 231, 62, 185, 106, 0 },
+        { 92, 161, 185, 15, 191, 167, 1 },
+        { 43, 78, 190, 115, 221, 131, 1 },
+        { 242, 254, 248, 78, 194, 157, 0 }, },
+      { { 231, 26, 89, 61, 43, 68, 0 },
+        { 189, 225, 17, 121, 17, 186, 0 },
+        { 17, 106, 94, 77, 44, 115, 1 },
+        { 46, 196, 79, 68, 67, 222, 1 }, },
+      { { 230, 61, 186, 78, 33, 23, 0 },
+        { 233, 197, 218, 26, 151, 98, 0 },
+        { 116, 66, 57, 46, 222, 51, 1 },
+        { 35, 116, 172, 45, 209, 203, 1 }, },
+      { { 231, 80, 110, 107, 241, 111, 0 },
+        { 173, 53, 249, 92, 178, 55, 1 },
+        { 123, 71, 235, 59, 5, 115, 1 },
+        { 246, 38, 157, 79, 214, 90, 1 }, },
+      { { 229, 83, 212, 72, 59, 179, 0 },
+        { 9, 77, 89, 46, 20, 255, 1 },
+        { 102, 238, 9, 21, 229, 83, 1 },
+        { 255, 148, 58, 77, 89, 72, 0 }, },
+      { { 228, 120, 9, 177, 15, 166, 1 },
+        { 51, 169, 26, 253, 80, 160, 1 },
+        { 178, 248, 70, 200, 15, 19, 1 },
+        { 130, 133, 95, 172, 74, 230, 0 }, },
+      { { 229, 122, 161, 185, 186, 74, 1 },
+        { 31, 161, 170, 239, 48, 187, 0 },
+        { 169, 46, 206, 194, 175, 83, 1 },
+        { 110, 134, 123, 170, 194, 252, 0 }, },
+      { { 231, 124, 180, 146, 88, 174, 1 },
+        { 211, 217, 138, 158, 176, 181, 1 },
+        { 186, 141, 36, 150, 159, 115, 1 },
+        { 214, 134, 188, 168, 205, 229, 1 }, },
+      { { 230, 164, 245, 240, 132, 66, 1 },
+        { 215, 96, 235, 139, 88, 36, 0 },
+        { 161, 16, 135, 215, 146, 179, 1 },
+        { 18, 13, 104, 235, 131, 117, 1 }, },
+      { { 229, 213, 42, 118, 142, 25, 1 },
+        { 115, 37, 224, 44, 255, 240, 0 },
+        { 204, 56, 183, 42, 85, 211, 1 },
+        { 7, 255, 154, 3, 210, 103, 0 }, },
+      { { 231, 215, 202, 210, 228, 123, 1 },
+        { 255, 21, 105, 142, 254, 120, 1 },
+        { 239, 19, 165, 169, 245, 243, 1 },
+        { 143, 63, 184, 203, 84, 127, 1 }, },
+      { { 228, 239, 89, 211, 239, 61, 1 },
+        { 123, 212, 115, 253, 252, 232, 1 },
+        { 222, 123, 229, 205, 123, 147, 1 },
+        { 139, 159, 223, 231, 21, 239, 0 }, },
+      { { 235, 27, 228, 239, 142, 205, 0 },
+        { 132, 175, 225, 250, 245, 190, 0 },
+        { 89, 184, 251, 147, 236, 107, 1 },
+        { 62, 215, 175, 195, 250, 144, 1 }, },
+      { { 233, 50, 9, 4, 85, 129, 1 },
+        { 34, 31, 18, 9, 81, 57, 0 },
+        { 192, 213, 16, 72, 38, 75, 1 },
+        { 78, 69, 72, 36, 124, 34, 0 }, },
+      { { 235, 52, 254, 217, 172, 58, 1 },
+        { 250, 67, 235, 202, 114, 246, 1 },
+        { 174, 26, 205, 191, 150, 107, 1 },
+        { 183, 167, 41, 235, 225, 47, 1 }, },
+      { { 234, 78, 19, 245, 78, 30, 0 },
+        { 208, 242, 72, 253, 115, 232, 0 },
+        { 60, 57, 87, 228, 57, 43, 1 },
+        { 11, 231, 95, 137, 39, 133, 1 }, },
+      { { 233, 176, 103, 32, 6, 254, 0 },
+        { 4, 43, 139, 57, 122, 116, 1 },
+        { 63, 176, 2, 115, 6, 203, 1 },
+        { 151, 47, 78, 104, 234, 16, 0 }, },
+      { { 234, 213, 177, 80, 109, 191, 0 },
+        { 216, 95, 216, 31, 124, 224, 1 },
+        { 126, 219, 5, 70, 213, 171, 1 },
+        { 131, 159, 124, 13, 253, 13, 1 }, },
+      { { 239, 10, 161, 134, 54, 174, 0 },
+        { 137, 138, 136, 187, 241, 57, 1 },
+        { 58, 182, 48, 194, 168, 123, 1 },
+        { 206, 71, 238, 136, 168, 200, 1 }, },
+      { { 237, 54, 239, 15, 39, 238, 1 },
+        { 111, 11, 155, 123, 243, 62, 1 },
+        { 187, 242, 120, 123, 182, 91, 1 },
+        { 190, 103, 239, 108, 232, 123, 0 }, },
+      { { 237, 74, 130, 29, 33, 213, 0 },
+        { 29, 142, 16, 94, 19, 122, 0 },
+        { 85, 194, 92, 32, 169, 91, 1 },
+        { 47, 100, 61, 4, 56, 220, 0 }, },
+      { { 236, 96, 189, 109, 140, 6, 0 },
+        { 33, 98, 234, 95, 81, 166, 0 },
+        { 48, 24, 219, 94, 131, 27, 1 },
+        { 50, 197, 125, 43, 163, 66, 0 }, },
+      { { 239, 130, 202, 100, 252, 71, 0 },
+        { 173, 54, 105, 26, 91, 185, 0 },
+        { 113, 31, 147, 41, 160, 251, 1 },
+        { 78, 237, 44, 75, 54, 90, 1 }, },
+      { { 238, 161, 127, 189, 151, 92, 0 },
+        { 181, 98, 179, 249, 127, 103, 0 },
+        { 29, 116, 222, 255, 66, 187, 1 },
+        { 115, 127, 79, 230, 163, 86, 1 }, },
+      { { 238, 209, 152, 137, 82, 229, 1 },
+        { 167, 95, 0, 254, 28, 35, 1 },
+        { 211, 165, 72, 140, 197, 187, 1 },
+        { 226, 28, 63, 128, 125, 114, 1 }, },
+      { { 241, 9, 85, 233, 4, 138, 1 },
+        { 2, 232, 77, 201, 116, 54, 0 },
+        { 168, 144, 75, 213, 72, 71, 1 },
+        { 54, 23, 73, 217, 11, 160, 0 }, },
+      { { 243, 42, 138, 178, 12, 104, 1 },
+        { 182, 160, 6, 138, 242, 184, 1 },
+        { 139, 24, 38, 168, 170, 103, 1 },
+        { 142, 167, 168, 176, 2, 182, 1 }, },
+      { { 243, 71, 148, 129, 100, 1, 1 },
+        { 202, 84, 4, 206, 84, 60, 0 },
+        { 192, 19, 64, 148, 241, 103, 1 },
+        { 30, 21, 57, 144, 21, 41, 1 }, },
+      { { 243, 136, 79, 37, 132, 41, 1 },
+        { 162, 164, 37, 73, 123, 52, 1 },
+        { 202, 16, 210, 121, 8, 231, 1 },
+        { 150, 111, 73, 82, 18, 162, 1 }, },
+      { { 240, 162, 31, 6, 126, 77, 1 },
+        { 46, 84, 6, 57, 251, 173, 0 },
+        { 217, 63, 48, 124, 34, 135, 1 },
+        { 90, 239, 206, 48, 21, 58, 0 }, },
+      { { 243, 170, 11, 255, 165, 205, 0 },
+        { 188, 172, 118, 217, 251, 58, 0 },
+        { 89, 210, 255, 232, 42, 231, 1 },
+        { 46, 111, 205, 183, 26, 158, 1 }, },
+      { { 240, 175, 124, 121, 142, 228, 0 },
+        { 116, 232, 231, 120, 92, 174, 1 },
+        { 19, 184, 207, 31, 122, 135, 1 },
+        { 186, 157, 15, 115, 139, 151, 0 }, },
+      { { 240, 217, 16, 212, 202, 31, 1 },
+        { 18, 213, 108, 188, 61, 224, 0 },
+        { 252, 41, 149, 132, 77, 135, 1 },
+        { 3, 222, 30, 155, 85, 164, 0 }, },
+      { { 245, 75, 179, 178, 85, 245, 1 },
+        { 23, 252, 148, 159, 214, 121, 1 },
+        { 215, 213, 38, 230, 233, 87, 1 },
+        { 207, 53, 252, 148, 159, 244, 0 }, },
+      { { 246, 81, 96, 41, 26, 234, 1 },
+        { 135, 41, 141, 108, 52, 163, 1 },
+        { 171, 172, 74, 3, 69, 55, 1 },
+        { 226, 150, 27, 88, 202, 112, 1 }, },
+      { { 246, 117, 82, 145, 217, 185, 1 },
+        { 211, 93, 55, 204, 54, 225, 1 },
+        { 206, 205, 196, 165, 87, 55, 1 },
+        { 195, 182, 25, 246, 93, 101, 1 }, },
+      { { 245, 114, 198, 173, 192, 65, 0 },
+        { 5, 53, 39, 206, 19, 62, 0 },
+        { 65, 1, 218, 177, 167, 87, 1 },
+        { 62, 100, 57, 242, 86, 80, 0 }, },
+      { { 247, 124, 210, 85, 227, 70, 0 },
+        { 221, 209, 127, 126, 19, 48, 0 },
+        { 49, 99, 213, 37, 159, 119, 1 },
+        { 6, 100, 63, 127, 69, 221, 1 }, },
+      { { 246, 132, 78, 31, 171, 28, 0 },
+        { 249, 0, 53, 120, 187, 230, 0 },
+        { 28, 106, 252, 57, 16, 183, 1 },
+        { 51, 238, 143, 86, 0, 79, 1 }, },
+      { { 248, 61, 136, 57, 165, 1, 1 },
+        { 122, 167, 54, 74, 84, 34, 0 },
+        { 192, 82, 206, 8, 222, 15, 1 },
+        { 34, 21, 41, 54, 114, 175, 0 }, },
+      { { 251, 54, 195, 223, 220, 215, 1 },
+        { 214, 31, 111, 219, 211, 251, 0 },
+        { 245, 157, 253, 225, 182, 111, 1 },
+        { 111, 229, 237, 251, 124, 53, 1 }, },
+      { { 248, 76, 172, 3, 76, 20, 1 },
+        { 98, 146, 132, 94, 208, 228, 0 },
+        { 148, 25, 96, 26, 153, 15, 1 },
+        { 19, 133, 189, 16, 164, 163, 0 }, },
+      { { 251, 160, 208, 185, 211, 75, 1 },
+        { 150, 118, 63, 234, 56, 51, 0 },
+        { 233, 101, 206, 133, 130, 239, 1 },
+        { 102, 14, 43, 254, 55, 52, 1 }, },
+      { { 250, 195, 132, 204, 125, 54, 1 },
+        { 138, 18, 92, 158, 93, 239, 1 },
+        { 182, 95, 25, 144, 225, 175, 1 },
+        { 251, 221, 60, 157, 36, 40, 1 }, },
+      { { 249, 231, 61, 60, 30, 97, 1 },
+        { 118, 102, 134, 45, 93, 191, 1 },
+        { 195, 60, 30, 94, 115, 207, 1 },
+        { 254, 221, 90, 48, 179, 55, 0 }, },
+      { { 248, 255, 88, 101, 6, 119, 1 },
+        { 102, 231, 79, 124, 93, 104, 1 },
+        { 247, 48, 83, 13, 127, 143, 1 },
+        { 139, 93, 31, 121, 115, 179, 0 }, },
+      { { 253, 11, 219, 85, 100, 56, 1 },
+        { 59, 210, 69, 75, 119, 120, 1 },
+        { 142, 19, 85, 109, 232, 95, 1 },
+        { 143, 119, 105, 81, 37, 238, 0 }, },
+      { { 253, 22, 174, 228, 229, 62, 1 },
+        { 107, 51, 252, 154, 115, 124, 1 },
+        { 190, 83, 147, 186, 180, 95, 1 },
+        { 159, 103, 44, 159, 230, 107, 0 }, },
+      { { 254, 73, 163, 120, 194, 52, 0 },
+        { 145, 178, 228, 63, 22, 98, 1 },
+        { 22, 33, 143, 98, 201, 63, 1 },
+        { 163, 52, 126, 19, 166, 196, 1 }, },
+      { { 253, 132, 226, 198, 107, 168, 1 },
+        { 75, 26, 213, 170, 187, 176, 1 },
+        { 138, 235, 49, 163, 144, 223, 1 },
+        { 134, 238, 170, 213, 172, 105, 0 }, },
+      { { 252, 149, 79, 148, 230, 207, 0 },
+        { 125, 31, 45, 185, 127, 36, 0 },
+        { 121, 179, 148, 249, 84, 159, 1 },
+        { 18, 127, 78, 218, 124, 95, 0 }, },
+      { { 254, 165, 35, 88, 48, 164, 1 },
+        { 219, 10, 198, 25, 30, 35, 1 },
+        { 146, 134, 13, 98, 82, 191, 1 },
+        { 226, 60, 76, 49, 168, 109, 1 }, },
+      { { 254, 168, 217, 255, 176, 118, 0 },
+        { 189, 226, 111, 219, 153, 99, 1 },
+        { 55, 6, 255, 205, 138, 191, 1 },
+        { 227, 76, 237, 251, 35, 222, 1 }, },
+      { { 255, 195, 135, 255, 162, 252, 1 },
+        { 159, 42, 100, 255, 191, 126, 1 },
+        { 159, 162, 255, 240, 225, 255, 1 },
+        { 191, 126, 255, 147, 42, 124, 1 }, },
+      { { 95, 114, 124, 241, 17, 248, 0 },
+        { 181, 107, 215, 196, 48, 93, 1 },
+        { 15, 196, 71, 159, 39, 125, 0 },
+        { 221, 6, 17, 245, 235, 86, 1 }, },
+      { { 135, 81, 63, 164, 61, 190, 1 },
+        { 171, 105, 152, 149, 103, 245, 1 },
+        { 190, 222, 18, 254, 69, 112, 1 },
+        { 215, 243, 84, 140, 203, 106, 1 }, },
+      { { 198, 147, 77, 53, 31, 189, 0 },
+        { 177, 45, 17, 113, 125, 237, 1 },
+        { 94, 252, 86, 89, 100, 177, 1 },
+        { 219, 223, 71, 68, 90, 70, 1 }, },
+      { { 231, 230, 150, 226, 6, 159, 1 },
+        { 195, 108, 74, 190, 250, 124, 0 },
+        { 252, 176, 35, 180, 179, 243, 1 },
+        { 31, 47, 190, 169, 27, 97, 1 }, }, };
+
+  static unsigned char DICT_ARUCO_MIP_36h12_BYTES[][4][5] = {{{210,182,58,9,13},{69,104,93,183,4},{185,5,198,212,11},{46,219,161,106,2}},{{96,1,19,78,5},{28,98,96,152,1},{167,44,136,0,6},{129,144,100,99,8}},{{18,6,251,231,2},{56,216,14,61,7},{78,125,246,4,8},{235,199,1,177,12}},{{255,138,214,203,4},{162,233,120,223,11},{45,54,181,31,15},{223,177,233,116,5}},{{133,218,155,196,9},{220,196,29,90,10},{146,61,149,186,1},{85,171,130,51,11}},{{180,97,175,233,12},{145,239,103,14,6},{57,127,88,98,13},{103,14,111,120,9}},{{109,181,31,225,3},{215,83,54,252,2},{200,127,138,219,6},{67,246,204,174,11}},{{82,72,197,65,15},{52,157,65,141,8},{248,42,49,36,10},{27,24,43,146,12}},{{0,143,52,80,3},{4,19,152,56,12},{192,162,207,16,0},{49,193,156,130,0}},{{142,164,98,236,14},{171,112,83,43,6},{115,116,98,87,1},{109,76,160,237,5}},{{234,194,190,118,13},{14,197,255,155,5},{182,231,212,53,7},{173,159,250,55,0}},{{26,246,21,196,4},{91,13,88,57,2},{34,58,134,245,8},{73,193,171,13,10}},{{180,138,73,242,7},{180,24,254,10,11},{228,249,37,18,13},{213,7,241,130,13}},{{46,78,18,131,11},{134,84,41,53,11},{220,20,135,39,4},{218,201,66,166,1}},{{120,177,242,250,8},{99,234,179,152,7},{21,244,248,209,14},{225,156,213,124,6}},{{39,211,79,87,14},{248,87,253,77,1},{126,175,44,190,4},{139,43,254,161,15}},{{137,34,47,255,1},{31,97,142,78,7},{143,255,68,73,1},{231,39,24,111,8}},{{76,22,105,64,6},{242,16,76,168,4},{96,41,102,131,2},{33,83,32,132,15}},{{191,73,179,81,1},{150,206,160,95,12},{136,172,217,47,13},{63,160,87,54,9}},{{220,25,28,213,13},{206,11,197,158,10},{186,179,137,131,11},{87,154,61,7,3}},{{17,215,195,248,5},{116,238,218,104,2},{161,252,62,184,8},{65,101,183,114,14}},{{22,161,48,227,5},{133,10,82,29,7},{172,112,200,86,8},{235,132,165,10,1}},{{226,159,39,239,15},{92,115,123,175,15},{255,126,79,148,7},{255,93,236,227,10}},{{66,141,138,224,12},{0,194,87,169,10},{48,117,27,20,2},{89,94,164,48,0}},{{144,213,72,71,7},{108,30,84,46,1},{238,33,42,176,9},{135,66,167,131,6}},{{35,25,203,201,3},{116,242,36,77,10},{201,61,57,140,4},{91,34,68,242,14}},{{195,176,195,223,12},{121,224,209,207,3},{63,188,48,220,3},{207,56,176,121,14}},{{4,36,188,204,9},{141,161,5,56,6},{147,51,210,66,0},{97,202,8,91,1}},{{42,8,29,99,0},{18,1,38,29,9},{12,107,129,5,4},{155,134,72,4,8}},{{118,39,67,217,6},{177,122,232,173,2},{105,188,46,70,14},{75,81,117,232,13}},{{208,100,91,241,9},{53,76,135,190,2},{152,253,162,96,11},{71,222,19,42,12}},{{243,141,127,214,0},{56,75,180,251,15},{6,191,235,28,15},{253,242,221,33,12}},{{198,203,249,161,0},{176,134,30,151,14},{8,89,253,54,3},{126,151,134,16,13}},{{60,27,231,198,5},{254,203,104,8,15},{166,62,125,131,12},{241,1,109,55,15}},{{39,111,117,230,3},{189,23,42,121,15},{198,122,239,110,4},{249,229,78,139,13}},{{68,144,163,246,3},{220,208,146,136,7},{198,252,80,146,2},{225,20,144,179,11}},{{218,96,172,213,2},{11,157,132,143,6},{74,179,80,101,11},{111,18,27,157,0}},{{60,198,141,245,9},{158,141,191,44,2},{154,251,22,51,12},{67,79,219,23,9}},{{171,70,249,218,14},{50,180,237,123,7},{117,185,246,45,5},{237,235,114,212,12}},{{136,213,51,215,8},{90,70,145,62,7},{30,188,202,177,1},{231,200,150,37,10}},{{182,214,46,194,1},{196,77,60,43,7},{132,55,70,182,13},{237,67,203,34,3}},{{179,192,43,100,6},{24,92,118,75,4},{98,109,64,60,13},{45,38,227,161,8}},{{34,229,109,64,8},{49,7,53,41,4},{16,43,106,116,4},{41,74,206,8,12}},{{172,95,87,112,10},{242,87,171,58,8},{80,238,175,163,5},{21,205,94,164,15}},{{170,169,147,246,6},{27,210,242,27,11},{102,252,153,85,5},{221,132,244,189,8}},{{76,170,7,200,13},{151,97,89,136,10},{177,62,5,83,2},{81,25,168,110,9}},{{92,155,79,123,0},{242,107,158,140,9},{13,239,45,147,10},{147,23,157,100,15}},{{170,158,240,224,5},{102,128,122,59,14},{160,112,247,149,5},{125,197,224,22,6}},{{7,5,197,117,0},{184,131,130,109,0},{10,234,58,14,0},{11,100,28,17,13}},{{172,129,245,69,14},{186,147,113,30,4},{122,42,248,19,5},{39,136,236,149,13}},{{115,91,145,231,4},{88,142,106,221,11},{46,120,157,172,14},{219,181,103,17,10}},{{140,195,92,238,4},{170,39,94,26,3},{39,115,172,51,1},{197,135,174,69,5}},{{228,70,148,208,4},{128,133,232,186,2},{32,178,150,34,7},{69,209,122,16,1}},{{181,225,33,222,0},{153,46,176,74,7},{7,184,72,122,13},{229,32,215,73,9}},{{38,16,23,208,15},{212,81,225,25,2},{240,190,128,134,4},{73,136,120,162,11}},{{241,212,57,235,5},{84,44,118,254,7},{173,121,194,184,15},{231,246,227,66,10}},{{161,163,58,201,6},{1,114,124,94,6},{105,53,204,88,5},{103,163,228,232,0}},{{23,76,98,192,2},{160,92,0,105,14},{64,52,99,46,8},{121,96,3,160,5}},{{30,226,127,113,6},{179,93,222,29,4},{104,239,228,119,8},{43,135,187,172,13}},{{139,28,94,206,9},{110,97,5,123,11},{151,55,163,141,1},{221,234,8,103,6}},{{106,5,176,198,10},{10,146,33,185,7},{86,48,218,5,6},{233,216,68,149,0}},{{13,5,104,223,12},{170,34,197,108,7},{63,177,106,11,0},{227,106,52,69,5}},{{25,45,37,229,15},{31,27,67,108,14},{250,122,75,73,8},{115,108,45,143,8}},{{26,219,236,204,8},{106,175,29,9,14},{19,51,125,181,8},{121,11,143,85,6}},{{207,236,135,240,0},{147,197,146,235,10},{0,254,19,127,3},{93,116,154,60,9}},{{208,185,221,231,10},{121,155,23,158,11},{94,123,185,208,11},{215,158,141,153,14}},{{136,220,239,129,14},{114,213,85,38,14},{120,31,115,177,1},{118,74,170,180,14}},{{68,86,129,203,9},{212,164,9,172,3},{157,56,22,162,2},{195,89,2,82,11}},{{219,178,255,200,3},{119,249,28,219,6},{193,63,244,221,11},{109,179,137,254,14}},{{164,141,150,223,1},{140,227,176,62,11},{143,182,155,18,5},{215,192,220,115,1}},{{183,44,194,231,13},{173,200,99,111,11},{190,116,51,78,13},{223,108,97,59,5}},{{12,41,91,83,15},{183,82,197,28,9},{252,173,169,67,0},{147,138,52,174,13}},{{244,152,50,112,4},{192,72,242,154,12},{32,228,193,146,15},{53,148,241,32,3}},{{153,104,237,194,9},{55,141,5,74,15},{148,59,113,105,9},{245,42,11,30,12}},{{158,78,26,248,5},{134,108,206,59,10},{161,245,135,39,9},{93,199,51,102,1}},{{134,131,226,209,11},{164,210,153,15,6},{216,180,124,22,1},{111,9,148,178,5}},{{129,11,69,192,4},{48,3,72,74,10},{32,58,45,8,1},{85,33,44,0,12}},{{106,196,75,254,2},{58,116,182,169,3},{71,253,34,53,6},{201,86,210,229,12}},{{100,83,70,97,5},{228,71,106,140,0},{168,102,44,162,6},{3,21,110,34,7}},{{57,144,189,89,8},{82,169,181,92,4},{25,171,208,153,12},{35,170,217,84,10}},{{28,158,208,246,10},{234,152,155,56,11},{86,240,183,147,8},{209,205,145,149,7}},{{194,103,41,214,5},{29,6,204,171,7},{166,185,78,100,3},{237,83,54,11,8}},{{131,153,63,121,5},{84,99,214,95,12},{169,239,201,156,1},{63,166,188,98,10}},{{58,192,90,197,13},{46,76,117,29,2},{186,53,160,53,12},{75,138,227,39,4}},{{53,122,223,243,11},{245,221,175,92,11},{220,255,181,234,12},{211,175,91,186,15}},{{13,92,5,86,5},{222,5,192,104,9},{166,170,3,171,0},{145,96,58,7,11}},{{47,84,126,244,4},{234,69,230,121,6},{34,247,226,175,4},{105,230,122,37,7}},{{134,193,21,4,1},{156,7,16,19,0},{130,10,136,54,1},{12,128,142,3,9}},{{100,15,217,229,15},{188,146,111,188,10},{250,121,191,2,6},{83,223,100,147,13}},{{206,8,187,207,7},{158,240,68,159,15},{239,61,209,7,3},{255,146,32,247,9}},{{16,155,179,67,14},{80,218,89,28,13},{124,44,221,144,8},{179,137,165,176,10}},{{194,20,53,201,2},{80,49,0,191,6},{73,58,194,132,3},{111,208,8,192,10}},{{53,180,223,206,4},{249,233,116,120,3},{39,63,178,218,12},{193,226,233,121,15}},{{69,151,82,207,2},{232,114,24,252,3},{79,52,174,154,2},{195,241,132,225,7}},{{236,145,91,130,12},{242,66,117,146,3},{52,29,168,147,7},{196,154,228,36,15}},{{81,136,30,237,0},{8,105,22,220,10},{11,119,129,24,10},{83,182,137,97,0}},{{45,218,125,201,7},{246,53,124,92,14},{233,59,229,187,4},{115,163,234,198,15}},{{46,1,66,20,4},{170,66,224,1,0},{34,132,40,7,4},{8,0,116,37,5}},{{66,232,144,249,9},{5,164,147,157,10},{153,240,145,116,2},{91,156,146,90,0}},{{154,136,86,82,7},{38,89,208,27,9},{228,166,161,21,9},{157,128,185,166,4}},{{142,128,217,216,0},{178,160,148,27,2},{1,185,176,23,1},{77,130,144,84,13}},{{137,28,188,243,4},{66,129,198,126,15},{44,243,211,137,1},{247,230,56,20,2}},{{37,221,130,65,0},{192,198,48,108,8},{8,36,27,186,4},{19,96,198,48,3}},{{35,149,81,211,4},{112,2,240,125,3},{44,184,170,156,4},{203,224,244,0,14}},{{143,232,240,199,0},{171,132,16,95,15},{14,48,241,127,1},{255,160,130,29,5}},{{148,16,106,151,0},{232,72,132,6,7},{14,149,96,130,9},{230,2,17,33,7}},{{130,96,155,64,12},{17,196,69,27,0},{48,45,144,100,1},{13,138,34,56,8}},{{15,201,202,243,6},{162,214,214,77,11},{108,245,57,63,0},{219,38,182,180,5}},{{104,129,129,209,1},{22,130,176,140,2},{136,184,24,17,6},{67,16,212,22,8}},{{113,134,19,192,8},{16,72,57,248,2},{16,60,134,24,14},{65,249,193,32,8}},{{15,26,183,98,9},{214,193,11,89,13},{148,110,213,143,0},{185,173,8,54,11}},{{163,87,191,193,8},{80,199,45,127,6},{24,63,222,172,5},{111,235,78,48,10}},{{76,3,183,164,6},{154,211,74,144,6},{98,94,220,3,2},{96,149,44,181,9}},{{32,77,237,206,6},{56,183,100,40,15},{103,59,123,32,4},{241,66,110,209,12}},{{173,99,0,211,7},{135,22,232,78,3},{236,176,12,107,5},{199,33,118,142,1}},{{132,204,76,208,9},{164,5,149,42,10},{144,179,35,50,1},{85,74,154,2,5}},{{66,22,14,92,4},{72,97,204,169,0},{35,167,6,132,2},{9,83,56,97,2}},{{135,210,173,250,8},{208,165,159,75,7},{21,251,84,190,1},{237,47,154,80,11}},{{120,80,231,116,9},{126,205,163,136,4},{146,238,112,161,14},{33,28,91,55,14}},{{78,117,15,199,12},{219,71,69,173,3},{62,63,10,231,2},{203,90,46,45,11}},{{191,46,93,253,10},{187,57,175,127,10},{91,251,167,79,13},{95,239,89,205,13}},{{216,131,36,218,5},{6,43,216,138,7},{165,178,76,17,11},{229,17,189,70,0}},{{35,75,82,248,0},{32,102,170,89,10},{1,244,173,44,4},{89,165,86,96,4}},{{55,130,4,81,4},{128,9,248,77,0},{40,162,4,30,12},{11,33,249,0,1}},{{171,223,42,213,3},{78,86,188,111,14},{202,181,79,189,5},{127,99,214,167,2}},{{54,94,120,239,9},{236,44,47,61,15},{159,113,231,166,12},{251,207,67,67,7}},{{73,202,166,202,2},{2,245,24,200,15},{69,54,85,57,2},{241,49,138,244,0}},{{3,195,157,223,3},{28,183,156,93,3},{207,187,156,60,0},{203,163,158,211,8}},{{198,140,83,133,13},{188,64,81,183,10},{186,28,163,22,3},{94,216,160,35,13}},{{91,252,187,246,7},{95,220,214,249,15},{230,253,211,253,10},{249,246,179,191,10}},{{98,50,65,226,1},{117,0,42,137,3},{132,120,36,196,6},{201,21,64,10,14}},{{171,201,13,92,12},{26,39,245,75,8},{51,171,9,61,5},{29,42,254,69,8}},{{56,140,111,232,5},{54,105,118,40,14},{161,127,99,17,12},{113,70,233,102,12}},{{218,14,45,98,13},{22,9,79,171,13},{180,107,71,5,11},{189,95,41,6,8}},{{16,133,93,254,9},{60,43,151,56,3},{151,251,170,16,8},{193,206,157,67,12}},{{77,70,239,214,11},{190,213,141,232,7},{214,191,118,43,2},{225,123,26,183,13}},{{118,234,18,214,1},{141,76,184,153,11},{134,180,133,118,14},{217,145,211,43,1}},{{157,179,119,211,13},{247,75,217,94,7},{188,190,236,219,9},{231,169,189,46,15}},{{238,208,239,167,1},{254,197,54,135,7},{142,95,112,183,7},{238,22,202,55,15}},{{230,236,58,226,15},{133,84,119,187,15},{244,117,195,118,7},{253,222,226,170,1}},{{68,31,174,232,3},{196,243,14,168,14},{193,119,95,130,2},{113,87,12,242,3}},{{186,25,200,255,5},{110,170,230,15,11},{175,241,57,133,13},{223,6,117,87,6}},{{49,48,53,234,11},{85,57,35,88,7},{213,122,192,200,12},{225,172,73,202,10}},{{108,232,247,98,5},{183,197,114,152,13},{164,110,241,115,6},{177,148,234,62,13}},{{136,13,171,88,13},{22,226,197,42,12},{177,173,91,1,1},{53,74,52,118,8}},{{141,52,9,224,13},{215,0,71,106,2},{176,121,2,203,1},{69,110,32,14,11}},{{43,233,46,226,1},{7,71,54,73,15},{132,119,73,125,4},{249,38,206,46,0}},{{214,3,2,198,12},{136,74,73,139,3},{54,52,12,6,11},{205,25,37,33,1}},{{70,159,252,114,4},{224,131,222,185,13},{36,227,255,150,2},{185,215,188,16,7}},{{135,238,190,237,3},{141,245,30,127,14},{203,119,215,126,1},{127,231,138,251,1}},{{66,88,126,247,10},{104,85,135,157,15},{94,247,225,164,2},{251,158,26,161,6}},{{122,140,196,229,2},{42,153,50,173,10},{74,114,51,21,14},{91,84,201,149,4}},{{118,164,55,101,0},{153,73,50,189,4},{10,110,194,86,14},{43,212,201,41,9}},{{153,158,65,239,4},{122,40,90,110,11},{47,120,39,153,9},{215,101,161,69,14}},{{125,9,105,228,2},{186,26,38,200,14},{66,121,105,11,14},{113,54,69,133,13}},{{192,43,175,70,11},{29,211,13,138,13},{214,47,93,64,3},{181,27,12,187,8}},{{146,89,243,228,7},{124,222,66,27,14},{226,124,249,164,9},{125,132,39,179,14}},{{33,22,161,220,0},{88,160,168,104,6},{3,184,86,136,4},{97,97,80,81,10}},{{159,45,228,216,4},{163,171,192,107,14},{33,178,123,79,9},{125,96,61,92,5}},{{0,239,250,194,9},{37,198,29,56,15},{148,53,255,112,0},{241,203,134,58,4}},{{123,55,31,248,12},{83,107,239,249,2},{49,255,142,205,14},{73,255,125,108,10}},{{102,131,57,218,9},{148,34,189,153,7},{149,185,204,22,6},{233,155,212,66,9}},{{208,16,174,227,15},{68,217,71,142,7},{252,119,80,128,11},{231,30,41,178,2}},{{28,208,11,76,0},{218,108,20,8,0},{3,45,0,179,8},{1,2,131,101,11}},{{149,7,15,195,11},{148,91,13,110,3},{220,63,14,10,9},{199,107,13,162,9}},{{248,76,154,119,0},{10,204,166,190,9},{14,229,147,33,15},{151,214,83,53,0}},{{56,248,99,215,6},{123,92,240,12,15},{110,188,97,241,12},{243,0,243,173,14}},{{54,70,255,4,5},{188,205,108,49,4},{162,15,246,38,12},{40,195,107,51,13}},{{206,27,150,65,2},{194,211,8,159,8},{72,38,157,135,3},{31,145,12,180,3}},{{122,93,69,218,8},{114,47,161,169,11},{21,186,43,165,14},{217,88,95,68,14}},{{20,224,14,246,12},{137,77,215,8,3},{54,247,0,114,8},{193,14,187,41,1}},{{94,149,171,253,8},{218,234,151,173,6},{27,253,90,151,10},{107,94,149,117,11}},{{178,233,203,114,9},{53,206,183,11,9},{148,237,57,116,13},{157,14,215,58,12}},{{3,108,71,221,7},{61,117,192,109,10},{235,190,35,108,0},{91,96,58,235,12}},{{184,238,151,198,11},{31,221,57,58,11},{214,62,151,113,13},{213,201,203,191,8}},{{14,158,143,101,7},{222,209,94,45,8},{234,111,23,151,0},{27,71,168,183,11}},{{212,173,46,241,10},{129,91,151,174,14},{88,247,75,82,11},{119,94,157,168,1}},{{136,17,199,243,2},{114,211,130,14,3},{76,254,56,129,1},{199,4,28,180,14}},{{71,189,231,195,1},{245,195,16,237,15},{140,62,123,222,2},{251,112,140,58,15}},{{58,218,223,182,4},{122,205,254,17,11},{38,223,181,181,12},{216,135,251,53,14}},{{110,91,40,87,4},{202,6,236,141,13},{46,161,77,167,6},{187,19,118,5,3}},{{51,230,124,217,1},{37,45,188,125,6},{137,179,230,124,12},{107,227,219,74,4}},{{42,185,253,210,13},{119,131,245,25,15},{180,187,249,213,4},{249,138,252,30,14}},{{138,250,103,242,11},{119,85,155,11,15},{212,254,101,245,1},{253,13,154,174,14}},{{230,162,143,197,14},{153,209,125,143,2},{122,63,20,86,7},{79,27,232,185,9}},{{114,4,156,219,13},{4,169,229,189,3},{189,179,146,4,14},{203,218,121,82,0}},{{174,101,218,193,2},{163,214,36,63,2},{72,53,186,103,5},{79,194,70,188,5}},{{18,81,164,82,6},{64,159,192,9,5},{100,162,88,164,8},{169,0,63,144,2}},{{16,137,171,132,1},{28,202,20,0,14},{130,29,89,16,8},{112,2,133,51,8}},{{226,240,150,238,0},{73,229,50,155,3},{7,118,144,244,7},{205,148,202,121,2}},{{176,202,238,87,3},{44,221,188,14,13},{206,167,117,48,13},{183,3,219,179,4}},{{253,102,119,232,6},{179,125,106,250,6},{97,126,230,107,15},{101,245,107,236,13}},{{68,75,63,81,8},{144,71,141,156,12},{24,175,205,34,2},{51,155,30,32,9}},{{190,139,58,86,10},{138,90,189,27,13},{86,165,205,23,13},{189,139,213,165,1}},{{104,10,117,207,12},{58,33,105,156,15},{63,58,229,1,6},{243,153,104,69,12}},{{172,2,186,234,8},{130,224,47,26,7},{21,117,212,3,5},{229,143,64,116,1}},{{151,216,21,225,12},{208,13,83,95,10},{56,122,129,190,9},{95,172,171,0,11}},{{29,67,134,224,8},{130,207,11,72,2},{16,118,28,43,8},{65,45,15,52,1}},{{26,20,245,176,14},{114,153,195,49,6},{112,218,242,133,8},{104,204,57,148,14}},{{230,88,168,216,1},{196,164,164,139,14},{129,177,81,166,7},{125,18,82,82,3}},{{163,134,142,250,7},{4,241,254,107,3},{229,247,22,28,5},{205,103,248,242,0}},{{54,104,169,103,3},{157,156,38,13,13},{206,105,81,102,12},{187,6,67,155,9}},{{232,252,83,216,5},{119,100,240,186,10},{161,188,163,241,7},{85,208,242,110,14}},{{46,43,126,221,5},{175,99,236,29,14},{171,183,237,71,4},{123,131,124,111,5}},{{139,36,112,241,3},{39,16,130,127,6},{200,240,226,77,1},{111,228,16,142,4}},{{246,151,149,243,2},{208,155,186,191,3},{76,250,158,150,15},{207,213,221,144,11}},{{69,137,255,200,14},{176,243,85,216,14},{113,63,249,26,2},{113,186,172,240,13}},{{46,32,128,201,12},{131,160,97,13,2},{57,48,16,71,4},{75,8,96,92,1}},{{6,66,101,247,13},{188,5,203,13,7},{190,250,100,38,0},{235,13,58,3,13}},{{61,113,77,209,0},{243,15,164,76,2},{8,187,40,235,12},{67,34,95,12,15}},{{22,146,198,239,1},{236,233,26,13,3},{143,118,52,150,8},{203,5,137,115,7}},{{62,103,242,244,9},{175,206,171,57,6},{146,244,254,103,12},{105,205,87,63,5}},{{80,65,218,214,3},{44,222,132,152,3},{198,181,184,32,10},{193,146,23,179,4}},{{26,21,3,65,5},{86,74,64,45,0},{168,44,10,133,8},{11,64,37,38,10}},{{100,193,140,116,2},{136,151,182,136,0},{66,227,24,50,6},{1,22,222,145,1}},{{10,114,238,195,5},{103,197,76,13,7},{172,55,116,229,0},{235,3,42,62,6}},{{31,15,157,198,0},{154,139,12,121,11},{6,59,159,15,8},{217,227,13,21,9}},{{169,85,155,198,7},{94,214,100,122,3},{230,61,154,169,5},{197,226,102,183,10}},{{243,41,17,208,13},{21,10,225,219,10},{176,184,137,76,15},{93,184,117,10,8}},{{33,192,212,255,12},{40,165,243,92,3},{63,242,176,56,4},{195,172,250,81,4}},{{224,28,239,91,0},{112,225,164,174,13},{13,175,115,128,7},{183,82,88,112,14}},{{78,35,163,82,0},{147,194,136,137,5},{4,172,92,71,2},{169,17,20,60,9}},{{170,79,4,228,9},{14,7,43,43,10},{146,114,15,37,5},{93,77,78,7,0}},{{225,196,252,196,3},{44,149,52,250,6},{194,51,242,56,7},{101,242,202,147,4}},{{32,142,143,110,8},{24,225,63,40,9},{23,111,23,16,4},{145,79,200,113,8}},{{132,134,119,74,5},{180,97,88,58,5},{165,46,230,18,1},{165,193,168,98,13}},{{158,152,199,85,8},{250,201,145,15,8},{26,174,49,151,9},{31,8,153,53,15}},{{44,89,251,125,12},{250,230,231,28,12},{59,237,249,163,4},{51,142,118,117,15}},{{148,70,164,97,3},{132,157,10,46,4},{200,98,86,34,9},{39,69,11,146,1}},{{130,146,220,194,14},{96,145,93,27,3},{116,51,180,148,1},{205,139,168,144,6}},{{0,77,97,99,1},{52,6,2,44,13},{140,104,107,32,0},{179,68,6,2,12}},{{208,85,39,128,9},{84,79,1,162,6},{144,30,74,160,11},{100,88,15,34,10}},{{160,22,56,82,13},{68,0,237,58,5},{180,161,198,128,5},{165,203,112,2,2}},{{143,101,127,99,9},{183,71,7,127,5},{156,111,234,111,1},{175,238,14,46,13}},{{204,166,195,227,7},{183,208,90,174,3},{236,124,54,83,3},{199,85,160,190,13}},{{203,19,107,199,10},{122,82,13,207,7},{94,61,108,141,3},{239,59,4,165,14}},{{252,90,131,229,3},{222,220,42,142,10},{202,124,21,163,15},{87,21,67,183,11}},{{154,164,79,195,0},{51,73,20,47,3},{12,63,34,85,9},{207,66,137,44,12}},{{189,236,27,211,12},{147,76,245,126,11},{60,189,131,123,13},{215,234,243,44,9}},{{224,32,185,247,12},{25,128,231,158,7},{62,249,208,64,7},{231,158,112,25,8}},{{75,143,53,251,0},{18,35,154,253,15},{13,250,207,29,2},{251,245,156,68,8}},{{184,22,95,99,7},{118,89,110,62,1},{236,111,166,129,13},{135,199,105,166,14}},{{51,220,136,214,9},{76,140,181,105,11},{150,177,19,188,12},{217,106,211,19,2}},{{16,162,247,228,13},{61,201,91,24,6},{178,126,244,80,8},{97,141,169,59,12}},{{200,203,95,245,3},{62,87,158,158,10},{202,255,173,49,3},{87,151,158,167,12}},{{222,37,159,246,11},{159,219,135,187,3},{214,255,154,71,11},{205,222,29,191,9}},{{70,208,112,221,4},{232,36,208,157,6},{43,176,224,182,2},{107,144,178,65,7}},{{50,211,185,116,1},{92,142,190,25,4},{130,233,220,180,12},{41,135,215,19,10}},{{112,117,241,192,4},{113,142,96,184,6},{32,56,250,224,14},{97,208,103,24,14}},{{77,88,219,234,0},{242,228,6,216,11},{5,125,177,171,2},{209,182,2,116,15}}};
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode.cpp b/upstream/opencv/modules/objdetect/src/barcode.cpp
new file mode 100644
index 0000000..d3f3573
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode.cpp
@@ -0,0 +1,438 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "precomp.hpp"
+#include <opencv2/objdetect/barcode.hpp>
+#include <opencv2/core/utils/filesystem.hpp>
+#include "barcode_decoder/ean13_decoder.hpp"
+#include "barcode_decoder/ean8_decoder.hpp"
+#include "barcode_detector/bardetect.hpp"
+#include "barcode_decoder/common/super_scale.hpp"
+#include "barcode_decoder/common/utils.hpp"
+#include "graphical_code_detector_impl.hpp"
+
+using std::string;
+using std::vector;
+using std::make_shared;
+using std::array;
+using std::shared_ptr;
+using std::dynamic_pointer_cast;
+
+namespace cv {
+namespace barcode {
+
+//==================================================================================================
+
+static bool checkBarInputImage(InputArray img, Mat &gray)
+{
+    CV_Assert(!img.empty());
+    CV_CheckDepthEQ(img.depth(), CV_8U, "");
+    if (img.cols() <= 40 || img.rows() <= 40)
+    {
+        return false; // image data is not enough for providing reliable results
+    }
+    int incn = img.channels();
+    CV_Check(incn, incn == 1 || incn == 3 || incn == 4, "");
+    if (incn == 3 || incn == 4)
+    {
+        cvtColor(img, gray, COLOR_BGR2GRAY);
+    }
+    else
+    {
+        gray = img.getMat();
+    }
+    return true;
+}
+
+static void updatePointsResult(OutputArray points_, const vector<Point2f> &points)
+{
+    if (points_.needed())
+    {
+        int N = int(points.size() / 4);
+        if (N > 0)
+        {
+            Mat m_p(N, 4, CV_32FC2, (void *) &points[0]);
+            int points_type = points_.fixedType() ? points_.type() : CV_32FC2;
+            m_p.reshape(2, points_.rows()).convertTo(points_, points_type);  // Mat layout: N x 4 x 2cn
+        }
+        else
+        {
+            points_.release();
+        }
+    }
+}
+
+inline const array<shared_ptr<AbsDecoder>, 2> &getDecoders()
+{
+    //indicate Decoder
+    static const array<shared_ptr<AbsDecoder>, 2> decoders{
+            shared_ptr<AbsDecoder>(new Ean13Decoder()), shared_ptr<AbsDecoder>(new Ean8Decoder())};
+    return decoders;
+}
+
+//==================================================================================================
+
+class BarDecode
+{
+public:
+    void init(const vector<Mat> &bar_imgs_);
+
+    const vector<Result> &getDecodeInformation()
+    { return result_info; }
+
+    bool decodeMultiplyProcess();
+
+private:
+    vector<Mat> bar_imgs;
+    vector<Result> result_info;
+};
+
+void BarDecode::init(const vector<Mat> &bar_imgs_)
+{
+    bar_imgs = bar_imgs_;
+}
+
+bool BarDecode::decodeMultiplyProcess()
+{
+    static float constexpr THRESHOLD_CONF = 0.6f;
+    result_info.clear();
+    result_info.resize(bar_imgs.size());
+    parallel_for_(Range(0, int(bar_imgs.size())), [&](const Range &range) {
+        for (int i = range.start; i < range.end; i++)
+        {
+            Mat bin_bar;
+            Result max_res;
+            float max_conf = -1.f;
+            bool decoded = false;
+            for (const auto &decoder:getDecoders())
+            {
+                if (decoded)
+                { break; }
+                for (const auto binary_type : binary_types)
+                {
+                    binarize(bar_imgs[i], bin_bar, binary_type);
+                    auto cur_res = decoder->decodeROI(bin_bar);
+                    if (cur_res.second > max_conf)
+                    {
+                        max_res = cur_res.first;
+                        max_conf = cur_res.second;
+                        if (max_conf > THRESHOLD_CONF)
+                        {
+                            // code decoded
+                            decoded = true;
+                            break;
+                        }
+                    }
+                } //binary types
+            } //decoder types
+
+            result_info[i] = max_res;
+        }
+    });
+    return !result_info.empty();
+}
+
+//==================================================================================================
+// Private class definition and implementation (pimpl)
+
+struct BarcodeImpl : public GraphicalCodeDetector::Impl
+{
+public:
+    shared_ptr<SuperScale> sr;
+    bool use_nn_sr = false;
+    double detectorThrDownSample = 512.f;
+    vector<float> detectorWindowSizes = {0.01f, 0.03f, 0.06f, 0.08f};
+    double detectorThrGradMagnitude = 64.f;
+
+public:
+    //=================
+    // own methods
+    BarcodeImpl() {}
+
+    vector<Mat> initDecode(const Mat &src, const vector<vector<Point2f>> &points) const;
+    bool decodeWithType(InputArray img,
+                     InputArray points,
+                     vector<string> &decoded_info,
+                     vector<string> &decoded_type) const;
+    bool detectAndDecodeWithType(InputArray img,
+                              vector<string> &decoded_info,
+                              vector<string> &decoded_type,
+                              OutputArray points_) const;
+
+    //=================
+    // implement interface
+    ~BarcodeImpl() CV_OVERRIDE {}
+    bool detect(InputArray img, OutputArray points) const CV_OVERRIDE;
+    string decode(InputArray img, InputArray points, OutputArray straight_code) const CV_OVERRIDE;
+    string detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const CV_OVERRIDE;
+    bool detectMulti(InputArray img, OutputArray points) const CV_OVERRIDE;
+    bool decodeMulti(InputArray img, InputArray points, vector<string>& decoded_info, OutputArrayOfArrays straight_code) const CV_OVERRIDE;
+    bool detectAndDecodeMulti(InputArray img, vector<string>& decoded_info, OutputArray points, OutputArrayOfArrays straight_code) const CV_OVERRIDE;
+};
+
+// return cropped and scaled bar img
+vector<Mat> BarcodeImpl::initDecode(const Mat &src, const vector<vector<Point2f>> &points) const
+{
+    vector<Mat> bar_imgs;
+    for (auto &corners : points)
+    {
+        Mat bar_img;
+        cropROI(src, bar_img, corners);
+//        sharpen(bar_img, bar_img);
+        // empirical settings
+        if (bar_img.cols < 320 || bar_img.cols > 640)
+        {
+            float scale = 560.0f / static_cast<float>(bar_img.cols);
+            sr->processImageScale(bar_img, bar_img, scale, use_nn_sr);
+        }
+        bar_imgs.emplace_back(bar_img);
+    }
+    return bar_imgs;
+}
+
+bool BarcodeImpl::decodeWithType(InputArray img,
+                              InputArray points,
+                              vector<string> &decoded_info,
+                              vector<string> &decoded_type) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        return false;
+    }
+    CV_Assert(points.size().width > 0);
+    CV_Assert((points.size().width % 4) == 0);
+    vector<vector<Point2f>> src_points;
+    Mat bar_points = points.getMat();
+    bar_points = bar_points.reshape(2, 1);
+    for (int i = 0; i < bar_points.size().width; i += 4)
+    {
+        vector<Point2f> tempMat = bar_points.colRange(i, i + 4);
+        if (contourArea(tempMat) > 0.0)
+        {
+            src_points.push_back(tempMat);
+        }
+    }
+    CV_Assert(!src_points.empty());
+    vector<Mat> bar_imgs = initDecode(inarr, src_points);
+    BarDecode bardec;
+    bardec.init(bar_imgs);
+    bardec.decodeMultiplyProcess();
+    const vector<Result> info = bardec.getDecodeInformation();
+    decoded_info.clear();
+    decoded_type.clear();
+    bool ok = false;
+    for (const auto &res : info)
+    {
+        if (res.isValid())
+        {
+            ok = true;
+        }
+
+        decoded_info.emplace_back(res.result);
+        decoded_type.emplace_back(res.typeString());
+    }
+    return ok;
+}
+
+bool BarcodeImpl::detectAndDecodeWithType(InputArray img,
+                                       vector<string> &decoded_info,
+                                       vector<string> &decoded_type,
+                                       OutputArray points_) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        points_.release();
+        return false;
+    }
+    vector<Point2f> points;
+    bool ok = this->detect(inarr, points);
+    if (!ok)
+    {
+        points_.release();
+        return false;
+    }
+    updatePointsResult(points_, points);
+    decoded_info.clear();
+    decoded_type.clear();
+    ok = decodeWithType(inarr, points, decoded_info, decoded_type);
+    return ok;
+}
+
+bool BarcodeImpl::detect(InputArray img, OutputArray points) const
+{
+    Mat inarr;
+    if (!checkBarInputImage(img, inarr))
+    {
+        points.release();
+        return false;
+    }
+
+    Detect bardet;
+    bardet.init(inarr, detectorThrDownSample);
+    bardet.localization(detectorWindowSizes, detectorThrGradMagnitude);
+    if (!bardet.computeTransformationPoints())
+    { return false; }
+    vector<vector<Point2f>> pnts2f = bardet.getTransformationPoints();
+    vector<Point2f> trans_points;
+    for (auto &i : pnts2f)
+    {
+        for (const auto &j : i)
+        {
+            trans_points.push_back(j);
+        }
+    }
+    updatePointsResult(points, trans_points);
+    return true;
+}
+
+string BarcodeImpl::decode(InputArray img, InputArray points, OutputArray straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_info;
+    vector<string> decoded_type;
+    if (!decodeWithType(img, points, decoded_info, decoded_type))
+        return string();
+    if (decoded_info.size() < 1)
+        return string();
+    return decoded_info[0];
+}
+
+string BarcodeImpl::detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_info;
+    vector<string> decoded_type;
+    vector<Point2f> points_;
+    if (!detectAndDecodeWithType(img, decoded_info, decoded_type, points_))
+        return string();
+    if (points_.size() < 4 || decoded_info.size() < 1)
+        return string();
+    points_.resize(4);
+    updatePointsResult(points, points_);
+    return decoded_info[0];
+}
+
+bool BarcodeImpl::detectMulti(InputArray img, OutputArray points) const
+{
+    return detect(img, points);
+}
+
+bool BarcodeImpl::decodeMulti(InputArray img, InputArray points, vector<string> &decoded_info, OutputArrayOfArrays straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_type;
+    return decodeWithType(img, points, decoded_info, decoded_type);
+}
+
+bool BarcodeImpl::detectAndDecodeMulti(InputArray img, vector<string> &decoded_info, OutputArray points, OutputArrayOfArrays straight_code) const
+{
+    CV_UNUSED(straight_code);
+    vector<string> decoded_type;
+    return detectAndDecodeWithType(img, decoded_info, decoded_type, points);
+}
+
+//==================================================================================================
+// Public class implementation
+
+BarcodeDetector::BarcodeDetector()
+    : BarcodeDetector(std::string())
+{
+}
+
+BarcodeDetector::BarcodeDetector(const string &super_resolution_model_path)
+{
+    Ptr<BarcodeImpl> p_ = new BarcodeImpl();
+    p = p_;
+    p_->sr = make_shared<SuperScale>();
+    // The optional Super Resolution model is a single-file ONNX network (Caffe support
+    // has been removed). An empty path simply disables super resolution.
+    if (!super_resolution_model_path.empty())
+    {
+        CV_Assert(utils::fs::exists(super_resolution_model_path));
+        int res = p_->sr->init(super_resolution_model_path);
+        CV_Assert(res == 0);
+        p_->use_nn_sr = true;
+    }
+}
+
+BarcodeDetector::~BarcodeDetector() = default;
+
+bool BarcodeDetector::decodeWithType(InputArray img, InputArray points, vector<string> &decoded_info, vector<string> &decoded_type) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    return p_->decodeWithType(img, points, decoded_info, decoded_type);
+}
+
+bool BarcodeDetector::detectAndDecodeWithType(InputArray img, vector<string> &decoded_info, vector<string> &decoded_type, OutputArray points_) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    return p_->detectAndDecodeWithType(img, decoded_info, decoded_type, points_);
+}
+
+double BarcodeDetector::getDownsamplingThreshold() const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    return p_->detectorThrDownSample;
+}
+
+BarcodeDetector& BarcodeDetector::setDownsamplingThreshold(double thresh)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(thresh >= 64);
+
+    p_->detectorThrDownSample = thresh;
+    return *this;
+}
+
+void BarcodeDetector::getDetectorScales(CV_OUT std::vector<float>& sizes) const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    sizes = p_->detectorWindowSizes;
+}
+
+BarcodeDetector& BarcodeDetector::setDetectorScales(const std::vector<float>& sizes)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(sizes.size() > 0 && sizes.size() <= 16);
+
+    for (const float &size : sizes) {
+        CV_Assert(size > 0 && size < 1);
+    }
+
+    p_->detectorWindowSizes = sizes;
+
+    return *this;
+}
+
+double BarcodeDetector::getGradientThreshold() const
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+
+    return p_->detectorThrGradMagnitude;
+}
+
+BarcodeDetector& BarcodeDetector::setGradientThreshold(double thresh)
+{
+    Ptr<BarcodeImpl> p_ = dynamic_pointer_cast<BarcodeImpl>(p);
+    CV_Assert(p_);
+    CV_Assert(thresh >= 0 && thresh < 1e4);
+
+    p_->detectorThrGradMagnitude = thresh;
+    return *this;
+}
+
+}// namespace barcode
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp
new file mode 100644
index 0000000..9eadf4b
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.cpp
@@ -0,0 +1,118 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "abs_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+
+void cropROI(const Mat &src, Mat &dst, const std::vector<Point2f> &rects)
+{
+    std::vector<Point2f> vertices = rects;
+    int height = cvRound(norm(vertices[0] - vertices[1]));
+    int width = cvRound(norm(vertices[1] - vertices[2]));
+    if (height > width)
+    {
+        std::swap(height, width);
+        Point2f v0 = vertices[0];
+        vertices.erase(vertices.begin());
+        vertices.push_back(v0);
+    }
+    std::vector<Point2f> dst_vertices{
+            Point2f(0, (float) (height - 1)), Point2f(0, 0), Point2f((float) (width - 1), 0),
+            Point2f((float) (width - 1), (float) (height - 1))};
+    dst.create(Size(width, height), CV_8UC1);
+    Mat M = getPerspectiveTransform(vertices, dst_vertices);
+    warpPerspective(src, dst, M, dst.size(), cv::INTER_LINEAR, BORDER_CONSTANT, Scalar(255));
+}
+
+void fillCounter(const std::vector<uchar> &row, uint start, Counter &counter)
+{
+    size_t counter_length = counter.pattern.size();
+    std::fill(counter.pattern.begin(), counter.pattern.end(), 0);
+    counter.sum = 0;
+    size_t end = row.size();
+    uchar color = row[start];
+    uint counterPosition = 0;
+    while (start < end)
+    {
+        if (row[start] == color)
+        { // that is, exactly one is true
+            counter.pattern[counterPosition]++;
+            counter.sum++;
+        }
+        else
+        {
+            counterPosition++;
+            if (counterPosition == counter_length)
+            {
+                break;
+            }
+            else
+            {
+                counter.pattern[counterPosition] = 1;
+                counter.sum++;
+                color = 255 - color;
+            }
+        }
+        ++start;
+    }
+}
+
+static inline uint
+patternMatchVariance(const Counter &counter, const std::vector<int> &pattern, uint maxIndividualVariance)
+{
+    size_t numCounters = counter.pattern.size();
+    int total = static_cast<int>(counter.sum);
+    int patternLength = std::accumulate(pattern.cbegin(), pattern.cend(), 0);
+    if (total < patternLength)
+    {
+        // If we don't even have one pixel per unit of bar width, assume this is too small
+        // to reliably match, so fail:
+        // and use constexpr functions
+        return WHITE;// max
+    }
+    // We're going to fake floating-point math in integers. We just need to use more bits.
+    // Scale up patternLength so that intermediate values below like scaledCounter will have
+    // more "significant digits"
+
+    int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+    maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+    uint totalVariance = 0;
+    for (uint x = 0; x < numCounters; x++)
+    {
+        int cnt = counter.pattern[x] << INTEGER_MATH_SHIFT;
+        int scaledPattern = pattern[x] * unitBarWidth;
+        uint variance = std::abs(cnt - scaledPattern);
+        if (variance > maxIndividualVariance)
+        {
+            return WHITE;
+        }
+        totalVariance += variance;
+    }
+    return totalVariance / total;
+}
+
+/**
+* Determines how closely a set of observed counts of runs of black/white values matches a given
+* target pattern. This is reported as the ratio of the total variance from the expected pattern
+* proportions across all pattern elements, to the length of the pattern.
+*
+* @param counters observed counters
+* @param pattern expected pattern
+* @param maxIndividualVariance The most any counter can differ before we give up
+* @return ratio of total variance between counters and pattern compared to total pattern size,
+*  where the ratio has been multiplied by 256. So, 0 means no variance (perfect match); 256 means
+*  the total variance between counters and patterns equals the pattern length, higher values mean
+*  even more variance
+*/
+uint patternMatch(const Counter &counters, const std::vector<int> &pattern, uint maxIndividual)
+{
+    CV_Assert(counters.pattern.size() == pattern.size());
+    return patternMatchVariance(counters, pattern, maxIndividual);
+}
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.hpp
new file mode 100644
index 0000000..87b33e7
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/abs_decoder.hpp
@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_ABS_DECODER_HPP
+#define OPENCV_BARCODE_ABS_DECODER_HPP
+
+#include "opencv2/objdetect/barcode.hpp"
+
+namespace cv {
+namespace barcode {
+using std::string;
+using std::vector;
+constexpr static uchar BLACK = std::numeric_limits<uchar>::min();
+// WHITE elemental area is 0xff
+constexpr static uchar WHITE = std::numeric_limits<uchar>::max();
+
+
+struct Result
+{
+    enum BarcodeType
+    {
+        BARCODE_NONE,
+        BARCODE_EAN_8,
+        BARCODE_EAN_13,
+        BARCODE_UPC_A,
+        BARCODE_UPC_E,
+        BARCODE_UPC_EAN_EXTENSION
+    };
+
+    std::string result;
+    BarcodeType format = Result::BARCODE_NONE;
+
+    Result() = default;
+
+    Result(const std::string &_result, BarcodeType _format)
+    {
+        result = _result;
+        format = _format;
+    }
+    string typeString() const
+    {
+        switch (format)
+        {
+            case Result::BARCODE_EAN_8: return "EAN_8";
+            case Result::BARCODE_EAN_13: return "EAN_13";
+            case Result::BARCODE_UPC_E: return "UPC_E";
+            case Result::BARCODE_UPC_A: return "UPC_A";
+            case Result::BARCODE_UPC_EAN_EXTENSION: return "UPC_EAN_EXTENSION";
+            default: return string();
+        }
+    }
+    bool isValid() const
+    {
+        return format != BARCODE_NONE;
+    }
+};
+
+struct Counter
+{
+    std::vector<int> pattern;
+    uint sum;
+
+    explicit Counter(const vector<int> &_pattern)
+    {
+        pattern = _pattern;
+        sum = 0;
+    }
+};
+
+class AbsDecoder
+{
+public:
+    virtual std::pair<Result, float> decodeROI(const Mat &bar_img) const = 0;
+
+    virtual ~AbsDecoder() = default;
+
+protected:
+    virtual Result decode(const vector<uchar> &data) const = 0;
+
+    virtual bool isValid(const string &result) const = 0;
+
+    size_t bits_num{};
+    size_t digit_number{};
+};
+
+void cropROI(const Mat &_src, Mat &_dst, const std::vector<Point2f> &rect);
+
+void fillCounter(const std::vector<uchar> &row, uint start, Counter &counter);
+
+constexpr static uint INTEGER_MATH_SHIFT = 8;
+constexpr static uint PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+
+uint patternMatch(const Counter &counters, const std::vector<int> &pattern, uint maxIndividual);
+}
+} // namespace cv
+
+#endif // OPENCV_BARCODE_ABS_DECODER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
new file mode 100644
index 0000000..76d63d6
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.cpp
@@ -0,0 +1,195 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#include "../../precomp.hpp"
+#include "hybrid_binarizer.hpp"
+
+namespace cv {
+namespace barcode {
+
+
+#define CLAMP(x, x1, x2) x < (x1) ? (x1) : ((x) > (x2) ? (x2) : (x))
+
+// This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
+// So this is the smallest dimension in each axis we can accept.
+constexpr static int BLOCK_SIZE_POWER = 3;
+constexpr static int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00
+constexpr static int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;   // ...0011...11
+constexpr static int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+constexpr static int MIN_DYNAMIC_RANGE = 24;
+
+void
+calculateThresholdForBlock(const std::vector<uchar> &luminances, int sub_width, int sub_height, int width, int height,
+                           const Mat &black_points, Mat &dst)
+{
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    for (int y = 0; y < sub_height; y++)
+    {
+        int yoffset = y << BLOCK_SIZE_POWER;
+        if (yoffset > maxYOffset)
+        {
+            yoffset = maxYOffset;
+        }
+        int top = CLAMP(y, 2, sub_height - 3);
+        for (int x = 0; x < sub_width; x++)
+        {
+            int xoffset = x << BLOCK_SIZE_POWER;
+            if (xoffset > maxXOffset)
+            {
+                xoffset = maxXOffset;
+            }
+            int left = CLAMP(x, 2, sub_width - 3);
+            int sum = 0;
+            const auto *black_row = black_points.ptr<uchar>(top - 2);
+            for (int z = 0; z <= 4; z++)
+            {
+                sum += black_row[left - 2] + black_row[left - 1] + black_row[left] + black_row[left + 1] +
+                       black_row[left + 2];
+                black_row += black_points.cols;
+            }
+            int average = sum / 25;
+            int temp_y = 0;
+
+            auto *ptr = dst.ptr<uchar>(yoffset, xoffset);
+            for (int offset = yoffset * width + xoffset; temp_y < 8; offset += width)
+            {
+                for (int temp_x = 0; temp_x < 8; ++temp_x)
+                {
+                    *(ptr + temp_x) = (luminances[offset + temp_x] & 255) <= average ? 0 : 255;
+                }
+                ++temp_y;
+                ptr += width;
+            }
+        }
+    }
+
+}
+
+Mat calculateBlackPoints(std::vector<uchar> luminances, int sub_width, int sub_height, int width, int height)
+{
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    Mat black_points(Size(sub_width, sub_height), CV_8UC1);
+    for (int y = 0; y < sub_height; y++)
+    {
+        int yoffset = y << BLOCK_SIZE_POWER;
+        if (yoffset > maxYOffset)
+        {
+            yoffset = maxYOffset;
+        }
+        for (int x = 0; x < sub_width; x++)
+        {
+            int xoffset = x << BLOCK_SIZE_POWER;
+            if (xoffset > maxXOffset)
+            {
+                xoffset = maxXOffset;
+            }
+            int sum = 0;
+            int min = 0xFF;
+            int max = 0;
+            for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width)
+            {
+                for (int xx = 0; xx < BLOCK_SIZE; xx++)
+                {
+                    int pixel = luminances[offset + xx] & 0xFF;
+                    sum += pixel;
+                    // still looking for good contrast
+                    if (pixel < min)
+                    {
+                        min = pixel;
+                    }
+                    if (pixel > max)
+                    {
+                        max = pixel;
+                    }
+                }
+                // short-circuit min/max tests once dynamic range is met
+                if (max - min > MIN_DYNAMIC_RANGE)
+                {
+                    // finish the rest of the rows quickly
+                    for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width)
+                    {
+                        for (int xx = 0; xx < BLOCK_SIZE; xx++)
+                        {
+                            sum += luminances[offset + xx] & 0xFF;
+                        }
+                    }
+                }
+            }
+
+            // The default estimate is the average of the values in the block.
+            int average = sum >> (BLOCK_SIZE_POWER * 2);
+            if (max - min <= MIN_DYNAMIC_RANGE)
+            {
+                // If variation within the block is low, assume this is a block with only light or only
+                // dark pixels. In that case we do not want to use the average, as it would divide this
+                // low contrast area into black and white pixels, essentially creating data out of noise.
+                //
+                // The default assumption is that the block is light/background. Since no estimate for
+                // the level of dark pixels exists locally, use half the min for the block.
+                average = min / 2;
+
+                if (y > 0 && x > 0)
+                {
+                    // Correct the "white background" assumption for blocks that have neighbors by comparing
+                    // the pixels in this block to the previously calculated black points. This is based on
+                    // the fact that dark barcode symbology is always surrounded by some amount of light
+                    // background for which reasonable black point estimates were made. The bp estimated at
+                    // the boundaries is used for the interior.
+
+                    // The (min < bp) is arbitrary but works better than other heuristics that were tried.
+                    int averageNeighborBlackPoint =
+                            (black_points.at<uchar>(y - 1, x) + (2 * black_points.at<uchar>(y, x - 1)) +
+                             black_points.at<uchar>(y - 1, x - 1)) / 4;
+                    if (min < averageNeighborBlackPoint)
+                    {
+                        average = averageNeighborBlackPoint;
+                    }
+                }
+            }
+            black_points.at<uchar>(y, x) = (uchar) average;
+        }
+    }
+    return black_points;
+
+}
+
+
+void hybridBinarization(const Mat &src, Mat &dst)
+{
+    int width = src.cols;
+    int height = src.rows;
+
+    if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION)
+    {
+        std::vector<uchar> luminances(src.begin<uchar>(), src.end<uchar>());
+
+        int sub_width = width >> BLOCK_SIZE_POWER;
+        if ((width & BLOCK_SIZE_MASK) != 0)
+        {
+            sub_width++;
+        }
+
+        int sub_height = height >> BLOCK_SIZE_POWER;
+        if ((height & BLOCK_SIZE_MASK) != 0)
+        {
+            sub_height++;
+        }
+
+        Mat black_points = calculateBlackPoints(luminances, sub_width, sub_height, width, height);
+
+        dst.create(src.size(), src.type());
+        calculateThresholdForBlock(luminances, sub_width, sub_height, width, height, black_points, dst);
+    }
+    else
+    {
+        threshold(src, dst, 155, 255, THRESH_OTSU + THRESH_BINARY);
+    }
+
+}
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.hpp
new file mode 100644
index 0000000..88f93d0
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/hybrid_binarizer.hpp
@@ -0,0 +1,22 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Modified from ZXing. Copyright ZXing authors.
+// Licensed under the Apache License, Version 2.0 (the "License").
+
+#ifndef OPENCV_BARCODE_HYBRID_BINARIZER_HPP
+#define OPENCV_BARCODE_HYBRID_BINARIZER_HPP
+
+namespace cv {
+namespace barcode {
+
+void hybridBinarization(const Mat &src, Mat &dst);
+
+void
+calculateThresholdForBlock(const std::vector<uchar> &luminances, int sub_width, int sub_height, int width, int height,
+                           const Mat &black_points, Mat &dst);
+
+Mat calculateBlackPoints(std::vector<uchar> luminances, int sub_width, int sub_height, int width, int height);
+}
+}
+#endif // OPENCV_BARCODE_HYBRID_BINARIZER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp
new file mode 100644
index 0000000..33e1db0
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.cpp
@@ -0,0 +1,99 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+// Modified by darkliang wangberlinT
+
+#include "../../precomp.hpp"
+#include "super_scale.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/core/utils/logger.hpp"
+
+namespace cv {
+namespace barcode {
+
+#ifdef HAVE_OPENCV_DNN
+
+constexpr static float MAX_SCALE = 4.0f;
+
+int SuperScale::init(const std::string &model_path)
+{
+    // Super Resolution is loaded from a single-file ONNX model (e.g. dnn/wechat_2021-01/sr.onnx).
+    srnet_ = dnn::readNetFromONNX(model_path);
+    net_loaded_ = true;
+    return 0;
+}
+
+void SuperScale::processImageScale(const Mat &src, Mat &dst, float scale, const bool &use_sr, int sr_max_size)
+{
+    scale = min(scale, MAX_SCALE);
+    if (scale > .0 && scale < 1.0)
+    {  // down sample
+        resize(src, dst, Size(), scale, scale, INTER_AREA);
+    }
+    else if (scale > 1.5 && scale < 2.0)
+    {
+        resize(src, dst, Size(), scale, scale, INTER_CUBIC);
+    }
+    else if (scale >= 2.0)
+    {
+        int width = src.cols;
+        int height = src.rows;
+        if (use_sr && (int) sqrt(width * height * 1.0) < sr_max_size && net_loaded_)
+        {
+            superResolutionScale(src, dst);
+            if (scale > 2.0)
+            {
+                processImageScale(dst, dst, scale / 2.0f, use_sr);
+            }
+        }
+        else
+        { resize(src, dst, Size(), scale, scale, INTER_CUBIC); }
+    }
+}
+
+int SuperScale::superResolutionScale(const Mat &src, Mat &dst)
+{
+    Mat blob;
+    dnn::blobFromImage(src, blob, 1.0 / 255, Size(src.cols, src.rows), {0.0f}, false, false);
+
+    srnet_.setInput(blob);
+    auto prob = srnet_.forward();
+
+    dst = Mat(prob.size[2], prob.size[3], CV_8UC1);
+
+    for (int row = 0; row < prob.size[2]; row++)
+    {
+        const float *prob_score = prob.ptr<float>(0, 0, row);
+        auto *dst_row = dst.ptr<uchar>(row);
+        for (int col = 0; col < prob.size[3]; col++)
+        {
+            dst_row[col] = saturate_cast<uchar>(prob_score[col] * 255.0f);
+        }
+    }
+    return 0;
+}
+
+#else // HAVE_OPENCV_DNN
+
+int SuperScale::init(const std::string &model_path)
+{
+    CV_UNUSED(model_path);
+    return 0;
+}
+
+void SuperScale::processImageScale(const Mat &src, Mat &dst, float scale, const bool & isEnabled, int sr_max_size)
+{
+    CV_UNUSED(sr_max_size);
+    if (isEnabled)
+    {
+        CV_LOG_WARNING(NULL, "objdetect/barcode: SuperScaling disabled - OpenCV has been built without DNN support");
+    }
+    resize(src, dst, Size(), scale, scale, INTER_CUBIC);
+}
+#endif // HAVE_OPENCV_DNN
+
+}  // namespace barcode
+}  // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.hpp
new file mode 100644
index 0000000..37d7288
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/super_scale.hpp
@@ -0,0 +1,41 @@
+/// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Tencent is pleased to support the open source community by making WeChat QRCode available.
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+
+#ifndef OPENCV_BARCODE_SUPER_SCALE_HPP
+#define OPENCV_BARCODE_SUPER_SCALE_HPP
+
+#ifdef HAVE_OPENCV_DNN
+# include "opencv2/dnn.hpp"
+#endif
+
+namespace cv {
+namespace barcode {
+
+class SuperScale
+{
+public:
+    SuperScale() = default;
+
+    ~SuperScale() = default;
+
+    int init(const std::string &model_path);
+
+    void processImageScale(const Mat &src, Mat &dst, float scale, const bool &use_sr, int sr_max_size = 160);
+
+#ifdef HAVE_OPENCV_DNN
+private:
+    dnn::Net srnet_;
+    bool net_loaded_ = false;
+
+    int superResolutionScale(const cv::Mat &src, cv::Mat &dst);
+#endif
+};
+
+} // namespace barcode
+} // namespace cv
+
+#endif // OPENCV_BARCODE_SUPER_SCALE_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp
new file mode 100644
index 0000000..123955c
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.cpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../../precomp.hpp"
+#include "utils.hpp"
+#include "hybrid_binarizer.hpp"
+
+namespace cv {
+namespace barcode {
+
+
+void sharpen(const Mat &src, const Mat &dst)
+{
+    Mat blur;
+    GaussianBlur(src, blur, Size(0, 0), 25);
+    addWeighted(src, 2, blur, -1, -20, dst);
+}
+
+void binarize(const Mat &src, Mat &dst, BinaryType mode)
+{
+    switch (mode)
+    {
+        case OTSU:
+            threshold(src, dst, 155, 255, THRESH_OTSU + THRESH_BINARY);
+            break;
+        case HYBRID:
+            hybridBinarization(src, dst);
+            break;
+        default:
+            CV_Error(Error::StsNotImplemented, "This binary type is not yet implemented");
+    }
+}
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.hpp
new file mode 100644
index 0000000..85597c0
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/common/utils.hpp
@@ -0,0 +1,26 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_UTILS_HPP
+#define OPENCV_BARCODE_UTILS_HPP
+
+
+namespace cv {
+namespace barcode {
+
+enum BinaryType
+{
+    OTSU = 0, HYBRID = 1
+};
+static constexpr BinaryType binary_types[] = {OTSU, HYBRID};
+
+void sharpen(const Mat &src, const Mat &dst);
+
+void binarize(const Mat &src, Mat &dst, BinaryType mode);
+
+}
+}
+
+#endif // OPENCV_BARCODE_UTILS_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp
new file mode 100644
index 0000000..8be6122
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.cpp
@@ -0,0 +1,92 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "ean13_decoder.hpp"
+
+// three digit decode method from https://baike.baidu.com/item/EAN-13
+
+namespace cv {
+namespace barcode {
+
+static constexpr size_t EAN13BITS_NUM = 95;
+static constexpr size_t EAN13DIGIT_NUM = 13;
+// default thought that mat is a matrix after binary-transfer.
+/**
+* decode EAN-13
+* @prama: data: the input array,
+* @prama: start: the index of start order, begin at 0, max-value is data.size()-1
+* it scan begin at the data[start]
+*/
+Result Ean13Decoder::decode(const vector<uchar> &data) const
+{
+    string result;
+    char decode_result[EAN13DIGIT_NUM + 1]{'\0'};
+    if (data.size() < EAN13BITS_NUM)
+    {
+        return Result("Wrong Size", Result::BARCODE_NONE);
+    }
+    pair<uint, uint> pattern;
+    if (!findStartGuardPatterns(data, pattern))
+    {
+        return Result("Begin Pattern Not Found", Result::BARCODE_NONE);
+    }
+    uint start = pattern.second;
+    Counter counter(vector<int>{0, 0, 0, 0});
+    size_t end = data.size();
+    int first_char_bit = 0;
+    // [1,6] are left part of EAN, [7,12] are right part, index 0 is calculated by left part
+    for (int i = 1; i < 7 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_AB_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i] = static_cast<char>('0' + bestMatch % 10);
+        start = counter.sum + start;
+        first_char_bit += (bestMatch >= 10) << i;
+    }
+    decode_result[0] = static_cast<char>(FIRST_CHAR_ARRAY()[first_char_bit >> 2] + '0');
+    // why there need >> 2?
+    // first, the i in for-cycle is begin in 1
+    // second, the first i = 1 is always
+    Counter middle_counter(vector<int>(MIDDLE_PATTERN().size()));
+    if (!findGuardPatterns(data, start, true, MIDDLE_PATTERN(), middle_counter, pattern))
+    {
+        return Result("Middle Pattern Not Found", Result::BARCODE_NONE);
+
+    }
+    start = pattern.second;
+    for (int i = 0; i < 6 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i + 7] = static_cast<char>('0' + bestMatch);
+        start = counter.sum + start;
+    }
+    Counter end_counter(vector<int>(BEGIN_PATTERN().size()));
+    if (!findGuardPatterns(data, start, false, BEGIN_PATTERN(), end_counter, pattern))
+    {
+        return Result("End Pattern Not Found", Result::BARCODE_NONE);
+    }
+    result = string(decode_result);
+    if (!isValid(result))
+    {
+        return Result("Wrong: " + result.append(string(EAN13DIGIT_NUM - result.size(), ' ')), Result::BARCODE_NONE);
+    }
+    return Result(result, Result::BARCODE_EAN_13);
+}
+
+Ean13Decoder::Ean13Decoder()
+{
+    this->bits_num = EAN13BITS_NUM;
+    this->digit_number = EAN13DIGIT_NUM;
+}
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.hpp
new file mode 100644
index 0000000..1fcedd7
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean13_decoder.hpp
@@ -0,0 +1,31 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_EAN13_DECODER_HPP
+#define OPENCV_BARCODE_EAN13_DECODER_HPP
+
+#include "upcean_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+//extern struct EncodePair;
+using std::string;
+using std::vector;
+using std::pair;
+
+
+class Ean13Decoder : public UPCEANDecoder
+{
+public:
+    Ean13Decoder();
+
+    ~Ean13Decoder() override = default;
+
+protected:
+    Result decode(const vector<uchar> &data) const override;
+};
+}
+} // namespace cv
+#endif // OPENCV_BARCODE_EAN13_DECODER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp
new file mode 100644
index 0000000..23be9dc
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.cpp
@@ -0,0 +1,79 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "ean8_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+static constexpr size_t EAN8BITS_NUM = 70;
+static constexpr size_t EAN8DIGIT_NUM = 8;
+
+Result Ean8Decoder::decode(const vector<uchar> &data) const
+{
+    std::string result;
+    char decode_result[EAN8DIGIT_NUM + 1]{'\0'};
+    if (data.size() < EAN8BITS_NUM)
+    {
+        return Result("Wrong Size", Result::BARCODE_NONE);
+    }
+    pair<uint, uint> pattern;
+    if (!findStartGuardPatterns(data, pattern))
+    {
+        return Result("Begin Pattern Not Found", Result::BARCODE_NONE);
+    }
+    uint start = pattern.second;
+    Counter counter(vector<int>{0, 0, 0, 0});
+    size_t end = data.size();
+    for (int i = 0; i < 4 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i] = static_cast<char>('0' + bestMatch % 10);
+        start = counter.sum + start;
+    }
+
+    Counter middle_counter(vector<int>(MIDDLE_PATTERN().size()));
+
+    if (!findGuardPatterns(data, start, true, MIDDLE_PATTERN(), middle_counter, pattern))
+    {
+        return Result("Middle Pattern Not Found", Result::BARCODE_NONE);
+    }
+
+    start = pattern.second;
+    for (int i = 0; i < 4 && start < end; ++i)
+    {
+        int bestMatch = decodeDigit(data, counter, start, get_A_or_C_Patterns());
+        if (bestMatch == -1)
+        {
+            return Result("Decode Error", Result::BARCODE_NONE);
+        }
+        decode_result[i + 4] = static_cast<char>('0' + bestMatch);
+        start = counter.sum + start;
+    }
+    Counter end_counter(vector<int>(BEGIN_PATTERN().size()));
+    if (!findGuardPatterns(data, start, false, BEGIN_PATTERN(), end_counter, pattern))
+    {
+        return Result("End Pattern Not Found", Result::BARCODE_NONE);
+    }
+    result = string(decode_result);
+    if (!isValid(result))
+    {
+        return Result("Wrong: " + result.append(string(EAN8DIGIT_NUM - result.size(), ' ')), Result::BARCODE_NONE);
+    }
+    return Result(result, Result::BARCODE_EAN_8);
+}
+
+Ean8Decoder::Ean8Decoder()
+{
+    this->digit_number = EAN8DIGIT_NUM;
+    this->bits_num = EAN8BITS_NUM;
+}
+
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.hpp
new file mode 100644
index 0000000..4f5a062
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/ean8_decoder.hpp
@@ -0,0 +1,32 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_EAN8_DECODER_HPP
+#define OPENCV_BARCODE_EAN8_DECODER_HPP
+
+#include "upcean_decoder.hpp"
+
+namespace cv {
+namespace barcode {
+
+using std::string;
+using std::vector;
+using std::pair;
+
+class Ean8Decoder : public UPCEANDecoder
+{
+
+public:
+    Ean8Decoder();
+
+    ~Ean8Decoder() override = default;
+
+protected:
+    Result decode(const vector<uchar> &data) const override;
+};
+}
+}
+
+#endif // OPENCV_BARCODE_EAN8_DECODER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
new file mode 100644
index 0000000..2288f5b
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.cpp
@@ -0,0 +1,290 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "upcean_decoder.hpp"
+#include <map>
+
+namespace cv {
+namespace barcode {
+
+static constexpr int DIVIDE_PART = 15;
+static constexpr int BIAS_PART = 2;
+
+#if 0
+void UPCEANDecoder::drawDebugLine(Mat &debug_img, const Point2i &begin, const Point2i &end) const
+{
+    Result result;
+    std::vector<uchar> middle;
+    LineIterator line = LineIterator(debug_img, begin, end);
+    middle.reserve(line.count);
+    for (int cnt = 0; cnt < line.count; cnt++, line++)
+    {
+        middle.push_back(debug_img.at<uchar>(line.pos()));
+    }
+    std::pair<int, int> start_range;
+    if (findStartGuardPatterns(middle, start_range))
+    {
+        circle(debug_img, Point2i(begin.x + start_range.second, begin.y), 2, Scalar(0), 2);
+    }
+    result = this->decode(middle);
+    if (result.format == Result::BARCODE_NONE)
+    {
+        result = this->decode(std::vector<uchar>(middle.crbegin(), middle.crend()));
+    }
+    if (result.format == Result::BARCODE_NONE)
+    {
+        cv::line(debug_img, begin, end, Scalar(0), 2);
+        cv::putText(debug_img, result.result, begin, cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(0, 0, 255), 1);
+    }
+}
+#endif
+
+bool UPCEANDecoder::findGuardPatterns(const std::vector<uchar> &row, uint rowOffset, uchar whiteFirst,
+                                      const std::vector<int> &pattern, Counter &counter, std::pair<uint, uint> &result)
+{
+    size_t patternLength = pattern.size();
+    size_t width = row.size();
+    uchar color = whiteFirst ? WHITE : BLACK;
+    rowOffset = (int) (std::find(row.cbegin() + rowOffset, row.cend(), color) - row.cbegin());
+    uint counterPosition = 0;
+    uint patternStart = rowOffset;
+    for (uint x = rowOffset; x < width; x++)
+    {
+        if (row[x] == color)
+        {
+            counter.pattern[counterPosition]++;
+            counter.sum++;
+        }
+        else
+        {
+            if (counterPosition == patternLength - 1)
+            {
+                if (patternMatch(counter, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE)
+                {
+                    result.first = patternStart;
+                    result.second = x;
+                    return true;
+                }
+                patternStart += counter.pattern[0] + counter.pattern[1];
+                counter.sum -= counter.pattern[0] + counter.pattern[1];
+
+                std::copy(counter.pattern.begin() + 2, counter.pattern.end(), counter.pattern.begin());
+
+                counter.pattern[patternLength - 2] = 0;
+                counter.pattern[patternLength - 1] = 0;
+                counterPosition--;
+            }
+            else
+            {
+                counterPosition++;
+            }
+            counter.pattern[counterPosition] = 1;
+            counter.sum++;
+            color = (std::numeric_limits<uchar>::max() - color);
+        }
+    }
+    return false;
+}
+
+bool UPCEANDecoder::findStartGuardPatterns(const std::vector<uchar> &row, std::pair<uint, uint> &start_range)
+{
+    bool is_find = false;
+    int next_start = 0;
+    while (!is_find)
+    {
+        Counter guard_counters(std::vector<int>{0, 0, 0});
+        if (!findGuardPatterns(row, next_start, BLACK, BEGIN_PATTERN(), guard_counters, start_range))
+        {
+            return false;
+        }
+        int start = static_cast<int>(start_range.first);
+        next_start = static_cast<int>(start_range.second);
+        int quiet_start = max(start - (next_start - start), 0);
+        is_find = (quiet_start != start) &&
+                  (std::find(std::begin(row) + quiet_start, std::begin(row) + start, BLACK) == std::begin(row) + start);
+    }
+    return true;
+}
+
+int UPCEANDecoder::decodeDigit(const std::vector<uchar> &row, Counter &counters, uint rowOffset,
+                               const std::vector<std::vector<int>> &patterns)
+{
+    fillCounter(row, rowOffset, counters);
+    int bestMatch = -1;
+    uint bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
+    int i = 0;
+    for (const auto &pattern : patterns)
+    {
+        uint variance = patternMatch(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
+        if (variance < bestVariance)
+        {
+            bestVariance = variance;
+            bestMatch = i;
+        }
+        i++;
+    }
+    return std::max(-1, bestMatch);
+    // -1 is Mismatch or means error.
+}
+
+/*Input a ROI mat return result */
+std::pair<Result, float> UPCEANDecoder::decodeROI(const Mat &bar_img) const
+{
+    if ((size_t) bar_img.cols < this->bits_num)
+    {
+        return std::make_pair(Result{string(), Result::BARCODE_NONE}, 0.0F);
+    }
+
+    std::map<std::string, int> result_vote;
+    std::map<Result::BarcodeType, int> format_vote;
+    int vote_cnt = 0;
+    int total_vote = 0;
+    std::string max_result;
+    Result::BarcodeType max_type = Result::BARCODE_NONE;
+
+    const int step = bar_img.rows / (DIVIDE_PART + BIAS_PART);
+    Result result;
+    int row_num;
+    for (int i = 0; i < DIVIDE_PART; ++i)
+    {
+        row_num = (i + BIAS_PART / 2) * step;
+        if (row_num < 0 || row_num > bar_img.rows)
+        {
+            continue;
+        }
+        const auto *ptr = bar_img.ptr<uchar>(row_num);
+        vector<uchar> line(ptr, ptr + bar_img.cols);
+        result = decodeLine(line);
+        if (result.format != Result::BARCODE_NONE)
+        {
+            total_vote++;
+            result_vote[result.result] += 1;
+            if (result_vote[result.result] > vote_cnt)
+            {
+                vote_cnt = result_vote[result.result];
+                max_result = result.result;
+                max_type = result.format;
+            }
+        }
+    }
+    if (total_vote == 0 || (vote_cnt << 2) < total_vote)
+    {
+        return std::make_pair(Result(string(), Result::BARCODE_NONE), 0.0f);
+    }
+
+    float confidence = (float) vote_cnt / (float) DIVIDE_PART;
+    //Check if it is UPC-A format
+    if (max_type == Result::BARCODE_EAN_13 && max_result[0] == '0')
+    {
+        max_result = max_result.substr(1, 12); //UPC-A length 12
+        max_type = Result::BARCODE_UPC_A;
+    }
+    return std::make_pair(Result(max_result, max_type), confidence);
+}
+
+
+Result UPCEANDecoder::decodeLine(const vector<uchar> &line) const
+{
+    Result result = this->decode(line);
+    if (result.format == Result::BARCODE_NONE)
+    {
+        result = this->decode(std::vector<uchar>(line.crbegin(), line.crend()));
+    }
+    return result;
+}
+
+bool UPCEANDecoder::isValid(const string &result) const
+{
+    if (result.size() != digit_number)
+    {
+        return false;
+    }
+    int sum = 0;
+    for (int index = (int) result.size() - 2, i = 1; index >= 0; index--, i++)
+    {
+        int temp = result[index] - '0';
+        sum += (temp + ((i & 1) != 0 ? temp << 1 : 0));
+    }
+    return (result.back() - '0') == ((10 - (sum % 10)) % 10);
+}
+
+// right for A
+const std::vector<std::vector<int>> &get_A_or_C_Patterns()
+{
+    static const std::vector<std::vector<int>> A_or_C_Patterns{{3, 2, 1, 1}, // 0
+                                                               {2, 2, 2, 1}, // 1
+                                                               {2, 1, 2, 2}, // 2
+                                                               {1, 4, 1, 1}, // 3
+                                                               {1, 1, 3, 2}, // 4
+                                                               {1, 2, 3, 1}, // 5
+                                                               {1, 1, 1, 4}, // 6
+                                                               {1, 3, 1, 2}, // 7
+                                                               {1, 2, 1, 3}, // 8
+                                                               {3, 1, 1, 2}  // 9
+    };
+    return A_or_C_Patterns;
+}
+
+const std::vector<std::vector<int>> &get_AB_Patterns()
+{
+    static const std::vector<std::vector<int>> AB_Patterns = [] {
+        constexpr uint offset = 10;
+        auto AB_Patterns_inited = std::vector<std::vector<int>>(offset << 1, std::vector<int>(PATTERN_LENGTH, 0));
+        std::copy(get_A_or_C_Patterns().cbegin(), get_A_or_C_Patterns().cend(), AB_Patterns_inited.begin());
+        //AB pattern is
+        for (uint i = 0; i < offset; ++i)
+        {
+            for (uint j = 0; j < PATTERN_LENGTH; ++j)
+            {
+                AB_Patterns_inited[i + offset][j] = AB_Patterns_inited[i][PATTERN_LENGTH - j - 1];
+            }
+        }
+        return AB_Patterns_inited;
+    }();
+    return AB_Patterns;
+}
+
+const std::vector<int> &BEGIN_PATTERN()
+{
+    // it just need it's 1:1:1(black:white:black)
+    static const std::vector<int> BEGIN_PATTERN_(3, 1);
+    return BEGIN_PATTERN_;
+}
+
+const std::vector<int> &MIDDLE_PATTERN()
+{
+    // it just need it's 1:1:1:1:1(white:black:white:black:white)
+    static const std::vector<int> MIDDLE_PATTERN_(5, 1);
+    return MIDDLE_PATTERN_;
+}
+
+const std::array<char, 32> &FIRST_CHAR_ARRAY()
+{
+    // use array to simulation a Hashmap,
+    // because the data's size is small,
+    // use a hashmap or brute-force search 10 times both can not accept
+    static const std::array<char, 32> pattern{
+            '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x06', '\x00', '\x00', '\x00', '\x09', '\x00',
+            '\x08', '\x03', '\x00', '\x00', '\x00', '\x00', '\x05', '\x00', '\x07', '\x02', '\x00', '\x00', '\x04',
+            '\x01', '\x00', '\x00', '\x00', '\x00', '\x00'};
+    // length is 32 to ensure the security
+    // 0x00000 -> 0  -> 0
+    // 0x11010 -> 26 -> 1
+    // 0x10110 -> 22 -> 2
+    // 0x01110 -> 14 -> 3
+    // 0x11001 -> 25 -> 4
+    // 0x10011 -> 19 -> 5
+    // 0x00111 -> 7  -> 6
+    // 0x10101 -> 21 -> 7
+    // 0x01101 -> 13 -> 8
+    // 0x01011 -> 11 -> 9
+    // delete the 1-13's 2 number's bit,
+    // it always be A which do not need to count.
+    return pattern;
+}
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.hpp b/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.hpp
new file mode 100644
index 0000000..6efc109
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_decoder/upcean_decoder.hpp
@@ -0,0 +1,67 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_UPCEAN_DECODER_HPP
+#define OPENCV_BARCODE_UPCEAN_DECODER_HPP
+
+#include "abs_decoder.hpp"
+
+/**
+ *   upcean_decoder the abstract basic class for decode formats,
+ *   it will have ean13/8,upc_a,upc_e , etc.. class extend this class
+*/
+namespace cv {
+namespace barcode {
+using std::string;
+using std::vector;
+
+class UPCEANDecoder : public AbsDecoder
+{
+
+public:
+    ~UPCEANDecoder() override = default;
+
+    std::pair<Result, float> decodeROI(const Mat &bar_img) const override;
+
+protected:
+    static int decodeDigit(const std::vector<uchar> &row, Counter &counters, uint rowOffset,
+                           const std::vector<std::vector<int>> &patterns);
+
+    static bool
+    findGuardPatterns(const std::vector<uchar> &row, uint rowOffset, uchar whiteFirst, const std::vector<int> &pattern,
+                      Counter &counter, std::pair<uint, uint> &result);
+
+    static bool findStartGuardPatterns(const std::vector<uchar> &row, std::pair<uint, uint> &start_range);
+
+    Result decodeLine(const vector<uchar> &line) const;
+
+    Result decode(const vector<uchar> &bar) const override = 0;
+
+    bool isValid(const string &result) const override;
+
+private:
+    #if 0
+    void drawDebugLine(Mat &debug_img, const Point2i &begin, const Point2i &end) const;
+    #endif
+};
+
+const std::vector<std::vector<int>> &get_A_or_C_Patterns();
+
+const std::vector<std::vector<int>> &get_AB_Patterns();
+
+const std::vector<int> &BEGIN_PATTERN();
+
+const std::vector<int> &MIDDLE_PATTERN();
+
+const std::array<char, 32> &FIRST_CHAR_ARRAY();
+
+constexpr static uint PATTERN_LENGTH = 4;
+constexpr static uint MAX_AVG_VARIANCE = static_cast<uint>(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.48f);
+constexpr static uint MAX_INDIVIDUAL_VARIANCE = static_cast<uint>(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f);
+
+}
+} // namespace cv
+
+#endif // OPENCV_BARCODE_UPCEAN_DECODER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp b/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp
new file mode 100644
index 0000000..e0fcf7b
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.cpp
@@ -0,0 +1,522 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#include "../precomp.hpp"
+#include "bardetect.hpp"
+#include "opencv2/geometry.hpp"
+
+namespace cv {
+namespace barcode {
+static constexpr float PI = static_cast<float>(CV_PI);
+static constexpr float HALF_PI = static_cast<float>(CV_PI / 2);
+
+#define CALCULATE_SUM(ptr, result) \
+    top_left = static_cast<float>(*((ptr) + left_col + integral_cols * top_row));\
+    top_right = static_cast<float>(*((ptr) + integral_cols * top_row + right_col));\
+    bottom_right = static_cast<float>(*((ptr) + right_col + bottom_row * integral_cols));\
+    bottom_left = static_cast<float>(*((ptr) + bottom_row * integral_cols + left_col));\
+    (result) = (bottom_right - bottom_left - top_right + top_left);
+
+
+inline bool Detect::isValidCoord(const Point &coord, const Size &limit)
+{
+    if ((coord.x < 0) || (coord.y < 0))
+    {
+        return false;
+    }
+
+    if ((unsigned) coord.x > (unsigned) (limit.width - 1) || ((unsigned) coord.y > (unsigned) (limit.height - 1)))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+//==============================================================================
+// NMSBoxes copied from modules/dnn/src/nms.inl.hpp
+// TODO: move NMSBoxes outside the dnn module to allow other modules use it
+
+namespace
+{
+
+template <typename T>
+static inline bool SortScorePairDescend(const std::pair<float, T>& pair1,
+                          const std::pair<float, T>& pair2)
+{
+    return pair1.first > pair2.first;
+}
+
+inline void GetMaxScoreIndex(const std::vector<float>& scores, const float threshold, const int top_k,
+                      std::vector<std::pair<float, int> >& score_index_vec)
+{
+    CV_DbgAssert(score_index_vec.empty());
+    // Generate index score pairs.
+    for (size_t i = 0; i < scores.size(); ++i)
+    {
+        if (scores[i] > threshold)
+        {
+            score_index_vec.push_back(std::make_pair(scores[i], (int)i));
+        }
+    }
+
+    // Sort the score pair according to the scores in descending order
+    std::stable_sort(score_index_vec.begin(), score_index_vec.end(),
+                     SortScorePairDescend<int>);
+
+    // Keep top_k scores if needed.
+    if (top_k > 0 && top_k < (int)score_index_vec.size())
+    {
+        score_index_vec.resize(top_k);
+    }
+}
+
+template <typename BoxType>
+inline void NMSFast_(const std::vector<BoxType>& bboxes,
+      const std::vector<float>& scores, const float score_threshold,
+      const float nms_threshold, const float eta, const int top_k,
+      std::vector<int>& indices,
+      float (*computeOverlap)(const BoxType&, const BoxType&),
+      size_t limit = std::numeric_limits<int>::max())
+{
+    CV_Assert(bboxes.size() == scores.size());
+
+    // Get top_k scores (with corresponding indices).
+    std::vector<std::pair<float, int> > score_index_vec;
+    GetMaxScoreIndex(scores, score_threshold, top_k, score_index_vec);
+
+    // Do nms.
+    float adaptive_threshold = nms_threshold;
+    indices.clear();
+    for (size_t i = 0; i < score_index_vec.size(); ++i) {
+        const int idx = score_index_vec[i].second;
+        bool keep = true;
+        for (int k = 0; k < (int)indices.size() && keep; ++k) {
+            const int kept_idx = indices[k];
+            float overlap = computeOverlap(bboxes[idx], bboxes[kept_idx]);
+            keep = overlap <= adaptive_threshold;
+        }
+        if (keep) {
+            indices.push_back(idx);
+            if (indices.size() >= limit) {
+                break;
+            }
+        }
+        if (keep && eta < 1 && adaptive_threshold > 0.5) {
+          adaptive_threshold *= eta;
+        }
+    }
+}
+
+static inline float rotatedRectIOU(const RotatedRect& a, const RotatedRect& b)
+{
+    std::vector<Point2f> inter;
+    int res = rotatedRectangleIntersection(a, b, inter);
+    if (inter.empty() || res == INTERSECT_NONE)
+        return 0.0f;
+    if (res == INTERSECT_FULL)
+        return 1.0f;
+    float interArea = (float)contourArea(inter);
+    return interArea / (a.size.area() + b.size.area() - interArea);
+}
+
+static void NMSBoxes(const std::vector<RotatedRect>& bboxes, const std::vector<float>& scores,
+              const float score_threshold, const float nms_threshold,
+              std::vector<int>& indices, const float eta = 1.f, const int top_k = 0)
+{
+    CV_Assert_N(bboxes.size() == scores.size(), score_threshold >= 0,
+        nms_threshold >= 0, eta > 0);
+    NMSFast_(bboxes, scores, score_threshold, nms_threshold, eta, top_k, indices, rotatedRectIOU);
+}
+
+} // namespace <anonymous>::
+
+
+//==============================================================================
+
+void Detect::init(const Mat &src, double detectorThreshDownSamplingLimit)
+{
+    const double min_side = std::min(src.size().width, src.size().height);
+    if (min_side > detectorThreshDownSamplingLimit)
+    {
+        purpose = SHRINKING;
+        coeff_expansion = min_side / detectorThreshDownSamplingLimit;
+        width = cvRound(src.size().width / coeff_expansion);
+        height = cvRound(src.size().height / coeff_expansion);
+        Size new_size(width, height);
+        resize(src, resized_barcode, new_size, 0, 0, INTER_AREA);
+    }
+//    else if (min_side < 512.0)
+//    {
+//        purpose = ZOOMING;
+//        coeff_expansion = 512.0 / min_side;
+//        width = cvRound(src.size().width * coeff_expansion);
+//        height = cvRound(src.size().height * coeff_expansion);
+//        Size new_size(width, height);
+//        resize(src, resized_barcode, new_size, 0, 0, INTER_CUBIC);
+//    }
+    else
+    {
+        purpose = UNCHANGED;
+        coeff_expansion = 1.0;
+        width = src.size().width;
+        height = src.size().height;
+        resized_barcode = src.clone();
+    }
+    // median blur: sometimes it reduces the noise, but also reduces the recall
+    // medianBlur(resized_barcode, resized_barcode, 3);
+
+}
+
+
+void Detect::localization(const std::vector<float>& detectorWindowSizes, double detectorThreshGradientMagnitude)
+{
+
+    localization_bbox.clear();
+    bbox_scores.clear();
+
+    // get integral image
+    preprocess(detectorThreshGradientMagnitude);
+    // empirical setting
+    //static constexpr float SCALE_LIST[] = {0.01f, 0.03f, 0.06f, 0.08f};
+    const auto min_side = static_cast<float>(std::min(width, height));
+    int window_size;
+    for (const float scale: detectorWindowSizes)
+    {
+        window_size = cvRound(min_side * scale);
+        if(window_size == 0) {
+            window_size = 1;
+        }
+        calCoherence(window_size);
+        barcodeErode();
+        regionGrowing(window_size);
+    }
+
+}
+
+
+bool Detect::computeTransformationPoints()
+{
+
+    bbox_indices.clear();
+    transformation_points.clear();
+    transformation_points.reserve(bbox_indices.size());
+    RotatedRect rect;
+    Point2f temp[4];
+
+    /**
+     * #24902 resolution invariant barcode detector
+     *
+     * refactor of THRESHOLD_SCORE = float(width * height) / 300.f
+     * wrt to rescaled input size - 300 value needs factorization
+     * only one factor pair matches a common aspect ratio of 4:3 ~ 20x15
+     * decomposing this yields THRESHOLD_SCORE = (width / 20) * (height / 15)
+     * therefore each factor was rescaled based by purpose (refsize was 512)
+     */
+    const float THRESHOLD_WSCALE = (purpose != UNCHANGED) ? 20 : (20 * width / 512.f);
+    const float THRESHOLD_HSCALE = (purpose != UNCHANGED) ? 15 : (15 * height / 512.f);
+    const float THRESHOLD_SCORE = (width / THRESHOLD_WSCALE) * (height / THRESHOLD_HSCALE);
+
+    NMSBoxes(localization_bbox, bbox_scores, THRESHOLD_SCORE, 0.1f, bbox_indices);
+
+    for (const auto &bbox_index : bbox_indices)
+    {
+        rect = localization_bbox[bbox_index];
+        if (purpose == ZOOMING)
+        {
+            rect.center /= coeff_expansion;
+            rect.size.height /= static_cast<float>(coeff_expansion);
+            rect.size.width /= static_cast<float>(coeff_expansion);
+        }
+        else if (purpose == SHRINKING)
+        {
+            rect.center *= coeff_expansion;
+            rect.size.height *= static_cast<float>(coeff_expansion);
+            rect.size.width *= static_cast<float>(coeff_expansion);
+        }
+        rect.points(temp);
+        transformation_points.emplace_back(vector<Point2f>{temp[0], temp[1], temp[2], temp[3]});
+    }
+
+    return !transformation_points.empty();
+}
+
+
+void Detect::preprocess(double detectorGradientMagnitudeThresh)
+{
+    Mat scharr_x, scharr_y, temp;
+    Scharr(resized_barcode, scharr_x, CV_32F, 1, 0);
+    Scharr(resized_barcode, scharr_y, CV_32F, 0, 1);
+    // calculate magnitude of gradient and truncate
+    magnitude(scharr_x, scharr_y, temp);
+    threshold(temp, temp, detectorGradientMagnitudeThresh, 1, THRESH_BINARY);
+    temp.convertTo(gradient_magnitude, CV_8U);
+    integral(gradient_magnitude, integral_edges, CV_32F);
+
+
+    for (int y = 0; y < height; y++)
+    {
+        auto *const x_row = scharr_x.ptr<float_t>(y);
+        auto *const y_row = scharr_y.ptr<float_t>(y);
+        auto *const magnitude_row = gradient_magnitude.ptr<uint8_t>(y);
+        for (int pos = 0; pos < width; pos++)
+        {
+            if (magnitude_row[pos] == 0)
+            {
+                x_row[pos] = 0;
+                y_row[pos] = 0;
+                continue;
+            }
+            if (x_row[pos] < 0)
+            {
+                x_row[pos] *= -1;
+                y_row[pos] *= -1;
+            }
+        }
+    }
+    integral(scharr_x, temp, integral_x_sq, CV_32F, CV_32F);
+    integral(scharr_y, temp, integral_y_sq, CV_32F, CV_32F);
+    integral(scharr_x.mul(scharr_y), integral_xy, temp, CV_32F, CV_32F);
+}
+
+
+// Change coherence orientation edge_nums
+// depend on width height integral_edges integral_x_sq integral_y_sq integral_xy
+void Detect::calCoherence(int window_size)
+{
+    static constexpr float THRESHOLD_COHERENCE = 0.9f;
+    int right_col, left_col, top_row, bottom_row;
+    float xy, x_sq, y_sq, d, rect_area;
+    const float THRESHOLD_AREA = float(window_size * window_size) * 0.42f;
+    Size new_size(width / window_size, height / window_size);
+    coherence = Mat(new_size, CV_8U), orientation = Mat(new_size, CV_32F), edge_nums = Mat(new_size, CV_32F);
+
+    float top_left, top_right, bottom_left, bottom_right;
+    int integral_cols = width + 1;
+    const auto *edges_ptr = integral_edges.ptr<float_t>(), *x_sq_ptr = integral_x_sq.ptr<float_t>(), *y_sq_ptr = integral_y_sq.ptr<float_t>(), *xy_ptr = integral_xy.ptr<float_t>();
+    for (int y = 0; y < new_size.height; y++)
+    {
+        auto *coherence_row = coherence.ptr<uint8_t>(y);
+        auto *orientation_row = orientation.ptr<float_t>(y);
+        auto *edge_nums_row = edge_nums.ptr<float_t>(y);
+        if (y * window_size >= height)
+        {
+            continue;
+        }
+        top_row = y * window_size;
+        bottom_row = min(height, (y + 1) * window_size);
+
+        for (int pos = 0; pos < new_size.width; pos++)
+        {
+
+            // then calculate the column locations of the rectangle and set them to -1
+            // if they are outside the matrix bounds
+            if (pos * window_size >= width)
+            {
+                continue;
+            }
+            left_col = pos * window_size;
+            right_col = min(width, (pos + 1) * window_size);
+
+            //we had an integral image to count non-zero elements
+            CALCULATE_SUM(edges_ptr, rect_area)
+            if (rect_area < THRESHOLD_AREA)
+            {
+                // smooth region
+                coherence_row[pos] = 0;
+                continue;
+            }
+
+            CALCULATE_SUM(x_sq_ptr, x_sq)
+            CALCULATE_SUM(y_sq_ptr, y_sq)
+            CALCULATE_SUM(xy_ptr, xy)
+
+            // get the values of the rectangle corners from the integral image - 0 if outside bounds
+            d = sqrt((x_sq - y_sq) * (x_sq - y_sq) + 4 * xy * xy) / (x_sq + y_sq);
+            if (d > THRESHOLD_COHERENCE)
+            {
+                coherence_row[pos] = 255;
+                orientation_row[pos] = atan2(x_sq - y_sq, 2 * xy) / 2.0f;
+                edge_nums_row[pos] = rect_area;
+            }
+            else
+            {
+                coherence_row[pos] = 0;
+            }
+
+        }
+
+    }
+}
+
+// will change localization_bbox bbox_scores
+// will change coherence,
+// depend on coherence orientation edge_nums
+void Detect::regionGrowing(int window_size)
+{
+    static constexpr float LOCAL_THRESHOLD_COHERENCE = 0.95f, THRESHOLD_RADIAN =
+            PI / 30, LOCAL_RATIO = 0.5f, EXPANSION_FACTOR = 1.2f;
+    static constexpr uint THRESHOLD_BLOCK_NUM = 35;
+    Point pt_to_grow, pt;                       //point to grow
+
+    float src_value;
+    float cur_value;
+    float edge_num;
+    float rect_orientation;
+    float sin_sum, cos_sum;
+    uint counter;
+    //grow direction
+    static constexpr int DIR[8][2] = {{-1, -1},
+                                      {0,  -1},
+                                      {1,  -1},
+                                      {1,  0},
+                                      {1,  1},
+                                      {0,  1},
+                                      {-1, 1},
+                                      {-1, 0}};
+    vector<Point2f> growingPoints, growingImgPoints;
+    for (int y = 0; y < coherence.rows; y++)
+    {
+        auto *coherence_row = coherence.ptr<uint8_t>(y);
+
+        for (int x = 0; x < coherence.cols; x++)
+        {
+            if (coherence_row[x] == 0)
+            {
+                continue;
+            }
+            // flag
+            coherence_row[x] = 0;
+            growingPoints.clear();
+            growingImgPoints.clear();
+
+            pt = Point(x, y);
+            cur_value = orientation.at<float_t>(pt);
+            sin_sum = sin(2 * cur_value);
+            cos_sum = cos(2 * cur_value);
+            counter = 1;
+            edge_num = edge_nums.at<float_t>(pt);
+            growingPoints.push_back(pt);
+            growingImgPoints.push_back(Point(pt));
+            while (!growingPoints.empty())
+            {
+                pt = growingPoints.back();
+                growingPoints.pop_back();
+                src_value = orientation.at<float_t>(pt);
+
+                //growing in eight directions
+                for (auto i : DIR)
+                {
+                    pt_to_grow = Point(pt.x + i[0], pt.y + i[1]);
+
+                    //check if out of boundary
+                    if (!isValidCoord(pt_to_grow, coherence.size()))
+                    {
+                        continue;
+                    }
+
+                    if (coherence.at<uint8_t>(pt_to_grow) == 0)
+                    {
+                        continue;
+                    }
+                    cur_value = orientation.at<float_t>(pt_to_grow);
+                    if (abs(cur_value - src_value) < THRESHOLD_RADIAN ||
+                        abs(cur_value - src_value) > PI - THRESHOLD_RADIAN)
+                    {
+                        coherence.at<uint8_t>(pt_to_grow) = 0;
+                        sin_sum += sin(2 * cur_value);
+                        cos_sum += cos(2 * cur_value);
+                        counter += 1;
+                        edge_num += edge_nums.at<float_t>(pt_to_grow);
+                        growingPoints.push_back(pt_to_grow);                 //push next point to grow back to stack
+                        growingImgPoints.push_back(pt_to_grow);
+                    }
+                }
+            }
+            //minimum block num
+            if (counter < THRESHOLD_BLOCK_NUM)
+            {
+                continue;
+            }
+            float local_coherence = (sin_sum * sin_sum + cos_sum * cos_sum) / static_cast<float>(counter * counter);
+            // minimum local gradient orientation_arg coherence_arg
+            if (local_coherence < LOCAL_THRESHOLD_COHERENCE)
+            {
+                continue;
+            }
+            RotatedRect minRect = minAreaRect(growingImgPoints);
+            if (edge_num < minRect.size.area() * float(window_size * window_size) * LOCAL_RATIO ||
+                static_cast<float>(counter) < minRect.size.area() * LOCAL_RATIO)
+            {
+                continue;
+            }
+            const float local_orientation = atan2(cos_sum, sin_sum) / 2.0f;
+            // only orientation_arg is approximately equal to the rectangle orientation_arg
+            rect_orientation = (minRect.angle) * PI / 180.f;
+            if (minRect.size.width < minRect.size.height)
+            {
+                rect_orientation += (rect_orientation <= 0.f ? HALF_PI : -HALF_PI);
+                std::swap(minRect.size.width, minRect.size.height);
+            }
+            if (abs(local_orientation - rect_orientation) > THRESHOLD_RADIAN &&
+                abs(local_orientation - rect_orientation) < PI - THRESHOLD_RADIAN)
+            {
+                continue;
+            }
+            minRect.angle = local_orientation * 180.f / PI;
+            minRect.size.width *= static_cast<float>(window_size) * EXPANSION_FACTOR;
+            minRect.size.height *= static_cast<float>(window_size);
+            minRect.center.x = (minRect.center.x + 0.5f) * static_cast<float>(window_size);
+            minRect.center.y = (minRect.center.y + 0.5f) * static_cast<float>(window_size);
+            localization_bbox.push_back(minRect);
+            bbox_scores.push_back(edge_num);
+
+        }
+    }
+}
+
+inline const std::array<Mat, 4> &getStructuringElement()
+{
+    static const std::array<Mat, 4> structuringElement{
+            Mat_<uint8_t>{{3,   3},
+                          {255, 0, 0, 0, 0, 0, 0, 0, 255}}, Mat_<uint8_t>{{3, 3},
+                                                                          {0, 0, 255, 0, 0, 0, 255, 0, 0}},
+            Mat_<uint8_t>{{3, 3},
+                          {0, 0, 0, 255, 0, 255, 0, 0, 0}}, Mat_<uint8_t>{{3, 3},
+                                                                          {0, 255, 0, 0, 0, 0, 0, 255, 0}}};
+    return structuringElement;
+}
+
+// Change mat
+void Detect::barcodeErode()
+{
+    static const std::array<Mat, 4> &structuringElement = getStructuringElement();
+    Mat m0, m1, m2, m3;
+    dilate(coherence, m0, structuringElement[0]);
+    dilate(coherence, m1, structuringElement[1]);
+    dilate(coherence, m2, structuringElement[2]);
+    dilate(coherence, m3, structuringElement[3]);
+    int sum;
+    for (int y = 0; y < coherence.rows; y++)
+    {
+        auto coherence_row = coherence.ptr<uint8_t>(y);
+        auto m0_row = m0.ptr<uint8_t>(y);
+        auto m1_row = m1.ptr<uint8_t>(y);
+        auto m2_row = m2.ptr<uint8_t>(y);
+        auto m3_row = m3.ptr<uint8_t>(y);
+
+        for (int pos = 0; pos < coherence.cols; pos++)
+        {
+            if (coherence_row[pos] != 0)
+            {
+                sum = m0_row[pos] + m1_row[pos] + m2_row[pos] + m3_row[pos];
+                //more than 2 group
+                coherence_row[pos] = sum > 600 ? 255 : 0;
+            }
+        }
+    }
+}
+}
+}
diff --git a/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.hpp b/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.hpp
new file mode 100644
index 0000000..178fded
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/barcode_detector/bardetect.hpp
@@ -0,0 +1,62 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+// Copyright (c) 2020-2021 darkliang wangberlinT Certseeds
+
+#ifndef OPENCV_BARCODE_BARDETECT_HPP
+#define OPENCV_BARCODE_BARDETECT_HPP
+
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+namespace barcode {
+using std::vector;
+
+class Detect
+{
+private:
+    vector<RotatedRect> localization_rects;
+    vector<RotatedRect> localization_bbox;
+    vector<float> bbox_scores;
+    vector<int> bbox_indices;
+    vector<vector<Point2f>> transformation_points;
+
+
+public:
+    void init(const Mat &src, double detectorThreshDownSamplingLimit);
+
+    void localization(const vector<float>& detectorWindowSizes, double detectorGradientMagnitudeThresh);
+
+    vector<vector<Point2f>> getTransformationPoints()
+    { return transformation_points; }
+
+    bool computeTransformationPoints();
+
+protected:
+    enum resize_direction
+    {
+        ZOOMING, SHRINKING, UNCHANGED
+    } purpose = UNCHANGED;
+
+
+    double coeff_expansion = 1.0;
+    int height, width;
+    Mat resized_barcode, gradient_magnitude, coherence, orientation, edge_nums, integral_x_sq, integral_y_sq, integral_xy, integral_edges;
+
+    void preprocess(double detectorThreshGradientMagnitude);
+
+    void calCoherence(int window_size);
+
+    static inline bool isValidCoord(const Point &coord, const Size &limit);
+
+    void regionGrowing(int window_size);
+
+    void barcodeErode();
+
+
+};
+}
+}
+
+#endif // OPENCV_BARCODE_BARDETECT_HPP
diff --git a/upstream/opencv/modules/objdetect/src/calibinit.cpp b/upstream/opencv/modules/objdetect/src/calibinit.cpp
new file mode 100644
index 0000000..83c6b06
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/calibinit.cpp
@@ -0,0 +1,2296 @@
+//M*//////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/************************************************************************************\
+    This is improved variant of chessboard corner detection algorithm that
+    uses a graph of connected quads. It is based on the code contributed
+    by Vladimir Vezhnevets and Philip Gruebele.
+    Here is the copyright notice from the original Vladimir's code:
+    ===============================================================
+
+    The algorithms developed and implemented by Vezhnevets Vladimir
+    aka Dead Moroz (vvp@graphics.cs.msu.ru)
+    See http://graphics.cs.msu.su/en/research/calibration/opencv.html
+    for detailed information.
+
+    Reliability additions and modifications made by Philip Gruebele.
+    <a href="mailto:pgruebele@cox.net">pgruebele@cox.net</a>
+
+    Some further improvements for detection of partially occluded boards at non-ideal
+    lighting conditions have been made by Alex Bovyrin and Kurt Kolonige
+
+\************************************************************************************/
+
+/************************************************************************************\
+  This version adds a new and improved variant of chessboard corner detection
+  that works better in poor lighting condition. It is based on work from
+  Oliver Schreer and Stefano Masneri. This method works faster than the previous
+  one and reverts back to the older method in case no chessboard detection is
+  possible. Overall performance improves also because now the method avoids
+  performing the same computation multiple times when not necessary.
+
+\************************************************************************************/
+
+#include "precomp.hpp"
+#include "circlesgrid.hpp"
+#include "opencv2/geometry.hpp"
+#include "opencv2/flann.hpp"
+
+#include <stack>
+
+//#define ENABLE_TRIM_COL_ROW
+
+// Requires CMake flag: DEBUG_opencv_calib3d=ON
+//#define DEBUG_CHESSBOARD
+#define DEBUG_CHESSBOARD_TIMEOUT 0  // 0 - wait for 'q'
+
+#include <opencv2/core/utils/logger.defines.hpp>
+//#undef CV_LOG_STRIP_LEVEL
+//#define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_VERBOSE + 1
+#include <opencv2/core/utils/logger.hpp>
+
+#ifdef DEBUG_CHESSBOARD
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#define DPRINTF(...)  CV_LOG_INFO(NULL, format("calib: " __VA_ARGS__))
+#else
+#define DPRINTF(...)
+#endif
+
+namespace cv {
+
+//=====================================================================================
+// Implementation for the enhanced calibration object detection
+//=====================================================================================
+
+#define MAX_CONTOUR_APPROX  7
+
+struct QuadCountour {
+    Point pt[4];
+    int parent_contour;
+
+    QuadCountour(const Point pt_[4], int parent_contour_) :
+        parent_contour(parent_contour_)
+    {
+        pt[0] = pt_[0]; pt[1] = pt_[1]; pt[2] = pt_[2]; pt[3] = pt_[3];
+    }
+};
+
+/** This structure stores information about the chessboard corner.*/
+struct ChessBoardCorner
+{
+    Point2f pt;  // Coordinates of the corner
+    int row;         // Board row index
+    int count;       // Number of neighbor corners
+    struct ChessBoardCorner* neighbors[4]; // Neighbor corners
+
+    ChessBoardCorner(const Point2f& pt_ = Point2f()) :
+        pt(pt_), row(0), count(0)
+    {
+        neighbors[0] = neighbors[1] = neighbors[2] = neighbors[3] = NULL;
+    }
+
+    float sumDist(int& n_) const
+    {
+        float sum = 0;
+        int n = 0;
+        for (int i = 0; i < 4; ++i)
+        {
+            if (neighbors[i])
+            {
+                sum += sqrt(normL2Sqr<float>(neighbors[i]->pt - pt));
+                n++;
+            }
+        }
+        n_ = n;
+        return sum;
+    }
+};
+
+
+/** This structure stores information about the chessboard quadrangle.*/
+struct ChessBoardQuad
+{
+    int count;      // Number of quad neighbors
+    int group_idx;  // quad group ID
+    int row, col;   // row and column of this quad
+    bool ordered;   // true if corners/neighbors are ordered counter-clockwise
+    float edge_sqr_len; // quad edge squared length, in pix^2
+    // neighbors and corners are synced, i.e., neighbor 0 shares corner 0
+    ChessBoardCorner *corners[4]; // Coordinates of quad corners
+    struct ChessBoardQuad *neighbors[4]; // Pointers of quad neighbors. M.b. sparse.
+    // Each neighbors element corresponds to quad corner, but not just sequential index.
+
+    ChessBoardQuad(int group_idx_ = -1) :
+        count(0),
+        group_idx(group_idx_),
+        row(0), col(0),
+        ordered(0),
+        edge_sqr_len(0)
+    {
+        corners[0] = corners[1] = corners[2] = corners[3] = NULL;
+        neighbors[0] = neighbors[1] = neighbors[2] = neighbors[3] = NULL;
+    }
+};
+
+
+
+#ifdef DEBUG_CHESSBOARD
+static void SHOW(const std::string & name, Mat & img)
+{
+    imshow(name, img);
+#if DEBUG_CHESSBOARD_TIMEOUT
+    waitKey(DEBUG_CHESSBOARD_TIMEOUT);
+#else
+    while ((uchar)waitKey(0) != 'q') {}
+#endif
+}
+static void SHOW_QUADS(const std::string & name, const Mat & img_, ChessBoardQuad * quads, int quads_count)
+{
+    Mat img = img_.clone();
+    if (img.channels() == 1)
+        cvtColor(img, img, COLOR_GRAY2BGR);
+    for (int i = 0; i < quads_count; ++i)
+    {
+        ChessBoardQuad & quad = quads[i];
+        for (int j = 0; j < 4; ++j)
+        {
+            line(img, quad.corners[j]->pt, quad.corners[(j + 1) & 3]->pt, Scalar(0, 240, 0), 1, LINE_AA);
+        }
+    }
+    imshow(name, img);
+#if DEBUG_CHESSBOARD_TIMEOUT
+    waitKey(DEBUG_CHESSBOARD_TIMEOUT);
+#else
+    while ((uchar)waitKey(0) != 'q') {}
+#endif
+}
+#else
+#define SHOW(...)
+#define SHOW_QUADS(...)
+#endif
+
+
+
+class ChessBoardDetector
+{
+public:
+    Mat binarized_image;
+    Size pattern_size;
+
+    AutoBuffer<ChessBoardQuad> all_quads;
+    AutoBuffer<ChessBoardCorner> all_corners;
+
+    int all_quads_count;
+
+    struct NeighborsFinder {
+        const float thresh_sqr_scale = 2.f;
+        ChessBoardDetector& detector;
+        std::vector<int> neighbors_indices;
+        std::vector<float> neighbors_dists;
+        std::vector<Point2f> all_quads_pts;
+        flann::GenericIndex<flann::L2_Simple<float>> all_quads_pts_index;
+
+        NeighborsFinder(ChessBoardDetector& detector);
+
+        bool findCornerNeighbor(
+            const int quad_idx,
+            const int corner_idx,
+            const cv::Point2f& corner_pt,
+            float& min_sqr_dist,
+            const float sqr_radius,
+            int& closest_quad_idx,
+            int& closest_corner_idx,
+            cv::Point2f& closest_corner_pt);
+    };
+
+    ChessBoardDetector(const Size& pattern_size_) :
+        pattern_size(pattern_size_),
+        all_quads_count(0)
+    {
+    }
+
+    void reset()
+    {
+        all_quads.deallocate();
+        all_corners.deallocate();
+        all_quads_count = 0;
+    }
+
+    void generateQuads(const Mat& image_, int flags, int dilations);
+
+    bool processQuads(std::vector<Point2f>& out_corners, int &prev_sqr_size);
+
+    void findQuadNeighbors();
+
+    void findConnectedQuads(std::vector<ChessBoardQuad*>& out_group, int group_idx);
+
+    int checkQuadGroup(const std::vector<ChessBoardQuad*>& quad_group, std::vector<ChessBoardCorner*>& out_corners);
+
+    int cleanFoundConnectedQuads(std::vector<ChessBoardQuad*>& quad_group);
+
+    int orderFoundConnectedQuads(std::vector<ChessBoardQuad*>& quads);
+
+    void orderQuad(ChessBoardQuad& quad, ChessBoardCorner& corner, int common);
+
+#ifdef ENABLE_TRIM_COL_ROW
+    void trimCol(std::vector<ChessBoardQuad*>& quads, int col, int dir);
+    void trimRow(std::vector<ChessBoardQuad*>& quads, int row, int dir);
+#endif
+
+    int addOuterQuad(ChessBoardQuad& quad, std::vector<ChessBoardQuad*>& quads);
+
+    void removeQuadFromGroup(std::vector<ChessBoardQuad*>& quads, ChessBoardQuad& q0);
+
+    bool checkBoardMonotony(const std::vector<Point2f>& corners);
+};
+
+/***************************************************************************************************/
+//COMPUTE INTENSITY HISTOGRAM OF INPUT IMAGE
+template<typename ArrayContainer>
+static void icvGetIntensityHistogram256(const Mat& img, ArrayContainer& piHist)
+{
+    for (int i = 0; i < 256; i++)
+        piHist[i] = 0;
+    // sum up all pixel in row direction and divide by number of columns
+    for (int j = 0; j < img.rows; ++j)
+    {
+        const uchar* row = img.ptr<uchar>(j);
+        for (int i = 0; i < img.cols; i++)
+        {
+            piHist[row[i]]++;
+        }
+    }
+}
+/***************************************************************************************************/
+//SMOOTH HISTOGRAM USING WINDOW OF SIZE 2*iWidth+1
+template<int iWidth_, typename ArrayContainer>
+static void icvSmoothHistogram256(const ArrayContainer& piHist, ArrayContainer& piHistSmooth, int iWidth = 0)
+{
+    CV_DbgAssert(iWidth_ == 0 || (iWidth == iWidth_ || iWidth == 0));
+    iWidth = (iWidth_ != 0) ? iWidth_ : iWidth;
+    CV_Assert(iWidth > 0);
+    CV_DbgAssert(piHist.size() == 256);
+    CV_DbgAssert(piHistSmooth.size() == 256);
+    for (int i = 0; i < 256; ++i)
+    {
+        int iIdx_min = std::max(0, i - iWidth);
+        int iIdx_max = std::min(255, i + iWidth);
+        int iSmooth = 0;
+        for (int iIdx = iIdx_min; iIdx <= iIdx_max; ++iIdx)
+        {
+            CV_DbgAssert(iIdx >= 0 && iIdx < 256);
+            iSmooth += piHist[iIdx];
+        }
+        piHistSmooth[i] = iSmooth/(iIdx_max-iIdx_min+1);
+    }
+}
+/***************************************************************************************************/
+//COMPUTE FAST HISTOGRAM GRADIENT
+template<typename ArrayContainer>
+static void icvGradientOfHistogram256(const ArrayContainer& piHist, ArrayContainer& piHistGrad)
+{
+    CV_DbgAssert(piHist.size() == 256);
+    CV_DbgAssert(piHistGrad.size() == 256);
+    piHistGrad[0] = 0;
+    int prev_grad = 0;
+    for (int i = 1; i < 255; ++i)
+    {
+        int grad = piHist[i-1] - piHist[i+1];
+        if (std::abs(grad) < 100)
+        {
+            if (prev_grad == 0)
+                grad = -100;
+            else
+                grad = prev_grad;
+        }
+        piHistGrad[i] = grad;
+        prev_grad = grad;
+    }
+    piHistGrad[255] = 0;
+}
+/***************************************************************************************************/
+//PERFORM SMART IMAGE THRESHOLDING BASED ON ANALYSIS OF INTENSITY HISTOGRAM
+static void icvBinarizationHistogramBased(Mat & img)
+{
+    CV_Assert(img.channels() == 1 && img.depth() == CV_8U);
+    int iCols = img.cols;
+    int iRows = img.rows;
+    int iMaxPix = iCols*iRows;
+    int iMaxPix1 = iMaxPix/100;
+    const int iNumBins = 256;
+    const int iMaxPos = 20;
+    AutoBuffer<int, 256> piHistIntensity(iNumBins);
+    AutoBuffer<int, 256> piHistSmooth(iNumBins);
+    AutoBuffer<int, 256> piHistGrad(iNumBins);
+    AutoBuffer<int> piMaxPos(iMaxPos);
+
+    icvGetIntensityHistogram256(img, piHistIntensity);
+
+#if 0
+    // get accumulated sum starting from bright
+    AutoBuffer<int, 256> piAccumSum(iNumBins);
+    piAccumSum[iNumBins-1] = piHistIntensity[iNumBins-1];
+    for (int i = iNumBins - 2; i >= 0; --i)
+    {
+        piAccumSum[i] = piHistIntensity[i] + piAccumSum[i+1];
+    }
+#endif
+
+    // first smooth the distribution
+    //const int iWidth = 1;
+    icvSmoothHistogram256<1>(piHistIntensity, piHistSmooth);
+
+    // compute gradient
+    icvGradientOfHistogram256(piHistSmooth, piHistGrad);
+
+    // check for zeros
+    unsigned iCntMaxima = 0;
+    for (int i = iNumBins-2; (i > 2) && (iCntMaxima < iMaxPos); --i)
+    {
+        if ((piHistGrad[i-1] < 0) && (piHistGrad[i] > 0))
+        {
+            int iSumAroundMax = piHistSmooth[i-1] + piHistSmooth[i] + piHistSmooth[i+1];
+            if (!(iSumAroundMax < iMaxPix1 && i < 64))
+            {
+                piMaxPos[iCntMaxima++] = i;
+            }
+        }
+    }
+
+    DPRINTF("HIST: MAXIMA COUNT: %d (%d, %d, %d, ...)", iCntMaxima,
+            iCntMaxima > 0 ? piMaxPos[0] : -1,
+            iCntMaxima > 1 ? piMaxPos[1] : -1,
+            iCntMaxima > 2 ? piMaxPos[2] : -1);
+
+    int iThresh = 0;
+
+    CV_Assert((size_t)iCntMaxima <= piMaxPos.size());
+
+    DPRINTF("HIST: MAXIMA COUNT: %d (%d, %d, %d, ...)", iCntMaxima,
+                iCntMaxima > 0 ? piMaxPos[0] : -1,
+                iCntMaxima > 1 ? piMaxPos[1] : -1,
+                iCntMaxima > 2 ? piMaxPos[2] : -1);
+
+    if (iCntMaxima == 0)
+    {
+        // no any maxima inside (only 0 and 255 which are not counted above)
+        // Does image black-write already?
+        const int iMaxPix2 = iMaxPix / 2;
+        for (int sum = 0, i = 0; i < 256; ++i) // select mean intensity
+        {
+            sum += piHistIntensity[i];
+            if (sum > iMaxPix2)
+            {
+                iThresh = i;
+                break;
+            }
+        }
+    }
+    else if (iCntMaxima == 1)
+    {
+        iThresh = piMaxPos[0]/2;
+    }
+    else if (iCntMaxima == 2)
+    {
+        iThresh = (piMaxPos[0] + piMaxPos[1])/2;
+    }
+    else // iCntMaxima >= 3
+    {
+        // CHECKING THRESHOLD FOR WHITE
+        int iIdxAccSum = 0, iAccum = 0;
+        for (int i = iNumBins - 1; i > 0; --i)
+        {
+            iAccum += piHistIntensity[i];
+            // iMaxPix/18 is about 5,5%, minimum required number of pixels required for white part of chessboard
+            if ( iAccum > (iMaxPix/18) )
+            {
+                iIdxAccSum = i;
+                break;
+            }
+        }
+
+        unsigned iIdxBGMax = 0;
+        int iBrightMax = piMaxPos[0];
+        // printf("iBrightMax = %d\n", iBrightMax);
+        for (unsigned n = 0; n < iCntMaxima - 1; ++n)
+        {
+            iIdxBGMax = n + 1;
+            if ( piMaxPos[n] < iIdxAccSum )
+            {
+                break;
+            }
+            iBrightMax = piMaxPos[n];
+        }
+
+        // CHECKING THRESHOLD FOR BLACK
+        int iMaxVal = piHistIntensity[piMaxPos[iIdxBGMax]];
+
+        //IF TOO CLOSE TO 255, jump to next maximum
+        if (piMaxPos[iIdxBGMax] >= 250 && iIdxBGMax + 1 < iCntMaxima)
+        {
+            iIdxBGMax++;
+            iMaxVal = piHistIntensity[piMaxPos[iIdxBGMax]];
+        }
+
+        for (unsigned n = iIdxBGMax + 1; n < iCntMaxima; n++)
+        {
+            if (piHistIntensity[piMaxPos[n]] >= iMaxVal)
+            {
+                iMaxVal = piHistIntensity[piMaxPos[n]];
+                iIdxBGMax = n;
+            }
+        }
+
+        //SETTING THRESHOLD FOR BINARIZATION
+        int iDist2 = (iBrightMax - piMaxPos[iIdxBGMax])/2;
+        iThresh = iBrightMax - iDist2;
+        DPRINTF("THRESHOLD SELECTED = %d, BRIGHTMAX = %d, DARKMAX = %d", iThresh, iBrightMax, piMaxPos[iIdxBGMax]);
+    }
+
+    if (iThresh > 0)
+    {
+        img = (img >= iThresh);
+    }
+}
+
+static std::vector<Point2f> getCornersFromQuads(ChessBoardQuad* p_all_quads, const int all_quads_count)
+{
+    std::vector<Point2f> all_quads_pts;
+    all_quads_pts.reserve(all_quads_count * 4);
+    for (int idx = 0; idx < all_quads_count; idx++)
+    {
+        const ChessBoardQuad& cur_quad = (const ChessBoardQuad&)p_all_quads[idx];
+        for (int i = 0; i < 4; i++)
+            all_quads_pts.push_back(cur_quad.corners[i]->pt);
+    }
+    return all_quads_pts;
+}
+
+ChessBoardDetector::NeighborsFinder::NeighborsFinder(ChessBoardDetector& _detector) :
+    detector(_detector),
+    all_quads_pts(getCornersFromQuads(detector.all_quads.data(), detector.all_quads_count)),
+    all_quads_pts_index(Mat(all_quads_pts).reshape(1, detector.all_quads_count * 4), cvflann::KDTreeSingleIndexParams())
+{
+    const int all_corners_count = detector.all_quads_count * 4;
+    neighbors_indices.resize(all_corners_count);
+    neighbors_dists.resize(all_corners_count);
+}
+
+static double pointSideFromLine(const Point2f& line_direction_vector, const Point2f& vector)
+{
+    return line_direction_vector.cross(vector);
+}
+
+static bool arePointsOnSameSideFromLine(const Point2f& line_pt1, const Point2f& line_pt2, const Point2f& pt1, const Point2f& pt2)
+{
+    const Point2f line_direction_vector = line_pt2 - line_pt1;
+    const Point2f vector1 = pt1 - line_pt1;
+    const Point2f vector2 = pt2 - line_pt1;
+    return pointSideFromLine(line_direction_vector, vector1) * pointSideFromLine(line_direction_vector, vector2) > 0.;
+}
+
+bool ChessBoardDetector::NeighborsFinder::findCornerNeighbor(
+    const int quad_idx,
+    const int corner_idx,
+    const cv::Point2f& corner_pt,
+    float& min_sqr_dist,
+    const float sqr_radius,
+    int& closest_quad_idx,
+    int& closest_corner_idx,
+    cv::Point2f& closest_corner_pt)
+{
+    ChessBoardQuad* p_all_quads = detector.all_quads.data();
+
+    const ChessBoardQuad& cur_quad = (const ChessBoardQuad&)p_all_quads[quad_idx];
+    int closest_neighbor_idx = -1;
+    ChessBoardQuad *closest_quad = 0;
+
+    // find the closest corner in all other quadrangles
+    const std::vector<float> query = { corner_pt.x, corner_pt.y };
+    const cvflann::SearchParams search_params(-1);
+    const int neighbors_count = all_quads_pts_index.radiusSearch(query, neighbors_indices, neighbors_dists, sqr_radius, search_params);
+
+    for (int neighbor_idx_idx = 0; neighbor_idx_idx < neighbors_count; neighbor_idx_idx++)
+    {
+        const int neighbor_idx = neighbors_indices[neighbor_idx_idx];
+        const int k = neighbor_idx >> 2;
+        if (k == quad_idx)
+            continue;
+
+        ChessBoardQuad& q_k = p_all_quads[k];
+        const int j = neighbor_idx & 3;
+        if (q_k.neighbors[j])
+            continue;
+
+        const Point2f neighbor_pt = all_quads_pts[neighbor_idx];
+        const float sqr_dist = normL2Sqr<float>(corner_pt - neighbor_pt);
+        if (sqr_dist <= cur_quad.edge_sqr_len * thresh_sqr_scale &&
+            sqr_dist <= q_k.edge_sqr_len * thresh_sqr_scale)
+        {
+            // check edge lengths, make sure they're compatible
+            // edges that are different by more than 1:4 are rejected.
+            // edge_sqr_len is edge squared length, so we compare them
+            // with squared constant 16 = 4^2
+            if (q_k.edge_sqr_len > 16 * cur_quad.edge_sqr_len ||
+                cur_quad.edge_sqr_len > 16 * q_k.edge_sqr_len)
+            {
+                DPRINTF("Incompatible edge lengths");
+                continue;
+            }
+
+            const Point2f mid_pt1 = (cur_quad.corners[corner_idx]->pt + cur_quad.corners[(corner_idx + 1) & 3]->pt) / 2.f;
+            const Point2f mid_pt2 = (cur_quad.corners[(corner_idx + 2) & 3]->pt + cur_quad.corners[(corner_idx + 3) & 3]->pt) / 2.f;
+            if (!arePointsOnSameSideFromLine(mid_pt1, mid_pt2, corner_pt, neighbor_pt))
+                continue;
+
+            const Point2f mid_pt3 = (cur_quad.corners[(corner_idx + 1) & 3]->pt + cur_quad.corners[(corner_idx + 2) & 3]->pt) / 2.f;
+            const Point2f mid_pt4 = (cur_quad.corners[(corner_idx + 3) & 3]->pt + cur_quad.corners[corner_idx]->pt) / 2.f;
+            if (!arePointsOnSameSideFromLine(mid_pt3, mid_pt4, corner_pt, neighbor_pt))
+                continue;
+
+            const Point2f neighbor_pt_diagonal = q_k.corners[(j + 2) & 3]->pt;
+            if (!arePointsOnSameSideFromLine(mid_pt1, mid_pt2, corner_pt, neighbor_pt_diagonal))
+                continue;
+
+            if (!arePointsOnSameSideFromLine(mid_pt3, mid_pt4, corner_pt, neighbor_pt_diagonal))
+                continue;
+
+            closest_neighbor_idx = neighbor_idx;
+            closest_quad_idx = k;
+            closest_corner_idx = j;
+            closest_quad = &q_k;
+            min_sqr_dist = sqr_dist;
+            break;
+        }
+    }
+
+    // we found a matching corner point?
+    if (closest_neighbor_idx >= 0 && closest_quad_idx >= 0 && closest_corner_idx >= 0 && min_sqr_dist < FLT_MAX)
+    {
+        CV_Assert(closest_quad);
+
+        if (cur_quad.count >= 4 || closest_quad->count >= 4)
+            return false;
+
+        // If another point from our current quad is closer to the found corner
+        // than the current one, then we don't count this one after all.
+        // This is necessary to support small squares where otherwise the wrong
+        // corner will get matched to closest_quad;
+        closest_corner_pt = all_quads_pts[closest_neighbor_idx];
+
+        int j = 0;
+        for (; j < 4; j++)
+        {
+            if (cur_quad.neighbors[j] == closest_quad)
+                break;
+
+            if (normL2Sqr<float>(closest_corner_pt - all_quads_pts[(quad_idx << 2) + j]) < min_sqr_dist)
+                break;
+        }
+        if (j < 4)
+            return false;
+
+        // Check that each corner is a neighbor of different quads
+        for(j = 0; j < 4; j++ )
+        {
+            if (closest_quad->neighbors[j] == &cur_quad)
+                break;
+        }
+        if (j < 4)
+            return false;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool findChessboardCorners(InputArray image_, Size pattern_size,
+                           OutputArray corners_, int flags)
+{
+    CV_INSTRUMENT_REGION();
+
+    DPRINTF("==== findChessboardCorners(img=%dx%d, pattern=%dx%d, flags=%d)",
+            image_.cols(), image_.rows(), pattern_size.width, pattern_size.height, flags);
+
+    bool found = false;
+
+    const bool is_plain = (flags & CALIB_CB_PLAIN) != 0;
+
+    int type = image_.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    Mat img = image_.getMat();
+
+    CV_CheckType(type, depth == CV_8U && (cn == 1 || cn == 3 || cn == 4),
+            "Only 8-bit grayscale or color images are supported");
+
+    if (pattern_size.width <= 2 || pattern_size.height <= 2)
+        CV_Error(Error::StsOutOfRange, "Both width and height of the pattern should have bigger than 2");
+
+    if (!corners_.needed())
+        CV_Error(Error::StsNullPtr, "Null pointer to corners");
+
+    std::vector<Point2f> out_corners;
+
+    if (is_plain)
+      CV_CheckType(type, depth == CV_8U && cn == 1, "Only 8-bit grayscale images are supported with CALIB_CB_PLAIN flag enable");
+
+    if (img.channels() != 1)
+    {
+        cvtColor(img, img, COLOR_BGR2GRAY);
+    }
+
+    int prev_sqr_size = 0;
+
+    Mat thresh_img_new = img.clone();
+    if(!is_plain)
+        icvBinarizationHistogramBased(thresh_img_new); // process image in-place
+    SHOW("New binarization", thresh_img_new);
+
+    if (flags & CALIB_CB_FAST_CHECK && !is_plain)
+    {
+        //perform new method for checking chessboard using a binary image.
+        //image is binarised using a threshold dependent on the image histogram
+        if (checkChessboardBinary(thresh_img_new, pattern_size) <= 0) //fall back to the old method
+        {
+            if (!checkChessboard(img, pattern_size))
+            {
+                corners_.release();
+                return false;
+            }
+        }
+    }
+
+    ChessBoardDetector detector(pattern_size);
+
+    const int min_dilations = 0;
+    const int max_dilations = is_plain ? 0 : 7;
+
+    // Try our standard "0" and "1" dilations, but if the pattern is not found, iterate the whole procedure with higher dilations.
+    // This is necessary because some squares simply do not separate properly without and with a single dilations. However,
+    // we want to use the minimum number of dilations possible since dilations cause the squares to become smaller,
+    // making it difficult to detect smaller squares.
+    for (int dilations = min_dilations; dilations <= max_dilations; dilations++)
+    {
+        //USE BINARY IMAGE COMPUTED USING icvBinarizationHistogramBased METHOD
+        if(!is_plain && dilations > 0)
+            dilate( thresh_img_new, thresh_img_new, Mat(), Point(-1, -1), 1 );
+
+        // So we can find rectangles that go to the edge, we draw a white line around the image edge.
+        // Otherwise FindContours will miss those clipped rectangle contours.
+        // The border color will be the image mean, because otherwise we risk screwing up filters like cvSmooth()...
+        rectangle( thresh_img_new, Point(0,0), Point(thresh_img_new.cols-1, thresh_img_new.rows-1), Scalar(255,255,255), 3, LINE_8);
+
+        detector.reset();
+        detector.generateQuads(thresh_img_new, flags, dilations);
+        DPRINTF("Quad count: %d/%d", detector.all_quads_count, (pattern_size.width/2+1)*(pattern_size.height/2+1));
+        SHOW_QUADS("New quads", thresh_img_new, &detector.all_quads[0], detector.all_quads_count);
+        if (detector.processQuads(out_corners, prev_sqr_size))
+        {
+            found = true;
+            break;
+        }
+    }
+
+    DPRINTF("Chessboard detection result 0: %d", (int)found);
+
+    // revert to old, slower, method if detection failed
+    if (!found && !is_plain)
+    {
+        if (flags & CALIB_CB_NORMALIZE_IMAGE)
+        {
+            img = img.clone();
+            equalizeHist(img, img);
+        }
+
+        Mat thresh_img;
+        prev_sqr_size = 0;
+
+        DPRINTF("Fallback to old algorithm");
+        const bool useAdaptive = flags & CALIB_CB_ADAPTIVE_THRESH;
+        if (!useAdaptive)
+        {
+            // empiric threshold level
+            // thresholding performed here and not inside the cycle to save processing time
+            double meanval = mean(img).val[0];
+            int thresh_level = std::max(cvRound(meanval - 10), 10);
+            threshold(img, thresh_img, thresh_level, 255, THRESH_BINARY);
+        }
+        //if flag CALIB_CB_ADAPTIVE_THRESH is not set it doesn't make sense to iterate over k
+        int max_k = useAdaptive ? 6 : 1;
+        Mat prev_thresh_img;
+        for (int k = 0; k < max_k && !found; k++)
+        {
+            int prev_block_size = -1;
+            for (int dilations = min_dilations; dilations <= max_dilations; dilations++)
+            {
+                // convert the input grayscale image to binary (black-n-white)
+                if (useAdaptive)
+                {
+                    int block_size = cvRound(prev_sqr_size == 0
+                                             ? std::min(img.cols, img.rows) * (k % 2 == 0 ? 0.2 : 0.1)
+                                             : prev_sqr_size * 2);
+                    block_size = block_size | 1;
+                    // convert to binary
+                    if (block_size != prev_block_size)
+                    {
+                        adaptiveThreshold( img, thresh_img, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, block_size, (k/2)*5 );
+                        dilate( thresh_img, thresh_img, Mat(), Point(-1, -1), dilations );
+                        thresh_img.copyTo(prev_thresh_img);
+                    }
+                    else if (dilations > 0)
+                    {
+                        dilate( prev_thresh_img, prev_thresh_img, Mat(), Point(-1, -1), 1 );
+                        prev_thresh_img.copyTo(thresh_img);
+                    }
+                    prev_block_size = block_size;
+                }
+                else
+                {
+                    if (dilations > 0)
+                        dilate( thresh_img, thresh_img, Mat(), Point(-1, -1), 1 );
+                }
+                SHOW("Old binarization", thresh_img);
+
+                // So we can find rectangles that go to the edge, we draw a white line around the image edge.
+                // Otherwise FindContours will miss those clipped rectangle contours.
+                // The border color will be the image mean, because otherwise we risk screwing up filters like cvSmooth()...
+                rectangle( thresh_img, Point(0,0), Point(thresh_img.cols-1, thresh_img.rows-1), Scalar(255,255,255), 3, LINE_8);
+
+                detector.reset();
+                detector.generateQuads(thresh_img, flags, dilations);
+                DPRINTF("Quad count: %d/%d", detector.all_quads_count, (pattern_size.width/2+1)*(pattern_size.height/2+1));
+                SHOW_QUADS("Old quads", thresh_img, &detector.all_quads[0], detector.all_quads_count);
+                if (detector.processQuads(out_corners, prev_sqr_size))
+                {
+                    found = 1;
+                    break;
+                }
+            }
+        }
+    }
+
+    DPRINTF("Chessboard detection result 1: %d", (int)found);
+
+    if (found)
+        found = detector.checkBoardMonotony(out_corners);
+
+    DPRINTF("Chessboard detection result 2: %d", (int)found);
+
+    // check that none of the found corners is too close to the image boundary
+    if (found)
+    {
+        const int BORDER = 8;
+        for (int k = 0; k < pattern_size.width*pattern_size.height; ++k)
+        {
+            if( out_corners[k].x <= BORDER || out_corners[k].x > img.cols - BORDER ||
+                out_corners[k].y <= BORDER || out_corners[k].y > img.rows - BORDER )
+            {
+                found = false;
+                break;
+            }
+        }
+    }
+
+    DPRINTF("Chessboard detection result 3: %d", (int)found);
+
+    if (found)
+    {
+        if ((pattern_size.height & 1) == 0 && (pattern_size.width & 1) == 0 )
+        {
+            int last_row = (pattern_size.height-1)*pattern_size.width;
+            double dy0 = out_corners[last_row].y - out_corners[0].y;
+            if (dy0 < 0)
+            {
+                int n = pattern_size.width*pattern_size.height;
+                for(int i = 0; i < n/2; i++ )
+                {
+                    std::swap(out_corners[i], out_corners[n-i-1]);
+                }
+            }
+        }
+        cornerSubPix(img, out_corners, Size(2, 2), Size(-1,-1),
+                         TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 15, 0.1));
+    }
+
+    Mat(out_corners).copyTo(corners_);
+    return found;
+}
+
+//
+// Checks that each board row and column is pretty much monotonous curve:
+// It analyzes each row and each column of the chessboard as following:
+//    for each corner c lying between end points in the same row/column it checks that
+//    the point projection to the line segment (a,b) is lying between projections
+//    of the neighbor corners in the same row/column.
+//
+// This function has been created as temporary workaround for the bug in current implementation
+// of cvFindChessboardCorners that produces absolutely unordered sets of corners.
+//
+bool ChessBoardDetector::checkBoardMonotony(const std::vector<Point2f>& corners)
+{
+    for (int k = 0; k < 2; ++k)
+    {
+        int max_i = (k == 0 ? pattern_size.height : pattern_size.width);
+        int max_j = (k == 0 ? pattern_size.width: pattern_size.height) - 1;
+        for (int i = 0; i < max_i; ++i)
+        {
+            Point2f a = k == 0 ? corners[i*pattern_size.width] : corners[i];
+            Point2f b = k == 0 ? corners[(i+1)*pattern_size.width-1]
+                                   : corners[(pattern_size.height-1)*pattern_size.width + i];
+            float dx0 = b.x - a.x, dy0 = b.y - a.y;
+            if (fabs(dx0) + fabs(dy0) < FLT_EPSILON)
+                return false;
+            float prevt = 0;
+            for (int j = 1; j < max_j; ++j)
+            {
+                Point2f c = k == 0 ? corners[i*pattern_size.width + j]
+                                       : corners[j*pattern_size.width + i];
+                float t = ((c.x - a.x)*dx0 + (c.y - a.y)*dy0)/(dx0*dx0 + dy0*dy0);
+                if (t < prevt || t > 1)
+                    return false;
+                prevt = t;
+            }
+        }
+    }
+    return true;
+}
+
+//
+// order a group of connected quads
+// order of corners:
+//   0 is top left
+//   clockwise from there
+// note: "top left" is nominal, depends on initial ordering of starting quad
+//   but all other quads are ordered consistently
+//
+// can change the number of quads in the group
+// can add quads, so we need to have quad/corner arrays passed in
+//
+int ChessBoardDetector::orderFoundConnectedQuads(std::vector<ChessBoardQuad*>& quads)
+{
+    const int max_quad_buf_size = (int)all_quads.size();
+    int quad_count = (int)quads.size();
+
+    std::stack<ChessBoardQuad*> stack;
+
+    // first find an interior quad
+    ChessBoardQuad *start = NULL;
+    for (int i = 0; i < quad_count; i++)
+    {
+        if (quads[i]->count == 4)
+        {
+            start = quads[i];
+            break;
+        }
+    }
+
+    if (start == NULL)
+        return 0;   // no 4-connected quad
+
+    // start with first one, assign rows/cols
+    int row_min = 0, col_min = 0, row_max=0, col_max = 0;
+
+    std::map<int, int> col_hist;
+    std::map<int, int> row_hist;
+
+    stack.push(start);
+    start->row = 0;
+    start->col = 0;
+    start->ordered = true;
+
+    // Recursively order the quads so that all position numbers (e.g.,
+    // 0,1,2,3) are in the at the same relative corner (e.g., lower right).
+
+    while (!stack.empty())
+    {
+        ChessBoardQuad* q = stack.top(); stack.pop(); CV_Assert(q);
+
+        int col = q->col;
+        int row = q->row;
+        col_hist[col]++;
+        row_hist[row]++;
+
+        // check min/max
+        if (row > row_max) row_max = row;
+        if (row < row_min) row_min = row;
+        if (col > col_max) col_max = col;
+        if (col < col_min) col_min = col;
+
+        for (int i = 0; i < 4; i++)
+        {
+            CV_DbgAssert(q);
+            ChessBoardQuad *neighbor = q->neighbors[i];
+            switch(i)   // adjust col, row for this quad
+            {           // start at top left, go clockwise
+            case 0:
+                row--; col--; break;
+            case 1:
+                col += 2; break;
+            case 2:
+                row += 2;   break;
+            case 3:
+                col -= 2; break;
+            }
+
+            // just do inside quads
+            if (neighbor && neighbor->ordered == false && neighbor->count == 4)
+            {
+                DPRINTF("col: %d  row: %d", col, row);
+                CV_Assert(q->corners[i]);
+                orderQuad(*neighbor, *(q->corners[i]), (i+2)&3); // set in order
+                neighbor->ordered = true;
+                neighbor->row = row;
+                neighbor->col = col;
+                stack.push(neighbor);
+            }
+        }
+    }
+
+#ifdef DEBUG_CHESSBOARD
+    for (int i = col_min; i <= col_max; i++)
+        DPRINTF("HIST[%d] = %d", i, col_hist[i]);
+#endif
+
+    // analyze inner quad structure
+    int w = pattern_size.width - 1;
+    int h = pattern_size.height - 1;
+    int drow = row_max - row_min + 1;
+    int dcol = col_max - col_min + 1;
+
+    // normalize pattern and found quad indices
+    if ((w > h && dcol < drow) ||
+        (w < h && drow < dcol))
+    {
+        h = pattern_size.width - 1;
+        w = pattern_size.height - 1;
+    }
+
+    DPRINTF("Size: %dx%d  Pattern: %dx%d", dcol, drow, w, h);
+
+    // check if there are enough inner quads
+    if (dcol < w || drow < h)   // found enough inner quads?
+    {
+        DPRINTF("Too few inner quad rows/cols");
+        return 0;   // no, return
+    }
+#ifdef ENABLE_TRIM_COL_ROW
+    // too many columns, not very common
+    if (dcol == w+1)    // too many, trim
+    {
+        DPRINTF("Trimming cols");
+        if (col_hist[col_max] > col_hist[col_min])
+        {
+            DPRINTF("Trimming left col");
+            trimCol(quads, col_min, -1);
+        }
+        else
+        {
+            DPRINTF("Trimming right col");
+            trimCol(quads, col_max, +1);
+        }
+    }
+
+    // too many rows, not very common
+    if (drow == h+1)    // too many, trim
+    {
+        DPRINTF("Trimming rows");
+        if (row_hist[row_max] > row_hist[row_min])
+        {
+            DPRINTF("Trimming top row");
+            trimRow(quads, row_min, -1);
+        }
+        else
+        {
+            DPRINTF("Trimming bottom row");
+            trimRow(quads, row_max, +1);
+        }
+    }
+
+    quad_count = (int)quads.size(); // update after icvTrimCol/icvTrimRow
+#endif
+
+    // check edges of inner quads
+    // if there is an outer quad missing, fill it in
+    // first order all inner quads
+    int found = 0;
+    for (int i=0; i < quad_count; ++i)
+    {
+        ChessBoardQuad& q = *quads[i];
+        if (q.count != 4)
+            continue;
+
+        {   // ok, look at neighbors
+            int col = q.col;
+            int row = q.row;
+            for (int j = 0; j < 4; j++)
+            {
+                switch(j)   // adjust col, row for this quad
+                {           // start at top left, go clockwise
+                case 0:
+                    row--; col--; break;
+                case 1:
+                    col += 2; break;
+                case 2:
+                    row += 2;   break;
+                case 3:
+                    col -= 2; break;
+                }
+                ChessBoardQuad *neighbor = q.neighbors[j];
+                if (neighbor && !neighbor->ordered && // is it an inner quad?
+                    col <= col_max && col >= col_min &&
+                    row <= row_max && row >= row_min)
+                {
+                    // if so, set in order
+                    DPRINTF("Adding inner: col: %d  row: %d", col, row);
+                    found++;
+                    CV_Assert(q.corners[j]);
+                    orderQuad(*neighbor, *q.corners[j], (j+2)&3);
+                    neighbor->ordered = true;
+                    neighbor->row = row;
+                    neighbor->col = col;
+                }
+            }
+        }
+    }
+
+    // if we have found inner quads, add corresponding outer quads,
+    //   which are missing
+    if (found > 0)
+    {
+        DPRINTF("Found %d inner quads not connected to outer quads, repairing", found);
+        for (int i = 0; i < quad_count && all_quads_count < max_quad_buf_size; i++)
+        {
+            ChessBoardQuad& q = *quads[i];
+            if (q.count < 4 && q.ordered)
+            {
+                int added = addOuterQuad(q, quads);
+                quad_count += added;
+            }
+        }
+
+        if (all_quads_count >= max_quad_buf_size)
+            return 0;
+    }
+
+
+    // final trimming of outer quads
+    if (dcol == w && drow == h) // found correct inner quads
+    {
+        DPRINTF("Inner bounds ok, check outer quads");
+        for (int i = quad_count - 1; i >= 0; i--) // eliminate any quad not connected to an ordered quad
+        {
+            ChessBoardQuad& q = *quads[i];
+            if (q.ordered == false)
+            {
+                bool outer = false;
+                for (int j=0; j<4; j++) // any neighbors that are ordered?
+                {
+                    if (q.neighbors[j] && q.neighbors[j]->ordered)
+                        outer = true;
+                }
+                if (!outer) // not an outer quad, eliminate
+                {
+                    DPRINTF("Removing quad %d", i);
+                    removeQuadFromGroup(quads, q);
+                }
+            }
+
+        }
+        return (int)quads.size();
+    }
+
+    return 0;
+}
+
+
+// add an outer quad
+// looks for the neighbor of <quad> that isn't present,
+//   tries to add it in.
+// <quad> is ordered
+int ChessBoardDetector::addOuterQuad(ChessBoardQuad& quad, std::vector<ChessBoardQuad*>& quads)
+{
+    int added = 0;
+    int max_quad_buf_size = (int)all_quads.size();
+
+    for (int i = 0; i < 4 && all_quads_count < max_quad_buf_size; i++) // find no-neighbor corners
+    {
+        if (!quad.neighbors[i])    // ok, create and add neighbor
+        {
+            int j = (i+2)&3;
+            DPRINTF("Adding quad as neighbor 2");
+            int q_index = all_quads_count++;
+            ChessBoardQuad& q = all_quads[q_index];
+            q = ChessBoardQuad(0);
+            added++;
+            quads.push_back(&q);
+
+            // set neighbor and group id
+            quad.neighbors[i] = &q;
+            quad.count += 1;
+            q.neighbors[j] = &quad;
+            q.group_idx = quad.group_idx;
+            q.count = 1;   // number of neighbors
+            q.ordered = false;
+            q.edge_sqr_len = quad.edge_sqr_len;
+
+            // make corners of new quad
+            // same as neighbor quad, but offset
+            const Point2f pt_offset = quad.corners[i]->pt - quad.corners[j]->pt;
+            for (int k = 0; k < 4; k++)
+            {
+                ChessBoardCorner& corner = (ChessBoardCorner&)all_corners[q_index * 4 + k];
+                const Point2f& pt = quad.corners[k]->pt;
+                corner = ChessBoardCorner(pt);
+                q.corners[k] = &corner;
+                corner.pt += pt_offset;
+            }
+            // have to set exact corner
+            q.corners[j] = quad.corners[i];
+
+            // set row and col for next step check
+            switch (i)
+            {
+            case 0:
+                q.col = quad.col - 1; q.row = quad.row - 1; break;
+            case 1:
+                q.col = quad.col + 1; q.row = quad.row - 1; break;
+            case 2:
+                q.col = quad.col + 1; q.row = quad.row - 1; break;
+            case 3:
+                q.col = quad.col - 1; q.row = quad.row + 1; break;
+            }
+
+            // now find other neighbor and add it, if possible
+            for (int k = 1; k <= 3; k += 2)
+            {
+                int next_i = (i + k) % 4;
+                int prev_i = (i + k + 2) % 4;
+                ChessBoardQuad* quad_prev = quad.neighbors[prev_i];
+                if (quad_prev &&
+                    quad_prev->ordered &&
+                    quad_prev->neighbors[i] &&
+                    quad_prev->neighbors[i]->ordered &&
+                    std::abs(quad_prev->neighbors[i]->col - q.col) == 1 &&
+                    std::abs(quad_prev->neighbors[i]->row - q.row) == 1)
+                {
+                    ChessBoardQuad* qn = quad_prev->neighbors[i];
+                    q.count = 2;
+                    q.neighbors[prev_i] = qn;
+                    qn->neighbors[next_i] = &q;
+                    qn->count += 1;
+                    // have to set exact corner
+                    q.corners[prev_i] = qn->corners[next_i];
+                }
+            }
+        }
+    }
+    return added;
+}
+
+
+// trimming routines
+#ifdef ENABLE_TRIM_COL_ROW
+void ChessBoardDetector::trimCol(std::vector<ChessBoardQuad*>& quads, int col, int dir)
+{
+    std::vector<ChessBoardQuad*> quads_(quads);
+    // find the right quad(s)
+    for (size_t i = 0; i < quads_.size(); ++i)
+    {
+        ChessBoardQuad& q = *quads_[i];
+#ifdef DEBUG_CHESSBOARD
+        if (q.ordered)
+            DPRINTF("i: %d  index: %d  cur: %d", (int)i, col, q.col);
+#endif
+        if (q.ordered && q.col == col)
+        {
+            if (dir == 1)
+            {
+                if (q.neighbors[1])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[1]);
+                }
+                if (q.neighbors[2])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[2]);
+                }
+            }
+            else
+            {
+                if (q.neighbors[0])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[0]);
+                }
+                if (q.neighbors[3])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[3]);
+                }
+            }
+        }
+    }
+}
+
+void ChessBoardDetector::trimRow(std::vector<ChessBoardQuad*>& quads, int row, int dir)
+{
+    std::vector<ChessBoardQuad*> quads_(quads);
+    // find the right quad(s)
+    for (size_t i = 0; i < quads_.size(); ++i)
+    {
+        ChessBoardQuad& q = *quads_[i];
+#ifdef DEBUG_CHESSBOARD
+        if (q.ordered)
+            DPRINTF("i: %d  index: %d  cur: %d", (int)i, row, q.row);
+#endif
+        if (q.ordered && q.row == row)
+        {
+            if (dir == 1)   // remove from bottom
+            {
+                if (q.neighbors[2])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[2]);
+                }
+                if (q.neighbors[3])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[3]);
+                }
+            }
+            else    // remove from top
+            {
+                if (q.neighbors[0])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[0]);
+                }
+                if (q.neighbors[1])
+                {
+                    removeQuadFromGroup(quads, *q.neighbors[1]);
+                }
+            }
+
+        }
+    }
+}
+#endif
+
+//
+// remove quad from quad group
+//
+void ChessBoardDetector::removeQuadFromGroup(std::vector<ChessBoardQuad*>& quads, ChessBoardQuad& q0)
+{
+    const int count = (int)quads.size();
+
+    int self_idx = -1;
+
+    // remove any references to this quad as a neighbor
+    for (int i = 0; i < count; ++i)
+    {
+        ChessBoardQuad* q = quads[i];
+        if (q == &q0)
+            self_idx = i;
+        for (int j = 0; j < 4; j++)
+        {
+            if (q->neighbors[j] == &q0)
+            {
+                q->neighbors[j] = NULL;
+                q->count--;
+                for (int k = 0; k < 4; ++k)
+                {
+                    if (q0.neighbors[k] == q)
+                    {
+                        q0.neighbors[k] = 0;
+                        q0.count--;
+#ifndef _DEBUG
+                        break;
+#endif
+                    }
+                }
+                break;
+            }
+        }
+    }
+    CV_Assert(self_idx >= 0); // item itself should be found
+
+    // remove the quad
+    if (self_idx != count-1)
+        quads[self_idx] = quads[count-1];
+    quads.resize(count - 1);
+}
+
+//
+// put quad into correct order, where <corner> has value <common>
+//
+void ChessBoardDetector::orderQuad(ChessBoardQuad& quad, ChessBoardCorner& corner, int common)
+{
+    CV_DbgAssert(common >= 0 && common <= 3);
+
+    // find the corner
+    int tc = 0;;
+    for (; tc < 4; ++tc)
+        if (quad.corners[tc]->pt == corner.pt)
+            break;
+
+    // set corner order
+    // shift
+    while (tc != common)
+    {
+        // shift by one
+        ChessBoardCorner *tempc = quad.corners[3];
+        ChessBoardQuad *tempq = quad.neighbors[3];
+        for (int i = 3; i > 0; --i)
+        {
+            quad.corners[i] = quad.corners[i-1];
+            quad.neighbors[i] = quad.neighbors[i-1];
+        }
+        quad.corners[0] = tempc;
+        quad.neighbors[0] = tempq;
+        tc = (tc + 1) & 3;
+    }
+}
+
+
+// if we found too many connect quads, remove those which probably do not belong.
+int ChessBoardDetector::cleanFoundConnectedQuads(std::vector<ChessBoardQuad*>& quad_group)
+{
+    // number of quads this pattern should contain
+    int count = ((pattern_size.width + 1)*(pattern_size.height + 1) + 1)/2;
+
+    // if we have more quadrangles than we should,
+    // try to eliminate duplicates or ones which don't belong to the pattern rectangle...
+    int quad_count = (int)quad_group.size();
+    if (quad_count <= count)
+        return quad_count;
+    CV_DbgAssert(quad_count > 0);
+
+    // create an array of quadrangle centers
+    AutoBuffer<Point2f> centers(quad_count);
+
+    Point2f center;
+    for (int i = 0; i < quad_count; ++i)
+    {
+        ChessBoardQuad* q = quad_group[i];
+
+        const Point2f ci = (
+                q->corners[0]->pt +
+                q->corners[1]->pt +
+                q->corners[2]->pt +
+                q->corners[3]->pt
+            ) * 0.25f;
+
+        centers[i] = ci;
+        center += ci;
+    }
+    center *= (1.0f / quad_count);
+
+    // If we still have more quadrangles than we should,
+    // we try to eliminate bad ones based on minimizing the bounding box.
+    // We iteratively remove the point which reduces the size of
+    // the bounding box of the blobs the most
+    // (since we want the rectangle to be as small as possible)
+    // remove the quadrangle that causes the biggest reduction
+    // in pattern size until we have the correct number
+    while (quad_count > count)
+    {
+        double min_box_area = DBL_MAX;
+        int min_box_area_index = -1;
+
+        // For each point, calculate box area without that point
+        for (int skip = 0; skip < quad_count; ++skip)
+        {
+            // get bounding rectangle
+            Point2f temp = centers[skip]; // temporarily make index 'skip' the same as
+            centers[skip] = center;            // pattern center (so it is not counted for convex hull)
+            std::vector<Point2f> hull;
+            Mat points(1, quad_count, CV_32FC2, &centers[0]);
+            convexHull(points, hull, true);
+            centers[skip] = temp;
+            double hull_area = contourArea(hull, false);
+
+            // remember smallest box area
+            if (hull_area < min_box_area)
+            {
+                min_box_area = hull_area;
+                min_box_area_index = skip;
+            }
+        }
+
+        ChessBoardQuad *q0 = quad_group[min_box_area_index];
+
+        // remove any references to this quad as a neighbor
+        for (int i = 0; i < quad_count; ++i)
+        {
+            ChessBoardQuad *q = quad_group[i];
+            CV_DbgAssert(q);
+            for (int j = 0; j < 4; ++j)
+            {
+                if (q->neighbors[j] == q0)
+                {
+                    q->neighbors[j] = 0;
+                    q->count--;
+                    for (int k = 0; k < 4; ++k)
+                    {
+                        if (q0->neighbors[k] == q)
+                        {
+                            q0->neighbors[k] = 0;
+                            q0->count--;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        // remove the quad
+        quad_count--;
+        quad_group[min_box_area_index] = quad_group[quad_count];
+        centers[min_box_area_index] = centers[quad_count];
+    }
+    quad_group.resize(quad_count);
+
+    return quad_count;
+}
+
+
+
+void ChessBoardDetector::findConnectedQuads(std::vector<ChessBoardQuad*>& out_group, int group_idx)
+{
+    out_group.clear();
+
+    std::stack<ChessBoardQuad*> stack;
+
+    int i = 0;
+    for (; i < all_quads_count; i++)
+    {
+        ChessBoardQuad* q = (ChessBoardQuad*)&all_quads[i];
+
+        // Scan the array for a first unlabeled quad
+        if (q->count <= 0 || q->group_idx >= 0) continue;
+
+        // Recursively find a group of connected quads starting from the seed all_quads[i]
+        stack.push(q);
+        out_group.push_back(q);
+        q->group_idx = group_idx;
+        q->ordered = false;
+
+        while (!stack.empty())
+        {
+            q = stack.top(); CV_Assert(q);
+            stack.pop();
+            for (int k = 0; k < 4; k++ )
+            {
+                CV_DbgAssert(q);
+                ChessBoardQuad *neighbor = q->neighbors[k];
+                if (neighbor && neighbor->count > 0 && neighbor->group_idx < 0 )
+                {
+                    stack.push(neighbor);
+                    out_group.push_back(neighbor);
+                    neighbor->group_idx = group_idx;
+                    neighbor->ordered = false;
+                }
+            }
+        }
+        break;
+    }
+}
+
+
+int ChessBoardDetector::checkQuadGroup(const std::vector<ChessBoardQuad*>& quad_group, std::vector<ChessBoardCorner*>& out_corners)
+{
+    const int ROW1 = 1000000;
+    const int ROW2 = 2000000;
+    const int ROW_ = 3000000;
+
+    int quad_count = (int)quad_group.size();
+
+    std::vector<ChessBoardCorner*> corners(quad_count*4);
+    int corner_count = 0;
+    int result = 0;
+
+    int width = 0, height = 0;
+    int hist[5] = {0,0,0,0,0};
+    //ChessBoardCorner* first = 0, *first2 = 0, *right, *cur, *below, *c;
+
+    // build dual graph, which vertices are internal quad corners
+    // and two vertices are connected iff they lie on the same quad edge
+    for (int i = 0; i < quad_count; ++i)
+    {
+        ChessBoardQuad* q = quad_group[i];
+        /*CvScalar color = q->count == 0 ? cvScalar(0,255,255) :
+                         q->count == 1 ? cvScalar(0,0,255) :
+                         q->count == 2 ? cvScalar(0,255,0) :
+                         q->count == 3 ? cvScalar(255,255,0) :
+                                         cvScalar(255,0,0);*/
+
+        for (int j = 0; j < 4; ++j)
+        {
+            if (q->neighbors[j])
+            {
+                int next_j = (j + 1) & 3;
+                ChessBoardCorner *a = q->corners[j], *b = q->corners[next_j];
+                // mark internal corners that belong to:
+                //   - a quad with a single neighbor - with ROW1,
+                //   - a quad with two neighbors     - with ROW2
+                // make the rest of internal corners with ROW_
+                int row_flag = q->count == 1 ? ROW1 : q->count == 2 ? ROW2 : ROW_;
+
+                if (a->row == 0)
+                {
+                    corners[corner_count++] = a;
+                    a->row = row_flag;
+                }
+                else if (a->row > row_flag)
+                {
+                    a->row = row_flag;
+                }
+
+                if (q->neighbors[next_j])
+                {
+                    if (a->count >= 4 || b->count >= 4)
+                        goto finalize;
+                    for (int k = 0; k < 4; ++k)
+                    {
+                        if (a->neighbors[k] == b)
+                            goto finalize;
+                        if (b->neighbors[k] == a)
+                            goto finalize;
+                    }
+                    a->neighbors[a->count++] = b;
+                    b->neighbors[b->count++] = a;
+                }
+            }
+        }
+    }
+
+    if (corner_count != pattern_size.width*pattern_size.height)
+        goto finalize;
+
+{
+    ChessBoardCorner* first = NULL, *first2 = NULL;
+    for (int i = 0; i < corner_count; ++i)
+    {
+        int n = corners[i]->count;
+        CV_DbgAssert(0 <= n && n <= 4);
+        hist[n]++;
+        if (!first && n == 2)
+        {
+            if (corners[i]->row == ROW1)
+                first = corners[i];
+            else if (!first2 && corners[i]->row == ROW2)
+                first2 = corners[i];
+        }
+    }
+
+    // start with a corner that belongs to a quad with a single neighbor.
+    // if we do not have such, start with a corner of a quad with two neighbors.
+    if( !first )
+        first = first2;
+
+    if( !first || hist[0] != 0 || hist[1] != 0 || hist[2] != 4 ||
+        hist[3] != (pattern_size.width + pattern_size.height)*2 - 8 )
+        goto finalize;
+
+    ChessBoardCorner* cur = first;
+    ChessBoardCorner* right = NULL;
+    ChessBoardCorner* below = NULL;
+    out_corners.clear();
+    out_corners.push_back(cur);
+
+    for (int k = 0; k < 4; ++k)
+    {
+        ChessBoardCorner* c = cur->neighbors[k];
+        if (c)
+        {
+            if (!right)
+                right = c;
+            else if (!below)
+                below = c;
+        }
+    }
+
+    if( !right || (right->count != 2 && right->count != 3) ||
+        !below || (below->count != 2 && below->count != 3) )
+        goto finalize;
+
+    cur->row = 0;
+
+    first = below; // remember the first corner in the next row
+
+    // find and store the first row (or column)
+    while( 1 )
+    {
+        right->row = 0;
+        out_corners.push_back(right);
+        if( right->count == 2 )
+            break;
+        if( right->count != 3 || (int)out_corners.size() >= std::max(pattern_size.width,pattern_size.height) )
+            goto finalize;
+        cur = right;
+        for (int k = 0; k < 4; ++k)
+        {
+            ChessBoardCorner* c = cur->neighbors[k];
+            if (c && c->row > 0)
+            {
+                int kk = 0;
+                for (; kk < 4; ++kk)
+                {
+                    if (c->neighbors[kk] == below)
+                        break;
+                }
+                if (kk < 4)
+                    below = c;
+                else
+                    right = c;
+            }
+        }
+    }
+
+    width = (int)out_corners.size();
+    if (width == pattern_size.width)
+        height = pattern_size.height;
+    else if (width == pattern_size.height)
+        height = pattern_size.width;
+    else
+        goto finalize;
+
+    // find and store all the other rows
+    for (int i = 1; ; ++i)
+    {
+        if( !first )
+            break;
+        cur = first;
+        first = 0;
+        int j = 0;
+        for (; ; ++j)
+        {
+            cur->row = i;
+            out_corners.push_back(cur);
+            if (cur->count == 2 + (i < height-1) && j > 0)
+                break;
+
+            right = 0;
+
+            // find a neighbor that has not been processed yet
+            // and that has a neighbor from the previous row
+            for (int k = 0; k < 4; ++k)
+            {
+                ChessBoardCorner* c = cur->neighbors[k];
+                if (c && c->row > i)
+                {
+                    int kk = 0;
+                    for (; kk < 4; ++kk)
+                    {
+                        if (c->neighbors[kk] && c->neighbors[kk]->row == i-1)
+                            break;
+                    }
+                    if(kk < 4)
+                    {
+                        right = c;
+                        if (j > 0)
+                            break;
+                    }
+                    else if (j == 0)
+                        first = c;
+                }
+            }
+            if (!right)
+                goto finalize;
+            cur = right;
+        }
+
+        if (j != width - 1)
+            goto finalize;
+    }
+
+    if ((int)out_corners.size() != corner_count)
+        goto finalize;
+
+    // check if we need to transpose the board
+    if (width != pattern_size.width)
+    {
+        std::swap(width, height);
+
+        std::vector<ChessBoardCorner*> tmp(out_corners);
+        for (int i = 0; i < height; ++i)
+            for (int j = 0; j < width; ++j)
+                out_corners[i*width + j] = tmp[j*height + i];
+    }
+
+    // check if we need to revert the order in each row
+    {
+        Point2f p0 = out_corners[0]->pt,
+                    p1 = out_corners[pattern_size.width-1]->pt,
+                    p2 = out_corners[pattern_size.width]->pt;
+        if( (p1.x - p0.x)*(p2.y - p1.y) - (p1.y - p0.y)*(p2.x - p1.x) < 0 )
+        {
+            if (width % 2 == 0)
+            {
+                for (int i = 0; i < height; ++i)
+                    for (int j = 0; j < width/2; ++j)
+                        std::swap(out_corners[i*width+j], out_corners[i*width+width-j-1]);
+            }
+            else
+            {
+                for (int j = 0; j < width; ++j)
+                    for (int i = 0; i < height/2; ++i)
+                        std::swap(out_corners[i*width+j], out_corners[(height - i - 1)*width+j]);
+            }
+        }
+    }
+
+    result = corner_count;
+}
+
+finalize:
+    if (result <= 0)
+    {
+        corner_count = std::min(corner_count, pattern_size.area());
+        out_corners.resize(corner_count);
+        for (int i = 0; i < corner_count; i++)
+            out_corners[i] = corners[i];
+
+        result = -corner_count;
+
+        if (result == -pattern_size.area())
+            result = -result;
+    }
+
+    return result;
+}
+
+
+
+void ChessBoardDetector::findQuadNeighbors()
+{
+    NeighborsFinder neighborsFinder(*this);
+    for (int idx = 0; idx < all_quads_count; idx++)
+    {
+        ChessBoardQuad& cur_quad = (ChessBoardQuad&)all_quads[idx];
+
+        // choose the points of the current quadrangle that are close to
+        // some points of the other quadrangles
+        // (it can happen for split corners (due to dilation) of the
+        // checker board). Search only in other quadrangles!
+
+        // for each corner of this quadrangle
+        for (int i = 0; i < 4; i++)
+        {
+            if (cur_quad.neighbors[i])
+                continue;
+
+            const cv::Point2f pt = neighborsFinder.all_quads_pts[(idx << 2) + i];
+
+            float min_sqr_dist = FLT_MAX;
+
+            int closest_quad_idx = -1;
+            int closest_corner_idx = -1;
+
+            float sqr_radius = cur_quad.edge_sqr_len * neighborsFinder.thresh_sqr_scale + 1;
+
+            cv::Point2f closest_corner_pt;
+
+            bool found = neighborsFinder.findCornerNeighbor(
+                idx,
+                i,
+                pt,
+                min_sqr_dist,
+                sqr_radius,
+                closest_quad_idx,
+                closest_corner_idx,
+                closest_corner_pt);
+
+            if (!found)
+                continue;
+
+            sqr_radius = min_sqr_dist + 1;
+            min_sqr_dist = FLT_MAX;
+
+            int closest_closest_quad_idx = -1;
+            int closest_closest_corner_idx = -1;
+
+            cv::Point2f closest_closest_corner_pt;
+
+            found = neighborsFinder.findCornerNeighbor(
+                closest_quad_idx,
+                closest_corner_idx,
+                closest_corner_pt,
+                min_sqr_dist,
+                sqr_radius,
+                closest_closest_quad_idx,
+                closest_closest_corner_idx,
+                closest_closest_corner_pt);
+
+            if (!found)
+                continue;
+
+            if (closest_closest_quad_idx != idx ||
+                closest_closest_corner_idx != i ||
+                closest_closest_corner_pt != pt)
+                continue;
+
+            ChessBoardQuad* closest_quad = &all_quads[closest_quad_idx];
+            ChessBoardCorner& closest_corner = *closest_quad->corners[closest_corner_idx];
+            closest_corner.pt = (pt + closest_corner_pt) * 0.5f;
+
+            // We've found one more corner - remember it
+            cur_quad.count++;
+            cur_quad.neighbors[i] = closest_quad;
+            cur_quad.corners[i] = &closest_corner;
+
+            closest_quad->count++;
+            closest_quad->neighbors[closest_corner_idx] = &cur_quad;
+        }
+    }
+}
+
+
+// returns corners in clockwise order
+// corners don't necessarily start at same position on quad (e.g.,
+//   top left corner)
+void ChessBoardDetector::generateQuads(const Mat& image_, int flags, int dilations)
+{
+    binarized_image = image_;  // save for debug purposes
+
+    int quad_count = 0;
+
+    all_quads.deallocate();
+    all_corners.deallocate();
+
+    // empiric bound for minimal allowed area for squares
+    const int min_area = 25; //cvRound( image->cols * image->rows * .03 * 0.01 * 0.92 );
+
+    bool filterQuads = (flags & CALIB_CB_FILTER_QUADS) != 0;
+
+    std::vector<std::vector<Point> > contours;
+    std::vector<Vec4i> hierarchy;
+
+    findContours(image_, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
+
+    if (contours.empty())
+    {
+        CV_LOG_DEBUG(NULL, "calib(chessboard): findContours() returns no contours");
+        return;
+    }
+
+    std::vector<int> contour_child_counter(contours.size(), 0);
+    int boardIdx = -1;
+
+    std::vector<QuadCountour> contour_quads;
+
+    for (int idx = (int)(contours.size() - 1); idx >= 0; --idx)
+    {
+        int parentIdx = hierarchy[idx][3];
+        if (hierarchy[idx][2] != -1 || parentIdx == -1)  // holes only (no child contours and with parent)
+            continue;
+        const std::vector<Point>& contour = contours[idx];
+
+        Rect contour_rect = boundingRect(contour);
+        if (contour_rect.area() < min_area)
+            continue;
+
+        std::vector<Point> approx_contour = contour;
+
+        const int min_approx_level = 1, max_approx_level = MAX_CONTOUR_APPROX;
+        for (int approx_level = min_approx_level; approx_contour.size() > 4 && approx_level <= max_approx_level; approx_level++ )
+        {
+            approxPolyDP(approx_contour, approx_contour, (float)approx_level, true);
+        }
+
+        // reject non-quadrangles
+        if (approx_contour.size() != 4)
+            continue;
+        if (!isContourConvex(approx_contour))
+            continue;
+
+        Point pt[4];
+        for (int i = 0; i < 4; ++i)
+            pt[i] = approx_contour[i];
+        CV_LOG_VERBOSE(NULL, 9, "... contours(" << contour_quads.size() << " added):" << pt[0] << " " << pt[1] << " " << pt[2] << " " << pt[3]);
+
+        if (filterQuads)
+        {
+            double p = arcLength(approx_contour, true);
+            double area = contourArea(approx_contour, false);
+
+            double d1 = sqrt(normL2Sqr<double>(pt[0] - pt[2]));
+            double d2 = sqrt(normL2Sqr<double>(pt[1] - pt[3]));
+
+            // philipg.  Only accept those quadrangles which are more square
+            // than rectangular and which are big enough
+            double d3 = sqrt(normL2Sqr<double>(pt[0] - pt[1]));
+            double d4 = sqrt(normL2Sqr<double>(pt[1] - pt[2]));
+            if (!(d3*4 > d4 && d4*4 > d3 && d3*d4 < area*1.5 && area > min_area &&
+                d1 >= 0.15 * p && d2 >= 0.15 * p))
+                continue;
+        }
+
+        contour_child_counter[parentIdx]++;
+        if (boardIdx != parentIdx && (boardIdx < 0 || contour_child_counter[boardIdx] < contour_child_counter[parentIdx]))
+            boardIdx = parentIdx;
+
+        contour_quads.emplace_back(pt, parentIdx);
+    }
+
+    size_t total = contour_quads.size();
+    size_t max_quad_buf_size = std::max((size_t)2, total * 3);
+    all_quads.allocate(max_quad_buf_size);
+    all_corners.allocate(max_quad_buf_size * 4);
+
+    // Create array of quads structures
+    for (size_t idx = 0; idx < total; ++idx)
+    {
+        QuadCountour& qc = contour_quads[idx];
+        if (filterQuads && qc.parent_contour != boardIdx)
+            continue;
+
+        int quad_idx = quad_count++;
+        ChessBoardQuad& q = all_quads[quad_idx];
+
+        // reset group ID
+        q = ChessBoardQuad();
+        for (int i = 0; i < 4; ++i)
+        {
+            Point2f pt(qc.pt[i]);
+            ChessBoardCorner& corner = all_corners[quad_idx * 4 + i];
+
+            corner = ChessBoardCorner(pt);
+            q.corners[i] = &corner;
+        }
+        q.edge_sqr_len = FLT_MAX;
+        for (int i = 0; i < 4; ++i)
+        {
+            float sqr_d = normL2Sqr<float>(q.corners[i]->pt - q.corners[(i+1)&3]->pt);
+            q.edge_sqr_len = std::min(q.edge_sqr_len, sqr_d);
+        }
+
+        const int edge_len_compensation = 2 * dilations;
+        q.edge_sqr_len += 2 * sqrt(q.edge_sqr_len) * edge_len_compensation + edge_len_compensation * edge_len_compensation;
+    }
+
+    all_quads_count = quad_count;
+
+    CV_LOG_VERBOSE(NULL, 3, "Total quad contours: " << total);
+    CV_LOG_VERBOSE(NULL, 3, "max_quad_buf_size=" << max_quad_buf_size);
+    CV_LOG_VERBOSE(NULL, 3, "filtered quad_count=" << quad_count);
+}
+
+bool ChessBoardDetector::processQuads(std::vector<Point2f>& out_corners, int &prev_sqr_size)
+{
+    out_corners.resize(0);
+    if (all_quads_count <= 0)
+        return false;
+
+    size_t max_quad_buf_size = all_quads.size();
+
+    // Find quad's neighbors
+    findQuadNeighbors();
+
+    // allocate extra for adding in orderFoundQuads
+    std::vector<ChessBoardQuad*> quad_group;
+    std::vector<ChessBoardCorner*> corner_group; corner_group.reserve(max_quad_buf_size * 4);
+
+    for (int group_idx = 0; ; group_idx++)
+    {
+        findConnectedQuads(quad_group, group_idx);
+        if (quad_group.empty())
+            break;
+
+        int count = (int)quad_group.size();
+
+        // order the quad corners globally
+        // maybe delete or add some
+        DPRINTF("Starting ordering of inner quads (%d)", count);
+        count = orderFoundConnectedQuads(quad_group);
+        DPRINTF("Finished ordering of inner quads (%d)", count);
+
+        if (count == 0)
+            continue;       // haven't found inner quads
+
+        // If count is more than it should be, this will remove those quads
+        // which cause maximum deviation from a nice square pattern.
+        count = cleanFoundConnectedQuads(quad_group);
+        DPRINTF("Connected group: %d, count: %d", group_idx, count);
+
+        count = checkQuadGroup(quad_group, corner_group);
+        DPRINTF("Connected group: %d, count: %d", group_idx, count);
+
+        int n = count > 0 ? pattern_size.width * pattern_size.height : -count;
+        n = std::min(n, pattern_size.width * pattern_size.height);
+        float sum_dist = 0;
+        int total = 0;
+
+        for(int i = 0; i < n; i++ )
+        {
+            int ni = 0;
+            float sum = corner_group[i]->sumDist(ni);
+            sum_dist += sum;
+            total += ni;
+        }
+        prev_sqr_size = cvRound(sum_dist/std::max(total, 1));
+
+        if (count > 0 || (-count > (int)out_corners.size()))
+        {
+            // copy corners to output array
+            out_corners.clear();
+            out_corners.reserve(n);
+            for (int i = 0; i < n; ++i)
+                out_corners.push_back(corner_group[i]->pt);
+
+            if (count == pattern_size.width*pattern_size.height
+                    && checkBoardMonotony(out_corners))
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+
+void drawChessboardCorners( InputOutputArray image, Size patternSize,
+                                InputArray _corners,
+                                bool patternWasFound )
+{
+    CV_INSTRUMENT_REGION();
+
+    int type = image.type();
+    int cn = CV_MAT_CN(type);
+    CV_CheckType(type, cn == 1 || cn == 3 || cn == 4,
+            "Number of channels must be 1, 3 or 4" );
+
+    int depth = CV_MAT_DEPTH(type);
+    CV_CheckType(type, depth == CV_8U || depth == CV_16U || depth == CV_32F,
+            "Only 8-bit, 16-bit or floating-point 32-bit images are supported");
+
+    if (_corners.empty())
+        return;
+    Mat corners = _corners.getMat();
+    const Point2f* corners_data = corners.ptr<Point2f>(0);
+    CV_DbgAssert(corners_data);
+    int nelems = corners.checkVector(2, CV_32F, true);
+    CV_Assert(nelems >= 0);
+
+    const int shift = 0;
+    const int radius = 4;
+    const int r = radius*(1 << shift);
+
+    double scale = 1;
+    switch (depth)
+    {
+    case CV_8U:
+        scale = 1;
+        break;
+    case CV_16U:
+        scale = 256;
+        break;
+    case CV_32F:
+        scale = 1./255;
+        break;
+    }
+
+    int line_type = (type == CV_8UC1 || type == CV_8UC3) ? LINE_AA : LINE_8;
+
+    if (!patternWasFound)
+    {
+        Scalar color(0,0,255,0);
+        if (cn == 1)
+            color = Scalar::all(200);
+        color *= scale;
+
+        for (int i = 0; i < nelems; i++ )
+        {
+            Point2i pt(
+                    cvRound(corners_data[i].x*(1 << shift)),
+                    cvRound(corners_data[i].y*(1 << shift))
+            );
+            line(image, Point(pt.x - r, pt.y - r), Point( pt.x + r, pt.y + r), color, 1, line_type, shift);
+            line(image, Point(pt.x - r, pt.y + r), Point( pt.x + r, pt.y - r), color, 1, line_type, shift);
+            circle(image, pt, r+(1<<shift), color, 1, line_type, shift);
+        }
+    }
+    else
+    {
+        const int line_max = 7;
+        static const int line_colors[line_max][4] =
+        {
+            {0,0,255,0},
+            {0,128,255,0},
+            {0,200,200,0},
+            {0,255,0,0},
+            {200,200,0,0},
+            {255,0,0,0},
+            {255,0,255,0}
+        };
+
+        Point2i prev_pt;
+        for (int y = 0, i = 0; y < patternSize.height; y++)
+        {
+            const int* line_color = &line_colors[y % line_max][0];
+            Scalar color(line_color[0], line_color[1], line_color[2], line_color[3]);
+            if (cn == 1)
+                color = Scalar::all(200);
+            color *= scale;
+
+            for (int x = 0; x < patternSize.width; x++, i++)
+            {
+                Point2i pt(
+                        cvRound(corners_data[i].x*(1 << shift)),
+                        cvRound(corners_data[i].y*(1 << shift))
+                );
+
+                if (i != 0)
+                    line(image, prev_pt, pt, color, 1, line_type, shift);
+
+                line(image, Point(pt.x - r, pt.y - r), Point( pt.x + r, pt.y + r), color, 1, line_type, shift);
+                line(image, Point(pt.x - r, pt.y + r), Point( pt.x + r, pt.y - r), color, 1, line_type, shift);
+                circle(image, pt, r+(1<<shift), color, 1, line_type, shift);
+                prev_pt = pt;
+            }
+        }
+    }
+}
+
+bool findCirclesGrid( InputArray _image, Size patternSize,
+                          OutputArray _centers, int flags, const Ptr<FeatureDetector> &blobDetector,
+                          const CirclesGridFinderParameters& parameters_)
+{
+    CV_INSTRUMENT_REGION();
+
+    CirclesGridFinderParameters parameters = parameters_; // parameters.gridType is amended below
+
+    bool isAsymmetricGrid = (flags & CALIB_CB_ASYMMETRIC_GRID) ? true : false;
+    bool isSymmetricGrid  = (flags & CALIB_CB_SYMMETRIC_GRID ) ? true : false;
+    CV_Assert(isAsymmetricGrid ^ isSymmetricGrid);
+
+    std::vector<Point2f> centers;
+
+    std::vector<Point2f> points;
+    if (blobDetector)
+    {
+        std::vector<KeyPoint> keypoints;
+        blobDetector->detect(_image, keypoints);
+        for (size_t i = 0; i < keypoints.size(); i++)
+        {
+            points.push_back(keypoints[i].pt);
+        }
+    }
+    else
+    {
+        CV_CheckTypeEQ(_image.type(), CV_32FC2, "blobDetector must be provided or image must contains Point2f array (std::vector<Point2f>) with candidates");
+        _image.copyTo(points);
+    }
+
+    if(flags & CALIB_CB_ASYMMETRIC_GRID)
+      parameters.gridType = CirclesGridFinderParameters::ASYMMETRIC_GRID;
+    if(flags & CALIB_CB_SYMMETRIC_GRID)
+      parameters.gridType = CirclesGridFinderParameters::SYMMETRIC_GRID;
+
+    if(flags & CALIB_CB_CLUSTERING)
+    {
+      CirclesGridClusterFinder circlesGridClusterFinder(parameters);
+      circlesGridClusterFinder.findGrid(points, patternSize, centers);
+      Mat(centers).copyTo(_centers);
+      return !centers.empty();
+    }
+
+    bool isValid = false;
+    const int attempts = 2;
+    const size_t minHomographyPoints = 4;
+    Mat H;
+    for (int i = 0; i < attempts; i++)
+    {
+        centers.clear();
+        CirclesGridFinder boxFinder(patternSize, points, parameters);
+        try
+        {
+            bool isFound = boxFinder.findHoles();
+            if (isFound)
+            {
+                switch(parameters.gridType)
+                {
+                case CirclesGridFinderParameters::SYMMETRIC_GRID:
+                    boxFinder.getHoles(centers);
+                    break;
+                case CirclesGridFinderParameters::ASYMMETRIC_GRID:
+                    boxFinder.getAsymmetricHoles(centers);
+                    break;
+                default:
+                    CV_Error(Error::StsBadArg, "Unknown pattern type");
+                }
+
+                isValid = true;
+                break;  // done, return result
+            }
+        }
+        catch (const cv::Exception& e)
+        {
+            CV_UNUSED(e);
+            CV_LOG_DEBUG(NULL, "findCirclesGrid2: attempt=" << i << ": " << e.what());
+            // nothing, next attempt
+        }
+
+        boxFinder.getHoles(centers);
+        if (i != attempts - 1)
+        {
+            if (centers.size() < minHomographyPoints)
+                break;
+            H = CirclesGridFinder::rectifyGrid(boxFinder.getDetectedGridSize(), centers, points, points);
+        }
+    }
+
+    if (!centers.empty() && !H.empty())  // undone rectification
+    {
+        Mat orgPointsMat;
+        transform(centers, orgPointsMat, H.inv());
+        convertPointsFromHomogeneous(orgPointsMat, centers);
+    }
+    Mat(centers).copyTo(_centers);
+    return isValid;
+}
+
+bool findCirclesGrid(InputArray _image, Size patternSize,
+                     OutputArray _centers, int flags, const Ptr<FeatureDetector> &blobDetector)
+{
+    return findCirclesGrid(_image, patternSize, _centers, flags, blobDetector, CirclesGridFinderParameters());
+}
+
+} // namespace
+/* End of file. */
diff --git a/upstream/opencv/modules/objdetect/src/checkchessboard.cpp b/upstream/opencv/modules/objdetect/src/checkchessboard.cpp
new file mode 100644
index 0000000..ac708a6
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/checkchessboard.cpp
@@ -0,0 +1,211 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                        Intel License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000, Intel Corporation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of Intel Corporation may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include <vector>
+#include <algorithm>
+
+namespace cv {
+
+using namespace std;
+
+static void icvGetQuadrangleHypotheses(const std::vector<std::vector< cv::Point > > & contours, const std::vector< cv::Vec4i > & hierarchy, std::vector<std::pair<float, int> >& quads, int class_id)
+{
+    const float min_aspect_ratio = 0.3f;
+    const float max_aspect_ratio = 3.0f;
+    const float min_box_size = 10.0f;
+
+    for (size_t i = 0; i < contours.size(); ++i)
+    {
+        if (hierarchy.at(i)[3] != -1)
+            continue; // skip holes
+
+        const std::vector< cv::Point > & c = contours[i];
+        cv::RotatedRect box = cv::minAreaRect(c);
+
+        float box_size = MAX(box.size.width, box.size.height);
+        if(box_size < min_box_size)
+        {
+            continue;
+        }
+
+        float aspect_ratio = box.size.width/MAX(box.size.height, 1);
+        if(aspect_ratio < min_aspect_ratio || aspect_ratio > max_aspect_ratio)
+        {
+            continue;
+        }
+
+        quads.emplace_back(box_size, class_id);
+    }
+}
+
+static void countClasses(const std::vector<std::pair<float, int> >& pairs, size_t idx1, size_t idx2, std::vector<int>& counts)
+{
+    counts.assign(2, 0);
+    for(size_t i = idx1; i != idx2; i++)
+    {
+        counts[pairs[i].second]++;
+    }
+}
+
+inline bool less_pred(const std::pair<float, int>& p1, const std::pair<float, int>& p2)
+{
+    return p1.first < p2.first;
+}
+
+static void fillQuads(Mat & white, Mat & black, double white_thresh, double black_thresh, vector<pair<float, int> > & quads)
+{
+    Mat thresh;
+    {
+        vector< vector<Point> > contours;
+        vector< Vec4i > hierarchy;
+        threshold(white, thresh, white_thresh, 255, THRESH_BINARY);
+        findContours(thresh, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
+        icvGetQuadrangleHypotheses(contours, hierarchy, quads, 1);
+    }
+
+    {
+        vector< vector<Point> > contours;
+        vector< Vec4i > hierarchy;
+        threshold(black, thresh, black_thresh, 255, THRESH_BINARY_INV);
+        findContours(thresh, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
+        icvGetQuadrangleHypotheses(contours, hierarchy, quads, 0);
+    }
+}
+
+static bool checkQuads(vector<pair<float, int> > & quads, const cv::Size & size)
+{
+    const size_t min_quads_count = size.width*size.height/2;
+    std::sort(quads.begin(), quads.end(), less_pred);
+
+    // now check if there are many hypotheses with similar sizes
+    // do this by floodfill-style algorithm
+    const float size_rel_dev = 0.4f;
+
+    for(size_t i = 0; i < quads.size(); i++)
+    {
+        size_t j = i + 1;
+        for(; j < quads.size(); j++)
+        {
+            if(quads[j].first/quads[i].first > 1.0f + size_rel_dev)
+            {
+                break;
+            }
+        }
+
+        if(j + 1 > min_quads_count + i)
+        {
+            // check the number of black and white squares
+            std::vector<int> counts;
+            countClasses(quads, i, j, counts);
+            const int black_count = cvRound(ceil(size.width/2.0)*ceil(size.height/2.0));
+            const int white_count = cvRound(floor(size.width/2.0)*floor(size.height/2.0));
+            if(counts[0] < black_count*0.75 ||
+               counts[1] < white_count*0.75)
+            {
+                continue;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool checkChessboard(InputArray _img, Size size)
+{
+    Mat img = _img.getMat();
+    CV_Assert(img.channels() == 1 && img.depth() == CV_8U);
+
+    const int erosion_count = 1;
+    const float black_level = 20.f;
+    const float white_level = 130.f;
+    const float black_white_gap = 70.f;
+
+    Mat white;
+    Mat black;
+    erode(img, white, Mat(), Point(-1, -1), erosion_count);
+    dilate(img, black, Mat(), Point(-1, -1), erosion_count);
+
+    bool result = false;
+    for(float thresh_level = black_level; thresh_level < white_level && !result; thresh_level += 20.0f)
+    {
+        vector<pair<float, int> > quads;
+        fillQuads(white, black, thresh_level + black_white_gap, thresh_level, quads);
+        if (checkQuads(quads, size))
+            result = true;
+    }
+    return result;
+}
+
+// does a fast check if a chessboard is in the input image. This is a workaround to
+// a problem of cvFindChessboardCorners being slow on images with no chessboard
+// - src: input binary image
+// - size: chessboard size
+// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called,
+// 0 if there is no chessboard, -1 in case of error
+int checkChessboardBinary(const cv::Mat & img, const cv::Size & size)
+{
+    CV_Assert(img.channels() == 1 && img.depth() == CV_8U);
+
+    Mat white = img.clone();
+    Mat black = img.clone();
+
+    int result = 0;
+    for ( int erosion_count = 0; erosion_count <= 3; erosion_count++ )
+    {
+        if ( 1 == result )
+            break;
+
+        if ( 0 != erosion_count ) // first iteration keeps original images
+        {
+            erode(white, white, Mat(), Point(-1, -1), 1);
+            dilate(black, black, Mat(), Point(-1, -1), 1);
+        }
+
+        vector<pair<float, int> > quads;
+        fillQuads(white, black, 128, 128, quads);
+        if (checkQuads(quads, size))
+            result = 1;
+    }
+    return result;
+}
+
+}
diff --git a/upstream/opencv/modules/objdetect/src/chessboard.cpp b/upstream/opencv/modules/objdetect/src/chessboard.cpp
new file mode 100644
index 0000000..2caa855
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/chessboard.cpp
@@ -0,0 +1,3973 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "opencv2/flann.hpp"
+#include "opencv2/geometry.hpp"
+#include "chessboard.hpp"
+#include "math.h"
+
+//#define CV_DETECTORS_CHESSBOARD_DEBUG
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+#include <opencv2/highgui.hpp>
+static cv::Mat debug_image;
+#endif
+
+using namespace std;
+namespace cv {
+namespace details {
+
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+// magic numbers used for chessboard corner detection
+/////////////////////////////////////////////////////////////////////////////
+static const float CORNERS_SEARCH = 0.5F;                       // percentage of the edge length to the next corner used to find new corners
+static const float MAX_ANGLE = float(48.0/180.0*CV_PI);          // max angle between line segments supposed to be straight
+static const float MIN_COS_ANGLE = float(std::cos(35.0/180*CV_PI));   // min cos angle between board edges
+static const float MIN_RESPONSE_RATIO = 0.1F;
+static const float ELLIPSE_WIDTH = 0.35F;                       // width of the search ellipse in percentage of its length
+static const float RAD2DEG = float(180.0/CV_PI);
+static const int MAX_SYMMETRY_ERRORS = 5;                       // maximal number of failures during point symmetry test (filtering out lines)
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
+
+// some helper methods
+static float calcSharpness(cv::InputArray _values,float rise_distance);
+static bool isPointOnLine(cv::Point2f l1,cv::Point2f l2,cv::Point2f pt,float min_angle);
+static int testPointSymmetry(const cv::Mat& mat,cv::Point2f pt,float dist,float max_error);
+static float calcSubpixel(const float &x_l,const float &x,const float &x_r);
+static float calcSubPos(const float &x_l,const float &x,const float &x_r);
+static void polyfit(const Mat& src_x, const Mat& src_y, Mat& dst, int order);
+static float calcSignedDistance(const cv::Vec2f &n,const cv::Point2f &a,const cv::Point2f &pt);
+static void normalizePoints1D(cv::InputArray _points,cv::OutputArray _T,cv::OutputArray _new_points);
+static cv::Mat findHomography1D(cv::InputArray _src,cv::InputArray _dst);
+static cv::Mat normalizeVector(cv::InputArray _points);
+
+cv::Mat normalizeVector(cv::InputArray _points)
+{
+    cv::Mat points = _points.getMat();
+    if(points.cols > 1)
+    {
+        if(points.rows == 1)
+            points = points.reshape(points.channels(),points.cols);
+        else if(points.channels() == 1)
+            points = points.reshape(points.cols,points.rows);
+        else
+            CV_Error(Error::StsBadArg, "unsupported format");
+    }
+    return points;
+}
+
+float calcSharpness(cv::InputArray _values,float rise_distance)
+{
+    CV_CheckTypeEQ(_values.type(),CV_8UC1, "values must be of the type CV_8UC1");
+    cv::Mat values = normalizeVector(_values);
+    if(values.empty())
+        return 0;
+    if(values.rows != 1 && values.cols != 1)
+        CV_Error(Error::StsBadArg, "values must be 1xn or nx1");
+    if(rise_distance <= 0.0 || rise_distance > 1.0)
+        CV_Error(Error::StsBadArg, "rise_distance must lie in th interval ]0..1]");
+
+    // find global min max
+    cv::Point min_loc,max_loc;
+    double min_val,max_val;
+    cv::minMaxLoc(values,&min_val,&max_val,&min_loc,&max_loc);
+    int max_pos = std::max(max_loc.x,max_loc.y);
+    int min_pos = std::max(min_loc.x,min_loc.y);
+    if(max_pos == min_pos)
+        return 0;
+
+    // calc new interval according to the rise distance
+    double delta = max_val-min_val;
+    double min_val2 = min_val+delta*0.5*(1.0-rise_distance);
+    double max_val2 = max_val-delta*0.5*(1.0-rise_distance);
+
+    // find new max starting at min pos
+    int dt = 1;
+    if(max_pos < min_pos)
+        dt= -1;
+    int max_pos2 = max_pos;
+    for(int i=min_pos+dt;i != max_pos;i+=dt)
+    {
+        uint8_t val = values.at<uint8_t>(i);
+        if(val >= max_val2)
+        {
+            max_pos2 = i;
+            break;
+        }
+    }
+
+    // find new min starting at max pos
+    int min_pos2 = min_pos;
+    for(int i=max_pos-dt;i != min_pos;i-=dt)
+    {
+        uint8_t val = values.at<uint8_t>(i);
+        if(val <= min_val2)
+        {
+            min_pos2 = i;
+            break;
+        }
+    }
+
+    // calc sub pixel max pos
+    double max_pos3 = max_pos2;
+    uint8_t val1 = values.at<uint8_t>(max_pos2-dt); // <= val2
+    uint8_t val2 = values.at<uint8_t>(max_pos2);
+    double m = (val2-val1)/dt;
+    if(m != 0)
+        max_pos3 = max_pos2+(max_val2-val2)/m;
+
+    // calc sub pixel min pos
+    double min_pos3 = min_pos2;
+    val1 = values.at<uint8_t>(min_pos2); // <= val2
+    val2 = values.at<uint8_t>(min_pos2+dt);
+    m = (val2-val1)/dt;
+    if(m != 0)
+        min_pos3 = min_pos2+(min_val2-val1)/m;
+
+    return float(fabs(max_pos3-min_pos3));
+}
+
+
+void normalizePoints1D(cv::InputArray _points,cv::OutputArray _T,cv::OutputArray _new_points)
+{
+    cv::Mat points = _points.getMat();
+    if(points.cols > 1 && points.rows == 1)
+        points = points.reshape(1,points.cols);
+    CV_CheckChannelsEQ(points.channels(), 1, "points must have only one channel");
+
+    // calc centroid
+    double centroid= cv::mean(points)[0];
+
+    // shift origin to centroid
+    cv::Mat new_points = points-centroid;
+
+    // calc mean distance
+    double mean_dist = cv::mean(cv::abs(new_points))[0];
+    if(mean_dist<= DBL_EPSILON)
+        CV_Error(Error::StsBadArg, "all given points are identical");
+    double scale = 1.0/mean_dist;
+
+
+    // generate transformation
+    cv::Matx22d Tx(
+        scale, -scale*centroid,
+        0,     1
+    );
+    Mat(Tx, false).copyTo(_T);
+
+    // calc normalized points;
+    _new_points.create(points.rows,1,points.type());
+    new_points = _new_points.getMat();
+    switch(points.type())
+    {
+    case CV_32FC1:
+        for(int i=0;i < points.rows;++i)
+        {
+            cv::Vec2d p(points.at<float>(i), 1.0);
+            p = Tx*p;
+            new_points.at<float>(i) = float(p(0)/p(1));
+        }
+        break;
+    case CV_64FC1:
+        for(int i=0;i < points.rows;++i)
+        {
+            cv::Vec2d p(points.at<double>(i), 1.0);
+            p = Tx*p;
+            new_points.at<double>(i) = p(0)/p(1);
+        }
+        break;
+    default:
+        CV_Error(Error::StsUnsupportedFormat, "unsupported point type");
+    }
+}
+
+cv::Mat findHomography1D(cv::InputArray _src,cv::InputArray _dst)
+{
+    // check inputs
+    cv::Mat src = _src.getMat();
+    cv::Mat dst = _dst.getMat();
+    if(src.cols > 1 && src.rows == 1)
+        src = src.reshape(1,src.cols);
+    if(dst.cols > 1 && dst.rows == 1)
+        dst = dst.reshape(1,dst.cols);
+    CV_CheckEQ(src.rows, dst.rows, "size mismatch");
+    CV_CheckChannelsEQ(src.channels(), 1, "data with only one channel are supported");
+    CV_CheckChannelsEQ(dst.channels(), 1, "data with only one channel are supported");
+    CV_CheckTypeEQ(src.type(), dst.type(), "src and dst must have the same type");
+    CV_Check(src.rows, src.rows >= 3,"at least three point pairs are needed");
+
+    // normalize points
+    cv::Mat src_T,dst_T, src_n,dst_n;
+    normalizePoints1D(src,src_T,src_n);
+    normalizePoints1D(dst,dst_T,dst_n);
+
+    int count = src_n.rows;
+    cv::Mat A = cv::Mat::zeros(count,3,CV_64FC1);
+    cv::Mat b = cv::Mat::zeros(count,1,CV_64FC1);
+
+    // fill A;b and perform singular value decomposition
+    // it is assumed that w is one for both coordinates
+    // h22 is kept to 1
+    switch(src_n.type())
+    {
+    case CV_32FC1:
+        for(int i=0;i<count;++i)
+        {
+            double s = src_n.at<float>(i);
+            double d = dst_n.at<float>(i);
+            A.at<double>(i,0) = s;
+            A.at<double>(i,1) = 1.0;
+            A.at<double>(i,2) = -s*d;
+            b.at<double>(i) = d;
+        }
+        break;
+    case CV_64FC1:
+        for(int i=0;i<count;++i)
+        {
+            double s = src_n.at<double>(i);
+            double d = dst_n.at<double>(i);
+            A.at<double>(i,0) = s;
+            A.at<double>(i,1) = 1.0;
+            A.at<double>(i,2) = -s*d;
+            b.at<double>(i) = d;
+        }
+        break;
+    default:
+        CV_Error(Error::StsUnsupportedFormat,"unsupported type");
+    }
+
+    cv::Mat u,d,vt;
+    cv::SVD::compute(A,d,u,vt);
+    cv::Mat b_ = u.t()*b;
+
+    cv::Mat y(b_.rows,1,CV_64FC1);
+    for(int i=0;i<b_.rows;++i)
+        y.at<double>(i) = b_.at<double>(i)/d.at<double>(i);
+
+    cv::Mat x = vt.t()*y;
+    cv::Matx22d H_(x.at<double>(0), x.at<double>(1), x.at<double>(2), 1.0);
+
+    // denormalize
+    Mat H = dst_T.inv()*Mat(H_, false)*src_T;
+
+    // enforce frobeniusnorm of one
+    double scale = cv::norm(H);
+    CV_Assert(fabs(scale) > DBL_EPSILON);
+    scale = 1.0 / scale;
+    return H*scale;
+}
+void polyfit(const Mat& src_x, const Mat& src_y, Mat& dst, int order)
+{
+    int npoints = src_x.checkVector(1);
+    int nypoints = src_y.checkVector(1);
+    CV_Assert(npoints == nypoints && npoints >= order+1);
+    Mat_<double> srcX(src_x), srcY(src_y);
+    Mat_<double> A = Mat_<double>::ones(npoints,order + 1);
+    // build A matrix
+    for (int y = 0; y < npoints; ++y)
+    {
+        for (int x = 1; x < A.cols; ++x)
+            A.at<double>(y,x) = srcX.at<double>(y)*A.at<double>(y,x-1);
+    }
+    cv::Mat w;
+    solve(A,srcY.reshape(1, npoints),w,DECOMP_SVD);
+    w.convertTo(dst, ((src_x.depth() == CV_64F || src_y.depth() == CV_64F) ? CV_64F : CV_32F));
+}
+
+float calcSignedDistance(const cv::Vec2f &n,const cv::Point2f &a,const cv::Point2f &pt)
+{
+    cv::Vec3f v1(n[0],n[1],0);
+    cv::Vec3f v2(pt.x-a.x,pt.y-a.y,0);
+    return v1.cross(v2)[2];
+}
+
+bool isPointOnLine(cv::Point2f l1,cv::Point2f l2,cv::Point2f pt,float min_angle)
+{
+    cv::Vec2f vec1(l1-pt);
+    cv::Vec2f vec2(pt-l2);
+    if(vec1.dot(vec2) < min_angle*cv::norm(vec1)*cv::norm(vec2))
+        return false;
+    return true;
+}
+
+// returns how many tests fails out of 10
+int testPointSymmetry(const cv::Mat &mat,cv::Point2f pt,float dist,float max_error)
+{
+    cv::Rect image_rect(int(0.5*dist),int(0.5*dist),int(mat.cols-0.5*dist),int(mat.rows-0.5*dist));
+    cv::Size size(int(0.5*dist),int(0.5*dist));
+    int count = 0;
+    cv::Mat patch1,patch2;
+    cv::Point2f center1,center2;
+    for (int angle_i = 0; angle_i < 10; angle_i++)
+    {
+        double angle = angle_i * (CV_PI * 0.1);
+        cv::Point2f n(float(std::cos(angle)),float(-std::sin(angle)));
+        center1 = pt+dist*n;
+        if(!image_rect.contains(center1))
+            return false;
+        center2 = pt-dist*n;
+        if(!image_rect.contains(center2))
+            return false;
+        cv::getRectSubPix(mat,size,center1,patch1);
+        cv::getRectSubPix(mat,size,center2,patch2);
+        if(fabs(cv::mean(patch1)[0]-cv::mean(patch2)[0]) > max_error)
+            ++count;
+    }
+    return count;
+}
+
+inline float calcSubpixel(const float &x_l,const float &x,const float &x_r)
+{
+    // prevent zero values
+    if(x_l <= 0)
+        return 0;
+    if(x <= 0)
+        return 0;
+    if(x_r <= 0)
+        return 0;
+    const float l0 = float(std::log(x_l+1e-6));
+    const float l1 = float(std::log(x+1e-6));
+    const float l2 = float(std::log(x_r+1e-6));
+    float delta = l2-l1-l1+l0;
+    if(!delta) // this happens if all values are identical
+        return 0;
+    delta = (l0-l2)/(delta+delta);
+    return delta;
+}
+
+inline float calcSubPos(const float &x_l,const float &x,const float &x_r)
+{
+    float val = 2.0F *(x_l-2.0F*x+x_r);
+    if(val == 0.0F)
+        return 0.0F;
+    val = (x_l-x_r)/val;
+    if(val > 1.0F)
+        return 1.0F;
+    if(val < -1.0F)
+        return -1.0F;
+    return val;
+}
+
+FastX::FastX(const Parameters &para)
+{
+    reconfigure(para);
+}
+
+void FastX::reconfigure(const Parameters &para)
+{
+    CV_Check(para.min_scale, para.min_scale >= 0 && para.min_scale <= para.max_scale, "invalid scale");
+    parameters = para;
+}
+
+// rotates the image around its center
+void FastX::rotate(float angle,cv::InputArray img,cv::Size size,cv::OutputArray out)const
+{
+    if(angle == 0)
+    {
+        img.copyTo(out);
+        return;
+    }
+    else
+    {
+        cv::Matx23d m = cv::getRotationMatrix2D(cv::Point2f(float(img.cols()*0.5),float(img.rows()*0.5)),float(angle/CV_PI*180),1);
+        m(0,2) += 0.5*(size.width-img.cols());
+        m(1,2) += 0.5*(size.height-img.rows());
+        cv::warpAffine(img,out,m,size);
+    }
+}
+
+void FastX::calcFeatureMap(const Mat &images,Mat& out)const
+{
+    if(images.empty())
+        CV_Error(Error::StsBadArg,"no rotation images");
+    int type = images.type(), depth = CV_MAT_DEPTH(type);
+    CV_CheckType(type,depth == CV_8U,
+            "Only 8-bit grayscale or color images are supported");
+    if(!images.isContinuous())
+        CV_Error(Error::StsBadArg,"image must be continuous");
+
+    float signal,noise,rating;
+    int count1;
+    unsigned char val1,val2,val3;
+    const unsigned char* wrap_around;
+    const unsigned char* pend;
+    const unsigned char* pimages = images.data;
+    const int channels = images.channels();
+    if(channels < 4)
+        CV_Error(Error::StsBadArg,"images must have at least four channels");
+
+    // for each pixel
+    out = cv::Mat::zeros(images.rows,images.cols,CV_32FC1);
+    const float *pout_end = reinterpret_cast<const float*>(out.dataend);
+    for(float *pout=out.ptr<float>(0,0);pout != pout_end;++pout)
+    {
+        //reset values
+        rating = 0.0; count1 = 0;
+        noise = 255; signal = 0;
+
+        //calc rating
+        pend = pimages+channels;
+        val1 = *(pend-1);                       // wrap around (last value)
+        wrap_around = pimages++;                // store for wrap around (first value)
+        val2 = *wrap_around;                    // first value
+        for(;pimages != pend;++pimages)
+        {
+            val3 = *pimages;
+            if(val1 <= val2)
+            {
+                if(val3 < val2) // maxima
+                {
+                    if(signal < val2)
+                        signal = val2;
+                    ++count1;
+                }
+            }
+            else if(val1 > val2 && val3 >= val2) // minima
+            {
+                if(noise > val2)
+                    noise = val2;
+                ++count1;
+            }
+            val1 = val2;
+            val2 = val3;
+        }
+        // wrap around
+        if(val1 <= val2) // maxima
+        {
+            if(*wrap_around < val2)
+            {
+                if(signal < val2)
+                    signal = val2;
+                ++count1;
+            }
+        }
+        else if(val1 > val2 && *wrap_around >= val2) // minima
+        {
+            if(noise > val2)
+                noise = val2;
+            ++count1;
+        }
+
+        // store rating
+        if(count1 == parameters.branches)
+        {
+            rating = signal-noise;
+            *pout = rating*rating; //store rating in the feature map
+        }
+    }
+}
+
+std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &rotated_images,std::vector<cv::KeyPoint> &keypoints)const
+{
+    // validate rotated_images
+    if(rotated_images.empty())
+        CV_Error(Error::StsBadArg,"no rotated images");
+    std::vector<cv::Mat>::const_iterator iter = rotated_images.begin();
+    for(;iter != rotated_images.end();++iter)
+    {
+        if(iter->empty())
+            CV_Error(Error::StsBadArg,"empty rotated images");
+        if(iter->channels() < 4)
+            CV_Error(Error::StsBadArg,"rotated images must have at least four channels");
+    }
+
+    // assuming all elements of the same channel
+    const int channels = rotated_images.front().channels();
+    const int channels_1 = channels-1;
+    const float resolution = float(CV_PI/channels);
+    const float scale = float(parameters.super_resolution)+1.0F;
+
+    // for each keypoint
+    std::vector<std::vector<float> > angles;
+    angles.resize(keypoints.size());
+    parallel_for_(Range(0,(int)keypoints.size()),[&](const Range& range)
+    {
+        float angle;
+        float val1,val2,val3,wrap_around;
+        const unsigned char *pimages1,*pimages2,*pimages3,*pimages4;
+        std::vector<cv::KeyPoint>::iterator pt_iter = keypoints.begin()+range.start;
+        std::vector<cv::KeyPoint>::iterator pt_end = keypoints.begin()+range.end;
+        for(int id=range.start ;pt_iter != pt_end;++pt_iter,++id)
+        {
+            int scale_id = pt_iter->octave - parameters.min_scale;
+            if(scale_id>= int(rotated_images.size()) ||scale_id < 0)
+                CV_Error(Error::StsBadArg,"no rotated image for requested keypoint octave");
+            const cv::Mat &s_rotated_images = rotated_images[scale_id];
+
+            float x2 = pt_iter->pt.x*scale;
+            float y2 = pt_iter->pt.y*scale;
+            int row = int(y2);
+            int col = int(x2);
+            x2 -= col;
+            y2 -= row;
+            float x1 = 1.0F-x2; float y1 = 1.0F-y2;
+            float a = x1*y1; float b = x2*y1; float c = x1*y2; float d = x2*y2;
+            pimages1 = s_rotated_images.ptr<unsigned char>(row,col);
+            pimages2 = s_rotated_images.ptr<unsigned char>(row,col+1);
+            pimages3 = s_rotated_images.ptr<unsigned char>(row+1,col);
+            pimages4 = s_rotated_images.ptr<unsigned char>(row+1,col+1);
+            std::vector<float> &angles_i = angles[id];
+
+            //calc rating
+            val1 = a**(pimages1+channels_1)+b**(pimages2+channels_1)+
+                c**(pimages3+channels_1)+d**(pimages4+channels_1);        // wrap around (last value)
+            wrap_around = a**(pimages1++)+b**(pimages2++)+c**(pimages3++)+d**(pimages4++); // first value
+            val2 = wrap_around;                                                             // first value
+            for(int i=0;i<channels-1;++pimages1,++pimages2,++pimages3,++pimages4,++i)
+            {
+                val3 = a**(pimages1)+b**(pimages2)+c**(pimages3)+d**(pimages4);
+                if(val1 <= val2)
+                {
+                    if(val3 < val2)
+                    {
+                        angle = float((calcSubPos(val1,val2,val3)+i)*resolution);
+                        if(angle < 0)
+                            angle += float(CV_PI);
+                        else if(angle > CV_PI)
+                            angle -= float(CV_PI);
+                        angles_i.push_back(angle);
+                        pt_iter->angle = 360.0F-angle*RAD2DEG;
+                    }
+                }
+                else if(val1 > val2 && val3 >= val2)
+                {
+                    angle = float((calcSubPos(val1,val2,val3)+i)*resolution);
+                    if(angle < 0)
+                        angle += float(CV_PI);
+                    else if(angle > CV_PI)
+                        angle -= float(CV_PI);
+                    angles_i.push_back(-angle);
+                    pt_iter->angle = 360.0F-angle*RAD2DEG;
+                }
+                val1 = val2;
+                val2 = val3;
+            }
+            // wrap around
+            if(val1 <= val2)
+            {
+                if(wrap_around< val2)
+                {
+                    angle = float((calcSubPos(val1,val2,wrap_around)+channels-1)*resolution);
+                    if(angle < 0)
+                        angle += float(CV_PI);
+                    else if(angle > CV_PI)
+                        angle -= float(CV_PI);
+                    angles_i.push_back(angle);
+                    pt_iter->angle = 360.0F-angle*RAD2DEG;
+                }
+            }
+            else if(val1 > val2 && wrap_around >= val2)
+            {
+                angle = float((calcSubPos(val1,val2,wrap_around)+channels-1)*resolution);
+                if(angle < 0)
+                    angle += float(CV_PI);
+                else if(angle > CV_PI)
+                    angle -= float(CV_PI);
+                angles_i.push_back(-angle);
+                pt_iter->angle = 360.0F-angle*RAD2DEG;
+            }
+        }
+    });
+    return angles;
+}
+
+void FastX::findKeyPoints(const std::vector<cv::Mat> &feature_maps, std::vector<KeyPoint>& keypoints,const Mat& _mask) const
+{
+    //TODO check that all feature_maps have the same size
+    int num_scales = parameters.max_scale-parameters.min_scale;
+    CV_CheckGE(int(feature_maps.size()), num_scales, "missing feature maps");
+    if (!_mask.empty())
+    {
+        CV_CheckTypeEQ(_mask.type(), CV_8UC1, "wrong mask type");
+        CV_CheckEQ(_mask.size(), feature_maps.front().size(),"wrong mask type or size");
+    }
+    keypoints.clear();
+
+    cv::Mat mask;
+    if(!_mask.empty())
+        mask = _mask;
+    else
+        mask = cv::Mat::ones(feature_maps.front().size(),CV_8UC1);
+
+    int super_res = int(parameters.super_resolution);
+    int super_scale = super_res+1;
+    float super_comp = 0.25F*super_res;
+
+    // for each scale
+    float strength = parameters.strength;
+    std::vector<int> windows;
+    cv::Point pt,pt2;
+    double min,max;
+    cv::Mat src;
+    for(int scale=parameters.max_scale;scale>=parameters.min_scale;--scale)
+    {
+        int window_size = (1 << (scale + super_res)) + 1;
+        float window_size2 = 0.5F*window_size;
+        float window_size4 = 0.25F*window_size;
+        int window_size2i = cvRound(window_size2);
+
+        const cv::Mat &feature_map = feature_maps[scale-parameters.min_scale];
+        int y = ((feature_map.rows)/window_size)-2;
+        int x = ((feature_map.cols)/window_size)-2;
+        for(int row=1;row<y;++row)
+        {
+            for(int col=1;col<x;++col)
+            {
+                Rect rect(col*window_size,row*window_size,window_size,window_size);
+                src = feature_map(rect);
+                cv::minMaxLoc(src,&min,&max,NULL,&pt);
+                if(min == max || max < strength)
+                    continue;
+
+                cv::Point pos(pt.x+rect.x,pt.y+rect.y);
+                if(mask.at<unsigned char>(pos.y,pos.x) == 0)
+                    continue;
+
+                Rect rect2(int(pos.x-window_size2),int(pos.y-window_size2),window_size,window_size);
+                src = feature_map(rect2);
+                cv::minMaxLoc(src,NULL,NULL,NULL,&pt2);
+                if(pos.x == pt2.x+rect2.x && pos.y == pt2.y+rect2.y)
+                {
+                    // the point is the best one on the current scale
+                    // check all larger scales if there is a stronger one
+                    double max2;
+                    int scale2= scale-1;
+                    //parameters.min_scale;
+                    for(;scale2>=parameters.min_scale;--scale2)
+                    {
+                        cv::minMaxLoc(feature_maps[scale2-parameters.min_scale](rect),NULL,&max2,NULL,NULL);
+                        if(max2 > max)
+                            break;
+                    }
+                    if(scale2<parameters.min_scale && pos.x+1 < feature_map.cols && pos.y+1 < feature_map.rows)
+                    {
+                        float sub_x = float(calcSubpixel(feature_map.at<float>(pos.y,pos.x-1),
+                                feature_map.at<float>(pos.y,pos.x),
+                                feature_map.at<float>(pos.y,pos.x+1)));
+                        float sub_y = float(calcSubpixel(feature_map.at<float>(pos.y-1,pos.x),
+                                feature_map.at<float>(pos.y,pos.x),
+                                feature_map.at<float>(pos.y+1,pos.x)));
+                        cv::KeyPoint kpt(sub_x+pos.x,sub_y+pos.y,float(window_size),0.F,float(max),scale);
+                        int x2 = std::max(0,int(kpt.pt.x-window_size4));
+                        int y2 = std::max(0,int(kpt.pt.y-window_size4));
+                        int w = std::min(int(mask.cols-x2),window_size2i);
+                        int h = std::min(int(mask.rows-y2),window_size2i);
+                        mask(cv::Rect(x2,y2,w,h)) = 0.0;
+                        if(super_scale != 1)
+                        {
+                            kpt.pt.x /= super_scale;
+                            kpt.pt.y /= super_scale;
+                            kpt.pt.x -= super_comp;
+                            kpt.pt.y -= super_comp;
+                            kpt.size /= super_scale;
+                        }
+                        keypoints.push_back(kpt);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void FastX::detectAndCompute(cv::InputArray image,cv::InputArray mask,std::vector<cv::KeyPoint>& keypoints,
+        cv::OutputArray _descriptors,bool useProvidedKeyPoints)
+{
+    useProvidedKeyPoints = false;
+    detectImpl(image.getMat(),keypoints,mask.getMat());
+    if(!_descriptors.needed())
+        return;
+
+    // generate descriptors based on their position
+    _descriptors.create(int(keypoints.size()),2,CV_32FC1);
+    cv::Mat descriptors = _descriptors.getMat();
+    std::vector<cv::KeyPoint>::const_iterator iter = keypoints.begin();
+    for(int row=0;iter != keypoints.end();++iter,++row)
+    {
+        descriptors.at<float>(row,0) = iter->pt.x;
+        descriptors.at<float>(row,1) = iter->pt.y;
+    }
+    if(!useProvidedKeyPoints)        // suppress compiler warning
+        return;
+    return;
+}
+
+void FastX::detectImpl(const cv::Mat& _gray_image,
+        std::vector<cv::Mat> &rotated_images,
+        std::vector<cv::Mat> &feature_maps,
+        const cv::Mat &_mask)const
+{
+    if(!_mask.empty())
+        CV_Error(Error::StsBadSize, "Mask is not supported");
+    CV_CheckTypeEQ(_gray_image.type(), CV_8UC1, "Unsupported image type");
+
+    // up-sample if needed
+    cv::Mat gray_image;
+    const int super_res = int(parameters.super_resolution);
+    if(super_res)
+        cv::resize(_gray_image,gray_image,cv::Size(),2,2);
+    else
+        _gray_image.copyTo(gray_image);
+
+    //for each scale
+    const int num_scales = parameters.max_scale-parameters.min_scale+1;
+    const int diag = int(sqrt(gray_image.rows*gray_image.rows+gray_image.cols*gray_image.cols));
+    const cv::Size size(diag,diag);
+    const int num = int(0.5001*CV_PI/parameters.resolution);
+
+    rotated_images.resize(num_scales);
+    feature_maps.resize(num_scales);
+
+    parallel_for_(Range(parameters.min_scale,parameters.max_scale+1),[&](const Range& range){
+        for(int scale=range.start;scale < range.end;++scale)
+        {
+            // calc images
+            // for each angle step
+            int scale_id = scale-parameters.min_scale;
+            int scale_size = int(std::pow(2,scale+1+super_res));
+            int scale_size2 = int((scale_size/7)*2+1);
+            std::vector<cv::Mat> images;
+            images.resize(2*num);
+            cv::Mat rotated,filtered_h,filtered_v;
+            cv::boxFilter(gray_image,images[0],-1,cv::Size(scale_size,scale_size2));
+            cv::boxFilter(gray_image,images[num],-1,cv::Size(scale_size2,scale_size));
+            for(int i=1;i<num;++i)
+            {
+                float angle = parameters.resolution*i;
+                rotate(-angle,gray_image,size,rotated);
+                cv::boxFilter(rotated,filtered_h,-1,cv::Size(scale_size,scale_size2));
+                cv::boxFilter(rotated,filtered_v,-1,cv::Size(scale_size2,scale_size));
+
+                // rotate filtered images back
+                rotate(angle,filtered_h,gray_image.size(),images[i]);
+                rotate(angle,filtered_v,gray_image.size(),images[i+num]);
+            }
+            cv::merge(images,rotated_images[scale_id]);
+
+            // calc feature map
+            calcFeatureMap(rotated_images[scale_id],feature_maps[scale_id]);
+
+            // filter feature map to improve impulse responses
+            if(parameters.filter)
+            {
+                cv::Mat high,low;
+                cv::boxFilter(feature_maps[scale_id],low,-1,cv::Size(scale_size,scale_size));
+                int scale2 = int((scale_size/6))*2+1;
+                cv::boxFilter(feature_maps[scale_id],high,-1,cv::Size(scale2,scale2));
+                feature_maps[scale_id] = high-0.8*low;
+            }
+        }
+    });
+}
+
+void FastX::detectImpl(const cv::Mat& image,std::vector<cv::KeyPoint>& keypoints,std::vector<cv::Mat> &feature_maps,const cv::Mat &mask)const
+{
+    std::vector<cv::Mat> rotated_images;
+    detectImpl(image,rotated_images,feature_maps,mask);
+    findKeyPoints(feature_maps,keypoints,mask);
+}
+
+void FastX::detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask)const
+{
+    std::vector<cv::Mat> feature_maps;
+    detectImpl(image.getMat(),keypoints,feature_maps,mask.getMat());
+}
+
+void FastX::detectImpl(const Mat& src, std::vector<KeyPoint>& keypoints, const Mat& mask)const
+{
+    std::vector<cv::Mat> feature_maps;
+    detectImpl(src,keypoints,feature_maps,mask);
+}
+
+
+Ellipse::Ellipse():
+    angle(0),
+    cosf(0),
+    sinf(0)
+{
+}
+
+Ellipse::Ellipse(const cv::Point2f &_center, const cv::Size2f &_axes, float _angle):
+    center(_center),
+    axes(_axes),
+    angle(_angle),
+    cosf(std::cos(-_angle)),
+    sinf(std::sin(-_angle))
+{
+}
+
+const cv::Size2f &Ellipse::getAxes()const
+{
+    return axes;
+}
+
+cv::Point2f Ellipse::getCenter()const
+{
+    return center;
+}
+
+void Ellipse::draw(cv::InputOutputArray img,const cv::Scalar &color)const
+{
+    cv::ellipse(img,center,axes,360-angle/CV_PI*180,0,360,color);
+}
+
+bool Ellipse::contains(const cv::Point2f &pt)const
+{
+    cv::Point2f ptc = pt-center;
+    float x = cosf*ptc.x+sinf*ptc.y;
+    float y = -sinf*ptc.x+cosf*ptc.y;
+    if(x*x/(axes.width*axes.width)+y*y/(axes.height*axes.height) <= 1.0)
+        return true;
+    return false;
+}
+
+
+// returns false if the angle from the line pt1-pt2 to the line pt3-pt4 is negative
+static bool checkOrientation(const cv::Point2f &pt1,const cv::Point2f &pt2,
+        const cv::Point2f &pt3,const cv::Point2f &pt4)
+{
+    cv::Point3f p1(pt2.x-pt1.x,pt2.y-pt1.y,0);
+    cv::Point3f p2(pt4.x-pt3.x,pt4.y-pt3.y,0);
+    return p1.cross(p2).z > 0;
+}
+
+static bool sortKeyPoint(const cv::KeyPoint &pt1,const cv::KeyPoint &pt2)
+{
+    // used as comparison function for partial sort
+    // the keypoints with the best score should be first
+    return pt1.response > pt2.response;
+}
+
+cv::Mat Chessboard::getObjectPoints(const cv::Size &pattern_size,float cell_size)
+{
+    cv::Mat result(pattern_size.width*pattern_size.height,1,CV_32FC3);
+    for(int row=0;row < pattern_size.height;++row)
+    {
+        for(int col=0;col< pattern_size.width;++col)
+        {
+            cv::Point3f &pt = *result.ptr<cv::Point3f>(row*pattern_size.width+col);
+            pt.x = cell_size*col;
+            pt.y = cell_size*row;
+            pt.z = 0;
+        }
+    }
+    return result;
+}
+
+bool Chessboard::Board::Cell::isInside(const cv::Point2f &pt)const
+{
+    if(empty())
+        return false;
+    float l1 = (pt.x-top_left->x)*(bottom_left->y-top_left->y) - (bottom_left->x-top_left->x)*(pt.y-top_left->y);
+    float  l2 = (pt.x-top_right->x)*(top_left->y-top_right->y) - (top_left->x-top_right->x)*(pt.y-top_right->y);
+    float  l3 = (pt.x-bottom_left->x)*(top_right->y-bottom_left->y) - (top_right->x-bottom_left->x)*(pt.y-bottom_left->y);
+    if((l1>0 && l2>0  && l3>0) || (l1<0 && l2<0 && l3<0))
+        return true;
+    l1 = (pt.x-top_left->x)*(bottom_right->y-top_left->y) - (bottom_right->x-top_left->x)*(pt.y-top_left->y);
+    l2 = (pt.x-top_right->x)*(top_left->y-top_right->y) - (top_left->x-top_right->x)*(pt.y-top_right->y);
+    l3 = (pt.x-bottom_right->x)*(top_right->y-bottom_right->y) - (top_right->x-bottom_right->x)*(pt.y-bottom_right->y);
+    return (l1>0 && l2>0  && l3>0) || (l1<0 && l2<0 && l3<0);
+}
+
+bool Chessboard::Board::Cell::empty()const
+{
+    // check if one of its corners has NaN
+    if(top_left->x != top_left->x || top_left->y != top_left->y)
+        return true;
+    if(top_right->x != top_right->x || top_right->y != top_right->y)
+        return true;
+    if(bottom_right->x != bottom_right->x || bottom_right->y != bottom_right->y)
+        return true;
+    if(bottom_left->x != bottom_left->x || bottom_left->y != bottom_left->y)
+        return true;
+    return false;
+}
+
+int Chessboard::Board::Cell::getRow()const
+{
+    int row = 0;
+    Cell const* temp = this;
+    for(;temp->top;temp=temp->top,++row);
+    return row;
+}
+
+cv::Point2f Chessboard::Board::Cell::getCenter()const
+{
+    if(empty())
+        CV_Error(Error::StsBadArg,"Cell is empty");
+    cv::Point2f center = *top_left+*top_right+*bottom_left+*bottom_right;
+    center.x /=4;
+    center.y /=4;
+    return center;
+}
+
+int Chessboard::Board::Cell::getCol()const
+{
+    int col = 0;
+    Cell const* temp = this;
+    for(;temp->left;temp=temp->left,++col);
+    return col;
+}
+
+Chessboard::Board::Cell::Cell() :
+    top_left(NULL), top_right(NULL), bottom_right(NULL), bottom_left(NULL),
+    left(NULL), top(NULL), right(NULL), bottom(NULL),black(false),marker(false)
+{}
+
+Chessboard::Board::PointIter::PointIter(Cell *_cell,CornerIndex _corner_index):
+    corner_index(_corner_index),
+    cell(_cell)
+{
+}
+
+Chessboard::Board::PointIter::PointIter(const PointIter &other)
+{
+    this->operator=(other);
+}
+
+void Chessboard::Board::PointIter::operator=(const PointIter &other)
+{
+    corner_index = other.corner_index;
+    cell = other.cell;
+}
+
+Chessboard::Board::Cell* Chessboard::Board::PointIter::getCell()
+{
+    return cell;
+}
+
+bool Chessboard::Board::PointIter::valid()const
+{
+    return cell != NULL;
+}
+
+bool Chessboard::Board::PointIter::isNaN()const
+{
+    const cv::Point2f *pt = operator*();
+    if(pt->x != pt->x || pt->y != pt->y)        // NaN check
+        return true;
+    return false;
+}
+
+bool Chessboard::Board::PointIter::checkCorner()const
+{
+    if(!cell->empty())
+        return true;
+    // test all other cells
+    switch(corner_index)
+    {
+    case BOTTOM_LEFT:
+        if(cell->left)
+        {
+            if(!cell->left->empty())
+                return true;
+            if(cell->left->bottom && !cell->left->bottom->empty())
+                return true;
+        }
+        if(cell->bottom)
+        {
+            if(!cell->bottom->empty())
+                return true;
+            if(cell->bottom->left && !cell->bottom->left->empty())
+                return true;
+        }
+        break;
+    case TOP_LEFT:
+        if(cell->left)
+        {
+            if(!cell->left->empty())
+                return true;
+            if(cell->left->top && !cell->left->top->empty())
+                return true;
+        }
+        if(cell->top)
+        {
+            if(!cell->top->empty())
+                return true;
+            if(cell->top->left && !cell->top->left->empty())
+                return true;
+        }
+        break;
+    case TOP_RIGHT:
+        if(cell->right)
+        {
+            if(!cell->right->empty())
+                return true;
+            if(cell->right->top && !cell->right->top->empty())
+                return true;
+        }
+        if(cell->top)
+        {
+            if(!cell->top->empty())
+                return true;
+            if(cell->top->right && !cell->top->right->empty())
+                return true;
+        }
+        break;
+    case BOTTOM_RIGHT:
+        if(cell->right)
+        {
+            if(!cell->right->empty())
+                return true;
+            if(cell->right->bottom && !cell->right->bottom->empty())
+                return true;
+        }
+        if(cell->bottom)
+        {
+            if(!cell->bottom->empty())
+                return true;
+            if(cell->bottom->right && !cell->bottom->right->empty())
+                return true;
+        }
+        break;
+    default:
+        CV_Assert(false);
+    }
+    return false;
+}
+
+
+bool Chessboard::Board::PointIter::left(bool check_empty)
+{
+    switch(corner_index)
+    {
+    case BOTTOM_LEFT:
+        if(cell->left && (!check_empty || !cell->left->empty()))
+            cell = cell->left;
+        else if(check_empty && cell->bottom && cell->bottom->left && !cell->bottom->left->empty())
+        {
+            cell = cell->bottom->left;
+            corner_index = TOP_LEFT;
+        }
+        else
+            return false;
+        break;
+    case TOP_LEFT:
+        if(cell->left && (!check_empty || !cell->left->empty()))
+            cell = cell->left;
+        else if(check_empty && cell->top && cell->top->left && !cell->top->left->empty())
+        {
+            cell = cell->top->left;
+            corner_index = BOTTOM_LEFT;
+        }
+        else
+            return false;
+        break;
+    case TOP_RIGHT:
+        corner_index = TOP_LEFT;
+        break;
+    case BOTTOM_RIGHT:
+        corner_index = BOTTOM_LEFT;
+        break;
+    default:
+        CV_Assert(false);
+    }
+    return true;
+}
+
+bool Chessboard::Board::PointIter::top(bool check_empty)
+
+{
+    switch(corner_index)
+    {
+    case TOP_RIGHT:
+        if(cell->top && (!check_empty || !cell->top->empty()))
+            cell = cell->top;
+        else if(check_empty && cell->right && cell->right->top&& !cell->right->top->empty())
+        {
+            cell = cell->right->top;
+            corner_index = TOP_LEFT;
+        }
+        else
+            return false;
+        break;
+    case TOP_LEFT:
+        if(cell->top && (!check_empty || !cell->top->empty()))
+            cell = cell->top;
+        else if(check_empty && cell->left && cell->left->top&& !cell->left->top->empty())
+        {
+            cell = cell->left->top;
+            corner_index = TOP_RIGHT;
+        }
+        else
+            return false;
+        break;
+    case BOTTOM_LEFT:
+        corner_index = TOP_LEFT;
+        break;
+    case BOTTOM_RIGHT:
+        corner_index = TOP_RIGHT;
+        break;
+    default:
+        CV_Assert(false);
+    }
+    return true;
+}
+
+bool Chessboard::Board::PointIter::right(bool check_empty)
+{
+    switch(corner_index)
+    {
+    case TOP_RIGHT:
+        if(cell->right && (!check_empty || !cell->right->empty()))
+            cell = cell->right;
+        else if(check_empty && cell->top && cell->top->right && !cell->top->right->empty())
+        {
+            cell = cell->top->right;
+            corner_index = BOTTOM_RIGHT;
+        }
+        else
+            return false;
+        break;
+    case BOTTOM_RIGHT:
+        if(cell->right && (!check_empty || !cell->right->empty()))
+            cell = cell->right;
+        else if(check_empty && cell->bottom && cell->bottom->right && !cell->bottom->right->empty())
+        {
+            cell = cell->bottom->right;
+            corner_index = TOP_RIGHT;
+        }
+        else
+            return false;
+        break;
+    case TOP_LEFT:
+        corner_index = TOP_RIGHT;
+        break;
+    case BOTTOM_LEFT:
+        corner_index = BOTTOM_RIGHT;
+        break;
+    default:
+        CV_Assert(false);
+    }
+    return true;
+}
+
+bool Chessboard::Board::PointIter::bottom(bool check_empty)
+{
+    switch(corner_index)
+    {
+    case BOTTOM_LEFT:
+        if(cell->bottom && (!check_empty || !cell->bottom->empty()))
+            cell = cell->bottom;
+        else if(check_empty && cell->left && cell->left->bottom && !cell->left->bottom->empty())
+        {
+            cell = cell->left->bottom;
+            corner_index = BOTTOM_RIGHT;
+        }
+        else
+            return false;
+        break;
+    case BOTTOM_RIGHT:
+        if(cell->bottom && (!check_empty || !cell->bottom->empty()))
+            cell = cell->bottom;
+        else if(check_empty && cell->right && cell->right->bottom && !cell->right->bottom->empty())
+        {
+            cell = cell->right->bottom;
+            corner_index = BOTTOM_LEFT;
+        }
+        else
+            return false;
+        break;
+    case TOP_LEFT:
+        corner_index = BOTTOM_LEFT;
+        break;
+    case TOP_RIGHT:
+        corner_index = BOTTOM_RIGHT;
+        break;
+    default:
+        CV_Assert(false);
+    }
+    return true;
+}
+
+
+const cv::Point2f* Chessboard::Board::PointIter::operator*()const
+{
+    switch(corner_index)
+    {
+    case TOP_LEFT:
+        return cell->top_left;
+    case TOP_RIGHT:
+        return cell->top_right;
+    case BOTTOM_RIGHT:
+        return cell->bottom_right;
+    case BOTTOM_LEFT:
+        return cell->bottom_left;
+    }
+    CV_Assert(false);
+}
+
+const cv::Point2f* Chessboard::Board::PointIter::operator->()const
+{
+    return operator*();
+}
+
+cv::Point2f* Chessboard::Board::PointIter::operator*()
+{
+    const cv::Point2f *pt = const_cast<const PointIter*>(this)->operator*();
+    return const_cast<cv::Point2f*>(pt);
+}
+
+cv::Point2f* Chessboard::Board::PointIter::operator->()
+{
+    return operator*();
+}
+
+Chessboard::Board::Board(float _white_angle,float _black_angle):
+    top_left(NULL),
+    rows(0),
+    cols(0),
+    white_angle(_white_angle),
+    black_angle(_black_angle)
+{
+}
+
+
+Chessboard::Board::Board(const Chessboard::Board &other):
+    top_left(NULL),
+    rows(0),
+    cols(0)
+{
+    *this = other;
+}
+
+Chessboard::Board::Board(const cv::Size &size, const std::vector<cv::Point2f> &points,float _white_angle,float _black_angle):
+    top_left(NULL),
+    rows(0),
+    cols(0),
+    white_angle(_white_angle),
+    black_angle(_black_angle)
+{
+    if(size.width*size.height != int(points.size()))
+        CV_Error(Error::StsBadArg,"size mismatch");
+    if(size.width < 3 || size.height < 3)
+        CV_Error(Error::StsBadArg,"at least 3 rows and cols are needed to initialize the board");
+
+    // init board with 3x3
+    // TODO write function speeding up the copying
+    cv::Mat data = cv::Mat(points).reshape(2,size.height);
+    cv::Mat temp;
+    data(cv::Rect(0,0,3,3)).copyTo(temp);
+    std::vector<cv::Point2f> ipoints = temp.reshape(2,1);
+    if(!init(ipoints))
+        return;
+
+    // add all cols if more than 3
+    for(int col=3 ; col< data.cols;++col)
+    {
+        data(cv::Rect(col,0,1,3)).copyTo(temp);
+        ipoints = temp.reshape(2,1);
+        addColumnRight(ipoints);
+    }
+
+    // add all rows if more than 3
+    for(int row=3; row < data.rows;++row)
+    {
+        data(cv::Rect(0,row,cols,1)).copyTo(temp);
+        ipoints = temp.reshape(2,1);
+        addRowBottom(ipoints);
+    }
+}
+
+Chessboard::Board::~Board()
+{
+    clear();
+}
+
+void Chessboard::Board::setAngles(float white, float black)
+{
+    white_angle = white;
+    black_angle = black;
+}
+
+float Chessboard::Board::getAngle()const
+{
+    if(isEmpty())
+        CV_Error(Error::StsBadArg,"Board is empty");
+    if(colCount() < 3)
+        CV_Error(Error::StsBadArg,"Board is too small");
+
+    cv::Point2f delta = *(top_left->right->top_right)-*(top_left->top_left);
+    cv::Point3f pt(delta.x,delta.y,0);
+    float val;
+    if(fabs(pt.x) > fabs(pt.y))
+    {
+        cv::Point3f ptx(1,0,0);
+        val = float(ptx.dot(pt)/cv::norm(pt));
+        if(val < 0)
+            val = -std::acos(val);
+        else
+            val = std::acos(val);
+    }
+    else
+    {
+        cv::Point3f ptx(0,1,0);
+        val = float(ptx.dot(pt)/cv::norm(pt));
+        if(val < 0)
+            val = float(-std::acos(val)+CV_PI/2);
+        else
+            val = float(std::acos(val)+CV_PI/2);
+    }
+    return val;
+}
+
+bool Chessboard::Board::isHorizontal()const
+{
+    double angle = getAngle();
+    if((angle < 0.25*CV_PI && angle > -0.25*CV_PI) || angle > 0.75*CV_PI || angle < -0.75*CV_PI)
+        return true;
+    return false;
+}
+
+cv::Mat Chessboard::Board::getObjectPoints(float cell_size)const
+{
+    cv::Mat points = Chessboard::getObjectPoints(getSize(),cell_size);
+
+    // check for any offset due to a found marker
+    for(auto &&cell : cells)
+    {
+        if(cell->marker && !cell->black)
+        {
+            // apply offset
+            cv::Point3f offset(cell->getCol()*cell_size,cell->getRow()*cell_size,0);
+            for(int i =0;i < points.rows;++i)
+                points.at<cv::Point3f>(i) -= offset;
+            break;
+        }
+    }
+    return points;
+}
+
+std::vector<cv::Point2f> Chessboard::Board::getCellCenters()const
+{
+    int icols = int(colCount());
+    int irows = int(rowCount());
+    if(icols < 3 || irows < 3)
+        CV_Error(Error::StsBadArg,"Chessboard must be at least consist of 3 rows and cols to calculate the cell centers");
+
+    std::vector<cv::Point2f> points;
+    cv::Matx33d H(estimateHomography(DUMMY_FIELD_SIZE));
+    cv::Vec3d pt1,pt2;
+    pt1[2] = 1;
+    for(int row = 0;row < irows;++row)
+    {
+        pt1[1] = (0.5+row)*DUMMY_FIELD_SIZE;
+        for(int col= 0;col< icols;++col)
+        {
+            pt1[0] = (0.5+col)*DUMMY_FIELD_SIZE;
+            pt2 = H*pt1;
+            points.push_back(cv::Point2f(float(pt2[0]/pt2[2]),float(pt2[1]/pt2[2])));
+        }
+    }
+    return points;
+}
+
+std::vector<cv::Mat> Chessboard::Board::getCells(float shrink_factor,bool bwhite,bool bblack) const
+{
+    std::vector<cv::Mat> result;
+    int icols = int(colCount());
+    int irows = int(rowCount());
+    if(icols < 3 || irows < 3)
+        return result;
+
+    for(int row=0;row<irows-1;++row)
+    {
+        for(int col=0;col<icols-1;++col)
+        {
+            const Cell *cell = getCell(row,col);
+            if(!bwhite && !cell->black)
+                continue;
+            if(!bblack && cell->black)
+                continue;
+            cv::Mat points = cv::Mat(4,1,CV_32FC2);
+            points.at<cv::Point2f>(0) = *cell->top_left;
+            points.at<cv::Point2f>(1) = *cell->top_right;
+            points.at<cv::Point2f>(2) = *cell->bottom_right;
+            points.at<cv::Point2f>(3) = *cell->bottom_left;
+            if(shrink_factor != 1)
+            {
+                cv::Point2f center = *cell->top_left+*cell->top_right+*cell->bottom_left+*cell->bottom_right;
+                center.x /=4;
+                center.y /=4;
+                for(int i=0;i<4;++i)
+                {
+                    auto &pt = points.at<cv::Point2f>(i);
+                    pt = center+(pt-center)*shrink_factor;
+                }
+            }
+            result.push_back(points);
+        }
+    }
+    return result;
+}
+
+cv::Mat Chessboard::Board::warpImage(cv::InputArray image)const
+{
+    cv::Mat H = estimateHomography();
+    cv::Mat mat;
+    cv::Size size = getSize();
+    size.width = (size.width+1)*DUMMY_FIELD_SIZE;
+    size.height= (size.height+1)*DUMMY_FIELD_SIZE;
+    cv::warpPerspective(image,mat,H.inv(),size);
+    return mat;
+}
+
+void Chessboard::Board::draw(cv::InputArray m,cv::OutputArray out,cv::InputArray _H)const
+{
+    cv::Mat H = _H.getMat();
+    if(H.empty())
+        H = estimateHomography();
+    cv::Mat image = m.getMat().clone();
+    if(image.type() == CV_32FC1)
+    {
+        double maxVal,minVal;
+        cv::minMaxLoc(image, &minVal, &maxVal);
+        double scale = 255.0/(maxVal-minVal);
+        image.convertTo(image,CV_8UC1,scale,-scale*minVal);
+        cv::applyColorMap(image,image,cv::COLORMAP_JET);
+    }
+
+    // draw all points and search areas
+    std::vector<cv::Point2f> points = getCorners();
+    std::vector<cv::Point2f>::const_iterator iter1 = points.begin();
+    int icols = int(colCount());
+    int irows = int(rowCount());
+    int count=0;
+    for(int row=0;row<irows;++row)
+    {
+        for(int col=0;col<icols;++col,++iter1)
+        {
+            if(!H.empty() && iter1->x != iter1->x)    // NaN check
+            {
+                // draw search ellipse
+                Ellipse ellipse = estimateSearchArea(H,row,col,0.4F);
+                ellipse.draw(image,cv::Scalar::all(200));
+            }
+            else
+            {
+                cv::circle(image,*iter1,4,cv::Scalar(count*20,count*20,count*20,255),-1);
+                ++count;
+            }
+        }
+    }
+
+    // draw field colors
+    for(int row=0;row<irows-1;++row)
+    {
+        for(int col=0;col<icols-1;++col)
+        {
+            const Cell *cell = getCell(row,col);
+            cv::Point2f center = cell->getCenter();
+            int size = 4;
+            if(row==0&&col==0)
+                size=8;
+            if(row==0&&col==1)
+                size=7;
+
+            if(cell->marker)
+            {
+                if(cell->black)
+                    cv::circle(image,center,2,cv::Scalar::all(0),-1);
+                else
+                {
+                    cv::circle(image,center,2,cv::Scalar::all(255),-1);
+                    // draw coordinate
+                    if(col+1 < icols)
+                    {
+                        const Cell *cell2 = getCell(row,col+1);
+                        cv::Point2f center2 = cell2->getCenter();
+                        cv::line(image,center,center2,cv::Scalar::all(127),2);
+                    }
+                    if(row+1 < irows)
+                    {
+                        const Cell *cell2 = getCell(row+1,col);
+                        cv::Point2f center2 = cell2->getCenter();
+                        cv::line(image,center,center2,cv::Scalar::all(127),2);
+                    }
+                }
+            }
+            else
+            {
+                if(cell->black)
+                    cv::circle(image,center,size,cv::Scalar::all(255),-1);
+                else
+                    cv::circle(image,center,size,cv::Scalar(0,0,10,255),-1);
+            }
+        }
+    }
+
+    out.create(image.rows,image.cols,image.type());
+    image.copyTo(out.getMat());
+}
+
+bool Chessboard::Board::estimatePose(const cv::Size2f &real_size,cv::InputArray _K,cv::OutputArray rvec,cv::OutputArray tvec)const
+{
+    cv::Mat K = _K.getMat();
+    CV_CheckTypeEQ(K.type(), CV_64FC1, "wrong K type");
+    CV_CheckEQ(K.size(), Size(3, 3), "wrong K size");
+    if(isEmpty())
+        return false;
+
+    int icols = int(colCount());
+    int irows = int(rowCount());
+    float field_width = real_size.width/(icols+1);
+    float field_height= real_size.height/(irows+1);
+    // the center of the board is placed at (0,0,1)
+    int offset_x = int(-(icols-1)*field_width*0.5F);
+    int offset_y = int(-(irows-1)*field_width*0.5F);
+
+    std::vector<cv::Point2f> image_points;
+    std::vector<cv::Point3f> object_points;
+    std::vector<cv::Point2f> corners_temp = getCorners(true);
+    std::vector<cv::Point2f>::const_iterator iter = corners_temp.begin();
+    for(int row = 0;row < irows;++row)
+    {
+        for(int col= 0;col<icols;++col,++iter)
+        {
+            if(iter == corners_temp.end())
+                CV_Error(Error::StsInternal,"internal error");
+            if(iter->x != iter->x)      // NaN check
+                continue;
+            image_points.push_back(*iter);
+            object_points.push_back(cv::Point3f(field_width*col-offset_x,field_height*row-offset_y,1.0));
+        }
+    }
+    return solvePnP(object_points,image_points,K,cv::Mat(),rvec,tvec);//,cv::SOLVEPNP_P3P);
+}
+
+float Chessboard::Board::getBlackAngle()const
+{
+    return black_angle;
+}
+
+float Chessboard::Board::getWhiteAngle()const
+{
+    return white_angle;
+}
+
+void Chessboard::Board::swap(Chessboard::Board &other)
+{
+    corners.swap(other.corners);
+    cells.swap(other.cells);
+    std::swap(rows,other.rows);
+    std::swap(cols,other.cols);
+    std::swap(top_left,other.top_left);
+    std::swap(white_angle,other.white_angle);
+    std::swap(black_angle,other.black_angle);
+}
+
+Chessboard::Board& Chessboard::Board::operator=(const Chessboard::Board &other)
+{
+    if(this == &other)
+        return *this;
+    clear();
+    rows = other.rows;
+    cols = other.cols;
+    white_angle = other.white_angle;
+    black_angle = other.black_angle;
+    cells.reserve(other.cells.size());
+    corners.reserve(other.corners.size());
+
+    //copy all points and generate mapping
+    std::map<cv::Point2f*,cv::Point2f*> point_point_mapping;
+    point_point_mapping[NULL] = NULL;
+    std::vector<cv::Point2f*>::const_iterator iter = other.corners.begin();
+    for(;iter != other.corners.end();++iter)
+    {
+        cv::Point2f *pt = new cv::Point2f(**iter);
+        point_point_mapping[*iter] = pt;
+        corners.push_back(pt);
+    }
+
+    //copy all cells using mapping
+    std::map<Cell*,Cell*> cell_cell_mapping;
+    std::vector<Cell*>::const_iterator iter2 = other.cells.begin();
+    for(;iter2 != other.cells.end();++iter2)
+    {
+        Cell *cell = new Cell;
+        cell->top_left = point_point_mapping[(*iter2)->top_left];
+        cell->top_right= point_point_mapping[(*iter2)->top_right];
+        cell->bottom_right= point_point_mapping[(*iter2)->bottom_right];
+        cell->bottom_left = point_point_mapping[(*iter2)->bottom_left];
+        cell->black = (*iter2)->black;
+        cell->marker = (*iter2)->marker;
+        cell_cell_mapping[*iter2] = cell;
+        cells.push_back(cell);
+    }
+
+    //set cell connections using mapping
+    cell_cell_mapping[NULL] = NULL;
+    iter2 = other.cells.begin();
+    std::vector<Cell*>::iterator iter3 = cells.begin();
+    for(;iter2 != other.cells.end();++iter2,++iter3)
+    {
+        (*iter3)->left = cell_cell_mapping[(*iter2)->left];
+        (*iter3)->top = cell_cell_mapping[(*iter2)->top];
+        (*iter3)->right = cell_cell_mapping[(*iter2)->right];
+        (*iter3)->bottom= cell_cell_mapping[(*iter2)->bottom];
+    }
+    top_left = cell_cell_mapping[other.top_left];
+    return *this;
+}
+
+bool Chessboard::Board::normalizeMarkerOrientation()
+{
+    // use row by row fashion as cells must not be arranged correctly
+    Cell *pcell = NULL;
+    int trows = int(rowCount());
+    int tcols = int(colCount());
+    for(int row=0;row != trows && !pcell;++row)
+    {
+        for(int col=0;col != tcols;++col)
+        {
+            Cell* current_cell = getCell(row,col);
+            if(!current_cell->marker || !current_cell->right || !current_cell->right->marker)
+                continue;
+
+            if(current_cell->right->top && current_cell->right->top->marker)
+            {
+                rotateLeft();
+                rotateLeft();
+                pcell = current_cell->right;
+                break;
+            }
+            if(current_cell->right->bottom && current_cell->right->bottom->marker)
+            {
+                rotateLeft();
+                pcell = current_cell->right;
+                break;
+            }
+            if(current_cell->top && current_cell->top->marker)
+            {
+                rotateRight();
+                pcell = current_cell;
+                break;
+            }
+            if(current_cell->bottom && current_cell->bottom->marker)
+            {
+                // correct orientation
+                pcell = current_cell;
+                break;
+            }
+        }
+    }
+    if(pcell)
+    {
+        //check for ambiguity
+        if(rowCount()-pcell->bottom->getRow() > 2)
+        {
+            CV_LOG_DEBUG(NULL, "FIX board " << pcell->bottom->getRow() << " " << rowCount());
+            flipVertical();
+            rotateRight();
+        }
+        return true;
+    }
+    return false;
+}
+
+void Chessboard::Board::normalizeOrientation(bool bblack)
+{
+    // fix ordering
+    cv::Point2f y = getCorner(0,1)-getCorner(2,1);
+    cv::Point2f x = getCorner(1,2)-getCorner(1,0);
+    cv::Point3f y3d(y.x,y.y,0);
+    cv::Point3f x3d(x.x,x.y,0);
+    if(x3d.cross(y3d).z > 0)
+        flipHorizontal();
+
+    //normalize orientation so that first element is black or white
+    const Cell* cell = getCell(0,0);
+    if(cell->black != bblack && colCount()%2 != 0)
+        rotateLeft();
+    else if(cell->black != bblack && rowCount()%2 != 0)
+    {
+        rotateLeft();
+        rotateLeft();
+    }
+
+    //find closest point to top left image corner
+    //in case of symmetric checkerboard
+    if(colCount() == rowCount())
+    {
+        PointIter iter_top_right(top_left,TOP_RIGHT);
+        while(iter_top_right.right());
+        PointIter iter_bottom_right(iter_top_right);
+        while(iter_bottom_right.bottom());
+        PointIter iter_bottom_left(top_left,BOTTOM_LEFT);
+        while(iter_bottom_left.bottom());
+        // check if one of the cell is empty and do not normalize if so
+        if(top_left->empty() || iter_top_right.getCell()->empty() ||
+                iter_bottom_left.getCell()->empty() || iter_bottom_right.getCell()->empty())
+            return;
+
+        float d1 = top_left->top_left->dot(*top_left->top_left);
+        float d2 = (*iter_top_right)->dot(*(*iter_top_right));
+        float d3 = (*iter_bottom_left)->dot(*(*iter_bottom_left));
+        float d4 = (*iter_bottom_right)->dot(*(*iter_bottom_right));
+        if(d2 <= d1 && d2 <= d3 && d2 <= d4) // top left is top right
+            rotateLeft();
+        else if(d3 <= d1 && d3 <= d2 && d3 <= d4) // top left is bottom left
+            rotateRight();
+        else if(d4 <= d1 && d4 <= d2 && d4 <= d3)      // top left is bottom right
+        {
+            rotateLeft();
+            rotateLeft();
+        }
+    }
+}
+
+void Chessboard::Board::rotateRight()
+{
+    PointIter p_iter(top_left,BOTTOM_LEFT);
+    while(p_iter.bottom());
+
+    std::vector<Cell*>::iterator iter = cells.begin();
+    for(;iter != cells.end();++iter)
+    {
+        Cell *temp = (*iter)->bottom;
+        (*iter)->bottom = (*iter)->right;
+        (*iter)->right= (*iter)->top;
+        (*iter)->top= (*iter)->left;
+        (*iter)->left = temp;
+
+        cv::Point2f *ptemp = (*iter)->bottom_left;
+        (*iter)->bottom_left= (*iter)->bottom_right;
+        (*iter)->bottom_right= (*iter)->top_right;
+        (*iter)->top_right= (*iter)->top_left;
+        (*iter)->top_left= ptemp;
+    }
+    int temp = rows;
+    rows = cols;
+    cols = temp;
+    top_left = p_iter.getCell();
+}
+
+
+void Chessboard::Board::rotateLeft()
+{
+    PointIter p_iter(top_left,TOP_RIGHT);
+    while(p_iter.right());
+
+    std::vector<Cell*>::iterator iter = cells.begin();
+    for(;iter != cells.end();++iter)
+    {
+        Cell *temp = (*iter)->top;
+        (*iter)->top = (*iter)->right;
+        (*iter)->right= (*iter)->bottom;
+        (*iter)->bottom= (*iter)->left;
+        (*iter)->left = temp;
+
+        cv::Point2f *ptemp = (*iter)->top_left;
+        (*iter)->top_left = (*iter)->top_right;
+        (*iter)->top_right= (*iter)->bottom_right;
+        (*iter)->bottom_right = (*iter)->bottom_left;
+        (*iter)->bottom_left = ptemp;
+    }
+    int temp = rows;
+    rows = cols;
+    cols = temp;
+    top_left = p_iter.getCell();
+}
+
+void Chessboard::Board::flipHorizontal()
+{
+    PointIter p_iter(top_left,TOP_RIGHT);
+    while(p_iter.right());
+
+    std::vector<Cell*>::iterator iter = cells.begin();
+    for(;iter != cells.end();++iter)
+    {
+        Cell *temp = (*iter)->right;
+        (*iter)->right= (*iter)->left;
+        (*iter)->left = temp;
+
+        cv::Point2f *ptemp = (*iter)->top_left;
+        (*iter)->top_left = (*iter)->top_right;
+        (*iter)->top_right = ptemp;
+
+        ptemp = (*iter)->bottom_left;
+        (*iter)->bottom_left = (*iter)->bottom_right;
+        (*iter)->bottom_right = ptemp;
+    }
+    top_left = p_iter.getCell();
+}
+
+void Chessboard::Board::flipVertical()
+{
+    PointIter p_iter(top_left,BOTTOM_LEFT);
+    while(p_iter.bottom());
+
+    std::vector<Cell*>::iterator iter = cells.begin();
+    for(;iter != cells.end();++iter)
+    {
+        Cell *temp = (*iter)->top;
+        (*iter)->top= (*iter)->bottom;
+        (*iter)->bottom = temp;
+
+        cv::Point2f *ptemp = (*iter)->top_left;
+        (*iter)->top_left = (*iter)->bottom_left;
+        (*iter)->bottom_left = ptemp;
+
+        ptemp = (*iter)->top_right;
+        (*iter)->top_right = (*iter)->bottom_right;
+        (*iter)->bottom_right = ptemp;
+    }
+    top_left = p_iter.getCell();
+}
+
+// returns the best found score
+// if NaN is returned for a point no point at all was found
+// if 0 is returned the point lies outside of the ellipse
+float Chessboard::Board::findMaxPoint(cv::flann::Index &index,const cv::Mat &data,const Ellipse &ellipse,float white_angle,float black_angle,cv::Point2f &point)
+{
+    // flann data type enriched with angles (third column)
+    CV_CheckType(data.type(), CV_32FC1, "type of flann data is not supported");
+    CV_CheckEQ(data.cols, 4, "4-cols flann data is expected");
+
+    std::vector<float> query,dists;
+    std::vector<int> indices;
+    query.resize(2);
+    point = ellipse.getCenter();
+    query[0] = point.x;
+    query[1] = point.y;
+    index.knnSearch(query,indices,dists,4,cv::flann::SearchParams(64));
+    std::vector<int>::const_iterator iter = indices.begin();
+    float best_score = -std::numeric_limits<float>::max();
+    point.x = std::numeric_limits<float>::quiet_NaN();
+    point.y = std::numeric_limits<float>::quiet_NaN();
+    for(;iter != indices.end();++iter)
+    {
+        const float *val = data.ptr<float>(*iter);
+        const float &response = *(val+3);
+        if(response < best_score)
+            continue;
+        const float &a0 = *(val+2);
+        float a1 = std::fabs(a0-white_angle);
+        float a2 = std::fabs(a0-black_angle);
+        if(a1 > CV_PI*0.5)
+            a1 = std::fabs(float(a1-CV_PI));
+        if(a2> CV_PI*0.5)
+            a2 = std::fabs(float(a2-CV_PI));
+        if(a1  < MAX_ANGLE || a2 < MAX_ANGLE )
+        {
+            cv::Point2f pt(val[0], val[1]);
+            if(point.x != point.x)       // NaN check
+                point = pt;
+            if(best_score < response && ellipse.contains(pt))
+            {
+                best_score = response;
+                point = pt;
+            }
+        }
+    }
+    if(best_score == -std::numeric_limits<float>::max())
+        return 0;
+    else
+        return best_score;
+}
+
+void Chessboard::Board::clear()
+{
+    top_left = NULL; rows = 0; cols = 0;
+    std::vector<Cell*>::iterator iter = cells.begin();
+    for(;iter != cells.end();++iter)
+        delete *iter;
+    cells.clear();
+    std::vector<cv::Point2f*>::iterator iter2 = corners.begin();
+    for(;iter2 != corners.end();++iter2)
+        delete *iter2;
+    corners.clear();
+}
+
+// p0 p1 p2
+// p3 p4 p5
+// p6 p7 p8
+bool Chessboard::Board::init(const std::vector<cv::Point2f> points)
+{
+    clear();
+    if(points.size() != 9)
+        CV_Error(Error::StsBadArg,"exact nine points are expected to initialize the board");
+
+    // generate cells
+    corners.resize(9);
+    for(int i=0;i < 9;++i)
+        corners[i] = new cv::Point2f(points[i]);
+    cells.resize(4);
+    for(int i=0;i<4;++i)
+        cells[i] = new Cell();
+
+    //cell 0
+    cells[0]->top_left = corners[0];
+    cells[0]->top_right = corners[1];
+    cells[0]->bottom_right = corners[4];
+    cells[0]->bottom_left = corners[3];
+    cells[0]->right = cells[1];
+    cells[0]->bottom = cells[2];
+
+    //cell 1
+    cells[1]->top_left = corners[1];
+    cells[1]->top_right = corners[2];
+    cells[1]->bottom_right = corners[5];
+    cells[1]->bottom_left = corners[4];
+    cells[1]->left = cells[0];
+    cells[1]->bottom = cells[3];
+
+    //cell 2
+    cells[2]->top_left = corners[3];
+    cells[2]->top_right = corners[4];
+    cells[2]->bottom_right = corners[7];
+    cells[2]->bottom_left = corners[6];
+    cells[2]->top = cells[0];
+    cells[2]->right = cells[3];
+
+    //cell 3
+    cells[3]->top_left = corners[4];
+    cells[3]->top_right = corners[5];
+    cells[3]->bottom_right = corners[8];
+    cells[3]->bottom_left = corners[7];
+    cells[3]->top = cells[1];
+    cells[3]->left= cells[2];
+
+    top_left = cells.front();
+    rows = 3;
+    cols = 3;
+
+    // set initial cell colors
+    Point2f pt1 = *(cells[0]->top_right)-*(cells[0]->bottom_left);
+    pt1 /= cv::norm(pt1);
+    cv::Point2f pt2(std::cos(white_angle),-std::sin(white_angle));
+    cv::Point2f pt3(std::cos(black_angle),-std::sin(black_angle));
+    if(fabs(pt1.dot(pt2)) < fabs(pt1.dot(pt3)))
+    {
+        cells[0]->black = false;
+        cells[1]->black = true;
+        cells[2]->black = true;
+        cells[3]->black = false;
+    }
+    else
+    {
+        cells[0]->black = true;
+        cells[1]->black = false;
+        cells[2]->black = false;
+        cells[3]->black = true;
+    }
+    return true;
+}
+
+//TODO magic number
+bool Chessboard::Board::estimatePoint(const cv::Point2f &p0,const cv::Point2f &p1,const cv::Point2f &p2, cv::Point2f &p3)
+{
+    // use cross ration to find new point
+    if(p0 == p1 || p0 == p2 || p1 == p2)
+        return false;
+    cv::Point2f p01 = p1-p0;
+    cv::Point2f p12 = p2-p1;
+    float a = float(cv::norm(p01));
+    float b = float(cv::norm(p12));
+    float t = (0.75F*a-0.25F*b);
+    if(t <= 0)
+        return false;
+    float c = 0.25F*b*(a+b)/t;
+    if(c < 0.1F)
+        return false;
+    p01 = p01/a;
+    p12 = p12/b;
+    // check angle between p01 and p12 < 25°
+    if(p01.dot(p12) < 0.9)
+        return false;
+    // calc mean
+    // p12 = (p01+p12)*0.5;
+    // p3 = p2+p12*c;
+    p3 = p2+p12*c;
+
+    // compensate radial distortion by fitting polynom
+    std::vector<double> x,y;
+    x.resize(3,0); y.resize(3,0);
+    x[1] = b;
+    x[2] = b+a;
+    y[2] = calcSignedDistance(-p12,p2,p0);
+    cv::Mat dst;
+    polyfit(cv::Mat(x),cv::Mat(y),dst,2);
+    double d = dst.at<double>(0)-dst.at<double>(1)*c+dst.at<double>(2)*c*c;
+    cv::Vec3f v1(p12.x,p12.y,0);
+    cv::Vec3f v2(0,0,1);
+    cv::Vec3f v3 = v1.cross(v2);
+    cv::Point2f n2(v3[0],v3[1]);
+    p3 += d*n2;
+    return true;
+}
+
+bool Chessboard::Board::estimatePoint(const cv::Point2f &p0,const cv::Point2f &p1,const cv::Point2f &p2, const cv::Point2f &p3, cv::Point2f &p4)
+{
+    // use 1D homography to find fith point minimizing square error
+    if(p0 == p1 || p0 == p2 || p0 == p3 || p1 == p2 || p1 == p3 || p2 == p3 )
+        return false;
+    static const cv::Mat src = (cv::Mat_<double>(1,4) << 0,10,20,30);
+    cv::Point2f p01 = p1-p0;
+    cv::Point2f p02 = p2-p0;
+    cv::Point2f p03 = p3-p0;
+    float a = float(cv::norm(p01));
+    float b = float(cv::norm(p02));
+    float c = float(cv::norm(p03));
+    cv::Mat dst = (cv::Mat_<double>(1,4) << 0,a,b,c);
+    cv::Mat h = findHomography1D(src,dst);
+    float d = float((h.at<double>(0,0)*40+h.at<double>(0,1))/(h.at<double>(1,0)*40+h.at<double>(1,1)));
+    cv::Point2f p12 = p2-p1;
+    cv::Point2f p23 = p3-p2;
+    p01 = p01/a;
+    p12 = p12/cv::norm(p12);
+    p23 = p23/cv::norm(p23);
+    p4 = p3+(d-c)*p23;
+
+    // compensate radial distortion by fitting polynom
+    std::vector<double> x,y;
+    x.resize(4,0); y.resize(4,0);
+    x[1] = c-b;
+    x[2] = c-a;
+    x[3] = c;
+    y[2] = calcSignedDistance(-p23,p3,p1);
+    y[3] = calcSignedDistance(-p23,p3,p0);
+    polyfit(cv::Mat(x),cv::Mat(y),dst,2);
+    d = d-c;
+    double e = dst.at<double>(0)-dst.at<double>(1)*fabs(d)+dst.at<double>(2)*d*d;
+    cv::Vec3f v1(p23.x,p23.y,0);
+    cv::Vec3f v2(0,0,1);
+    cv::Vec3f v3 = v1.cross(v2);
+    cv::Point2f n2(v3[0],v3[1]);
+    p4 += e*n2;
+    return true;
+}
+
+// H is describing the transformation from dummy to reality
+Ellipse Chessboard::Board::estimateSearchArea(cv::Mat _H,int row, int col,float p,int field_size)
+{
+    cv::Matx31d point1,point2,center;
+    center(0) = (1+col)*field_size;
+    center(1) = (1+row)*field_size;
+    center(2) = 1.0;
+    point1(0) = center(0)-p*field_size;
+    point1(1) = center(1);
+    point1(2) = center(2);
+    point2(0) = center(0);
+    point2(1) = center(1)-p*field_size;
+    point2(2) = center(2);
+
+    cv::Matx33d H(_H);
+    point1 = H*point1;
+    point2 = H*point2;
+    center = H*center;
+    cv::Point2f pt(float(center(0)/center(2)),float(center(1)/center(2)));
+    cv::Point2f pt1(float(point1(0)/point1(2)),float(point1(1)/point1(2)));
+    cv::Point2f pt2(float(point2(0)/point2(2)),float(point2(1)/point2(2)));
+
+    cv::Point2f p01(pt1-pt);
+    cv::Point2f p02(pt2-pt);
+    float norm1 = float(cv::norm(p01));
+    float norm2 = float(cv::norm(p02));
+    float angle = float(std::acos(p01.dot(p02)/norm1/norm2));
+    cv::Size2f axes(norm1,norm2);
+    return Ellipse(pt,axes,angle);
+}
+
+bool Chessboard::Board::estimateSearchArea(const cv::Point2f &p1,const cv::Point2f &p2,const cv::Point2f &p3,float p,Ellipse &ellipse,const cv::Point2f *p0)
+{
+    cv::Point2f p4,n;
+    if(p0)
+    {
+        // use 1D homography
+        if(!estimatePoint(*p0,p1,p2,p3,p4))
+            return false;
+        n = p4-*p0;
+    }
+    else
+    {
+        // use cross ratio
+        if(!estimatePoint(p1,p2,p3,p4))
+            return false;
+        n = p4-p1;
+    }
+    float norm = float(cv::norm(n));
+    n = n/norm;
+    float angle = std::acos(n.x);
+    if(n.y > 0)
+        angle = float(2.0F*CV_PI-angle);
+    n = p4-p3;
+    norm = float(cv::norm(n));
+    double delta = std::max(3.0F,p*norm);
+    ellipse = Ellipse(p4,cv::Size(int(delta),int(std::max(2.0,delta*ELLIPSE_WIDTH))),angle);
+    return true;
+}
+
+bool Chessboard::Board::checkRowColumn(const std::vector<cv::Point2f> &points)
+{
+    if(points.size() < 4)
+    {
+        if(points.size() == 3)
+            return true;
+        else
+            return false;
+    }
+    std::vector<cv::Point2f>::const_iterator iter = points.begin();
+    std::vector<cv::Point2f>::const_iterator iter2 = iter+1;
+    std::vector<cv::Point2f>::const_iterator iter3 = iter2+1;
+    std::vector<cv::Point2f>::const_iterator iter4 = iter3+1;
+    Ellipse ellipse;
+    if(!estimateSearchArea(*iter4,*iter3,*iter2,CORNERS_SEARCH*3,ellipse))
+        return false;
+    if(!ellipse.contains(*iter))
+        return false;
+
+    std::vector<cv::Point2f>::const_iterator iter5 = iter4+1;
+    for(;iter5 != points.end();++iter5)
+    {
+        if(!estimateSearchArea(*iter2,*iter3,*iter4,CORNERS_SEARCH,ellipse,&(*iter)))
+            return false;
+        if(!ellipse.contains(*iter5))
+            return false;
+        iter = iter2;
+        iter2 = iter3;
+        iter3 = iter4;
+        iter4 = iter5;
+    }
+    return true;
+}
+
+cv::Point2f &Chessboard::Board::getCorner(int _row,int _col)
+{
+    int _rows = int(rowCount());
+    int _cols = int(colCount());
+    if(_row >= _rows || _col >= _cols)
+        CV_Error(Error::StsBadArg,"out of bound");
+    if(_row == 0)
+    {
+        PointIter iter(top_left,TOP_LEFT);
+        int count = 0;
+        do
+        {
+            if(count == _col)
+                return *(*iter);
+            ++count;
+        }while(iter.right());
+    }
+    else
+    {
+        Cell *row_start = top_left;
+        int count = 1;
+        do
+        {
+            if(count == _row)
+            {
+                PointIter iter(row_start,BOTTOM_LEFT);
+                int count2 = 0;
+                do
+                {
+                    if(count2 == _col)
+                        return *(*iter);
+                    ++count2;
+                }while(iter.right());
+            }
+            ++count;
+            row_start = row_start->bottom;
+        }while(row_start);
+    }
+    CV_Error(Error::StsInternal,"cannot find corner");
+    // return *top_left->top_left; // never reached
+}
+
+bool Chessboard::Board::isCellBlack(int row,int col)const
+{
+    return getCell(row,col)->black;
+}
+
+bool Chessboard::Board::hasCellMarker(int row,int col)
+{
+    return getCell(row,col)->marker;
+}
+
+int Chessboard::Board::detectMarkers(cv::InputArray image)
+{
+    cv::Mat img = image.getMat();
+    CV_CheckTypeEQ(img.type(), CV_8UC1, "Unsupported source type");
+    if(img.empty())
+        CV_Error(Error::StsBadArg,"image is empty");
+    if(isEmpty())
+        CV_Error(Error::StsBadArg,"board is is empty");
+
+    // get undistorted board
+    cv::Mat board_image = warpImage(image);
+
+    cv::Mat mask = cv::Mat::zeros(DUMMY_FIELD_SIZE,DUMMY_FIELD_SIZE,CV_8UC1);
+    cv::circle(mask,cv::Point(DUMMY_FIELD_SIZE/2,DUMMY_FIELD_SIZE/2),DUMMY_FIELD_SIZE/7,cv::Scalar::all(255),-1);
+    int signal_size = cv::countNonZero(mask);
+    CV_Assert(signal_size > 0);
+
+    cv::Mat mask2 = cv::Mat::zeros(DUMMY_FIELD_SIZE,DUMMY_FIELD_SIZE,CV_8UC1);
+    cv::circle(mask2,cv::Point(DUMMY_FIELD_SIZE/2,DUMMY_FIELD_SIZE/2),DUMMY_FIELD_SIZE/2,cv::Scalar::all(255),-1);
+    cv::circle(mask2,cv::Point(DUMMY_FIELD_SIZE/2,DUMMY_FIELD_SIZE/2),DUMMY_FIELD_SIZE/5,cv::Scalar::all(0),-1);
+    int noise_size = cv::countNonZero(mask2);
+    CV_Assert(noise_size > 0);
+
+    std::vector<cv::Point2f> dst,src;
+    dst.push_back(cv::Point2f(0.0F,0.0F));
+    dst.push_back(cv::Point2f(float(DUMMY_FIELD_SIZE),0.0F));
+    dst.push_back(cv::Point2f(float(DUMMY_FIELD_SIZE),float(DUMMY_FIELD_SIZE)));
+    dst.push_back(cv::Point2f(0.0F,float(DUMMY_FIELD_SIZE)));
+    src.resize(4);
+
+    // check each field
+    int icols = int(colCount()-1);
+    int irows = int(rowCount()-1);
+    int count = 0;
+    cv::Mat temp;
+    for(int y=1;y<irows;++y)
+    {
+        for(int x=1;x<icols;++x)
+        {
+            Cell *cell = getCell(y,x);
+
+            // calculate homography for each field to avoid issues with
+            // distorted images
+            src[0] = *cell->top_left;
+            src[1] = *cell->top_right;
+            src[2] = *cell->bottom_right;
+            src[3] = *cell->bottom_left;
+            cv::Mat H = findHomography(src,dst,LMEDS);
+            cv::Mat field;
+            cv::warpPerspective(image,field,H,cv::Size(DUMMY_FIELD_SIZE,DUMMY_FIELD_SIZE));
+
+            // calc signal and noise value
+            cv::bitwise_and(field,mask,temp);
+            double signal = cv::sum(temp)[0]/signal_size;
+            cv::bitwise_and(field,mask2,temp);
+            double noise= cv::sum(temp)[0]/noise_size;
+
+            // calc reference value
+            Cell *cell2 = getCell(y,abs(x-1));
+            src[0] = *cell2->top_left;
+            src[1] = *cell2->top_right;
+            src[2] = *cell2->bottom_right;
+            src[3] = *cell2->bottom_left;
+            H = findHomography(src,dst,LMEDS);
+            cv::warpPerspective(image,field,H,cv::Size(DUMMY_FIELD_SIZE,DUMMY_FIELD_SIZE));
+            cv::bitwise_and(field,mask2,temp);
+            double reference = cv::sum(temp)[0]/noise_size;
+            // check if marker is present
+            if(cell->black)
+                cell->marker = signal-noise > (reference-noise)*0.5;
+            else
+                cell->marker = noise-signal > (noise-reference)*0.5;
+            if(cell->marker)
+                count++;
+            CV_LOG_DEBUG(NULL, "Cell: " << x << "/" << y << " signal " << signal << " noise " << noise << " reference " << reference  << " has marker " << int(cell->marker));
+        }
+    }
+    return count;
+}
+
+bool Chessboard::Board::isCellEmpty(int row,int col)
+{
+    return getCell(row,col)->empty();
+}
+
+Chessboard::Board::Cell* Chessboard::Board::getCell(int row,int col)
+{
+    const Cell *cell = const_cast<const Board*>(this)->getCell(row,col);
+    return const_cast<Cell*>(cell);
+}
+
+const Chessboard::Board::Cell* Chessboard::Board::getCell(int row,int col)const
+{
+    if(row > rows-1 || row < 0 || col > cols-1 || col < 0)
+        CV_Error(Error::StsBadArg,"out of bound");
+    PointIter p_iter(top_left,BOTTOM_RIGHT);
+    for(int i=0; i< row; p_iter.bottom(),++i);
+    for(int i=0; i< col; p_iter.right(),++i);
+    return p_iter.getCell();
+}
+
+
+bool Chessboard::Board::isEmpty()const
+{
+    return cells.empty();
+}
+
+size_t Chessboard::Board::colCount()const
+{
+    return cols;
+}
+
+size_t Chessboard::Board::rowCount()const
+{
+    return rows;
+}
+
+cv::Size Chessboard::Board::getSize()const
+{
+    return cv::Size(int(colCount()),int(rowCount()));
+}
+
+void Chessboard::Board::drawEllipses(const std::vector<Ellipse> &ellipses)
+{
+    // currently there is no global image find way to store global image
+    // without polluting namespace
+    if(ellipses.empty())
+        return;     //avoid compiler warning
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    cv::Mat img;
+    draw(debug_image,img);
+    std::vector<Ellipse>::const_iterator iter = ellipses.begin();
+    for(;iter != ellipses.end();++iter)
+        iter->draw(img);
+    cv::imshow("chessboard",img);
+    cv::waitKey(-1);
+#endif
+}
+
+
+// TODO also delete points
+bool Chessboard::Board::shrinkLeft()
+{
+    if(colCount() < 4)
+        return false;
+
+    // unlink cells on the left side and delete them
+    top_left = top_left->right;
+    PointIter iter(top_left,BOTTOM_RIGHT);
+    do
+    {
+        auto cell = iter.getCell();
+        auto citer = std::find(cells.begin(),cells.end(),cell->left);
+        delete cell->left;
+        cell->left= NULL;
+        cells.erase(citer);
+    }
+    while(iter.bottom());
+    --cols;
+    return true;
+}
+
+bool Chessboard::Board::shrinkRight()
+{
+    if(colCount() < 4)
+        return false;
+
+    // unlink cells on the left side and delete them
+    PointIter iter(top_left,BOTTOM_RIGHT);
+    while(iter.right());
+    iter.left();
+    iter.left();
+    do
+    {
+        auto cell = iter.getCell();
+        auto citer = std::find(cells.begin(),cells.end(),cell->right);
+        delete cell->right;
+        cell->right= NULL;
+        cells.erase(citer);
+    }
+    while(iter.bottom());
+    --cols;
+    return true;
+}
+
+bool Chessboard::Board::shrinkTop()
+{
+    if(rowCount() < 4)
+        return false;
+
+    // unlink cells on the left side and delete them
+    top_left = top_left->bottom;
+    PointIter iter(top_left,BOTTOM_RIGHT);
+    do
+    {
+        auto cell = iter.getCell();
+        auto citer = std::find(cells.begin(),cells.end(),cell->top);
+        delete cell->top;
+        cell->top= NULL;
+        cells.erase(citer);
+    }
+    while(iter.right());
+    --rows;
+    return true;
+}
+
+bool Chessboard::Board::shrinkBottom()
+{
+    if(rowCount() < 4)
+        return false;
+
+    // unlink cells on the left side and delete them
+    PointIter iter(top_left,BOTTOM_RIGHT);
+    while(iter.bottom());
+    iter.top();
+    iter.top();
+    do
+    {
+        auto cell = iter.getCell();
+        auto citer = std::find(cells.begin(),cells.end(),cell->bottom);
+        delete cell->bottom;
+        cell->bottom= NULL;
+        cells.erase(citer);
+    }
+    while(iter.right());
+    --rows;
+    return true;
+}
+
+void Chessboard::Board::growLeft()
+{
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+    PointIter iter(top_left,TOP_LEFT);
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.right();
+        cv::Point2f *p1 = *iter2;
+        iter2.right();
+        cv::Point2f *p2 = *iter2;
+        if(iter2.right())
+            estimatePoint(**iter2,*p2,*p1,*p0,pt);
+        else
+            estimatePoint(*p2,*p1,*p0,pt);
+        points.push_back(pt);
+    }
+    while(iter.bottom());
+    addColumnLeft(points);
+}
+
+bool Chessboard::Board::growLeft(const cv::Mat &map,cv::flann::Index &flann_index)
+{
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    std::vector<Ellipse> ellipses;
+#endif
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"growLeft: Board is empty");
+    PointIter iter(top_left,TOP_LEFT);
+    std::vector<cv::Point2f> points;
+    int count = 0;
+    Ellipse ellipse;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.right();
+        cv::Point2f *p1 = *iter2;
+        iter2.right();
+        cv::Point2f *p2 = *iter2;
+        cv::Point2f *p3 = NULL;
+        if(iter2.right())
+            p3 = *iter2;
+        if(!estimateSearchArea(*p2,*p1,*p0,CORNERS_SEARCH,ellipse,p3))
+            return false;
+        float result = findMaxPoint(flann_index,map,ellipse,white_angle,black_angle,pt);
+        if(pt == *p0)
+        {
+            ++count;
+            points.push_back(ellipse.getCenter());
+            if(points.back().x < 0 || points.back().y <0)
+                return false;
+        }
+        else if(result != 0)
+        {
+            points.push_back(pt);
+            if(result < 0)
+                ++count;
+        }
+        else
+        {
+            ++count;
+            if(pt.x != pt.x)    // NaN check
+                points.push_back(ellipse.getCenter());
+            else
+                points.push_back(pt);
+        }
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+        ellipses.push_back(ellipse);
+#endif
+    }
+    while(iter.bottom());
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    drawEllipses(ellipses);
+#endif
+    if(points.size()-count <= 2)
+        return false;
+    if(count > points.size()*0.5 || !checkRowColumn(points))
+        return false;
+    addColumnLeft(points);
+    return true;
+}
+
+void Chessboard::Board::growTop()
+{
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+    PointIter iter(top_left,TOP_LEFT);
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.bottom();
+        cv::Point2f *p1 = *iter2;
+        iter2.bottom();
+        cv::Point2f *p2 = *iter2;
+        if(iter2.bottom())
+            estimatePoint(**iter2,*p2,*p1,*p0,pt);
+        else
+            estimatePoint(*p2,*p1,*p0,pt);
+        points.push_back(pt);
+    }
+    while(iter.right());
+    addRowTop(points);
+}
+
+bool Chessboard::Board::growTop(const cv::Mat &map,cv::flann::Index &flann_index)
+{
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    std::vector<Ellipse> ellipses;
+#endif
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+
+    PointIter iter(top_left,TOP_LEFT);
+    std::vector<cv::Point2f> points;
+    int count = 0;
+    Ellipse ellipse;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.bottom();
+        cv::Point2f *p1 = *iter2;
+        iter2.bottom();
+        cv::Point2f *p2 = *iter2;
+        cv::Point2f *p3 = NULL;
+        if(iter2.bottom())
+            p3 = *iter2;
+        if(!estimateSearchArea(*p2,*p1,*p0,CORNERS_SEARCH,ellipse,p3))
+            return false;
+        float result = findMaxPoint(flann_index,map,ellipse,white_angle,black_angle,pt);
+        if(pt == *p0)
+        {
+            ++count;
+            points.push_back(ellipse.getCenter());
+            if(points.back().x < 0 || points.back().y <0)
+                return false;
+        }
+        else if(result != 0)
+        {
+            points.push_back(pt);
+            if(result < 0)
+                ++count;
+        }
+        else
+        {
+            ++count;
+            if(pt.x != pt.x)    // NaN check
+                points.push_back(ellipse.getCenter());
+            else
+                points.push_back(pt);
+        }
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+        ellipses.push_back(ellipse);
+#endif
+    }
+    while(iter.right());
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    drawEllipses(ellipses);
+#endif
+    if(count > points.size()*0.5 || !checkRowColumn(points))
+        return false;
+    addRowTop(points);
+    return true;
+}
+
+void Chessboard::Board::growRight()
+{
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+    PointIter iter(top_left,TOP_RIGHT);
+    while(iter.right());
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.left();
+        cv::Point2f *p1 = *iter2;
+        iter2.left();
+        cv::Point2f *p2 = *iter2;
+        if(iter2.left())
+            estimatePoint(**iter2,*p2,*p1,*p0,pt);
+        else
+            estimatePoint(*p2,*p1,*p0,pt);
+        points.push_back(pt);
+    }
+    while(iter.bottom());
+    addColumnRight(points);
+}
+
+bool Chessboard::Board::growRight(const cv::Mat &map,cv::flann::Index &flann_index)
+{
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    std::vector<Ellipse> ellipses;
+#endif
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+
+    PointIter iter(top_left,TOP_RIGHT);
+    while(iter.right());
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    Ellipse ellipse;
+    int count = 0;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.left();
+        cv::Point2f *p1 = *iter2;
+        iter2.left();
+        cv::Point2f *p2 = *iter2;
+        cv::Point2f *p3 = NULL;
+        if(iter2.left())
+            p3 = *iter2;
+        if(!estimateSearchArea(*p2,*p1,*p0,CORNERS_SEARCH,ellipse,p3))
+            return false;
+        float result = findMaxPoint(flann_index,map,ellipse,white_angle,black_angle,pt);
+        if(pt == *p0)
+        {
+            ++count;
+            points.push_back(ellipse.getCenter());
+            if(points.back().x < 0 || points.back().y <0)
+                return false;
+        }
+        else if(result != 0)
+        {
+            points.push_back(pt);
+            if(result < 0)
+                ++count;
+        }
+        else
+        {
+            ++count;
+            if(pt.x != pt.x)     // NaN check
+                points.push_back(ellipse.getCenter());
+            else
+                points.push_back(pt);
+        }
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+        ellipses.push_back(ellipse);
+#endif
+    }
+    while(iter.bottom());
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    drawEllipses(ellipses);
+#endif
+    if(count > points.size()*0.5 || !checkRowColumn(points))
+        return false;
+    addColumnRight(points);
+    return true;
+}
+
+void Chessboard::Board::growBottom()
+{
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+
+    PointIter iter(top_left,BOTTOM_LEFT);
+    while(iter.bottom());
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.top();
+        cv::Point2f *p1 = *iter2;
+        iter2.top();
+        cv::Point2f *p2 = *iter2;
+        if(iter2.top())
+            estimatePoint(**iter2,*p2,*p1,*p0,pt);
+        else
+            estimatePoint(*p2,*p1,*p0,pt);
+        points.push_back(pt);
+    }
+    while(iter.right());
+    addRowBottom(points);
+}
+
+bool Chessboard::Board::growBottom(const cv::Mat &map,cv::flann::Index &flann_index)
+{
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    std::vector<Ellipse> ellipses;
+#endif
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+
+    PointIter iter(top_left,BOTTOM_LEFT);
+    while(iter.bottom());
+    std::vector<cv::Point2f> points;
+    cv::Point2f pt;
+    Ellipse ellipse;
+    int count = 0;
+    do
+    {
+        PointIter iter2(iter);
+        cv::Point2f *p0 = *iter2;
+        iter2.top();
+        cv::Point2f *p1 = *iter2;
+        iter2.top();
+        cv::Point2f *p2 = *iter2;
+        cv::Point2f *p3 = NULL;
+        if(iter2.top())
+            p3 = *iter2;
+        if(!estimateSearchArea(*p2,*p1,*p0,CORNERS_SEARCH,ellipse,p3))
+            return false;
+        float result = findMaxPoint(flann_index,map,ellipse,white_angle,black_angle,pt);
+        if(pt == *p0)
+        {
+            ++count;
+            points.push_back(ellipse.getCenter());
+            if(points.back().x < 0 || points.back().y <0)
+                return false;
+        }
+        else if(result != 0)
+        {
+            points.push_back(pt);
+            if(result < 0)
+                ++count;
+        }
+        else
+        {
+            ++count;
+            if(pt.x != pt.x)     // NaN check
+                points.push_back(ellipse.getCenter());
+            else
+                points.push_back(pt);
+        }
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+        ellipses.push_back(ellipse);
+#endif
+    }
+    while(iter.right());
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    drawEllipses(ellipses);
+#endif
+    if(count > points.size()*0.5 || !checkRowColumn(points))
+        return false;
+    addRowBottom(points);
+    return true;
+}
+
+void Chessboard::Board::addColumnLeft(const std::vector<cv::Point2f> &points)
+{
+    if(points.empty() || points.size() != rowCount())
+        CV_Error(Error::StsBadArg,"wrong number of points");
+
+    int offset = int(cells.size());
+    cells.resize(offset+points.size()-1);
+    for(int i = offset;i < (int) cells.size();++i)
+        cells[i] = new Cell();
+    corners.push_back(new cv::Point2f(points.front()));
+
+    Cell *cell = top_left;
+    std::vector<cv::Point2f>::const_iterator iter = points.begin()+1;
+    for(int pos=offset;iter != points.end();++iter,cell = cell->bottom,++pos)
+    {
+        cell->left = cells[pos];
+        cells[pos]->black = !cell->black;
+        if(pos != offset)
+            cells[pos]->top = cells[pos-1];
+        cells[pos]->right = cell;
+        if(pos +1 < (int)cells.size())
+            cells[pos]->bottom= cells[pos+1];
+        cells[pos]->top_left = corners.back();
+        corners.push_back(new cv::Point2f(*iter));
+        cells[pos]->bottom_left = corners.back();
+        cells[pos]->top_right=cell->top_left;
+        cells[pos]->bottom_right=cell->bottom_left;
+    }
+    top_left = cells[offset];
+    ++cols;
+}
+
+void Chessboard::Board::addRowTop(const std::vector<cv::Point2f> &points)
+{
+    if(points.empty() || points.size() != colCount())
+        CV_Error(Error::StsBadArg,"wrong number of points");
+
+    int offset = int(cells.size());
+    cells.resize(offset+points.size()-1);
+    for(int i = offset;i < (int) cells.size();++i)
+        cells[i] = new Cell();
+    corners.push_back(new cv::Point2f(points.front()));
+
+    Cell *cell = top_left;
+    std::vector<cv::Point2f>::const_iterator iter = points.begin()+1;
+    for(int pos=offset;iter != points.end();++iter,cell = cell->right,++pos)
+    {
+        cell->top = cells[pos];
+        cells[pos]->black = !cell->black;
+        if(pos != offset)
+            cells[pos]->left= cells[pos-1];
+        cells[pos]->bottom= cell;
+        if(pos +1 <(int) cells.size())
+            cells[pos]->right= cells[pos+1];
+
+        cells[pos]->top_left = corners.back();
+        corners.push_back(new cv::Point2f(*iter));
+        cells[pos]->top_right = corners.back();
+        cells[pos]->bottom_left = cell->top_left;
+        cells[pos]->bottom_right = cell->top_right;
+    }
+    top_left = cells[offset];
+    ++rows;
+}
+
+void Chessboard::Board::addColumnRight(const std::vector<cv::Point2f> &points)
+{
+    if(points.empty() || points.size() != rowCount())
+        CV_Error(Error::StsBadArg,"wrong number of points");
+
+    int offset = int(cells.size());
+    cells.resize(offset+points.size()-1);
+    for(int i = offset;i < (int) cells.size();++i)
+        cells[i] = new Cell();
+    corners.push_back(new cv::Point2f(points.front()));
+
+    Cell *cell = top_left;
+    for(;cell->right;cell = cell->right);
+    std::vector<cv::Point2f>::const_iterator iter = points.begin()+1;
+    for(int pos=offset;iter != points.end();++iter,cell = cell->bottom,++pos)
+    {
+        cell->right = cells[pos];
+        cells[pos]->black = !cell->black;
+        if(pos != offset)
+            cells[pos]->top= cells[pos-1];
+        cells[pos]->left = cell;
+        if(pos +1 <(int) cells.size())
+            cells[pos]->bottom= cells[pos+1];
+
+        cells[pos]->top_right = corners.back();
+        corners.push_back(new cv::Point2f(*iter));
+        cells[pos]->bottom_right = corners.back();
+        cells[pos]->top_left =cell->top_right;
+        cells[pos]->bottom_left =cell->bottom_right;
+    }
+    ++cols;
+}
+
+void Chessboard::Board::addRowBottom(const std::vector<cv::Point2f> &points)
+{
+    if(points.empty() || points.size() != colCount())
+        CV_Error(Error::StsBadArg,"wrong number of points");
+
+    int offset = int(cells.size());
+    cells.resize(offset+points.size()-1);
+    for(int i = offset;i < (int) cells.size();++i)
+        cells[i] = new Cell();
+    corners.push_back(new cv::Point2f(points.front()));
+
+    Cell *cell = top_left;
+    for(;cell->bottom;cell = cell->bottom);
+    std::vector<cv::Point2f>::const_iterator iter = points.begin()+1;
+    for(int pos=offset;iter != points.end();++iter,cell = cell->right,++pos)
+    {
+        cell->bottom = cells[pos];
+        cells[pos]->black = !cell->black;
+        if(pos != offset)
+            cells[pos]->left = cells[pos-1];
+        cells[pos]->top = cell;
+        if(pos +1 < (int)cells.size())
+            cells[pos]->right= cells[pos+1];
+
+        cells[pos]->bottom_left = corners.back();
+        corners.push_back(new cv::Point2f(*iter));
+        cells[pos]->bottom_right = corners.back();
+        cells[pos]->top_left = cell->bottom_left;
+        cells[pos]->top_right = cell->bottom_right;
+    }
+    ++rows;
+}
+
+bool Chessboard::Board::checkUnique()const
+{
+    std::vector<cv::Point2f> points = getCorners(false);
+    std::vector<cv::Point2f>::const_iterator iter = points.begin();
+    for(;iter != points.end();++iter)
+    {
+        std::vector<cv::Point2f>::const_iterator iter2 = iter+1;
+        for(;iter2 != points.end();++iter2)
+        {
+            if(*iter == *iter2)
+                return false;
+        }
+    }
+    return true;
+}
+
+int Chessboard::Board::validateCorners(const cv::Mat &data,cv::flann::Index &flann_index,const cv::Mat &h,float min_response)
+{
+    // TODO check input
+    if(isEmpty() || h.empty())
+        return 0;
+    int count = 0; int icol = 0;
+    // first row
+    PointIter iter(top_left,TOP_LEFT);
+    cv::Point2f point;
+    do
+    {
+        if((*iter)->x == (*iter)->x)
+            ++count;
+        else
+        {
+            Ellipse ellipse = estimateSearchArea(h,0,icol,0.4F);
+            float result = findMaxPoint(flann_index,data,ellipse,white_angle,black_angle,point);
+            if(fabs(result) >= min_response)
+            {
+                ++count;
+                **iter = point;
+            }
+        }
+        ++icol;
+    }while(iter.right());
+
+    // all other rows
+    int irow = 1;
+    Cell *row = top_left;
+    do
+    {
+        PointIter iter2(row,BOTTOM_LEFT);
+        icol = 0;
+        do
+        {
+            if((*iter2)->x == (*iter2)->x)
+                ++count;
+            else
+            {
+                Ellipse ellipse = estimateSearchArea(h,irow,icol,0.4F);
+                if(min_response <= findMaxPoint(flann_index,data,ellipse,white_angle,black_angle,point))
+                {
+                    ++count;
+                    **iter2 = point;
+                }
+            }
+            ++icol;
+        }while(iter2.right());
+        row = row->bottom;
+        ++irow;
+    }while(row);
+
+    // check that there are no points with the same coordinate
+    std::vector<cv::Point2f> points = getCorners(false);
+    std::vector<cv::Point2f>::const_iterator iter1 = points.begin();
+    for(;iter1 != points.end();++iter1)
+    {
+        // we do not have to check for NaN because of getCorners(false)
+        std::vector<cv::Point2f>::const_iterator iter2 = iter1+1;
+        for(;iter2 != points.end();++iter2)
+            if(*iter1 == *iter2)
+                return -1;  // one corner is there twice -> not valid configuration
+    }
+    return count;
+}
+
+bool Chessboard::Board::validateContour()const
+{
+    std::vector<cv::Point2f> contour = getContour();
+    if(contour.size() != 4)
+    {
+        return false;
+    }
+    cv::Point2f n1 = contour[1]-contour[0];
+    cv::Point2f n2 = contour[2]-contour[1];
+    cv::Point2f n3 = contour[3]-contour[2];
+    cv::Point2f n4 = contour[0]-contour[3];
+    n1 = n1/cv::norm(n1);
+    n2 = n2/cv::norm(n2);
+    n3 = n3/cv::norm(n3);
+    n4 = n4/cv::norm(n4);
+    // a > b => cos(a) < cos(b)
+    if(fabs(n1.dot(n2)) > MIN_COS_ANGLE||
+            fabs(n2.dot(n3)) > MIN_COS_ANGLE||
+            fabs(n3.dot(n4)) > MIN_COS_ANGLE||
+            fabs(n4.dot(n1)) > MIN_COS_ANGLE)
+        return false;
+    return true;
+}
+
+std::vector<cv::Point2f> Chessboard::Board::getContour()const
+{
+    std::vector<cv::Point2f> points;
+    if(isEmpty())
+        return points;
+
+    //find start cell part of the contour
+    Cell* start_cell = NULL;
+    PointIter iter(top_left,TOP_LEFT);
+    do
+    {
+        PointIter iter2(iter);
+        do
+        {
+            if(!iter2.getCell()->empty())
+            {
+                start_cell = iter2.getCell();
+                iter = iter2;
+                break;
+            }
+        }while(iter2.right());
+    }while(!start_cell && iter.bottom());
+    if(start_cell == NULL)
+        return points;
+
+    // trace contour
+    const cv::Point2f *start_pt = *iter;
+    int mode = 2; int last = -1;
+    do
+    {
+        PointIter current_iter(iter);
+        switch(mode)
+        {
+        case 1: // top
+            if(iter.top(true))
+            {
+                if(last != 1)
+                    points.push_back(**current_iter);
+                mode = 4;
+                last = 1;
+                break;
+            }
+            /* fallthrough */
+        case 2: // right
+            if(iter.right(true))
+            {
+                if(last != 2)
+                    points.push_back(**current_iter);
+                mode = 1;
+                last = 2;
+                break;
+            }
+            /* fallthrough */
+        case 3: // bottom
+            if(iter.bottom(true))
+            {
+                if(last != 3)
+                    points.push_back(**current_iter);
+                mode = 2;
+                last = 3;
+                break;
+            }
+            /* fallthrough */
+        case 4: // left
+            if(iter.left(true))
+            {
+                if(last != 4)
+                    points.push_back(**current_iter);
+                mode = 3;
+                last = 4;
+                break;
+            }
+            mode = 1;
+            break;
+        default:
+            CV_Error(Error::StsInternal,"cannot retrieve contour");
+        }
+    }while(*iter != start_pt);
+    return points;
+}
+
+void Chessboard::Board::maskImage(cv::InputOutputArray img,const cv::Scalar &color)const
+{
+    Chessboard::Board temp(*this);
+    temp.growLeft();
+    temp.growRight();
+    temp.growTop();
+    temp.growBottom();
+    cv::Mat contour;
+    cv::Mat(temp.getContour()).convertTo(contour,CV_32S);
+    std::vector<cv::Mat> contours;
+    contours.push_back(contour);
+    cv::drawContours(img,contours,0,color,-1);
+}
+
+cv::Mat Chessboard::Board::estimateHomography(cv::Rect rect,int field_size)const
+{
+    int _rows = int(rowCount());
+    int _cols = int(colCount());
+    if(_rows < 3  || _cols < 3)
+        return cv::Mat();
+    if(rect.width <= 0)
+        rect.width= _cols;
+    if(rect.height <= 0)
+        rect.height= _rows;
+
+    int col_end = std::min(rect.x+rect.width,_cols);
+    int row_end = std::min(rect.y+rect.height,_rows);
+    std::vector<cv::Point2f> points = getCorners(true);
+
+    // build src and dst
+    std::vector<cv::Point2f> src,dst;
+    for(int row =rect.y;row < row_end;++row)
+    {
+        for(int col=rect.x;col <col_end;++col)
+        {
+            const cv::Point2f &pt = points[row*_rows+col];
+            if(pt.x != pt.x)    // NaN check
+                continue;
+            src.push_back(cv::Point2f(float(field_size)*(col+1),float(field_size)*(row+1)));
+            dst.push_back(pt);
+        }
+    }
+    if(dst.size() < 4)
+        return cv::Mat();
+    return findHomography(src, dst,LMEDS);
+}
+
+cv::Mat Chessboard::Board::estimateHomography(int field_size)const
+{
+    int _rows = int(rowCount());
+    int _cols = int(colCount());
+    if(_rows < 3  || _cols < 3)
+        return cv::Mat();
+    std::vector<cv::Point2f> src,dst;
+    std::vector<cv::Point2f> points = getCorners(true);
+    std::vector<cv::Point2f>::const_iterator iter = points.begin();
+    for(int row =0;row < _rows;++row)
+    {
+        for(int col=0;col <_cols;++col,++iter)
+        {
+            const cv::Point2f &pt = *iter;
+            if(pt.x == pt.x)
+            {
+                src.push_back(cv::Point2f(float(field_size)*(col+1),float(field_size)*(row+1)));
+                dst.push_back(pt);
+            }
+        }
+    }
+    if(dst.size() < 4)
+        return cv::Mat();
+    return findHomography(src, dst);
+}
+
+bool Chessboard::Board::findNextPoint(cv::flann::Index &index,const cv::Mat &data,
+        const cv::Point2f &pt1,const cv::Point2f &pt2, const cv::Point2f &pt3,
+        float white_angle,float black_angle,float min_response,cv::Point2f &point)
+{
+    Ellipse ellipse;
+    if(!estimateSearchArea(pt1,pt2,pt3,0.4F,ellipse))
+        return false;
+    if(min_response > fabs(findMaxPoint(index,data,ellipse,white_angle,black_angle,point)))
+        return false;
+    return true;
+}
+
+int Chessboard::Board::grow(const cv::Mat &map,cv::flann::Index &flann_index)
+{
+    if(isEmpty())
+        CV_Error(Error::StsInternal,"Board is empty");
+    bool bleft = true;
+    bool btop = true;
+    bool bright = true;
+    bool bbottom= true;
+    int count = 0;
+    do
+    {
+        if(btop)
+        {
+            btop= growTop(map,flann_index);
+            if(btop)
+            {
+                ++count;
+                continue;
+            }
+        }
+        if(bbottom)
+        {
+            bbottom= growBottom(map,flann_index);
+            if(bbottom)
+            {
+                ++count;
+                continue;
+            }
+        }
+
+        // grow to the left
+        if(bleft)
+        {
+            bleft = growLeft(map,flann_index);
+            if(bleft)
+            {
+                ++count;
+                continue;
+            }
+        }
+        if(bright)
+        {
+            bright= growRight(map,flann_index);
+            if(bright)
+            {
+                ++count;
+                continue;
+            }
+        }
+    }while(bleft || btop || bright || bbottom );
+    return count;
+}
+
+std::map<int,int> Chessboard::Board::getMapping()const
+{
+    std::map<int,int> map;
+    std::vector<cv::Point2f> points = getCorners();
+    std::vector<cv::Point2f>::iterator iter = points.begin();
+    for(int idx1=0,idx2=0;iter != points.end();++iter,++idx1)
+    {
+        if(iter->x != iter->x)  // NaN check
+            continue;
+        map[idx1] = idx2++;
+    }
+    return map;
+}
+
+std::vector<cv::Point2f> Chessboard::Board::getCorners(bool ball)const
+{
+    std::vector<cv::Point2f> points;
+    if(isEmpty())
+        return points;
+
+    // first row
+    PointIter iter(top_left,TOP_LEFT);
+    do
+    {
+        if(ball || !iter.isNaN())
+            points.push_back(*(*iter));
+    }while(iter.right());
+
+    // all other rows
+    Cell *row = top_left;
+    do
+    {
+        PointIter iter2(row,BOTTOM_LEFT);
+        do
+        {
+            if(ball || !iter2.isNaN())
+                points.push_back(*(*iter2));
+        }while(iter2.right());
+        row = row->bottom;
+    }while(row);
+    return points;
+}
+
+std::vector<cv::KeyPoint> Chessboard::Board::getKeyPoints(bool ball)const
+{
+    std::vector<cv::KeyPoint> keypoints;
+    std::vector<cv::Point2f> points = getCorners(ball);
+    std::vector<cv::Point2f>::const_iterator iter = points.begin();
+    for(;iter != points.end();++iter)
+        keypoints.push_back(cv::KeyPoint(iter->x,iter->y,1));
+    return keypoints;
+}
+
+
+cv::Scalar Chessboard::Board::calcEdgeSharpness(cv::InputArray _img,float rise_distance,bool vertical,cv::OutputArray _sharpness)
+{
+    cv::Mat img = _img.getMat();
+    if(img.empty())
+        CV_Error(Error::StsBadArg,"image is empty");
+    if(img.type() != CV_8UC1)
+        CV_Error(Error::StsBadArg,"image type is not supported. Expect CV_8UC1");
+
+    int tcols = int(colCount());
+    int trows = int(rowCount());
+    std::vector<cv::Point2f> centers = getCellCenters();
+
+    if(int(centers.size()) != trows*tcols)
+        CV_Error(Error::StsInternal,"internal error - size mismatch");
+
+    // build horizontal lines
+    std::vector<std::pair<cv::Point2f,cv::Point2f> > pairs;
+    if(vertical)
+    {
+        for(int row = 1;row < trows-1;++row)
+        {
+            std::vector<cv::Point2f>::const_iterator iter1 = centers.begin()+row*tcols;
+            std::vector<cv::Point2f>::const_iterator iter2 = iter1+1;
+            for(int col= 0;col< tcols-1;++col,++iter1,++iter2)
+                pairs.push_back(std::make_pair(*iter1,*iter2));
+        }
+    }
+    else
+    {
+        // build vertical lines
+        for(int col = 1;col< tcols-1;++col)
+        {
+            // avoid using iterators to not trigger out of range
+            int i1 = col;
+            int i2 = i1 + tcols;
+            for (int row = 0; row < trows - 1; ++row, i1 += tcols, i2 += tcols)
+            {
+                pairs.push_back(std::make_pair(centers[i1], centers[i2]));
+            }
+        }
+    }
+
+    // calc edge response for each line
+    cv::Rect rect(0,0,img.cols,img.rows);
+    std::vector<std::pair<cv::Point2f,cv::Point2f> >::const_iterator iter =  pairs.begin();
+    int count = 0;
+    float sharpness = 0;
+    float max_val= 0;
+    float min_val= 0;
+    double dmin,dmax;
+    cv::Mat data = cv::Mat::zeros(int(pairs.size()),5,CV_32FC1);
+    for(;iter != pairs.end();++iter)
+    {
+        // get values from the image
+        if(!rect.contains(iter->first) || !rect.contains(iter->second))
+            continue;
+        int delta = int(cv::norm(iter->second-iter->first));
+        if(delta < 10)
+            continue;
+
+        float dx = (iter->second.x-iter->first.x)/delta;
+        float dy = (iter->second.y-iter->first.y)/delta;
+        std::vector<uint8_t> values;
+        cv::Mat patch;
+        for(int i=0;i<delta;++i)
+        {
+            int count2 = 0;
+            float value = 0;
+            cv::Point2f p0(iter->first.x+dx*i,iter->first.y+dy*i);
+            for(int num=-1;num < 2;++num)
+            {
+                cv::Point2f p1(p0.x+dy*num,p0.y-dx*num);
+                if(!rect.contains(p1))
+                    continue;
+                cv::getRectSubPix(img,cv::Size(1,1),p1,patch);
+                value += patch.at<uint8_t>(0,0);
+                ++count2;
+            }
+            values.push_back(count2 > 0 ? uint8_t(value/count2) : 0);
+        }
+
+        float val = calcSharpness(values,rise_distance);
+        sharpness += val;
+        cv::minMaxLoc(values,&dmin,&dmax);
+        max_val+= float(dmax);
+        min_val += float(dmin);
+        data.at<float>(count,0) = iter->first.x+(iter->second.x-iter->first.x)/2;
+        data.at<float>(count,1) = iter->first.y+(iter->second.y-iter->first.y)/2;
+        data.at<float>(count,2) = val;
+        data.at<float>(count,3) = float(dmin);
+        data.at<float>(count,4) = float(dmax);
+        count +=1;
+    }
+    if(count == 0)
+    {
+        CV_LOG_DEBUG(NULL, "calcEdgeSharpness: checkerboard too small for calculation.");
+        return cv::Scalar::all(9999);
+    }
+    sharpness = sharpness/float(count);
+    max_val = max_val/float(count);
+    min_val = min_val/float(count);
+    if(_sharpness.needed())
+        data.copyTo(_sharpness);
+    return cv::Scalar(sharpness,min_val,max_val);
+}
+
+
+Chessboard::Chessboard(const Parameters &para)
+{
+    reconfigure(para);
+}
+
+void Chessboard::reconfigure(const Parameters &config)
+{
+    parameters = config;
+}
+
+Chessboard::Parameters Chessboard::getPara()const
+{
+    return parameters;
+}
+
+Chessboard::~Chessboard()
+{
+}
+
+void Chessboard::findKeyPoints(const cv::Mat& image, std::vector<KeyPoint>& keypoints,std::vector<cv::Mat> &feature_maps,
+        std::vector<std::vector<float> > &angles ,const cv::Mat& mask)const
+{
+    keypoints.clear();
+    angles.clear();
+    vector<KeyPoint> keypoints_temp;
+    FastX::Parameters para;
+
+    para.branches = 2;                    // this is always the case for checssboard corners
+    para.strength = 150;                  // minimal threshold
+    para.resolution = float(CV_PI*0.25);   // this gives the best results taking interpolation into account
+    para.filter = 1;
+    para.super_resolution = parameters.super_resolution;
+    para.min_scale = parameters.min_scale;
+    para.max_scale = parameters.max_scale;
+
+    FastX detector(para);
+    std::vector<cv::Mat> rotated_images;
+    detector.detectImpl(image,rotated_images,feature_maps,mask);
+
+    //calculate seed chessboard corners
+    detector.findKeyPoints(feature_maps,keypoints_temp,mask);
+
+    //sort points and limit number
+    int max_seeds = std::min((int)keypoints_temp.size(),parameters.max_points);
+    if(max_seeds < 9)
+        return;
+
+    std::partial_sort(keypoints_temp.begin(),keypoints_temp.begin()+max_seeds-1,
+            keypoints_temp.end(),sortKeyPoint);
+    keypoints_temp.resize(max_seeds);
+    std::vector<std::vector<float> > angles_temp  = detector.calcAngles(rotated_images,keypoints_temp);
+
+    // filter out keypoints which are not symmetric
+    std::vector<KeyPoint>::iterator iter1 = keypoints_temp.begin();
+    std::vector<std::vector<float> >::const_iterator iter2 = angles_temp.begin();
+    for(;iter1 != keypoints_temp.end();++iter1,++iter2)
+    {
+        cv::KeyPoint &pt = *iter1;
+        const std::vector<float> &angles_i3 = *iter2;
+        if(angles_i3.size() != 2)// || pt.response < noise)
+            continue;
+        int result = testPointSymmetry(image,pt.pt,pt.size*0.7F,std::max(10.0F,sqrt(pt.response)+0.5F*pt.size));
+        if(result > MAX_SYMMETRY_ERRORS)
+            continue;
+        else if(result > 3)
+            pt.response = - pt.response;
+        angles.push_back(angles_i3);
+        keypoints.push_back(pt);
+    }
+}
+
+cv::Mat Chessboard::buildData(const std::vector<KeyPoint>& keypoints)const
+{
+    cv::Mat data(int(keypoints.size()),4,CV_32FC1);       // x + y + angle + strength
+    std::vector<cv::KeyPoint>::const_iterator iter = keypoints.begin();
+    float *val = reinterpret_cast<float*>(data.data);
+    for(;iter != keypoints.end();++iter)
+    {
+        (*val++) = iter->pt.x;
+        (*val++) = iter->pt.y;
+        (*val++) = float(2.0*CV_PI-iter->angle/180.0*CV_PI);
+        (*val++) = iter->response;
+    }
+    return data;
+}
+
+std::vector<cv::KeyPoint> Chessboard::getInitialPoints(cv::flann::Index &flann_index,const cv::Mat &data,const cv::KeyPoint &center,float white_angle,float black_angle,float min_response)const
+{
+    CV_CheckTypeEQ(data.type(), CV_32FC1, "Unsupported source type");
+    if(data.cols != 4)
+        CV_Error(Error::StsBadArg,"wrong data format");
+
+    std::vector<float> query,dists;
+    std::vector<int> indices;
+    query.resize(2); query[0] = center.pt.x; query[1] = center.pt.y;
+    flann_index.knnSearch(query,indices,dists,21,cv::flann::SearchParams(32));
+
+    // collect all points having a similar angle and response
+    std::vector<cv::KeyPoint> points;
+    std::vector<int>::const_iterator ids_iter = indices.begin()+1; // first point is center
+    points.push_back(center);
+    for(;ids_iter != indices.end();++ids_iter)
+    {
+        // TODO do more angle tests
+        // test only one angle against the stored one
+        const float &response = data.at<float>(*ids_iter,3);
+        if(fabs(response) < min_response)
+            continue;
+        const float &angle = data.at<float>(*ids_iter,2);
+        float angle_temp = fabs(angle-white_angle);
+        if(angle_temp > CV_PI*0.5)
+            angle_temp = float(fabs(angle_temp-CV_PI));
+        if(angle_temp > MAX_ANGLE)
+        {
+            angle_temp = fabs(angle-black_angle);
+            if(angle_temp > CV_PI*0.5)
+                angle_temp = float(fabs(angle_temp-CV_PI));
+            if(angle_temp >MAX_ANGLE)
+                continue;
+        }
+        points.push_back(cv::KeyPoint(data.at<float>(*ids_iter,0),data.at<float>(*ids_iter,1),center.size,angle,response));
+    }
+    return points;
+}
+
+Chessboard::BState Chessboard::generateBoards(cv::flann::Index &flann_index,const cv::Mat &data,
+        const cv::KeyPoint &center,float white_angle,float black_angle,float min_response,const cv::Mat& img,
+        std::vector<Chessboard::Board> &boards)const
+{
+    // collect all points having a similar angle
+    std::vector<cv::KeyPoint> kpoints= getInitialPoints(flann_index,data,center,white_angle,black_angle,min_response);
+    if(kpoints.size() < 5)
+        return MISSING_POINTS;
+
+    if(!img.empty())
+    {
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+        cv::Mat out;
+        cv::drawKeypoints(img,kpoints,out,cv::Scalar(0,0,255,255),4);
+        std::vector<cv::KeyPoint> temp;
+        temp.push_back(kpoints.front());
+        cv::drawKeypoints(out,temp,out,cv::Scalar(0,255,0,255),4);
+        cv::imshow("chessboard",out);
+        cv::waitKey(-1);
+#endif
+    }
+
+    // use angles to filter out points
+    std::vector<cv::KeyPoint> points;
+    cv::Vec2f n1(std::cos(white_angle),-std::sin(white_angle));
+    cv::Vec2f n2(std::cos(black_angle),-std::sin(black_angle));
+    std::vector<cv::KeyPoint>::const_iterator iter1 = kpoints.begin()+1; // first point is center
+    for(;iter1 != kpoints.end();++iter1)
+    {
+        // calc angle
+        cv::Vec2f vec(iter1->pt-center.pt);
+        vec = vec/cv::norm(vec);
+        if(fabs(vec.dot(n1)) < 0.96 && fabs(vec.dot(n2)) < 0.96)   //check that angle is bigger than 15°
+            points.push_back(*iter1);
+    }
+
+    // generate pairs those connection goes through the center
+    std::vector<std::pair<cv::KeyPoint,cv::KeyPoint> > pairs;
+    iter1 = points.begin();
+    for(;iter1 != points.end();++iter1)
+    {
+        std::vector<cv::KeyPoint>::const_iterator iter2 = iter1+1;
+        for(;iter2 != points.end();++iter2)
+        {
+            if(isPointOnLine(iter1->pt,iter2->pt,center.pt,0.97F))
+            {
+                if(cv::norm(iter1->pt) < cv::norm(iter2->pt))
+                    pairs.push_back(std::make_pair(*iter1,*iter2));
+                else
+                    pairs.push_back(std::make_pair(*iter2,*iter1));
+            }
+        }
+    }
+
+    // generate all possible combinations consisting of two pairs
+    if(pairs.size() < 2)
+        return MISSING_PAIRS;
+    std::vector<std::pair<cv::KeyPoint,cv::KeyPoint> >::iterator iter_pair1 = pairs.begin();
+
+    BState best_state = MISSING_PAIRS;
+    for(;iter_pair1 != pairs.end();++iter_pair1)
+    {
+        cv::Point2f p1 = iter_pair1->second.pt-iter_pair1->first.pt;
+        p1 = p1/cv::norm(p1);
+        std::vector<std::pair<cv::KeyPoint,cv::KeyPoint> >::iterator iter_pair2 = iter_pair1+1;
+        for(;iter_pair2 != pairs.end();++iter_pair2)
+        {
+            cv::Point2f p2 = iter_pair2->second.pt-iter_pair2->first.pt;
+            p2 = p2/cv::norm(p2);
+            if(p2.dot(p1) > 0.95)
+            {
+                if(best_state < WRONG_PAIR_ANGLE)
+                    best_state = WRONG_PAIR_ANGLE;
+            }
+            else
+            {
+                // check orientations
+                if(checkOrientation(iter_pair1->first.pt,iter_pair1->second.pt,iter_pair2->first.pt,iter_pair2->second.pt))
+                    std::swap(iter_pair2->first,iter_pair2->second);
+
+                // minimal case
+                std::vector<cv::Point2f> board_points;
+                board_points.resize(9,cv::Point2f(std::numeric_limits<float>::quiet_NaN(),
+                            std::numeric_limits<float>::quiet_NaN()));
+
+                board_points[1] = iter_pair2->first.pt;
+                board_points[3] = iter_pair1->first.pt;
+                board_points[4] = center.pt;
+                board_points[5] = iter_pair1->second.pt;
+                board_points[7] = iter_pair2->second.pt;
+                boards.push_back(Board(cv::Size(3,3),board_points,white_angle,black_angle));
+                Board &board = boards.back();
+
+                if(board.isEmpty())
+                {
+                    if(best_state < WRONG_CONFIGURATION)
+                        best_state = WRONG_CONFIGURATION;
+                    boards.pop_back(); // MAKE SURE board is no longer used !!!!
+                    continue;
+                }
+                best_state = FOUND_BOARD;
+            }
+        }
+    }
+    return best_state;
+}
+
+void Chessboard::detectImpl(const Mat& image, vector<KeyPoint>& keypoints,std::vector<Mat> &feature_maps,const Mat& mask)const
+{
+    keypoints.clear();
+    Board board = detectImpl(image,feature_maps,mask);
+    keypoints = board.getKeyPoints();
+    return;
+}
+
+Chessboard::Board Chessboard::detectImpl(const Mat& gray,std::vector<cv::Mat> &feature_maps,const Mat& mask)const
+{
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+    debug_image = gray;
+#endif
+    CV_CheckTypeEQ(gray.type(),CV_8UC1, "Unsupported image type");
+
+    cv::Size chessboard_size2(parameters.chessboard_size.height,parameters.chessboard_size.width);
+    std::vector<KeyPoint> keypoints_seed;
+    std::vector<std::vector<float> > angles;
+    findKeyPoints(gray,keypoints_seed,feature_maps,angles,mask);
+    if(int(keypoints_seed.size()) < parameters.chessboard_size.width * parameters.chessboard_size.height)
+        return Chessboard::Board();
+
+    // check how many points are likely a checkerboard corner
+    float response = fabs(keypoints_seed.front().response*MIN_RESPONSE_RATIO);
+    std::vector<KeyPoint>::const_iterator seed_iter = keypoints_seed.begin();
+    int count = 0;
+    int inum = chessboard_size2.width*chessboard_size2.height;
+    for(;seed_iter != keypoints_seed.end() && count < inum;++seed_iter,++count)
+    {
+        // points are sorted based on response
+        if(fabs(seed_iter->response) < response)
+        {
+            seed_iter = keypoints_seed.end();
+            return Chessboard::Board();
+        }
+    }
+    // just add dummy points or flann will fail during knnSearch
+    if(keypoints_seed.size() < 21)
+        keypoints_seed.resize(21, cv::KeyPoint(-99999.0F,-99999.0F,0.0F,0.0F,0.0F));
+
+    //build kd tree
+    cv::Mat data = buildData(keypoints_seed);
+    cv::Mat flann_data(data.rows,2,CV_32FC1);
+    data(cv::Rect(0,0,2,data.rows)).copyTo(flann_data);
+    cv::flann::Index flann_index(flann_data,cv::flann::KDTreeIndexParams(1),cvflann::FLANN_DIST_EUCLIDEAN);
+
+    // for each point
+    std::vector<std::vector<float> >::const_iterator angles_iter = angles.begin();
+    std::vector<cv::KeyPoint>::const_iterator points_iter = keypoints_seed.begin();
+    cv::Rect bounding_box(5,5,gray.cols-10,gray.rows-10);
+    int max_tests = std::min(parameters.max_tests,int(keypoints_seed.size()));
+    for(count=0;count < max_tests;++angles_iter,++points_iter,++count)
+    {
+        // regard current point as center point
+        // which must have two angles!!! (this was already checked)
+        float min_response = points_iter->response*MIN_RESPONSE_RATIO;
+        if(min_response <= 0)
+        {
+            if(max_tests+1 < int(keypoints_seed.size()))
+                ++max_tests;
+            continue;
+        }
+        const std::vector<float> &angles_i = *angles_iter;
+        float white_angle =  fabs(angles_i.front());  // angle is negative if black --> clockwise
+        float black_angle =  fabs(angles_i.back());   // angle is negative if black --> clockwise
+        if(angles_i.front() < 0)                 // ensure white angle is first
+            swap(white_angle,black_angle);
+
+        std::vector<Board> boards;
+        generateBoards(flann_index, data,*points_iter,white_angle,black_angle,min_response,gray,boards);
+        parallel_for_(Range(0,(int)boards.size()),[&](const Range& range){
+            for(int i=range.start;i <range.end;++i)
+            {
+                auto iter_boards = boards.begin()+i;
+                cv::Mat h = iter_boards->estimateHomography();
+                int size = iter_boards->validateCorners(data,flann_index,h,min_response);
+                if(size != 9 || !iter_boards->validateContour())
+                {
+                    iter_boards->clear();
+                    continue;
+                }
+                //grow based on kd-tree
+                iter_boards->grow(data,flann_index);
+                if(!iter_boards->checkUnique())
+                {
+                    iter_boards->clear();
+                    continue;
+                }
+
+                // check bounding box
+                std::vector<cv::Point2f> contour = iter_boards->getContour();
+                std::vector<cv::Point2f>::const_iterator iter = contour.begin();
+                for(;iter != contour.end();++iter)
+                {
+                    if(!bounding_box.contains(*iter))
+                        break;
+                }
+                if(iter != contour.end())
+                {
+                    iter_boards->clear();
+                    continue;
+                }
+
+                iter_boards->normalizeOrientation(false);
+
+                if(iter_boards->getSize() == parameters.chessboard_size ||
+                        iter_boards->getSize() == chessboard_size2)
+                {
+                    if(iter_boards->getSize() != parameters.chessboard_size)
+                    {
+                        if(iter_boards->isCellBlack(0,0) == iter_boards->isCellBlack(0,int(iter_boards->colCount())-1))
+                            iter_boards->rotateLeft();
+                        else
+                            iter_boards->rotateRight();
+                    }
+#ifdef CV_DETECTORS_CHESSBOARD_DEBUG
+                    cv::Mat img;
+                    iter_boards->draw(debug_image,img);
+                    cv::imshow("chessboard",img);
+                    cv::waitKey(-1);
+#endif
+                }
+                else
+                {
+                    if(iter_boards->getSize().width < chessboard_size2.width || iter_boards->getSize().height < chessboard_size2.height)
+                        iter_boards->clear();
+                    else if(!parameters.larger)
+                        iter_boards->clear();
+                    else
+                    {
+                        // try to optimize board
+                        while(true)
+                        {
+                            Board temp(*iter_boards);
+                            temp.shrinkRight();
+                            temp.shrinkLeft();
+                            temp.shrinkRight();
+                            temp.shrinkLeft();
+                            temp.growTop(data,flann_index);
+                            temp.growBottom(data,flann_index);
+                            temp.grow(data,flann_index);
+                            if(temp.rowCount()*temp.colCount() > iter_boards->rowCount()*iter_boards->colCount())
+                            {
+                                *iter_boards = temp;
+                                continue;
+                            }
+
+                            temp = (*iter_boards);
+                            temp = (*iter_boards);
+                            temp.shrinkTop();
+                            temp.shrinkBottom();
+                            temp.shrinkTop();
+                            temp.shrinkBottom();
+                            temp.growLeft(data,flann_index);
+                            temp.growRight(data,flann_index);
+                            temp.grow(data,flann_index);
+                            if(temp.rowCount()*temp.colCount() > iter_boards->rowCount()*iter_boards->colCount())
+                            {
+                                *iter_boards = temp;
+                                continue;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+                // check for markers
+                if(!iter_boards->isEmpty() && parameters.marker)
+                {
+                    auto icount = iter_boards->detectMarkers(gray);
+                    if(3 != icount || !iter_boards->normalizeMarkerOrientation())
+                        iter_boards->clear();
+                }
+            }
+        });
+        // check if a good board was found
+        // check if a good board was found and return largest one
+        const Board *best_board = NULL;
+        for(const auto &board : boards)
+        {
+            if(!board.isEmpty())
+            {
+                if(!best_board || best_board->rowCount() * best_board->colCount() < board.colCount()*board.rowCount())
+                    best_board = &board;
+            }
+        }
+        if(best_board)
+            return *best_board;
+    }
+    return Chessboard::Board();
+}
+
+void Chessboard::detectAndCompute(cv::InputArray image,cv::InputArray mask,std::vector<cv::KeyPoint>& keypoints,
+        cv::OutputArray descriptors,bool useProvidedKeyPoints)
+{
+    descriptors.clear();
+    useProvidedKeyPoints=false;
+    std::vector<cv::Mat> maps;
+    detectImpl(image.getMat(),keypoints,maps,mask.getMat());
+    if(!useProvidedKeyPoints)        // suppress compiler warning
+        return;
+    return;
+}
+
+void Chessboard::detectImpl(const Mat& image, vector<KeyPoint>& keypoints,const Mat& mask)const
+{
+    std::vector<cv::Mat> maps;
+    detectImpl(image,keypoints,maps,mask);
+}
+
+void Chessboard::detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask)const
+{
+    detectImpl(image.getMat(),keypoints,mask.getMat());
+}
+
+}} // end namespace details
+
+
+// public API
+bool cv::findChessboardCornersSB(InputArray image_, Size pattern_size,
+                                 OutputArray corners_, int flags, OutputArray meta_)
+{
+    CV_INSTRUMENT_REGION();
+    int type = image_.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_CheckType(type, depth == CV_8U && (cn == 1 || cn == 3),
+            "Only 8-bit grayscale or color images are supported");
+    if(pattern_size.width <= 2 || pattern_size.height <= 2)
+    {
+        CV_Error(Error::StsOutOfRange, "Both width and height of the pattern should have bigger than 2");
+    }
+    if (!corners_.needed())
+        CV_Error(Error::StsNullPtr, "Null pointer to corners");
+
+    Mat img;
+    if (image_.channels() != 1)
+        cvtColor(image_, img, COLOR_BGR2GRAY);
+    else
+        img = image_.getMat();
+
+    details::Chessboard::Parameters para;
+    para.chessboard_size = pattern_size;
+    para.min_scale = 2;
+    para.max_scale = 4;
+    para.max_tests = 30;
+    para.max_points = std::max(100,pattern_size.width*pattern_size.height*2);
+    para.super_resolution = false;
+
+    // setup search based on flags
+    if(flags & CALIB_CB_NORMALIZE_IMAGE)
+    {
+        Mat tmp;
+        cv::equalizeHist(img, tmp);
+        swap(img, tmp);
+        flags ^= CALIB_CB_NORMALIZE_IMAGE;
+    }
+    if(flags & CALIB_CB_EXHAUSTIVE)
+    {
+        para.max_tests = 100;
+        para.max_points = std::max(1000,pattern_size.width*pattern_size.height*2);
+        flags ^= CALIB_CB_EXHAUSTIVE;
+    }
+    if(flags & CALIB_CB_ACCURACY)
+    {
+        para.super_resolution = true;
+        flags ^= CALIB_CB_ACCURACY;
+    }
+    if(flags & CALIB_CB_LARGER)
+    {
+        para.larger = true;
+        flags ^= CALIB_CB_LARGER;
+    }
+    if(flags & CALIB_CB_MARKER)
+    {
+        para.marker = true;
+        para.max_points *= 4;
+        flags ^= CALIB_CB_MARKER;
+    }
+    if(flags)
+        CV_Error(Error::StsOutOfRange, cv::format("Invalid remaining flags %d", (int)flags));
+
+    std::vector<cv::KeyPoint> corners;
+    details::Chessboard detector(para);
+
+    std::vector<cv::Mat> maps;
+    details::Chessboard::Board board = detector.detectImpl(img,maps,cv::Mat());
+    corners = board.getKeyPoints();
+    if(corners.empty())
+    {
+        corners_.release();
+        if(meta_.needed())
+            meta_.release();
+        return false;
+    }
+    std::vector<cv::Point2f> points;
+    KeyPoint::convert(corners,points);
+    Mat(points).copyTo(corners_);
+
+    // export meta data
+    if(meta_.needed())
+    {
+        meta_.create(int(board.rowCount()),int(board.colCount()),CV_8UC1);
+        cv::Mat meta = meta_.getMat();
+        meta.setTo(cv::Scalar::all(0));
+        for(int row =0;row < meta.rows-1;++row)
+        {
+            for(int col=0;col< meta.cols-1;++col)
+            {
+                if(board.isCellBlack(row,col))
+                {
+                    if(board.hasCellMarker(row,col))
+                        meta.at<uint8_t>(row,col) = 3;
+                    else
+                        meta.at<uint8_t>(row,col) = 1;
+                }
+                else
+                {
+                    if(board.hasCellMarker(row,col))
+                        meta.at<uint8_t>(row,col) = 4;   // origin
+                    else
+                        meta.at<uint8_t>(row,col) = 2;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+// public API
+cv::Scalar cv::estimateChessboardSharpness(InputArray image_, Size patternSize, InputArray corners_,
+                                       float rise_distance,bool vertical, cv::OutputArray sharpness)
+{
+    CV_INSTRUMENT_REGION();
+    int type = image_.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_CheckType(type, depth == CV_8U && (cn == 1 || cn == 3),
+            "Only 8-bit grayscale or color images are supported");
+    if(patternSize.width <= 2 || patternSize.height <= 2)
+        CV_Error(Error::StsOutOfRange, "Both width and height of the pattern should have bigger than 2");
+
+    cv::Mat corners = details::normalizeVector(corners_);
+    std::vector<cv::Point2f> points;
+    corners.reshape(2,corners.rows).convertTo(points,CV_32FC2);
+    if(int(points.size()) != patternSize.width * patternSize.height)
+        CV_Error(Error::StsBadArg, "Size mismatch between patternSize and number of provided corners.");
+
+    Mat img;
+    if (image_.channels() != 1)
+        cvtColor(image_, img, COLOR_BGR2GRAY);
+    else
+        img = image_.getMat();
+
+    details::Chessboard::Board board(patternSize,points);
+    return board.calcEdgeSharpness(img,rise_distance,vertical,sharpness);
+}
diff --git a/upstream/opencv/modules/objdetect/src/chessboard.hpp b/upstream/opencv/modules/objdetect/src/chessboard.hpp
new file mode 100644
index 0000000..a39f1f5
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/chessboard.hpp
@@ -0,0 +1,872 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef CHESSBOARD_HPP_
+#define CHESSBOARD_HPP_
+
+#include "opencv2/core.hpp"
+#include "opencv2/features.hpp"
+#include <vector>
+#include <set>
+#include <map>
+
+namespace cv {
+namespace details{
+/**
+ * \brief Fast point sysmetric cross detector based on a localized radon transformation
+ */
+class FastX : public cv::Feature2D
+{
+    public:
+        struct Parameters
+        {
+            float strength;       //!< minimal strength of a valid junction in dB
+            float resolution;     //!< angle resolution in radians
+            int branches;         //!< the number of branches
+            int min_scale;        //!< scale level [0..8]
+            int max_scale;        //!< scale level [0..8]
+            bool filter;          //!< post filter feature map to improve impulse response
+            bool super_resolution; //!< up-sample
+
+            Parameters()
+            {
+                strength = 40;
+                resolution = float(CV_PI*0.25);
+                branches = 2;
+                min_scale = 2;
+                max_scale = 5;
+                super_resolution = true;
+                filter = true;
+            }
+        };
+
+    public:
+        FastX(const Parameters &config = Parameters());
+        virtual ~FastX(){}
+
+        void reconfigure(const Parameters &para);
+
+        //declaration to be wrapped by rbind
+        void detect(cv::InputArray image,std::vector<cv::KeyPoint>& keypoints, cv::InputArray mask=cv::Mat())override
+        {cv::Feature2D::detect(image.getMat(),keypoints,mask.getMat());}
+
+        virtual void detectAndCompute(cv::InputArray image,
+                                              cv::InputArray mask,
+                                              std::vector<cv::KeyPoint>& keypoints,
+                                              cv::OutputArray descriptors,
+                                              bool useProvidedKeyPoints = false)override;
+
+        void detectImpl(const cv::Mat& image,
+                               std::vector<cv::KeyPoint>& keypoints,
+                               std::vector<cv::Mat> &feature_maps,
+                               const cv::Mat& mask=cv::Mat())const;
+
+        void detectImpl(const cv::Mat& image,
+                                std::vector<cv::Mat> &rotated_images,
+                                std::vector<cv::Mat> &feature_maps,
+                                const cv::Mat& mask=cv::Mat())const;
+
+        void findKeyPoints(const std::vector<cv::Mat> &feature_map,
+                                   std::vector<cv::KeyPoint>& keypoints,
+                                   const cv::Mat& mask = cv::Mat())const;
+
+        std::vector<std::vector<float> > calcAngles(const std::vector<cv::Mat> &rotated_images,
+                                                            std::vector<cv::KeyPoint> &keypoints)const;
+        // define pure virtual methods
+        virtual int descriptorSize()const override{return 0;}
+        virtual int descriptorType()const override{return 0;}
+        virtual void operator()( cv::InputArray image, cv::InputArray mask, std::vector<cv::KeyPoint>& keypoints, cv::OutputArray descriptors, bool useProvidedKeypoints=false )const
+        {
+            descriptors.clear();
+            detectImpl(image.getMat(),keypoints,mask);
+            if(!useProvidedKeypoints)        // suppress compiler warning
+                return;
+            return;
+        }
+
+    protected:
+        virtual void computeImpl( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, cv::Mat& descriptors)const
+        {
+            descriptors = cv::Mat();
+            detectImpl(image,keypoints);
+        }
+
+    private:
+        void detectImpl(const cv::Mat& _src, std::vector<cv::KeyPoint>& keypoints, const cv::Mat& mask)const;
+        virtual void detectImpl(cv::InputArray image, std::vector<cv::KeyPoint>& keypoints, cv::InputArray mask=cv::noArray())const;
+
+        void rotate(float angle,cv::InputArray img,cv::Size size,cv::OutputArray out)const;
+        void calcFeatureMap(const cv::Mat &images,cv::Mat& out)const;
+
+    private:
+        Parameters parameters;
+};
+
+/**
+ * \brief Ellipse class
+ */
+class Ellipse
+{
+    public:
+        Ellipse();
+        Ellipse(const cv::Point2f &center, const cv::Size2f &axes, float angle);
+
+        void draw(cv::InputOutputArray img,const cv::Scalar &color = cv::Scalar::all(120))const;
+        bool contains(const cv::Point2f &pt)const;
+        cv::Point2f getCenter()const;
+        const cv::Size2f &getAxes()const;
+
+    private:
+        cv::Point2f center;
+        cv::Size2f axes;
+        float angle,cosf,sinf;
+};
+
+/**
+ * \brief Chessboard corner detector
+ *
+ * The detectors tries to find all chessboard corners of an imaged
+ * chessboard and returns them as an ordered vector of KeyPoints.
+ * Thereby, the left top corner has index 0 and the bottom right
+ * corner n*m-1.
+ */
+class Chessboard: public cv::Feature2D
+{
+    public:
+        static const int DUMMY_FIELD_SIZE = 100;  // in pixel
+
+        /**
+         * \brief Configuration of a chessboard corner detector
+         *
+         */
+        struct Parameters
+        {
+            cv::Size chessboard_size; //!< size of the chessboard
+            int min_scale;            //!< scale level [0..8]
+            int max_scale;            //!< scale level [0..8]
+            int max_points;           //!< maximal number of points regarded
+            int max_tests;            //!< maximal number of tested hypothesis
+            bool super_resolution;    //!< use super-repsolution for chessboard detection
+            bool larger;              //!< indicates if larger boards should be returned
+            bool marker;              //!< indicates that valid boards must have a white and black circle marker used for orientation
+
+            Parameters()
+            {
+                chessboard_size = cv::Size(9,6);
+                min_scale = 3;
+                max_scale = 4;
+                super_resolution = true;
+                max_points = 200;
+                max_tests = 50;
+                larger = false;
+                marker = false;
+            }
+
+            Parameters(int scale,int _max_points):
+                min_scale(scale),
+                max_scale(scale),
+                max_points(_max_points)
+            {
+                chessboard_size = cv::Size(9,6);
+            }
+        };
+
+
+        /**
+         * \brief Gets the 3D objects points for the chessboard assuming the
+         * left top corner is located at the origin.
+         *
+         * \param[in] pattern_size Number of rows and cols of the pattern
+         * \param[in] cell_size Size of one cell
+         *
+         * \returns Returns the object points as CV_32FC3
+         */
+        static cv::Mat getObjectPoints(const cv::Size &pattern_size,float cell_size);
+
+        /**
+         * \brief Class for searching and storing chessboard corners.
+         *
+         * The search is based on a feature map having strong pixel
+         * values at positions where a chessboard corner is located.
+         *
+         * The board must be rectangular but supports empty cells
+         *
+         */
+        class Board
+        {
+            public:
+                /**
+                 * \brief Estimates the position of the next point on a line using cross ratio constrain
+                 *
+                 * cross ratio:
+                 * d12/d34 = d13/d24
+                 *
+                 * point order on the line:
+                 * p0 --> p1 --> p2 --> p3
+                 *
+                 * \param[in] p0 First point coordinate
+                 * \param[in] p1 Second point coordinate
+                 * \param[in] p2 Third point coordinate
+                 * \param[out] p3 Forth point coordinate
+                 *
+                 */
+                static bool estimatePoint(const cv::Point2f &p0,const cv::Point2f &p1,const cv::Point2f &p2,cv::Point2f &p3);
+
+                // using 1D homography
+                static bool estimatePoint(const cv::Point2f &p0,const cv::Point2f &p1,const cv::Point2f &p2,const cv::Point2f &p3, cv::Point2f &p4);
+
+                /**
+                 * \brief Checks if all points of a row or column have a valid cross ratio constraint
+                 *
+                 * cross ratio:
+                 * d12/d34 = d13/d24
+                 *
+                 * point order on the row/column:
+                 * pt1 --> pt2 --> pt3 --> pt4
+                 *
+                 * \param[in] points THe points of the row/column
+                 *
+                 */
+                static bool checkRowColumn(const std::vector<cv::Point2f> &points);
+
+                /**
+                 * \brief Estimates the search area for the next point on the line using cross ratio
+                 *
+                 * point order on the line:
+                 * (p0) --> p1 --> p2 --> p3 --> search area
+                 *
+                 * \param[in] p1 First point coordinate
+                 * \param[in] p2 Second point coordinate
+                 * \param[in] p3 Third point coordinate
+                 * \param[in] p Percentage of d34 used for the search area width and height [0..1]
+                 * \param[out] ellipse The search area
+                 * \param[in] p0 optional point to improve accuracy
+                 *
+                 * \return Returns false if no search area can be calculated
+                 *
+                 */
+                static bool estimateSearchArea(const cv::Point2f &p1,const cv::Point2f &p2,const cv::Point2f &p3,float p,
+                                                       Ellipse &ellipse,const cv::Point2f *p0 =NULL);
+
+                /**
+                 * \brief Estimates the search area for a specific point based on the given homography
+                 *
+                 * \param[in] H homography describing the transformation from ideal board to real one
+                 * \param[in] row Row of the point
+                 * \param[in] col Col of the point
+                 * \param[in] p Percentage [0..1]
+                 *
+                 * \return Returns false if no search area can be calculated
+                 *
+                 */
+                static Ellipse estimateSearchArea(cv::Mat H,int row, int col,float p,int field_size = DUMMY_FIELD_SIZE);
+
+                /**
+                 * \brief Searches for the maximum in a given search area
+                 *
+                 * \param[in] map feature map
+                 * \param[in] ellipse search area
+                 * \param[in] min_val Minimum value of the maximum to be accepted as maximum
+                 *
+                 * \return Returns a negative value if all points are outside the ellipse
+                 *
+                 */
+                static float findMaxPoint(cv::flann::Index &index,const cv::Mat &data,const Ellipse &ellipse,float white_angle,float black_angle,cv::Point2f &pt);
+
+                /**
+                 * \brief Searches for the next point using cross ratio constrain
+                 *
+                 * \param[in] index flann index
+                 * \param[in] data extended flann data
+                 * \param[in] pt1
+                 * \param[in] pt2
+                 * \param[in] pt3
+                 * \param[in] white_angle
+                 * \param[in] black_angle
+                 * \param[in] min_response
+                 * \param[out] point The resulting point
+                 *
+                 * \return Returns false if no point could be found
+                 *
+                 */
+                static bool findNextPoint(cv::flann::Index &index,const cv::Mat &data,
+                                                  const cv::Point2f &pt1,const cv::Point2f &pt2, const cv::Point2f &pt3,
+                                                  float white_angle,float black_angle,float min_response,cv::Point2f &point);
+
+                /**
+                 * \brief Creates a new Board object
+                 *
+                 */
+                Board(float white_angle=0,float black_angle=0);
+                Board(const cv::Size &size, const std::vector<cv::Point2f> &points,float white_angle=0,float black_angle=0);
+                Board(const Chessboard::Board &other);
+                virtual ~Board();
+
+                Board& operator=(const Chessboard::Board &other);
+
+                /**
+                 * \brief Draws the corners into the given image
+                 *
+                 * \param[in] m The image
+                 * \param[out] out The resulting image
+                 * \param[in] H optional homography to calculate search area
+                 *
+                 */
+                void draw(cv::InputArray m,cv::OutputArray out,cv::InputArray H=cv::Mat())const;
+
+                /**
+                 * \brief Estimates the pose of the chessboard
+                 *
+                 */
+                bool estimatePose(const cv::Size2f &real_size,cv::InputArray _K,cv::OutputArray rvec,cv::OutputArray tvec)const;
+
+                /**
+                 * \brief Clears all internal data of the object
+                 *
+                 */
+                void clear();
+
+                /**
+                 * \brief Returns the angle of the black diagnonale
+                 *
+                 */
+                float getBlackAngle()const;
+
+                /**
+                 * \brief Returns the angle of the black diagnonale
+                 *
+                 */
+                float getWhiteAngle()const;
+
+                /**
+                 * \brief Initializes a 3x3 grid from 9 corner coordinates
+                 *
+                 * All points must be ordered:
+                 * p0 p1 p2
+                 * p3 p4 p5
+                 * p6 p7 p8
+                 *
+                 * \param[in] points vector of points
+                 *
+                 * \return Returns false if the grid could not be initialized
+                 */
+                bool init(const std::vector<cv::Point2f> points);
+
+                /**
+                 * \brief Returns true if the board is empty
+                 *
+                 */
+                bool isEmpty() const;
+
+                /**
+                 * \brief Returns all board corners as ordered vector
+                 *
+                 * The left top corner has index 0 and the bottom right
+                 * corner rows*cols-1. All corners which only belong to
+                 * empty cells are returned as NaN.
+                 */
+                std::vector<cv::Point2f> getCorners(bool ball=true) const;
+
+                /**
+                 * \brief Returns all board corners as ordered vector of KeyPoints
+                 *
+                 * The left top corner has index 0 and the bottom right
+                 * corner rows*cols-1.
+                 *
+                 * \param[in] ball if set to false only non empty points are returned
+                 *
+                 */
+                std::vector<cv::KeyPoint> getKeyPoints(bool ball=true) const;
+
+                /**
+                 * \brief Returns the centers of the chessboard cells
+                 *
+                 * The left top corner has index 0 and the bottom right
+                 * corner (rows-1)*(cols-1)-1.
+                 *
+                 */
+                std::vector<cv::Point2f> getCellCenters() const;
+
+                /**
+                 * \brief Returns all cells as mats of four points each describing their corners.
+                 *
+                 * The left top cell has index 0
+                 *
+                 */
+                std::vector<cv::Mat> getCells(float shrink_factor = 1.0,bool bwhite=true,bool bblack = true) const;
+
+                /**
+                 * \brief Estimates the homography between an ideal board
+                 * and reality based on the already recovered points
+                 *
+                 * \param[in] rect selecting a subset of the already recovered points
+                 * \param[in] field_size The field size of the ideal board
+                 *
+                 */
+                cv::Mat estimateHomography(cv::Rect rect,int field_size = DUMMY_FIELD_SIZE)const;
+
+                /**
+                 * \brief Estimates the homography between an ideal board
+                 * and reality based on the already recovered points
+                 *
+                 * \param[in] field_size The field size of the ideal board
+                 *
+                 */
+                cv::Mat estimateHomography(int field_size = DUMMY_FIELD_SIZE)const;
+
+                /**
+                 * \brief Warp image to match ideal checkerboard
+                 *
+                 */
+                cv::Mat warpImage(cv::InputArray image)const;
+
+                /**
+                 * \brief Returns the size of the board
+                 *
+                 */
+                cv::Size getSize() const;
+
+                /**
+                 * \brief Returns the number of cols
+                 *
+                 */
+                size_t colCount() const;
+
+                /**
+                 * \brief Returns the number of rows
+                 *
+                 */
+                size_t rowCount() const;
+
+                /**
+                 * \brief Returns the inner contour of the board including only valid corners
+                 *
+                 * \info the contour might be non squared if not all points of the board are defined
+                 *
+                 */
+                std::vector<cv::Point2f> getContour()const;
+
+                /**
+                 * \brief Masks the found board in the given image
+                 *
+                 */
+                void maskImage(cv::InputOutputArray img,const cv::Scalar &color=cv::Scalar::all(0))const;
+
+                /**
+                 * \brief Grows the board in all direction until no more corners are found in the feature map
+                 *
+                 * \param[in] data CV_32FC1 data of the flann index
+                 * \param[in] flann_index flann index
+                 *
+                 * \returns the number of grows
+                 */
+                int grow(const cv::Mat &data,cv::flann::Index &flann_index);
+
+                /**
+                 * \brief Validates all corners using guided search based on the given homography
+                 *
+                 * \param[in] data CV_32FC1 data of the flann index
+                 * \param[in] flann_index flann index
+                 * \param[in] h Homography describing the transformation from ideal board to the real one
+                 * \param[in] min_response Min response
+                 *
+                 * \returns the number of valid corners
+                 */
+                int validateCorners(const cv::Mat &data,cv::flann::Index &flann_index,const cv::Mat &h,float min_response=0);
+
+                /**
+                 * \brief check that no corner is used more than once
+                 *
+                 * \returns Returns false if a corner is used more than once
+                 */
+                 bool checkUnique()const;
+
+                 /**
+                  * \brief Returns false if the angles of the contour are smaller than 35°
+                  *
+                  */
+                 bool validateContour()const;
+
+
+                 /**
+                   \brief delete left column of the board
+                   */
+                 bool shrinkLeft();
+
+                 /**
+                   \brief delete right column of the board
+                   */
+                 bool shrinkRight();
+
+                 /**
+                   \brief shrink first row of the board
+                   */
+                 bool shrinkTop();
+
+                 /**
+                   \brief delete last row of the board
+                   */
+                 bool shrinkBottom();
+
+                /**
+                 * \brief Grows the board to the left by adding one column.
+                 *
+                 * \param[in] map CV_32FC1 feature map
+                 *
+                 * \returns Returns false if the feature map has no maxima at the requested positions
+                 */
+                bool growLeft(const cv::Mat &map,cv::flann::Index &flann_index);
+                void growLeft();
+
+                /**
+                 * \brief Grows the board to the top by adding one row.
+                 *
+                 * \param[in] map CV_32FC1 feature map
+                 *
+                 * \returns Returns false if the feature map has no maxima at the requested positions
+                 */
+                bool growTop(const cv::Mat &map,cv::flann::Index &flann_index);
+                void growTop();
+
+                /**
+                 * \brief Grows the board to the right by adding one column.
+                 *
+                 * \param[in] map CV_32FC1 feature map
+                 *
+                 * \returns Returns false if the feature map has no maxima at the requested positions
+                 */
+                bool growRight(const cv::Mat &map,cv::flann::Index &flann_index);
+                void growRight();
+
+                /**
+                 * \brief Grows the board to the bottom by adding one row.
+                 *
+                 * \param[in] map CV_32FC1 feature map
+                 *
+                 * \returns Returns false if the feature map has no maxima at the requested positions
+                 */
+                bool growBottom(const cv::Mat &map,cv::flann::Index &flann_index);
+                void growBottom();
+
+                /**
+                 * \brief Adds one column on the left side
+                 *
+                 * \param[in] points The corner coordinates
+                 *
+                 */
+                void addColumnLeft(const std::vector<cv::Point2f> &points);
+
+                /**
+                 * \brief Adds one column at the top
+                 *
+                 * \param[in] points The corner coordinates
+                 *
+                 */
+                void addRowTop(const std::vector<cv::Point2f> &points);
+
+                /**
+                 * \brief Adds one column on the right side
+                 *
+                 * \param[in] points The corner coordinates
+                 *
+                 */
+                void addColumnRight(const std::vector<cv::Point2f> &points);
+
+                /**
+                 * \brief Adds one row at the bottom
+                 *
+                 * \param[in] points The corner coordinates
+                 *
+                 */
+                void addRowBottom(const std::vector<cv::Point2f> &points);
+
+                /**
+                 * \brief Rotates the board 90° degrees to the left
+                 */
+                void rotateLeft();
+
+                /**
+                 * \brief Rotates the board 90° degrees to the right
+                 */
+                void rotateRight();
+
+                /**
+                 * \brief Flips the board along its local x(width) coordinate direction
+                 */
+                void flipVertical();
+
+                /**
+                 * \brief Flips the board along its local y(height) coordinate direction
+                 */
+                void flipHorizontal();
+
+                /**
+                 * \brief Flips and rotates the board so that the angle of
+                 * either the black or white diagonal is bigger than the x
+                 * and y axis of the board and from a right handed
+                 * coordinate system
+                 */
+                void normalizeOrientation(bool bblack=true);
+
+                /**
+                 * \brief Flips and rotates the board so that the marker
+                 * is normalized
+                 */
+                bool normalizeMarkerOrientation();
+
+                /**
+                 * \brief Exchanges the stored board with the board stored in other
+                 */
+                void swap(Chessboard::Board &other);
+
+                bool operator==(const Chessboard::Board& other) const {return rows*cols == other.rows*other.cols;}
+                bool operator< (const Chessboard::Board& other) const {return rows*cols < other.rows*other.cols;}
+                bool operator> (const Chessboard::Board& other) const {return rows*cols > other.rows*other.cols;}
+                bool operator>= (const cv::Size& size)const { return rows*cols >= size.width*size.height; }
+
+                /**
+                 * \brief Returns a specific corner
+                 *
+                 * \info raises runtime_error if row col does not exists
+                 */
+                cv::Point2f& getCorner(int row,int col);
+
+                /**
+                 * \brief Returns true if the cell is empty meaning at least one corner is NaN
+                 */
+                bool isCellEmpty(int row,int col);
+
+                /**
+                 * \brief Returns the mapping from all corners idx to only valid corners idx
+                 */
+                std::map<int,int> getMapping()const;
+
+                /**
+                 * \brief Returns true if the cell is black
+                 *
+                 */
+                 bool isCellBlack(int row,int col)const;
+
+                /**
+                 * \brief Returns true if the cell has a round marker at its
+                 * center
+                 *
+                 */
+                 bool hasCellMarker(int row,int col);
+
+                /**
+                 * \brief Detects round markers in the chessboard fields based
+                 * on the given image and the already recoverd board corners
+                 *
+                 * \returns Returns the number of found markes
+                 *
+                 */
+                 int detectMarkers(cv::InputArray image);
+
+                 /**
+                  * \brief Calculates the average edge sharpness for the chessboard
+                  *
+                  * \param[in] image The image where the chessboard was detected
+                  * \param[in] rise_distance Rise distance 0.8 means 10% ... 90%
+                  * \param[in] vertical by default only edge response for horiontal lines are calculated
+                  *
+                  * \returns Scalar(sharpness, average min_val, average max_val)
+                  *
+                  * \author aduda@krakenrobotik.de
+                  */
+                 cv::Scalar calcEdgeSharpness(cv::InputArray image,float rise_distance=0.8,bool vertical=false,cv::OutputArray sharpness=cv::noArray());
+
+
+                 /**
+                  * \brief Gets the 3D objects points for the chessboard
+                  * assuming the left top corner is located at the origin. In
+                  * case the board as a marker, the white marker cell is at position zero
+                  *
+                  * \param[in] cell_size Size of one cell
+                  *
+                  * \returns Returns the object points as CV_32FC3
+                  */
+                 cv::Mat getObjectPoints(float cell_size)const;
+
+
+                 /**
+                  * \brief Returns the angle the board is rotated agains the x-axis of the image plane
+                  * \returns Returns the object points as CV_32FC3
+                  */
+                 float getAngle()const;
+
+                 /**
+                  * \brief Returns true if the main direction of the board is close to the image x-axis than y-axis
+                  */
+                 bool isHorizontal()const;
+
+                 /**
+                  * \brief Updates the search angles
+                  */
+                 void setAngles(float white,float black);
+
+            private:
+                // stores one cell
+                // in general a cell is initialized by the Board so that:
+                // * all corners are always pointing to a valid cv::Point2f
+                // * depending on the position left,top,right and bottom might be set to NaN
+                // * A cell is empty if at least one corner is NaN
+                struct Cell
+                {
+                    cv::Point2f *top_left,*top_right,*bottom_right,*bottom_left; // corners
+                    Cell *left,*top,*right,*bottom;         // neighbouring cells
+                    bool black;                             // set to true if cell is black
+                    bool marker;                            // set to true if cell has a round marker in its center
+                    Cell();
+                    bool empty()const;                      // indicates if the cell is empty (one of its corners has NaN)
+                    int getRow()const;
+                    int getCol()const;
+                    cv::Point2f getCenter()const;
+                    bool isInside(const cv::Point2f &pt)const;  // check if point is inside the cell
+                };
+
+                // corners
+                enum CornerIndex
+                {
+                    TOP_LEFT,
+                    TOP_RIGHT,
+                    BOTTOM_RIGHT,
+                    BOTTOM_LEFT
+                };
+
+                Cell* getCell(int row,int column); // returns a specific cell
+                const Cell* getCell(int row,int column)const; // returns a specific cell
+                void drawEllipses(const std::vector<Ellipse> &ellipses);
+
+                // Iterator for iterating over board corners
+                class PointIter
+                {
+                    public:
+                        PointIter(Cell *cell,CornerIndex corner_index);
+                        PointIter(const PointIter &other);
+                        void operator=(const PointIter &other);
+                        bool valid() const;                   // returns if the pointer is pointing to a cell
+
+                        bool left(bool check_empty=false);    // moves one corner to the left or returns false
+                        bool right(bool check_empty=false);   // moves one corner to the right or returns false
+                        bool bottom(bool check_empty=false);  // moves one corner to the bottom or returns false
+                        bool top(bool check_empty=false);     // moves one corner to the top or returns false
+                        bool checkCorner()const;              // returns true if the current corner belongs to at least one
+                                                              // none empty cell
+                        bool isNaN()const;                    // returns true if the current corner is NaN
+
+                        const cv::Point2f* operator*() const;  // current corner coordinate
+                        cv::Point2f* operator*();              // current corner coordinate
+                        const cv::Point2f* operator->() const; // current corner coordinate
+                        cv::Point2f* operator->();             // current corner coordinate
+
+                        Cell *getCell();                 // current cell
+                    private:
+                        CornerIndex corner_index;
+                        Cell *cell;
+                };
+
+                std::vector<Cell*> cells;          // storage for all board cells
+                std::vector<cv::Point2f*> corners; // storage for all corners
+                Cell *top_left;                    // pointer to the top left corner of the board in its local coordinate system
+                int rows;                          // number of inner pattern rows
+                int cols;                          // number of inner pattern cols
+                float white_angle,black_angle;
+        };
+    public:
+
+        /**
+         * \brief Creates a chessboard corner detectors
+         *
+         * \param[in] config Configuration used to detect chessboard corners
+         *
+         */
+        Chessboard(const Parameters &config = Parameters());
+        virtual ~Chessboard();
+        void reconfigure(const Parameters &config = Parameters());
+        Parameters getPara()const;
+
+        /*
+         * \brief Detects chessboard corners in the given image.
+         *
+         * The detectors tries to find all chessboard corners of an imaged
+         * chessboard and returns them as an ordered vector of KeyPoints.
+         * Thereby, the left top corner has index 0 and the bottom right
+         * corner n*m-1.
+         *
+         * \param[in] image The image
+         * \param[out] keypoints The detected corners as a vector of ordered KeyPoints
+         * \param[in] mask Currently not supported
+         *
+         */
+        void detect(cv::InputArray image,std::vector<cv::KeyPoint>& keypoints, cv::InputArray mask=cv::Mat())override
+        {cv::Feature2D::detect(image.getMat(),keypoints,mask.getMat());}
+
+        virtual void detectAndCompute(cv::InputArray image,cv::InputArray mask, std::vector<cv::KeyPoint>& keypoints,cv::OutputArray descriptors,
+                                              bool useProvidedKeyPoints = false)override;
+
+        /*
+         * \brief Detects chessboard corners in the given image.
+         *
+         * The detectors tries to find all chessboard corners of an imaged
+         * chessboard and returns them as an ordered vector of KeyPoints.
+         * Thereby, the left top corner has index 0 and the bottom right
+         * corner n*m-1.
+         *
+         * \param[in] image The image
+         * \param[out] keypoints The detected corners as a vector of ordered KeyPoints
+         * \param[out] feature_maps The feature map generated by LRJT and used to find the corners
+         * \param[in] mask Currently not supported
+         *
+         */
+        void detectImpl(const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints,std::vector<cv::Mat> &feature_maps,const cv::Mat& mask)const;
+        Chessboard::Board detectImpl(const cv::Mat& image,std::vector<cv::Mat> &feature_maps,const cv::Mat& mask)const;
+
+        // define pure virtual methods
+        virtual int descriptorSize()const override{return 0;}
+        virtual int descriptorType()const override{return 0;}
+        virtual void operator()( cv::InputArray image, cv::InputArray mask, std::vector<cv::KeyPoint>& keypoints, cv::OutputArray descriptors, bool useProvidedKeypoints=false )const
+        {
+            descriptors.clear();
+            detectImpl(image.getMat(),keypoints,mask);
+            if(!useProvidedKeypoints)        // suppress compiler warning
+                return;
+            return;
+        }
+
+    protected:
+        virtual void computeImpl( const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints, cv::Mat& descriptors)const
+        {
+            descriptors = cv::Mat();
+            detectImpl(image,keypoints);
+        }
+
+        // indicates why a board could not be initialized for a certain keypoint
+        enum BState
+        {
+            MISSING_POINTS = 0,       // at least 5 points are needed
+            MISSING_PAIRS = 1,        // at least two pairs are needed
+            WRONG_PAIR_ANGLE = 2,     // angle between pairs is too small
+            WRONG_CONFIGURATION = 3,  // point configuration is wrong and does not belong to a board
+            FOUND_BOARD = 4           // board was found
+        };
+
+        void findKeyPoints(const cv::Mat& image, std::vector<cv::KeyPoint>& keypoints,std::vector<cv::Mat> &feature_maps,
+                           std::vector<std::vector<float> > &angles ,const cv::Mat& mask)const;
+        cv::Mat buildData(const std::vector<cv::KeyPoint>& keypoints)const;
+        std::vector<cv::KeyPoint> getInitialPoints(cv::flann::Index &flann_index,const cv::Mat &data,const cv::KeyPoint &center,float white_angle,float black_angle, float min_response = 0)const;
+        BState generateBoards(cv::flann::Index &flann_index,const cv::Mat &data, const cv::KeyPoint &center,
+                             float white_angle,float black_angle,float min_response,const cv::Mat &img,
+                             std::vector<Chessboard::Board> &boards)const;
+
+    private:
+        void detectImpl(const cv::Mat&,std::vector<cv::KeyPoint>&, const cv::Mat& mast =cv::Mat())const;
+        virtual void detectImpl(cv::InputArray image, std::vector<cv::KeyPoint>& keypoints, cv::InputArray mask=cv::noArray())const;
+
+    private:
+        Parameters parameters; // storing the configuration of the detector
+};
+}}  // end namespace details and cv
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/circlesgrid.cpp b/upstream/opencv/modules/objdetect/src/circlesgrid.cpp
new file mode 100644
index 0000000..8088b2c
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/circlesgrid.cpp
@@ -0,0 +1,1662 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+#include "circlesgrid.hpp"
+#include <limits>
+
+ // Requires CMake flag: DEBUG_opencv_calib=ON
+//#define DEBUG_CIRCLES
+
+#ifdef DEBUG_CIRCLES
+#  include <iostream>
+#  include "opencv2/opencv_modules.hpp"
+#  ifdef HAVE_OPENCV_HIGHGUI
+#    include "opencv2/highgui.hpp"
+#  else
+#    undef DEBUG_CIRCLES
+#  endif
+#endif
+
+#include "opencv2/geometry.hpp"
+
+namespace cv {
+
+#ifdef DEBUG_CIRCLES
+void drawPoints(const std::vector<Point2f> &points, Mat &outImage, int radius = 2,  Scalar color = Scalar::all(255), int thickness = -1)
+{
+  for(size_t i=0; i<points.size(); i++)
+  {
+    circle(outImage, points[i], radius, color, thickness);
+  }
+}
+#endif
+
+void CirclesGridClusterFinder::hierarchicalClustering(const std::vector<Point2f> &points, const Size &patternSz, std::vector<Point2f> &patternPoints)
+{
+    int j, n = (int)points.size();
+    size_t pn = static_cast<size_t>(patternSz.area());
+
+    patternPoints.clear();
+    if (pn >= points.size())
+    {
+        if (pn == points.size())
+            patternPoints = points;
+        return;
+    }
+
+    Mat dists(n, n, CV_32FC1, Scalar(0));
+    Mat distsMask(dists.size(), CV_8UC1, Scalar(0));
+    for(int i = 0; i < n; i++)
+    {
+        for(j = i+1; j < n; j++)
+        {
+            dists.at<float>(i, j) = (float)norm(points[i] - points[j]);
+            distsMask.at<uchar>(i, j) = 255;
+            //TODO: use symmetry
+            distsMask.at<uchar>(j, i) = 255;//distsMask.at<uchar>(i, j);
+            dists.at<float>(j, i) = dists.at<float>(i, j);
+        }
+    }
+
+    std::vector<std::list<size_t> > clusters(points.size());
+    for(size_t i=0; i<points.size(); i++)
+    {
+        clusters[i].push_back(i);
+    }
+
+    int patternClusterIdx = 0;
+    while(clusters[patternClusterIdx].size() < pn)
+    {
+        Point minLoc;
+        minMaxLoc(dists, 0, 0, &minLoc, 0, distsMask);
+        int minIdx = std::min(minLoc.x, minLoc.y);
+        int maxIdx = std::max(minLoc.x, minLoc.y);
+
+        distsMask.row(maxIdx).setTo(0);
+        distsMask.col(maxIdx).setTo(0);
+        Mat tmpRow = dists.row(minIdx);
+        Mat tmpCol = dists.col(minIdx);
+        cv::min(dists.row(minLoc.x), dists.row(minLoc.y), tmpRow);
+        tmpRow = tmpRow.t();
+        tmpRow.copyTo(tmpCol);
+
+        clusters[minIdx].splice(clusters[minIdx].end(), clusters[maxIdx]);
+        patternClusterIdx = minIdx;
+    }
+
+    //the largest cluster can have more than pn points -- we need to filter out such situations
+    if(clusters[patternClusterIdx].size() != static_cast<size_t>(patternSz.area()))
+    {
+      return;
+    }
+
+    patternPoints.reserve(clusters[patternClusterIdx].size());
+    for(std::list<size_t>::iterator it = clusters[patternClusterIdx].begin(); it != clusters[patternClusterIdx].end();++it)
+    {
+        patternPoints.push_back(points[*it]);
+    }
+}
+
+void CirclesGridClusterFinder::findGrid(const std::vector<cv::Point2f> &points, cv::Size _patternSize, std::vector<Point2f>& centers)
+{
+  patternSize = _patternSize;
+  centers.clear();
+  if(points.empty())
+  {
+    return;
+  }
+
+  std::vector<Point2f> patternPoints;
+  hierarchicalClustering(points, patternSize, patternPoints);
+  if(patternPoints.empty())
+  {
+    return;
+  }
+
+#ifdef DEBUG_CIRCLES
+  Mat patternPointsImage(1024, 1248, CV_8UC1, Scalar(0));
+  drawPoints(patternPoints, patternPointsImage);
+  imshow("pattern points", patternPointsImage);
+#endif
+
+  std::vector<Point2f> hull2f;
+  convexHull(patternPoints, hull2f, false);
+  const size_t cornersCount = isAsymmetricGrid ? 6 : 4;
+  if(hull2f.size() < cornersCount)
+    return;
+
+  std::vector<Point2f> corners;
+  findCorners(hull2f, corners);
+  if(corners.size() != cornersCount)
+    return;
+
+  std::vector<Point2f> outsideCorners, sortedCorners;
+  if(isAsymmetricGrid)
+  {
+    findOutsideCorners(corners, outsideCorners);
+    const size_t outsideCornersCount = 2;
+    if(outsideCorners.size() != outsideCornersCount)
+      return;
+  }
+  getSortedCorners(hull2f, patternPoints, corners, outsideCorners, sortedCorners);
+  if(sortedCorners.size() != cornersCount)
+    return;
+
+  std::vector<Point2f> rectifiedPatternPoints;
+  rectifyPatternPoints(patternPoints, sortedCorners, rectifiedPatternPoints);
+  if(patternPoints.size() != rectifiedPatternPoints.size())
+    return;
+
+  parsePatternPoints(patternPoints, rectifiedPatternPoints, centers);
+}
+
+void CirclesGridClusterFinder::findCorners(const std::vector<cv::Point2f> &hull2f, std::vector<cv::Point2f> &corners)
+{
+  //find angles (cosines) of vertices in convex hull
+  std::vector<float> angles;
+  for(size_t i=0; i<hull2f.size(); i++)
+  {
+    Point2f vec1 = hull2f[(i+1) % hull2f.size()] - hull2f[i % hull2f.size()];
+    Point2f vec2 = hull2f[(i-1 + static_cast<int>(hull2f.size())) % hull2f.size()] - hull2f[i % hull2f.size()];
+    float angle = (float)(vec1.ddot(vec2) / (norm(vec1) * norm(vec2)));
+    angles.push_back(angle);
+  }
+
+  //sort angles by cosine
+  //corners are the most sharp angles (6)
+  Mat anglesMat = Mat(angles);
+  Mat sortedIndices;
+  sortIdx(anglesMat, sortedIndices, SORT_EVERY_ROW + SORT_DESCENDING);
+  CV_Assert(sortedIndices.type() == CV_32SC1);
+  CV_Assert(sortedIndices.rows == 1);
+  const int cornersCount = isAsymmetricGrid ? 6 : 4;
+  Mat cornersIndices;
+  cv::sort(sortedIndices.colRange(0, cornersCount), cornersIndices, SORT_EVERY_ROW + SORT_ASCENDING);
+  corners.clear();
+  for(int i=0; i<cornersCount; i++)
+  {
+    corners.push_back(hull2f[cornersIndices.at<int>(i)]);
+  }
+}
+
+void CirclesGridClusterFinder::findOutsideCorners(const std::vector<cv::Point2f> &corners, std::vector<cv::Point2f> &outsideCorners)
+{
+  CV_Assert(!corners.empty());
+  outsideCorners.clear();
+  //find two pairs of the most nearest corners
+  const size_t n = corners.size();
+
+#ifdef DEBUG_CIRCLES
+  Mat cornersImage(1024, 1248, CV_8UC1, Scalar(0));
+  drawPoints(corners, cornersImage);
+  imshow("corners", cornersImage);
+#endif
+
+  std::vector<Point2f> tangentVectors(n);
+  for(size_t k=0; k < n; k++)
+  {
+    Point2f diff = corners[(k + 1) % n] - corners[k];
+    tangentVectors[k] = diff * (1.0f / norm(diff));
+  }
+
+  //compute angles between all sides
+  Mat cosAngles((int)n, (int)n, CV_32FC1, 0.0f);
+  for(size_t i = 0; i < n; i++)
+  {
+    for(size_t j = i + 1; j < n; j++)
+    {
+      float val = fabs(tangentVectors[i].dot(tangentVectors[j]));
+      cosAngles.at<float>((int)i, (int)j) = val;
+      cosAngles.at<float>((int)j, (int)i) = val;
+    }
+  }
+
+  //find two parallel sides to which outside corners belong
+  Point maxLoc;
+  minMaxLoc(cosAngles, 0, 0, 0, &maxLoc);
+  const int diffBetweenFalseLines = 3;
+  if(abs(maxLoc.x - maxLoc.y) == diffBetweenFalseLines)
+  {
+    cosAngles.row(maxLoc.x).setTo(0.0f);
+    cosAngles.col(maxLoc.x).setTo(0.0f);
+    cosAngles.row(maxLoc.y).setTo(0.0f);
+    cosAngles.col(maxLoc.y).setTo(0.0f);
+    minMaxLoc(cosAngles, 0, 0, 0, &maxLoc);
+  }
+
+#ifdef DEBUG_CIRCLES
+  Mat linesImage(1024, 1248, CV_8UC1, Scalar(0));
+  line(linesImage, corners[maxLoc.y], corners[(maxLoc.y + 1) % n], Scalar(255));
+  line(linesImage, corners[maxLoc.x], corners[(maxLoc.x + 1) % n], Scalar(255));
+  imshow("lines", linesImage);
+#endif
+
+  int maxIdx = std::max(maxLoc.x, maxLoc.y);
+  int minIdx = std::min(maxLoc.x, maxLoc.y);
+  const int bigDiff = 4;
+  if(maxIdx - minIdx == bigDiff)
+  {
+    minIdx += (int)n;
+    std::swap(maxIdx, minIdx);
+  }
+  if(maxIdx - minIdx != (int)n - bigDiff)
+  {
+    return;
+  }
+
+  int outsidersSegmentIdx = (minIdx + maxIdx) / 2;
+
+  outsideCorners.push_back(corners[outsidersSegmentIdx % n]);
+  outsideCorners.push_back(corners[(outsidersSegmentIdx + 1) % n]);
+
+#ifdef DEBUG_CIRCLES
+  drawPoints(outsideCorners, cornersImage, 2, Scalar(128));
+  imshow("corners", cornersImage);
+#endif
+}
+
+namespace {
+double pointLineDistance(const cv::Point2f &p, const cv::Vec4f &line)
+{
+  Vec3f pa( line[0], line[1], 1 );
+  Vec3f pb( line[2], line[3], 1 );
+  Vec3f l = pa.cross(pb);
+  return std::abs((p.x * l[0] + p.y * l[1] + l[2])) * 1.0 /
+         std::sqrt(double(l[0] * l[0] + l[1] * l[1]));
+}
+}
+
+void CirclesGridClusterFinder::getSortedCorners(const std::vector<cv::Point2f> &hull2f, const std::vector<cv::Point2f> &patternPoints, const std::vector<cv::Point2f> &corners, const std::vector<cv::Point2f> &outsideCorners, std::vector<cv::Point2f> &sortedCorners)
+{
+  Point2f firstCorner;
+  if(isAsymmetricGrid)
+  {
+    Point2f center = std::accumulate(corners.begin(), corners.end(), Point2f(0.0f, 0.0f));
+    center *= 1.0 / corners.size();
+
+    std::vector<Point2f> centerToCorners;
+    for(size_t i=0; i<outsideCorners.size(); i++)
+    {
+      centerToCorners.push_back(outsideCorners[i] - center);
+    }
+
+    //TODO: use CirclesGridFinder::getDirection
+    float crossProduct = centerToCorners[0].x * centerToCorners[1].y - centerToCorners[0].y * centerToCorners[1].x;
+    //y axis is inverted in computer vision so we check > 0
+    bool isClockwise = crossProduct > 0;
+    firstCorner  = isClockwise ? outsideCorners[1] : outsideCorners[0];
+  }
+  else
+  {
+    firstCorner = corners[0];
+  }
+
+  std::vector<Point2f>::const_iterator firstCornerIterator = std::find(hull2f.begin(), hull2f.end(), firstCorner);
+  sortedCorners.clear();
+  for(std::vector<Point2f>::const_iterator it = firstCornerIterator; it != hull2f.end();++it)
+  {
+    std::vector<Point2f>::const_iterator itCorners = std::find(corners.begin(), corners.end(), *it);
+    if(itCorners != corners.end())
+    {
+      sortedCorners.push_back(*it);
+    }
+  }
+  for(std::vector<Point2f>::const_iterator it = hull2f.begin(); it != firstCornerIterator;++it)
+  {
+    std::vector<Point2f>::const_iterator itCorners = std::find(corners.begin(), corners.end(), *it);
+    if(itCorners != corners.end())
+    {
+      sortedCorners.push_back(*it);
+    }
+  }
+
+  if(!isAsymmetricGrid)
+  {
+    double dist01 = norm(sortedCorners[0] - sortedCorners[1]);
+    double dist12 = norm(sortedCorners[1] - sortedCorners[2]);
+    // Use half the average distance between circles on the shorter side as threshold for determining whether a point lies on an edge.
+    double thresh = min(dist01, dist12) / min(patternSize.width, patternSize.height) / 2;
+
+    size_t circleCount01 = 0;
+    size_t circleCount12 = 0;
+    Vec4f line01( sortedCorners[0].x, sortedCorners[0].y, sortedCorners[1].x, sortedCorners[1].y );
+    Vec4f line12( sortedCorners[1].x, sortedCorners[1].y, sortedCorners[2].x, sortedCorners[2].y );
+    // Count the circles along both edges.
+    for (size_t i = 0; i < patternPoints.size(); i++)
+    {
+      if (pointLineDistance(patternPoints[i], line01) < thresh)
+        circleCount01++;
+      if (pointLineDistance(patternPoints[i], line12) < thresh)
+        circleCount12++;
+    }
+
+    // Ensure that the edge from sortedCorners[0] to sortedCorners[1] is the one with more circles (i.e. it is interpreted as the pattern's width).
+    if ((circleCount01 > circleCount12 && patternSize.height > patternSize.width) || (circleCount01 < circleCount12 && patternSize.height < patternSize.width))
+    {
+      for(size_t i=0; i<sortedCorners.size()-1; i++)
+      {
+        sortedCorners[i] = sortedCorners[i+1];
+      }
+      sortedCorners[sortedCorners.size() - 1] = firstCorner;
+    }
+  }
+}
+
+void CirclesGridClusterFinder::rectifyPatternPoints(const std::vector<cv::Point2f> &patternPoints, const std::vector<cv::Point2f> &sortedCorners, std::vector<cv::Point2f> &rectifiedPatternPoints)
+{
+  //indices of corner points in pattern
+  std::vector<Point> trueIndices;
+  trueIndices.emplace_back(0, 0);
+  trueIndices.emplace_back(patternSize.width - 1, 0);
+  if(isAsymmetricGrid)
+  {
+    trueIndices.emplace_back(patternSize.width - 1, 1);
+    trueIndices.emplace_back(patternSize.width - 1, patternSize.height - 2);
+  }
+  trueIndices.emplace_back(patternSize.width - 1, patternSize.height - 1);
+  trueIndices.emplace_back(0, patternSize.height - 1);
+
+  std::vector<Point2f> idealPoints;
+  for(size_t idx=0; idx<trueIndices.size(); idx++)
+  {
+    int i = trueIndices[idx].y;
+    int j = trueIndices[idx].x;
+    if(isAsymmetricGrid)
+    {
+      idealPoints.emplace_back((2*j + i % 2)*squareSize, i*squareSize);
+    }
+    else
+    {
+      idealPoints.emplace_back(j*squareSize, i*squareSize);
+    }
+  }
+
+  Mat homography = findHomography(sortedCorners, idealPoints, 0);
+  Mat rectifiedPointsMat;
+  transform(patternPoints, rectifiedPointsMat, homography);
+  rectifiedPatternPoints.clear();
+  convertPointsFromHomogeneous(rectifiedPointsMat, rectifiedPatternPoints);
+}
+
+void CirclesGridClusterFinder::parsePatternPoints(const std::vector<cv::Point2f> &patternPoints,
+                                                  const std::vector<cv::Point2f> &rectifiedPatternPoints,
+                                                  std::vector<cv::Point2f> &centers)
+{
+#ifndef HAVE_OPENCV_FLANN
+  CV_UNUSED(patternPoints);
+  CV_UNUSED(rectifiedPatternPoints);
+  CV_UNUSED(centers);
+  CV_Error(Error::StsNotImplemented, "The desired functionality requires flann module, which was disabled.");
+#else
+  flann::LinearIndexParams flannIndexParams;
+  flann::Index flannIndex(Mat(rectifiedPatternPoints).reshape(1,
+                (int)rectifiedPatternPoints.size()), flannIndexParams);
+
+  centers.clear();
+  for( int i = 0; i < patternSize.height; i++ )
+  {
+    for( int j = 0; j < patternSize.width; j++ )
+    {
+      Point2f idealPt;
+      if(isAsymmetricGrid)
+        idealPt = Point2f((2*j + i % 2)*squareSize, i*squareSize);
+      else
+        idealPt = Point2f(j*squareSize, i*squareSize);
+
+      Mat query(1, 2, CV_32F, &idealPt);
+      const int knn = 1;
+      int indicesbuf[knn] = {0};
+      float distsbuf[knn] = {0.f};
+      Mat indices(1, knn, CV_32S, &indicesbuf);
+      Mat dists(1, knn, CV_32F, &distsbuf);
+      flannIndex.knnSearch(query, indices, dists, knn, flann::SearchParams());
+      centers.push_back(patternPoints.at(indicesbuf[0]));
+
+      if(distsbuf[0] > maxRectifiedDistance)
+      {
+#ifdef DEBUG_CIRCLES
+        std::cout << "Pattern not detected: too large rectified distance" << std::endl;
+#endif
+        centers.clear();
+        return;
+      }
+    }
+  }
+#endif
+}
+
+Graph::Graph(size_t n)
+{
+  for (size_t i = 0; i < n; i++)
+  {
+    addVertex(i);
+  }
+}
+
+bool Graph::doesVertexExist(size_t id) const
+{
+  return (vertices.find(id) != vertices.end());
+}
+
+void Graph::addVertex(size_t id)
+{
+  CV_Assert( !doesVertexExist( id ) );
+
+  vertices.emplace(id, Vertex());
+}
+
+void Graph::addEdge(size_t id1, size_t id2)
+{
+  CV_Assert( doesVertexExist( id1 ) );
+  CV_Assert( doesVertexExist( id2 ) );
+
+  vertices[id1].neighbors.insert(id2);
+  vertices[id2].neighbors.insert(id1);
+}
+
+void Graph::removeEdge(size_t id1, size_t id2)
+{
+  CV_Assert( doesVertexExist( id1 ) );
+  CV_Assert( doesVertexExist( id2 ) );
+
+  vertices[id1].neighbors.erase(id2);
+  vertices[id2].neighbors.erase(id1);
+}
+
+bool Graph::areVerticesAdjacent(size_t id1, size_t id2) const
+{
+  Vertices::const_iterator it = vertices.find(id1);
+  CV_Assert(it != vertices.end());
+  const Neighbors & neighbors = it->second.neighbors;
+  return neighbors.find(id2) != neighbors.end();
+}
+
+size_t Graph::getVerticesCount() const
+{
+  return vertices.size();
+}
+
+size_t Graph::getDegree(size_t id) const
+{
+  Vertices::const_iterator it = vertices.find(id);
+  CV_Assert( it != vertices.end() );
+  return it->second.neighbors.size();
+}
+
+void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
+{
+  const int edgeWeight = 1;
+
+  const int n = (int)getVerticesCount();
+  distanceMatrix.create(n, n, CV_32SC1);
+  distanceMatrix.setTo(infinity);
+  for (Vertices::const_iterator it1 = vertices.begin(); it1 != vertices.end();++it1)
+  {
+    distanceMatrix.at<int> ((int)it1->first, (int)it1->first) = 0;
+    for (Neighbors::const_iterator it2 = it1->second.neighbors.begin(); it2 != it1->second.neighbors.end();++it2)
+    {
+      CV_Assert( it1->first != *it2 );
+      distanceMatrix.at<int> ((int)it1->first, (int)*it2) = edgeWeight;
+    }
+  }
+
+  for (Vertices::const_iterator it1 = vertices.begin(); it1 != vertices.end();++it1)
+  {
+    for (Vertices::const_iterator it2 = vertices.begin(); it2 != vertices.end();++it2)
+    {
+      for (Vertices::const_iterator it3 = vertices.begin(); it3 != vertices.end();++it3)
+      {
+      int i1 = (int)it1->first, i2 = (int)it2->first, i3 = (int)it3->first;
+        int val1 = distanceMatrix.at<int> (i2, i3);
+        int val2;
+        if (distanceMatrix.at<int> (i2, i1) == infinity ||
+      distanceMatrix.at<int> (i1, i3) == infinity)
+          val2 = val1;
+        else
+        {
+          val2 = distanceMatrix.at<int> (i2, i1) + distanceMatrix.at<int> (i1, i3);
+        }
+        distanceMatrix.at<int> (i2, i3) = (val1 == infinity) ? val2 : std::min(val1, val2);
+      }
+    }
+  }
+}
+
+const Graph::Neighbors& Graph::getNeighbors(size_t id) const
+{
+  Vertices::const_iterator it = vertices.find(id);
+  CV_Assert( it != vertices.end() );
+  return it->second.neighbors;
+}
+
+CirclesGridFinder::Segment::Segment(cv::Point2f _s, cv::Point2f _e) :
+  s(_s), e(_e)
+{
+}
+
+void computeShortestPath(Mat &predecessorMatrix, int v1, int v2, std::vector<int> &path);
+void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessorMatrix);
+
+CirclesGridFinderParameters::CirclesGridFinderParameters()
+{
+  minDensity = 10;
+  densityNeighborhoodSize = Size2f(16, 16);
+  minDistanceToAddKeypoint = 20;
+  kmeansAttempts = 100;
+  convexHullFactor = 1.1f;
+  keypointScale = 1;
+
+  minGraphConfidence = 9;
+  vertexGain = 1;
+  vertexPenalty = -0.6f;
+  edgeGain = 1;
+  edgePenalty = -0.6f;
+  existingVertexGain = 10000;
+
+  minRNGEdgeSwitchDist = 5.f;
+  gridType = SYMMETRIC_GRID;
+
+  squareSize = 1.0f;
+  maxRectifiedDistance = squareSize/2.0f;
+}
+
+CirclesGridFinder::CirclesGridFinder(Size _patternSize, const std::vector<Point2f> &testKeypoints,
+                                     const CirclesGridFinderParameters &_parameters) :
+  patternSize(static_cast<size_t> (_patternSize.width), static_cast<size_t> (_patternSize.height))
+{
+  CV_Assert(_patternSize.height >= 0 && _patternSize.width >= 0);
+
+  keypoints = testKeypoints;
+  parameters = _parameters;
+  largeHoles = 0;
+  smallHoles = 0;
+}
+
+bool CirclesGridFinder::findHoles()
+{
+  switch (parameters.gridType)
+  {
+    case CirclesGridFinderParameters::SYMMETRIC_GRID:
+    {
+      std::vector<Point2f> vectors, filteredVectors, basis;
+      Graph rng(0);
+      computeRNG(rng, vectors);
+      filterOutliersByDensity(vectors, filteredVectors);
+      std::vector<Graph> basisGraphs;
+      findBasis(filteredVectors, basis, basisGraphs);
+      findMCS(basis, basisGraphs);
+      break;
+    }
+
+    case CirclesGridFinderParameters::ASYMMETRIC_GRID:
+    {
+      std::vector<Point2f> vectors, tmpVectors, filteredVectors, basis;
+      Graph rng(0);
+      computeRNG(rng, tmpVectors);
+      rng2gridGraph(rng, vectors);
+      filterOutliersByDensity(vectors, filteredVectors);
+      std::vector<Graph> basisGraphs;
+      findBasis(filteredVectors, basis, basisGraphs);
+      findMCS(basis, basisGraphs);
+      eraseUsedGraph(basisGraphs);
+      holes2 = holes;
+      holes.clear();
+      findMCS(basis, basisGraphs);
+      break;
+    }
+
+    default:
+      CV_Error(Error::StsBadArg, "Unknown pattern type");
+  }
+  return (isDetectionCorrect());
+}
+
+void CirclesGridFinder::rng2gridGraph(Graph &rng, std::vector<cv::Point2f> &vectors) const
+{
+  for (size_t i = 0; i < rng.getVerticesCount(); i++)
+  {
+    Graph::Neighbors neighbors1 = rng.getNeighbors(i);
+    for (Graph::Neighbors::iterator it1 = neighbors1.begin(); it1 != neighbors1.end(); ++it1)
+    {
+      Graph::Neighbors neighbors2 = rng.getNeighbors(*it1);
+      for (Graph::Neighbors::iterator it2 = neighbors2.begin(); it2 != neighbors2.end(); ++it2)
+      {
+        if (i < *it2)
+        {
+          Point2f vec1 = keypoints[i] - keypoints[*it1];
+          Point2f vec2 = keypoints[*it1] - keypoints[*it2];
+          if (norm(vec1 - vec2) < parameters.minRNGEdgeSwitchDist || norm(vec1 + vec2)
+              < parameters.minRNGEdgeSwitchDist)
+            continue;
+
+          vectors.push_back(keypoints[i] - keypoints[*it2]);
+          vectors.push_back(keypoints[*it2] - keypoints[i]);
+        }
+      }
+    }
+  }
+}
+
+void CirclesGridFinder::eraseUsedGraph(std::vector<Graph> &basisGraphs) const
+{
+  for (size_t i = 0; i < holes.size(); i++)
+  {
+    for (size_t j = 0; j < holes[i].size(); j++)
+    {
+      for (size_t k = 0; k < basisGraphs.size(); k++)
+      {
+        if (i != holes.size() - 1 && basisGraphs[k].areVerticesAdjacent(holes[i][j], holes[i + 1][j]))
+        {
+          basisGraphs[k].removeEdge(holes[i][j], holes[i + 1][j]);
+        }
+
+        if (j != holes[i].size() - 1 && basisGraphs[k].areVerticesAdjacent(holes[i][j], holes[i][j + 1]))
+        {
+          basisGraphs[k].removeEdge(holes[i][j], holes[i][j + 1]);
+        }
+      }
+    }
+  }
+}
+
+bool CirclesGridFinder::isDetectionCorrect()
+{
+  switch (parameters.gridType)
+  {
+    case CirclesGridFinderParameters::SYMMETRIC_GRID:
+    {
+      rotatedGrid = holes.size() != patternSize.height && holes.size() == patternSize.width;
+      if (holes.size() != patternSize.height && holes.size() != patternSize.width)
+        return false;
+
+      size_t num_vertices = 0ull;
+      for (size_t i = 0; i < holes.size(); i++)
+      {
+        if (holes[i].size() != patternSize.width && rotatedGrid == false)
+        {
+          return false;
+        }
+        else if (holes[i].size() != patternSize.height && rotatedGrid == true)
+        {
+          rotatedGrid = false;
+          return false;
+        }
+
+        num_vertices += holes[i].size();
+      }
+      return num_vertices == patternSize.area();
+    }
+
+    case CirclesGridFinderParameters::ASYMMETRIC_GRID:
+    {
+      if (holes.size() < holes2.size() || holes[0].size() < holes2[0].size())
+      {
+        largeHoles = &holes2;
+        smallHoles = &holes;
+      }
+      else
+      {
+        largeHoles = &holes;
+        smallHoles = &holes2;
+      }
+
+      size_t largeWidth = patternSize.width;
+      size_t largeHeight = (size_t)ceil(patternSize.height / 2.);
+      size_t smallWidth = patternSize.width;
+      size_t smallHeight = (size_t)floor(patternSize.height / 2.);
+
+      size_t sw = smallWidth, sh = smallHeight, lw = largeWidth, lh = largeHeight;
+      if (largeHoles->size() != largeHeight)
+      {
+        std::swap(lh, lw);
+      }
+      if (smallHoles->size() != smallHeight)
+      {
+        std::swap(sh, sw);
+      }
+
+      if (largeHoles->size() != lh || smallHoles->size() != sh)
+      {
+        return false;
+      }
+
+      std::set<size_t> vertices;
+      for (size_t i = 0; i < largeHoles->size(); i++)
+      {
+        if (largeHoles->at(i).size() != lw)
+        {
+          return false;
+        }
+
+        for (size_t j = 0; j < largeHoles->at(i).size(); j++)
+        {
+          vertices.insert(largeHoles->at(i)[j]);
+        }
+
+        if (i < smallHoles->size())
+        {
+          if (smallHoles->at(i).size() != sw)
+          {
+            return false;
+          }
+
+          for (size_t j = 0; j < smallHoles->at(i).size(); j++)
+          {
+            vertices.insert(smallHoles->at(i)[j]);
+          }
+        }
+      }
+      return (vertices.size() == largeHeight * largeWidth + smallHeight * smallWidth);
+    }
+  }
+  CV_Error(Error::StsBadArg, "Unknown pattern type");
+}
+
+void CirclesGridFinder::findMCS(const std::vector<Point2f> &basis, std::vector<Graph> &basisGraphs)
+{
+  holes.clear();
+  Path longestPath;
+  size_t bestGraphIdx = findLongestPath(basisGraphs, longestPath);
+  std::vector<size_t> holesRow = longestPath.vertices;
+
+  while (holesRow.size() > std::max(patternSize.width, patternSize.height))
+  {
+    holesRow.pop_back();
+    holesRow.erase(holesRow.begin());
+  }
+
+  if (bestGraphIdx == 0)
+  {
+    holes.push_back(holesRow);
+    size_t w = holes[0].size();
+    size_t h = holes.size();
+
+    //parameters.minGraphConfidence = holes[0].size() * parameters.vertexGain + (holes[0].size() - 1) * parameters.edgeGain;
+    //parameters.minGraphConfidence = holes[0].size() * parameters.vertexGain + (holes[0].size() / 2) * parameters.edgeGain;
+    //parameters.minGraphConfidence = holes[0].size() * parameters.existingVertexGain + (holes[0].size() / 2) * parameters.edgeGain;
+    parameters.minGraphConfidence = holes[0].size() * parameters.existingVertexGain;
+    for (size_t i = h; i < patternSize.height; i++)
+    {
+      addHolesByGraph(basisGraphs, true, basis[1]);
+    }
+
+    //parameters.minGraphConfidence = holes.size() * parameters.existingVertexGain + (holes.size() / 2) * parameters.edgeGain;
+    parameters.minGraphConfidence = holes.size() * parameters.existingVertexGain;
+
+    for (size_t i = w; i < patternSize.width; i++)
+    {
+      addHolesByGraph(basisGraphs, false, basis[0]);
+    }
+  }
+  else
+  {
+    holes.resize(holesRow.size());
+    for (size_t i = 0; i < holesRow.size(); i++)
+      holes[i].push_back(holesRow[i]);
+
+    size_t w = holes[0].size();
+    size_t h = holes.size();
+
+    parameters.minGraphConfidence = holes.size() * parameters.existingVertexGain;
+    for (size_t i = w; i < patternSize.width; i++)
+    {
+      addHolesByGraph(basisGraphs, false, basis[0]);
+    }
+
+    parameters.minGraphConfidence = holes[0].size() * parameters.existingVertexGain;
+    for (size_t i = h; i < patternSize.height; i++)
+    {
+      addHolesByGraph(basisGraphs, true, basis[1]);
+    }
+  }
+}
+
+Mat CirclesGridFinder::rectifyGrid(Size detectedGridSize, const std::vector<Point2f>& centers,
+                                   const std::vector<Point2f> &keypoints, std::vector<Point2f> &warpedKeypoints)
+{
+  CV_Assert( !centers.empty() );
+  const float edgeLength = 30;
+  const Point2f offset(150, 150);
+
+  std::vector<Point2f> dstPoints;
+  bool isClockwiseBefore =
+      getDirection(centers[0], centers[detectedGridSize.width - 1], centers[centers.size() - 1]) < 0;
+
+  int iStart = isClockwiseBefore ? 0 : detectedGridSize.height - 1;
+  int iEnd = isClockwiseBefore ? detectedGridSize.height : -1;
+  int iStep = isClockwiseBefore ? 1 : -1;
+  for (int i = iStart; i != iEnd; i += iStep)
+  {
+    for (int j = 0; j < detectedGridSize.width; j++)
+    {
+      dstPoints.push_back(offset + Point2f(edgeLength * j, edgeLength * i));
+    }
+  }
+
+  Mat H = findHomography(centers, dstPoints, RANSAC);
+  //Mat H = findHomography(corners, dstPoints);
+
+  if (H.empty())
+  {
+      H = Mat::zeros(3, 3, CV_64FC1);
+      warpedKeypoints.clear();
+      return H;
+  }
+
+  std::vector<Point2f> srcKeypoints;
+  for (size_t i = 0; i < keypoints.size(); i++)
+  {
+    srcKeypoints.push_back(keypoints[i]);
+  }
+
+  Mat dstKeypointsMat;
+  transform(srcKeypoints, dstKeypointsMat, H);
+  std::vector<Point2f> dstKeypoints;
+  convertPointsFromHomogeneous(dstKeypointsMat, dstKeypoints);
+
+  warpedKeypoints.clear();
+  for (auto &pt:dstKeypoints)
+  {
+    warpedKeypoints.emplace_back(std::move(pt));
+  }
+
+  return H;
+}
+
+size_t CirclesGridFinder::findNearestKeypoint(Point2f pt) const
+{
+  size_t bestIdx = 0;
+  double minDist = std::numeric_limits<double>::max();
+  for (size_t i = 0; i < keypoints.size(); i++)
+  {
+    double dist = norm(pt - keypoints[i]);
+    if (dist < minDist)
+    {
+      minDist = dist;
+      bestIdx = i;
+    }
+  }
+  return bestIdx;
+}
+
+void CirclesGridFinder::addPoint(Point2f pt, std::vector<size_t> &points)
+{
+  size_t ptIdx = findNearestKeypoint(pt);
+  if (norm(keypoints[ptIdx] - pt) > parameters.minDistanceToAddKeypoint)
+  {
+    Point2f kpt = Point2f(pt);
+    keypoints.push_back(kpt);
+    points.push_back(keypoints.size() - 1);
+  }
+  else
+  {
+    points.push_back(ptIdx);
+  }
+}
+
+void CirclesGridFinder::findCandidateLine(std::vector<size_t> &line, size_t seedLineIdx, bool addRow, Point2f basisVec,
+                                          std::vector<size_t> &seeds)
+{
+  line.clear();
+  seeds.clear();
+
+  if (addRow)
+  {
+    for (size_t i = 0; i < holes[seedLineIdx].size(); i++)
+    {
+      Point2f pt = keypoints[holes[seedLineIdx][i]] + basisVec;
+      addPoint(pt, line);
+      seeds.push_back(holes[seedLineIdx][i]);
+    }
+  }
+  else
+  {
+    for (size_t i = 0; i < holes.size(); i++)
+    {
+      Point2f pt = keypoints[holes[i][seedLineIdx]] + basisVec;
+      addPoint(pt, line);
+      seeds.push_back(holes[i][seedLineIdx]);
+    }
+  }
+
+  CV_Assert( line.size() == seeds.size() );
+}
+
+void CirclesGridFinder::findCandidateHoles(std::vector<size_t> &above, std::vector<size_t> &below, bool addRow, Point2f basisVec,
+                                           std::vector<size_t> &aboveSeeds, std::vector<size_t> &belowSeeds)
+{
+  above.clear();
+  below.clear();
+  aboveSeeds.clear();
+  belowSeeds.clear();
+
+  findCandidateLine(above, 0, addRow, -basisVec, aboveSeeds);
+  size_t lastIdx = addRow ? holes.size() - 1 : holes[0].size() - 1;
+  findCandidateLine(below, lastIdx, addRow, basisVec, belowSeeds);
+
+  CV_Assert( below.size() == above.size() );
+  CV_Assert( belowSeeds.size() == aboveSeeds.size() );
+  CV_Assert( below.size() == belowSeeds.size() );
+}
+
+bool CirclesGridFinder::areCentersNew(const std::vector<size_t> &newCenters, const std::vector<std::vector<size_t> > &holes)
+{
+  for (size_t i = 0; i < newCenters.size(); i++)
+  {
+    for (size_t j = 0; j < holes.size(); j++)
+    {
+      if (holes[j].end() != std::find(holes[j].begin(), holes[j].end(), newCenters[i]))
+      {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+void CirclesGridFinder::insertWinner(float aboveConfidence, float belowConfidence, float minConfidence, bool addRow,
+                                     const std::vector<size_t> &above, const std::vector<size_t> &below,
+                                     std::vector<std::vector<size_t> > &holes)
+{
+  if (aboveConfidence < minConfidence && belowConfidence < minConfidence)
+    return;
+
+  if (addRow)
+  {
+    if (aboveConfidence >= belowConfidence)
+    {
+      if (!areCentersNew(above, holes))
+        CV_Error( cv::Error::StsError, "Centers are not new" );
+
+      holes.insert(holes.begin(), above);
+    }
+    else
+    {
+      if (!areCentersNew(below, holes))
+        CV_Error( cv::Error::StsError, "Centers are not new" );
+
+      holes.insert(holes.end(), below);
+    }
+  }
+  else
+  {
+    if (aboveConfidence >= belowConfidence)
+    {
+      if (!areCentersNew(above, holes))
+        CV_Error( cv::Error::StsError, "Centers are not new" );
+
+      for (size_t i = 0; i < holes.size(); i++)
+      {
+        holes[i].insert(holes[i].begin(), above[i]);
+      }
+    }
+    else
+    {
+      if (!areCentersNew(below, holes))
+        CV_Error( cv::Error::StsError, "Centers are not new" );
+
+      for (size_t i = 0; i < holes.size(); i++)
+      {
+        holes[i].insert(holes[i].end(), below[i]);
+      }
+    }
+  }
+}
+
+float CirclesGridFinder::computeGraphConfidence(const std::vector<Graph> &basisGraphs, bool addRow,
+                                                const std::vector<size_t> &points, const std::vector<size_t> &seeds)
+{
+  CV_Assert( points.size() == seeds.size() );
+  float confidence = 0;
+  const size_t vCount = basisGraphs[0].getVerticesCount();
+  CV_Assert( basisGraphs[0].getVerticesCount() == basisGraphs[1].getVerticesCount() );
+
+  for (size_t i = 0; i < seeds.size(); i++)
+  {
+    if (seeds[i] < vCount && points[i] < vCount)
+    {
+      if (!basisGraphs[addRow].areVerticesAdjacent(seeds[i], points[i]))
+      {
+        confidence += parameters.vertexPenalty;
+      }
+      else
+      {
+        confidence += parameters.vertexGain;
+      }
+    }
+
+    if (points[i] < vCount)
+    {
+      confidence += parameters.existingVertexGain;
+    }
+  }
+
+  for (size_t i = 1; i < points.size(); i++)
+  {
+    if (points[i - 1] < vCount && points[i] < vCount)
+    {
+      if (!basisGraphs[!addRow].areVerticesAdjacent(points[i - 1], points[i]))
+      {
+        confidence += parameters.edgePenalty;
+      }
+      else
+      {
+        confidence += parameters.edgeGain;
+      }
+    }
+  }
+  return confidence;
+
+}
+
+void CirclesGridFinder::addHolesByGraph(const std::vector<Graph> &basisGraphs, bool addRow, Point2f basisVec)
+{
+  std::vector<size_t> above, below, aboveSeeds, belowSeeds;
+  findCandidateHoles(above, below, addRow, basisVec, aboveSeeds, belowSeeds);
+  float aboveConfidence = computeGraphConfidence(basisGraphs, addRow, above, aboveSeeds);
+  float belowConfidence = computeGraphConfidence(basisGraphs, addRow, below, belowSeeds);
+
+  insertWinner(aboveConfidence, belowConfidence, parameters.minGraphConfidence, addRow, above, below, holes);
+}
+
+void CirclesGridFinder::filterOutliersByDensity(const std::vector<Point2f> &samples, std::vector<Point2f> &filteredSamples)
+{
+  if (samples.empty())
+    CV_Error( cv::Error::StsError, "samples is empty" );
+
+  filteredSamples.clear();
+
+  for (size_t i = 0; i < samples.size(); i++)
+  {
+    Rect_<float> rect(samples[i] - Point2f(parameters.densityNeighborhoodSize) * 0.5,
+                      parameters.densityNeighborhoodSize);
+    int neighborsCount = 0;
+    for (size_t j = 0; j < samples.size(); j++)
+    {
+      if (rect.contains(samples[j]))
+        neighborsCount++;
+    }
+    if (neighborsCount >= parameters.minDensity)
+      filteredSamples.push_back(samples[i]);
+  }
+
+  if (filteredSamples.empty())
+    CV_Error( cv::Error::StsError, "filteredSamples is empty" );
+}
+
+void CirclesGridFinder::findBasis(const std::vector<Point2f> &samples, std::vector<Point2f> &basis, std::vector<Graph> &basisGraphs)
+{
+  basis.clear();
+  Mat bestLabels;
+  TermCriteria termCriteria;
+  Mat centers;
+  const int clustersCount = 4;
+  int nsamples = (int)samples.size();
+  kmeans(Mat(samples).reshape(1, nsamples), clustersCount, bestLabels, termCriteria, parameters.kmeansAttempts,
+         KMEANS_RANDOM_CENTERS, centers);
+  CV_Assert( centers.type() == CV_32FC1 );
+
+  std::vector<int> basisIndices;
+  //TODO: only remove duplicate
+  for (int i = 0; i < clustersCount; i++)
+  {
+    int maxIdx = (fabs(centers.at<float> (i, 0)) < fabs(centers.at<float> (i, 1)));
+    if (centers.at<float> (i, maxIdx) > 0)
+    {
+      Point2f vec(centers.at<float> (i, 0), centers.at<float> (i, 1));
+      basis.push_back(vec);
+      basisIndices.push_back(i);
+    }
+  }
+  if (basis.size() != 2)
+    CV_Error(cv::Error::StsError, "Basis size is not 2");
+
+  if (basis[1].x > basis[0].x)
+  {
+    std::swap(basis[0], basis[1]);
+    std::swap(basisIndices[0], basisIndices[1]);
+  }
+
+  const float minBasisDif = 2;
+  if (norm(basis[0] - basis[1]) < minBasisDif)
+    CV_Error(cv::Error::StsError, "degenerate basis" );
+
+  std::vector<std::vector<Point2f> > clusters(2), hulls(2);
+  for (int k = 0; k < (int)samples.size(); k++)
+  {
+    int label = bestLabels.at<int> (k, 0);
+    int idx = -1;
+    if (label == basisIndices[0])
+      idx = 0;
+    if (label == basisIndices[1])
+      idx = 1;
+    if (idx >= 0)
+    {
+      clusters[idx].push_back(basis[idx] + parameters.convexHullFactor * (samples[k] - basis[idx]));
+    }
+  }
+  for (size_t i = 0; i < basis.size(); i++)
+  {
+    convexHull(clusters[i], hulls[i]);
+  }
+
+  basisGraphs.resize(basis.size(), Graph(keypoints.size()));
+  for (size_t i = 0; i < keypoints.size(); i++)
+  {
+    for (size_t j = 0; j < keypoints.size(); j++)
+    {
+      if (i == j)
+        continue;
+
+      Point2f vec = keypoints[i] - keypoints[j];
+
+      for (size_t k = 0; k < hulls.size(); k++)
+      {
+        if (pointPolygonTest(hulls[k], vec, false) >= 0)
+        {
+          basisGraphs[k].addEdge(i, j);
+        }
+      }
+    }
+  }
+  if (basisGraphs.size() != 2)
+    CV_Error(cv::Error::StsError, "Number of basis graphs is not 2");
+}
+
+void CirclesGridFinder::computeRNG(Graph &rng, std::vector<cv::Point2f> &vectors, Mat *drawImage) const
+{
+  rng = Graph(keypoints.size());
+  vectors.clear();
+
+  //TODO: use more fast algorithm instead of naive N^3
+  for (size_t i = 0; i < keypoints.size(); i++)
+  {
+    for (size_t j = 0; j < keypoints.size(); j++)
+    {
+      if (i == j)
+        continue;
+
+      Point2f vec = keypoints[i] - keypoints[j];
+      double dist = norm(vec);
+
+      bool isNeighbors = true;
+      for (size_t k = 0; k < keypoints.size(); k++)
+      {
+        if (k == i || k == j)
+          continue;
+
+        double dist1 = norm(keypoints[i] - keypoints[k]);
+        double dist2 = norm(keypoints[j] - keypoints[k]);
+        if (dist1 < dist && dist2 < dist)
+        {
+          isNeighbors = false;
+          break;
+        }
+      }
+
+      if (isNeighbors)
+      {
+        rng.addEdge(i, j);
+        vectors.push_back(keypoints[i] - keypoints[j]);
+        if (drawImage != 0)
+        {
+          line(*drawImage, keypoints[i], keypoints[j], Scalar(255, 0, 0), 2);
+          circle(*drawImage, keypoints[i], 3, Scalar(0, 0, 255), -1);
+          circle(*drawImage, keypoints[j], 3, Scalar(0, 0, 255), -1);
+        }
+      }
+    }
+  }
+}
+
+void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessorMatrix)
+{
+  CV_Assert( dm.type() == CV_32SC1 );
+  predecessorMatrix.create(verticesCount, verticesCount, CV_32SC1);
+  predecessorMatrix = -1;
+  for (int i = 0; i < predecessorMatrix.rows; i++)
+  {
+    for (int j = 0; j < predecessorMatrix.cols; j++)
+    {
+      int dist = dm.at<int> (i, j);
+      for (int k = 0; k < verticesCount; k++)
+      {
+        if (dm.at<int> (i, k) == dist - 1 && dm.at<int> (k, j) == 1)
+        {
+          predecessorMatrix.at<int> (i, j) = k;
+          break;
+        }
+      }
+    }
+  }
+}
+
+static void computeShortestPath(Mat &predecessorMatrix, size_t v1, size_t v2, std::vector<size_t> &path)
+{
+  if (predecessorMatrix.at<int> ((int)v1, (int)v2) < 0)
+  {
+    path.push_back(v1);
+    return;
+  }
+
+  computeShortestPath(predecessorMatrix, v1, predecessorMatrix.at<int> ((int)v1, (int)v2), path);
+  path.push_back(v2);
+}
+
+size_t CirclesGridFinder::findLongestPath(std::vector<Graph> &basisGraphs, Path &bestPath)
+{
+  std::vector<Path> longestPaths(1);
+  std::vector<int> confidences;
+
+  size_t bestGraphIdx = 0;
+  const int infinity = -1;
+  for (size_t graphIdx = 0; graphIdx < basisGraphs.size(); graphIdx++)
+  {
+    const Graph &g = basisGraphs[graphIdx];
+    Mat distanceMatrix;
+    g.floydWarshall(distanceMatrix, infinity);
+    Mat predecessorMatrix;
+    computePredecessorMatrix(distanceMatrix, (int)g.getVerticesCount(), predecessorMatrix);
+
+    double maxVal;
+    Point maxLoc;
+    minMaxLoc(distanceMatrix, 0, &maxVal, 0, &maxLoc);
+
+    if (maxVal > longestPaths[0].length)
+    {
+      longestPaths.clear();
+      confidences.clear();
+      bestGraphIdx = graphIdx;
+    }
+    if (longestPaths.empty() || (maxVal == longestPaths[0].length && graphIdx == bestGraphIdx))
+    {
+      Path path = Path(maxLoc.x, maxLoc.y, cvRound(maxVal));
+      CV_Assert(maxLoc.x >= 0 && maxLoc.y >= 0)
+        ;
+      size_t id1 = static_cast<size_t> (maxLoc.x);
+      size_t id2 = static_cast<size_t> (maxLoc.y);
+      computeShortestPath(predecessorMatrix, id1, id2, path.vertices);
+      longestPaths.push_back(path);
+
+      int conf = 0;
+      for (int v2 = 0; v2 < (int)path.vertices.size(); v2++)
+      {
+        conf += (int)basisGraphs[1 - (int)graphIdx].getDegree(v2);
+      }
+      confidences.push_back(conf);
+    }
+  }
+
+  int maxConf = -1;
+  int bestPathIdx = -1;
+  for (int i = 0; i < (int)confidences.size(); i++)
+  {
+    if (confidences[i] > maxConf)
+    {
+      maxConf = confidences[i];
+      bestPathIdx = i;
+    }
+  }
+
+  //int bestPathIdx = rand() % longestPaths.size();
+  bestPath = longestPaths.at(bestPathIdx);
+  bool needReverse = (bestGraphIdx == 0 && keypoints[bestPath.lastVertex].x < keypoints[bestPath.firstVertex].x)
+      || (bestGraphIdx == 1 && keypoints[bestPath.lastVertex].y < keypoints[bestPath.firstVertex].y);
+  if (needReverse)
+  {
+    std::swap(bestPath.lastVertex, bestPath.firstVertex);
+    std::reverse(bestPath.vertices.begin(), bestPath.vertices.end());
+  }
+  return bestGraphIdx;
+}
+
+void CirclesGridFinder::drawBasis(const std::vector<Point2f> &basis, Point2f origin, Mat &drawImg) const
+{
+  for (size_t i = 0; i < basis.size(); i++)
+  {
+    Point2f pt(basis[i]);
+    line(drawImg, origin, origin + pt, Scalar(0, (double)(i * 255), 0), 2);
+  }
+}
+
+void CirclesGridFinder::drawBasisGraphs(const std::vector<Graph> &basisGraphs, Mat &drawImage, bool drawEdges,
+                                        bool drawVertices) const
+{
+  //const int vertexRadius = 1;
+  const int vertexRadius = 3;
+  const Scalar vertexColor = Scalar(0, 0, 255);
+  const int vertexThickness = -1;
+
+  const Scalar edgeColor = Scalar(255, 0, 0);
+  //const int edgeThickness = 1;
+  const int edgeThickness = 2;
+
+  if (drawEdges)
+  {
+    for (size_t i = 0; i < basisGraphs.size(); i++)
+    {
+      for (size_t v1 = 0; v1 < basisGraphs[i].getVerticesCount(); v1++)
+      {
+        for (size_t v2 = 0; v2 < basisGraphs[i].getVerticesCount(); v2++)
+        {
+          if (basisGraphs[i].areVerticesAdjacent(v1, v2))
+          {
+            line(drawImage, keypoints[v1], keypoints[v2], edgeColor, edgeThickness);
+          }
+        }
+      }
+    }
+  }
+  if (drawVertices)
+  {
+    for (size_t v = 0; v < basisGraphs[0].getVerticesCount(); v++)
+    {
+      circle(drawImage, keypoints[v], vertexRadius, vertexColor, vertexThickness);
+    }
+  }
+}
+
+void CirclesGridFinder::drawHoles(const Mat &srcImage, Mat &drawImage) const
+{
+  //const int holeRadius = 4;
+  //const int holeRadius = 2;
+  //const int holeThickness = 1;
+  const int holeRadius = 3;
+  const int holeThickness = -1;
+
+  //const Scalar holeColor = Scalar(0, 0, 255);
+  const Scalar holeColor = Scalar(0, 255, 0);
+
+  if (srcImage.channels() == 1)
+    cvtColor(srcImage, drawImage, COLOR_GRAY2RGB);
+  else
+    srcImage.copyTo(drawImage);
+
+  for (size_t i = 0; i < holes.size(); i++)
+  {
+    for (size_t j = 0; j < holes[i].size(); j++)
+    {
+      if (j != holes[i].size() - 1)
+        line(drawImage, keypoints[holes[i][j]], keypoints[holes[i][j + 1]], Scalar(255, 0, 0), 2);
+      if (i != holes.size() - 1)
+        line(drawImage, keypoints[holes[i][j]], keypoints[holes[i + 1][j]], Scalar(255, 0, 0), 2);
+
+      circle(drawImage, keypoints[holes[i][j]], holeRadius, holeColor, holeThickness);
+    }
+  }
+}
+
+Size CirclesGridFinder::getDetectedGridSize() const
+{
+  if (holes.size() == 0)
+    return Size(0, 0);
+
+  return Size((int)holes[0].size(), (int)holes.size());
+}
+
+void CirclesGridFinder::getHoles(std::vector<Point2f> &outHoles) const
+{
+  outHoles.clear();
+  if (rotatedGrid == false)
+  {
+    for (size_t i = 0ull; i < holes.size(); i++)
+    {
+      for (size_t j = 0ull; j < holes[i].size(); j++)
+      {
+        outHoles.push_back(keypoints[holes[i][j]]);
+      }
+    }
+  }
+  else
+  {
+    bool visit_all = false;
+    size_t j = 0ull;
+    while (visit_all != true)
+    {
+      visit_all = true;
+      for (size_t i = 0ull; i < holes.size(); i++)
+      {
+        if (j < holes[i].size())
+        {
+          outHoles.push_back(keypoints[holes[i][j]]);
+          visit_all = false;
+        }
+      }
+      j++;
+    }
+  }
+}
+
+static bool areIndicesCorrect(Point pos, std::vector<std::vector<size_t> > *points)
+{
+  if (pos.y < 0 || pos.x < 0)
+    return false;
+  return (static_cast<size_t> (pos.y) < points->size() && static_cast<size_t> (pos.x) < points->at(pos.y).size());
+}
+
+void CirclesGridFinder::getAsymmetricHoles(std::vector<cv::Point2f> &outHoles) const
+{
+  outHoles.clear();
+
+  std::vector<Point> largeCornerIndices, smallCornerIndices;
+  std::vector<Point> firstSteps, secondSteps;
+  size_t cornerIdx = getFirstCorner(largeCornerIndices, smallCornerIndices, firstSteps, secondSteps);
+  CV_Assert(largeHoles != 0 && smallHoles != 0)
+    ;
+
+  Point srcLargePos = largeCornerIndices[cornerIdx];
+  Point srcSmallPos = smallCornerIndices[cornerIdx];
+
+  while (areIndicesCorrect(srcLargePos, largeHoles) || areIndicesCorrect(srcSmallPos, smallHoles))
+  {
+    Point largePos = srcLargePos;
+    while (areIndicesCorrect(largePos, largeHoles))
+    {
+      outHoles.push_back(keypoints[largeHoles->at(largePos.y)[largePos.x]]);
+      largePos += firstSteps[cornerIdx];
+    }
+    srcLargePos += secondSteps[cornerIdx];
+
+    Point smallPos = srcSmallPos;
+    while (areIndicesCorrect(smallPos, smallHoles))
+    {
+      outHoles.push_back(keypoints[smallHoles->at(smallPos.y)[smallPos.x]]);
+      smallPos += firstSteps[cornerIdx];
+    }
+    srcSmallPos += secondSteps[cornerIdx];
+  }
+}
+
+double CirclesGridFinder::getDirection(Point2f p1, Point2f p2, Point2f p3)
+{
+  Point2f a = p3 - p1;
+  Point2f b = p2 - p1;
+  return a.x * b.y - a.y * b.x;
+}
+
+bool CirclesGridFinder::areSegmentsIntersecting(Segment seg1, Segment seg2)
+{
+  bool doesStraddle1 = (getDirection(seg2.s, seg2.e, seg1.s) * getDirection(seg2.s, seg2.e, seg1.e)) < 0;
+  bool doesStraddle2 = (getDirection(seg1.s, seg1.e, seg2.s) * getDirection(seg1.s, seg1.e, seg2.e)) < 0;
+  return doesStraddle1 && doesStraddle2;
+
+  /*
+   Point2f t1 = e1-s1;
+   Point2f n1(t1.y, -t1.x);
+   double c1 = -n1.ddot(s1);
+
+   Point2f t2 = e2-s2;
+   Point2f n2(t2.y, -t2.x);
+   double c2 = -n2.ddot(s2);
+
+   bool seg1 = ((n1.ddot(s2) + c1) * (n1.ddot(e2) + c1)) <= 0;
+   bool seg1 = ((n2.ddot(s1) + c2) * (n2.ddot(e1) + c2)) <= 0;
+
+   return seg1 && seg2;
+   */
+}
+
+void CirclesGridFinder::getCornerSegments(const std::vector<std::vector<size_t> > &points, std::vector<std::vector<Segment> > &segments,
+                                          std::vector<Point> &cornerIndices, std::vector<Point> &firstSteps,
+                                          std::vector<Point> &secondSteps) const
+{
+  segments.clear();
+  cornerIndices.clear();
+  firstSteps.clear();
+  secondSteps.clear();
+  int h = (int)points.size();
+  int w = (int)points[0].size();
+  CV_Assert(h >= 2 && w >= 2)
+    ;
+
+  //all 8 segments with one end in a corner
+  std::vector<Segment> corner;
+  corner.emplace_back(keypoints[points[1][0]], keypoints[points[0][0]]);
+  corner.emplace_back(keypoints[points[0][0]], keypoints[points[0][1]]);
+  segments.push_back(corner);
+  cornerIndices.emplace_back(0, 0);
+  firstSteps.emplace_back(1, 0);
+  secondSteps.emplace_back(0, 1);
+  corner.clear();
+
+  corner.emplace_back(keypoints[points[0][w - 2]], keypoints[points[0][w - 1]]);
+  corner.emplace_back(keypoints[points[0][w - 1]], keypoints[points[1][w - 1]]);
+  segments.push_back(corner);
+  cornerIndices.emplace_back(w - 1, 0);
+  firstSteps.emplace_back(0, 1);
+  secondSteps.emplace_back(-1, 0);
+  corner.clear();
+
+  corner.emplace_back(keypoints[points[h - 2][w - 1]], keypoints[points[h - 1][w - 1]]);
+  corner.emplace_back(keypoints[points[h - 1][w - 1]], keypoints[points[h - 1][w - 2]]);
+  segments.push_back(corner);
+  cornerIndices.emplace_back(w - 1, h - 1);
+  firstSteps.emplace_back(-1, 0);
+  secondSteps.emplace_back(0, -1);
+  corner.clear();
+
+  corner.emplace_back(keypoints[points[h - 1][1]], keypoints[points[h - 1][0]]);
+  corner.emplace_back(keypoints[points[h - 1][0]], keypoints[points[h - 2][0]]);
+  cornerIndices.emplace_back(0, h - 1);
+  firstSteps.emplace_back(0, -1);
+  secondSteps.emplace_back(1, 0);
+  segments.push_back(corner);
+  corner.clear();
+
+  //y axis is inverted in computer vision so we check < 0
+  bool isClockwise =
+      getDirection(keypoints[points[0][0]], keypoints[points[0][w - 1]], keypoints[points[h - 1][w - 1]]) < 0;
+  if (!isClockwise)
+  {
+#ifdef DEBUG_CIRCLES
+    std::cout << "Corners are counterclockwise" << std::endl;
+#endif
+    std::reverse(segments.begin(), segments.end());
+    std::reverse(cornerIndices.begin(), cornerIndices.end());
+    std::reverse(firstSteps.begin(), firstSteps.end());
+    std::reverse(secondSteps.begin(), secondSteps.end());
+    std::swap(firstSteps, secondSteps);
+  }
+}
+
+bool CirclesGridFinder::doesIntersectionExist(const std::vector<Segment> &corner, const std::vector<std::vector<Segment> > &segments)
+{
+  for (size_t i = 0; i < corner.size(); i++)
+  {
+    for (size_t j = 0; j < segments.size(); j++)
+    {
+      for (size_t k = 0; k < segments[j].size(); k++)
+      {
+        if (areSegmentsIntersecting(corner[i], segments[j][k]))
+          return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+size_t CirclesGridFinder::getFirstCorner(std::vector<Point> &largeCornerIndices, std::vector<Point> &smallCornerIndices, std::vector<
+    Point> &firstSteps, std::vector<Point> &secondSteps) const
+{
+  std::vector<std::vector<Segment> > largeSegments;
+  std::vector<std::vector<Segment> > smallSegments;
+
+  getCornerSegments(*largeHoles, largeSegments, largeCornerIndices, firstSteps, secondSteps);
+  getCornerSegments(*smallHoles, smallSegments, smallCornerIndices, firstSteps, secondSteps);
+
+  const size_t cornersCount = 4;
+  CV_Assert(largeSegments.size() == cornersCount)
+    ;
+
+  bool isInsider[cornersCount];
+
+  for (size_t i = 0; i < cornersCount; i++)
+  {
+    isInsider[i] = doesIntersectionExist(largeSegments[i], smallSegments);
+  }
+
+  int cornerIdx = 0;
+  bool waitOutsider = true;
+
+  for (size_t i = 0; i < cornersCount * 2; ++i)
+  {
+    if (waitOutsider)
+    {
+      if (!isInsider[(cornerIdx + 1) % cornersCount])
+        waitOutsider = false;
+    }
+    else
+    {
+      if (isInsider[(cornerIdx + 1) % cornersCount])
+        return cornerIdx;
+    }
+
+    cornerIdx = (cornerIdx + 1) % cornersCount;
+  }
+
+  CV_Error(Error::StsNoConv, "isInsider array has the same values");
+}
+
+}
diff --git a/upstream/opencv/modules/objdetect/src/circlesgrid.hpp b/upstream/opencv/modules/objdetect/src/circlesgrid.hpp
new file mode 100644
index 0000000..29ecd93
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/circlesgrid.hpp
@@ -0,0 +1,199 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#ifndef CIRCLESGRID_HPP_
+#define CIRCLESGRID_HPP_
+
+#include <fstream>
+#include <set>
+#include <list>
+#include <numeric>
+#include <map>
+
+namespace cv {
+
+class CirclesGridClusterFinder
+{
+    CirclesGridClusterFinder& operator=(const CirclesGridClusterFinder&);
+    CirclesGridClusterFinder(const CirclesGridClusterFinder&);
+public:
+  CirclesGridClusterFinder(const CirclesGridFinderParameters &parameters)
+  {
+    isAsymmetricGrid = parameters.gridType == CirclesGridFinderParameters::ASYMMETRIC_GRID;
+    squareSize = parameters.squareSize;
+    maxRectifiedDistance = parameters.maxRectifiedDistance;
+  }
+  void findGrid(const std::vector<Point2f> &points, Size patternSize, std::vector<Point2f>& centers);
+
+  //cluster 2d points by geometric coordinates
+  void hierarchicalClustering(const std::vector<Point2f> &points, const Size &patternSize, std::vector<Point2f> &patternPoints);
+private:
+  void findCorners(const std::vector<Point2f> &hull2f, std::vector<Point2f> &corners);
+  void findOutsideCorners(const std::vector<Point2f> &corners, std::vector<Point2f> &outsideCorners);
+  void getSortedCorners(const std::vector<Point2f> &hull2f, const std::vector<Point2f> &patternPoints, const std::vector<Point2f> &corners, const std::vector<Point2f> &outsideCorners, std::vector<Point2f> &sortedCorners);
+  void rectifyPatternPoints(const std::vector<Point2f> &patternPoints, const std::vector<Point2f> &sortedCorners, std::vector<Point2f> &rectifiedPatternPoints);
+  void parsePatternPoints(const std::vector<Point2f> &patternPoints, const std::vector<Point2f> &rectifiedPatternPoints, std::vector<Point2f> &centers);
+
+  float squareSize, maxRectifiedDistance;
+  bool isAsymmetricGrid;
+
+  Size patternSize;
+};
+
+class Graph
+{
+public:
+  typedef std::set<size_t> Neighbors;
+  struct Vertex
+  {
+    Neighbors neighbors;
+  };
+  typedef std::map<size_t, Vertex> Vertices;
+
+  Graph(size_t n);
+  void addVertex(size_t id);
+  void addEdge(size_t id1, size_t id2);
+  void removeEdge(size_t id1, size_t id2);
+  bool doesVertexExist(size_t id) const;
+  bool areVerticesAdjacent(size_t id1, size_t id2) const;
+  size_t getVerticesCount() const;
+  size_t getDegree(size_t id) const;
+  const Neighbors& getNeighbors(size_t id) const;
+  void floydWarshall(Mat &distanceMatrix, int infinity = -1) const;
+private:
+  Vertices vertices;
+};
+
+struct Path
+{
+  int firstVertex;
+  int lastVertex;
+  int length;
+
+  std::vector<size_t> vertices;
+
+  Path(int first = -1, int last = -1, int len = -1)
+  {
+    firstVertex = first;
+    lastVertex = last;
+    length = len;
+  }
+};
+
+class CirclesGridFinder
+{
+public:
+  CirclesGridFinder(Size patternSize, const std::vector<Point2f> &testKeypoints,
+                    const CirclesGridFinderParameters &parameters = CirclesGridFinderParameters());
+  bool findHoles();
+  static Mat rectifyGrid(Size detectedGridSize, const std::vector<Point2f>& centers, const std::vector<
+      Point2f> &keypoint, std::vector<Point2f> &warpedKeypoints);
+
+  void getHoles(std::vector<Point2f> &holes) const;
+  void getAsymmetricHoles(std::vector<Point2f> &holes) const;
+  Size getDetectedGridSize() const;
+
+  void drawBasis(const std::vector<Point2f> &basis, Point2f origin, Mat &drawImg) const;
+  void drawBasisGraphs(const std::vector<Graph> &basisGraphs, Mat &drawImg, bool drawEdges = true,
+                       bool drawVertices = true) const;
+  void drawHoles(const Mat &srcImage, Mat &drawImage) const;
+private:
+  void computeRNG(Graph &rng, std::vector<Point2f> &vectors, Mat *drawImage = 0) const;
+  void rng2gridGraph(Graph &rng, std::vector<Point2f> &vectors) const;
+  void eraseUsedGraph(std::vector<Graph> &basisGraphs) const;
+  void filterOutliersByDensity(const std::vector<Point2f> &samples, std::vector<Point2f> &filteredSamples);
+  void findBasis(const std::vector<Point2f> &samples, std::vector<Point2f> &basis,
+                 std::vector<Graph> &basisGraphs);
+  void findMCS(const std::vector<Point2f> &basis, std::vector<Graph> &basisGraphs);
+  size_t findLongestPath(std::vector<Graph> &basisGraphs, Path &bestPath);
+  float computeGraphConfidence(const std::vector<Graph> &basisGraphs, bool addRow, const std::vector<size_t> &points,
+                               const std::vector<size_t> &seeds);
+  void addHolesByGraph(const std::vector<Graph> &basisGraphs, bool addRow, Point2f basisVec);
+
+  size_t findNearestKeypoint(Point2f pt) const;
+  void addPoint(Point2f pt, std::vector<size_t> &points);
+  void findCandidateLine(std::vector<size_t> &line, size_t seedLineIdx, bool addRow, Point2f basisVec, std::vector<
+      size_t> &seeds);
+  void findCandidateHoles(std::vector<size_t> &above, std::vector<size_t> &below, bool addRow, Point2f basisVec,
+                          std::vector<size_t> &aboveSeeds, std::vector<size_t> &belowSeeds);
+  static bool areCentersNew(const std::vector<size_t> &newCenters, const std::vector<std::vector<size_t> > &holes);
+  bool isDetectionCorrect();
+
+  static void insertWinner(float aboveConfidence, float belowConfidence, float minConfidence, bool addRow,
+                           const std::vector<size_t> &above, const std::vector<size_t> &below, std::vector<std::vector<
+                               size_t> > &holes);
+
+  struct Segment
+  {
+    Point2f s;
+    Point2f e;
+    Segment(Point2f _s, Point2f _e);
+  };
+
+  //if endpoint is on a segment then function return false
+  static bool areSegmentsIntersecting(Segment seg1, Segment seg2);
+  static bool doesIntersectionExist(const std::vector<Segment> &corner, const std::vector<std::vector<Segment> > &segments);
+  void getCornerSegments(const std::vector<std::vector<size_t> > &points, std::vector<std::vector<Segment> > &segments,
+                         std::vector<Point> &cornerIndices, std::vector<Point> &firstSteps,
+                         std::vector<Point> &secondSteps) const;
+  size_t getFirstCorner(std::vector<Point> &largeCornerIndices, std::vector<Point> &smallCornerIndices,
+                        std::vector<Point> &firstSteps, std::vector<Point> &secondSteps) const;
+  static double getDirection(Point2f p1, Point2f p2, Point2f p3);
+
+  std::vector<Point2f> keypoints;
+
+  std::vector<std::vector<size_t> > holes;
+  std::vector<std::vector<size_t> > holes2;
+  std::vector<std::vector<size_t> > *largeHoles;
+  std::vector<std::vector<size_t> > *smallHoles;
+
+  const Size_<size_t> patternSize;
+  CirclesGridFinderParameters parameters;
+  bool rotatedGrid = false;
+
+  CirclesGridFinder& operator=(const CirclesGridFinder&);
+  CirclesGridFinder(const CirclesGridFinder&);
+};
+
+}
+
+#endif /* CIRCLESGRID_HPP_ */
diff --git a/upstream/opencv/modules/objdetect/src/face_detect.cpp b/upstream/opencv/modules/objdetect/src/face_detect.cpp
new file mode 100644
index 0000000..c6b2430
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/face_detect.cpp
@@ -0,0 +1,325 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+#include <algorithm>
+
+namespace cv
+{
+
+#ifdef HAVE_OPENCV_DNN
+class FaceDetectorYNImpl : public FaceDetectorYN
+{
+public:
+    FaceDetectorYNImpl(const String& model,
+                       const String& config,
+                       const Size& input_size,
+                       float score_threshold,
+                       float nms_threshold,
+                       int top_k,
+                       int backend_id,
+                       int target_id)
+                       :divisor(32),
+                       strides({8, 16, 32})
+    {
+        net = dnn::readNet(model, config);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+
+        inputW = input_size.width;
+        inputH = input_size.height;
+
+        padW = (int((inputW - 1) / divisor) + 1) * divisor;
+        padH = (int((inputH - 1) / divisor) + 1) * divisor;
+
+        if (!net.getMainGraph())
+            net.setInputShape("input", MatShape({1, 3, padH, padW}));
+
+        scoreThreshold = score_threshold;
+        nmsThreshold = nms_threshold;
+        topK = top_k;
+    }
+
+    FaceDetectorYNImpl(const String& framework,
+                       const std::vector<uchar>& bufferModel,
+                       const std::vector<uchar>& bufferConfig,
+                       const Size& input_size,
+                       float score_threshold,
+                       float nms_threshold,
+                       int top_k,
+                       int backend_id,
+                       int target_id)
+                       :divisor(32),
+                       strides({8, 16, 32})
+    {
+        net = dnn::readNet(framework, bufferModel, bufferConfig);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+
+        inputW = input_size.width;
+        inputH = input_size.height;
+
+        padW = (int((inputW - 1) / divisor) + 1) * divisor;
+        padH = (int((inputH - 1) / divisor) + 1) * divisor;
+
+        if (!net.getMainGraph())
+            net.setInputShape("input", MatShape({1, 3, padH, padW}));
+
+        scoreThreshold = score_threshold;
+        nmsThreshold = nms_threshold;
+        topK = top_k;
+    }
+
+    void setInputSize(const Size& input_size) override
+    {
+        inputW = input_size.width;
+        inputH = input_size.height;
+        padW = ((inputW - 1) / divisor + 1) * divisor;
+        padH = ((inputH - 1) / divisor + 1) * divisor;
+        if (!net.getMainGraph())
+            net.setInputShape("input", MatShape({1, 3, padH, padW}));
+    }
+
+    Size getInputSize() override
+    {
+        Size input_size;
+        input_size.width = inputW;
+        input_size.height = inputH;
+        return input_size;
+    }
+
+    void setScoreThreshold(float score_threshold) override
+    {
+        scoreThreshold = score_threshold;
+    }
+
+    float getScoreThreshold() override
+    {
+        return scoreThreshold;
+    }
+
+    void setNMSThreshold(float nms_threshold) override
+    {
+        nmsThreshold = nms_threshold;
+    }
+
+    float getNMSThreshold() override
+    {
+        return nmsThreshold;
+    }
+
+    void setTopK(int top_k) override
+    {
+        topK = top_k;
+    }
+
+    int getTopK() override
+    {
+        return topK;
+    }
+
+    int detect(InputArray input_image, OutputArray faces) override
+    {
+        // TODO: more checkings should be done?
+        if (input_image.empty())
+        {
+            return 0;
+        }
+        CV_CheckEQ(input_image.size(), Size(inputW, inputH), "Size does not match. Call setInputSize(size) if input size does not match the preset size");
+
+        Mat input_blob;
+        if(input_image.kind() == _InputArray::UMAT) {
+            // Pad input_image with divisor 32
+            UMat pad_image;
+            padWithDivisor(input_image, pad_image);
+            // Build blob from input image
+            input_blob = dnn::blobFromImage(pad_image);
+        } else {
+            // Pad input_image with divisor 32
+            Mat pad_image;
+            padWithDivisor(input_image, pad_image);
+            // Build blob from input image
+            input_blob = dnn::blobFromImage(pad_image);
+        }
+        // Forward
+        std::vector<String> output_names = { "cls_8", "cls_16", "cls_32", "obj_8", "obj_16", "obj_32", "bbox_8", "bbox_16", "bbox_32", "kps_8", "kps_16", "kps_32" };
+        std::vector<Mat> output_blobs;
+        net.setInput(input_blob);
+        net.forward(output_blobs, output_names);
+
+        // Post process
+        Mat results = postProcess(output_blobs);
+        results.convertTo(faces, CV_32FC1);
+        return 1;
+    }
+private:
+    Mat postProcess(const std::vector<Mat>& output_blobs)
+    {
+        Mat faces;
+        for (size_t i = 0; i < strides.size(); ++i) {
+            int cols = int(padW / strides[i]);
+            int rows = int(padH / strides[i]);
+
+            // Extract from output_blobs
+            Mat cls = output_blobs[i];
+            Mat obj = output_blobs[i + strides.size() * 1];
+            Mat bbox = output_blobs[i + strides.size() * 2];
+            Mat kps = output_blobs[i + strides.size() * 3];
+
+            // Decode from predictions
+            float* cls_v = (float*)(cls.data);
+            float* obj_v = (float*)(obj.data);
+            float* bbox_v = (float*)(bbox.data);
+            float* kps_v = (float*)(kps.data);
+
+            // (tl_x, tl_y, w, h, re_x, re_y, le_x, le_y, nt_x, nt_y, rcm_x, rcm_y, lcm_x, lcm_y, score)
+            // 'tl': top left point of the bounding box
+            // 're': right eye, 'le': left eye
+            // 'nt':  nose tip
+            // 'rcm': right corner of mouth, 'lcm': left corner of mouth
+            Mat face(1, 15, CV_32FC1);
+
+            for(int r = 0; r < rows; ++r) {
+                for(int c = 0; c < cols; ++c) {
+                    size_t idx = r * cols + c;
+
+                    // Get score
+                    float cls_score = cls_v[idx];
+                    float obj_score = obj_v[idx];
+
+                    // Clamp
+                    cls_score = MIN(cls_score, 1.f);
+                    cls_score = MAX(cls_score, 0.f);
+                    obj_score = MIN(obj_score, 1.f);
+                    obj_score = MAX(obj_score, 0.f);
+                    float score = std::sqrt(cls_score * obj_score);
+                    face.at<float>(0, 14) = score;
+
+                    // Checking if the score meets the threshold before adding the face
+                    if (score < scoreThreshold)
+                        continue;
+                    // Get bounding box
+                    float cx = ((c + bbox_v[idx * 4 + 0]) * strides[i]);
+                    float cy = ((r + bbox_v[idx * 4 + 1]) * strides[i]);
+                    float w = exp(bbox_v[idx * 4 + 2]) * strides[i];
+                    float h = exp(bbox_v[idx * 4 + 3]) * strides[i];
+
+                    float x1 = cx - w / 2.f;
+                    float y1 = cy - h / 2.f;
+
+                    face.at<float>(0, 0) = x1;
+                    face.at<float>(0, 1) = y1;
+                    face.at<float>(0, 2) = w;
+                    face.at<float>(0, 3) = h;
+
+                    // Get landmarks
+                    for(int n = 0; n < 5; ++n) {
+                        face.at<float>(0, 4 + 2 * n) = (kps_v[idx * 10 + 2 * n] + c) * strides[i];
+                        face.at<float>(0, 4 + 2 * n + 1) = (kps_v[idx * 10 + 2 * n + 1]+ r) * strides[i];
+                    }
+                    faces.push_back(face);
+                }
+            }
+        }
+
+        if (faces.rows > 1)
+        {
+            // Retrieve boxes and scores
+            std::vector<Rect2i> faceBoxes;
+            std::vector<float> faceScores;
+            for (int rIdx = 0; rIdx < faces.rows; rIdx++)
+            {
+                faceBoxes.push_back(Rect2i(int(faces.at<float>(rIdx, 0)),
+                                           int(faces.at<float>(rIdx, 1)),
+                                           int(faces.at<float>(rIdx, 2)),
+                                           int(faces.at<float>(rIdx, 3))));
+                faceScores.push_back(faces.at<float>(rIdx, 14));
+            }
+
+            std::vector<int> keepIdx;
+            dnn::NMSBoxes(faceBoxes, faceScores, scoreThreshold, nmsThreshold, keepIdx, 1.f, topK);
+
+            // Get NMS results
+            Mat nms_faces;
+            for (int idx: keepIdx)
+            {
+                nms_faces.push_back(faces.row(idx));
+            }
+            return nms_faces;
+        }
+        else
+        {
+            return faces;
+        }
+    }
+
+    void padWithDivisor(InputArray input_image, OutputArray pad_image)
+    {
+        int bottom = padH - inputH;
+        int right = padW - inputW;
+        copyMakeBorder(input_image, pad_image, 0, bottom, 0, right, BORDER_CONSTANT, 0);
+    }
+private:
+    dnn::Net net;
+
+    int inputW;
+    int inputH;
+    int padW;
+    int padH;
+    const int divisor;
+    int topK;
+    float scoreThreshold;
+    float nmsThreshold;
+    const std::vector<int> strides;
+};
+#endif
+
+Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& model,
+                                           const String& config,
+                                           const Size& input_size,
+                                           const float score_threshold,
+                                           const float nms_threshold,
+                                           const int top_k,
+                                           const int backend_id,
+                                           const int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceDetectorYNImpl>(model, config, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id);
+#else
+    CV_UNUSED(model); CV_UNUSED(config); CV_UNUSED(input_size); CV_UNUSED(score_threshold); CV_UNUSED(nms_threshold); CV_UNUSED(top_k); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceDetectorYN requires enabled 'dnn' module.");
+#endif
+}
+
+Ptr<FaceDetectorYN> FaceDetectorYN::create(const String& framework,
+                                           const std::vector<uchar>& bufferModel,
+                                           const std::vector<uchar>& bufferConfig,
+                                           const Size& input_size,
+                                           const float score_threshold,
+                                           const float nms_threshold,
+                                           const int top_k,
+                                           const int backend_id,
+                                           const int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceDetectorYNImpl>(framework, bufferModel, bufferConfig, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id);
+#else
+    CV_UNUSED(framework);  CV_UNUSED(bufferModel); CV_UNUSED(bufferConfig); CV_UNUSED(input_size); CV_UNUSED(score_threshold); CV_UNUSED(nms_threshold); CV_UNUSED(top_k); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceDetectorYN requires enabled 'dnn' module.");
+#endif
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/face_recognize.cpp b/upstream/opencv/modules/objdetect/src/face_recognize.cpp
new file mode 100644
index 0000000..b024c78
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/face_recognize.cpp
@@ -0,0 +1,218 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#include "opencv2/core.hpp"
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+#include <algorithm>
+
+namespace cv
+{
+
+#ifdef HAVE_OPENCV_DNN
+class FaceRecognizerSFImpl : public FaceRecognizerSF
+{
+public:
+    FaceRecognizerSFImpl(const String& model, const String& config, int backend_id, int target_id)
+    {
+        net = dnn::readNet(model, config);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+    }
+
+    FaceRecognizerSFImpl(const String& framework,
+                         const std::vector<uchar>& bufferModel,
+                         const std::vector<uchar>& bufferConfig,
+                         int backend_id, int target_id)
+    {
+        net = dnn::readNet(framework, bufferModel, bufferConfig);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(backend_id);
+        net.setPreferableTarget(target_id);
+    }
+
+    void alignCrop(InputArray _src_img, InputArray _face_mat, OutputArray _aligned_img) const override
+    {
+        Mat face_mat = _face_mat.getMat();
+        float src_point[5][2];
+        for (int row = 0; row < 5; ++row)
+        {
+            for(int col = 0; col < 2; ++col)
+            {
+                src_point[row][col] = face_mat.at<float>(0, row*2+col+4);
+            }
+        }
+        Mat warp_mat = getSimilarityTransformMatrix(src_point);
+        warpAffine(_src_img, _aligned_img, warp_mat, Size(112, 112), INTER_LINEAR);
+    }
+    void feature(InputArray _aligned_img, OutputArray _face_feature) override
+    {
+        Mat inputBolb = dnn::blobFromImage(_aligned_img, 1, Size(112, 112), Scalar(0, 0, 0), true, false);
+        net.setInput(inputBolb);
+        net.forward(_face_feature);
+    }
+    double match(InputArray _face_feature1, InputArray _face_feature2, int dis_type) const override
+    {
+        Mat face_feature1 = _face_feature1.getMat(), face_feature2 = _face_feature2.getMat();
+        normalize(face_feature1, face_feature1);
+        normalize(face_feature2, face_feature2);
+
+        if(dis_type == DisType::FR_COSINE){
+            return sum(face_feature1.mul(face_feature2))[0];
+        }else if(dis_type == DisType::FR_NORM_L2){
+            return norm(face_feature1, face_feature2);
+        }else{
+            throw std::invalid_argument("invalid parameter " + std::to_string(dis_type));
+        }
+
+    }
+
+private:
+    Mat getSimilarityTransformMatrix(float src[5][2]) const {
+        float dst[5][2] = { {38.2946f, 51.6963f}, {73.5318f, 51.5014f}, {56.0252f, 71.7366f}, {41.5493f, 92.3655f}, {70.7299f, 92.2041f} };
+        float avg0 = (src[0][0] + src[1][0] + src[2][0] + src[3][0] + src[4][0]) / 5;
+        float avg1 = (src[0][1] + src[1][1] + src[2][1] + src[3][1] + src[4][1]) / 5;
+        //Compute mean of src and dst.
+        float src_mean[2] = { avg0, avg1 };
+        float dst_mean[2] = { 56.0262f, 71.9008f };
+        //Subtract mean from src and dst.
+        float src_demean[5][2];
+        for (int i = 0; i < 2; i++)
+        {
+            for (int j = 0; j < 5; j++)
+            {
+                src_demean[j][i] = src[j][i] - src_mean[i];
+            }
+        }
+        float dst_demean[5][2];
+        for (int i = 0; i < 2; i++)
+        {
+            for (int j = 0; j < 5; j++)
+            {
+                dst_demean[j][i] = dst[j][i] - dst_mean[i];
+            }
+        }
+        double A00 = 0.0, A01 = 0.0, A10 = 0.0, A11 = 0.0;
+        for (int i = 0; i < 5; i++)
+            A00 += dst_demean[i][0] * src_demean[i][0];
+        A00 = A00 / 5;
+        for (int i = 0; i < 5; i++)
+            A01 += dst_demean[i][0] * src_demean[i][1];
+        A01 = A01 / 5;
+        for (int i = 0; i < 5; i++)
+            A10 += dst_demean[i][1] * src_demean[i][0];
+        A10 = A10 / 5;
+        for (int i = 0; i < 5; i++)
+            A11 += dst_demean[i][1] * src_demean[i][1];
+        A11 = A11 / 5;
+        Mat A = (Mat_<double>(2, 2) << A00, A01, A10, A11);
+        double d[2] = { 1.0, 1.0 };
+        double detA = A00 * A11 - A01 * A10;
+        if (detA < 0)
+            d[1] = -1;
+        double T[3][3] = { {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0} };
+        Mat s, u, vt, v;
+        SVD::compute(A, s, u, vt);
+        double smax = s.ptr<double>(0)[0]>s.ptr<double>(1)[0] ? s.ptr<double>(0)[0] : s.ptr<double>(1)[0];
+        double tol = smax * 2 * FLT_MIN;
+        int rank = 0;
+        if (s.ptr<double>(0)[0]>tol)
+            rank += 1;
+        if (s.ptr<double>(1)[0]>tol)
+            rank += 1;
+        double arr_u[2][2] = { {u.ptr<double>(0)[0], u.ptr<double>(0)[1]}, {u.ptr<double>(1)[0], u.ptr<double>(1)[1]} };
+        double arr_vt[2][2] = { {vt.ptr<double>(0)[0], vt.ptr<double>(0)[1]}, {vt.ptr<double>(1)[0], vt.ptr<double>(1)[1]} };
+        double det_u = arr_u[0][0] * arr_u[1][1] - arr_u[0][1] * arr_u[1][0];
+        double det_vt = arr_vt[0][0] * arr_vt[1][1] - arr_vt[0][1] * arr_vt[1][0];
+        if (rank == 1)
+        {
+            if ((det_u*det_vt) > 0)
+            {
+                Mat uvt = u*vt;
+                T[0][0] = uvt.ptr<double>(0)[0];
+                T[0][1] = uvt.ptr<double>(0)[1];
+                T[1][0] = uvt.ptr<double>(1)[0];
+                T[1][1] = uvt.ptr<double>(1)[1];
+            }
+            else
+            {
+                double temp = d[1];
+                d[1] = -1;
+                Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
+                Mat Dvt = D*vt;
+                Mat uDvt = u*Dvt;
+                T[0][0] = uDvt.ptr<double>(0)[0];
+                T[0][1] = uDvt.ptr<double>(0)[1];
+                T[1][0] = uDvt.ptr<double>(1)[0];
+                T[1][1] = uDvt.ptr<double>(1)[1];
+                d[1] = temp;
+            }
+        }
+        else
+        {
+            Mat D = (Mat_<double>(2, 2) << d[0], 0.0, 0.0, d[1]);
+            Mat Dvt = D*vt;
+            Mat uDvt = u*Dvt;
+            T[0][0] = uDvt.ptr<double>(0)[0];
+            T[0][1] = uDvt.ptr<double>(0)[1];
+            T[1][0] = uDvt.ptr<double>(1)[0];
+            T[1][1] = uDvt.ptr<double>(1)[1];
+        }
+        double var1 = 0.0;
+        for (int i = 0; i < 5; i++)
+            var1 += src_demean[i][0] * src_demean[i][0];
+        var1 = var1 / 5;
+        double var2 = 0.0;
+        for (int i = 0; i < 5; i++)
+            var2 += src_demean[i][1] * src_demean[i][1];
+        var2 = var2 / 5;
+        double scale = 1.0 / (var1 + var2)* (s.ptr<double>(0)[0] * d[0] + s.ptr<double>(1)[0] * d[1]);
+        double TS[2];
+        TS[0] = T[0][0] * src_mean[0] + T[0][1] * src_mean[1];
+        TS[1] = T[1][0] * src_mean[0] + T[1][1] * src_mean[1];
+        T[0][2] = dst_mean[0] - scale*TS[0];
+        T[1][2] = dst_mean[1] - scale*TS[1];
+        T[0][0] *= scale;
+        T[0][1] *= scale;
+        T[1][0] *= scale;
+        T[1][1] *= scale;
+        Mat transform_mat = (Mat_<double>(2, 3) << T[0][0], T[0][1], T[0][2], T[1][0], T[1][1], T[1][2]);
+        return transform_mat;
+    }
+private:
+    dnn::Net net;
+};
+#endif
+
+Ptr<FaceRecognizerSF> FaceRecognizerSF::create(const String& model, const String& config, int backend_id, int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceRecognizerSFImpl>(model, config, backend_id, target_id);
+#else
+    CV_UNUSED(model); CV_UNUSED(config); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceRecognizerSF requires enabled 'dnn' module");
+#endif
+}
+
+Ptr<FaceRecognizerSF> FaceRecognizerSF::create(const String& framework,
+                                               const std::vector<uchar>& bufferModel,
+                                               const std::vector<uchar>& bufferConfig,
+                                               int backend_id, int target_id)
+{
+#ifdef HAVE_OPENCV_DNN
+    return makePtr<FaceRecognizerSFImpl>(framework, bufferModel, bufferConfig, backend_id, target_id);
+#else
+    CV_UNUSED(framework);  CV_UNUSED(bufferModel); CV_UNUSED(bufferConfig); CV_UNUSED(backend_id); CV_UNUSED(target_id);
+    CV_Error(cv::Error::StsNotImplemented, "cv::FaceRecognizerSF requires enabled 'dnn' module");
+#endif
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp b/upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp
new file mode 100644
index 0000000..971fd59
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/graphical_code_detector.cpp
@@ -0,0 +1,45 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "opencv2/objdetect/graphical_code_detector.hpp"
+#include "graphical_code_detector_impl.hpp"
+
+namespace cv {
+
+GraphicalCodeDetector::GraphicalCodeDetector() {}
+
+bool GraphicalCodeDetector::detect(InputArray img, OutputArray points) const {
+    CV_Assert(p);
+    return p->detect(img, points);
+}
+
+std::string GraphicalCodeDetector::decode(InputArray img, InputArray points, OutputArray straight_code) const {
+    CV_Assert(p);
+    return p->decode(img, points, straight_code);
+}
+
+std::string GraphicalCodeDetector::detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const {
+    CV_Assert(p);
+    return p->detectAndDecode(img, points, straight_code);
+}
+
+bool GraphicalCodeDetector::detectMulti(InputArray img, OutputArray points) const {
+    CV_Assert(p);
+    return p->detectMulti(img, points);
+}
+
+bool GraphicalCodeDetector::decodeMulti(InputArray img, InputArray points, std::vector<std::string>& decoded_info,
+                                       OutputArrayOfArrays straight_code) const {
+    CV_Assert(p);
+    return p->decodeMulti(img, points, decoded_info, straight_code);
+}
+
+bool GraphicalCodeDetector::detectAndDecodeMulti(InputArray img, std::vector<std::string>& decoded_info, OutputArray points,
+                                                OutputArrayOfArrays straight_code) const {
+    CV_Assert(p);
+    return p->detectAndDecodeMulti(img, decoded_info, points, straight_code);
+}
+
+}
diff --git a/upstream/opencv/modules/objdetect/src/graphical_code_detector_impl.hpp b/upstream/opencv/modules/objdetect/src/graphical_code_detector_impl.hpp
new file mode 100644
index 0000000..987ccaa
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/graphical_code_detector_impl.hpp
@@ -0,0 +1,40 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#ifndef OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_IMPL_HPP
+#define OPENCV_OBJDETECT_GRAPHICAL_CODE_DETECTOR_IMPL_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+
+struct GraphicalCodeDetector::Impl {
+    virtual ~Impl() {}
+    virtual bool detect(InputArray img, OutputArray points) const = 0;
+    virtual std::string decode(InputArray img, InputArray points, OutputArray straight_code) const = 0;
+    virtual std::string detectAndDecode(InputArray img, OutputArray points, OutputArray straight_code) const = 0;
+    virtual bool detectMulti(InputArray img, OutputArray points) const = 0;
+    virtual bool decodeMulti(InputArray img, InputArray points, std::vector<std::string>& decoded_info,
+                             OutputArrayOfArrays straight_code) const = 0;
+    virtual bool detectAndDecodeMulti(InputArray img, std::vector<std::string>& decoded_info,
+                                      OutputArray points, OutputArrayOfArrays straight_code) const = 0;
+};
+
+class QRCodeDecoder {
+public:
+    virtual ~QRCodeDecoder();
+
+    static Ptr<QRCodeDecoder> create();
+
+    virtual bool decode(const Mat& straight, String& decoded_info) = 0;
+
+    QRCodeEncoder::EncodeMode mode;
+    QRCodeEncoder::ECIEncodings eci;
+    uint8_t parity = 0;
+    uint8_t sequence_num = 0;
+    uint8_t total_num = 1;
+};
+
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/main.cpp b/upstream/opencv/modules/objdetect/src/main.cpp
new file mode 100644
index 0000000..127f86b
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/main.cpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//
+// Library initialization file
+//
+
+#include "precomp.hpp"
+
+IPP_INITIALIZER_AUTO
+
+/* End of file. */
diff --git a/upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp b/upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp
new file mode 100644
index 0000000..e26579f
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/bound_min.cpp
@@ -0,0 +1,180 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+#include "bound_min.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+CBoundMin::CBoundMin()
+
+{
+}
+
+CBoundMin::~CBoundMin()
+{
+}
+
+void CBoundMin::calculate()
+{
+
+    corners.clear();
+    size_t N = chart.size();
+    if (!N)
+        return;
+
+    std::vector<Point2f> X(4 * N);
+    for (size_t i = 0; i < N; i++)
+    {
+        mcc::CChart cc = chart[i];
+        for (size_t j = 0; j < 4; j++)
+        {
+            X[i * 4 + j] = cc.corners[j];
+        }
+    }
+
+    // media
+    Point2f mu(0, 0);
+    for (size_t i = 0; i < 4 * N; i++)
+        mu += X[i];
+    mu /= (4 * (int)N);
+
+    for (size_t i = 0; i < 4 * N; i++)
+        X[i] -= mu;
+
+    // calculate all line
+    std::vector<Point3f> L;
+    L.resize(4 * N);
+    for (size_t i = 0; i < N; i++)
+    {
+        Point3f v0, v1, v2, v3;
+        v0.x = X[4 * i + 0].x;
+        v0.y = X[4 * i + 0].y;
+        v0.z = 1;
+        v1.x = X[4 * i + 1].x;
+        v1.y = X[4 * i + 1].y;
+        v1.z = 1;
+        v2.x = X[4 * i + 2].x;
+        v2.y = X[4 * i + 2].y;
+        v2.z = 1;
+        v3.x = X[4 * i + 3].x;
+        v3.y = X[4 * i + 3].y;
+        v3.z = 1;
+
+        L[4 * i + 0] = v0.cross(v1);
+        L[4 * i + 1] = v1.cross(v2);
+        L[4 * i + 2] = v2.cross(v3);
+        L[4 * i + 3] = v3.cross(v0);
+    }
+
+    // line convex hull
+    std::vector<int> dist;
+    dist.resize(4 * N);
+    Point2f n;
+    float d;
+
+    for (size_t i = 0; i < 4 * N; i++)
+    {
+        n.x = L[i].x;
+        n.y = L[i].y;
+        d = L[i].z;
+
+        int s = 0;
+        for (size_t j = 0; j < N; j++)
+            s += (X[j].dot(n) + d) <= 0;
+        dist[i] = s;
+    }
+
+    // sort
+    std::vector<int> idx;
+    std::vector<Point3f> Ls;
+    Ls.resize(4 * N);
+    mcc::sort(dist, idx);
+    for (size_t i = 0; i < 4 * N; i++)
+        Ls[i] = L[idx[i]];
+
+    std::vector<Point3f> Lc;
+    Lc.resize(4 * N);
+    Lc[0] = Ls[0];
+    Point3f ln;
+
+    int j, k = 0;
+    for (size_t i = 0; i < 4 * N; i++)
+    {
+
+        ln = Ls[i]; //current line
+        if (!validateLine(Lc, ln, k, j))
+        {
+
+            Lc[k] = ln;
+            k++;
+        }
+        else if ((abs(Lc[j].z) < abs(ln.z)) && (abs(dist[i] - dist[j]) < 2))
+        {
+            Lc[j] = ln;
+        }
+        if (k == 4 && abs(dist[i] - dist[k - 1]) > 2)
+            break;
+    }
+    if (k < 4)
+        return;
+
+    std::vector<float> thetas;
+    thetas.resize(4);
+    for (size_t i = 0; i < 4; i++)
+        thetas[i] = atan2(Lc[i].y / Lc[i].z, Lc[i].x / Lc[i].z);
+
+    sort(thetas, idx, false);
+    std::vector<Point3f> lines;
+    lines.resize(4);
+    for (size_t i = 0; i < 4; i++)
+        lines[i] = Lc[idx[i]];
+
+    Point3f Vcart;
+    Point2f Vhom;
+    std::vector<Point2f> V;
+    V.resize(4);
+
+    for (size_t i = 0; i < 4; i++)
+    {
+        j = (i + 1) % 4;
+        Vcart = lines[i].cross(lines[j]);
+        if (fabs(Vcart.z) <= 1e-6){
+            continue;
+        }
+        Vhom.x = Vcart.x / Vcart.z;
+        Vhom.y = Vcart.y / Vcart.z;
+        V[i] = Vhom + mu;
+    }
+
+    corners = V;
+}
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/bound_min.hpp b/upstream/opencv/modules/objdetect/src/mcc/bound_min.hpp
new file mode 100644
index 0000000..257b7ab
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/bound_min.hpp
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_BOUND_MIN_HPP
+#define _MCC_BOUND_MIN_HPP
+
+#include "charts.hpp"
+
+namespace cv
+{
+
+namespace mcc
+{
+
+class CBoundMin
+{
+
+public:
+    CBoundMin();
+    ~CBoundMin();
+
+    void setCharts(const std::vector<CChart> &chartIn) { chart = chartIn; }
+    void getCorners(std::vector<Point2f> &cornersOut) { cornersOut = corners; }
+    void calculate();
+
+private:
+    std::vector<CChart> chart;
+    std::vector<Point2f> corners;
+
+private:
+    bool validateLine(const std::vector<Point3f> &Lc, Point3f ln,
+                      int k, int &j)
+    {
+
+        double theta;
+        Point2d v0, v1;
+
+        for (j = 0; j < k; j++)
+        {
+            v0.x = Lc[j].x;
+            v0.y = Lc[j].y;
+            v1.x = ln.x;
+            v1.y = ln.y;
+            theta = v0.dot(v1) / (norm(v0) * norm(v1));
+            theta = acos(theta);
+
+            if (theta < 0.5)
+                return true;
+        }
+
+        return false;
+    }
+};
+
+} // namespace mcc
+
+} // namespace cv
+#endif //_MCC_BOUND_MIN_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/charts.cpp b/upstream/opencv/modules/objdetect/src/mcc/charts.cpp
new file mode 100644
index 0000000..9fb7100
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/charts.cpp
@@ -0,0 +1,96 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+#include "charts.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+CChart::CChart()
+    : perimetro(0), area(0), large_side(0)
+{
+}
+
+CChart::~CChart()
+{
+}
+
+void CChart::
+    setCorners(std::vector<Point2f> p)
+{
+    Point v1, v2;
+    if (p.empty())
+        return;
+
+    // copy
+    corners = p;
+
+    // Sort the corners in anti-clockwise order
+    polyanticlockwise(corners);
+
+    // Properties
+    area = contourArea(corners);
+    perimetro = perimeter(corners);
+    center = mace_center(corners);
+
+    v1 = corners[2] - corners[0];
+    v2 = corners[3] - corners[1];
+    large_side = std::max(norm(v1), norm(v2));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+CChartDraw::
+    CChartDraw(CChart &pChart, InputOutputArray image)
+    : m_pChart(pChart), m_image(image.getMat())
+{
+}
+
+void CChartDraw::
+    drawContour(Scalar color /*= CV_RGB(0, 250, 0)*/) const
+{
+
+    //Draw lines
+    int thickness = 2;
+    line(m_image, (m_pChart).corners[0], (m_pChart).corners[1], color, thickness, LINE_AA);
+    line(m_image, (m_pChart).corners[1], (m_pChart).corners[2], color, thickness, LINE_AA);
+    line(m_image, (m_pChart).corners[2], (m_pChart).corners[3], color, thickness, LINE_AA);
+    line(m_image, (m_pChart).corners[3], (m_pChart).corners[0], color, thickness, LINE_AA);
+}
+
+void CChartDraw::
+    drawCenter(Scalar color /*= CV_RGB(0, 0, 255)*/) const
+{
+    int radius = 3;
+    int thickness = 2;
+    circle(m_image, (m_pChart).center, radius, color, thickness);
+}
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/charts.hpp b/upstream/opencv/modules/objdetect/src/mcc/charts.hpp
new file mode 100644
index 0000000..985595d
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/charts.hpp
@@ -0,0 +1,90 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_CHARTS_HPP
+#define _MCC_CHARTS_HPP
+
+namespace cv
+{
+namespace mcc
+{
+
+/** @brief Chart model
+      *
+      * .--------. <- px,py
+      * |         | one chart for checker color
+      * |  RGB   |
+      * |  Lab   |
+      * |        |
+      * .--------.
+      *
+      * @author Pedro Marrero Fernndez
+      */
+
+class CChart
+{
+
+public:
+    CChart();
+    ~CChart();
+
+    /** @brief set corners
+     *@param p[in] new corners
+    */
+    void setCorners(std::vector<Point2f> p);
+
+public:
+    std::vector<Point2f> corners;
+    Point2f center;
+    double perimetro;
+    double area;
+    double large_side;
+};
+
+/** @brief Chart draw */
+class CChartDraw
+{
+public:
+    /** @brief contructor */
+    CChartDraw(CChart &pChart, InputOutputArray image);
+
+    /** @brief draw the chart contour over the image */
+    void drawContour(Scalar color = CV_RGB(0, 250, 0)) const;
+
+    /** @brief draw the chart center over the image */
+    void drawCenter(Scalar color = CV_RGB(0, 0, 255)) const;
+
+private:
+    CChart &m_pChart;
+    Mat m_image;
+};
+
+} // namespace mcc
+} // namespace cv
+
+#endif //_MCC_CHARTS_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp b/upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp
new file mode 100644
index 0000000..0803b73
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/checker_detector.cpp
@@ -0,0 +1,1591 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+
+#include "checker_detector.hpp"
+#include "graph_cluster.hpp"
+#include "bound_min.hpp"
+#include "wiener_filter.hpp"
+#include "checker_model.hpp"
+#include "debug.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+
+Ptr<CCheckerDetector> CCheckerDetector::create()
+{
+    return makePtr<CCheckerDetectorImpl>();
+}
+
+#ifdef HAVE_OPENCV_DNN
+Ptr<CCheckerDetector> CCheckerDetector::create(const dnn::Net& net)
+{
+    return makePtr<CCheckerDetectorImpl>(net);
+}
+#endif
+
+CCheckerDetectorImpl::
+    CCheckerDetectorImpl()
+{
+}
+
+CCheckerDetectorImpl::~CCheckerDetectorImpl()
+{
+}
+
+bool CCheckerDetectorImpl::
+    _no_net_process(InputArray image, const int nc,
+                    std::vector<Rect> regionsOfInterest)
+{
+    m_checkers.clear();
+
+    Mat img = image.getMat();
+    for (const Rect &region : regionsOfInterest)
+    {
+        //-------------------------------------------------------------------
+        // Run the model to find good regions
+        //-------------------------------------------------------------------
+        Mat croppedImage = img(region);
+#ifdef MCC_DEBUG
+        std::string pathOut = "./";
+#endif
+        //-------------------------------------------------------------------
+        // prepare image
+        //-------------------------------------------------------------------
+
+        Mat img_bgr, img_gray;
+        float asp;
+        prepareImage(croppedImage, img_gray, img_bgr, asp);
+
+#ifdef MCC_DEBUG
+        showAndSave("prepare_image", img_gray, pathOut);
+#endif
+        //-------------------------------------------------------------------
+        // thresholding
+        //-------------------------------------------------------------------
+        std::vector<Mat> img_bw;
+        performThreshold(img_gray, img_bw);
+
+        Mat3f img_rgb_f(img_bgr);
+        cvtColor(img_rgb_f, img_rgb_f, COLOR_BGR2RGB);
+        img_rgb_f /= 255;
+
+        Mat img_rgb_org, img_ycbcr_org;
+        std::vector<Mat> rgb_planes(3), ycbcr_planes(3);
+
+        // Convert to RGB and YCbCr space
+        cvtColor(croppedImage, img_rgb_org, COLOR_BGR2RGB);
+        cvtColor(croppedImage, img_ycbcr_org, COLOR_BGR2YCrCb);
+
+        // Get chanels
+        split(img_rgb_org, rgb_planes);
+        split(img_ycbcr_org, ycbcr_planes);
+        Mutex mtx;
+        parallel_for_(
+            Range(0, (int)img_bw.size()), [&](const Range &range) {
+                const int begin = range.start;
+                const int end = range.end;
+                for (int i = begin; i < end; i++)
+                {
+
+#ifdef MCC_DEBUG
+                    showAndSave("threshold_image", img_bw[i], pathOut);
+#endif
+                    // find contour
+                    //-------------------------------------------------------------------
+                    ContoursVector contours;
+                    findContours(img_bw[i], contours);
+
+                    if (contours.empty())
+                        continue;
+#ifdef MCC_DEBUG
+                    Mat im_contour(img_bgr.size(), CV_8UC1);
+                    im_contour = Scalar(0);
+                    drawContours(im_contour, contours, -1, Scalar(255), 2, LINE_AA);
+                    showAndSave("find_contour", im_contour, pathOut);
+#endif
+                    //-------------------------------------------------------------------
+                    // find candidate
+                    //-------------------------------------------------------------------
+
+                    std::vector<CChart> detectedCharts;
+                    findCandidates(contours, detectedCharts);
+
+                    if (detectedCharts.empty())
+                        continue;
+
+#ifdef MCC_DEBUG
+                    Mat img_chart;
+                    img_bgr.copyTo(img_chart);
+
+                    for (size_t ind = 0; ind < detectedCharts.size(); ind++)
+                    {
+
+                        CChartDraw chrtdrw((detectedCharts[ind]), img_chart);
+                        chrtdrw.drawCenter();
+                        chrtdrw.drawContour();
+                    }
+                    showAndSave("find_candidate", img_chart, pathOut);
+#endif
+                    //-------------------------------------------------------------------
+                    // clusters analysis
+                    //-------------------------------------------------------------------
+
+                    std::vector<int> G;
+                    clustersAnalysis(detectedCharts, G);
+
+                    if (G.empty())
+                        continue;
+
+#ifdef MCC_DEBUG
+                    Mat im_gru;
+                    img_bgr.copyTo(im_gru);
+                    RNG rng(0xFFFFFFFF);
+                    int radius = 10, thickness = -1;
+
+                    std::vector<int> g;
+                    unique(G, g);
+                    size_t Nc = g.size();
+                    std::vector<Scalar> colors(Nc);
+                    for (size_t ind = 0; ind < Nc; ind++)
+                        colors[ind] = randomcolor(rng);
+
+                    for (size_t ind = 0; ind < detectedCharts.size(); ind++)
+                        circle(im_gru, detectedCharts[ind].center, radius, colors[G[ind]],
+                                   thickness);
+                    showAndSave("clusters_analysis", im_gru, pathOut);
+#endif
+                    //-------------------------------------------------------------------
+                    // checker color recognize
+                    //-------------------------------------------------------------------
+
+                    std::vector<std::vector<Point2f>> colorCharts;
+                    checkerRecognize(img_bgr, detectedCharts, G, colorCharts);
+
+                    if (colorCharts.empty())
+                        continue;
+
+#ifdef MCC_DEBUG
+                    Mat image_box;
+                    img_bgr.copyTo(image_box);
+                    for (size_t ind = 0; ind < colorCharts.size(); ind++)
+                    {
+                        std::vector<Point2f> ibox = colorCharts[ind];
+                        Scalar color_box = CV_RGB(0, 0, 255);
+                        int thickness_box = 2;
+                        line(image_box, ibox[0], ibox[1], color_box, thickness_box, LINE_AA);
+                        line(image_box, ibox[1], ibox[2], color_box, thickness_box, LINE_AA);
+                        line(image_box, ibox[2], ibox[3], color_box, thickness_box, LINE_AA);
+                        line(image_box, ibox[3], ibox[0], color_box, thickness_box, LINE_AA);
+                    }
+                    showAndSave("checker_recognition", image_box, pathOut);
+#endif
+                    //-------------------------------------------------------------------
+                    // checker color analysis
+                    //-------------------------------------------------------------------
+                    std::vector<Ptr<CChecker>> checkers;
+                    Point2f total_offset = static_cast<Point2f>(region.tl());
+                    checkerAnalysis(img_rgb_f, nc, colorCharts, checkers, asp,
+                                    img_rgb_org, img_ycbcr_org, rgb_planes, ycbcr_planes,
+                                    total_offset);
+
+#ifdef MCC_DEBUG
+                    Mat image_checker;
+                    croppedImage.copyTo(image_checker);
+                    draw(checkers, image_checker);
+                    showAndSave("checker_analysis", image_checker, pathOut);
+#endif
+                    for (Ptr<CChecker> checker : checkers)
+                    {
+                        AutoLock lock(mtx);
+                        m_checkers.push_back(checker);
+                    }
+                }
+#ifdef MCC_DEBUG
+            },
+            1); //Run only one thread in debug mode
+#else
+            });
+#endif
+    }
+    //remove too close detections
+    removeTooCloseDetections();
+    m_checkers.resize(min(nc, (int)m_checkers.size()));
+    return !m_checkers.empty();
+}
+
+bool CCheckerDetectorImpl::
+    process(InputArray image, const std::vector<Rect> &regionsOfInterest,
+            const int nc /*= 1*/)
+{
+    m_checkers.clear();
+
+#ifdef HAVE_OPENCV_DNN
+    if (this->net.empty() || !m_useDnn)
+    {
+        return _no_net_process(image, nc, regionsOfInterest);
+    }
+
+    Mat img = image.getMat();
+
+    Mat img_rgb_org, img_ycbcr_org;
+    std::vector<Mat> rgb_planes(3), ycbcr_planes(3);
+
+    // Convert to RGB and YCbCr space
+    cvtColor(img, img_rgb_org, COLOR_BGR2RGB);
+    cvtColor(img, img_ycbcr_org, COLOR_BGR2YCrCb);
+
+    // Get chanels
+    split(img_rgb_org, rgb_planes);
+    split(img_ycbcr_org, ycbcr_planes);
+
+    for (const Rect &region : regionsOfInterest)
+    {
+        //-------------------------------------------------------------------
+        // Run the model to find good regions
+        //-------------------------------------------------------------------
+
+        Mat croppedImage = img(region);
+
+        int rows = croppedImage.size[0];
+        int cols = croppedImage.size[1];
+        net.setInput(dnn::blobFromImage(croppedImage, 1.0, Size(), Scalar(), true));
+        Mat output = net.forward();
+
+        Mat detectionMat(output.size[2], output.size[3], CV_32F, output.ptr<float>());
+
+        for (int i = 0; i < detectionMat.rows; i++)
+        {
+            float confidence = detectionMat.at<float>(i, 2);
+            if (confidence > m_params.confidenceThreshold)
+            {
+                float xTopLeft = max(0.0f, detectionMat.at<float>(i, 3) * cols - m_params.borderWidth);
+                float yTopLeft = max(0.0f, detectionMat.at<float>(i, 4) * rows - m_params.borderWidth);
+                float xBottomRight = min((float)cols - 1, detectionMat.at<float>(i, 5) * cols + m_params.borderWidth);
+                float yBottomRight = min((float)rows - 1, detectionMat.at<float>(i, 6) * rows + m_params.borderWidth);
+
+                Point2f topLeft = {xTopLeft, yTopLeft};
+                Point2f bottomRight = {xBottomRight, yBottomRight};
+
+                Rect innerRegion(topLeft, bottomRight);
+                Mat innerCroppedImage = croppedImage(innerRegion);
+
+#ifdef MCC_DEBUG
+                std::string pathOut = "./";
+#endif
+                //-------------------------------------------------------------------
+                // prepare image
+                //-------------------------------------------------------------------
+
+                Mat img_bgr, img_gray;
+                float asp;
+                prepareImage(innerCroppedImage, img_gray, img_bgr, asp);
+
+                //-------------------------------------------------------------------
+                // thresholding
+                //-------------------------------------------------------------------
+
+                std::vector<Mat> img_bw;
+                performThreshold(img_gray, img_bw);
+
+                Mat3f img_rgb_f(img_bgr);
+                cvtColor(img_rgb_f, img_rgb_f, COLOR_BGR2RGB);
+                img_rgb_f /= 255;
+                Mutex mtx;
+                parallel_for_(
+                    Range(0, (int)img_bw.size()), [&](const Range &range) {
+                        const int begin = range.start;
+                        const int end = range.end;
+
+                        for (int ind = begin; ind < end; ind++)
+                        {
+
+#ifdef MCC_DEBUG
+                            showAndSave("threshold_image", img_bw[ind], pathOut);
+#endif
+                            //------------------------------------------------------------------
+                            // find contour
+                            //-------------------------------------------------------------------
+                            ContoursVector contours;
+                            findContours(img_bw[ind], contours);
+
+                            if (contours.empty())
+                                continue;
+#ifdef MCC_DEBUG
+                            Mat im_contour(img_bgr.size(), CV_8UC1);
+                            im_contour = Scalar(0);
+                            drawContours(im_contour, contours, -1, Scalar(255), 2, LINE_AA);
+                            showAndSave("find_contour", im_contour, pathOut);
+#endif
+                            //-------------------------------------------------------------------
+                            // find candidate
+                            //-------------------------------------------------------------------
+
+                            std::vector<CChart> detectedCharts;
+                            findCandidates(contours, detectedCharts);
+
+                            if (detectedCharts.empty())
+                                continue;
+
+#ifdef MCC_DEBUG
+                            Mat img_chart;
+                            img_bgr.copyTo(img_chart);
+
+                            for (size_t index = 0; index < detectedCharts.size(); index++)
+                            {
+
+                                CChartDraw chrtdrw((detectedCharts[index]), img_chart);
+                                chrtdrw.drawCenter();
+                                chrtdrw.drawContour();
+                            }
+                            showAndSave("find_candidate", img_chart, pathOut);
+#endif
+                            //-------------------------------------------------------------------
+                            // clusters analysis
+                            //-------------------------------------------------------------------
+
+                            std::vector<int> G;
+                            clustersAnalysis(detectedCharts, G);
+
+                            if (G.empty())
+                                continue;
+#ifdef MCC_DEBUG
+                            Mat im_gru;
+                            img_bgr.copyTo(im_gru);
+                            RNG rng(0xFFFFFFFF);
+                            int radius = 10, thickness = -1;
+
+                            std::vector<int> g;
+                            unique(G, g);
+                            size_t Nc = g.size();
+                            std::vector<Scalar> colors(Nc);
+                            for (size_t index = 0; index < Nc; index++)
+                                colors[index] = randomcolor(rng);
+
+                            for (size_t index = 0; index < detectedCharts.size(); index++)
+                                circle(im_gru, detectedCharts[index].center, radius, colors[G[index]],
+                                           thickness);
+                            showAndSave("clusters_analysis", im_gru, pathOut);
+#endif
+
+                            //-------------------------------------------------------------------
+                            // checker color recognize
+                            //-------------------------------------------------------------------
+
+                            std::vector<std::vector<Point2f>> colorCharts;
+                            checkerRecognize(img_bgr, detectedCharts, G, colorCharts);
+
+                            if (colorCharts.empty())
+                                continue;
+
+#ifdef MCC_DEBUG
+                            Mat image_box;
+                            img_bgr.copyTo(image_box);
+                            for (size_t index = 0; index < colorCharts.size(); index++)
+                            {
+                                std::vector<Point2f> ibox = colorCharts[index];
+                                Scalar color_box = CV_RGB(0, 0, 255);
+                                int thickness_box = 2;
+                                line(image_box, ibox[0], ibox[1], color_box, thickness_box, LINE_AA);
+                                line(image_box, ibox[1], ibox[2], color_box, thickness_box, LINE_AA);
+                                line(image_box, ibox[2], ibox[3], color_box, thickness_box, LINE_AA);
+                                line(image_box, ibox[3], ibox[0], color_box, thickness_box, LINE_AA);
+                                //circle(image_box, ibox[0], 10, Scalar(0, 0, 255), 3);
+                                //circle(image_box, ibox[1], 10, Scalar(0, 255, 0), 3);
+                            }
+                            showAndSave("checker_recognition", image_box, pathOut);
+#endif
+                            //-------------------------------------------------------------------
+                            // checker color analysis
+                            //-------------------------------------------------------------------
+                            std::vector<Ptr<CChecker>> checkers;
+                            Point2f total_offset = static_cast<Point2f>(region.tl() + innerRegion.tl());
+                            checkerAnalysis(img_rgb_f, nc, colorCharts, checkers, asp,
+                                            img_rgb_org, img_ycbcr_org, rgb_planes, ycbcr_planes,
+                                            total_offset);
+#ifdef MCC_DEBUG
+                            Mat image_checker;
+                            innerCroppedImage.copyTo(image_checker);
+                            draw(checkers, image_checker);
+                            showAndSave("checker_analysis", image_checker, pathOut);
+#endif
+                            for (Ptr<CChecker> checker : checkers)
+                            {
+                                AutoLock lock(mtx);
+                                m_checkers.push_back(checker);
+                            }
+                        }
+#ifdef MCC_DEBUG
+                    },
+                    1); //Run only one thread in debug mode
+#else
+                    });
+#endif
+            }
+        }
+    }
+    // As a failsafe try the classical method
+    if (m_checkers.empty())
+    {
+        return _no_net_process(image, nc, regionsOfInterest);
+    }
+    //remove too close detections
+    removeTooCloseDetections();
+
+    m_checkers.resize(min(nc, (int)m_checkers.size()));
+
+    return !m_checkers.empty();
+#else
+    return _no_net_process(image, nc, regionsOfInterest);
+#endif
+}
+
+
+//Overload for the above function
+bool CCheckerDetectorImpl::
+    process(InputArray image, const int nc /*= 1*/)
+{
+    return process(image, std::vector<Rect>(1, Rect(0, 0, image.cols(), image.rows())),
+                   nc);
+}
+
+void CCheckerDetectorImpl::setDetectionParams(const DetectorParametersMCC &params)
+{
+    this->m_params = params;
+}
+
+void CCheckerDetectorImpl::setColorChartType(ColorChart chartType)
+{
+    this->m_chartType = chartType;
+}
+#ifdef HAVE_OPENCV_DNN
+void CCheckerDetectorImpl::setUseDnnModel(bool useDnn)
+{
+    this->m_useDnn = useDnn;
+}
+
+bool CCheckerDetectorImpl::getUseDnnModel() const
+{
+    return m_useDnn;
+}
+#endif
+const DetectorParametersMCC& CCheckerDetectorImpl::getDetectionParams() const
+{
+    return m_params;
+}
+
+ColorChart CCheckerDetectorImpl::getColorChartType() const
+{
+    return m_chartType;
+}
+
+void CCheckerDetectorImpl::
+    prepareImage(InputArray bgr, OutputArray grayOut,
+                 OutputArray bgrOut, float &aspOut) const
+{
+
+    int min_size;
+    Size size = bgr.size();
+    aspOut = 1;
+    bgr.copyTo(bgrOut);
+
+    // Resize image
+    min_size = std::min(size.width, size.height);
+    if (m_params.minImageSize > min_size)
+    {
+        aspOut = (float)m_params.minImageSize / min_size;
+        resize(bgr, bgrOut, Size(int(size.width * aspOut), int(size.height * aspOut)), INTER_LINEAR_EXACT);
+    }
+
+    // Convert to grayscale
+    cvtColor(bgrOut, grayOut, COLOR_BGR2GRAY);
+
+    // PDiamel: wiener adaptative methods to minimize the noise effets
+    // by illumination
+
+    CWienerFilter filter;
+    filter.wiener2(grayOut, grayOut, 5, 5);
+
+    //JLeandro: perform morphological open on the equalized image
+    //to minimize the noise effects by CLAHE and to even intensities
+    //inside the MCC patches (regions)
+
+    Mat strelbox = getStructuringElement(MORPH_RECT, Size(5, 5));
+    morphologyEx(grayOut, grayOut, MORPH_OPEN, strelbox);
+}
+
+void CCheckerDetectorImpl::
+    performThreshold(InputArray grayscaleImg,
+                     OutputArrayOfArrays thresholdImgs) const
+{
+    // number of window sizes (scales) to apply adaptive thresholding
+    int nScales = (m_params.adaptiveThreshWinSizeMax - m_params.adaptiveThreshWinSizeMin) / m_params.adaptiveThreshWinSizeStep + 1;
+    thresholdImgs.create(nScales, 1, CV_8U);
+    std::vector<Mat> _thresholdImgs(nScales);
+    parallel_for_(Range(0, nScales),[&](const Range& range) {
+        const int start = range.start;
+        const int end = range.end;
+        for (int i = start; i < end; i++) {
+            int currScale = m_params.adaptiveThreshWinSizeMin + i * m_params.adaptiveThreshWinSizeStep;
+            Mat tempThresholdImg;
+            adaptiveThreshold(grayscaleImg, tempThresholdImg, 255, ADAPTIVE_THRESH_MEAN_C,
+                                  THRESH_BINARY_INV, currScale, m_params.adaptiveThreshConstant);
+            _thresholdImgs[i] = tempThresholdImg;
+        }
+    });
+
+    thresholdImgs.assign(_thresholdImgs);
+}
+
+void CCheckerDetectorImpl::
+    findContours(
+        InputArray srcImg,
+        ContoursVector &contours) const
+{
+    // contour detected
+    // [Suzuki85] Suzuki, S. and Abe, K., Topological Structural Analysis of Digitized
+    // Binary Images by Border Following. CVGIP 30 1, pp 32-46 (1985)
+    ContoursVector allContours;
+    cv::findContours(srcImg, allContours, RETR_LIST, CHAIN_APPROX_NONE);
+
+    //select contours
+    contours.clear();
+
+    for (size_t i = 0; i < allContours.size(); i++)
+    {
+
+        PointsVector contour;
+        contour = allContours[i];
+
+        int contourSize = (int)contour.size();
+        if (contourSize <= m_params.minContourPointsAllowed)
+            continue;
+
+        double area = contourArea(contour);
+
+        if (area < m_params.minContoursArea)
+            continue;
+
+        PointsVector hull;
+        convexHull(contour, hull);
+        double area_hull = contourArea(hull);
+        double S = area / area_hull;
+        if (S < m_params.minContourSolidity)
+            continue;
+
+        contours.push_back(allContours[i]);
+    }
+}
+
+void CCheckerDetectorImpl::
+    findCandidates(
+        const ContoursVector &contours,
+        std::vector<CChart> &detectedCharts)
+{
+    std::vector<Point> approxCurve;
+    std::vector<CChart> possibleCharts;
+
+    // For each contour, analyze if it is a parallelepiped likely to be the chart
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        // Approximate to a polygon
+        //  It uses the Douglas-Peucker algorithm
+        // http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
+        double eps = contours[i].size() * m_params.findCandidatesApproxPolyDPEpsMultiplier;
+        approxPolyDP(contours[i], approxCurve, eps, true);
+
+        // We interested only in polygons that contains only four points
+        if (approxCurve.size() != 4)
+            continue;
+
+        // And they have to be convex
+        if (!isContourConvex(approxCurve))
+            continue;
+
+        // Ensure that the distance between consecutive points is large enough
+        float minDist = INFINITY;
+
+        for (size_t j = 0; j < 4; j++)
+        {
+            Point side = approxCurve[j] - approxCurve[(j + 1) % 4];
+            float squaredSideLength = (float)side.dot(side);
+            minDist = std::min(minDist, squaredSideLength);
+        }
+
+        // Check that distance is not very small
+        if (minDist < m_params.minContourLengthAllowed)
+            continue;
+
+        // All tests are passed. Save chart candidate:
+        CChart chart;
+
+        std::vector<Point2f> corners(4);
+        for (int j = 0; j < 4; j++)
+            corners[j] = Point2f((float)approxCurve[j].x, (float)approxCurve[j].y);
+        chart.setCorners(corners);
+
+        possibleCharts.push_back(chart);
+    }
+
+    // Remove these elements which corners are too close to each other.
+    // Eliminate overlaps!!!
+    // First detect candidates for removal:
+    std::vector<std::pair<int, int>> tooNearCandidates;
+    for (int i = 0; i < (int)possibleCharts.size(); i++)
+    {
+        const CChart &m1 = possibleCharts[i];
+
+        //calculate the average distance of each corner to the nearest corner of the other chart candidate
+        for (int j = i + 1; j < (int)possibleCharts.size(); j++)
+        {
+            const CChart &m2 = possibleCharts[j];
+
+            float distSquared = 0;
+
+            for (int c = 0; c < 4; c++)
+            {
+                Point v = m1.corners[c] - m2.corners[c];
+                distSquared += v.dot(v);
+            }
+
+            distSquared /= 4;
+
+            if (distSquared < m_params.minInterContourDistance)
+            {
+                tooNearCandidates.push_back(std::pair<int, int>(i, j));
+            }
+        }
+    }
+
+    // Mark for removal the element of the pair with smaller perimeter
+    std::vector<bool> removalMask(possibleCharts.size(), false);
+
+    for (size_t i = 0; i < tooNearCandidates.size(); i++)
+    {
+        float p1 = perimeter(possibleCharts[tooNearCandidates[i].first].corners);
+        float p2 = perimeter(possibleCharts[tooNearCandidates[i].second].corners);
+
+        size_t removalIndex;
+        if (p1 > p2)
+            removalIndex = tooNearCandidates[i].second;
+        else
+            removalIndex = tooNearCandidates[i].first;
+
+        removalMask[removalIndex] = true;
+    }
+
+    detectedCharts.clear();
+    for (size_t i = 0; i < possibleCharts.size(); i++)
+    {
+        if (removalMask[i])
+            continue;
+        detectedCharts.push_back(possibleCharts[i]);
+    }
+}
+
+void CCheckerDetectorImpl::
+    clustersAnalysis(
+        const std::vector<CChart> &detectedCharts,
+        std::vector<int> &groups)
+{
+    size_t N = detectedCharts.size();
+    std::vector<Point> X(N);
+    std::vector<double> B0(N), W(N);
+    std::vector<int> G;
+
+    CChart chart;
+    double b0;
+    for (size_t i = 0; i < N; i++)
+    {
+        chart = detectedCharts[i];
+        b0 = chart.large_side * m_params.B0factor;
+        X[i] = chart.center;
+        W[i] = chart.area;
+        B0[i] = b0;
+    }
+
+    CB0cluster bocluster;
+    bocluster.setVertex(X);
+    bocluster.setWeight(W);
+    bocluster.setB0(B0);
+    bocluster.group();
+    bocluster.getGroup(G);
+    groups = G;
+}
+
+void CCheckerDetectorImpl::
+    checkerRecognize(
+        InputArray img,
+        const std::vector<CChart> &detectedCharts,
+        const std::vector<int> &G,
+        std::vector<std::vector<Point2f>> &colorChartsOut)
+{
+    std::vector<int> gU;
+    unique(G, gU);
+    size_t Nc = gU.size();                //numero de grupos
+    size_t Ncc = detectedCharts.size(); //numero de charts
+
+    std::vector<std::vector<Point2f>> colorCharts;
+
+    for (size_t g = 0; g < Nc; g++)
+    {
+
+        ///-------------------------------------------------
+        /// selecionar grupo i-esimo
+
+        std::vector<CChart> chartSub;
+        for (size_t i = 0; i < Ncc; i++)
+            if (G[i] == (int)g)
+                chartSub.push_back(detectedCharts[i]);
+
+        size_t Nsc = chartSub.size();
+        if (static_cast<int>(Nsc) < m_params.minGroupSize)
+            continue;
+
+        ///-------------------------------------------------
+        /// min box estimation
+
+        CBoundMin bm;
+        std::vector<Point2f> points;
+
+        bm.setCharts(chartSub);
+        bm.calculate();
+        bm.getCorners(points);
+
+        // boundary condition
+        if (points.size() == 0)
+            continue;
+
+        // sort the points in anti-clockwise order
+        polyanticlockwise(points);
+
+        ///-------------------------------------------------
+        /// box projective transformation
+
+        // get physical char box model
+        std::vector<Point2f> chartPhy;
+        get_subbox_chart_physical(points, chartPhy);
+
+        // Find the perspective transformation that brings current chart to rectangular form
+        Matx33f ccT = getPerspectiveTransform(points, chartPhy);
+
+        // transformer
+        std::vector<Point2f> c(Nsc), ct;
+        std::vector<Point2f> ch(4 * Nsc), cht;
+
+        for (size_t i = 0; i < Nsc; i++)
+        {
+
+            CChart cc = chartSub[i];
+            for (size_t j = 0; j < 4; j++)
+                ch[i * 4 + j] = cc.corners[j];
+            c[i] = chartSub[i].center;
+        }
+
+        transform_points_forward(ccT, c, ct);
+        transform_points_forward(ccT, ch, cht);
+
+        float wchart = 0, hchart = 0;
+        std::vector<float> cx(Nsc), cy(Nsc);
+        for (size_t i = 0, k = 0; i < Nsc; i++)
+        {
+            k = i * 4;
+            Point2f v1 = cht[k + 1] - cht[k + 0];
+            Point2f v2 = cht[k + 3] - cht[k + 0];
+            wchart += (float)norm(v1);
+            hchart += (float)norm(v2);
+            cx[i] = ct[i].x;
+            cy[i] = ct[i].y;
+        }
+
+        wchart /= Nsc;
+        hchart /= Nsc;
+
+        ///-------------------------------------------------
+        /// centers and color estimate
+
+        float tolx = wchart / 2, toly = hchart / 2;
+        std::vector<float> cxr, cyr;
+        reduce_array(cx, cxr, tolx);
+        reduce_array(cy, cyr, toly);
+
+        if (cxr.size() == 1 || cyr.size() == 1) //no information can be extracted if \
+                                                //only one row or columns in present
+            continue;
+        // color and center rectificate
+        Size2i colorSize = Size2i((int)cxr.size(), (int)cyr.size());
+        Mat colorMat(colorSize, CV_32FC3);
+        std::vector<Point2f> cte(colorSize.area());
+
+        int k = 0;
+
+        for (int i = 0; i < colorSize.height; i++)
+        {
+            for (int j = 0; j < colorSize.width; j++)
+            {
+                Point2f vc = Point2f(cxr[j], cyr[i]);
+                cte[k] = vc;
+
+                // recovery color
+                Point2f cti;
+                Matx31f p, xt;
+
+                p(0, 0) = vc.x;
+                p(1, 0) = vc.y;
+                p(2, 0) = 1;
+                xt = ccT.inv() * p;
+                cti.x = xt(0, 0) / xt(2, 0);
+                cti.y = xt(1, 0) / xt(2, 0);
+
+                // color
+                int x, y;
+                x = (int)cti.x;
+                y = (int)cti.y;
+                Vec3f &srgb = colorMat.at<Vec3f>(i, j);
+                Vec3b rgb;
+                if (0 <= y && y < img.rows() && 0 <= x && x < img.cols())
+                    rgb = img.getMat().at<Vec3b>(y, x);
+
+                srgb[0] = (float)rgb[0] / 255;
+                srgb[1] = (float)rgb[1] / 255;
+                srgb[2] = (float)rgb[2] / 255;
+
+                k++;
+            }
+        }
+
+        CChartModel::SUBCCMModel scm;
+        scm.centers = cte;
+        scm.color_size = colorSize;
+        colorMat = colorMat.t();
+        scm.sub_chart = colorMat.reshape(3, colorSize.area());
+
+        ///-------------------------------------------------
+
+        // color chart model
+        CChartModel cccm(m_chartType);
+
+        int iTheta;     // rotation angle of chart
+        int offset;     // offset
+        float error; // min error
+        if (!cccm.evaluate(scm, offset, iTheta, error))
+            continue;
+        if (iTheta >= 4)
+            cccm.flip();
+
+        for (int i = 0; i < iTheta % 4; i++)
+            cccm.rotate90();
+
+        ///-------------------------------------------------
+        /// calculate coordanate
+
+        Size2i dim = cccm.size;
+        std::vector<Point2f> center = cccm.center;
+        std::vector<Point2f> box = cccm.box;
+        int cols = dim.height - colorSize.width + 1;
+
+        int x = (offset) / cols;
+        int y = (offset) % cols;
+
+        // seleccionar sub grid centers of model
+        std::vector<Point2f> ctss(colorSize.area());
+        Point2f point_ac = Point2f(0, 0);
+        int p = 0;
+
+        for (int i = x; i < (x + colorSize.height); i++)
+        {
+            for (int j = y; j < (y + colorSize.width); j++)
+            {
+                int iter = i * dim.height + j;
+                ctss[p] = center[iter];
+                point_ac += ctss[p];
+                p++;
+            }
+        }
+        // is colineal point
+        if (point_ac.x == ctss[0].x * p || point_ac.y == ctss[0].y * p)
+            continue;
+        // Find the perspective transformation
+        Matx33f ccTe = findHomography(ctss, cte);
+
+        std::vector<Point2f> tbox, ibox;
+        transform_points_forward(ccTe, box, tbox);
+        transform_points_inverse(ccT, tbox, ibox);
+
+        // sort the points in anti-clockwise order
+        if (iTheta < 4)
+            mcc::polyanticlockwise(ibox);
+        else
+            mcc::polyclockwise(ibox);
+        colorCharts.push_back(ibox);
+    }
+
+    colorChartsOut = colorCharts;
+}
+void CCheckerDetectorImpl::draw(std::vector<Ptr<CChecker>>& checkers, InputOutputArray img, Scalar color, int thickness)
+{
+    for (Ptr<CChecker> checker : checkers)
+    {
+        std::vector<Point2f> charts = checker->getColorCharts();
+        size_t N = charts.size() / 4;
+        for (size_t i = 0, k; i < N; i++)
+        {
+            k = 4 * i;
+            for (size_t j = 0; j < 4; j++)
+                line(img, charts[k+j], charts[k+((j + 1) % 4)], color, thickness, LINE_AA);
+        }
+    }
+}
+Mat CCheckerDetectorImpl::getRefColors() {
+    static const double ColorChecker2005_LAB_D50_2[24][3] = { { 37.986, 13.555, 14.059 },
+        { 65.711, 18.13, 17.81 },
+        { 49.927, -4.88, -21.925 },
+        { 43.139, -13.095, 21.905 },
+        { 55.112, 8.844, -25.399 },
+        { 70.719, -33.397, -0.199 },
+        { 62.661, 36.067, 57.096 },
+        { 40.02, 10.41, -45.964 },
+        { 51.124, 48.239, 16.248 },
+        { 30.325, 22.976, -21.587 },
+        { 72.532, -23.709, 57.255 },
+        { 71.941, 19.363, 67.857 },
+        { 28.778, 14.179, -50.297 },
+        { 55.261, -38.342, 31.37 },
+        { 42.101, 53.378, 28.19 },
+        { 81.733, 4.039, 79.819 },
+        { 51.935, 49.986, -14.574 },
+        { 51.038, -28.631, -28.638 },
+        { 96.539, -0.425, 1.186 },
+        { 81.257, -0.638, -0.335 },
+        { 66.766, -0.734, -0.504 },
+        { 50.867, -0.153, -0.27 },
+        { 35.656, -0.421, -1.231 },
+        { 20.461, -0.079, -0.973 } };
+
+    static const double Vinyl_LAB_D50_2[18][3] = { { 100, 0.00520000001, -0.0104 },
+        { 73.0833969, -0.819999993, -2.02099991 },
+        { 62.493, 0.425999999, -2.23099995 },
+        { 50.4640007, 0.446999997, -2.32399988 },
+        { 37.7970009, 0.0359999985, -1.29700005 },
+        { 0, 0, 0 },
+        { 51.5880013, 73.5179977, 51.5690002 },
+        { 93.6989975, -15.7340002, 91.9420013 },
+        { 69.4079971, -46.5940018, 50.4869995 },
+        { 66.61000060000001, -13.6789999, -43.1720009 },
+        { 11.7110004, 16.9799995, -37.1759987 },
+        { 51.973999, 81.9440002, -8.40699959 },
+        { 40.5489998, 50.4399986, 24.8490009 },
+        { 60.8160019, 26.0690002, 49.4420013 },
+        { 52.2529984, -19.9500008, -23.9960003 },
+        { 51.2859993, 48.4700012, -15.0579996 },
+        { 68.70700069999999, 12.2959995, 16.2129993 },
+        { 63.6839981, 10.2930002, 16.7639999 } };
+
+    static const double DigitalSG_LAB_D50_2[140][3] = { { 96.55, -0.91, 0.57 },
+        { 6.43, -0.06, -0.41 },
+        { 49.7, -0.18, 0.03 },
+        { 96.5, -0.89, 0.59 },
+        { 6.5, -0.06, -0.44 },
+        { 49.66, -0.2, 0.01 },
+        { 96.52, -0.91, 0.58 },
+        { 6.49, -0.02, -0.28 },
+        { 49.72, -0.2, 0.04 },
+        { 96.43, -0.91, 0.67 },
+        { 49.72, -0.19, 0 },
+        { 32.6, 51.58, -10.85 },
+        { 60.75, 26.22, -18.6 },
+        { 28.69, 48.28, -39 },
+        { 49.38, -15.43, -48.48 },
+        { 60.63, -30.77, -26.23 },
+        { 19.29, -26.37, -6.15 },
+        { 60.15, -41.77, -12.6 },
+        { 21.42, 1.67, 8.79 },
+        { 49.69, -0.2, 0.01 },
+        { 6.5, -0.03, -0.67 },
+        { 21.82, 17.33, -18.35 },
+        { 41.53, 18.48, -37.26 },
+        { 19.99, -0.16, -36.29 },
+        { 60.16, -18.45, -31.42 },
+        { 19.94, -17.92, -20.96 },
+        { 60.68, -6.05, -32.81 },
+        { 50.81, -49.8, -9.63 },
+        { 60.65, -39.77, 20.76 },
+        { 6.53, -0.03, -0.43 },
+        { 96.56, -0.91, 0.59 },
+        { 84.19, -1.95, -8.23 },
+        { 84.75, 14.55, 0.23 },
+        { 84.87, -19.07, -0.82 },
+        { 85.15, 13.48, 6.82 },
+        { 84.17, -10.45, 26.78 },
+        { 61.74, 31.06, 36.42 },
+        { 64.37, 20.82, 18.92 },
+        { 50.4, -53.22, 14.62 },
+        { 96.51, -0.89, 0.65 },
+        { 49.74, -0.19, 0.03 },
+        { 31.91, 18.62, 21.99 },
+        { 60.74, 38.66, 70.97 },
+        { 19.35, 22.23, -58.86 },
+        { 96.52, -0.91, 0.62 },
+        { 6.66, 0, -0.3 },
+        { 76.51, 20.81, 22.72 },
+        { 72.79, 29.15, 24.18 },
+        { 22.33, -20.7, 5.75 },
+        { 49.7, -0.19, 0.01 },
+        { 6.53, -0.05, -0.61 },
+        { 63.42, 20.19, 19.22 },
+        { 34.94, 11.64, -50.7 },
+        { 52.03, -44.15, 39.04 },
+        { 79.43, 0.29, -0.17 },
+        { 30.67, -0.14, -0.53 },
+        { 63.6, 14.44, 26.07 },
+        { 64.37, 14.5, 17.05 },
+        { 60.01, -44.33, 8.49 },
+        { 6.63, -0.01, -0.47 },
+        { 96.56, -0.93, 0.59 },
+        { 46.37, -5.09, -24.46 },
+        { 47.08, 52.97, 20.49 },
+        { 36.04, 64.92, 38.51 },
+        { 65.05, 0, -0.32 },
+        { 40.14, -0.19, -0.38 },
+        { 43.77, 16.46, 27.12 },
+        { 64.39, 17, 16.59 },
+        { 60.79, -29.74, 41.5 },
+        { 96.48, -0.89, 0.64 },
+        { 49.75, -0.21, 0.01 },
+        { 38.18, -16.99, 30.87 },
+        { 21.31, 29.14, -27.51 },
+        { 80.57, 3.85, 89.61 },
+        { 49.71, -0.2, 0.03 },
+        { 60.27, 0.08, -0.41 },
+        { 67.34, 14.45, 16.9 },
+        { 64.69, 16.95, 18.57 },
+        { 51.12, -49.31, 44.41 },
+        { 49.7, -0.2, 0.02 },
+        { 6.67, -0.05, -0.64 },
+        { 51.56, 9.16, -26.88 },
+        { 70.83, -24.26, 64.77 },
+        { 48.06, 55.33, -15.61 },
+        { 35.26, -0.09, -0.24 },
+        { 75.16, 0.25, -0.2 },
+        { 44.54, 26.27, 38.93 },
+        { 35.91, 16.59, 26.46 },
+        { 61.49, -52.73, 47.3 },
+        { 6.59, -0.05, -0.5 },
+        { 96.58, -0.9, 0.61 },
+        { 68.93, -34.58, -0.34 },
+        { 69.65, 20.09, 78.57 },
+        { 47.79, -33.18, -30.21 },
+        { 15.94, -0.42, -1.2 },
+        { 89.02, -0.36, -0.48 },
+        { 63.43, 25.44, 26.25 },
+        { 65.75, 22.06, 27.82 },
+        { 61.47, 17.1, 50.72 },
+        { 96.53, -0.89, 0.66 },
+        { 49.79, -0.2, 0.03 },
+        { 85.17, 10.89, 17.26 },
+        { 89.74, -16.52, 6.19 },
+        { 84.55, 5.07, -6.12 },
+        { 84.02, -13.87, -8.72 },
+        { 70.76, 0.07, -0.35 },
+        { 45.59, -0.05, 0.23 },
+        { 20.3, 0.07, -0.32 },
+        { 61.79, -13.41, 55.42 },
+        { 49.72, -0.19, 0.02 },
+        { 6.77, -0.05, -0.44 },
+        { 21.85, 34.37, 7.83 },
+        { 42.66, 67.43, 48.42 },
+        { 60.33, 36.56, 3.56 },
+        { 61.22, 36.61, 17.32 },
+        { 62.07, 52.8, 77.14 },
+        { 72.42, -9.82, 89.66 },
+        { 62.03, 3.53, 57.01 },
+        { 71.95, -27.34, 73.69 },
+        { 6.59, -0.04, -0.45 },
+        { 49.77, -0.19, 0.04 },
+        { 41.84, 62.05, 10.01 },
+        { 19.78, 29.16, -7.85 },
+        { 39.56, 65.98, 33.71 },
+        { 52.39, 68.33, 47.84 },
+        { 81.23, 24.12, 87.51 },
+        { 81.8, 6.78, 95.75 },
+        { 71.72, -16.23, 76.28 },
+        { 20.31, 14.45, 16.74 },
+        { 49.68, -0.19, 0.05 },
+        { 96.48, -0.88, 0.68 },
+        { 49.69, -0.18, 0.03 },
+        { 6.39, -0.04, -0.33 },
+        { 96.54, -0.9, 0.67 },
+        { 49.72, -0.18, 0.05 },
+        { 6.49, -0.03, -0.41 },
+        { 96.51, -0.9, 0.69 },
+        { 49.7, -0.19, 0.07 },
+        { 6.47, 0, -0.38 },
+        { 96.46, -0.89, 0.7 } };
+
+    Mat lab_color(1, 1, CV_32FC3), rgb_color(1, 1, CV_32FC3);
+
+    const double (*colorData)[3] = nullptr;
+    int colorCount = 0;
+
+    switch (m_chartType) {
+        case MCC24:
+            colorData = ColorChecker2005_LAB_D50_2;
+            colorCount = 24;
+            break;
+        case VINYL18:
+            colorData = Vinyl_LAB_D50_2;
+            colorCount = 18;
+            break;
+        case SG140:
+            colorData = DigitalSG_LAB_D50_2;
+            colorCount = 140;
+            break;
+        default:
+            throw std::runtime_error("Unknown color type requested.");
+    }
+
+    Mat out = Mat(colorCount, 1, CV_32SC3);
+
+    for (int i = 0; i < colorCount; i++) {
+        lab_color.at<Vec3f>(0, 0) = Vec3f(
+            static_cast<float>(colorData[i][0]),
+            static_cast<float>(colorData[i][1]),
+            static_cast<float>(colorData[i][2])
+        );
+
+        cvtColor(lab_color, rgb_color, COLOR_Lab2BGR);
+
+        // Convert to 8-bit RGB values (0-255) but store as int
+        Vec3f rgb = rgb_color.at<Vec3f>(0, 0) * 255;
+        out.at<Vec3i>(i, 0) = Vec3i(
+            std::min(255, std::max(0, static_cast<int>(rgb[0]))),  // Blue
+            std::min(255, std::max(0, static_cast<int>(rgb[1]))),  // Green
+            std::min(255, std::max(0, static_cast<int>(rgb[2])))   // Red
+        );
+    }
+    return out;
+}
+
+void CCheckerDetectorImpl::
+    checkerAnalysis(
+        InputArray img_f,
+        const unsigned int nc,
+        const std::vector<std::vector<Point2f>> &colorCharts,
+        std::vector<Ptr<CChecker>> &checkers,
+        float asp,
+        const Mat &img_rgb_org,
+        const Mat &img_ycbcr_org,
+        std::vector<Mat> &rgb_planes,
+        std::vector<Mat> &ycbcr_planes,
+        const Point2f& offset)
+{
+    size_t N;
+    std::vector<Point2f> ibox;
+
+    // color chart classic model
+    CChartModel cccm(m_chartType);
+    Mat lab;
+    cccm.copyToColorMat(lab, 0);
+    lab = lab.reshape(3, lab.size().area());
+    lab /= 255;
+
+    Mat mask(img_f.size(), CV_8U);
+    mask.setTo(Scalar::all(0));
+
+    N = colorCharts.size();
+    std::vector<float> J(N);
+    for (size_t i = 0; i < N; i++)
+    {
+        ibox = colorCharts[i];
+        J[i] = cost_function(img_f, mask, lab, ibox);
+    }
+
+    std::vector<int> idx;
+    sort(J, idx);
+    float invAsp = 1 / asp;
+    size_t n = min(nc, (unsigned)N);
+    checkers.clear();
+
+    for (size_t i = 0; i < n; i++)
+    {
+        ibox = colorCharts[idx[i]];
+
+        if (J[i] > m_params.maxError)
+            continue;
+
+        // redimension box
+        for (size_t j = 0; j < 4; j++)
+            ibox[j] = invAsp * ibox[j] + offset;
+
+        Mat charts_rgb, charts_ycbcr;
+        get_profile(ibox, charts_rgb, charts_ycbcr, img_rgb_org,
+                    img_ycbcr_org, rgb_planes, ycbcr_planes);
+
+        // result
+        Ptr<CChecker> checker = CChecker::create();
+        checker->setBox(ibox);
+        checker->setTarget(m_chartType);
+        checker->setChartsRGB(charts_rgb);
+        checker->setChartsYCbCr(charts_ycbcr);
+        checker->setCenter(mace_center(ibox));
+        checker->setCost(J[i]);
+
+        checkers.push_back(checker);
+    }
+}
+
+void CCheckerDetectorImpl::
+    removeTooCloseDetections()
+{
+    // Remove these elements which corners are too close to each other.
+    // Eliminate overlaps!!!
+    // First detect candidates for removal:
+    std::vector<std::pair<int, int>> tooNearCandidates;
+    for (int i = 0; i < (int)m_checkers.size(); i++)
+    {
+        const Ptr<CChecker> &m1 = m_checkers[i];
+
+        //calculate the average distance of each corner to the nearest corner of the other chart candidate
+        for (int j = i + 1; j < (int)m_checkers.size(); j++)
+        {
+            const Ptr<CChecker> &m2 = m_checkers[j];
+
+            float distSquared = 0;
+
+            for (int c = 0; c < 4; c++)
+            {
+                Point v = m1->getBox()[c] - m2->getBox()[c];
+                distSquared += v.dot(v);
+            }
+
+            distSquared /= 4;
+
+            if (distSquared < m_params.minInterCheckerDistance)
+            {
+                tooNearCandidates.push_back(std::pair<int, int>(i, j));
+            }
+        }
+    }
+
+    // Mark for removal the element of the pair with smaller cost
+    std::vector<bool> removalMask(m_checkers.size(), false);
+
+    for (size_t i = 0; i < tooNearCandidates.size(); i++)
+    {
+        float p1 = m_checkers[tooNearCandidates[i].first]->getCost();
+        float p2 = m_checkers[tooNearCandidates[i].second]->getCost();
+
+        size_t removalIndex;
+        if (p1 < p2)
+            removalIndex = tooNearCandidates[i].second;
+        else
+            removalIndex = tooNearCandidates[i].first;
+
+        removalMask[removalIndex] = true;
+    }
+
+    std::vector<Ptr<CChecker>> copy_m_checkers = m_checkers;
+    m_checkers.clear();
+
+    for (size_t i = 0; i < copy_m_checkers.size(); i++)
+    {
+        if (removalMask[i])
+            continue;
+        m_checkers.push_back(copy_m_checkers[i]);
+    }
+
+    sort( m_checkers.begin(), m_checkers.end(),
+          [&](const Ptr<CChecker> &a, const Ptr<CChecker> &b)
+          {
+              return a->getCost() < b->getCost();
+          });
+}
+
+void CCheckerDetectorImpl::
+    get_subbox_chart_physical(const std::vector<Point2f> &points, std::vector<Point2f> &chartPhy)
+{
+    float w, h;
+    Point2f v1 = points[1] - points[0];
+    Point2f v2 = points[3] - points[0];
+    float asp = (float)(norm(v2) / norm(v1));
+
+    w = 100;
+    h = (float)floor(100 * asp + 0.5);
+
+    chartPhy.clear();
+    chartPhy.resize(4);
+    chartPhy[0] = Point2f(0, 0);
+    chartPhy[1] = Point2f(w, 0);
+    chartPhy[2] = Point2f(w, h);
+    chartPhy[3] = Point2f(0, h);
+}
+
+void CCheckerDetectorImpl::
+    reduce_array(const std::vector<float> &x, std::vector<float> &x_new, float tol)
+{
+    size_t n = x.size(), nn;
+    std::vector<float> xx = x;
+    x_new.clear();
+
+    // sort array
+    std::sort(xx.begin(), xx.end());
+
+    // label array
+    std::vector<int> label(n);
+    for (size_t i = 0; i < n; i++)
+        label[i] = abs(xx[(n + i - 1) % n] - xx[i]) > tol;
+
+    // diff array
+    for (size_t i = 1; i < n; i++)
+        label[i] += label[i - 1];
+
+    // unique array
+    std::vector<int> ulabel;
+    unique(label, ulabel);
+
+    // mean for group
+    nn = ulabel.size();
+    x_new.resize(nn);
+    for (size_t i = 0; i < nn; i++)
+    {
+        float mu = 0, s = 0;
+        for (size_t j = 0; j < n; j++)
+        {
+            mu += (label[j] == ulabel[i]) * xx[j];
+            s += (label[j] == ulabel[i]);
+        }
+        x_new[i] = mu / s;
+    }
+
+    // diff array
+    std::vector<float> dif(nn - 1);
+    for (size_t i = 0; i < nn - 1; i++)
+        dif[i] = (x_new[(i + 1) % nn] - x_new[i]);
+
+    // max and idx
+    float fmax = 0;
+    size_t idx = 0;
+    for (size_t i = 0; i < nn - 1; i++)
+        if (fmax < dif[i])
+        {
+            fmax = dif[i];
+            idx = i;
+        }
+
+    // add ... X[i] MAX X[i+] ...
+    if (fmax > 4 * tol)
+        x_new.insert(x_new.begin() + idx + 1, (x_new[idx] + x_new[idx + 1]) / 2);
+}
+
+void CCheckerDetectorImpl::
+    transform_points_inverse(InputArray T, const std::vector<Point2f> &X, std::vector<Point2f> &Xt)
+{
+    Matx33f _T = T.getMat();
+    Matx33f Tinv = _T.inv();
+    transform_points_forward(Tinv, X, Xt);
+}
+void CCheckerDetectorImpl::
+    get_profile(
+        const std::vector<Point2f> &ibox,
+        OutputArray charts_rgb,
+        OutputArray charts_ycbcr,
+        InputArray im_rgb,
+        InputArray im_ycbcr,
+        std::vector<Mat> &rgb_planes,
+        std::vector<Mat> &ycbcr_planes)
+{
+    // color chart classic model
+    CChartModel cccm(m_chartType);
+    std::vector<Point2f> fbox = cccm.box;
+    std::vector<Point2f> cellchart = cccm.cellchart;
+
+    // tranformation
+    Matx33f ccT = getPerspectiveTransform(fbox, ibox);
+
+    Mat mask(im_rgb.size(), CV_8U);
+    mask.setTo(Scalar::all(0));
+    std::vector<Point2f> bch(4), bcht(4);
+    size_t N = cellchart.size() / 4;
+
+    // Create table charts information
+    //          |p_size|average|stddev|max|min|
+    //    RGB   |      |       |      |   |   |
+    //  YCbCr   |
+
+    Mat _charts_rgb = Mat(Size(5, 3 * (int)N), CV_64F);
+    Mat _charts_ycbcr = Mat(Size(5, 3 * (int)N), CV_64F);
+
+    Scalar mu_rgb, st_rgb, mu_ycb, st_ycb, p_size;
+    double max_rgb[3], min_rgb[3], max_ycb[3], min_ycb[3];
+
+    for (int i = 0, k; i < (int)N; i++)
+    {
+        k = 4 * i;
+        bch[0] = cellchart[k + 0];
+        bch[1] = cellchart[k + 1];
+        bch[2] = cellchart[k + 2];
+        bch[3] = cellchart[k + 3];
+        polyanticlockwise(bch);
+        transform_points_forward(ccT, bch, bcht);
+
+        Point2f c(0, 0);
+        for (int j = 0; j < 4; j++)
+            c += bcht[j];
+        c /= 4;
+        for (size_t j = 0; j < 4; j++)
+            bcht[j] = ((bcht[j] - c) * 0.50) + c;
+
+        Rect roi = poly2mask(bcht, im_rgb.size(), mask);
+        Mat submask = mask(roi);
+        p_size = sum(submask);
+
+        // rgb space
+        meanStdDev(im_rgb.getMat()(roi), mu_rgb, st_rgb, submask);
+        minMaxLoc(rgb_planes[0](roi), &min_rgb[0], &max_rgb[0], NULL, NULL, submask);
+        minMaxLoc(rgb_planes[1](roi), &min_rgb[1], &max_rgb[1], NULL, NULL, submask);
+        minMaxLoc(rgb_planes[2](roi), &min_rgb[2], &max_rgb[2], NULL, NULL, submask);
+
+        // create tabla
+        //|p_size|average|stddev|max|min|
+        // raw_r
+        _charts_rgb.at<double>(3 * i + 0, 0) = p_size(0);
+        _charts_rgb.at<double>(3 * i + 0, 1) = mu_rgb(0);
+        _charts_rgb.at<double>(3 * i + 0, 2) = st_rgb(0);
+        _charts_rgb.at<double>(3 * i + 0, 3) = min_rgb[0];
+        _charts_rgb.at<double>(3 * i + 0, 4) = max_rgb[0];
+        // raw_g
+        _charts_rgb.at<double>(3 * i + 1, 0) = p_size(0);
+        _charts_rgb.at<double>(3 * i + 1, 1) = mu_rgb(1);
+        _charts_rgb.at<double>(3 * i + 1, 2) = st_rgb(1);
+        _charts_rgb.at<double>(3 * i + 1, 3) = min_rgb[1];
+        _charts_rgb.at<double>(3 * i + 1, 4) = max_rgb[1];
+        // raw_b
+        _charts_rgb.at<double>(3 * i + 2, 0) = p_size(0);
+        _charts_rgb.at<double>(3 * i + 2, 1) = mu_rgb(2);
+        _charts_rgb.at<double>(3 * i + 2, 2) = st_rgb(2);
+        _charts_rgb.at<double>(3 * i + 2, 3) = min_rgb[2];
+        _charts_rgb.at<double>(3 * i + 2, 4) = max_rgb[2];
+
+        // YCbCr space
+        meanStdDev(im_ycbcr.getMat()(roi), mu_ycb, st_ycb, submask);
+        minMaxLoc(ycbcr_planes[0](roi), &min_ycb[0], &max_ycb[0], NULL, NULL, submask);
+        minMaxLoc(ycbcr_planes[1](roi), &min_ycb[1], &max_ycb[1], NULL, NULL, submask);
+        minMaxLoc(ycbcr_planes[2](roi), &min_ycb[2], &max_ycb[2], NULL, NULL, submask);
+
+        // create tabla
+        //|p_size|average|stddev|max|min|
+        // raw_Y
+        _charts_ycbcr.at<double>(3 * i + 0, 0) = p_size(0);
+        _charts_ycbcr.at<double>(3 * i + 0, 1) = mu_ycb(0);
+        _charts_ycbcr.at<double>(3 * i + 0, 2) = st_ycb(0);
+        _charts_ycbcr.at<double>(3 * i + 0, 3) = min_ycb[0];
+        _charts_ycbcr.at<double>(3 * i + 0, 4) = max_ycb[0];
+        // raw_Cb
+        _charts_ycbcr.at<double>(3 * i + 1, 0) = p_size(0);
+        _charts_ycbcr.at<double>(3 * i + 1, 1) = mu_ycb(1);
+        _charts_ycbcr.at<double>(3 * i + 1, 2) = st_ycb(1);
+        _charts_ycbcr.at<double>(3 * i + 1, 3) = min_ycb[1];
+        _charts_ycbcr.at<double>(3 * i + 1, 4) = max_ycb[1];
+        // raw_Cr
+        _charts_ycbcr.at<double>(3 * i + 2, 0) = p_size(0);
+        _charts_ycbcr.at<double>(3 * i + 2, 1) = mu_ycb(2);
+        _charts_ycbcr.at<double>(3 * i + 2, 2) = st_ycb(2);
+        _charts_ycbcr.at<double>(3 * i + 2, 3) = min_ycb[2];
+        _charts_ycbcr.at<double>(3 * i + 2, 4) = max_ycb[2];
+
+        submask.setTo(Scalar::all(0));
+    }
+    charts_rgb.assign(_charts_rgb);
+    charts_ycbcr.assign(_charts_ycbcr);
+}
+
+float CCheckerDetectorImpl::
+    cost_function(InputArray im_rgb, InputOutputArray mask, InputArray lab,
+                  const std::vector<Point2f> &ibox)
+{
+    CChartModel cccm(m_chartType);
+    std::vector<Point2f> fbox = cccm.box;
+    std::vector<Point2f> cellchart = cccm.cellchart;
+
+    // tranformation
+    Matx33f ccT = getPerspectiveTransform(fbox, ibox);
+    std::vector<Point2f> bch(4), bcht(4);
+
+    int N = (int)(cellchart.size() / 4);
+
+    Mat _lab = lab.getMat();
+    Mat _im_rgb = im_rgb.getMat();
+
+    float ec = 0, es = 0;
+    for (int i = 0, k; i < N; i++)
+    {
+        Vec3f r = _lab.at<Vec3f>(i);
+
+        k = 4 * i;
+        bch[0] = cellchart[k + 0];
+        bch[1] = cellchart[k + 1];
+        bch[2] = cellchart[k + 2];
+        bch[3] = cellchart[k + 3];
+        polyanticlockwise(bch);
+        transform_points_forward(ccT, bch, bcht);
+
+        Point2f c(0, 0);
+        for (int j = 0; j < 4; j++)
+            c += bcht[j];
+        c /= 4;
+        for (int j = 0; j < 4; j++)
+            bcht[j] = ((bcht[j] - c) * 0.75) + c;
+
+        Scalar mu, st;
+        Rect roi = poly2mask(bcht, _im_rgb.size(), mask);
+        if (!roi.empty())
+        {
+            Mat submask = mask.getMat()(roi);
+            meanStdDev(_im_rgb(roi), mu, st, submask);
+            submask.setTo(Scalar::all(0));
+
+            // cos error
+            float costh;
+            costh = (float)(mu.dot(Scalar(r)) / (norm(mu) * norm(r) + FLT_EPSILON));
+            ec += (1 - (1 + costh) / 2);
+
+            // standar desviation
+            es += (float)st.dot(st);
+        }
+    }
+
+    // J = arg min ec + es
+    float J = ec + es;
+    return J / N;
+}
+
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/checker_detector.hpp b/upstream/opencv/modules/objdetect/src/mcc/checker_detector.hpp
new file mode 100644
index 0000000..42d4276
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/checker_detector.hpp
@@ -0,0 +1,216 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_CHECKER_DETECTOR_HPP
+#define _MCC_CHECKER_DETECTOR_HPP
+
+#include "opencv2/objdetect.hpp"
+#include "charts.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+
+class CCheckerDetectorImpl : public CCheckerDetector
+{
+
+    typedef std::vector<Point> PointsVector;
+    typedef std::vector<PointsVector> ContoursVector;
+
+public:
+    CCheckerDetectorImpl();
+#ifdef HAVE_OPENCV_DNN
+    CCheckerDetectorImpl(const dnn::Net& _net){
+        net = _net;
+    }
+#endif
+    virtual ~CCheckerDetectorImpl();
+
+    bool process(InputArray image, const std::vector<Rect> &regionsOfInterest,
+                 const int nc = 1) CV_OVERRIDE;
+
+    bool process(InputArray image, const int nc = 1) CV_OVERRIDE;
+
+    Ptr<CChecker> getBestColorChecker() CV_OVERRIDE
+    {
+        if (m_checkers.size())
+            return m_checkers[0];
+        return nullptr;
+    }
+
+    std::vector<Ptr<CChecker>> getListColorChecker() CV_OVERRIDE
+    {
+        return m_checkers;
+    }
+    virtual Mat getRefColors() CV_OVERRIDE;
+
+    virtual void setDetectionParams(const DetectorParametersMCC &params) CV_OVERRIDE;
+
+    virtual void setColorChartType(ColorChart chartType) CV_OVERRIDE;
+
+#ifdef HAVE_OPENCV_DNN
+    virtual void setUseDnnModel(bool useDnn) CV_OVERRIDE;
+
+    virtual bool getUseDnnModel() const CV_OVERRIDE;
+#endif
+
+    virtual const DetectorParametersMCC& getDetectionParams() const CV_OVERRIDE;
+
+    virtual ColorChart getColorChartType() const CV_OVERRIDE;
+
+    virtual void draw(std::vector<Ptr<CChecker>>& checkers, InputOutputArray img, const Scalar color = CV_RGB(0,250,0), const int thickness = 2) CV_OVERRIDE;
+
+protected: // methods pipeline
+    bool _no_net_process(InputArray image, const int nc, std::vector<Rect> regionsOfInterest);
+    /// prepareImage
+    /** @brief Prepare Image
+      * @param bgrMat image in color space BGR
+      * @param grayOut gray scale
+      * @param bgrOut rescale image
+      * @param aspOut aspect ratio
+      * @param max_size rescale factor in max dim
+      */
+    virtual void
+    prepareImage(InputArray bgr, OutputArray grayOut, OutputArray bgrOut, float &aspOut) const;
+
+    /// performThreshold
+    /** @brief Adaptative threshold
+      * @param grayscaleImg gray scale image
+      * @param thresholdImg binary image
+      * @param wndx, wndy windows size
+      * @param step
+      */
+    virtual void
+    performThreshold(InputArray grayscaleImg, OutputArrayOfArrays thresholdImg) const;
+
+    /// findContours
+    /** @brief find contour in the image
+    * @param srcImg binary imagen
+    * @param contours
+    * @param minContourPointsAllowed
+    */
+    virtual void
+    findContours(InputArray srcImg, ContoursVector &contours) const;
+
+    /// findCandidates
+    /** @brief find posibel candidates
+    * @param contours
+    * @param detectedCharts
+    * @param minContourLengthAllowed
+    */
+    virtual void
+    findCandidates(const ContoursVector &contours, std::vector<CChart> &detectedCharts);
+
+    /// clustersAnalysis
+    /** @brief clusters charts analysis
+    * @param detectedCharts
+    * @param groups
+    */
+    virtual void
+    clustersAnalysis(const std::vector<CChart> &detectedCharts, std::vector<int> &groups);
+
+    /// checkerRecognize
+    /** @brief checker color recognition
+    * @param img
+    * @param detectedCharts
+    * @param G
+    * @param colorChartsOut
+    */
+    virtual void
+    checkerRecognize(InputArray img, const std::vector<CChart> &detectedCharts, const std::vector<int> &G,
+                     std::vector<std::vector<Point2f>> &colorChartsOut);
+
+    /// checkerAnalysis
+    /** @brief evaluate checker
+    * @param img
+    * @param img_org
+    * @param colorCharts
+    * @param checker
+    * @param asp
+    */
+    virtual void
+    checkerAnalysis(InputArray img_rgb_f, const unsigned int nc,
+                    const std::vector<std::vector<Point2f>> &colorCharts,
+                    std::vector<Ptr<CChecker>> &checkers, float asp,
+                    const Mat &img_rgb_org,
+                    const Mat &img_ycbcr_org,
+                    std::vector<Mat> &rgb_planes,
+                    std::vector<Mat> &ycbcr_planes,
+                    const Point2f& offset);
+
+    virtual void
+    removeTooCloseDetections();
+
+protected:
+    std::vector<Ptr<CChecker>> m_checkers;
+#ifdef HAVE_OPENCV_DNN
+    dnn::Net net;
+    bool m_useDnn = true;
+#else
+    bool m_useDnn = false;
+#endif
+    DetectorParametersMCC m_params = DetectorParametersMCC();
+    ColorChart m_chartType;
+
+private: // methods aux
+    void get_subbox_chart_physical(
+        const std::vector<Point2f> &points,
+        std::vector<Point2f> &chartPhy);
+
+    void reduce_array(
+        const std::vector<float> &x,
+        std::vector<float> &x_new,
+        float tol);
+
+    void transform_points_inverse(
+        InputArray T,
+        const std::vector<Point2f> &X,
+        std::vector<Point2f> &Xt);
+
+    void get_profile(
+        const std::vector<Point2f> &ibox,
+        OutputArray charts_rgb,
+        OutputArray charts_ycbcr,
+        InputArray im_rgb,
+        InputArray im_ycbcr,
+        std::vector<Mat> &rgb_planes,
+        std::vector<Mat> &ycbcr_planes);
+
+    /** @brief cost function
+     *  e(p) = ||f(p)||^2 = \sum_k (mu_{k,p}*r_k')/||mu_{k,p}||||r_k|| + ...
+     *                   + \sum_k || \sigma_{k,p} ||^2
+     */
+    float cost_function(InputArray img, InputOutputArray mask, InputArray lab,
+                        const std::vector<Point2f> &ibox);
+};
+
+} // namespace mcc
+} // namespace cv
+
+#endif //_MCC_CHECKER_DETECTOR_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp b/upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp
new file mode 100644
index 0000000..7f8fae2
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/checker_model.cpp
@@ -0,0 +1,487 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+
+#include "checker_model.hpp"
+#include "dictionary.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+
+///////////////////////////////////////////////////////////////////////////////
+/// CChartModel
+CChartModel::CChartModel(const ColorChart chartType)
+{
+    switch (chartType)
+    {
+    case MCC24: //Standard
+        size = Size2i(4, 6);
+        boxsize = Size2f(11.25, 16.75);
+        box.resize(4);
+        box[0] = Point2f(0.00, 0.00);
+        box[1] = Point2f(16.75, 0.00);
+        box[2] = Point2f(16.75, 11.25);
+        box[3] = Point2f(0.00, 11.25);
+
+        cellchart.assign(CChartClassicModelCellchart, CChartClassicModelCellchart + 4 * 24);
+        center.assign(CChartClassicModelCenter, CChartClassicModelCenter + 24);
+
+        chart.resize(size.area(), std::vector<float>(9));
+        for(int color = 0 ; color < (int)chart.size() ; color++)
+            chart[color].assign(CChartClassicModelColors[color] , CChartClassicModelColors[color] + 9 );
+
+        break;
+    case SG140: //DigitalSG
+        size = Size2i(10, 14);
+        boxsize = Size2f(27.75, 38.75);
+        box.resize(4);
+        box[0] = Point2f(0.00, 0.00);
+        box[1] = Point2f(38.75, 0.00);
+        box[2] = Point2f(38.75, 27.75);
+        box[3] = Point2f(0.00, 27.75);
+
+        cellchart.assign(CChartDigitalSGCellchart, CChartDigitalSGCellchart + 4 * 140);
+        center.assign(CChartDigitalSGCenter, CChartDigitalSGCenter + 140);
+
+        chart.resize(size.area(), std::vector<float>(9));
+        for(int color = 0 ; color < (int)chart.size() ; color++)
+            chart[color].assign(CChartDigitalSGColors[color] , CChartDigitalSGColors[color] + 9 );
+
+        break;
+    case VINYL18: //Vinyl
+        size = Size2i(3, 6);
+        boxsize = Size2f(12.50, 18.25);
+        box.resize(4);
+        box[0] = Point2f(0.00, 0.00);
+        box[1] = Point2f(18.25, 0.00);
+        box[2] = Point2f(18.25, 12.50);
+        box[3] = Point2f(0.00, 12.50);
+
+        cellchart.assign(CChartVinylCellchart, CChartVinylCellchart + 4 * 18);
+        center.assign(CChartVinylCenter, CChartVinylCenter + 18);
+
+        chart.resize(size.area(), std::vector<float>(9));
+        for(int color = 0 ; color < (int)chart.size() ; color++)
+            chart[color].assign(CChartVinylColors[color] , CChartVinylColors[color] + 9 );
+
+        break;
+    }
+}
+
+CChartModel::~CChartModel()
+{
+}
+
+bool CChartModel::
+    evaluate(const SUBCCMModel &subModel, int &offset, int &iTheta, float &error)
+{
+
+    float tError;
+    int tTheta, tOffset;
+    error = INFINITY;
+    bool beval = false;
+
+    // para todas las orientaciones
+    // min_{ theta,dt } | CC_e - CC |
+    for (tTheta = 0; tTheta < 8; tTheta++)
+    {
+        if (match(subModel, tTheta, tError, tOffset) && tError < error)
+        {
+            error = tError;
+            iTheta = tTheta;
+            offset = tOffset;
+            beval = true;
+        }
+    }
+
+    return beval;
+}
+
+void CChartModel::
+    copyToColorMat(OutputArray lab, int cs)
+{
+    size_t N, M, k;
+
+    N = size.width;
+    M = size.height;
+    Mat im_lab_org((int)N, (int)M, CV_32FC3);
+    int type_color = 3 * cs;
+    k = 0;
+
+    for (size_t i = 0; i < N; i++)
+    {
+        for (size_t j = 0; j < M; j++)
+        {
+            Vec3f &lab_values = im_lab_org.at<Vec3f>((int)i, (int)j);
+            lab_values[0] = chart[k][type_color + 0];
+            lab_values[1] = chart[k][type_color + 1];
+            lab_values[2] = chart[k][type_color + 2];
+            k++;
+        }
+    }
+
+    lab.assign(im_lab_org);
+}
+
+void mcc::CChartModel::
+    rotate90()
+{
+
+    size = Size2i(size.height, size.width);
+
+    //the matrix is roated clockwise 90 degree, so first row will become last column, second row second last column and so on
+    //doing this inplace will make the code a bit hard to read, so creating a temporary array
+
+    std::vector<Point2f> _cellchart(cellchart.size());
+    std::vector<Point2f> _center(center.size());
+
+    int k = 0;
+    for (int i = 0; i < size.width; i++)
+    {
+        for (int j = 0; j < size.height; j++)
+        {
+            //k contains the new coordintes,
+            int old_i = size.height - j - 1;
+            int old_j = i;
+            int old_k = (old_i)*size.width + old_j;
+
+            _cellchart[4 * k + 0] = cellchart[4 * old_k + 3];
+            _cellchart[4 * k + 1] = cellchart[4 * old_k + 0];
+            _cellchart[4 * k + 2] = cellchart[4 * old_k + 1];
+            _cellchart[4 * k + 3] = cellchart[4 * old_k + 2];
+
+            // center
+            _center[k] = center[old_k];
+            k++;
+        }
+    }
+    cellchart = _cellchart;
+    center = _center;
+
+    boxsize = Size2f(boxsize.height, boxsize.width);
+}
+
+void mcc::CChartModel::
+    flip()
+{
+
+    std::vector<Point2f> _cellchart(cellchart.size());
+    std::vector<Point2f> _center(center.size());
+
+    int k = 0;
+    for (int i = 0; i < size.width; i++)
+    {
+        for (int j = 0; j < size.height; j++)
+        {
+            //k contains the new coordintes,
+            int old_i = i;
+            int old_j = size.height - j - 1;
+            int old_k = (old_i)*size.height + old_j;
+
+            _cellchart[4 * k + 0] = cellchart[4 * old_k + 1];
+            _cellchart[4 * k + 1] = cellchart[4 * old_k + 0];
+            _cellchart[4 * k + 2] = cellchart[4 * old_k + 3];
+            _cellchart[4 * k + 3] = cellchart[4 * old_k + 2];
+
+            // center
+            _center[k] = center[old_k];
+            k++;
+        }
+    }
+    cellchart = _cellchart;
+    center = _center;
+}
+
+float CChartModel::
+    dist_color_lab(InputArray lab1, InputArray lab2)
+{
+
+    int N = lab1.rows();
+    float dist = 0, dist_i;
+
+    Mat _lab1 = lab1.getMat(), _lab2 = lab2.getMat();
+    for (int i = 0; i < N; i++)
+    {
+        Vec3f v1 = _lab1.at<Vec3f>(i, 0);
+        Vec3f v2 = _lab2.at<Vec3f>(i, 0);
+        // v1[0] = 1;
+        // v2[0] = 1; // L <- 0
+
+        // euclidean
+        Vec3f v = v1 - v2;
+        dist_i = v.dot(v);
+        dist += sqrt(dist_i);
+
+        // cosine
+        //float costh = v1.dot(v2) / (norm(v1)*norm(v2));
+        //dist += 1 - (1 + costh) / 2;
+    }
+
+    dist /= N;
+    return dist;
+}
+
+bool CChartModel::
+    match(const SUBCCMModel &subModel, int iTheta, float &error, int &ierror)
+{
+
+    size_t N, M, k;
+
+    N = size.width;
+    M = size.height;
+    Mat im_lab_org((int)N, (int)M, CV_32FC3);
+    int type_color = 3;
+    k = 0;
+
+    for (size_t i = 0; i < N; i++)
+    {
+        for (size_t j = 0; j < M; j++)
+        {
+            Vec3f &lab = im_lab_org.at<Vec3f>((int)i, (int)j);
+            lab[0] = chart[k][type_color + 0];
+            lab[1] = chart[k][type_color + 1];
+            lab[2] = chart[k][type_color + 2];
+            k++;
+        }
+    }
+
+    rot90(im_lab_org, iTheta);
+    N = im_lab_org.rows;
+    M = im_lab_org.cols;
+
+    size_t n, m;
+    n = subModel.color_size.height;
+    m = subModel.color_size.width;
+
+    // boundary condition
+    if (N < n || M < m)
+        return false;
+
+    // rgb to La*b*
+    Mat rgb_est = subModel.sub_chart;
+    Mat lab_est;
+
+    cvtColor(rgb_est, lab_est, COLOR_BGR2Lab);
+
+    size_t nN, mM;
+    nN = N - n + 1;
+    mM = M - m + 1;
+    std::vector<float> lEcm(nN * mM);
+    k = 0;
+    for (size_t i = 0; i < nN; i++)
+    {
+        for (size_t j = 0; j < mM; j++)
+        {
+            Mat lab_curr, lab_roi;
+            lab_roi = im_lab_org(Rect((int)j, (int)i, (int)m, (int)n));
+            lab_roi.copyTo(lab_curr);
+            lab_curr = lab_curr.t();
+            lab_curr = lab_curr.reshape(3, (int)n * (int)m);
+
+            // Mean squared error
+            // ECM = 1 / N sum_i(Y - Yp) ^ 2
+            lEcm[k] = dist_color_lab(lab_curr, lab_est) / (M * N);
+            k++;
+        }
+    }
+
+    // minimo
+    error = lEcm[0];
+    ierror = 0;
+    for (int i = 1; i < (int)lEcm.size(); i++)
+        if (error > lEcm[i])
+        {
+            error = lEcm[i];
+            ierror = i;
+        }
+
+    return true;
+}
+
+void CChartModel::
+    rot90(InputOutputArray mat, int itheta)
+{
+
+    //1=CW, 2=CCW, 3=180
+    switch (itheta)
+    {
+    case 1: //transpose+flip(1)=CW
+        transpose(mat, mat);
+        cv::flip(mat, mat, 1);
+        break;
+    case 2: //flip(-1)=180
+        cv::flip(mat, mat, -1);
+        break;
+    case 3: //transpose+flip(0)=CCW
+        transpose(mat, mat);
+        cv::flip(mat, mat, 0);
+        break;
+    //flipped images start here
+    case 4: //flip(1)=no rotation, just flipped
+        cv::flip(mat, mat, 1);
+        break;
+    case 5: //flip(1)+transpose + flip(1)=CW
+        cv::flip(mat, mat, 1);
+        transpose(mat, mat);
+        cv::flip(mat, mat, 1);
+        break;
+    case 6: //flip(1)+flip(-1)=180
+        cv::flip(mat, mat, 1);
+        cv::flip(mat, mat, -1);
+        break;
+    case 7: //flip(1)+transpose+flip(0)=CCW
+        cv::flip(mat, mat, 1);
+        transpose(mat, mat);
+        cv::flip(mat, mat, 0);
+        break;
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// // CChecker
+
+Ptr<CChecker> CChecker::create()
+{
+    return makePtr<CCheckerImpl>();
+}
+
+void CCheckerImpl::setTarget(ColorChart _target)
+{
+    target = _target;
+}
+void CCheckerImpl::setBox(std::vector<Point2f> _box)
+{
+    box = _box;
+}
+void CCheckerImpl::setChartsRGB(Mat _chartsRGB)
+{
+    chartsRGB = _chartsRGB;
+}
+void CCheckerImpl::setChartsYCbCr(Mat _chartsYCbCr)
+{
+    chartsYCbCr = _chartsYCbCr;
+}
+void CCheckerImpl::setCost(float _cost)
+{
+    cost = _cost;
+}
+void CCheckerImpl::setCenter(Point2f _center)
+{
+    center = _center;
+}
+
+ColorChart CCheckerImpl::getTarget()
+{
+    return target;
+}
+std::vector<Point2f> CCheckerImpl::getBox()
+{
+    return box;
+}
+std::vector<Point2f> CCheckerImpl::getColorCharts()
+{
+    // color chart classic model
+    CChartModel cccm(getTarget());
+    Mat lab;
+    size_t N;
+    std::vector<Point2f> fbox = cccm.box;
+    std::vector<Point2f> cellchart = cccm.cellchart;
+    std::vector<Point2f> charts(cellchart.size());
+
+    // tranformation
+    Matx33f ccT = getPerspectiveTransform(fbox, getBox());
+
+    std::vector<Point2f> bch(4), bcht(4);
+    N = cellchart.size() / 4;
+    for (size_t i = 0, k; i < N; i++)
+    {
+        k = 4 * i;
+        for (size_t j = 0ull; j < 4ull; j++)
+            bch[j] = cellchart[k + j];
+
+        polyanticlockwise(bch);
+        transform_points_forward(ccT, bch, bcht);
+
+        Point2f c(0, 0);
+        for (size_t j = 0; j < 4; j++)
+            c += bcht[j];
+        c /= 4;
+        for (size_t j = 0ull; j < 4ull; j++)
+            charts[k+j] = ((bcht[j] - c) * 0.50) + c;
+    }
+    return charts;
+}
+Mat CCheckerImpl::getChartsRGB(bool getStats /* = true */)
+{
+    if (!getStats){
+        Mat src = chartsRGB.col(1).clone().reshape(3, chartsRGB.rows/3);
+        return src;
+    }
+    return chartsRGB;
+}
+Mat CCheckerImpl::getChartsYCbCr()
+{
+    return chartsYCbCr;
+}
+float CCheckerImpl::getCost()
+{
+    return cost;
+}
+Point2f CCheckerImpl::getCenter()
+{
+    return center;
+}
+
+void transform_points_forward(const Matx33f& T, const std::vector<Point2f> &X, std::vector<Point2f> &Xt)
+{
+    size_t N = X.size();
+    if (Xt.size() != N)
+        Xt.resize(N);
+    std::fill(Xt.begin(), Xt.end(), Point2f(0.f, 0.f));
+    if (N == 0)
+        return;
+
+    Matx31f p, xt;
+    Point2f pt;
+    for (size_t i = 0; i < N; i++)
+    {
+        p(0, 0) = X[i].x;
+        p(1, 0) = X[i].y;
+        p(2, 0) = 1;
+        xt = T * p;
+        pt.x = xt(0, 0) / xt(2, 0);
+        pt.y = xt(1, 0) / xt(2, 0);
+        Xt[i] = pt;
+    }
+}
+
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/checker_model.hpp b/upstream/opencv/modules/objdetect/src/mcc/checker_model.hpp
new file mode 100644
index 0000000..3da5206
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/checker_model.hpp
@@ -0,0 +1,161 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_CHECKER_MODEL_HPP
+#define _MCC_CHECKER_MODEL_HPP
+
+namespace cv
+{
+namespace mcc
+{
+
+//! @addtogroup mcc
+//! @{
+
+/** CChartModel
+      *
+      * @brief Class for handing the different chart models.
+      *
+      *  This class contains the variables and functions which are specific
+      *  to a given chart type and will be used for it detections.
+
+      */
+
+class CChartModel
+{
+
+public:
+    /** SUBCCMModel
+        *
+        * @brief Information about a continuous subregion of the chart.
+        *
+        * Usually not all the cells of the chart can be detected by the
+        * detector. This submodel contains the information about the
+        * detected squares.
+        */
+
+    typedef struct
+        _SUBCCMModel
+    {
+
+        Mat sub_chart;
+        Size2i color_size;
+        std::vector<Point2f> centers;
+
+    } SUBCCMModel;
+
+public:
+    CChartModel(const ColorChart chartType);
+    ~CChartModel();
+
+    /** @brief evaluate submodel in this checker type*/
+    bool evaluate(const SUBCCMModel &subModel, int &offset, int &iTheta, float &error);
+
+    // function utils
+
+    void copyToColorMat(OutputArray lab, int cs = 0);
+    void rotate90();
+    void flip();
+
+public:
+    // Cie L*a*b* values use illuminant D50 2 degree observer sRGB values for
+    // for iluminante D65.
+
+    Size2i size;
+    Size2f boxsize;
+    std::vector<Point2f> box;
+    std::vector<Point2f> cellchart;
+    std::vector<Point2f> center;
+    std::vector<std::vector<float>> chart;
+
+protected:
+    /** \brief match checker color
+          * \param[in] subModel sub-checker
+          * \param[in] iTheta angle
+          * \param[out] error
+          * \param[out] ierror
+          * \return state
+          */
+    bool match(const SUBCCMModel &subModel, int iTheta, float &error, int &ierror);
+
+    /** \brief euclidian dist L2 for Lab space
+          * \note
+          * \f$ \sum_i \sqrt (\sum_k (ab1-ab2)_k.^2) \f$
+          * \param[in] lab1
+          * \param[in] lab2
+          * \return distance
+          */
+    float dist_color_lab(InputArray lab1, InputArray lab2);
+
+    /** \brief rotate matrix 90 degree */
+    void rot90(InputOutputArray mat, int itheta);
+};
+/** CChecker
+ *
+ * \brief checker model
+ * \author Pedro Marrero Fernandez
+ *
+ */
+class CCheckerImpl : public CChecker
+{
+public:
+public:
+    CCheckerImpl() {}
+    ~CCheckerImpl() {}
+
+    void setTarget(ColorChart _target)  CV_OVERRIDE;
+    void setBox(std::vector<Point2f> _box) CV_OVERRIDE;
+    void setChartsRGB(Mat _chartsRGB) CV_OVERRIDE;
+    void setChartsYCbCr(Mat _chartsYCbCr) CV_OVERRIDE;
+    void setCost(float _cost) CV_OVERRIDE;
+    void setCenter(Point2f _center) CV_OVERRIDE;
+
+    ColorChart getTarget() CV_OVERRIDE;
+    std::vector<Point2f> getBox() CV_OVERRIDE;
+    std::vector<Point2f> getColorCharts() CV_OVERRIDE;
+    Mat getChartsRGB(bool getStats = true) CV_OVERRIDE;
+    Mat getChartsYCbCr() CV_OVERRIDE;
+    float getCost() CV_OVERRIDE;
+    Point2f getCenter() CV_OVERRIDE;
+
+private:
+    ColorChart target;             ///< type of checkercolor
+    std::vector<Point2f> box; ///< positions of the corners
+    Mat chartsRGB;             ///< charts profile in rgb color space
+    Mat chartsYCbCr;         ///< charts profile in YCbCr color space
+    float cost;                     ///< cost to aproximate
+    Point2f center;             ///< center of the chart.
+};
+// @}
+
+void transform_points_forward(const Matx33f& T, const std::vector<Point2f> &X, std::vector<Point2f> &Xt);
+
+} // namespace mcc
+} // namespace cv
+
+#endif //_MCC_CHECKER_MODEL_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/common.cpp b/upstream/opencv/modules/objdetect/src/mcc/common.cpp
new file mode 100644
index 0000000..5b9eddf
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/common.cpp
@@ -0,0 +1,111 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+#include "common.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+Rect poly2mask(const std::vector<Point2f> &poly, Size size, InputOutputArray mask)
+{
+    // Create Polygon from vertices
+    std::vector<Point> roi_poly;
+    approxPolyDP(poly, roi_poly, 1.0, true);
+
+    Rect roi = boundingRect(roi_poly);
+
+    // Fill polygon white
+    fillConvexPoly(mask, &roi_poly[0], (int)roi_poly.size(), 1, 8, 0);
+
+    roi &= Rect(0, 0, size.width, size.height);
+    if (roi.empty())
+        roi = Rect(0, 0, 1, 1);
+    return roi;
+}
+
+float perimeter(const std::vector<Point2f> &ps)
+{
+    float sum = 0, dx, dy;
+
+    for (size_t i = 0; i < ps.size(); i++)
+    {
+        int i2 = (i + 1) % (int)ps.size();
+
+        dx = ps[i].x - ps[i2].x;
+        dy = ps[i].y - ps[i2].y;
+
+        sum += sqrt(dx * dx + dy * dy);
+    }
+
+    return sum;
+}
+
+Point2f
+mace_center(const std::vector<Point2f> &ps)
+{
+    Point2f center;
+    int n;
+
+    center = Point2f(0);
+    n = (int)ps.size();
+    for (int i = 0; i < n; i++)
+        center += ps[i];
+    center /= n;
+
+    return center;
+}
+
+void polyanticlockwise(std::vector<Point2f> &points)
+{
+    // Sort the points in anti-clockwise order
+    // Trace a line between the first and second point.
+    // If the third point is at the right side, then the points are anti-clockwise
+    Point2f v1 = points[1] - points[0];
+    Point2f v2 = points[2] - points[0];
+
+    //if the third point is in the left side, then sort in anti-clockwise order
+    if ((v1.x * v2.y) - (v1.y * v2.x) < 0.0)
+        std::swap(points[1], points[3]);
+}
+void polyclockwise(std::vector<Point2f> &points)
+{
+    // Sort the points in clockwise order
+    // Trace a line between the first and second point.
+    // If the third point is at the right side, then the points are clockwise
+    Point2f v1 = points[1] - points[0];
+    Point2f v2 = points[2] - points[0];
+
+    //if the third point is in the left side, then sort in clockwise order
+    if ((v1.x * v2.y) - (v1.y * v2.x) > 0.0)
+        std::swap(points[1], points[3]);
+}
+
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/common.hpp b/upstream/opencv/modules/objdetect/src/mcc/common.hpp
new file mode 100644
index 0000000..12c5bb7
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/common.hpp
@@ -0,0 +1,133 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_COMMON_HPP
+#define _MCC_COMMON_HPP
+
+namespace cv
+{
+namespace mcc
+{
+
+Rect poly2mask(const std::vector<Point2f> &poly, Size size, InputOutputArray mask);
+
+template <typename T>
+void circshift(std::vector<T> &A, int shiff)
+{
+    if (A.empty() || shiff < 1)
+        return;
+    int n = A.size();
+
+    if (shiff >= n)
+        return;
+
+    std::vector<T> Tmp(n);
+    for (int i = shiff; i < n + shiff; i++)
+        Tmp[(i % n)] = A[i - shiff];
+
+    A = Tmp;
+}
+
+float perimeter(const std::vector<Point2f> &ps);
+
+Point2f mace_center(const std::vector<Point2f> &ps);
+
+template <typename T>
+void unique(const std::vector<T> &A, std::vector<T> &U)
+{
+
+    int n = (int)A.size();
+    std::vector<T> Tm = A;
+
+    std::sort(Tm.begin(), Tm.end());
+
+    U.clear();
+    U.push_back(Tm[0]);
+    for (int i = 1; i < n; i++)
+        if (Tm[i] != Tm[i - 1])
+            U.push_back(Tm[i]);
+}
+
+void polyanticlockwise(std::vector<Point2f> &points);
+void polyclockwise(std::vector<Point2f> &points);
+
+// Does lexical cast of the input argument to string
+template <typename T>
+std::string ToString(const T &value)
+{
+    std::ostringstream stream;
+    stream << value;
+    return stream.str();
+}
+
+template <typename T>
+void change(T &a, T &b)
+{
+    T c = a;
+    a = b;
+    b = c;
+}
+
+template <typename T>
+void sort(std::vector<T> &A, std::vector<int> &idx, bool ord = true)
+{
+    size_t N = A.size();
+    if (N == 0)
+        return;
+
+    idx.clear();
+    idx.resize(N);
+    for (size_t i = 0; i < N; i++)
+        idx[i] = (int)i;
+
+    for (size_t i = 0; i < N - 1; i++)
+    {
+
+        size_t k = i;
+        T valor = A[i];
+        for (size_t j = i + 1; j < N; j++)
+        {
+            if ((A[j] < valor && ord) || (A[j] > valor && !ord))
+            {
+                valor = A[j];
+                k = j;
+            }
+        }
+
+        if (k == i)
+            continue;
+
+        change(A[i], A[k]);
+        change(idx[i], idx[k]);
+    }
+}
+
+} // namespace mcc
+} // namespace cv
+
+#endif //_MCC_COMMON_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/debug.cpp b/upstream/opencv/modules/objdetect/src/mcc/debug.cpp
new file mode 100644
index 0000000..15d353a
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/debug.cpp
@@ -0,0 +1,68 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+#include "debug.hpp"
+
+#ifdef MCC_DEBUG
+
+#include <opencv2/highgui.hpp>
+
+namespace cv
+{
+namespace mcc
+{
+Scalar randomcolor(RNG &rng)
+{
+    int icolor = (unsigned)rng;
+    return Scalar(icolor & 255, (icolor >> 8) & 255, (icolor >> 16) & 255);
+}
+
+void imshow_250xN(const std::string &name_, InputArray patch)
+{
+
+    Mat bigpatch;
+    Size size = patch.size();
+    float asp = (float)size.height / size.width;
+    int new_size = 550;
+    resize(patch, bigpatch, Size((int)new_size, int(new_size * asp)));
+    imshow(name_, bigpatch);
+}
+
+void showAndSave(std::string name, InputArray m, std::string path)
+{
+    imshow_250xN(name, m);
+    imwrite(path + "/" + name + ".png", m);
+    if (waitKey(0) == 'q')
+        return;
+}
+
+} // namespace mcc
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/mcc/debug.hpp b/upstream/opencv/modules/objdetect/src/mcc/debug.hpp
new file mode 100644
index 0000000..8bf5333
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/debug.hpp
@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_DEBUG_HPP
+#define _MCC_DEBUG_HPP
+
+#include "opencv2/objdetect/mcc_checker_detector.hpp"
+#ifdef MCC_DEBUG
+
+namespace cv
+{
+namespace mcc
+{
+
+Scalar randomcolor(RNG &rng);
+
+void imshow_250xN(const std::string &name_, InputArray patch);
+
+void showAndSave(std::string name, InputArray m, std::string path);
+} // namespace mcc
+} // namespace cv
+
+#endif
+
+#endif //_MCC_DEBUG_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/dictionary.hpp b/upstream/opencv/modules/objdetect/src/mcc/dictionary.hpp
new file mode 100644
index 0000000..2cc1290
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/dictionary.hpp
@@ -0,0 +1,1187 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_DICTIONARY_HPP
+#define _MCC_DICTIONARY_HPP
+
+
+
+namespace cv
+{
+namespace mcc
+{
+///////////////////////////////////////////////////////////////////////////////
+/// CChartClassicModel
+const float CChartClassicModelColors[24][9] = {
+
+    //       sRGB              CIE L*a*b*             Munsell Notation
+    // ---------------  ------------------------     Hue Value / Chroma
+    // R     G      B        L*      a*       b*
+    {115.0f, 82.0f, 68.0f, 37.986f, 13.555f, 14.059f, 3.00f, 3.70f, 3.2f},    //1.  dark shin
+    {194.0f, 150.0f, 130.0f, 65.711f, 18.130f, 17.810f, 2.20f, 6.47f, 4.1f},  //2.  light skin
+    {98.0f, 122.0f, 157.0f, 49.927f, -4.880f, -21.925f, 4.30f, 4.95f, 5.0f},  //3.  blue skin
+    {87.0f, 108.0f, 67.0f, 43.139f, -13.095f, 21.905f, 6.70f, 4.20f, 4.1f},   //4.  foliage
+    {133.0f, 128.0f, 177.0f, 55.112f, 8.844f, -25.399f, 9.70f, 5.47f, 6.7f},  //5.  blue flower
+    {103.0f, 189.0f, 170.0f, 70.719f, -33.395f, 0.199f, 2.50f, 7.00f, 6.0f},  //6.  bluish green
+    {214.0f, 126.0f, 44.0f, 62.661f, 36.067f, 57.096f, 5.00f, 6.00f, 11.0f},  //7.  orange
+    {80.0f, 91.0f, 166.0f, 40.020f, 10.410f, -45.964f, 7.50f, 4.00f, 10.7f},  //8.  purplish blue
+    {193.0f, 90.0f, 99.0f, 51.124f, 48.239f, 16.248f, 2.50f, 5.00f, 10.0f},   //9.  moderate red
+    {94.0f, 60.0f, 108.0f, 30.325f, 22.976f, -21.587f, 5.00f, 3.00f, 7.0f},   //10. purple
+    {157.0f, 188.0f, 64.0f, 72.532f, -23.709f, 57.255f, 5.00f, 7.10f, 9.1f},  //11. yelow green
+    {224.0f, 163.0f, 46.0f, 71.941f, 19.363f, 67.857f, 10.00f, 7.00f, 10.5f}, //12. orange yellow
+    {56.0f, 61.0f, 150.0f, 28.778f, 14.179f, -50.297f, 7.50f, 2.90f, 12.7f},  //13. blue
+    {70.0f, 148.0f, 73.0f, 55.261f, -38.342f, 31.370f, 0.25f, 5.40f, 8.65f},  //14. green
+    {175.0f, 54.0f, 60.0f, 42.101f, 53.378f, 28.190f, 5.00f, 4.00f, 12.0f},   //15. red
+    {231.0f, 199.0f, 31.0f, 81.733f, 4.039f, 79.819f, 5.00f, 8.00f, 11.1f},   //16. yellow
+    {187.0f, 86.0f, 149.0f, 51.935f, 49.986f, -14.574f, 2.50f, 5.00f, 12.0f}, //17. magenta
+    {8.0f, 133.0f, 161.0f, 51.038f, -28.631f, -28.638f, 5.00f, 5.00f, 8.0f},  //18. cyan
+    {243.0f, 243.0f, 242.0f, 96.539f, -0.425f, 1.186f, 0.00f, 9.50f, 0.0f},   //19. white(.05*)
+    {200.0f, 200.0f, 200.0f, 81.257f, -0.638f, -0.335f, 0.00f, 8.00f, 0.0f},  //20. neutral 8(.23*)
+    {160.0f, 160.0f, 160.0f, 66.766f, -0.734f, -0.504f, 0.00f, 6.50f, 0.0f},  //21. neutral 6.5(.44*)
+    {122.0f, 122.0f, 121.0f, 50.867f, -0.153f, -0.270f, 0.00f, 5.00f, 0.0f},  //22. neutral 5(.70*)
+    {85.0f, 85.0f, 85.0f, 35.656f, -0.421f, -1.231f, 0.00f, 3.50f, 0.0f},     //23. neutral 3.5(.1.05*)
+    {52.0f, 52.0f, 52.0f, 20.461f, -0.079f, -0.973f, 0.00f, 2.00f, 0.0f},     //24. black(1.50*)
+
+};
+
+const Point2f CChartClassicModelCellchart[96] = {
+    {0.25f, 0.25f},
+    {2.75f, 0.25f},
+    {2.75f, 2.75f},
+    {0.25f, 2.75f},
+    {3.00f, 0.25f},
+    {5.50f, 0.25f},
+    {5.50f, 2.75f},
+    {3.00f, 2.75f},
+    {5.75f, 0.25f},
+    {8.25f, 0.25f},
+    {8.25f, 2.75f},
+    {5.75f, 2.75f},
+    {8.50f, 0.25f},
+    {11.00f, 0.25f},
+    {11.00f, 2.75f},
+    {8.50f, 2.75f},
+    {11.25f, 0.25f},
+    {13.75f, 0.25f},
+    {13.75f, 2.75f},
+    {11.25f, 2.75f},
+    {14.00f, 0.25f},
+    {16.50f, 0.25f},
+    {16.50f, 2.75f},
+    {14.00f, 2.75f},
+    {0.25f, 3.00f},
+    {2.75f, 3.00f},
+    {2.75f, 5.50f},
+    {0.25f, 5.50f},
+    {3.00f, 3.00f},
+    {5.50f, 3.00f},
+    {5.50f, 5.50f},
+    {3.00f, 5.50f},
+    {5.75f, 3.00f},
+    {8.25f, 3.00f},
+    {8.25f, 5.50f},
+    {5.75f, 5.50f},
+    {8.50f, 3.00f},
+    {11.00f, 3.00f},
+    {11.00f, 5.50f},
+    {8.50f, 5.50f},
+    {11.25f, 3.00f},
+    {13.75f, 3.00f},
+    {13.75f, 5.50f},
+    {11.25f, 5.50f},
+    {14.00f, 3.00f},
+    {16.50f, 3.00f},
+    {16.50f, 5.50f},
+    {14.00f, 5.50f},
+    {0.25f, 5.75f},
+    {2.75f, 5.75f},
+    {2.75f, 8.25f},
+    {0.25f, 8.25f},
+    {3.00f, 5.75f},
+    {5.50f, 5.75f},
+    {5.50f, 8.25f},
+    {3.00f, 8.25f},
+    {5.75f, 5.75f},
+    {8.25f, 5.75f},
+    {8.25f, 8.25f},
+    {5.75f, 8.25f},
+    {8.50f, 5.75f},
+    {11.00f, 5.75f},
+    {11.00f, 8.25f},
+    {8.50f, 8.25f},
+    {11.25f, 5.75f},
+    {13.75f, 5.75f},
+    {13.75f, 8.25f},
+    {11.25f, 8.25f},
+    {14.00f, 5.75f},
+    {16.50f, 5.75f},
+    {16.50f, 8.25f},
+    {14.00f, 8.25f},
+    {0.25f, 8.50f},
+    {2.75f, 8.50f},
+    {2.75f, 11.00f},
+    {0.25f, 11.00f},
+    {3.00f, 8.50f},
+    {5.50f, 8.50f},
+    {5.50f, 11.00f},
+    {3.00f, 11.00f},
+    {5.75f, 8.50f},
+    {8.25f, 8.50f},
+    {8.25f, 11.00f},
+    {5.75f, 11.00f},
+    {8.50f, 8.50f},
+    {11.00f, 8.50f},
+    {11.00f, 11.00f},
+    {8.50f, 11.00f},
+    {11.25f, 8.50f},
+    {13.75f, 8.50f},
+    {13.75f, 11.00f},
+    {11.25f, 11.00f},
+    {14.00f, 8.50f},
+    {16.50f, 8.50f},
+    {16.50f, 11.00f},
+    {14.00f, 11.00f},
+
+};
+
+const Point2f CChartClassicModelCenter[24] = {
+    {1.50f, 1.50f},
+    {4.25f, 1.50f},
+    {7.00f, 1.50f},
+    {9.75f, 1.50f},
+    {12.50f, 1.50f},
+    {15.25f, 1.50f},
+    {1.50f, 4.25f},
+    {4.25f, 4.25f},
+    {7.00f, 4.25f},
+    {9.75f, 4.25f},
+    {12.50f, 4.25f},
+    {15.25f, 4.25f},
+    {1.50f, 7.00f},
+    {4.25f, 7.00f},
+    {7.00f, 7.00f},
+    {9.75f, 7.00f},
+    {12.50f, 7.00f},
+    {15.25f, 7.00f},
+    {1.50f, 9.75f},
+    {4.25f, 9.75f},
+    {7.00f, 9.75f},
+    {9.75f, 9.75f},
+    {12.50f, 9.75f},
+    {15.25f, 9.75f},
+
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+/// CChartDigitalSG
+const float CChartDigitalSGColors[140][9] = {
+
+    //       sRGB              CIE L*a*b*             Munsell Notation
+    // ---------------  ------------------------     Hue Value / Chroma
+    // R     G      B        L*      a*       b*
+    {243.6785f, 245.5509f, 243.9088f, 96.55f, -0.91f, 0.57f, -1.0f, -1.0f, -1.0f},
+    {19.8630f, 20.3003f, 20.8469f, 6.43f, -0.06f, -0.41f, -1.0f, -1.0f, -1.0f},
+    {117.8584f, 118.2530f, 118.1025f, 49.7f, -0.18f, 0.03f, -1.0f, -1.0f, -1.0f},
+    {243.5942f, 245.3933f, 243.7273f, 96.5f, -0.89f, 0.59f, -1.0f, -1.0f, -1.0f},
+    {19.9993f, 20.4566f, 21.0413f, 6.5f, -0.06f, -0.44f, -1.0f, -1.0f, -1.0f},
+    {117.7060f, 118.1645f, 118.0348f, 49.66f, -0.2f, 0.01f, -1.0f, -1.0f, -1.0f},
+    {243.6013f, 245.4638f, 243.8033f, 96.52f, -0.91f, 0.58f, -1.0f, -1.0f, -1.0f},
+    {20.1535f, 20.4065f, 20.7898f, 6.49f, -0.02f, -0.28f, -1.0f, -1.0f, -1.0f},
+    {117.8806f, 118.3134f, 118.1353f, 49.72f, -0.2f, 0.04f, -1.0f, -1.0f, -1.0f},
+    {243.4242f, 245.1981f, 243.3717f, 96.43f, -0.91f, 0.67f, -1.0f, -1.0f, -1.0f},
+    {117.8668f, 118.3107f, 118.2028f, 49.72f, -0.19f, 0.0f, -1.0f, -1.0f, -1.0f},
+    {141.3577f, 28.0252f, 95.0288f, 32.6f, 51.58f, -10.85f, -1.0f, -1.0f, -1.0f},
+    {177.5963f, 131.1085f, 179.7258f, 60.75f, 26.22f, -18.6f, -1.0f, -1.0f, -1.0f},
+    {108.2022f, 30.1190f, 128.8980f, 28.69f, 48.28f, -39.00f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 129.2029f, 199.4861f, 49.38f, -15.43f, -48.48f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 162.7924f, 191.4749f, 60.63f, -30.77f, -26.23f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 56.2386f, 55.1200f, 19.29f, -26.37f, -6.15f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 164.6157f, 165.9222f, 60.15f, -41.77f, -12.60f, -1.0f, -1.0f, -1.0f},
+    {58.6915f, 50.1355f, 38.5574f, 21.42f, 1.67f, 8.79f, -1.0f, -1.0f, -1.0f},
+    {117.7814f, 118.2399f, 118.1103f, 49.69f, -0.2f, 0.01f, -1.0f, -1.0f, -1.0f},
+    {19.8846f, 20.4558f, 21.3702f, 6.5f, -0.03f, -0.67f, -1.0f, -1.0f, -1.0f},
+    {64.2572f, 43.9020f, 79.5758f, 21.82f, 17.33f, -18.35f, -1.0f, -1.0f, -1.0f},
+    {91.6752f, 90.6539f, 159.4087f, 41.53f, 18.48f, -37.26f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 51.7097f, 101.8051f, 19.99f, -0.16f, -36.29f, -1.0f, -1.0f, -1.0f},
+    {16.4706f, 156.7786f, 199.5879f, 60.16f, -18.45f, -31.42f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 56.3863f, 78.4458f, 19.94f, -17.92f, -20.96f, -1.0f, -1.0f, -1.0f},
+    {85.8767f, 152.3418f, 203.7400f, 60.68f, -6.05f, -32.81f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 141.8412f, 136.0915f, 50.81f, -49.8f, -9.63f, -1.0f, -1.0f, -1.0f},
+    {73.4809f, 163.3852f, 108.1566f, 60.65f, -39.77f, 20.76f, -1.0f, -1.0f, -1.0f},
+    {20.1214f, 20.5079f, 21.0922f, 6.53f, -0.03f, -0.43f, -1.0f, -1.0f, -1.0f},
+    {243.7254f, 245.5782f, 243.8991f, 96.56f, -0.91f, 0.59f, -1.0f, -1.0f, -1.0f},
+    {198.0681f, 211.7588f, 225.2718f, 84.19f, -1.95f, -8.23f, -1.0f, -1.0f, -1.0f},
+    {239.3827f, 202.2618f, 211.6298f, 84.75f, 14.55f, 0.23f, -1.0f, -1.0f, -1.0f},
+    {169.1422f, 222.5039f, 212.7889f, 84.87f, -19.07f, -0.82f, -1.0f, -1.0f, -1.0f},
+    {243.3181f, 203.6053f, 200.4170f, 85.15f, 13.48f, 6.82f, -1.0f, -1.0f, -1.0f},
+    {209.6511f, 214.2775f, 159.1455f, 84.17f, -10.45f, 26.78f, -1.0f, -1.0f, -1.0f},
+    {215.5821f, 125.8663f, 86.0613f, 61.74f, 31.06f, 36.42f, -1.0f, -1.0f, -1.0f},
+    {202.3497f, 141.5423f, 123.4314f, 64.37f, 20.82f, 18.92f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 140.4951f, 93.3754f, 50.4f, -53.22f, 14.62f, -1.0f, -1.0f, -1.0f},
+    {243.6773f, 245.4176f, 243.6408f, 96.51f, -0.89f, 0.65f, -1.0f, -1.0f, -1.0f},
+    {117.9409f, 118.3590f, 118.2027f, 49.74f, -0.19f, 0.03f, -1.0f, -1.0f, -1.0f},
+    {110.5974f, 62.7615f, 41.3328f, 31.91f, 18.62f, 21.99f, -1.0f, -1.0f, -1.0f},
+    {228.7579f, 115.4417f, 0.0f, 60.74f, 38.66f, 70.97f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 42.4374f, 135.4228f, 19.35f, 22.23f, -58.86f, -1.0f, -1.0f, -1.0f},
+    {243.6376f, 245.4608f, 243.7265f, 96.52f, -0.91f, 0.62f, -1.0f, -1.0f, -1.0f},
+    {20.5471f, 20.7706f, 21.1856f, 6.66f, 0.00f, -0.30f, -1.0f, -1.0f, -1.0f},
+    {239.4052f, 173.7086f, 147.9643f, 76.51f, 20.81f, 22.72f, -1.0f, -1.0f, -1.0f},
+    {241.8648f, 157.2827f, 136.0207f, 72.79f, 29.15f, 24.18f, -1.0f, -1.0f, -1.0f},
+    {12.9473f, 61.0106f, 44.3207f, 22.33f, -20.70f, 5.75f, -1.0f, -1.0f, -1.0f},
+    {117.8245f, 118.2597f, 118.1357f, 49.7f, -0.19f, 0.01f, -1.0f, -1.0f, -1.0f},
+    {19.9625f, 20.5277f, 21.3483f, 6.53f, -0.05f, -0.61f, -1.0f, -1.0f, -1.0f},
+    {198.8077f, 139.4916f, 120.4582f, 63.42f, 20.19f, 19.22f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 81.2537f, 163.8455f, 34.94f, 11.64f, -50.70f, -1.0f, -1.0f, -1.0f},
+    {54.9984f, 141.2109f, 51.9967f, 52.03f, -44.15f, 39.04f, -1.0f, -1.0f, -1.0f},
+    {197.1775f, 196.5945f, 197.0767f, 79.43f, 0.29f, -0.17f, -1.0f, -1.0f, -1.0f},
+    {71.5553f, 72.2783f, 72.9901f, 30.67f, -0.14f, -0.53f, -1.0f, -1.0f, -1.0f},
+    {193.4891f, 143.5716f, 108.3919f, 63.6f, 14.44f, 26.07f, -1.0f, -1.0f, -1.0f},
+    {191.7291f, 146.0328f, 126.4483f, 64.37f, 14.50f, 17.05f, -1.0f, -1.0f, -1.0f},
+    {9.3958f, 163.8812f, 128.3477f, 60.01f, -44.33f, 8.49f, -1.0f, -1.0f, -1.0f},
+    {20.3474f, 20.7197f, 21.3632f, 6.63f, -0.01f, -0.47f, -1.0f, -1.0f, -1.0f},
+    {243.6841f, 245.5904f, 243.8984f, 96.56f, -0.93f, 0.59f, -1.0f, -1.0f, -1.0f},
+    {67.5763f, 114.3549f, 150.4402f, 46.37f, -5.09f, -24.46f, -1.0f, -1.0f, -1.0f},
+    {195.8311f, 65.0081f, 80.2132f, 47.08f, 52.97f, 20.49f, -1.0f, -1.0f, -1.0f},
+    {178.5490f, 0.0f, 27.2862f, 36.04f, 64.92f, 38.51f, -1.0f, -1.0f, -1.0f},
+    {157.5618f, 157.8520f, 158.3960f, 65.05f, 0.00f, -0.32f, -1.0f, -1.0f, -1.0f},
+    {93.9493f, 94.6924f, 95.1781f, 40.14f, -0.19f, -0.38f, -1.0f, -1.0f, -1.0f},
+    {141.2464f, 92.1355f, 59.0432f, 43.77f, 16.46f, 27.12f, -1.0f, -1.0f, -1.0f},
+    {195.4679f, 144.4185f, 127.4304f, 64.39f, 17.00f, 16.59f, -1.0f, -1.0f, -1.0f},
+    {116.6521f, 159.0566f, 69.5398f, 60.79f, -29.74f, 41.50f, -1.0f, -1.0f, -1.0f},
+    {243.5820f, 245.3320f, 243.5738f, 96.48f, -0.89f, 0.64f, -1.0f, -1.0f, -1.0f},
+    {117.9142f, 118.3962f, 118.2609f, 49.75f, -0.21f, 0.01f, -1.0f, -1.0f, -1.0f},
+    {78.3936f, 96.2850f, 37.2418f, 38.18f, -16.99f, 30.87f, -1.0f, -1.0f, -1.0f},
+    {72.2142f, 34.3584f, 92.2239f, 21.31f, 29.14f, -27.51f, -1.0f, -1.0f, -1.0f},
+    {244.5244f, 193.8503f, 0.0f, 80.57f, 3.85f, 89.61f, -1.0f, -1.0f, -1.0f},
+    {117.8475f, 118.2889f, 118.1270f, 49.71f, -0.20f, 0.03f, -1.0f, -1.0f, -1.0f},
+    {145.0665f, 145.2389f, 145.9725f, 60.27f, 0.08f, -0.41f, -1.0f, -1.0f, -1.0f},
+    {199.9555f, 153.8996f, 134.3363f, 67.34f, 14.45f, 16.90f, -1.0f, -1.0f, -1.0f},
+    {197.1786f, 145.1237f, 124.6796f, 64.69f, 16.95f, 18.57f, -1.0f, -1.0f, -1.0f},
+    {36.6899f, 140.3283f, 37.0131f, 51.12f, -49.31f, 44.41f, -1.0f, -1.0f, -1.0f},
+    {117.8144f, 118.2644f, 118.1186f, 49.7f, -0.20f, 0.02f, -1.0f, -1.0f, -1.0f},
+    {20.2541f, 20.8349f, 21.6861f, 6.67f, -0.05f, -0.64f, -1.0f, -1.0f, -1.0f},
+    {112.6726f, 119.9236f, 168.6891f, 51.56f, 9.16f, -26.88f, -1.0f, -1.0f, -1.0f},
+    {163.7979f, 183.1273f, 39.4915f, 70.83f, -24.26f, 64.77f, -1.0f, -1.0f, -1.0f},
+    {187.9194f, 68.6530f, 141.7077f, 48.06f, 55.33f, -15.61f, -1.0f, -1.0f, -1.0f},
+    {82.5699f, 82.9620f, 83.2778f, 35.26f, -0.09f, -0.24f, -1.0f, -1.0f, -1.0f},
+    {185.3466f, 184.8995f, 185.4040f, 75.16f, 0.25f, -0.20f, -1.0f, -1.0f, -1.0f},
+    {158.9114f, 86.2593f, 40.1532f, 44.54f, 26.27f, 38.93f, -1.0f, -1.0f, -1.0f},
+    {119.8508f, 73.3212f, 42.4862f, 35.91f, 16.59f, 26.46f, -1.0f, -1.0f, -1.0f},
+    {60.8859f, 169.4042f, 57.1272f, 61.49f, -52.73f, 47.30f, -1.0f, -1.0f, -1.0f},
+    {20.1742f, 20.6528f, 21.3198f, 6.59f, -0.05f, -0.50f, -1.0f, -1.0f, -1.0f},
+    {243.8216f, 245.6282f, 243.9185f, 96.58f, -0.90f, 0.61f, -1.0f, -1.0f, -1.0f},
+    {79.7809f, 185.0914f, 167.7500f, 68.93f, -34.58f, -0.34f, -1.0f, -1.0f, -1.0f},
+    {232.6743f, 153.8163f, 0.0f, 69.65f, 20.09f, 78.57f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 130.0449f, 163.4567f, 47.79f, -33.18f, -30.21f, -1.0f, -1.0f, -1.0f},
+    {38.1665f, 39.8882f, 41.3055f, 15.94f, -0.42f, -1.20f, -1.0f, -1.0f, -1.0f},
+    {222.3959f, 223.8081f, 224.4490f, 89.02f, -0.36f, -0.48f, -1.0f, -1.0f, -1.0f},
+    {209.4225f, 135.2473f, 108.2643f, 63.43f, 25.44f, 26.25f, -1.0f, -1.0f, -1.0f},
+    {211.8297f, 143.7736f, 111.0546f, 65.75f, 22.06f, 27.82f, -1.0f, -1.0f, -1.0f},
+    {198.7094f, 135.2492f, 55.8580f, 61.47f, 17.10f, 50.72f, -1.0f, -1.0f, -1.0f},
+    {243.7438f, 245.4744f, 243.6791f, 96.53f, -0.89f, 0.66f, -1.0f, -1.0f, -1.0f},
+    {118.0486f, 118.4902f, 118.3282f, 49.79f, -0.20f, 0.03f, -1.0f, -1.0f, -1.0f},
+    {245.4618f, 204.6880f, 180.8277f, 85.17f, 10.89f, 17.26f, -1.0f, -1.0f, -1.0f},
+    {196.2073f, 234.5558f, 213.2861f, 89.74f, -16.52f, 6.19f, -1.0f, -1.0f, -1.0f},
+    {215.5873f, 208.3601f, 222.5759f, 84.55f, 5.07f, -6.12f, -1.0f, -1.0f, -1.0f},
+    {169.8225f, 217.9657f, 225.3475f, 84.02f, -13.87f, -8.72f, -1.0f, -1.0f, -1.0f},
+    {172.9317f, 173.0792f, 173.7270f, 70.76f, 0.07f, -0.35f, -1.0f, -1.0f, -1.0f},
+    {107.9946f, 107.9158f, 107.5227f, 45.59f, -0.05f, 0.23f, -1.0f, -1.0f, -1.0f},
+    {48.8294f, 48.9265f, 49.4057f, 20.3f, 0.07f, -0.32f, -1.0f, -1.0f, -1.0f},
+    {154.4353f, 153.9054f, 41.5640f, 61.79f, -13.41f, 55.42f, -1.0f, -1.0f, -1.0f},
+    {117.8827f, 118.3094f, 118.1692f, 49.72f, -0.19f, 0.02f, -1.0f, -1.0f, -1.0f},
+    {20.6133f, 21.0396f, 21.6157f, 6.77f, -0.05f, -0.44f, -1.0f, -1.0f, -1.0f},
+    {98.5619f, 24.5454f, 42.2740f, 21.85f, 34.37f, 7.83f, -1.0f, -1.0f, -1.0f},
+    {203.5372f, 4.2888f, 23.0539f, 42.66f, 67.43f, 48.42f, -1.0f, -1.0f, -1.0f},
+    {206.9131f, 119.5498f, 140.5764f, 60.33f, 36.56f, 3.56f, -1.0f, -1.0f, -1.0f},
+    {215.5830f, 120.8032f, 119.0661f, 61.22f, 36.61f, 17.32f, -1.0f, -1.0f, -1.0f},
+    {251.8782f, 103.8825f, 0.0f, 62.07f, 52.80f, 77.14f, -1.0f, -1.0f, -1.0f},
+    {197.8463f, 179.7436f, 0.0f, 72.42f, -9.82f, 89.66f, -1.0f, -1.0f, -1.0f},
+    {182.0047f, 145.2731f, 40.3520f, 62.03f, 3.53f, 57.01f, -1.0f, -1.0f, -1.0f},
+    {163.8131f, 187.4426f, 0.0f, 71.95f, -27.34f, 73.69f, -1.0f, -1.0f, -1.0f},
+    {20.2251f, 20.6453f, 21.2489f, 6.59f, -0.04f, -0.45f, -1.0f, -1.0f, -1.0f},
+    {118.0243f, 118.4338f, 118.2614f, 49.77f, -0.19f, 0.04f, -1.0f, -1.0f, -1.0f},
+    {188.2188f, 31.6548f, 85.2439f, 41.84f, 62.05f, 10.01f, -1.0f, -1.0f, -1.0f},
+    {81.8360f, 27.8344f, 59.8794f, 19.78f, 29.16f, -7.85f, -1.0f, -1.0f, -1.0f},
+    {190.3670f, 0.0f, 42.9164f, 39.56f, 65.98f, 33.71f, -1.0f, -1.0f, -1.0f},
+    {236.3141f, 51.3514f, 46.5787f, 52.39f, 68.33f, 47.84f, -1.0f, -1.0f, -1.0f},
+    {276.7517f, 181.6850f, 0.0f, 81.23f, 24.12f, 87.51f, -1.0f, -1.0f, -1.0f},
+    {253.7462f, 195.2511f, 0.0f, 81.8f, 6.78f, 95.75f, -1.0f, -1.0f, -1.0f},
+    {183.1389f, 181.4049f, 0.0f, 71.72f, -16.23f, 76.28f, -1.0f, -1.0f, -1.0f},
+    {74.5051f, 40.0398f, 25.0285f, 20.31f, 14.45f, 16.74f, -1.0f, -1.0f, -1.0f},
+    {117.8060f, 118.2068f, 118.0183f, 49.68f, -0.19f, 0.05f, -1.0f, -1.0f, -1.0f},
+    {243.6388f, 245.3229f, 243.4973f, 96.48f, -0.88f, 0.68f, -1.0f, -1.0f, -1.0f},
+    {117.8333f, 118.2279f, 118.0773f, 49.69f, -0.18f, 0.03f, -1.0f, -1.0f, -1.0f},
+    {19.8618f, 20.1973f, 20.6441f, 6.39f, -0.04f, -0.33f, -1.0f, -1.0f, -1.0f},
+    {243.7610f, 245.5085f, 243.6882f, 96.54f, -0.90f, 0.67f, -1.0f, -1.0f, -1.0f},
+    {117.9245f, 118.3020f, 118.1192f, 49.72f, -0.18f, 0.05f, -1.0f, -1.0f, -1.0f},
+    {20.0461f, 20.4187f, 20.9774f, 6.49f, -0.03f, -0.41f, -1.0f, -1.0f, -1.0f},
+    {243.6929f, 245.4207f, 243.5636f, 96.51f, -0.90f, 0.69f, -1.0f, -1.0f, -1.0f},
+    {117.8721f, 118.2558f, 118.0350f, 49.7f, -0.19f, 0.07f, -1.0f, -1.0f, -1.0f},
+    {20.0704f, 20.3587f, 20.8917f, 6.47f, 0.00f, -0.38f, -1.0f, -1.0f, -1.0f},
+    {243.5788f, 245.2700f, 243.4010f, 96.46f, -0.89f, 0.7f, -1.0f, -1.0f, -1.0f},
+
+};
+
+const Point2f CChartDigitalSGCellchart[560] = {
+
+    {0.25f, 0.25f},
+    {2.75f, 0.25f},
+    {2.75f, 2.75f},
+    {0.25f, 2.75f},
+    {3.0f, 0.25f},
+    {5.5f, 0.25f},
+    {5.5f, 2.75f},
+    {3.0f, 2.75f},
+    {5.75f, 0.25f},
+    {8.25f, 0.25f},
+    {8.25f, 2.75f},
+    {5.75f, 2.75f},
+    {8.5f, 0.25f},
+    {11.0f, 0.25f},
+    {11.0f, 2.75f},
+    {8.5f, 2.75f},
+    {11.25f, 0.25f},
+    {13.75f, 0.25f},
+    {13.75f, 2.75f},
+    {11.25f, 2.75f},
+    {14.0f, 0.25f},
+    {16.5f, 0.25f},
+    {16.5f, 2.75f},
+    {14.0f, 2.75f},
+    {16.75f, 0.25f},
+    {19.25f, 0.25f},
+    {19.25f, 2.75f},
+    {16.75f, 2.75f},
+    {19.5f, 0.25f},
+    {22.0f, 0.25f},
+    {22.0f, 2.75f},
+    {19.5f, 2.75f},
+    {22.25f, 0.25f},
+    {24.75f, 0.25f},
+    {24.75f, 2.75f},
+    {22.25f, 2.75f},
+    {25.0f, 0.25f},
+    {27.5f, 0.25f},
+    {27.5f, 2.75f},
+    {25.0f, 2.75f},
+    {27.75f, 0.25f},
+    {30.25f, 0.25f},
+    {30.25f, 2.75f},
+    {27.75f, 2.75f},
+    {30.5f, 0.25f},
+    {33.0f, 0.25f},
+    {33.0f, 2.75f},
+    {30.5f, 2.75f},
+    {33.25f, 0.25f},
+    {35.75f, 0.25f},
+    {35.75f, 2.75f},
+    {33.25f, 2.75f},
+    {36.0f, 0.25f},
+    {38.5f, 0.25f},
+    {38.5f, 2.75f},
+    {36.0f, 2.75f},
+    {0.25f, 3.0f},
+    {2.75f, 3.0f},
+    {2.75f, 5.5f},
+    {0.25f, 5.5f},
+    {3.0f, 3.0f},
+    {5.5f, 3.0f},
+    {5.5f, 5.5f},
+    {3.0f, 5.5f},
+    {5.75f, 3.0f},
+    {8.25f, 3.0f},
+    {8.25f, 5.5f},
+    {5.75f, 5.5f},
+    {8.5f, 3.0f},
+    {11.0f, 3.0f},
+    {11.0f, 5.5f},
+    {8.5f, 5.5f},
+    {11.25f, 3.0f},
+    {13.75f, 3.0f},
+    {13.75f, 5.5f},
+    {11.25f, 5.5f},
+    {14.0f, 3.0f},
+    {16.5f, 3.0f},
+    {16.5f, 5.5f},
+    {14.0f, 5.5f},
+    {16.75f, 3.0f},
+    {19.25f, 3.0f},
+    {19.25f, 5.5f},
+    {16.75f, 5.5f},
+    {19.5f, 3.0f},
+    {22.0f, 3.0f},
+    {22.0f, 5.5f},
+    {19.5f, 5.5f},
+    {22.25f, 3.0f},
+    {24.75f, 3.0f},
+    {24.75f, 5.5f},
+    {22.25f, 5.5f},
+    {25.0f, 3.0f},
+    {27.5f, 3.0f},
+    {27.5f, 5.5f},
+    {25.0f, 5.5f},
+    {27.75f, 3.0f},
+    {30.25f, 3.0f},
+    {30.25f, 5.5f},
+    {27.75f, 5.5f},
+    {30.5f, 3.0f},
+    {33.0f, 3.0f},
+    {33.0f, 5.5f},
+    {30.5f, 5.5f},
+    {33.25f, 3.0f},
+    {35.75f, 3.0f},
+    {35.75f, 5.5f},
+    {33.25f, 5.5f},
+    {36.0f, 3.0f},
+    {38.5f, 3.0f},
+    {38.5f, 5.5f},
+    {36.0f, 5.5f},
+    {0.25f, 5.75f},
+    {2.75f, 5.75f},
+    {2.75f, 8.25f},
+    {0.25f, 8.25f},
+    {3.0f, 5.75f},
+    {5.5f, 5.75f},
+    {5.5f, 8.25f},
+    {3.0f, 8.25f},
+    {5.75f, 5.75f},
+    {8.25f, 5.75f},
+    {8.25f, 8.25f},
+    {5.75f, 8.25f},
+    {8.5f, 5.75f},
+    {11.0f, 5.75f},
+    {11.0f, 8.25f},
+    {8.5f, 8.25f},
+    {11.25f, 5.75f},
+    {13.75f, 5.75f},
+    {13.75f, 8.25f},
+    {11.25f, 8.25f},
+    {14.0f, 5.75f},
+    {16.5f, 5.75f},
+    {16.5f, 8.25f},
+    {14.0f, 8.25f},
+    {16.75f, 5.75f},
+    {19.25f, 5.75f},
+    {19.25f, 8.25f},
+    {16.75f, 8.25f},
+    {19.5f, 5.75f},
+    {22.0f, 5.75f},
+    {22.0f, 8.25f},
+    {19.5f, 8.25f},
+    {22.25f, 5.75f},
+    {24.75f, 5.75f},
+    {24.75f, 8.25f},
+    {22.25f, 8.25f},
+    {25.0f, 5.75f},
+    {27.5f, 5.75f},
+    {27.5f, 8.25f},
+    {25.0f, 8.25f},
+    {27.75f, 5.75f},
+    {30.25f, 5.75f},
+    {30.25f, 8.25f},
+    {27.75f, 8.25f},
+    {30.5f, 5.75f},
+    {33.0f, 5.75f},
+    {33.0f, 8.25f},
+    {30.5f, 8.25f},
+    {33.25f, 5.75f},
+    {35.75f, 5.75f},
+    {35.75f, 8.25f},
+    {33.25f, 8.25f},
+    {36.0f, 5.75f},
+    {38.5f, 5.75f},
+    {38.5f, 8.25f},
+    {36.0f, 8.25f},
+    {0.25f, 8.5f},
+    {2.75f, 8.5f},
+    {2.75f, 11.0f},
+    {0.25f, 11.0f},
+    {3.0f, 8.5f},
+    {5.5f, 8.5f},
+    {5.5f, 11.0f},
+    {3.0f, 11.0f},
+    {5.75f, 8.5f},
+    {8.25f, 8.5f},
+    {8.25f, 11.0f},
+    {5.75f, 11.0f},
+    {8.5f, 8.5f},
+    {11.0f, 8.5f},
+    {11.0f, 11.0f},
+    {8.5f, 11.0f},
+    {11.25f, 8.5f},
+    {13.75f, 8.5f},
+    {13.75f, 11.0f},
+    {11.25f, 11.0f},
+    {14.0f, 8.5f},
+    {16.5f, 8.5f},
+    {16.5f, 11.0f},
+    {14.0f, 11.0f},
+    {16.75f, 8.5f},
+    {19.25f, 8.5f},
+    {19.25f, 11.0f},
+    {16.75f, 11.0f},
+    {19.5f, 8.5f},
+    {22.0f, 8.5f},
+    {22.0f, 11.0f},
+    {19.5f, 11.0f},
+    {22.25f, 8.5f},
+    {24.75f, 8.5f},
+    {24.75f, 11.0f},
+    {22.25f, 11.0f},
+    {25.0f, 8.5f},
+    {27.5f, 8.5f},
+    {27.5f, 11.0f},
+    {25.0f, 11.0f},
+    {27.75f, 8.5f},
+    {30.25f, 8.5f},
+    {30.25f, 11.0f},
+    {27.75f, 11.0f},
+    {30.5f, 8.5f},
+    {33.0f, 8.5f},
+    {33.0f, 11.0f},
+    {30.5f, 11.0f},
+    {33.25f, 8.5f},
+    {35.75f, 8.5f},
+    {35.75f, 11.0f},
+    {33.25f, 11.0f},
+    {36.0f, 8.5f},
+    {38.5f, 8.5f},
+    {38.5f, 11.0f},
+    {36.0f, 11.0f},
+    {0.25f, 11.25f},
+    {2.75f, 11.25f},
+    {2.75f, 13.75f},
+    {0.25f, 13.75f},
+    {3.0f, 11.25f},
+    {5.5f, 11.25f},
+    {5.5f, 13.75f},
+    {3.0f, 13.75f},
+    {5.75f, 11.25f},
+    {8.25f, 11.25f},
+    {8.25f, 13.75f},
+    {5.75f, 13.75f},
+    {8.5f, 11.25f},
+    {11.0f, 11.25f},
+    {11.0f, 13.75f},
+    {8.5f, 13.75f},
+    {11.25f, 11.25f},
+    {13.75f, 11.25f},
+    {13.75f, 13.75f},
+    {11.25f, 13.75f},
+    {14.0f, 11.25f},
+    {16.5f, 11.25f},
+    {16.5f, 13.75f},
+    {14.0f, 13.75f},
+    {16.75f, 11.25f},
+    {19.25f, 11.25f},
+    {19.25f, 13.75f},
+    {16.75f, 13.75f},
+    {19.5f, 11.25f},
+    {22.0f, 11.25f},
+    {22.0f, 13.75f},
+    {19.5f, 13.75f},
+    {22.25f, 11.25f},
+    {24.75f, 11.25f},
+    {24.75f, 13.75f},
+    {22.25f, 13.75f},
+    {25.0f, 11.25f},
+    {27.5f, 11.25f},
+    {27.5f, 13.75f},
+    {25.0f, 13.75f},
+    {27.75f, 11.25f},
+    {30.25f, 11.25f},
+    {30.25f, 13.75f},
+    {27.75f, 13.75f},
+    {30.5f, 11.25f},
+    {33.0f, 11.25f},
+    {33.0f, 13.75f},
+    {30.5f, 13.75f},
+    {33.25f, 11.25f},
+    {35.75f, 11.25f},
+    {35.75f, 13.75f},
+    {33.25f, 13.75f},
+    {36.0f, 11.25f},
+    {38.5f, 11.25f},
+    {38.5f, 13.75f},
+    {36.0f, 13.75f},
+    {0.25f, 14.0f},
+    {2.75f, 14.0f},
+    {2.75f, 16.5f},
+    {0.25f, 16.5f},
+    {3.0f, 14.0f},
+    {5.5f, 14.0f},
+    {5.5f, 16.5f},
+    {3.0f, 16.5f},
+    {5.75f, 14.0f},
+    {8.25f, 14.0f},
+    {8.25f, 16.5f},
+    {5.75f, 16.5f},
+    {8.5f, 14.0f},
+    {11.0f, 14.0f},
+    {11.0f, 16.5f},
+    {8.5f, 16.5f},
+    {11.25f, 14.0f},
+    {13.75f, 14.0f},
+    {13.75f, 16.5f},
+    {11.25f, 16.5f},
+    {14.0f, 14.0f},
+    {16.5f, 14.0f},
+    {16.5f, 16.5f},
+    {14.0f, 16.5f},
+    {16.75f, 14.0f},
+    {19.25f, 14.0f},
+    {19.25f, 16.5f},
+    {16.75f, 16.5f},
+    {19.5f, 14.0f},
+    {22.0f, 14.0f},
+    {22.0f, 16.5f},
+    {19.5f, 16.5f},
+    {22.25f, 14.0f},
+    {24.75f, 14.0f},
+    {24.75f, 16.5f},
+    {22.25f, 16.5f},
+    {25.0f, 14.0f},
+    {27.5f, 14.0f},
+    {27.5f, 16.5f},
+    {25.0f, 16.5f},
+    {27.75f, 14.0f},
+    {30.25f, 14.0f},
+    {30.25f, 16.5f},
+    {27.75f, 16.5f},
+    {30.5f, 14.0f},
+    {33.0f, 14.0f},
+    {33.0f, 16.5f},
+    {30.5f, 16.5f},
+    {33.25f, 14.0f},
+    {35.75f, 14.0f},
+    {35.75f, 16.5f},
+    {33.25f, 16.5f},
+    {36.0f, 14.0f},
+    {38.5f, 14.0f},
+    {38.5f, 16.5f},
+    {36.0f, 16.5f},
+    {0.25f, 16.75f},
+    {2.75f, 16.75f},
+    {2.75f, 19.25f},
+    {0.25f, 19.25f},
+    {3.0f, 16.75f},
+    {5.5f, 16.75f},
+    {5.5f, 19.25f},
+    {3.0f, 19.25f},
+    {5.75f, 16.75f},
+    {8.25f, 16.75f},
+    {8.25f, 19.25f},
+    {5.75f, 19.25f},
+    {8.5f, 16.75f},
+    {11.0f, 16.75f},
+    {11.0f, 19.25f},
+    {8.5f, 19.25f},
+    {11.25f, 16.75f},
+    {13.75f, 16.75f},
+    {13.75f, 19.25f},
+    {11.25f, 19.25f},
+    {14.0f, 16.75f},
+    {16.5f, 16.75f},
+    {16.5f, 19.25f},
+    {14.0f, 19.25f},
+    {16.75f, 16.75f},
+    {19.25f, 16.75f},
+    {19.25f, 19.25f},
+    {16.75f, 19.25f},
+    {19.5f, 16.75f},
+    {22.0f, 16.75f},
+    {22.0f, 19.25f},
+    {19.5f, 19.25f},
+    {22.25f, 16.75f},
+    {24.75f, 16.75f},
+    {24.75f, 19.25f},
+    {22.25f, 19.25f},
+    {25.0f, 16.75f},
+    {27.5f, 16.75f},
+    {27.5f, 19.25f},
+    {25.0f, 19.25f},
+    {27.75f, 16.75f},
+    {30.25f, 16.75f},
+    {30.25f, 19.25f},
+    {27.75f, 19.25f},
+    {30.5f, 16.75f},
+    {33.0f, 16.75f},
+    {33.0f, 19.25f},
+    {30.5f, 19.25f},
+    {33.25f, 16.75f},
+    {35.75f, 16.75f},
+    {35.75f, 19.25f},
+    {33.25f, 19.25f},
+    {36.0f, 16.75f},
+    {38.5f, 16.75f},
+    {38.5f, 19.25f},
+    {36.0f, 19.25f},
+    {0.25f, 19.5f},
+    {2.75f, 19.5f},
+    {2.75f, 22.0f},
+    {0.25f, 22.0f},
+    {3.0f, 19.5f},
+    {5.5f, 19.5f},
+    {5.5f, 22.0f},
+    {3.0f, 22.0f},
+    {5.75f, 19.5f},
+    {8.25f, 19.5f},
+    {8.25f, 22.0f},
+    {5.75f, 22.0f},
+    {8.5f, 19.5f},
+    {11.0f, 19.5f},
+    {11.0f, 22.0f},
+    {8.5f, 22.0f},
+    {11.25f, 19.5f},
+    {13.75f, 19.5f},
+    {13.75f, 22.0f},
+    {11.25f, 22.0f},
+    {14.0f, 19.5f},
+    {16.5f, 19.5f},
+    {16.5f, 22.0f},
+    {14.0f, 22.0f},
+    {16.75f, 19.5f},
+    {19.25f, 19.5f},
+    {19.25f, 22.0f},
+    {16.75f, 22.0f},
+    {19.5f, 19.5f},
+    {22.0f, 19.5f},
+    {22.0f, 22.0f},
+    {19.5f, 22.0f},
+    {22.25f, 19.5f},
+    {24.75f, 19.5f},
+    {24.75f, 22.0f},
+    {22.25f, 22.0f},
+    {25.0f, 19.5f},
+    {27.5f, 19.5f},
+    {27.5f, 22.0f},
+    {25.0f, 22.0f},
+    {27.75f, 19.5f},
+    {30.25f, 19.5f},
+    {30.25f, 22.0f},
+    {27.75f, 22.0f},
+    {30.5f, 19.5f},
+    {33.0f, 19.5f},
+    {33.0f, 22.0f},
+    {30.5f, 22.0f},
+    {33.25f, 19.5f},
+    {35.75f, 19.5f},
+    {35.75f, 22.0f},
+    {33.25f, 22.0f},
+    {36.0f, 19.5f},
+    {38.5f, 19.5f},
+    {38.5f, 22.0f},
+    {36.0f, 22.0f},
+    {0.25f, 22.25f},
+    {2.75f, 22.25f},
+    {2.75f, 24.75f},
+    {0.25f, 24.75f},
+    {3.0f, 22.25f},
+    {5.5f, 22.25f},
+    {5.5f, 24.75f},
+    {3.0f, 24.75f},
+    {5.75f, 22.25f},
+    {8.25f, 22.25f},
+    {8.25f, 24.75f},
+    {5.75f, 24.75f},
+    {8.5f, 22.25f},
+    {11.0f, 22.25f},
+    {11.0f, 24.75f},
+    {8.5f, 24.75f},
+    {11.25f, 22.25f},
+    {13.75f, 22.25f},
+    {13.75f, 24.75f},
+    {11.25f, 24.75f},
+    {14.0f, 22.25f},
+    {16.5f, 22.25f},
+    {16.5f, 24.75f},
+    {14.0f, 24.75f},
+    {16.75f, 22.25f},
+    {19.25f, 22.25f},
+    {19.25f, 24.75f},
+    {16.75f, 24.75f},
+    {19.5f, 22.25f},
+    {22.0f, 22.25f},
+    {22.0f, 24.75f},
+    {19.5f, 24.75f},
+    {22.25f, 22.25f},
+    {24.75f, 22.25f},
+    {24.75f, 24.75f},
+    {22.25f, 24.75f},
+    {25.0f, 22.25f},
+    {27.5f, 22.25f},
+    {27.5f, 24.75f},
+    {25.0f, 24.75f},
+    {27.75f, 22.25f},
+    {30.25f, 22.25f},
+    {30.25f, 24.75f},
+    {27.75f, 24.75f},
+    {30.5f, 22.25f},
+    {33.0f, 22.25f},
+    {33.0f, 24.75f},
+    {30.5f, 24.75f},
+    {33.25f, 22.25f},
+    {35.75f, 22.25f},
+    {35.75f, 24.75f},
+    {33.25f, 24.75f},
+    {36.0f, 22.25f},
+    {38.5f, 22.25f},
+    {38.5f, 24.75f},
+    {36.0f, 24.75f},
+    {0.25f, 25.0f},
+    {2.75f, 25.0f},
+    {2.75f, 27.5f},
+    {0.25f, 27.5f},
+    {3.0f, 25.0f},
+    {5.5f, 25.0f},
+    {5.5f, 27.5f},
+    {3.0f, 27.5f},
+    {5.75f, 25.0f},
+    {8.25f, 25.0f},
+    {8.25f, 27.5f},
+    {5.75f, 27.5f},
+    {8.5f, 25.0f},
+    {11.0f, 25.0f},
+    {11.0f, 27.5f},
+    {8.5f, 27.5f},
+    {11.25f, 25.0f},
+    {13.75f, 25.0f},
+    {13.75f, 27.5f},
+    {11.25f, 27.5f},
+    {14.0f, 25.0f},
+    {16.5f, 25.0f},
+    {16.5f, 27.5f},
+    {14.0f, 27.5f},
+    {16.75f, 25.0f},
+    {19.25f, 25.0f},
+    {19.25f, 27.5f},
+    {16.75f, 27.5f},
+    {19.5f, 25.0f},
+    {22.0f, 25.0f},
+    {22.0f, 27.5f},
+    {19.5f, 27.5f},
+    {22.25f, 25.0f},
+    {24.75f, 25.0f},
+    {24.75f, 27.5f},
+    {22.25f, 27.5f},
+    {25.0f, 25.0f},
+    {27.5f, 25.0f},
+    {27.5f, 27.5f},
+    {25.0f, 27.5f},
+    {27.75f, 25.0f},
+    {30.25f, 25.0f},
+    {30.25f, 27.5f},
+    {27.75f, 27.5f},
+    {30.5f, 25.0f},
+    {33.0f, 25.0f},
+    {33.0f, 27.5f},
+    {30.5f, 27.5f},
+    {33.25f, 25.0f},
+    {35.75f, 25.0f},
+    {35.75f, 27.5f},
+    {33.25f, 27.5f},
+    {36.0f, 25.0f},
+    {38.5f, 25.0f},
+    {38.5f, 27.5f},
+    {36.0f, 27.5f}
+
+};
+
+const Point2f CChartDigitalSGCenter[140] = {
+    {1.5f, 1.5f},
+    {4.25f, 1.5f},
+    {7.0f, 1.5f},
+    {9.75f, 1.5f},
+    {12.5f, 1.5f},
+    {15.25f, 1.5f},
+    {18.0f, 1.5f},
+    {20.75f, 1.5f},
+    {23.5f, 1.5f},
+    {26.25f, 1.5f},
+    {29.0f, 1.5f},
+    {31.75f, 1.5f},
+    {34.5f, 1.5f},
+    {37.25f, 1.5f},
+    {1.5f, 4.25f},
+    {4.25f, 4.25f},
+    {7.0f, 4.25f},
+    {9.75f, 4.25f},
+    {12.5f, 4.25f},
+    {15.25f, 4.25f},
+    {18.0f, 4.25f},
+    {20.75f, 4.25f},
+    {23.5f, 4.25f},
+    {26.25f, 4.25f},
+    {29.0f, 4.25f},
+    {31.75f, 4.25f},
+    {34.5f, 4.25f},
+    {37.25f, 4.25f},
+    {1.5f, 7.0f},
+    {4.25f, 7.0f},
+    {7.0f, 7.0f},
+    {9.75f, 7.0f},
+    {12.5f, 7.0f},
+    {15.25f, 7.0f},
+    {18.0f, 7.0f},
+    {20.75f, 7.0f},
+    {23.5f, 7.0f},
+    {26.25f, 7.0f},
+    {29.0f, 7.0f},
+    {31.75f, 7.0f},
+    {34.5f, 7.0f},
+    {37.25f, 7.0f},
+    {1.5f, 9.75f},
+    {4.25f, 9.75f},
+    {7.0f, 9.75f},
+    {9.75f, 9.75f},
+    {12.5f, 9.75f},
+    {15.25f, 9.75f},
+    {18.0f, 9.75f},
+    {20.75f, 9.75f},
+    {23.5f, 9.75f},
+    {26.25f, 9.75f},
+    {29.0f, 9.75f},
+    {31.75f, 9.75f},
+    {34.5f, 9.75f},
+    {37.25f, 9.75f},
+    {1.5f, 12.5f},
+    {4.25f, 12.5f},
+    {7.0f, 12.5f},
+    {9.75f, 12.5f},
+    {12.5f, 12.5f},
+    {15.25f, 12.5f},
+    {18.0f, 12.5f},
+    {20.75f, 12.5f},
+    {23.5f, 12.5f},
+    {26.25f, 12.5f},
+    {29.0f, 12.5f},
+    {31.75f, 12.5f},
+    {34.5f, 12.5f},
+    {37.25f, 12.5f},
+    {1.5f, 15.25f},
+    {4.25f, 15.25f},
+    {7.0f, 15.25f},
+    {9.75f, 15.25f},
+    {12.5f, 15.25f},
+    {15.25f, 15.25f},
+    {18.0f, 15.25f},
+    {20.75f, 15.25f},
+    {23.5f, 15.25f},
+    {26.25f, 15.25f},
+    {29.0f, 15.25f},
+    {31.75f, 15.25f},
+    {34.5f, 15.25f},
+    {37.25f, 15.25f},
+    {1.5f, 18.0f},
+    {4.25f, 18.0f},
+    {7.0f, 18.0f},
+    {9.75f, 18.0f},
+    {12.5f, 18.0f},
+    {15.25f, 18.0f},
+    {18.0f, 18.0f},
+    {20.75f, 18.0f},
+    {23.5f, 18.0f},
+    {26.25f, 18.0f},
+    {29.0f, 18.0f},
+    {31.75f, 18.0f},
+    {34.5f, 18.0f},
+    {37.25f, 18.0f},
+    {1.5f, 20.75f},
+    {4.25f, 20.75f},
+    {7.0f, 20.75f},
+    {9.75f, 20.75f},
+    {12.5f, 20.75f},
+    {15.25f, 20.75f},
+    {18.0f, 20.75f},
+    {20.75f, 20.75f},
+    {23.5f, 20.75f},
+    {26.25f, 20.75f},
+    {29.0f, 20.75f},
+    {31.75f, 20.75f},
+    {34.5f, 20.75f},
+    {37.25f, 20.75f},
+    {1.5f, 23.5f},
+    {4.25f, 23.5f},
+    {7.0f, 23.5f},
+    {9.75f, 23.5f},
+    {12.5f, 23.5f},
+    {15.25f, 23.5f},
+    {18.0f, 23.5f},
+    {20.75f, 23.5f},
+    {23.5f, 23.5f},
+    {26.25f, 23.5f},
+    {29.0f, 23.5f},
+    {31.75f, 23.5f},
+    {34.5f, 23.5f},
+    {37.25f, 23.5f},
+    {1.5f, 26.25f},
+    {4.25f, 26.25f},
+    {7.0f, 26.25f},
+    {9.75f, 26.25f},
+    {12.5f, 26.25f},
+    {15.25f, 26.25f},
+    {18.0f, 26.25f},
+    {20.75f, 26.25f},
+    {23.5f, 26.25f},
+    {26.25f, 26.25f},
+    {29.0f, 26.25f},
+    {31.75f, 26.25f},
+    {34.5f, 26.25f},
+    {37.25f, 26.25f},
+
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+/// CChartVinyl
+
+const float CChartVinylColors[18][9] = {
+    //       sRGB              CIE L*a*b*             Munsell Notation
+    // ---------------  ------------------------     Hue Value / Chroma
+    // R     G      B        L*      a*       b*
+    {255.0f, 255.0f, 255.0f, 100.0f, 0.0052f, -0.0104f, -1.0f, -1.0f, -1.0f},
+    {176.0f, 180.0f, 183.0f, 73.0834f, -0.820f, -2.021f, -1.0f, -1.0f, -1.0f},
+    {150.0f, 151.0f, 155.0f, 62.493f, 0.426f, -2.231f, -1.0f, -1.0f, -1.0f},
+    {119.0f, 120.0f, 124.0f, 50.464f, 0.447f, -2.324f, -1.0f, -1.0f, -1.0f},
+    {88.0f, 89.0f, 91.0f, 37.797f, 0.036f, -1.297f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, -1.0f, -1.0f},
+    {237.0f, 27.0f, 36.0f, 51.588f, 73.518f, 51.569f, -1.0f, -1.0f, -1.0f},
+    {254.0f, 242.0f, 0.0f, 93.699f, -15.734f, 91.942f, -1.0f, -1.0f, -1.0f},
+    {106.0f, 189.0f, 71.0f, 69.408f, -46.594f, 50.487f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 173.0f, 239.0f, 66.610f, -13.679f, -43.172f, -1.0f, -1.0f, -1.0f},
+    {0.0f, 26.0f, 83.0f, 11.711f, 16.980f, -37.176f, -1.0f, -1.0f, -1.0f},
+    {238.0f, 1.0f, 141.0f, 51.974f, 81.944f, -8.407f, -1.0f, -1.0f, -1.0f},
+    {174.0f, 50.0f, 58.0f, 40.549f, 50.440f, 24.849f, -1.0f, -1.0f, -1.0f},
+    {209.0f, 127.0f, 41.0f, 60.816f, 26.069f, 49.442f, -1.0f, -1.0f, -1.0f},
+    {7.0f, 136.0f, 165.0f, 52.253f, -19.950f, -23.996f, -1.0f, -1.0f, -1.0f},
+    {188.0f, 86.0f, 149.0f, 51.286f, 48.470f, -15.058f, -1.0f, -1.0f, -1.0f},
+    {200.0f, 159.0f, 139.0f, 68.707f, 12.296f, 16.213f, -1.0f, -1.0f, -1.0f},
+    {183.0f, 147.0f, 125.0f, 63.684f, 10.293f, 16.764f, -1.0f, -1.0f, -1.0f},
+};
+
+const Point2f CChartVinylCellchart[72] = {
+    {0.25f, 0.25f},
+    {3.0f, 0.25f},
+    {3.0f, 6.25f},
+    {0.25f, 6.25f},
+    {3.25f, 0.25f},
+    {6.0f, 0.25f},
+    {6.0f, 6.25f},
+    {3.25f, 6.25f},
+    {6.25f, 0.25f},
+    {9.0f, 0.25f},
+    {9.0f, 6.25f},
+    {6.25f, 6.25f},
+    {9.25f, 0.25f},
+    {12.0f, 0.25f},
+    {12.0f, 6.25f},
+    {9.25f, 6.25f},
+    {12.25f, 0.25f},
+    {15.0f, 0.25f},
+    {15.0f, 6.25f},
+    {12.25f, 6.25f},
+    {15.25f, 0.25f},
+    {18.0f, 0.25f},
+    {18.0f, 6.25f},
+    {15.25f, 6.25f},
+    {0.25f, 6.5f},
+    {3.0f, 6.5f},
+    {3.0f, 9.25f},
+    {0.25f, 9.25f},
+    {3.25f, 6.5f},
+    {6.0f, 6.5f},
+    {6.0f, 9.25f},
+    {3.25f, 9.25f},
+    {6.25f, 6.5f},
+    {9.0f, 6.5f},
+    {9.0f, 9.25f},
+    {6.25f, 9.25f},
+    {9.25f, 6.5f},
+    {12.0f, 6.5f},
+    {12.0f, 9.25f},
+    {9.25f, 9.25f},
+    {12.25f, 6.5f},
+    {15.0f, 6.5f},
+    {15.0f, 9.25f},
+    {12.25f, 9.25f},
+    {15.25f, 6.5f},
+    {18.0f, 6.5f},
+    {18.0f, 9.25f},
+    {15.25f, 9.25f},
+    {0.25f, 9.5f},
+    {3.0f, 9.5f},
+    {3.0f, 12.25f},
+    {0.25f, 12.25f},
+    {3.25f, 9.5f},
+    {6.0f, 9.5f},
+    {6.0f, 12.25f},
+    {3.25f, 12.25f},
+    {6.25f, 9.5f},
+    {9.0f, 9.5f},
+    {9.0f, 12.25f},
+    {6.25f, 12.25f},
+    {9.25f, 9.5f},
+    {12.0f, 9.5f},
+    {12.0f, 12.25f},
+    {9.25f, 12.25f},
+    {12.25f, 9.5f},
+    {15.0f, 9.5f},
+    {15.0f, 12.25f},
+    {12.25f, 12.25f},
+    {15.25f, 9.5f},
+    {18.0f, 9.5f},
+    {18.0f, 12.25f},
+    {15.25f, 12.25f},
+
+};
+
+const Point2f CChartVinylCenter[18] = {
+    {1.625f, 3.25f},
+    {4.625f, 3.25f},
+    {7.625f, 3.25f},
+    {10.625f, 3.25f},
+    {13.625f, 3.25f},
+    {16.625f, 3.25f},
+    {1.625f, 7.875f},
+    {4.625f, 7.875f},
+    {7.625f, 7.875f},
+    {10.625f, 7.875f},
+    {13.625f, 7.875f},
+    {16.625f, 7.875f},
+    {1.625f, 10.875f},
+    {4.625f, 10.875f},
+    {7.625f, 10.875f},
+    {10.625f, 10.875f},
+    {13.625f, 10.875f},
+    {16.625f, 10.875f},
+
+};
+
+} // namespace mcc
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp b/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp
new file mode 100644
index 0000000..3c1cea3
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.cpp
@@ -0,0 +1,139 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "precomp.hpp"
+#include "graph_cluster.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+CB0cluster::CB0cluster()
+{
+}
+
+CB0cluster::~CB0cluster()
+{
+}
+
+void CB0cluster::
+    group()
+{
+
+    size_t n = X.size();
+    G.clear();
+    G.resize(n);
+
+    for (int i = 0; i < (int)n - 1; i++)
+    {
+        std::vector<double> Y;
+        Y.clear();
+        Y.resize(n - i);
+        Y[0] = 0;
+
+        // 1. group similar blobs
+        double dist, w, y;
+        for (int j = i + 1, k = 1; j < (int)n; j++, k++)
+        {
+            //dist(X_i,X_j)
+            dist = norm(X[i] - X[j]);
+
+            //heuristic to combine two sub charts, This is pretty ugly at the moment,
+            //Looking for somthing better
+            w = min(abs(W[i] - W[j]) / (W[i] + W[j]),
+                    abs(max(W[i], W[j]) - 24 / 11.0f * min(W[i], W[j])) / (max(W[i], W[j]) + 24 / 11.0f * min(W[i], W[j])));
+            w = (w < 0.1);
+
+            y = w * dist;
+            Y[k] = (y < B0[i]) * y;
+            ;
+        }
+
+        if (!G[i])
+            G[i] = i + 1;
+
+        std::vector<int> pos_b0;
+        find(Y, pos_b0);
+
+        size_t m = pos_b0.size();
+        if (!m)
+            continue;
+
+        std::vector<int> pos_nz, pos_z;
+        for (int j = 0; j < (int)m; j++)
+        {
+            pos_b0[j] = pos_b0[j] + i;
+            if (G[pos_b0[j]])
+                pos_nz.push_back(j);
+            else
+                pos_z.push_back(j);
+        }
+
+        for (int j = 0; j < (int)pos_z.size(); j++)
+        {
+            pos_z[j] = pos_b0[pos_z[j]];
+            G[pos_z[j]] = G[i];
+        }
+
+        if (!pos_nz.size())
+            continue;
+
+        std::vector<int> g;
+        for (size_t j = 0; j < pos_nz.size(); j++)
+        {
+            pos_nz[j] = pos_b0[pos_nz[j]];
+            g.push_back(G[pos_nz[j]]);
+        }
+
+        unique(g, g);
+        for (size_t k = 0; k < g.size(); k++)
+        {
+            int gk = g[k];
+            for (size_t j = 0; j < G.size(); j++)
+                if (G[j] == gk)
+                    G[j] = G[i];
+        }
+    }
+
+    if (!G[n - 1])
+        G[n - 1] = (int)n;
+
+    std::vector<int> S;
+    S = G;
+    unique(S, S);
+    for (int k = 0; k < (int)S.size(); k++)
+    {
+        int gk = S[k];
+        for (int j = 0; j < (int)G.size(); j++)
+            if (G[j] == gk)
+                G[j] = k;
+    }
+}
+
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.hpp b/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.hpp
new file mode 100644
index 0000000..b9ba194
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/graph_cluster.hpp
@@ -0,0 +1,74 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_GRAPH_CLUSTERS_HPP
+#define _MCC_GRAPH_CLUSTERS_HPP
+
+namespace cv
+{
+namespace mcc
+{
+
+class CB0cluster
+{
+public:
+    CB0cluster();
+    ~CB0cluster();
+
+    inline void setVertex(const std::vector<Point> &V) { X = V; }
+    inline void setB0(const std::vector<double> &b0) { B0 = b0; }
+    inline void setWeight(const std::vector<double> &Weight) { W = Weight; }
+
+    void group();
+
+    void getGroup(std::vector<int> &g) { g = G; }
+
+private:
+    //entrada
+    std::vector<Point> X;
+    std::vector<double> B0;
+    std::vector<double> W;
+
+    //salida
+    std::vector<int> G;
+
+private:
+    template <typename T>
+    void find(const std::vector<T> &A, std::vector<int> &indx)
+    {
+        indx.clear();
+        for (int i = 0; i < (int)A.size(); i++)
+            if (A[i])
+                indx.push_back(i);
+    }
+};
+
+} // namespace mcc
+} // namespace cv
+
+#endif //_MCC_GRAPH_CLUSTERS_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/precomp.hpp b/upstream/opencv/modules/objdetect/src/mcc/precomp.hpp
new file mode 100644
index 0000000..65d84c2
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/precomp.hpp
@@ -0,0 +1,48 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _MCC_PRECOMP_HPP
+#define _MCC_PRECOMP_HPP
+
+#include <limits>
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/geometry.hpp>
+#ifdef HAVE_OPENCV_DNN
+#include <opencv2/dnn.hpp>
+#endif
+
+#include <vector>
+#include <string>
+
+#include "opencv2/objdetect.hpp"
+
+#include "common.hpp"
+
+#endif //_MCC_PRECOMP_HPP
diff --git a/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp b/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp
new file mode 100644
index 0000000..5a5d374
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.cpp
@@ -0,0 +1,98 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "wiener_filter.hpp"
+
+namespace cv
+{
+namespace mcc
+{
+CWienerFilter::CWienerFilter()
+{
+}
+
+CWienerFilter::~CWienerFilter()
+{
+}
+
+void CWienerFilter::
+    wiener2(InputArray _src, OutputArray _dst, int szWindowX, int szWindowY)
+{
+
+    CV_Assert(szWindowX > 0 && szWindowY > 0);
+
+    Mat src = _src.getMat();
+
+    int nRows;
+    int nCols;
+    Scalar v = 0;
+    Mat p_kernel;
+    Mat srcStub;
+    //Now create a temporary holding matrix
+    Mat p_tmpMat1, p_tmpMat2, p_tmpMat3, p_tmpMat4;
+    double noise_power;
+
+    nRows = szWindowY;
+    nCols = szWindowX;
+
+    p_kernel = Mat(nRows, nCols, CV_32F, Scalar(1.0 / (double)(nRows * nCols)));
+
+    //Local mean of input
+    filter2D(src, p_tmpMat1, -1, p_kernel, Point(nCols / 2, nRows / 2)); //localMean
+
+    //Local variance of input
+    p_tmpMat2 = src.mul(src);
+    filter2D(p_tmpMat2, p_tmpMat3, -1, p_kernel, Point(nCols / 2, nRows / 2));
+
+    //Subtract off local_mean^2 from local variance
+    p_tmpMat4 = p_tmpMat1.mul(p_tmpMat1); //localMean^2
+    p_tmpMat3 = p_tmpMat3 - p_tmpMat4;
+    // Sub(p_tmpMat3, p_tmpMat4, p_tmpMat3); //filter(in^2) - localMean^2 ==> localVariance
+
+    //Estimate noise power
+    v = mean(p_tmpMat3);
+    noise_power = v.val[0];
+    // result = local_mean  + ( max(0, localVar - noise) ./ max(localVar, noise)) .* (in - local_mean)
+
+    p_tmpMat4 = src - p_tmpMat1; //in - local_mean
+
+    p_tmpMat2 = max(p_tmpMat3, noise_power); //max(localVar, noise)
+
+    add(p_tmpMat3, Scalar(-noise_power), p_tmpMat3); //localVar - noise
+    p_tmpMat3 = max(p_tmpMat3, 0);                     // max(0, localVar - noise)
+
+    p_tmpMat3 = (p_tmpMat3 / p_tmpMat2); //max(0, localVar-noise) / max(localVar, noise)
+
+    Mat dst = p_tmpMat3.mul(p_tmpMat4);
+    dst = dst + p_tmpMat1;
+
+    _dst.assign(dst);
+}
+
+} // namespace mcc
+} // namespace cv
diff --git a/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.hpp b/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.hpp
new file mode 100644
index 0000000..381329a
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/mcc/wiener_filter.hpp
@@ -0,0 +1,68 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+/*
+ * MIT License
+ *
+ * Copyright (c) 2018 Pedro Diamel Marrero Fernández
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+  *  @file wiener_filter
+  *  @brief filter wiener for denoise
+  *  @author: Pedro D. Marrero Fernandez
+  *  @data: 17/05/2016
+  */
+
+#ifndef _WIENER_FILTER_HPP
+#define _WIENER_FILTER_HPP
+
+#include "precomp.hpp"
+namespace cv
+{
+namespace mcc
+{
+
+/// CWienerFilter
+/**  @brief wiener class filter for denoise
+      *  @author: Pedro D. Marrero Fernandez
+      *  @data: 17/05/2016
+      */
+class CWienerFilter
+{
+public:
+    CWienerFilter();
+    ~CWienerFilter();
+
+    /** cvWiener2
+          * @brief A Wiener 2D Filter implementation for OpenCV
+          * @author: Ray Juang / rayver{ _at_ } hkn{ / _dot_ / } berkeley(_dot_) edu
+          * @date : 12.1.2006
+          */
+    void wiener2(InputArray _src, OutputArray _dst, int szWindowX, int szWindowY);
+};
+
+} // namespace mcc
+
+} // namespace cv
+
+#endif //_WIENER_FILTER_HPP
diff --git a/upstream/opencv/modules/objdetect/src/precomp.hpp b/upstream/opencv/modules/objdetect/src/precomp.hpp
new file mode 100644
index 0000000..603b217
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/precomp.hpp
@@ -0,0 +1,67 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/objdetect/barcode.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/geometry.hpp"
+
+#include <opencv2/core/utils/logger.hpp>
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/private.hpp"
+
+#include <numeric>
+#include <array>
+#include <vector>
+
+namespace cv {
+
+int checkChessboardBinary(const Mat & img, const Size & size);
+
+}
+
+#endif
diff --git a/upstream/opencv/modules/objdetect/src/qrcode.cpp b/upstream/opencv/modules/objdetect/src/qrcode.cpp
new file mode 100644
index 0000000..b7d049e
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/qrcode.cpp
@@ -0,0 +1,4706 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2018, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#include "precomp.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/geometry.hpp"
+#include <opencv2/core/utils/logger.hpp>
+#include "graphical_code_detector_impl.hpp"
+
+#include <array>
+#include <limits>
+#include <cmath>
+#include <queue>
+#include <map>
+
+namespace cv
+{
+using std::vector;
+using std::pair;
+
+static bool checkQRInputImage(InputArray img, Mat& gray)
+{
+    CV_Assert(!img.empty());
+    CV_CheckDepthEQ(img.depth(), CV_8U, "");
+
+    if (img.cols() <= 20 || img.rows() <= 20)
+    {
+        return false;  // image data is not enough for providing reliable results
+    }
+    int incn = img.channels();
+    CV_Check(incn, incn == 1 || incn == 3 || incn == 4, "");
+    if (incn == 3 || incn == 4)
+    {
+        cvtColor(img, gray, COLOR_BGR2GRAY);
+    }
+    else
+    {
+        gray = img.getMat();
+    }
+    return true;
+}
+
+static void updatePointsResult(OutputArray points_, const vector<Point2f>& points)
+{
+    if (points_.needed())
+    {
+        int N = int(points.size() / 4);
+        if (N > 0)
+        {
+            int nrows = points_.kind() == _InputArray::STD_VECTOR ? 1 : N;
+            Mat m_p(nrows, N*4/nrows, CV_32FC2, (void*)&points[0]);
+            int points_type = points_.fixedType() ? points_.type() : CV_32FC2;
+            m_p.convertTo(points_, points_type);  // Mat layout: N x 4 x 2cn
+        }
+        else
+        {
+            points_.release();
+        }
+    }
+}
+
+static Point2f intersectionLines(Point2f a1, Point2f a2, Point2f b1, Point2f b2)
+{
+    // Try to solve a two lines intersection (a1, a2) and (b1, b2) as a system of equations:
+    // a2 + u * (a1 - a2) = b2 + v * (b1 - b2)
+    const float divisor = (a1.x - a2.x) * (b1.y - b2.y) - (a1.y - a2.y) * (b1.x - b2.x);
+    const float eps = 0.001f;
+    if (abs(divisor) < eps)
+        return a2;
+    const float u = ((b2.x - a2.x) * (b1.y - b2.y) + (b1.x - b2.x) * (a2.y - b2.y)) / divisor;
+    return a2 + u * (a1 - a2);
+}
+
+//      / | b
+//     /  |
+//    /   |
+//  a/    | c
+
+static inline double getCosVectors(Point a, Point b, Point c)
+{
+    CV_DbgCheckNE(a, b, "Angle between vector and point is undetermined");
+    CV_DbgCheckNE(b, c, "Angle between vector and point is undetermined");
+    return ((a - b).x * (c - b).x + (a - b).y * (c - b).y) / (norm(a - b) * norm(c - b));
+}
+
+static bool arePointsNearest(Point2f a, Point2f b, float delta = 0.0)
+{
+    if ((abs(a.x - b.x) < delta) && (abs(a.y - b.y) < delta))
+        return true;
+    else
+        return false;
+}
+
+class QRDetect
+{
+public:
+    void init(const Mat& src, double eps_vertical_ = 0.2, double eps_horizontal_ = 0.1);
+    bool localization();
+    bool computeTransformationPoints();
+    Mat getBinBarcode() { return bin_barcode; }
+    Mat getStraightBarcode() { return straight_barcode; }
+    vector<Point2f> getTransformationPoints() { return transformation_points; }
+protected:
+    vector<Vec3d> searchHorizontalLines();
+    vector<Point2f> separateVerticalLines(const vector<Vec3d> &list_lines);
+    vector<Point2f> extractVerticalLines(const vector<Vec3d> &list_lines, double eps);
+    void fixationPoints(vector<Point2f> &local_point);
+    vector<Point2f> getQuadrilateral(vector<Point2f> angle_list);
+    bool testByPassRoute(vector<Point2f> hull, int start, int finish);
+
+    Mat barcode, bin_barcode, resized_barcode, resized_bin_barcode, straight_barcode;
+    vector<Point2f> localization_points, transformation_points;
+    double eps_vertical, eps_horizontal, coeff_expansion;
+    enum resize_direction { ZOOMING, SHRINKING, UNCHANGED } purpose;
+};
+
+
+void QRDetect::init(const Mat& src, double eps_vertical_, double eps_horizontal_)
+{
+    CV_TRACE_FUNCTION();
+    CV_Assert(!src.empty());
+    barcode = src.clone();
+    const double min_side = std::min(src.size().width, src.size().height);
+    if (min_side < 512.0)
+    {
+        purpose = ZOOMING;
+        coeff_expansion = 512.0 / min_side;
+        const int width  = cvRound(src.size().width  * coeff_expansion);
+        const int height = cvRound(src.size().height  * coeff_expansion);
+        Size new_size(width, height);
+        resize(src, barcode, new_size, 0, 0, INTER_LINEAR_EXACT);
+    }
+    else if (min_side > 512.0)
+    {
+        purpose = SHRINKING;
+        coeff_expansion = min_side / 512.0;
+        const int width  = cvRound(src.size().width  / coeff_expansion);
+        const int height = cvRound(src.size().height  / coeff_expansion);
+        Size new_size(width, height);
+        resize(src, resized_barcode, new_size, 0, 0, INTER_AREA);
+    }
+    else
+    {
+        purpose = UNCHANGED;
+        coeff_expansion = 1.0;
+    }
+
+    eps_vertical   = eps_vertical_;
+    eps_horizontal = eps_horizontal_;
+
+    if (!barcode.empty())
+        adaptiveThreshold(barcode, bin_barcode, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 83, 2);
+    else
+        bin_barcode.release();
+
+    if (!resized_barcode.empty())
+        adaptiveThreshold(resized_barcode, resized_bin_barcode, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 83, 2);
+    else
+        resized_bin_barcode.release();
+}
+
+vector<Vec3d> QRDetect::searchHorizontalLines()
+{
+    CV_TRACE_FUNCTION();
+    vector<Vec3d> result;
+    const int height_bin_barcode = bin_barcode.rows;
+    const int width_bin_barcode  = bin_barcode.cols;
+    const size_t test_lines_size = 5;
+    double test_lines[test_lines_size];
+    vector<size_t> pixels_position;
+
+    for (int y = 0; y < height_bin_barcode; y++)
+    {
+        pixels_position.clear();
+        const uint8_t *bin_barcode_row = bin_barcode.ptr<uint8_t>(y);
+
+        int pos = 0;
+        for (; pos < width_bin_barcode; pos++) { if (bin_barcode_row[pos] == 0) break; }
+        if (pos == width_bin_barcode) { continue; }
+
+        pixels_position.push_back(pos);
+        pixels_position.push_back(pos);
+        pixels_position.push_back(pos);
+
+        uint8_t future_pixel = 255;
+        for (int x = pos; x < width_bin_barcode; x++)
+        {
+            if (bin_barcode_row[x] == future_pixel)
+            {
+                future_pixel = static_cast<uint8_t>(~future_pixel);
+                pixels_position.push_back(x);
+            }
+        }
+        pixels_position.push_back(width_bin_barcode - 1);
+        for (size_t i = 2; i < pixels_position.size() - 3; i+=2)
+        {
+            test_lines[0] = static_cast<double>(pixels_position[i - 1] - pixels_position[i - 2]);
+            test_lines[1] = static_cast<double>(pixels_position[i    ] - pixels_position[i - 1]);
+            test_lines[2] = static_cast<double>(pixels_position[i + 1] - pixels_position[i    ]);
+            test_lines[3] = static_cast<double>(pixels_position[i + 2] - pixels_position[i + 1]);
+            test_lines[4] = static_cast<double>(pixels_position[i + 3] - pixels_position[i + 2]);
+
+            double length = 0.0, weight = 0.0;  // TODO avoid 'double' calculations
+
+            for (size_t j = 0; j < test_lines_size; j++) { length += test_lines[j]; }
+
+            if (length == 0) { continue; }
+            for (size_t j = 0; j < test_lines_size; j++)
+            {
+                if (j != 2) { weight += fabs((test_lines[j] / length) - 1.0/7.0); }
+                else        { weight += fabs((test_lines[j] / length) - 3.0/7.0); }
+            }
+
+            if (weight < eps_vertical)
+            {
+                Vec3d line;
+                line[0] = static_cast<double>(pixels_position[i - 2]);
+                line[1] = y;
+                line[2] = length;
+                result.push_back(line);
+            }
+        }
+    }
+    return result;
+}
+
+vector<Point2f> QRDetect::separateVerticalLines(const vector<Vec3d> &list_lines)
+{
+    CV_TRACE_FUNCTION();
+    const double min_dist_between_points = 10.0;
+    const double max_ratio = 1.0;
+    for (int coeff_epsilon_i = 1; coeff_epsilon_i < 101; ++coeff_epsilon_i)
+    {
+        const float coeff_epsilon = coeff_epsilon_i * 0.1f;
+        vector<Point2f> point2f_result = extractVerticalLines(list_lines, eps_horizontal * coeff_epsilon);
+        if (!point2f_result.empty())
+        {
+            vector<Point2f> centers;
+            Mat labels;
+            double compactness = kmeans(
+                    point2f_result, 3, labels,
+                    TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1),
+                    3, KMEANS_PP_CENTERS, centers);
+            double min_dist = std::numeric_limits<double>::max();
+            for (size_t i = 0; i < centers.size(); i++)
+            {
+                double dist = norm(centers[i] - centers[(i+1) % centers.size()]);
+                if (dist < min_dist)
+                {
+                    min_dist = dist;
+                }
+            }
+            if (min_dist < min_dist_between_points)
+            {
+                continue;
+            }
+            double mean_compactness = compactness / point2f_result.size();
+            double ratio = mean_compactness / min_dist;
+
+            if (ratio < max_ratio)
+            {
+                return point2f_result;
+            }
+        }
+    }
+    return vector<Point2f>();  // nothing
+}
+
+vector<Point2f> QRDetect::extractVerticalLines(const vector<Vec3d> &list_lines, double eps)
+{
+    CV_TRACE_FUNCTION();
+    vector<Vec3d> result;
+    vector<double> test_lines; test_lines.reserve(6);
+
+    for (size_t pnt = 0; pnt < list_lines.size(); pnt++)
+    {
+        const int x = cvRound(list_lines[pnt][0] + list_lines[pnt][2] * 0.5);
+        const int y = cvRound(list_lines[pnt][1]);
+
+        // --------------- Search vertical up-lines --------------- //
+
+        test_lines.clear();
+        uint8_t future_pixel_up = 255;
+
+        int temp_length_up = 0;
+        for (int j = y; j < bin_barcode.rows - 1; j++)
+        {
+            uint8_t next_pixel = bin_barcode.ptr<uint8_t>(j + 1)[x];
+            temp_length_up++;
+            if (next_pixel == future_pixel_up)
+            {
+                future_pixel_up = static_cast<uint8_t>(~future_pixel_up);
+                test_lines.push_back(temp_length_up);
+                temp_length_up = 0;
+                if (test_lines.size() == 3)
+                    break;
+            }
+        }
+
+        // --------------- Search vertical down-lines --------------- //
+
+        int temp_length_down = 0;
+        uint8_t future_pixel_down = 255;
+        for (int j = y; j >= 1; j--)
+        {
+            uint8_t next_pixel = bin_barcode.ptr<uint8_t>(j - 1)[x];
+            temp_length_down++;
+            if (next_pixel == future_pixel_down)
+            {
+                future_pixel_down = static_cast<uint8_t>(~future_pixel_down);
+                test_lines.push_back(temp_length_down);
+                temp_length_down = 0;
+                if (test_lines.size() == 6)
+                    break;
+            }
+        }
+
+        // --------------- Compute vertical lines --------------- //
+
+        if (test_lines.size() == 6)
+        {
+            double length = 0.0, weight = 0.0;  // TODO avoid 'double' calculations
+
+            for (size_t i = 0; i < test_lines.size(); i++)
+                length += test_lines[i];
+
+            CV_Assert(length > 0);
+            for (size_t i = 0; i < test_lines.size(); i++)
+            {
+                if (i % 3 != 0)
+                {
+                    weight += fabs((test_lines[i] / length) - 1.0/ 7.0);
+                }
+                else
+                {
+                    weight += fabs((test_lines[i] / length) - 3.0/14.0);
+                }
+            }
+
+            if (weight < eps)
+            {
+                result.push_back(list_lines[pnt]);
+            }
+        }
+    }
+
+    vector<Point2f> point2f_result;
+    if (result.size() > 2)
+    {
+        for (size_t i = 0; i < result.size(); i++)
+        {
+            point2f_result.push_back(
+                  Point2f(static_cast<float>(result[i][0] + result[i][2] * 0.5),
+                          static_cast<float>(result[i][1])));
+        }
+    }
+    return point2f_result;
+}
+
+void QRDetect::fixationPoints(vector<Point2f> &local_point)
+{
+    CV_TRACE_FUNCTION();
+    double cos_angles[3], norm_triangl[3];
+
+    norm_triangl[0] = norm(local_point[1] - local_point[2]);
+    norm_triangl[1] = norm(local_point[0] - local_point[2]);
+    norm_triangl[2] = norm(local_point[1] - local_point[0]);
+
+    cos_angles[0] = (norm_triangl[1] * norm_triangl[1] + norm_triangl[2] * norm_triangl[2]
+                  -  norm_triangl[0] * norm_triangl[0]) / (2 * norm_triangl[1] * norm_triangl[2]);
+    cos_angles[1] = (norm_triangl[0] * norm_triangl[0] + norm_triangl[2] * norm_triangl[2]
+                  -  norm_triangl[1] * norm_triangl[1]) / (2 * norm_triangl[0] * norm_triangl[2]);
+    cos_angles[2] = (norm_triangl[0] * norm_triangl[0] + norm_triangl[1] * norm_triangl[1]
+                  -  norm_triangl[2] * norm_triangl[2]) / (2 * norm_triangl[0] * norm_triangl[1]);
+
+    const double angle_barrier = 0.85;
+    if (fabs(cos_angles[0]) > angle_barrier || fabs(cos_angles[1]) > angle_barrier || fabs(cos_angles[2]) > angle_barrier)
+    {
+        local_point.clear();
+        return;
+    }
+
+    size_t i_min_cos =
+       (cos_angles[0] < cos_angles[1] && cos_angles[0] < cos_angles[2]) ? 0 :
+       (cos_angles[1] < cos_angles[0] && cos_angles[1] < cos_angles[2]) ? 1 : 2;
+
+    size_t index_max = 0;
+    double max_area = std::numeric_limits<double>::min();
+    for (size_t i = 0; i < local_point.size(); i++)
+    {
+        const size_t current_index = i % 3;
+        const size_t left_index  = (i + 1) % 3;
+        const size_t right_index = (i + 2) % 3;
+
+        const Point2f current_point(local_point[current_index]),
+            left_point(local_point[left_index]), right_point(local_point[right_index]),
+            central_point(intersectionLines(current_point,
+                              Point2f(static_cast<float>((local_point[left_index].x + local_point[right_index].x) * 0.5),
+                                      static_cast<float>((local_point[left_index].y + local_point[right_index].y) * 0.5)),
+                              Point2f(0, static_cast<float>(bin_barcode.rows - 1)),
+                              Point2f(static_cast<float>(bin_barcode.cols - 1),
+                                      static_cast<float>(bin_barcode.rows - 1))));
+
+        vector<Point2f> list_area_pnt;
+        list_area_pnt.push_back(current_point);
+
+        vector<LineIterator> list_line_iter;
+        list_line_iter.emplace_back(bin_barcode, current_point, left_point);
+        list_line_iter.emplace_back(bin_barcode, current_point, central_point);
+        list_line_iter.emplace_back(bin_barcode, current_point, right_point);
+
+        for (size_t k = 0; k < list_line_iter.size(); k++)
+        {
+            LineIterator& li = list_line_iter[k];
+            uint8_t future_pixel = 255, count_index = 0;
+            for(int j = 0; j < li.count; j++, ++li)
+            {
+                const Point p = li.pos();
+                if (p.x >= bin_barcode.cols ||
+                    p.y >= bin_barcode.rows)
+                {
+                    break;
+                }
+
+                const uint8_t value = bin_barcode.at<uint8_t>(p);
+                if (value == future_pixel)
+                {
+                    future_pixel = static_cast<uint8_t>(~future_pixel);
+                    count_index++;
+                    if (count_index == 3)
+                    {
+                        list_area_pnt.push_back(p);
+                        break;
+                    }
+                }
+            }
+        }
+
+        const double temp_check_area = contourArea(list_area_pnt);
+        if (temp_check_area > max_area)
+        {
+            index_max = current_index;
+            max_area = temp_check_area;
+        }
+
+    }
+    if (index_max == i_min_cos) { std::swap(local_point[0], local_point[index_max]); }
+    else { local_point.clear(); return; }
+
+    const Point2f rpt = local_point[0], bpt = local_point[1], gpt = local_point[2];
+    Matx22f m(rpt.x - bpt.x, rpt.y - bpt.y, gpt.x - rpt.x, gpt.y - rpt.y);
+    if( determinant(m) > 0 )
+    {
+        std::swap(local_point[1], local_point[2]);
+    }
+}
+
+bool QRDetect::localization()
+{
+    CV_TRACE_FUNCTION();
+    Point2f begin, end;
+    vector<Vec3d> list_lines_x = searchHorizontalLines();
+    vector<Point2f> list_lines_y;
+    Mat labels;
+    if (!list_lines_x.empty())
+    {
+        list_lines_y = separateVerticalLines(list_lines_x);
+        if (!list_lines_y.empty())
+        {
+            kmeans(list_lines_y, 3, labels,
+                TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1),
+                3, KMEANS_PP_CENTERS, localization_points);
+
+            fixationPoints(localization_points);
+        }
+    }
+
+    if (labels.empty())
+    {
+        localization_points.clear();
+    }
+
+    bool square_flag = false, local_points_flag = false;
+    double triangle_sides[3];
+    double triangle_perim, square_area, img_square_area;
+    if (localization_points.size() == 3)
+    {
+        triangle_sides[0] = norm(localization_points[0] - localization_points[1]);
+        triangle_sides[1] = norm(localization_points[1] - localization_points[2]);
+        triangle_sides[2] = norm(localization_points[2] - localization_points[0]);
+
+        triangle_perim = (triangle_sides[0] + triangle_sides[1] + triangle_sides[2]) / 2;
+
+        square_area = sqrt((triangle_perim * (triangle_perim - triangle_sides[0])
+                                           * (triangle_perim - triangle_sides[1])
+                                           * (triangle_perim - triangle_sides[2]))) * 2;
+        img_square_area = bin_barcode.cols * bin_barcode.rows;
+
+        if (square_area > (img_square_area * 0.2))
+        {
+            square_flag = true;
+        }
+    }
+    else
+    {
+        local_points_flag = true;
+    }
+    if ((square_flag || local_points_flag) && purpose == SHRINKING)
+    {
+        localization_points.clear();
+        bin_barcode = resized_bin_barcode.clone();
+        list_lines_x = searchHorizontalLines();
+        if( list_lines_x.empty() ) { return false; }
+        list_lines_y = separateVerticalLines(list_lines_x);
+        if( list_lines_y.empty() ) { return false; }
+
+        kmeans(list_lines_y, 3, labels,
+               TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1),
+               3, KMEANS_PP_CENTERS, localization_points);
+
+        fixationPoints(localization_points);
+        if (localization_points.size() != 3) { return false; }
+
+        const int width  = cvRound(bin_barcode.size().width  * coeff_expansion);
+        const int height = cvRound(bin_barcode.size().height * coeff_expansion);
+        Size new_size(width, height);
+        Mat intermediate;
+        resize(bin_barcode, intermediate, new_size, 0, 0, INTER_LINEAR_EXACT);
+        bin_barcode = intermediate.clone();
+        for (size_t i = 0; i < localization_points.size(); i++)
+        {
+            localization_points[i] *= coeff_expansion;
+        }
+    }
+    if (purpose == ZOOMING)
+    {
+        const int width  = cvRound(bin_barcode.size().width  / coeff_expansion);
+        const int height = cvRound(bin_barcode.size().height / coeff_expansion);
+        Size new_size(width, height);
+        Mat intermediate;
+        resize(bin_barcode, intermediate, new_size, 0, 0, INTER_LINEAR_EXACT);
+        bin_barcode = intermediate.clone();
+        for (size_t i = 0; i < localization_points.size(); i++)
+        {
+            localization_points[i] /= coeff_expansion;
+        }
+    }
+
+    for (size_t i = 0; i < localization_points.size(); i++)
+    {
+        for (size_t j = i + 1; j < localization_points.size(); j++)
+        {
+            if (norm(localization_points[i] - localization_points[j]) < 10)
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+
+}
+
+bool QRDetect::computeTransformationPoints()
+{
+    CV_TRACE_FUNCTION();
+    if (localization_points.size() != 3) { return false; }
+
+    vector<Point> locations, non_zero_elem[3], newHull;
+    vector<Point2f> new_non_zero_elem[3];
+    for (size_t i = 0; i < 3; i++)
+    {
+        Mat mask = Mat::zeros(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1);
+        uint8_t next_pixel, future_pixel = 255;
+        int count_test_lines = 0, index_c = max(0, min(cvRound(localization_points[i].x), bin_barcode.cols - 1));
+        const int index_r = max(0, min(cvRound(localization_points[i].y), bin_barcode.rows - 1));
+        for (; index_c < bin_barcode.cols - 1; index_c++)
+        {
+            next_pixel = bin_barcode.ptr<uint8_t>(index_r)[index_c + 1];
+            if (next_pixel == future_pixel)
+            {
+                future_pixel = static_cast<uint8_t>(~future_pixel);
+                count_test_lines++;
+                if (count_test_lines == 2)
+                {
+                    floodFill(bin_barcode, mask,
+                              Point(index_c + 1, index_r), 255,
+                              0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+                    break;
+                }
+            }
+        }
+        Mat mask_roi = mask(Range(1, bin_barcode.rows - 1), Range(1, bin_barcode.cols - 1));
+        findNonZero(mask_roi, non_zero_elem[i]);
+        newHull.insert(newHull.end(), non_zero_elem[i].begin(), non_zero_elem[i].end());
+    }
+    convexHull(newHull, locations);
+    for (size_t i = 0; i < locations.size(); i++)
+    {
+        for (size_t j = 0; j < 3; j++)
+        {
+            for (size_t k = 0; k < non_zero_elem[j].size(); k++)
+            {
+                if (locations[i] == non_zero_elem[j][k])
+                {
+                    new_non_zero_elem[j].push_back(locations[i]);
+                }
+            }
+        }
+    }
+
+    double pentagon_diag_norm = -1;
+    Point2f down_left_edge_point, up_right_edge_point, up_left_edge_point;
+    for (size_t i = 0; i < new_non_zero_elem[1].size(); i++)
+    {
+        for (size_t j = 0; j < new_non_zero_elem[2].size(); j++)
+        {
+            double temp_norm = norm(new_non_zero_elem[1][i] - new_non_zero_elem[2][j]);
+            if (temp_norm > pentagon_diag_norm)
+            {
+                down_left_edge_point = new_non_zero_elem[1][i];
+                up_right_edge_point  = new_non_zero_elem[2][j];
+                pentagon_diag_norm = temp_norm;
+            }
+        }
+    }
+
+    if (down_left_edge_point == Point2f(0, 0) ||
+        up_right_edge_point  == Point2f(0, 0) ||
+        new_non_zero_elem[0].size() == 0) { return false; }
+
+    double max_area = -1;
+    up_left_edge_point = new_non_zero_elem[0][0];
+
+    for (size_t i = 0; i < new_non_zero_elem[0].size(); i++)
+    {
+        vector<Point2f> list_edge_points;
+        list_edge_points.push_back(new_non_zero_elem[0][i]);
+        list_edge_points.push_back(down_left_edge_point);
+        list_edge_points.push_back(up_right_edge_point);
+
+        double temp_area = fabs(contourArea(list_edge_points));
+        if (max_area < temp_area)
+        {
+            up_left_edge_point = new_non_zero_elem[0][i];
+            max_area = temp_area;
+        }
+    }
+
+    Point2f down_max_delta_point, up_max_delta_point;
+    double norm_down_max_delta = -1, norm_up_max_delta = -1;
+    for (size_t i = 0; i < new_non_zero_elem[1].size(); i++)
+    {
+        double temp_norm_delta = norm(up_left_edge_point - new_non_zero_elem[1][i])
+                               + norm(down_left_edge_point - new_non_zero_elem[1][i]);
+        if (norm_down_max_delta < temp_norm_delta)
+        {
+            down_max_delta_point = new_non_zero_elem[1][i];
+            norm_down_max_delta = temp_norm_delta;
+        }
+    }
+
+
+    for (size_t i = 0; i < new_non_zero_elem[2].size(); i++)
+    {
+        double temp_norm_delta = norm(up_left_edge_point - new_non_zero_elem[2][i])
+                               + norm(up_right_edge_point - new_non_zero_elem[2][i]);
+        if (norm_up_max_delta < temp_norm_delta)
+        {
+            up_max_delta_point = new_non_zero_elem[2][i];
+            norm_up_max_delta = temp_norm_delta;
+        }
+    }
+
+    transformation_points.push_back(down_left_edge_point);
+    transformation_points.push_back(up_left_edge_point);
+    transformation_points.push_back(up_right_edge_point);
+    transformation_points.push_back(
+        intersectionLines(down_left_edge_point, down_max_delta_point,
+                          up_right_edge_point, up_max_delta_point));
+    vector<Point2f> quadrilateral = getQuadrilateral(transformation_points);
+    transformation_points = quadrilateral;
+
+    int width = bin_barcode.size().width;
+    int height = bin_barcode.size().height;
+    for (size_t i = 0; i < transformation_points.size(); i++)
+    {
+        if ((cvRound(transformation_points[i].x) > width) ||
+            (cvRound(transformation_points[i].y) > height)) { return false; }
+    }
+    return true;
+}
+
+// test function (if true then ------> else <------ )
+bool QRDetect::testByPassRoute(vector<Point2f> hull, int start, int finish)
+{
+    CV_TRACE_FUNCTION();
+    int index_hull = start, next_index_hull, hull_size = (int)hull.size();
+    double test_length[2] = { 0.0, 0.0 };
+    do
+    {
+        next_index_hull = index_hull + 1;
+        if (next_index_hull == hull_size) { next_index_hull = 0; }
+        test_length[0] += norm(hull[index_hull] - hull[next_index_hull]);
+        index_hull = next_index_hull;
+    }
+    while(index_hull != finish);
+
+    index_hull = start;
+    do
+    {
+        next_index_hull = index_hull - 1;
+        if (next_index_hull == -1) { next_index_hull = hull_size - 1; }
+        test_length[1] += norm(hull[index_hull] - hull[next_index_hull]);
+        index_hull = next_index_hull;
+    }
+    while(index_hull != finish);
+
+    if (test_length[0] < test_length[1]) { return true; } else { return false; }
+}
+
+vector<Point2f> QRDetect::getQuadrilateral(vector<Point2f> angle_list)
+{
+    CV_TRACE_FUNCTION();
+    size_t angle_size = angle_list.size();
+    uint8_t value, mask_value;
+    Mat mask = Mat::zeros(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1);
+    Mat fill_bin_barcode = bin_barcode.clone();
+    for (size_t i = 0; i < angle_size; i++)
+    {
+        LineIterator line_iter(bin_barcode, angle_list[ i      % angle_size],
+                                            angle_list[(i + 1) % angle_size]);
+        for(int j = 0; j < line_iter.count; j++, ++line_iter)
+        {
+            Point p = line_iter.pos();
+            value = bin_barcode.at<uint8_t>(p);
+            mask_value = mask.at<uint8_t>(p + Point(1, 1));
+            if (value == 0 && mask_value == 0)
+            {
+                floodFill(fill_bin_barcode, mask, p, 255,
+                          0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+            }
+        }
+    }
+    vector<Point> locations;
+    Mat mask_roi = mask(Range(1, bin_barcode.rows - 1), Range(1, bin_barcode.cols - 1));
+
+    findNonZero(mask_roi, locations);
+
+    for (size_t i = 0; i < angle_list.size(); i++)
+    {
+        int x = cvRound(angle_list[i].x);
+        int y = cvRound(angle_list[i].y);
+        locations.emplace_back(x,y);
+    }
+
+    vector<Point> integer_hull;
+    convexHull(locations, integer_hull);
+    int hull_size = (int)integer_hull.size();
+    vector<Point2f> hull(hull_size);
+    for (int i = 0; i < hull_size; i++)
+    {
+        float x = saturate_cast<float>(integer_hull[i].x);
+        float y = saturate_cast<float>(integer_hull[i].y);
+        hull[i] = Point2f(x, y);
+    }
+
+    const double experimental_area = fabs(contourArea(hull));
+
+    vector<Point2f> result_hull_point(angle_size);
+    vector<bool> used_hull_point(hull_size, false);
+    double min_norm;
+    for (size_t i = 0; i < angle_size; i++)
+    {
+        min_norm = std::numeric_limits<double>::max();
+        int closest_pnt_idx = -1;
+        for (int j = 0; j < hull_size; j++)
+        {
+            if (used_hull_point[j])
+            {
+                continue;
+            }
+            double temp_norm = norm(hull[j] - angle_list[i]);
+            if (min_norm > temp_norm)
+            {
+                min_norm = temp_norm;
+                closest_pnt_idx = j;
+            }
+        }
+        result_hull_point[i] = hull[closest_pnt_idx];
+        used_hull_point[closest_pnt_idx] = true;
+    }
+
+    int start_line[2] = { 0, 0 }, finish_line[2] = { 0, 0 }, unstable_pnt = 0;
+    for (int i = 0; i < hull_size; i++)
+    {
+        if (result_hull_point[2] == hull[i]) { start_line[0] = i; }
+        if (result_hull_point[1] == hull[i]) { finish_line[0] = start_line[1] = i; }
+        if (result_hull_point[0] == hull[i]) { finish_line[1] = i; }
+        if (result_hull_point[3] == hull[i]) { unstable_pnt = i; }
+    }
+
+    int index_hull, extra_index_hull, next_index_hull, extra_next_index_hull;
+    Point result_side_begin[4], result_side_end[4];
+
+    bool bypass_orientation = testByPassRoute(hull, start_line[0], finish_line[0]);
+
+    min_norm = std::numeric_limits<double>::max();
+    index_hull = start_line[0];
+    do
+    {
+        if (bypass_orientation) { next_index_hull = index_hull + 1; }
+        else { next_index_hull = index_hull - 1; }
+
+        if (next_index_hull == hull_size) { next_index_hull = 0; }
+        if (next_index_hull == -1) { next_index_hull = hull_size - 1; }
+
+        Point angle_closest_pnt =  norm(hull[index_hull] - angle_list[1]) >
+        norm(hull[index_hull] - angle_list[2]) ? angle_list[2] : angle_list[1];
+
+        Point intrsc_line_hull =
+        intersectionLines(hull[index_hull], hull[next_index_hull],
+                          angle_list[1], angle_list[2]);
+        double temp_norm = min_norm;
+        if (intrsc_line_hull != angle_closest_pnt)
+        {
+            temp_norm = getCosVectors(hull[index_hull], intrsc_line_hull, angle_closest_pnt);
+        }
+        if (min_norm > temp_norm &&
+            norm(hull[index_hull] - hull[next_index_hull]) >
+            norm(angle_list[1] - angle_list[2]) * 0.1)
+        {
+            min_norm = temp_norm;
+            result_side_begin[0] = hull[index_hull];
+            result_side_end[0]   = hull[next_index_hull];
+        }
+
+
+        index_hull = next_index_hull;
+    }
+    while(index_hull != finish_line[0]);
+
+    if (min_norm == std::numeric_limits<double>::max())
+    {
+        result_side_begin[0] = angle_list[1];
+        result_side_end[0]   = angle_list[2];
+    }
+
+    min_norm = std::numeric_limits<double>::max();
+    index_hull = start_line[1];
+    bypass_orientation = testByPassRoute(hull, start_line[1], finish_line[1]);
+    do
+    {
+        if (bypass_orientation) { next_index_hull = index_hull + 1; }
+        else { next_index_hull = index_hull - 1; }
+
+        if (next_index_hull == hull_size) { next_index_hull = 0; }
+        if (next_index_hull == -1) { next_index_hull = hull_size - 1; }
+
+        Point angle_closest_pnt =  norm(hull[index_hull] - angle_list[0]) >
+        norm(hull[index_hull] - angle_list[1]) ? angle_list[1] : angle_list[0];
+
+        Point intrsc_line_hull =
+        intersectionLines(hull[index_hull], hull[next_index_hull],
+                          angle_list[0], angle_list[1]);
+        double temp_norm = min_norm;
+        if (intrsc_line_hull != angle_closest_pnt)
+        {
+            temp_norm = getCosVectors(hull[index_hull], intrsc_line_hull, angle_closest_pnt);
+        }
+        if (min_norm > temp_norm &&
+            norm(hull[index_hull] - hull[next_index_hull]) >
+            norm(angle_list[0] - angle_list[1]) * 0.05)
+        {
+            min_norm = temp_norm;
+            result_side_begin[1] = hull[index_hull];
+            result_side_end[1]   = hull[next_index_hull];
+        }
+
+        index_hull = next_index_hull;
+    }
+    while(index_hull != finish_line[1]);
+
+    if (min_norm == std::numeric_limits<double>::max())
+    {
+        result_side_begin[1] = angle_list[0];
+        result_side_end[1]   = angle_list[1];
+    }
+
+    bypass_orientation = testByPassRoute(hull, start_line[0], unstable_pnt);
+    const bool extra_bypass_orientation = testByPassRoute(hull, finish_line[1], unstable_pnt);
+
+    vector<Point2f> result_angle_list(4), test_result_angle_list(4);
+    double min_diff_area = std::numeric_limits<double>::max();
+    index_hull = start_line[0];
+    const double standart_norm = std::max(
+        norm(result_side_begin[0] - result_side_end[0]),
+        norm(result_side_begin[1] - result_side_end[1]));
+    do
+    {
+        if (bypass_orientation) { next_index_hull = index_hull + 1; }
+        else { next_index_hull = index_hull - 1; }
+
+        if (next_index_hull == hull_size) { next_index_hull = 0; }
+        if (next_index_hull == -1) { next_index_hull = hull_size - 1; }
+
+        if (norm(hull[index_hull] - hull[next_index_hull]) < standart_norm * 0.1)
+        { index_hull = next_index_hull; continue; }
+
+        extra_index_hull = finish_line[1];
+        do
+        {
+            if (extra_bypass_orientation) { extra_next_index_hull = extra_index_hull + 1; }
+            else { extra_next_index_hull = extra_index_hull - 1; }
+
+            if (extra_next_index_hull == hull_size) { extra_next_index_hull = 0; }
+            if (extra_next_index_hull == -1) { extra_next_index_hull = hull_size - 1; }
+
+            if (norm(hull[extra_index_hull] - hull[extra_next_index_hull]) < standart_norm * 0.1)
+            { extra_index_hull = extra_next_index_hull; continue; }
+
+            test_result_angle_list[0]
+            = intersectionLines(result_side_begin[0], result_side_end[0],
+                                result_side_begin[1], result_side_end[1]);
+            test_result_angle_list[1]
+            = intersectionLines(result_side_begin[1], result_side_end[1],
+                                hull[extra_index_hull], hull[extra_next_index_hull]);
+            test_result_angle_list[2]
+            = intersectionLines(hull[extra_index_hull], hull[extra_next_index_hull],
+                                hull[index_hull], hull[next_index_hull]);
+            test_result_angle_list[3]
+            = intersectionLines(hull[index_hull], hull[next_index_hull],
+                                result_side_begin[0], result_side_end[0]);
+
+            const double test_diff_area
+                = fabs(fabs(contourArea(test_result_angle_list)) - experimental_area);
+            if (min_diff_area > test_diff_area)
+            {
+                min_diff_area = test_diff_area;
+                for (size_t i = 0; i < test_result_angle_list.size(); i++)
+                {
+                    result_angle_list[i] = test_result_angle_list[i];
+                }
+            }
+
+            extra_index_hull = extra_next_index_hull;
+        }
+        while(extra_index_hull != unstable_pnt);
+
+        index_hull = next_index_hull;
+    }
+    while(index_hull != unstable_pnt);
+
+    // check label points
+    if (norm(result_angle_list[0] - angle_list[1]) > 2) { result_angle_list[0] = angle_list[1]; }
+    if (norm(result_angle_list[1] - angle_list[0]) > 2) { result_angle_list[1] = angle_list[0]; }
+    if (norm(result_angle_list[3] - angle_list[2]) > 2) { result_angle_list[3] = angle_list[2]; }
+
+    // check calculation point
+    if (norm(result_angle_list[2] - angle_list[3]) >
+       (norm(result_angle_list[0] - result_angle_list[1]) +
+        norm(result_angle_list[0] - result_angle_list[3])) * 0.5 )
+    { result_angle_list[2] = angle_list[3]; }
+
+    return result_angle_list;
+}
+
+struct ImplContour : public GraphicalCodeDetector::Impl
+{
+public:
+    ImplContour(): epsX(0.2), epsY(0.1)  {}
+
+    double epsX, epsY;
+    mutable vector<vector<Point2f>> alignmentMarkers;
+    mutable vector<Point2f> updateQrCorners;
+    mutable vector<QRCodeEncoder::ECIEncodings> encodings;
+    bool useAlignmentMarkers = true;
+
+    bool detect(InputArray in, OutputArray points) const override;
+    std::string decode(InputArray img, InputArray points, OutputArray straight_qrcode) const override;
+    std::string detectAndDecode(InputArray img, OutputArray points, OutputArray straight_qrcode) const override;
+
+    bool detectMulti(InputArray img, OutputArray points) const override;
+    bool decodeMulti(InputArray img, InputArray points, std::vector<cv::String>& decoded_info,
+                     OutputArrayOfArrays straight_qrcode) const override;
+    bool detectAndDecodeMulti(InputArray img, std::vector<cv::String>& decoded_info, OutputArray points,
+                              OutputArrayOfArrays straight_qrcode) const override;
+
+    String decodeCurved(InputArray in, InputArray points, OutputArray straight_qrcode);
+
+    std::string detectAndDecodeCurved(InputArray in, OutputArray points, OutputArray straight_qrcode);
+
+    QRCodeEncoder::ECIEncodings getEncoding(int codeIdx);
+};
+
+QRCodeDetector::QRCodeDetector() {
+    p = makePtr<ImplContour>();
+}
+
+QRCodeDetector& QRCodeDetector::setEpsX(double epsX) {
+    std::dynamic_pointer_cast<ImplContour>(p)->epsX = epsX;
+    return *this;
+}
+
+QRCodeDetector& QRCodeDetector::setEpsY(double epsY) {
+    std::dynamic_pointer_cast<ImplContour>(p)->epsY = epsY;
+    return *this;
+}
+
+QRCodeEncoder::ECIEncodings QRCodeDetector::getEncoding(int codeIdx) {
+    auto& encodings = std::dynamic_pointer_cast<ImplContour>(p)->encodings;
+    CV_Assert(codeIdx >= 0);
+    CV_Assert(codeIdx < static_cast<int>(encodings.size()));
+    return encodings[codeIdx];
+}
+
+bool ImplContour::detect(InputArray in, OutputArray points) const
+{
+    Mat inarr;
+    if (!checkQRInputImage(in, inarr))
+        return false;
+
+    QRDetect qrdet;
+    qrdet.init(inarr, epsX, epsY);
+    if (!qrdet.localization()) { return false; }
+    if (!qrdet.computeTransformationPoints()) { return false; }
+    vector<Point2f> pnts2f = qrdet.getTransformationPoints();
+    updatePointsResult(points, pnts2f);
+    return true;
+}
+
+class QRDecode
+{
+public:
+    QRDecode(bool useAlignmentMarkers);
+    void init(const Mat &src, const vector<Point2f> &points);
+    Mat getIntermediateBarcode() { return intermediate; }
+    Mat getStraightBarcode() { return straight; }
+    size_t getVersion() { return version; }
+    std::string getDecodeInformation() { return result_info; }
+    bool straightDecodingProcess();
+    bool curvedDecodingProcess();
+    vector<Point2f> alignment_coords;
+    float coeff_expansion = 1.f;
+    vector<Point2f> getOriginalPoints() {return original_points;}
+    bool useAlignmentMarkers;
+
+    // Structured Append mode generates a sequence of QR codes.
+    // Final message is restored according to the index of the code in sequence.
+    // Different QR codes are grouped by a parity value.
+    bool isStructured() { return mode == QRCodeEncoder::EncodeMode::MODE_STRUCTURED_APPEND; }
+    struct {
+        uint8_t parity = 0;
+        uint8_t sequence_num = 0;
+        uint8_t total_num = 1;
+    } structure_info;
+
+    QRCodeEncoder::ECIEncodings eci;
+
+protected:
+    double getNumModules();
+    Mat getHomography() {
+        CV_TRACE_FUNCTION();
+        vector<Point2f> perspective_points = {{0.f, 0.f}, {test_perspective_size, 0.f},
+                                              {test_perspective_size, test_perspective_size},
+                                              {0.f, test_perspective_size}};
+        vector<Point2f> pts = original_points;
+        return findHomography(pts, perspective_points);
+    }
+    bool updatePerspective(const Mat& H);
+    bool versionDefinition();
+    void detectAlignment();
+    bool samplingForVersion();
+    bool decodingProcess();
+    inline double pointPosition(Point2f a, Point2f b , Point2f c);
+    float distancePointToLine(Point2f a, Point2f b , Point2f c);
+    void getPointsInsideQRCode(const vector<Point2f> &angle_list);
+    bool computeClosestPoints(const vector<Point> &result_integer_hull);
+    bool computeSidesPoints(const vector<Point> &result_integer_hull);
+    vector<Point> getPointsNearUnstablePoint(const vector<Point> &side, int start, int end, int step);
+    bool findAndAddStablePoint();
+    bool findIndexesCurvedSides();
+    bool findIncompleteIndexesCurvedSides();
+    Mat getPatternsMask();
+    Point findClosestZeroPoint(Point2f original_point);
+    bool findPatternsContours(vector<vector<Point> > &patterns_contours);
+    bool findPatternsVerticesPoints(vector<vector<Point> > &patterns_vertices_points);
+    bool findTempPatternsAddingPoints(vector<std::pair<int, vector<Point> > > &temp_patterns_add_points);
+    bool computePatternsAddingPoints(std::map<int, vector<Point> > &patterns_add_points);
+    bool addPointsToSides();
+    void completeAndSortSides();
+    vector<vector<float> > computeSpline(const vector<int> &x_arr, const vector<int> &y_arr);
+    bool createSpline(vector<vector<Point2f> > &spline_lines);
+    bool divideIntoEvenSegments(vector<vector<Point2f> > &segments_points);
+    bool straightenQRCodeInParts();
+    bool preparingCurvedQRCodes();
+
+    const static int NUM_SIDES = 2;
+    Mat original, bin_barcode, no_border_intermediate, intermediate, straight, curved_to_straight, test_image;
+    vector<Point2f> original_points;
+    Mat homography;
+    vector<Point2f> original_curved_points;
+    vector<Point> qrcode_locations;
+    vector<std::pair<size_t, Point> > closest_points;
+    vector<vector<Point> > sides_points;
+    std::pair<size_t, Point> unstable_pair;
+    vector<int> curved_indexes, curved_incomplete_indexes;
+    std::map<int, vector<Point> > complete_curved_sides;
+    std::string result_info;
+    uint8_t version, version_size;
+    float test_perspective_size;
+    QRCodeEncoder::EncodeMode mode;
+
+    struct sortPairAsc
+    {
+        bool operator()(const std::pair<size_t, double> &a,
+                        const std::pair<size_t, double> &b) const
+        {
+            return a.second < b.second;
+        }
+    };
+    struct sortPairDesc
+    {
+        bool operator()(const std::pair<size_t, double> &a,
+                        const std::pair<size_t, double> &b) const
+        {
+            return a.second > b.second;
+        }
+    };
+    struct sortPointsByX
+    {
+        bool operator()(const Point &a, const Point &b) const
+        {
+            return a.x < b.x;
+        }
+    };
+    struct sortPointsByY
+    {
+        bool operator()(const Point &a, const Point &b) const
+        {
+            return a.y < b.y;
+        }
+    };
+};
+
+float static getMinSideLen(const vector<Point2f> &points) {
+    CV_Assert(points.size() == 4ull);
+    double res = norm(points[1]-points[0]);
+    for (size_t i = 1ull; i < points.size(); i++) {
+        res = min(res, norm(points[i]-points[(i+1ull) % points.size()]));
+    }
+    return static_cast<float>(res);
+}
+
+
+void QRDecode::init(const Mat &src, const vector<Point2f> &points)
+{
+    CV_TRACE_FUNCTION();
+    vector<Point2f> bbox = points;
+    original = src.clone();
+    test_image = src.clone();
+    adaptiveThreshold(original, bin_barcode, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 83, 2);
+    intermediate = Mat::zeros(original.size(), CV_8UC1);
+    original_points = bbox;
+    version = 0;
+    version_size = 0;
+    test_perspective_size = max(getMinSideLen(points)+1.f, 251.f);
+    result_info = "";
+}
+
+inline double QRDecode::pointPosition(Point2f a, Point2f b , Point2f c)
+{
+    return (a.x - b.x) * (c.y - b.y) - (c.x - b.x) * (a.y - b.y);
+}
+
+float QRDecode::distancePointToLine(Point2f a, Point2f b , Point2f c)
+{
+    float A, B, C, result;
+    A = c.y - b.y;
+    B = c.x - b.x;
+    C = c.x * b.y - b.x * c.y;
+    float dist = sqrt(A*A + B*B);
+    if (dist == 0) return 0;
+    result = abs((A * a.x - B * a.y + C)) / dist;
+
+    return result;
+}
+
+void QRDecode::getPointsInsideQRCode(const vector<Point2f> &angle_list)
+{
+    CV_TRACE_FUNCTION();
+    size_t angle_size = angle_list.size();
+    Mat contour_mask = Mat::zeros(bin_barcode.size(), CV_8UC1);
+    for (size_t i = 0; i < angle_size; i++)
+    {
+        LineIterator line_iter(bin_barcode, angle_list[ i      % angle_size],
+                                            angle_list[(i + 1) % angle_size]);
+        for(int j = 0; j < line_iter.count; j++, ++line_iter)
+        {
+            Point p = line_iter.pos();
+            contour_mask.at<uint8_t>(p + Point(1, 1)) = 255;
+        }
+    }
+    Point2f center_point = intersectionLines(angle_list[0], angle_list[2],
+                                             angle_list[1], angle_list[3]);
+    floodFill(contour_mask, center_point, 255, 0, Scalar(), Scalar(), FLOODFILL_FIXED_RANGE);
+
+    vector<Point> locations;
+    findNonZero(contour_mask, locations);
+
+    Mat fill_bin_barcode = bin_barcode.clone();
+    Mat qrcode_mask = Mat::zeros(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1);
+    uint8_t value, mask_value;
+    for(size_t i = 0; i < locations.size(); i++)
+    {
+        value = bin_barcode.at<uint8_t>(locations[i]);
+        mask_value = qrcode_mask.at<uint8_t>(locations[i] + Point(1, 1));
+        if (value == 0 && mask_value == 0)
+        {
+            floodFill(fill_bin_barcode, qrcode_mask, locations[i], 255,
+                      0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+        }
+    }
+    Mat qrcode_mask_roi = qrcode_mask(Range(1, qrcode_mask.rows - 1), Range(1, qrcode_mask.cols - 1));
+    findNonZero(qrcode_mask_roi, qrcode_locations);
+}
+
+bool QRDecode::computeClosestPoints(const vector<Point> &result_integer_hull)
+{
+    CV_TRACE_FUNCTION();
+    double min_norm, max_norm = 0.0;
+    size_t idx_min = (size_t)-1;
+    for (size_t i = 0; i < original_points.size(); i++)
+    {
+        min_norm = std::numeric_limits<double>::max();
+
+        Point closest_pnt;
+        for (size_t j = 0; j < result_integer_hull.size(); j++)
+        {
+            Point integer_original_point = original_points[i];
+            double temp_norm = norm(integer_original_point - result_integer_hull[j]);
+            if (temp_norm < min_norm)
+            {
+                min_norm = temp_norm;
+                closest_pnt = result_integer_hull[j];
+                idx_min = j;
+            }
+        }
+        if (min_norm > max_norm)
+        {
+            max_norm = min_norm;
+            unstable_pair = std::pair<size_t,Point>(i, closest_pnt);
+        }
+        CV_Assert(idx_min != (size_t)-1);
+        closest_points.push_back(std::pair<size_t,Point>(idx_min, closest_pnt));
+    }
+
+    if (closest_points.size() != 4)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool QRDecode::computeSidesPoints(const vector<Point> &result_integer_hull)
+{
+    size_t num_closest_points = closest_points.size();
+    vector<Point> points;
+
+    for(size_t i = 0; i < num_closest_points; i++)
+    {
+        points.clear();
+        size_t start = closest_points[i].first,
+               end   = closest_points[(i + 1) % num_closest_points].first;
+        if (start < end)
+        {
+            points.insert(points.end(),
+                          result_integer_hull.begin() + start,
+                          result_integer_hull.begin() + end + 1);
+        }
+        else
+        {
+            points.insert(points.end(),
+                          result_integer_hull.begin() + start,
+                          result_integer_hull.end());
+            points.insert(points.end(),
+                          result_integer_hull.begin(),
+                          result_integer_hull.begin() + end + 1);
+        }
+        if (abs(result_integer_hull[start].x - result_integer_hull[end].x) >
+            abs(result_integer_hull[start].y - result_integer_hull[end].y))
+        {
+            if (points.front().x > points.back().x)
+            {
+                std::reverse(points.begin(), points.end());
+            }
+        }
+        else
+        {
+            if (points.front().y > points.back().y)
+            {
+                std::reverse(points.begin(), points.end());
+            }
+        }
+        if (points.empty())
+        {
+            return false;
+        }
+        sides_points.push_back(points);
+    }
+
+    return true;
+}
+
+vector<Point> QRDecode::getPointsNearUnstablePoint(const vector<Point> &side, int start, int end, int step)
+{
+    vector<Point> points;
+    Point p1, p2, p3;
+
+    double max_neighbour_angle = 1.0;
+    int index_max_angle = start + step;
+    bool enough_points = true;
+
+    if(side.size() < 3)
+    {
+        points.insert(points.end(), side.begin(), side.end());
+        return points;
+    }
+    const double cos_angle_threshold = -0.97;
+    for (int i = start + step; i != end; i+= step)
+    {
+        p1 = side[i + step];
+        if (norm(p1 - side[i])        < 5) { continue; }
+        p2 = side[i];
+        if (norm(p2 - side[i - step]) < 5) { continue; }
+        p3 = side[i - step];
+
+        double neighbour_angle = getCosVectors(p1, p2, p3);
+        neighbour_angle = floor(neighbour_angle*1000)/1000;
+
+        if ((neighbour_angle <= max_neighbour_angle) && (neighbour_angle < cos_angle_threshold))
+        {
+            max_neighbour_angle = neighbour_angle;
+            index_max_angle = i;
+        }
+        else if (i == end - step)
+        {
+            enough_points = false;
+            index_max_angle = i;
+        }
+    }
+
+    if (enough_points)
+    {
+        p1 = side[index_max_angle + step];
+        p2 = side[index_max_angle];
+        p3 = side[index_max_angle - step];
+
+        points.push_back(p1);
+        points.push_back(p2);
+        points.push_back(p3);
+    }
+    else
+    {
+        p1 = side[index_max_angle];
+        p2 = side[index_max_angle - step];
+
+        points.push_back(p1);
+        points.push_back(p2);
+    }
+
+    return points;
+}
+
+bool QRDecode::findAndAddStablePoint()
+{
+    size_t idx_unstable_point = unstable_pair.first;
+    Point unstable_point = unstable_pair.second;
+
+    vector<Point> current_side_points, next_side_points;
+    Point a1, a2, b1, b2;
+    int start_current, end_current, step_current, start_next, end_next, step_next;
+    vector<Point>::iterator it_a, it_b;
+
+    vector<Point> &current_side = sides_points[(idx_unstable_point + 3) % 4];
+    vector<Point> &next_side    = sides_points[idx_unstable_point];
+
+    if(current_side.size() < 2 || next_side.size() < 2)
+    {
+        return false;
+    }
+
+    if(arePointsNearest(unstable_point, current_side.front(), 3.0))
+    {
+        start_current = (int)current_side.size() - 1;
+        end_current = 0;
+        step_current = -1;
+        it_a = current_side.begin();
+    }
+    else if(arePointsNearest(unstable_point, current_side.back(), 3.0))
+    {
+        start_current = 0;
+        end_current = (int)current_side.size() - 1;
+        step_current = 1;
+        it_a = current_side.end() - 1;
+    }
+    else
+    {
+        return false;
+    }
+    if(arePointsNearest(unstable_point, next_side.front(), 3.0))
+    {
+        start_next = (int)next_side.size() - 1;
+        end_next = 0;
+        step_next = -1;
+        it_b = next_side.begin();
+    }
+    else if(arePointsNearest(unstable_point, next_side.back(), 3.0))
+    {
+        start_next = 0;
+        end_next = (int)next_side.size() - 1;
+        step_next = 1;
+        it_b = next_side.end() - 1;
+    }
+    else
+    {
+        return false;
+    }
+    current_side_points = getPointsNearUnstablePoint(current_side, start_current, end_current, step_current);
+    next_side_points    = getPointsNearUnstablePoint(next_side, start_next, end_next, step_next);
+
+    if (current_side_points.size() < 2 || next_side_points.size() < 2)
+    {
+        return false;
+    }
+
+    a1 = current_side_points[0];
+    a2 = current_side_points[1];
+
+    b1 = next_side_points[0];
+    b2 = next_side_points[1];
+
+    if(norm(a1 - b1) < 10 && next_side_points.size() > 2)
+    {
+        b1 = next_side_points[1];
+        b2 = next_side_points[2];
+    }
+
+    Point stable_point = intersectionLines(a1, a2, b1, b2);
+
+    const double max_side = std::max(bin_barcode.size().width, bin_barcode.size().height);
+    if ((abs(stable_point.x) > max_side) || (abs(stable_point.y) > max_side))
+    {
+        return false;
+    }
+
+    while (*it_a != a1)
+    {
+        it_a = current_side.erase(it_a);
+        if (it_a == current_side.end())
+        {
+            it_a -= step_current;
+        }
+        Point point_to_remove_from_current = *it_a;
+        if (point_to_remove_from_current.x > max_side || point_to_remove_from_current.y > max_side)
+        {
+            break;
+        }
+    }
+    while (*it_b != b1)
+    {
+        it_b = next_side.erase(it_b);
+        if (it_b == next_side.end())
+        {
+            it_b -= step_next;
+        }
+        Point point_to_remove_from_next = *it_b;
+        if (point_to_remove_from_next.x > max_side || point_to_remove_from_next.y > max_side)
+        {
+            break;
+        }
+    }
+
+    bool add_stable_point = true;
+
+    for (size_t i = 0; i < original_points.size(); i++)
+    {
+        if(arePointsNearest(stable_point, original_points[i], 3.0))
+        {
+            add_stable_point = false;
+            break;
+        }
+    }
+
+    if(add_stable_point)
+    {
+        current_side.insert(it_a, stable_point);
+        next_side.insert(it_b, stable_point);
+        closest_points[unstable_pair.first].second = stable_point;
+    }
+    else
+    {
+        stable_point = original_points[unstable_pair.first];
+        closest_points[unstable_pair.first].second = stable_point;
+        current_side.insert(it_a, stable_point);
+        next_side.insert(it_b, stable_point);
+    }
+
+    return true;
+}
+
+bool QRDecode::findIndexesCurvedSides()
+{
+    double max_dist_to_arc_side = 0.0;
+    size_t num_closest_points = closest_points.size();
+    int idx_curved_current = -1, idx_curved_opposite = -1;
+
+    for (size_t i = 0; i < num_closest_points; i++)
+    {
+        double dist_to_arc = 0.0;
+
+        Point arc_start = closest_points[i].second;
+        Point arc_end   = closest_points[(i + 1) % num_closest_points].second;
+
+        for (size_t j = 0; j < sides_points[i].size(); j++)
+        {
+            Point arc_point = sides_points[i][j];
+            double dist = distancePointToLine(arc_point, arc_start, arc_end);
+            dist_to_arc += dist;
+        }
+        dist_to_arc /= sides_points[i].size();
+
+        if (dist_to_arc > max_dist_to_arc_side)
+        {
+            max_dist_to_arc_side = dist_to_arc;
+            idx_curved_current = (int)i;
+            idx_curved_opposite = (int)(i + 2) % num_closest_points;
+        }
+    }
+    if (idx_curved_current == -1 || idx_curved_opposite == -1)
+    {
+        return false;
+    }
+
+    curved_indexes.push_back(idx_curved_current);
+    curved_indexes.push_back(idx_curved_opposite);
+
+    return true;
+}
+
+bool QRDecode::findIncompleteIndexesCurvedSides()
+{
+    int num_closest_points = (int)closest_points.size();
+
+    for (int i = 0; i < NUM_SIDES; i++)
+    {
+        int idx_side = curved_indexes[i];
+        int side_size = (int)sides_points[idx_side].size();
+
+        double max_norm = norm(closest_points[idx_side].second -
+                               closest_points[(idx_side + 1) % num_closest_points].second);
+        double real_max_norm = 0;
+
+        for (int j = 0; j < side_size - 1; j++)
+        {
+            double temp_norm = norm(sides_points[idx_side][j] -
+                                    sides_points[idx_side][j + 1]);
+            if (temp_norm > real_max_norm)
+            {
+                real_max_norm = temp_norm;
+            }
+        }
+        if (real_max_norm > (0.5 * max_norm))
+        {
+            curved_incomplete_indexes.push_back(curved_indexes[i]);
+        }
+
+    }
+
+    if (curved_incomplete_indexes.size() == 0)
+    {
+        return false;
+    }
+    return true;
+}
+
+Point QRDecode::findClosestZeroPoint(Point2f original_point)
+{
+    int orig_x = static_cast<int>(original_point.x);
+    int orig_y = static_cast<int>(original_point.y);
+    uint8_t value;
+    Point zero_point;
+
+    const int step = 2;
+    for (int i = std::max(orig_x - step, 0); i >= 0 && i <= std::min(orig_x + step, bin_barcode.cols - 1); i++)
+    {
+        for (int j = std::max(orig_y - step, 0); j >= 0 && j <= std::min(orig_y + step, bin_barcode.rows - 1); j++)
+        {
+            Point p(i, j);
+            value = bin_barcode.at<uint8_t>(p);
+            if (value == 0) zero_point = p;
+        }
+    }
+
+    return zero_point;
+}
+
+Mat QRDecode::getPatternsMask()
+{
+    Mat mask(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1, Scalar(0));
+    Mat patterns_mask(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1, Scalar(0));
+    Mat fill_bin_barcode = bin_barcode.clone();
+    for (size_t i = 0; i < original_points.size(); i++)
+    {
+        if (i == 2) continue;
+        Point p = findClosestZeroPoint(original_points[i]);
+        floodFill(fill_bin_barcode, mask, p, 255,
+                        0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+        patterns_mask += mask;
+    }
+    Mat mask_roi = patterns_mask(Range(1, bin_barcode.rows - 1), Range(1, bin_barcode.cols - 1));
+
+    return mask_roi;
+}
+
+bool QRDecode::findPatternsContours(vector<vector<Point> > &patterns_contours)
+{
+    Mat patterns_mask = getPatternsMask();
+    findContours(patterns_mask, patterns_contours, RETR_EXTERNAL, CHAIN_APPROX_NONE, Point(0, 0));
+    if (patterns_contours.size() != 3) {  return false; }
+    return true;
+}
+
+bool QRDecode::findPatternsVerticesPoints(vector<vector<Point> > &patterns_vertices_points)
+{
+    vector<vector<Point> > patterns_contours;
+    if(!findPatternsContours(patterns_contours))
+    {
+        return false;
+    }
+    const int num_vertices = 4;
+    for(size_t i = 0; i < patterns_contours.size(); i++)
+    {
+        vector<Point> convexhull_contours, new_convexhull_contours;
+        convexHull(patterns_contours[i], convexhull_contours);
+
+        size_t number_pnts_in_hull = convexhull_contours.size();
+        vector<std::pair<size_t, double> > cos_angles_in_hull;
+        vector<size_t> min_angle_pnts_indexes;
+
+        for(size_t j = 1; j < number_pnts_in_hull + 1; j++)
+        {
+            double cos_angle = getCosVectors(convexhull_contours[(j - 1) % number_pnts_in_hull],
+                                             convexhull_contours[ j      % number_pnts_in_hull],
+                                             convexhull_contours[(j + 1) % number_pnts_in_hull]);
+            cos_angles_in_hull.push_back(std::pair<size_t, double>(j, cos_angle));
+        }
+
+        sort(cos_angles_in_hull.begin(), cos_angles_in_hull.end(), sortPairDesc());
+
+        for (size_t j = 0; j < cos_angles_in_hull.size(); j++)
+        {
+            bool add_edge = true;
+            for(size_t k = 0; k < min_angle_pnts_indexes.size(); k++)
+            {
+                if(norm(convexhull_contours[cos_angles_in_hull[j].first % number_pnts_in_hull] -
+                        convexhull_contours[min_angle_pnts_indexes[k]   % number_pnts_in_hull]) < 3)
+                {
+                    add_edge = false;
+                }
+            }
+            if (add_edge)
+            {
+                min_angle_pnts_indexes.push_back(cos_angles_in_hull[j].first % number_pnts_in_hull);
+            }
+            if ((int)min_angle_pnts_indexes.size() == num_vertices) { break; }
+        }
+        std::sort(min_angle_pnts_indexes.begin(), min_angle_pnts_indexes.end());
+
+        vector<Point> contour_vertices_points;
+
+        for (size_t k = 0; k < min_angle_pnts_indexes.size(); k++)
+        {
+            contour_vertices_points.push_back(convexhull_contours[min_angle_pnts_indexes[k]]);
+        }
+        patterns_vertices_points.push_back(contour_vertices_points);
+    }
+    if (patterns_vertices_points.size() != 3)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool QRDecode::findTempPatternsAddingPoints(vector<std::pair<int, vector<Point> > > &temp_patterns_add_points)
+{
+    vector<vector<Point> >patterns_contours, patterns_vertices_points;
+    if(!findPatternsVerticesPoints(patterns_vertices_points))
+    {
+        return false;
+    }
+    if(!findPatternsContours(patterns_contours))
+    {
+        return false;
+    }
+
+    for (size_t i = 0; i < curved_incomplete_indexes.size(); i++)
+    {
+        int idx_curved_side = curved_incomplete_indexes[i];
+        Point close_transform_pnt_curr = original_points[idx_curved_side];
+        Point close_transform_pnt_next = original_points[(idx_curved_side + 1) % 4];
+
+        vector<size_t> patterns_indexes;
+
+        for (size_t j = 0; j < patterns_vertices_points.size(); j++)
+        {
+            for (size_t k = 0; k < patterns_vertices_points[j].size(); k++)
+            {
+                if (norm(close_transform_pnt_curr - patterns_vertices_points[j][k]) < 5)
+                {
+                    patterns_indexes.push_back(j);
+                    break;
+                }
+                if (norm(close_transform_pnt_next - patterns_vertices_points[j][k]) < 5)
+                {
+                    patterns_indexes.push_back(j);
+                    break;
+                }
+            }
+        }
+        for (size_t j = 0; j < patterns_indexes.size(); j++)
+        {
+            vector<Point> vertices = patterns_vertices_points[patterns_indexes[j]];
+            vector<std::pair<int, double> > vertices_dist_pair;
+            vector<Point> points;
+            for (size_t k = 0; k < vertices.size(); k++)
+            {
+                double dist_to_side = distancePointToLine(vertices[k], close_transform_pnt_curr,
+                                                                       close_transform_pnt_next);
+                vertices_dist_pair.push_back(std::pair<int, double>((int)k, dist_to_side));
+            }
+            if (vertices_dist_pair.size() == 0)
+            {
+                return false;
+            }
+            sort(vertices_dist_pair.begin(), vertices_dist_pair.end(), sortPairAsc());
+            Point p1, p2;
+            int index_p1_in_vertices = 0, index_p2_in_vertices = 0;
+            for (int k = 4; k > 0; k--)
+            {
+                if((vertices_dist_pair[0].first == k % 4) && (vertices_dist_pair[1].first == (k - 1) % 4))
+                {
+                    index_p1_in_vertices = vertices_dist_pair[0].first;
+                    index_p2_in_vertices = vertices_dist_pair[1].first;
+                }
+                else if((vertices_dist_pair[1].first == k % 4) && (vertices_dist_pair[0].first == (k - 1) % 4))
+                {
+                    index_p1_in_vertices = vertices_dist_pair[1].first;
+                    index_p2_in_vertices = vertices_dist_pair[0].first;
+                }
+            }
+            if (index_p1_in_vertices == index_p2_in_vertices) return false;
+
+            p1 = vertices[index_p1_in_vertices];
+            p2 = vertices[index_p2_in_vertices];
+
+            size_t index_p1_in_contour = 0, index_p2_in_contour = 0;
+            vector<Point> add_points = patterns_contours[patterns_indexes[j]];
+
+            for(size_t k = 0; k < add_points.size(); k++)
+            {
+                if (add_points[k] == p1)
+                {
+                    index_p1_in_contour = k;
+                }
+                if (add_points[k] == p2)
+                {
+                    index_p2_in_contour = k;
+                }
+            }
+
+            if (index_p1_in_contour > index_p2_in_contour)
+            {
+                for (size_t k = index_p1_in_contour; k < add_points.size(); k++)
+                {
+                    points.push_back(add_points[k]);
+                }
+                for (size_t k = 0; k <= index_p2_in_contour; k++)
+                {
+                    points.push_back(add_points[k]);
+                }
+            }
+            else if (index_p1_in_contour < index_p2_in_contour)
+            {
+                for (size_t k = index_p1_in_contour; k <= index_p2_in_contour; k++)
+                {
+                    points.push_back(add_points[k]);
+                }
+            }
+            else
+            {
+                return false;
+            }
+            if (abs(p1.x - p2.x) > abs(p1.y - p2.y))
+            {
+                std::sort(points.begin(), points.end(), sortPointsByX());
+            }
+            else
+            {
+                std::sort(points.begin(), points.end(), sortPointsByY());
+            }
+
+            temp_patterns_add_points.push_back(std::pair<int, vector<Point> >(idx_curved_side,points));
+        }
+    }
+
+    return true;
+}
+
+bool QRDecode::computePatternsAddingPoints(std::map<int, vector<Point> > &patterns_add_points)
+{
+    vector<std::pair<int, vector<Point> > > temp_patterns_add_points;
+    if(!findTempPatternsAddingPoints(temp_patterns_add_points))
+    {
+        return false;
+    }
+
+    const int num_points_in_pattern = 3;
+    for(size_t i = 0; i < temp_patterns_add_points.size(); i++)
+    {
+        int idx_side = temp_patterns_add_points[i].first;
+        int size = (int)temp_patterns_add_points[i].second.size();
+
+        float step = static_cast<float>(size) / num_points_in_pattern;
+        vector<Point> temp_points;
+        for (int j = 0; j < num_points_in_pattern; j++)
+        {
+            float val = j * step;
+            int idx = cvRound(val) >= size ? size - 1 : cvRound(val);
+            temp_points.push_back(temp_patterns_add_points[i].second[idx]);
+        }
+        temp_points.push_back(temp_patterns_add_points[i].second.back());
+        if(patterns_add_points.count(idx_side) == 1)
+        {
+            patterns_add_points[idx_side].insert(patterns_add_points[idx_side].end(),
+                                                temp_points.begin(), temp_points.end());
+        }
+        patterns_add_points.insert(std::pair<int, vector<Point> >(idx_side, temp_points));
+
+    }
+    if (patterns_add_points.size() == 0)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool QRDecode::addPointsToSides()
+{
+    if(!computePatternsAddingPoints(complete_curved_sides))
+    {
+        return false;
+    }
+    std::map<int, vector<Point> >::iterator it;
+    double mean_step = 0.0;
+    size_t num_points_at_side = 0;
+    for (it = complete_curved_sides.begin(); it != complete_curved_sides.end(); ++it)
+    {
+        int count = -1;
+        const size_t num_points_at_pattern = it->second.size();
+        for(size_t j = 0; j < num_points_at_pattern - 1; j++, count++)
+        {
+            if (count == 3) continue;
+            double temp_norm = norm(it->second[j] -
+                                    it->second[j + 1]);
+            mean_step += temp_norm;
+        }
+        num_points_at_side += num_points_at_pattern;
+    }
+    if (num_points_at_side == 0)
+    {
+        return false;
+    }
+    mean_step /= num_points_at_side;
+
+    const size_t num_incomplete_sides = curved_incomplete_indexes.size();
+    for (size_t i = 0; i < num_incomplete_sides; i++)
+    {
+        int idx = curved_incomplete_indexes[i];
+        vector<int> sides_points_indexes;
+
+        const int num_points_at_side_to_add = (int)sides_points[idx].size();
+        for (int j = 0; j < num_points_at_side_to_add; j++)
+        {
+            bool not_too_close = true;
+            const size_t num_points_at_side_exist = complete_curved_sides[idx].size();
+            for (size_t k = 0; k < num_points_at_side_exist; k++)
+            {
+                double temp_norm = norm(sides_points[idx][j] - complete_curved_sides[idx][k]);
+                if (temp_norm < mean_step)
+                {
+                    not_too_close = false;
+                    break;
+                }
+            }
+            if (not_too_close)
+            {
+                sides_points_indexes.push_back(j);
+            }
+        }
+
+        for (size_t j = 0; j < sides_points_indexes.size(); j++)
+        {
+            bool not_equal = true;
+            for (size_t k = 0; k < complete_curved_sides[idx].size(); k++)
+            {
+                if (sides_points[idx][sides_points_indexes[j]] ==
+                    complete_curved_sides[idx][k])
+                {
+                    not_equal = false;
+                }
+            }
+            if (not_equal)
+            {
+                complete_curved_sides[idx].push_back(sides_points[idx][sides_points_indexes[j]]);
+            }
+        }
+    }
+
+    return true;
+}
+
+void QRDecode::completeAndSortSides()
+{
+    if (complete_curved_sides.size() < 2)
+    {
+        for (int i = 0; i < NUM_SIDES; i++)
+        {
+            if(complete_curved_sides.count(curved_indexes[i]) == 0)
+            {
+                int idx_second_cur_side = curved_indexes[i];
+                complete_curved_sides.insert(std::pair<int,vector<Point> >(idx_second_cur_side, sides_points[idx_second_cur_side]));
+            }
+        }
+    }
+    std::map<int,vector<Point> >::iterator it;
+    for (it = complete_curved_sides.begin(); it != complete_curved_sides.end(); ++it)
+    {
+        Point p1 = it->second.front();
+        Point p2 = it->second.back();
+        if (abs(p1.x - p2.x) > abs(p1.y - p2.y))
+        {
+            std::sort(it->second.begin(), it->second.end(), sortPointsByX());
+        }
+        else
+        {
+            std::sort(it->second.begin(), it->second.end(), sortPointsByY());
+        }
+    }
+}
+
+vector<vector<float> > QRDecode::computeSpline(const vector<int> &x_arr, const vector<int> &y_arr)
+{
+    const int n = (int)x_arr.size();
+    vector<float> a, b(n - 1), d(n - 1), h(n - 1), alpha(n - 1), c(n), l(n), mu(n), z(n);
+
+    for (int i = 0; i < (int)y_arr.size(); i++)
+    {
+        a.push_back(static_cast<float>(x_arr[i]));
+    }
+    for (int i = 0; i < n - 1; i++)
+    {
+        h[i] = static_cast<float>(y_arr[i + 1] - y_arr[i]) + std::numeric_limits<float>::epsilon();
+    }
+    for (int i = 1; i < n - 1; i++)
+    {
+        alpha[i] = 3 / h[i] * (a[i + 1] - a[i]) - 3 / (h[i - 1]) * (a[i] - a[i - 1]);
+    }
+    l[0] = 1;
+    mu[0] = 0;
+    z[0] = 0;
+
+    for (int i = 1; i < n - 1; i++)
+    {
+        l[i] = 2 * (y_arr[i + 1] - y_arr[i - 1]) - h[i - 1] * mu[i - 1];
+        mu[i] = h[i] / l[i];
+        z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
+    }
+    l[n - 1] = 1;
+    z[n - 1] = 0;
+    c[n - 1] = 0;
+
+    for(int j = n - 2; j >= 0; j--)
+    {
+        c[j] = z[j] - mu[j] * c[j + 1];
+        b[j] = (a[j + 1] - a[j]) / h[j] - (h[j] * (c[j + 1] + 2 * c[j])) / 3;
+        d[j] = (c[j + 1] - c[j]) / (3 * h[j]);
+    }
+
+    vector<vector<float> > S(n - 1);
+    for (int i = 0; i < n - 1; i++)
+    {
+        S[i].push_back(a[i]);
+        S[i].push_back(b[i]);
+        S[i].push_back(c[i]);
+        S[i].push_back(d[i]);
+    }
+
+    return S;
+}
+
+bool QRDecode::createSpline(vector<vector<Point2f> > &spline_lines)
+{
+    int start, end;
+    vector<vector<float> > S;
+
+    for (int idx = 0; idx < NUM_SIDES; idx++)
+    {
+        int idx_curved_side = curved_indexes[idx];
+
+        vector<Point> spline_points = complete_curved_sides.find(idx_curved_side)->second;
+        vector<int> x_arr, y_arr;
+
+        for (size_t j = 0; j < spline_points.size(); j++)
+        {
+            x_arr.push_back(cvRound(spline_points[j].x));
+            y_arr.push_back(cvRound(spline_points[j].y));
+        }
+
+        bool horizontal_order = abs(x_arr.front() - x_arr.back()) > abs(y_arr.front() - y_arr.back());
+        vector<int>& second_arr = horizontal_order ? x_arr : y_arr;
+        vector<int>& first_arr  = horizontal_order ? y_arr : x_arr;
+
+        S = computeSpline(first_arr, second_arr);
+
+        int closest_point_first  = horizontal_order ? closest_points[idx_curved_side].second.x
+                                                    : closest_points[idx_curved_side].second.y;
+        int closest_point_second = horizontal_order ? closest_points[(idx_curved_side + 1) % 4].second.x
+                                                    : closest_points[(idx_curved_side + 1) % 4].second.y;
+
+        start = idx_curved_side;
+        end = (idx_curved_side + 1) % 4;
+        if(closest_point_first > closest_point_second)
+        {
+            start = (idx_curved_side + 1) % 4;
+            end = idx_curved_side;
+        }
+
+        int closest_point_start = horizontal_order ? closest_points[start].second.x : closest_points[start].second.y;
+        int closest_point_end   = horizontal_order ? closest_points[end].second.x   : closest_points[end].second.y;
+
+        for (int index = closest_point_start; index <= closest_point_end; index++)
+        {
+            if (index == second_arr.front())
+            {
+                spline_lines[idx].push_back(closest_points[start].second);
+            }
+            for (size_t i = 0; i < second_arr.size() - 1; i++)
+            {
+                if ((index > second_arr[i]) && (index <= second_arr[i + 1]))
+                {
+                    float val = S[i][0] + S[i][1] * (index - second_arr[i]) + S[i][2] * (index - second_arr[i]) * (index - second_arr[i])
+                                                                            + S[i][3] * (index - second_arr[i]) * (index - second_arr[i]) * (index - second_arr[i]);
+                    spline_lines[idx].push_back(horizontal_order ? Point2f(static_cast<float>(index), val) : Point2f(val, static_cast<float>(index)));
+                }
+            }
+        }
+    }
+    for (int i = 0; i < NUM_SIDES; i++)
+    {
+        if (spline_lines[i].size() == 0)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool QRDecode::divideIntoEvenSegments(vector<vector<Point2f> > &segments_points)
+{
+    vector<vector<Point2f> > spline_lines(NUM_SIDES);
+    if (!createSpline(spline_lines))
+    {
+        return false;
+    }
+    float mean_num_points_in_line = 0.0;
+    for (int i = 0; i < NUM_SIDES; i++)
+    {
+        mean_num_points_in_line += spline_lines[i].size();
+    }
+    mean_num_points_in_line /= NUM_SIDES;
+    const int min_num_points = 1, max_num_points = cvRound(mean_num_points_in_line / 2.0);
+    float linear_threshold = 0.5f;
+    for (int num = min_num_points; num < max_num_points; num++)
+    {
+        for (int i = 0; i < NUM_SIDES; i++)
+        {
+            segments_points[i].clear();
+
+            int size = (int)spline_lines[i].size();
+            float step = static_cast<float>(size) / num;
+            for (int j = 0; j < num; j++)
+            {
+                float val = j * step;
+                int idx = cvRound(val) >= size ? size - 1 : cvRound(val);
+                segments_points[i].push_back(spline_lines[i][idx]);
+            }
+            segments_points[i].push_back(spline_lines[i].back());
+        }
+        float mean_of_two_sides = 0.0;
+        for (int i = 0; i < NUM_SIDES; i++)
+        {
+            float mean_dist_in_segment = 0.0;
+            for (size_t j = 0; j < segments_points[i].size() - 1; j++)
+            {
+                Point2f segment_start = segments_points[i][j];
+                Point2f segment_end   = segments_points[i][j + 1];
+                vector<Point2f>::iterator it_start, it_end, it;
+                it_start = std::find(spline_lines[i].begin(), spline_lines[i].end(), segment_start);
+                it_end   = std::find(spline_lines[i].begin(), spline_lines[i].end(), segment_end);
+                float max_dist_to_line = 0.0;
+                for (it = it_start; it != it_end; it++)
+                {
+                    float temp_dist = distancePointToLine(*it, segment_start, segment_end);
+                    if (temp_dist > max_dist_to_line)
+                    {
+                        max_dist_to_line = temp_dist;
+                    }
+                }
+                mean_dist_in_segment += max_dist_to_line;
+            }
+            mean_dist_in_segment /= segments_points[i].size();
+            mean_of_two_sides    += mean_dist_in_segment;
+        }
+        mean_of_two_sides /= NUM_SIDES;
+        if (mean_of_two_sides < linear_threshold)
+        {
+            break;
+        }
+    }
+
+    return true;
+}
+
+bool QRDecode::straightenQRCodeInParts()
+{
+    vector<vector<Point2f> > segments_points(NUM_SIDES);
+    if (!divideIntoEvenSegments(segments_points))
+    {
+        return false;
+    }
+    vector<Point2f> current_curved_side, opposite_curved_side;
+
+    for (int i = 0; i < NUM_SIDES; i++)
+    {
+        Point2f temp_point_start = segments_points[i].front();
+        Point2f temp_point_end   = segments_points[i].back();
+        bool horizontal_order = (abs(temp_point_start.x - temp_point_end.x) >
+                                 abs(temp_point_start.y - temp_point_end.y));
+        float compare_point_current  = horizontal_order ? segments_points[i].front().y
+                                                        : segments_points[(i + 1) % 2].front().x;
+        float compare_point_opposite = horizontal_order ? segments_points[(i + 1) % 2].front().y
+                                                        : segments_points[i].front().x;
+
+        if (compare_point_current > compare_point_opposite)
+        {
+            current_curved_side  = segments_points[i];
+            opposite_curved_side = segments_points[(i + 1) % 2];
+        }
+    }
+    if (current_curved_side.size() != opposite_curved_side.size())
+    {
+        return false;
+    }
+    size_t number_pnts_to_cut = current_curved_side.size();
+    if (number_pnts_to_cut == 0)
+    {
+        return false;
+    }
+    float perspective_curved_size = max(getMinSideLen(original_points)+1.f, 251.f);;
+    const Size temporary_size(cvRound(perspective_curved_size), cvRound(perspective_curved_size));
+
+    float dist = perspective_curved_size / (number_pnts_to_cut - 1);
+    Mat perspective_result = Mat::zeros(temporary_size, CV_8UC1);
+    vector<Point2f> curved_parts_points;
+
+    float start_cut = 0.0;
+    vector<Point2f> temp_closest_points(4);
+
+    for (size_t i = 1; i < number_pnts_to_cut; i++)
+    {
+        curved_parts_points.clear();
+        Mat test_mask = Mat::zeros(bin_barcode.size(), CV_8UC1);
+
+        Point2f start_point = current_curved_side[i];
+        Point2f prev_start_point = current_curved_side[i - 1];
+        Point2f finish_point = opposite_curved_side[i];
+        Point2f prev_finish_point = opposite_curved_side[i - 1];
+
+        for (size_t j = 0; j < qrcode_locations.size(); j++)
+        {
+            if ((pointPosition(start_point, finish_point, qrcode_locations[j]) >= 0) &&
+                (pointPosition(prev_start_point, prev_finish_point, qrcode_locations[j]) <= 0))
+            {
+                test_mask.at<uint8_t>(qrcode_locations[j]) = 255;
+            }
+        }
+
+        vector<Point2f> perspective_points;
+
+        perspective_points.emplace_back(0.0f, start_cut);
+        perspective_points.emplace_back(perspective_curved_size, start_cut);
+
+        perspective_points.emplace_back(perspective_curved_size, start_cut + dist);
+        perspective_points.emplace_back(0.0f, start_cut+dist);
+
+        perspective_points.emplace_back(perspective_curved_size * 0.5f, start_cut + dist * 0.5f);
+
+        if (i == 1)
+        {
+            for (size_t j = 0; j < closest_points.size(); j++)
+            {
+                if (arePointsNearest(closest_points[j].second, prev_start_point, 3.0))
+                {
+                    temp_closest_points[j] = perspective_points[0];
+                }
+                else if (arePointsNearest(closest_points[j].second, prev_finish_point, 3.0))
+                {
+                    temp_closest_points[j] = perspective_points[1];
+                }
+            }
+        }
+        if (i == number_pnts_to_cut - 1)
+        {
+            for (size_t j = 0; j < closest_points.size(); j++)
+            {
+                if (arePointsNearest(closest_points[j].second, finish_point, 3.0))
+                {
+                    temp_closest_points[j] = perspective_points[2];
+                }
+                else if (arePointsNearest(closest_points[j].second, start_point, 3.0))
+                {
+                    temp_closest_points[j] = perspective_points[3];
+                }
+            }
+        }
+        start_cut += dist;
+
+        curved_parts_points.push_back(prev_start_point);
+        curved_parts_points.push_back(prev_finish_point);
+        curved_parts_points.push_back(finish_point);
+        curved_parts_points.push_back(start_point);
+
+        Point2f center_point = intersectionLines(curved_parts_points[0], curved_parts_points[2],
+                                                 curved_parts_points[1], curved_parts_points[3]);
+        if (cvIsNaN(center_point.x) || cvIsNaN(center_point.y))
+            return false;
+
+        vector<Point2f> pts = curved_parts_points;
+        pts.push_back(center_point);
+
+        Mat H = findHomography(pts, perspective_points);
+        if (H.empty())
+            return false;
+        Mat temp_intermediate(temporary_size, CV_8UC1);
+        warpPerspective(test_mask, temp_intermediate, H, temporary_size, INTER_NEAREST);
+        perspective_result += temp_intermediate;
+
+    }
+    Mat white_mask = Mat(temporary_size, CV_8UC1, Scalar(255));
+    Mat inversion = white_mask - perspective_result;
+    Mat temp_result;
+
+    original_curved_points = temp_closest_points;
+
+    Point2f original_center_point = intersectionLines(original_curved_points[0], original_curved_points[2],
+                                                      original_curved_points[1], original_curved_points[3]);
+
+    original_curved_points.push_back(original_center_point);
+
+    for (size_t i = 0; i < original_curved_points.size(); i++)
+    {
+        if (cvIsNaN(original_curved_points[i].x) || cvIsNaN(original_curved_points[i].y))
+            return false;
+    }
+
+    vector<Point2f> perspective_straight_points;
+    perspective_straight_points.emplace_back(0.f, 0.f);
+    perspective_straight_points.emplace_back(perspective_curved_size, 0.f);
+
+    perspective_straight_points.emplace_back(perspective_curved_size, perspective_curved_size);
+    perspective_straight_points.emplace_back(0.f, perspective_curved_size);
+
+    perspective_straight_points.emplace_back(perspective_curved_size * 0.5f, perspective_curved_size * 0.5f);
+
+    Mat H = findHomography(original_curved_points, perspective_straight_points);
+    if (H.empty())
+        return false;
+    warpPerspective(inversion, temp_result, H, temporary_size, INTER_NEAREST, BORDER_REPLICATE);
+
+    no_border_intermediate = temp_result(Range(1, temp_result.rows), Range(1, temp_result.cols));
+    const int border = cvRound(0.1 * perspective_curved_size);
+    const int borderType = BORDER_CONSTANT;
+    copyMakeBorder(no_border_intermediate, curved_to_straight, border, border, border, border, borderType, Scalar(255));
+    intermediate = curved_to_straight;
+
+    return true;
+}
+
+bool QRDecode::preparingCurvedQRCodes()
+{
+    vector<Point> result_integer_hull;
+    getPointsInsideQRCode(original_points);
+    if (qrcode_locations.size() == 0)
+        return false;
+    convexHull(qrcode_locations, result_integer_hull);
+    if (!computeClosestPoints(result_integer_hull))
+        return false;
+    if (!computeSidesPoints(result_integer_hull))
+        return false;
+    if (!findAndAddStablePoint())
+        return false;
+    if (!findIndexesCurvedSides())
+        return false;
+    if (findIncompleteIndexesCurvedSides())
+    {
+        if(!addPointsToSides())
+            return false;
+    }
+    completeAndSortSides();
+    if (!straightenQRCodeInParts())
+        return false;
+
+    return true;
+}
+
+/**
+ * @param finderPattern 4 points of finder pattern markers, calculated by findPatternsVerticesPoints()
+ * @return true if the pattern has the correct side lengths
+ */
+static inline bool checkFinderPatternByAspect(const vector<Point> &finderPattern) {
+    if (finderPattern.size() != 4ull)
+        return false;
+    float sidesLen[4];
+    for (size_t i = 0; i < finderPattern.size(); i++) {
+        sidesLen[i] = (sqrt(normL2Sqr<float>(Point2f(finderPattern[i] - finderPattern[(i+1ull)%finderPattern.size()]))));
+    }
+    const float maxSide = max(max(sidesLen[0], sidesLen[1]), max(sidesLen[2], sidesLen[3]));
+    const float minSide = min(min(sidesLen[0], sidesLen[1]), min(sidesLen[2], sidesLen[3]));
+
+    const float patternMaxRelativeLen = .3f;
+    if (1.f - minSide / maxSide > patternMaxRelativeLen)
+        return false;
+    return true;
+}
+
+/**
+ * @param finderPattern - 4 points of finder pattern markers, calculated by findPatternsVerticesPoints()
+ * @param cornerPointsQR - 4 corner points of QR code
+ * @return pair<int, int> first - the index in points of finderPattern closest to the corner of the QR code,
+ *                        second - the index in points of cornerPointsQR closest to the corner of finderPattern
+ *
+ * This function matches finder patterns to the corners of the QR code. Points of finder pattern calculated by
+ * findPatternsVerticesPoints() may be erroneous, so they are checked.
+ */
+static inline std::pair<int, int> matchPatternPoints(const vector<Point> &finderPattern,
+                                                     const vector<Point2f>& cornerPointsQR) {
+    if (!checkFinderPatternByAspect(finderPattern))
+        return std::make_pair(-1, -1);
+
+    float distanceToOrig = normL2Sqr<float>(Point2f(finderPattern[0]) - cornerPointsQR[0]);
+    int closestFinderPatternV = 0;
+    int closetOriginalV = 0;
+
+    for (size_t i = 0ull; i < finderPattern.size(); i++) {
+        for (size_t j = 0ull; j < cornerPointsQR.size(); j++) {
+            const float tmp = normL2Sqr<float>(Point2f(finderPattern[i]) - cornerPointsQR[j]);
+            if (tmp < distanceToOrig) {
+                distanceToOrig = tmp;
+                closestFinderPatternV = (int)i;
+                closetOriginalV = (int)j;
+            }
+        }
+    }
+    distanceToOrig = sqrt(distanceToOrig);
+
+    // check that the distance from the QR pattern to the corners of the QR code is small
+    const float originalQrSide = sqrt(normL2Sqr<float>(cornerPointsQR[0] - cornerPointsQR[1]))*0.5f +
+                                 sqrt(normL2Sqr<float>(cornerPointsQR[0] - cornerPointsQR[3]))*0.5f;
+    const float maxRelativeDistance = .1f;
+
+    if (distanceToOrig/originalQrSide > maxRelativeDistance)
+        return std::make_pair(-1, -1);
+    return std::make_pair(closestFinderPatternV, closetOriginalV);
+}
+
+double QRDecode::getNumModules() {
+    vector<vector<Point>> finderPatterns;
+    double numModulesX = 0., numModulesY = 0.;
+    if (findPatternsVerticesPoints(finderPatterns)) {
+        double pattern_distance[4] = {0.,0.,0.,0.};
+        for (auto& pattern : finderPatterns) {
+            auto indexes = matchPatternPoints(pattern, original_points);
+            if (indexes == std::make_pair(-1, -1))
+                return 0.;
+            Point2f vf[4] = {pattern[indexes.first % 4], pattern[(1+indexes.first) % 4],
+                                  pattern[(2+indexes.first) % 4], pattern[(3+indexes.first) % 4]};
+            for (int i = 1; i < 4; i++) {
+                pattern_distance[indexes.second] += (norm(vf[i] - vf[i-1]));
+            }
+            pattern_distance[indexes.second] += norm(vf[3] - vf[0]);
+            pattern_distance[indexes.second] /= 4.;
+        }
+        const double moduleSizeX = (pattern_distance[0] + pattern_distance[1])/(2.*7.);
+        const double moduleSizeY = (pattern_distance[0] + pattern_distance[3])/(2.*7.);
+        numModulesX = norm(original_points[1] - original_points[0])/moduleSizeX;
+        numModulesY = norm(original_points[3] - original_points[0])/moduleSizeY;
+    }
+    return (numModulesX + numModulesY)/2.;
+}
+
+// use code from https://stackoverflow.com/questions/13238704/calculating-the-position-of-qr-code-alignment-patterns
+static inline vector<pair<int, int>> getAlignmentCoordinates(int version) {
+    if (version <= 1) return {};
+    int intervals = (version / 7) + 1; // Number of gaps between alignment patterns
+    int distance = 4 * version + 4; // Distance between first and last alignment pattern
+    int step = cvRound((double)distance / (double)intervals); // Round equal spacing to nearest integer
+    step += step & 0b1; // Round step to next even number
+    vector<int> coordinates((size_t)intervals + 1ull);
+    coordinates[0] = 6; // First coordinate is always 6 (can't be calculated with step)
+    for (int i = 1; i <= intervals; i++) {
+        coordinates[i] = (6 + distance - step * (intervals - i));  // Start right/bottom and go left/up by step*k
+    }
+    if (version >= 7) {
+        return {std::make_pair(coordinates.back(), coordinates.back()),
+                std::make_pair(coordinates.back(), coordinates[coordinates.size()-2]),
+                std::make_pair(coordinates[coordinates.size()-2], coordinates.back()),
+                std::make_pair(coordinates[coordinates.size()-2], coordinates[coordinates.size()-2]),
+                std::make_pair(coordinates[0], coordinates[1]),
+                std::make_pair(coordinates[1], coordinates[0]),
+               };
+    }
+    return {std::make_pair(coordinates.back(), coordinates.back())};
+}
+
+
+bool QRDecode::updatePerspective(const Mat& H)
+{
+    if (H.empty())
+        return false;
+    homography = H;
+    Mat temp_intermediate;
+    const Size temporary_size(cvRound(test_perspective_size), cvRound(test_perspective_size));
+    warpPerspective(bin_barcode, temp_intermediate, H, temporary_size, INTER_NEAREST);
+    no_border_intermediate = temp_intermediate(Range(1, temp_intermediate.rows), Range(1, temp_intermediate.cols));
+
+    const int border = cvRound(0.1 * test_perspective_size);
+    const int borderType = BORDER_CONSTANT;
+    copyMakeBorder(no_border_intermediate, intermediate, border, border, border, border, borderType, Scalar(255));
+    return true;
+}
+
+static inline Point computeOffset(const vector<Point>& v)
+{
+    // compute the width/height of convex hull
+    Rect areaBox = boundingRect(v);
+
+    // compute the good offset
+    // the box is consisted by 7 steps
+    // to pick the middle of the stripe, it needs to be 1/14 of the size
+    const int cStep = 7 * 2;
+    Point offset = Point(areaBox.width, areaBox.height);
+    offset /= cStep;
+    return offset;
+}
+
+// QR code with version 7 or higher has a special 18 bit version number code.
+// @return std::pair<double, int> first - distance to estimatedVersion, second - version
+/**
+ * @param numModules - estimated numModules
+ * @param estimatedVersion
+ * @return pair<double, int>, first - Hamming distance to 18 bit code, second - closest version
+ *
+ * QR code with version 7 or higher has a special 18 bit version number code:
+ * https://www.thonky.com/qr-code-tutorial/format-version-information
+ */
+static inline std::pair<double, int> getVersionByCode(double numModules, Mat qr, int estimatedVersion) {
+    const double moduleSize = qr.rows / numModules;
+    Point2d startVersionInfo1 = Point2d((numModules-8.-3.)*moduleSize, 0.);
+    Point2d endVersionInfo1 = Point2d((numModules-8.)*moduleSize, moduleSize*6.);
+    Point2d startVersionInfo2 = Point2d(0., (numModules-8.-3.)*moduleSize);
+    Point2d endVersionInfo2 = Point2d(moduleSize*6., (numModules-8.)*moduleSize);
+    Mat v1(qr, Rect2d(startVersionInfo1, endVersionInfo1));
+    Mat v2(qr, Rect2d(startVersionInfo2, endVersionInfo2));
+    const double thresh = 127.;
+    resize(v1, v1, Size(3, 6), 0., 0., INTER_AREA);
+    threshold(v1, v1, thresh, 255, THRESH_BINARY);
+    resize(v2, v2, Size(6, 3), 0., 0., INTER_AREA);
+    threshold(v2, v2, thresh, 255, THRESH_BINARY);
+
+    Mat version1, version2;
+    // convert version1 (top right version information block) and
+    // version2 (bottom left version information block) to version table format
+    // https://www.thonky.com/qr-code-tutorial/format-version-tables
+    rotate((255-v1)/255, version1, ROTATE_180), rotate(((255-v2)/255).t(), version2, ROTATE_180);
+
+    static uint8_t versionCodes[][18] = {{0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0},{0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0},
+                                         {0,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,1},{0,0,1,0,1,0,0,1,0,0,1,1,0,1,0,0,1,1},
+                                         {0,0,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,0},{0,0,1,1,0,0,0,1,1,1,0,1,1,0,0,0,1,0},
+                                         {0,0,1,1,0,1,1,0,0,0,0,1,0,0,0,1,1,1},{0,0,1,1,1,0,0,1,1,0,0,0,0,0,1,1,0,1},
+                                         {0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0},{0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,0},
+                                         {0,1,0,0,0,1,0,1,0,0,0,1,0,1,1,1,0,1},{0,1,0,0,1,0,1,0,1,0,0,0,0,1,0,1,1,1},
+                                         {0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,1,0},{0,1,0,1,0,0,1,0,0,1,1,0,1,0,0,1,1,0},
+                                         {0,1,0,1,0,1,0,1,1,0,1,0,0,0,0,0,1,1},{0,1,0,1,1,0,1,0,0,0,1,1,0,0,1,0,0,1},
+                                         {0,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,0,0},{0,1,1,0,0,0,1,1,1,0,1,1,0,0,0,1,0,0},
+                                         {0,1,1,0,0,1,0,0,0,1,1,1,1,0,0,0,0,1},{0,1,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1},
+                                         {0,1,1,0,1,1,0,0,0,0,1,0,0,0,1,1,1,0},{0,1,1,1,0,0,1,1,0,0,0,0,0,1,1,0,1,0},
+                                         {0,1,1,1,0,1,0,0,1,1,0,0,1,1,1,1,1,1},{0,1,1,1,1,0,1,1,0,1,0,1,1,1,0,1,0,1},
+                                         {0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0},{1,0,0,0,0,0,1,0,0,1,1,1,0,1,0,1,0,1},
+                                         {1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,0,0},{1,0,0,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0},
+                                         {1,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,1},{1,0,0,1,0,0,1,0,1,1,0,0,0,0,1,0,1,1},
+                                         {1,0,0,1,0,1,0,1,0,0,0,0,1,0,1,1,1,0},{1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,1,0,0},
+                                         {1,0,0,1,1,1,0,1,0,1,0,1,0,0,0,0,0,1},{1,0,1,0,0,0,1,1,0,0,0,1,1,0,1,0,0,1}
+    };
+    double minDist = 19.;
+    int bestVersion = -1;
+    const double penaltyFactor = 0.8;
+
+    for (int i = 0; i < (int)(sizeof(versionCodes)/sizeof(versionCodes[0])); i++) {
+        Mat currVers(Size(3, 6), CV_8UC1, versionCodes[i]);
+        // minimum hamming distance between version = 8
+        double tmp = norm(currVers, version1, NORM_HAMMING) + penaltyFactor*abs(estimatedVersion-i-7);
+        if (tmp < minDist) {
+            bestVersion = i+7;
+            minDist = tmp;
+        }
+        tmp = norm(currVers, version2, NORM_HAMMING) + penaltyFactor*abs(estimatedVersion-i-7);
+        if (tmp < minDist) {
+            bestVersion = i+7;
+            minDist = tmp;
+        }
+    }
+    return std::make_pair(minDist, bestVersion);
+}
+
+bool QRDecode::versionDefinition()
+{
+    CV_TRACE_FUNCTION();
+    CV_LOG_DEBUG(NULL, "QR corners: " << original_points[0] << " " << original_points[1] << " " << original_points[2] <<
+                      " " << original_points[3]);
+    LineIterator line_iter(intermediate, Point2f(0, 0), Point2f(test_perspective_size, test_perspective_size));
+    Point black_point = Point(0, 0);
+    for(int j = 0; j < line_iter.count; j++, ++line_iter)
+    {
+        const uint8_t value = intermediate.at<uint8_t>(line_iter.pos());
+        if (value == 0)
+        {
+            black_point = line_iter.pos();
+            break;
+        }
+    }
+
+    Mat mask = Mat::zeros(intermediate.rows + 2, intermediate.cols + 2, CV_8UC1);
+    floodFill(intermediate, mask, black_point, 255, 0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+
+    vector<Point> locations, non_zero_elem;
+    Mat mask_roi = mask(Range(1, intermediate.rows - 1), Range(1, intermediate.cols - 1));
+    findNonZero(mask_roi, non_zero_elem);
+    convexHull(non_zero_elem, locations);
+    Point offset = computeOffset(locations);
+
+    Point temp_remote = locations[0], remote_point;
+    const Point delta_diff = offset;
+    for (size_t i = 0; i < locations.size(); i++)
+    {
+        if (norm(black_point - temp_remote) <= norm(black_point - locations[i]))
+        {
+            const uint8_t value = intermediate.at<uint8_t>(temp_remote - delta_diff);
+            temp_remote = locations[i];
+            if (value == 0) { remote_point = temp_remote - delta_diff; }
+            else { remote_point = temp_remote - (delta_diff / 2); }
+        }
+    }
+
+    size_t transition_x = 0 , transition_y = 0;
+
+    uint8_t future_pixel = 255;
+    const uint8_t *intermediate_row = intermediate.ptr<uint8_t>(remote_point.y);
+    for(int i = remote_point.x; i < intermediate.cols; i++)
+    {
+        if (intermediate_row[i] == future_pixel)
+        {
+            future_pixel = static_cast<uint8_t>(~future_pixel);
+            transition_x++;
+        }
+    }
+
+    future_pixel = 255;
+    for(int j = remote_point.y; j < intermediate.rows; j++)
+    {
+        const uint8_t value = intermediate.at<uint8_t>(Point(j, remote_point.x));
+        if (value == future_pixel)
+        {
+            future_pixel = static_cast<uint8_t>(~future_pixel);
+            transition_y++;
+        }
+    }
+
+    const int versionByTransition = saturate_cast<uint8_t>((std::min(transition_x, transition_y) - 1) * 0.25 - 1);
+    const int numModulesByTransition = 21 + (versionByTransition - 1) * 4;
+
+    const double numModulesByFinderPattern = getNumModules();
+    const double versionByFinderPattern = (numModulesByFinderPattern - 21.) * .25 + 1.;
+    bool useFinderPattern = false;
+    const double thresholdFinderPattern = 0.2;
+    const double roundingError = abs(numModulesByFinderPattern - cvRound(numModulesByFinderPattern));
+
+    if (cvRound(versionByFinderPattern) >= 1 && versionByFinderPattern <= 6. &&
+        transition_x != transition_y && roundingError < thresholdFinderPattern) {
+            useFinderPattern = true;
+    }
+
+    bool useCode = false;
+    int versionByCode = 7;
+    if (cvRound(versionByFinderPattern) >= 7 || versionByTransition >= 7) {
+        vector<std::pair<double, int>> versionAndDistances;
+        if (cvRound(versionByFinderPattern) >= 7) {
+            versionAndDistances.push_back(getVersionByCode(numModulesByFinderPattern, no_border_intermediate,
+                                                           cvRound(versionByFinderPattern)));
+        }
+        if (versionByTransition >= 7) {
+            versionAndDistances.push_back(getVersionByCode(numModulesByTransition, no_border_intermediate,
+                                                           versionByTransition));
+        }
+        const auto& bestVersion = min(versionAndDistances.front(), versionAndDistances.back());
+        double distanceByCode = bestVersion.first;
+        versionByCode = bestVersion.second;
+        if (distanceByCode < 5.) {
+            useCode = true;
+        }
+    }
+
+    if (useCode) {
+        CV_LOG_DEBUG(NULL, "Version type: useCode");
+        version = (uint8_t)versionByCode;
+    }
+    else if (useFinderPattern ) {
+        CV_LOG_DEBUG(NULL, "Version type: useFinderPattern");
+        version = (uint8_t)cvRound(versionByFinderPattern);
+    }
+    else {
+        CV_LOG_DEBUG(NULL, "Version type: useTransition");
+        version = (uint8_t)versionByTransition;
+    }
+    version_size = 21 + (version - 1) * 4;
+    if ( !(0 < version && version <= 40) ) { return false; }
+    CV_LOG_DEBUG(NULL, "QR version: " << (int)version);
+    return true;
+}
+
+void QRDecode::detectAlignment() {
+    vector<pair<int, int>> alignmentPositions = getAlignmentCoordinates(version);
+    if (alignmentPositions.size() > 0) {
+        vector<Point2f> perspective_points = {{0.f, 0.f}, {test_perspective_size, 0.f}, {0.f, test_perspective_size}};
+        vector<Point2f> object_points = {original_points[0], original_points[1], original_points[3]};
+
+        // create alignment image
+        static uint8_t alignmentMarker[25] = {
+            0, 0,   0,   0,   0,
+            0, 255, 255, 255, 0,
+            0, 255, 0,   255, 0,
+            0, 255, 255, 255, 0,
+            0, 0,   0,   0,   0
+        };
+        Mat alignmentMarkerMat(5, 5, CV_8UC1, alignmentMarker);
+        const float module_size = test_perspective_size / version_size;
+        Mat resizedAlignmentMarker;
+        resize(alignmentMarkerMat, resizedAlignmentMarker,
+               Size(cvRound(module_size * 5.f), cvRound(module_size * 5.f)), 0, 0, INTER_AREA);
+        const float module_offset = 1.9f;
+        const float offset = (module_size * (5 + module_offset * 2)); // 5 modules in alignment marker, 2 x module_offset modules in offset
+        for (const pair<int, int>& alignmentPos : alignmentPositions) {
+            const float left_top_x = (module_size * (alignmentPos.first - 2.f - module_offset)); // add offset
+            const float left_top_y = (module_size * (alignmentPos.second - 2.f - module_offset)); // add offset
+            Mat subImage(no_border_intermediate, Rect(cvRound(left_top_x), cvRound(left_top_y), cvRound(offset), cvRound(offset)));
+            Mat resTemplate;
+            matchTemplate(subImage, resizedAlignmentMarker, resTemplate, TM_CCOEFF_NORMED);
+            double minVal = 0., maxVal = 0.;
+            Point minLoc, maxLoc, matchLoc;
+            minMaxLoc(resTemplate, &minVal, &maxVal, &minLoc, &maxLoc);
+            CV_LOG_DEBUG(NULL, "Alignment maxVal: " << maxVal);
+            if (maxVal > 0.65) {
+                const float templateOffset = static_cast<float>(resizedAlignmentMarker.size().width) / 2.f;
+                Point2f alignmentCoord(Point2f(maxLoc.x + left_top_x + templateOffset, maxLoc.y + left_top_y + templateOffset));
+                alignment_coords.push_back(alignmentCoord);
+                perspectiveTransform(alignment_coords, alignment_coords, homography.inv());
+                CV_LOG_DEBUG(NULL, "Alignment coords: " << alignment_coords);
+                const float relativePosX = (alignmentPos.first + 0.5f) / version_size;
+                const float relativePosY = (alignmentPos.second + 0.5f) / version_size;
+                perspective_points.push_back({relativePosX * test_perspective_size, relativePosY * test_perspective_size});
+                object_points.push_back(alignment_coords.back());
+            }
+        }
+        if (object_points.size() > 3ull) {
+            double ransacReprojThreshold = 10.;
+            if (version == 2) { // in low version original_points[2] may be calculated more accurately using intersections method
+                object_points.push_back(original_points[2]);
+                ransacReprojThreshold = 5.; // set more strict ransacReprojThreshold
+                perspective_points.push_back({test_perspective_size, test_perspective_size});
+            }
+            Mat H = findHomography(object_points, perspective_points, RANSAC, ransacReprojThreshold);
+            if (H.empty())
+                return;
+            updatePerspective(H);
+            vector<Point2f> newCorner2 = {{test_perspective_size, test_perspective_size}};
+            perspectiveTransform(newCorner2, newCorner2, H.inv());
+            original_points[2] = newCorner2.front();
+        }
+    }
+}
+
+bool QRDecode::samplingForVersion()
+{
+    CV_TRACE_FUNCTION();
+    const double multiplyingFactor = (version < 3)  ? 1. :
+                                     (version == 3) ? 2. :
+                                     3.;
+    const Size newFactorSize(
+                  cvRound(no_border_intermediate.size().width  * multiplyingFactor),
+                  cvRound(no_border_intermediate.size().height * multiplyingFactor));
+    Mat postIntermediate(newFactorSize, CV_8UC1);
+    resize(no_border_intermediate, postIntermediate, newFactorSize, 0, 0, INTER_AREA);
+
+    const int delta_rows = cvRound((postIntermediate.rows * 1.0) / version_size);
+    const int delta_cols = cvRound((postIntermediate.cols * 1.0) / version_size);
+    // number of elements in the tail
+    const int skipped_rows = postIntermediate.rows - delta_rows * version_size;
+    const int skipped_cols = postIntermediate.cols - delta_cols * version_size;
+
+    vector<int> deltas_rows(version_size, delta_rows);
+    vector<int> deltas_cols(version_size, delta_cols);
+
+    for (int i = 0; i < abs(skipped_rows); i++) {
+        // fix deltas_rows at each skip_step
+        const double skip_step = static_cast<double>(version_size)/abs(skipped_rows);
+        const int corrected_index = static_cast<int>(i*skip_step + skip_step/2);
+        deltas_rows[corrected_index] += skipped_rows > 0 ? 1 : -1;
+    }
+    for (int i = 0; i < abs(skipped_cols); i++) {
+        // fix deltas_cols at each skip_step
+        const double skip_step = static_cast<double>(version_size)/abs(skipped_cols);
+        const int corrected_index = static_cast<int>(i*skip_step + skip_step/2);
+        deltas_cols[corrected_index] += skipped_cols > 0 ? 1 : -1;
+    }
+
+    const double totalFrequencyElem = countNonZero(postIntermediate) / static_cast<double>(postIntermediate.total());
+    straight = Mat(Size(version_size, version_size), CV_8UC1, Scalar(0));
+
+    for (int r = 0, i = 0; i < version_size; r += deltas_rows[i], i++) {
+        for (int c = 0, j = 0; j < version_size; c += deltas_cols[j], j++) {
+            Mat tile = postIntermediate(
+                           Range(r, min(r + delta_rows, postIntermediate.rows)),
+                           Range(c, min(c + delta_cols, postIntermediate.cols)));
+            const double frequencyElem = (countNonZero(tile) * 1.0) / tile.total();
+            straight.ptr<uint8_t>(i)[j] = (frequencyElem < totalFrequencyElem) ? 0 : 255;
+        }
+    }
+    return true;
+}
+
+static bool checkASCIIcompatible(const uint8_t* str, const size_t size) {
+    for (size_t i = 0; i < size; ++i) {
+        uint8_t byte = str[i];
+        if (byte >= 0x80)
+            return false;
+    }
+    return true;
+}
+
+static bool checkUTF8(const uint8_t* str, const size_t size) {
+    for (size_t i = 0; i < size; ++i) {
+        uint8_t byte = str[i];
+        if (byte >= 0x80) {
+            // Check that symbol is encoded correctly.
+
+            // Count number of bytes per symbol as a number of leading non-zero bits
+            uint8_t numBytesPerSymbol;
+            if ((byte & 0xe0) == 0xc0)
+                numBytesPerSymbol = 2;
+            else if ((byte & 0xf0) == 0xe0)
+                numBytesPerSymbol = 3;
+            else if ((byte & 0xf8) == 0xf0)
+                numBytesPerSymbol = 4;
+            else
+                return false;
+
+            for (size_t j = 1; j < numBytesPerSymbol; ++j) {
+                if (i + j >= size || (str[i + j] & 0xc0) != 0x80) {
+                    return false;
+                }
+            }
+            i += numBytesPerSymbol - 1;
+        }
+    }
+    return true;
+}
+
+static std::string encodeUTF8_bytesarray(const uint8_t* str, const size_t size) {
+    std::ostringstream res;
+    for (size_t i = 0; i < size; ++i) {
+        uint8_t byte = str[i];
+        if (byte >= 0x80) {
+            res << (char)(0xc0 | (byte >> 6));
+            res << (char)(0x80 | (byte & 0x3f));
+        } else {
+            res << (char)byte;
+        }
+    }
+    return res.str();
+}
+
+bool QRDecode::decodingProcess()
+{
+    const uint8_t* payload;
+    size_t payload_len;
+
+    auto decoder = QRCodeDecoder::create();
+    if (!decoder->decode(straight, result_info))
+        return false;
+    mode = decoder->mode;
+    eci = decoder->eci;
+    payload = reinterpret_cast<const uint8_t*>(result_info.c_str());
+    payload_len = result_info.size();
+    structure_info.parity = decoder->parity;
+    structure_info.sequence_num = decoder->sequence_num;
+    structure_info.total_num = decoder->total_num;
+
+    // Check output string format
+    switch (mode)
+    {
+        case QRCodeEncoder::EncodeMode::MODE_NUMERIC:
+            if (!checkASCIIcompatible(payload, payload_len)) {
+                CV_LOG_INFO(NULL, "QR: DATA_TYPE_NUMERIC payload must be ACSII compatible string");
+                return false;
+            }
+            result_info.assign((const char*)payload, payload_len);
+            return true;
+        case QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC:
+            if (!checkASCIIcompatible(payload, payload_len)) {
+                CV_LOG_INFO(NULL, "QR: DATA_TYPE_ALPHA payload must be ASCII compatible string");
+                return false;
+            }
+            result_info.assign((const char*)payload, payload_len);
+            return true;
+        case QRCodeEncoder::EncodeMode::MODE_BYTE:
+            // https://en.wikipedia.org/wiki/Extended_Channel_Interpretation
+            if (eci == QRCodeEncoder::ECIEncodings::ECI_UTF8) {
+                CV_LOG_INFO(NULL, "QR: payload ECI is UTF-8");
+                if (!checkUTF8(payload, payload_len)) {
+                    CV_LOG_INFO(NULL, "QRCode in BYTE mode with UTF-8 ECI must be UTF-8 compatible string");
+                    return false;
+                }
+                result_info.assign((const char*)payload, payload_len);
+            } else if (eci == 25/*ECI_UTF_16BE*/) {
+                CV_LOG_INFO(NULL, "QR: UTF-16BE ECI is not supported");
+                return false;
+            } else if (checkASCIIcompatible(payload, payload_len)) {
+                CV_LOG_INFO(NULL, "QR: payload is ASCII compatible (special handling for symbols encoding is not needed)");
+                result_info.assign((const char*)payload, payload_len);
+            } else {
+                if (checkUTF8(payload, payload_len)) {
+                    CV_LOG_INFO(NULL, "QR: payload bytes are UTF-8 compatible, return as-is");
+                    result_info.assign((const char*)payload, payload_len);
+                } else {
+                    CV_LOG_INFO(NULL, "QR: assume 1-byte per symbol encoding");
+                    result_info = encodeUTF8_bytesarray(payload, payload_len);
+                }
+            }
+            return true;
+        case QRCodeEncoder::EncodeMode::MODE_KANJI:
+            // FIXIT BUG: we must return UTF-8 compatible string
+            eci = QRCodeEncoder::ECIEncodings::ECI_SHIFT_JIS;
+            result_info.assign((const char*)payload, payload_len);
+            return true;
+        case QRCodeEncoder::EncodeMode::MODE_ECI:
+            CV_LOG_WARNING(NULL, "QR: ECI is not supported properly");
+            result_info.assign((const char*)payload, payload_len);
+            return true;
+        case QRCodeEncoder::EncodeMode::MODE_STRUCTURED_APPEND:
+            result_info.assign((const char*)payload, payload_len);
+            return true;
+        default:
+            CV_LOG_WARNING(NULL, "QR: unsupported QR data type");
+            return false;
+    }
+}
+
+bool QRDecode::straightDecodingProcess()
+{
+    if (!updatePerspective(getHomography()))  { return false; }
+    if (!versionDefinition())  { return false; }
+    if (useAlignmentMarkers)
+        detectAlignment();
+    if (!samplingForVersion()) { return false; }
+    if (!decodingProcess())    { return false; }
+    return true;
+}
+
+bool QRDecode::curvedDecodingProcess()
+{
+    if (!preparingCurvedQRCodes()) { return false; }
+    if (!versionDefinition())  { return false; }
+    if (!samplingForVersion()) { return false; }
+    if (!decodingProcess())    { return false; }
+    return true;
+}
+
+QRDecode::QRDecode(bool _useAlignmentMarkers):
+    useAlignmentMarkers(_useAlignmentMarkers),
+    version(0),
+    version_size(0),
+    test_perspective_size(0.f),
+    mode(QRCodeEncoder::EncodeMode::MODE_AUTO)
+    {}
+
+std::string ImplContour::decode(InputArray in, InputArray points, OutputArray straight_qrcode) const {
+    Mat inarr;
+    if (!checkQRInputImage(in, inarr))
+        return std::string();
+
+    vector<Point2f> src_points;
+    points.copyTo(src_points);
+    CV_Assert(src_points.size() == 4);
+    CV_CheckGT(contourArea(src_points), 0.0, "Invalid QR code source points");
+
+    QRDecode qrdec(useAlignmentMarkers);
+    qrdec.init(inarr, src_points);
+    bool ok = qrdec.straightDecodingProcess();
+
+    std::string decoded_info = qrdec.getDecodeInformation();
+    if (!ok && straight_qrcode.needed())
+    {
+        straight_qrcode.release();
+    }
+    else if (straight_qrcode.needed())
+    {
+        qrdec.getStraightBarcode().convertTo(straight_qrcode, CV_8UC1);
+    }
+    if (ok && !decoded_info.empty()) {
+        alignmentMarkers = {qrdec.alignment_coords};
+        updateQrCorners = qrdec.getOriginalPoints();
+    }
+    encodings.resize(1, qrdec.eci);
+    return ok ? decoded_info : std::string();
+}
+
+String QRCodeDetector::decodeCurved(InputArray in, InputArray points, OutputArray straight_qrcode) {
+    CV_Assert(p);
+    return std::dynamic_pointer_cast<ImplContour>(p)->decodeCurved(in, points, straight_qrcode);
+}
+
+String ImplContour::decodeCurved(InputArray in, InputArray points, OutputArray straight_qrcode)
+{
+    Mat inarr;
+    if (!checkQRInputImage(in, inarr))
+        return std::string();
+
+    vector<Point2f> src_points;
+    points.copyTo(src_points);
+    CV_Assert(src_points.size() == 4);
+    CV_CheckGT(contourArea(src_points), 0.0, "Invalid QR code source points");
+
+    QRDecode qrdec(useAlignmentMarkers);
+    qrdec.init(inarr, src_points);
+    bool ok = qrdec.curvedDecodingProcess();
+
+    std::string decoded_info = qrdec.getDecodeInformation();
+
+    if (!ok && straight_qrcode.needed())
+    {
+        straight_qrcode.release();
+    }
+    else if (straight_qrcode.needed())
+    {
+        qrdec.getStraightBarcode().convertTo(straight_qrcode, CV_8UC1);
+    }
+    encodings.resize(1, qrdec.eci);
+
+    return ok ? decoded_info : std::string();
+}
+
+std::string ImplContour::detectAndDecode(InputArray in, OutputArray points_, OutputArray straight_qrcode) const {
+    Mat inarr;
+    if (!checkQRInputImage(in, inarr))
+    {
+        points_.release();
+        return std::string();
+    }
+
+    vector<Point2f> points;
+    bool ok = detect(inarr, points);
+    if (!ok)
+    {
+        points_.release();
+        return std::string();
+    }
+    updatePointsResult(points_, points);
+    std::string decoded_info = decode(inarr, points, straight_qrcode);
+    return decoded_info;
+}
+
+std::string QRCodeDetector::detectAndDecodeCurved(InputArray in, OutputArray points,
+                                                  OutputArray straight_qrcode) {
+    CV_Assert(p);
+    return std::dynamic_pointer_cast<ImplContour>(p)->detectAndDecodeCurved(in, points, straight_qrcode);
+}
+
+std::string ImplContour::detectAndDecodeCurved(InputArray in, OutputArray points_,
+                                               OutputArray straight_qrcode)
+{
+    Mat inarr;
+    if (!checkQRInputImage(in, inarr))
+    {
+        points_.release();
+        return std::string();
+    }
+
+    vector<Point2f> points;
+    bool ok = detect(inarr, points);
+    if (!ok)
+    {
+        points_.release();
+        return std::string();
+    }
+    updatePointsResult(points_, points);
+    std::string decoded_info = decodeCurved(inarr, points, straight_qrcode);
+    return decoded_info;
+}
+
+class QRDetectMulti : public QRDetect
+{
+public:
+    void init(const Mat& src, double eps_vertical_ = 0.2, double eps_horizontal_ = 0.1);
+    bool localization();
+    bool computeTransformationPoints(const size_t cur_ind);
+    vector< vector < Point2f > > getTransformationPoints() { return transformation_points;}
+
+protected:
+    int findNumberLocalizationPoints(vector<Point2f>& tmp_localization_points);
+    void findQRCodeContours(vector<Point2f>& tmp_localization_points, vector< vector< Point2f > >& true_points_group, const int& num_qrcodes);
+    bool checkSets(vector<vector<Point2f> >& true_points_group, vector<vector<Point2f> >& true_points_group_copy,
+                   vector<Point2f>& tmp_localization_points);
+    void deleteUsedPoints(vector<vector<Point2f> >& true_points_group, vector<vector<Point2f> >& loc,
+                          vector<Point2f>& tmp_localization_points);
+    void fixationPoints(vector<Point2f> &local_point);
+    bool checkPoints(vector<Point2f> quadrangle_points);
+    bool checkPointsInsideQuadrangle(const vector<Point2f>& quadrangle_points);
+    bool checkPointsInsideTriangle(const vector<Point2f>& triangle_points);
+
+    Mat bin_barcode_fullsize, bin_barcode_temp;
+    vector<Point2f> not_resized_loc_points;
+    vector<Point2f> resized_loc_points;
+    vector< vector< Point2f > > localization_points, transformation_points;
+    struct compareDistanse_y
+    {
+        bool operator()(const Point2f& a, const Point2f& b) const
+        {
+            if (a.y != b.y)
+                return a.y < b.y;
+            else
+                return a.x < b.x;
+        }
+    };
+    struct compareSquare
+    {
+        const vector<Point2f>& points;
+        compareSquare(const vector<Point2f>& points_) : points(points_) {}
+        bool operator()(const Vec3i& a, const Vec3i& b) const;
+    };
+    Mat original;
+    class ParallelSearch : public ParallelLoopBody
+    {
+    public:
+        ParallelSearch(vector< vector< Point2f > >& true_points_group_,
+                vector< vector< Point2f > >& loc_, int iter_, vector<int>& end_,
+                vector< vector< Vec3i > >& all_points_,
+                QRDetectMulti& cl_)
+        :
+            true_points_group(true_points_group_),
+            loc(loc_),
+            iter(iter_),
+            end(end_),
+            all_points(all_points_),
+            cl(cl_)
+        {
+        }
+        void operator()(const Range& range) const CV_OVERRIDE;
+        vector< vector< Point2f > >& true_points_group;
+        vector< vector< Point2f > >& loc;
+        int iter;
+        vector<int>& end;
+        vector< vector< Vec3i > >& all_points;
+        QRDetectMulti& cl;
+    };
+};
+
+void QRDetectMulti::ParallelSearch::operator()(const Range& range) const
+{
+    for (int s = range.start; s < range.end; s++)
+    {
+        bool flag = false;
+        for (int r = iter; r < end[s]; r++)
+        {
+            if (flag)
+                break;
+
+            size_t x = iter + s;
+            size_t k = r - iter;
+            vector<Point2f> triangle;
+
+            for (int l = 0; l < 3; l++)
+            {
+                triangle.push_back(true_points_group[s][all_points[s][k][l]]);
+            }
+
+            if (cl.checkPointsInsideTriangle(triangle))
+            {
+                bool flag_for_break = false;
+                cl.fixationPoints(triangle);
+                if (triangle.size() == 3)
+                {
+                    cl.localization_points[x] = triangle;
+                    if (cl.purpose == cl.SHRINKING)
+                    {
+
+                        for (size_t j = 0; j < 3; j++)
+                        {
+                            cl.localization_points[x][j] *= cl.coeff_expansion;
+                        }
+                    }
+                    else if (cl.purpose == cl.ZOOMING)
+                    {
+                        for (size_t j = 0; j < 3; j++)
+                        {
+                            cl.localization_points[x][j] /= cl.coeff_expansion;
+                        }
+                    }
+                    for (size_t i = 0; i < 3; i++)
+                    {
+                        for (size_t j = i + 1; j < 3; j++)
+                        {
+                            if (norm(cl.localization_points[x][i] - cl.localization_points[x][j]) < 10)
+                            {
+                                cl.localization_points[x].clear();
+                                flag_for_break = true;
+                                break;
+                            }
+                        }
+                        if (flag_for_break)
+                            break;
+                    }
+                    if ((!flag_for_break)
+                            && (cl.localization_points[x].size() == 3)
+                            && (cl.computeTransformationPoints(x))
+                            && (cl.checkPointsInsideQuadrangle(cl.transformation_points[x]))
+                            && (cl.checkPoints(cl.transformation_points[x])))
+                    {
+                        for (int l = 0; l < 3; l++)
+                        {
+                            loc[s][all_points[s][k][l]].x = -1;
+                        }
+
+                        flag = true;
+                        break;
+                    }
+                }
+                if (flag)
+                {
+                    break;
+                }
+                else
+                {
+                    cl.transformation_points[x].clear();
+                    cl.localization_points[x].clear();
+                }
+            }
+        }
+    }
+}
+
+void QRDetectMulti::init(const Mat& src, double eps_vertical_, double eps_horizontal_)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(!src.empty());
+    const double min_side = std::min(src.size().width, src.size().height);
+    if (min_side < 512.0)
+    {
+        purpose = ZOOMING;
+        coeff_expansion = 512.0 / min_side;
+        const int width  = cvRound(src.size().width  * coeff_expansion);
+        const int height = cvRound(src.size().height  * coeff_expansion);
+        Size new_size(width, height);
+        resize(src, barcode, new_size, 0, 0, INTER_LINEAR_EXACT);
+    }
+    else if (min_side > 512.0)
+    {
+        purpose = SHRINKING;
+        coeff_expansion = min_side / 512.0;
+        const int width  = cvRound(src.size().width  / coeff_expansion);
+        const int height = cvRound(src.size().height  / coeff_expansion);
+        Size new_size(width, height);
+        resize(src, barcode, new_size, 0, 0, INTER_AREA);
+    }
+    else
+    {
+        purpose = UNCHANGED;
+        coeff_expansion = 1.0;
+        barcode = src.clone();
+    }
+
+    eps_vertical   = eps_vertical_;
+    eps_horizontal = eps_horizontal_;
+    adaptiveThreshold(barcode, bin_barcode, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 83, 2);
+    adaptiveThreshold(src, bin_barcode_fullsize, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 83, 2);
+}
+
+void QRDetectMulti::fixationPoints(vector<Point2f> &local_point)
+{
+    CV_TRACE_FUNCTION();
+
+    Point2f v0(local_point[1] - local_point[2]);
+    Point2f v1(local_point[0] - local_point[2]);
+    Point2f v2(local_point[1] - local_point[0]);
+
+    double cos_angles[3], norm_triangl[3];
+    norm_triangl[0] = norm(v0);
+    norm_triangl[1] = norm(v1);
+    norm_triangl[2] = norm(v2);
+
+    cos_angles[0] = v2.dot(-v1) / (norm_triangl[1] * norm_triangl[2]);
+    cos_angles[1] = v2.dot(v0) / (norm_triangl[0] * norm_triangl[2]);
+    cos_angles[2] = v1.dot(v0) / (norm_triangl[0] * norm_triangl[1]);
+
+    const double angle_barrier = 0.85;
+    if (fabs(cos_angles[0]) > angle_barrier || fabs(cos_angles[1]) > angle_barrier || fabs(cos_angles[2]) > angle_barrier)
+    {
+        local_point.clear();
+        return;
+    }
+
+    size_t i_min_cos =
+            (cos_angles[0] < cos_angles[1] && cos_angles[0] < cos_angles[2]) ? 0 :
+                    (cos_angles[1] < cos_angles[0] && cos_angles[1] < cos_angles[2]) ? 1 : 2;
+
+    size_t index_max = 0;
+    double max_area = std::numeric_limits<double>::min();
+    for (size_t i = 0; i < local_point.size(); i++)
+    {
+        const size_t current_index = i % 3;
+        const size_t left_index  = (i + 1) % 3;
+        const size_t right_index = (i + 2) % 3;
+
+        const Point2f current_point(local_point[current_index]);
+        const Point2f left_point(local_point[left_index]);
+        const Point2f right_point(local_point[right_index]);
+        const Point2f central_point(intersectionLines(
+                current_point,
+                Point2f(static_cast<float>((local_point[left_index].x + local_point[right_index].x) * 0.5),
+                        static_cast<float>((local_point[left_index].y + local_point[right_index].y) * 0.5)),
+                Point2f(0, static_cast<float>(bin_barcode_temp.rows - 1)),
+                Point2f(static_cast<float>(bin_barcode_temp.cols - 1),
+                        static_cast<float>(bin_barcode_temp.rows - 1))));
+
+        vector<Point2f> list_area_pnt;
+        list_area_pnt.push_back(current_point);
+
+        vector<LineIterator> list_line_iter;
+        list_line_iter.emplace_back(bin_barcode_temp, current_point, left_point);
+        list_line_iter.emplace_back(bin_barcode_temp, current_point, central_point);
+        list_line_iter.emplace_back(bin_barcode_temp, current_point, right_point);
+
+        for (size_t k = 0; k < list_line_iter.size(); k++)
+        {
+            LineIterator& li = list_line_iter[k];
+            uint8_t future_pixel = 255, count_index = 0;
+            for (int j = 0; j < li.count; j++, ++li)
+            {
+                Point p = li.pos();
+                if (p.x >= bin_barcode_temp.cols ||
+                    p.y >= bin_barcode_temp.rows)
+                {
+                    break;
+                }
+
+                const uint8_t value = bin_barcode_temp.at<uint8_t>(p);
+                if (value == future_pixel)
+                {
+                    future_pixel = static_cast<uint8_t>(~future_pixel);
+                    count_index++;
+                    if (count_index == 3)
+                    {
+                        list_area_pnt.push_back(p);
+                        break;
+                    }
+                }
+            }
+        }
+
+        const double temp_check_area = contourArea(list_area_pnt);
+        if (temp_check_area > max_area)
+        {
+            index_max = current_index;
+            max_area = temp_check_area;
+        }
+
+    }
+    if (index_max == i_min_cos)
+    {
+        std::swap(local_point[0], local_point[index_max]);
+    }
+    else
+    {
+        local_point.clear();
+        return;
+    }
+
+    const Point2f rpt = local_point[0], bpt = local_point[1], gpt = local_point[2];
+    Matx22f m(rpt.x - bpt.x, rpt.y - bpt.y, gpt.x - rpt.x, gpt.y - rpt.y);
+    if (determinant(m) > 0)
+    {
+        std::swap(local_point[1], local_point[2]);
+    }
+}
+
+class BWCounter
+{
+    size_t white;
+    size_t black;
+public:
+    BWCounter(size_t b = 0, size_t w = 0) : white(w), black(b) {}
+    BWCounter& operator+=(const BWCounter& other) { black += other.black; white += other.white; return *this; }
+    void count1(uchar pixel) { if (pixel == 255) white++; else if (pixel == 0) black++; }
+    double getBWFraction() const { return white == 0 ? std::numeric_limits<double>::infinity() : double(black) / double(white); }
+    static BWCounter checkOnePair(const Point2f& tl, const Point2f& tr, const Point2f& bl, const Point2f& br, const Mat& img)
+    {
+        BWCounter res;
+        LineIterator li1(tl, tr), li2(bl, br);
+        for (int i = 0; i < li1.count && i < li2.count; i++, li1++, li2++)
+        {
+            LineIterator it(img, li1.pos(), li2.pos());
+            for (int r = 0; r < it.count; r++, it++)
+                res.count1(img.at<uchar>(it.pos()));
+        }
+        return res;
+    }
+};
+
+bool QRDetectMulti::checkPoints(vector<Point2f> quadrangle)
+{
+    if (quadrangle.size() != 4)
+        return false;
+    std::sort(quadrangle.begin(), quadrangle.end(), compareDistanse_y());
+    BWCounter s;
+    s += BWCounter::checkOnePair(quadrangle[1], quadrangle[0], quadrangle[2], quadrangle[0], bin_barcode);
+    s += BWCounter::checkOnePair(quadrangle[1], quadrangle[3], quadrangle[2], quadrangle[3], bin_barcode);
+    const double frac = s.getBWFraction();
+    return frac > 0.76 && frac < 1.24;
+}
+
+bool QRDetectMulti::checkPointsInsideQuadrangle(const vector<Point2f>& quadrangle_points)
+{
+    if (quadrangle_points.size() != 4)
+        return false;
+
+    int count = 0;
+    for (size_t i = 0; i < not_resized_loc_points.size(); i++)
+    {
+        if (pointPolygonTest(quadrangle_points, not_resized_loc_points[i], true) > 0)
+        {
+            count++;
+        }
+    }
+    if (count == 3)
+        return true;
+    else
+        return false;
+}
+
+bool QRDetectMulti::checkPointsInsideTriangle(const vector<Point2f>& triangle_points)
+{
+    if (triangle_points.size() != 3)
+        return false;
+    double eps = 3;
+    for (size_t i = 0; i < resized_loc_points.size(); i++)
+    {
+        if (pointPolygonTest( triangle_points, resized_loc_points[i], true ) > 0)
+        {
+            if ((abs(resized_loc_points[i].x - triangle_points[0].x) > eps)
+                    && (abs(resized_loc_points[i].x - triangle_points[1].x) > eps)
+                    && (abs(resized_loc_points[i].x - triangle_points[2].x) > eps))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool QRDetectMulti::compareSquare::operator()(const Vec3i& a, const Vec3i& b) const
+{
+    Point2f a0 = points[a[0]];
+    Point2f a1 = points[a[1]];
+    Point2f a2 = points[a[2]];
+    Point2f b0 = points[b[0]];
+    Point2f b1 = points[b[1]];
+    Point2f b2 = points[b[2]];
+    return fabs((a1.x - a0.x) * (a2.y - a0.y) - (a2.x - a0.x) * (a1.y - a0.y)) <
+           fabs((b1.x - b0.x) * (b2.y - b0.y) - (b2.x - b0.x) * (b1.y - b0.y));
+}
+
+int QRDetectMulti::findNumberLocalizationPoints(vector<Point2f>& tmp_localization_points)
+{
+    size_t number_possible_purpose = 1;
+    if (purpose == SHRINKING)
+        number_possible_purpose = 2;
+    Mat tmp_shrinking = bin_barcode;
+    int tmp_num_points = 0;
+    int num_points = -1;
+    double eps = 0.0;
+    for (int epsCoeff = 1; epsCoeff <= 3; epsCoeff++)
+    {
+        eps = eps_horizontal * static_cast<double>(epsCoeff);
+        tmp_num_points = 0;
+        num_points = -1;
+        if (purpose == SHRINKING)
+            number_possible_purpose = 2;
+        else
+            number_possible_purpose = 1;
+        for (size_t k = 0; k < number_possible_purpose; k++)
+        {
+            if (k == 1)
+                bin_barcode = bin_barcode_fullsize;
+            vector<Vec3d> list_lines_x = searchHorizontalLines();
+            if (list_lines_x.empty())
+            {
+                if (k == 0)
+                {
+                    k = 1;
+                    bin_barcode = bin_barcode_fullsize;
+                    list_lines_x = searchHorizontalLines();
+                    if (list_lines_x.empty())
+                        break;
+                }
+                else
+                    break;
+            }
+            vector<Point2f> list_lines_y = extractVerticalLines(list_lines_x, eps);
+            if (list_lines_y.size() < 3)
+            {
+                if (k == 0)
+                {
+                    k = 1;
+                    bin_barcode = bin_barcode_fullsize;
+                    list_lines_x = searchHorizontalLines();
+                    if (list_lines_x.empty())
+                        break;
+                    list_lines_y = extractVerticalLines(list_lines_x, eps);
+                    if (list_lines_y.size() < 3)
+                        break;
+                }
+                else
+                    break;
+            }
+            vector<int> index_list_lines_y;
+            for (size_t i = 0; i < list_lines_y.size(); i++)
+                index_list_lines_y.push_back(-1);
+            num_points = 0;
+            for (size_t i = 0; i < list_lines_y.size() - 1; i++)
+            {
+                for (size_t j = i; j < list_lines_y.size(); j++ )
+                {
+
+                    double points_distance = norm(list_lines_y[i] - list_lines_y[j]);
+                    if (points_distance <= 10)
+                    {
+                        if ((index_list_lines_y[i] == -1) && (index_list_lines_y[j] == -1))
+                        {
+                            index_list_lines_y[i] = num_points;
+                            index_list_lines_y[j] = num_points;
+                            num_points++;
+                        }
+                        else if (index_list_lines_y[i] != -1)
+                            index_list_lines_y[j] = index_list_lines_y[i];
+                        else if (index_list_lines_y[j] != -1)
+                            index_list_lines_y[i] = index_list_lines_y[j];
+                    }
+                }
+            }
+            for (size_t i = 0; i < index_list_lines_y.size(); i++)
+            {
+                if (index_list_lines_y[i] == -1)
+                {
+                    index_list_lines_y[i] = num_points;
+                    num_points++;
+                }
+            }
+            if ((tmp_num_points < num_points) && (k == 1))
+            {
+                purpose = UNCHANGED;
+                tmp_num_points = num_points;
+                bin_barcode = bin_barcode_fullsize;
+                coeff_expansion = 1.0;
+            }
+            if ((tmp_num_points < num_points) && (k == 0))
+            {
+                tmp_num_points = num_points;
+            }
+        }
+
+        if ((tmp_num_points < 3) && (tmp_num_points >= 1))
+        {
+            const double min_side = std::min(bin_barcode_fullsize.size().width, bin_barcode_fullsize.size().height);
+            if (min_side > 512)
+            {
+                bin_barcode = tmp_shrinking;
+                purpose = SHRINKING;
+                coeff_expansion = min_side / 512.0;
+            }
+            if (min_side < 512)
+            {
+                bin_barcode = tmp_shrinking;
+                purpose = ZOOMING;
+                coeff_expansion = 512 / min_side;
+            }
+        }
+        else
+            break;
+    }
+    if (purpose == SHRINKING)
+        bin_barcode = tmp_shrinking;
+    num_points = tmp_num_points;
+    vector<Vec3d> list_lines_x = searchHorizontalLines();
+    if (list_lines_x.empty())
+        return num_points;
+    vector<Point2f> list_lines_y = extractVerticalLines(list_lines_x, eps);
+    if (list_lines_y.size() < 3)
+        return num_points;
+    if (num_points < 3)
+        return num_points;
+
+    Mat labels;
+    kmeans(list_lines_y, num_points, labels,
+            TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1),
+            num_points, KMEANS_PP_CENTERS, tmp_localization_points);
+    bin_barcode_temp = bin_barcode.clone();
+    if (purpose == SHRINKING)
+    {
+        const int width  = cvRound(bin_barcode.size().width  * coeff_expansion);
+        const int height = cvRound(bin_barcode.size().height * coeff_expansion);
+        Size new_size(width, height);
+        Mat intermediate;
+        resize(bin_barcode, intermediate, new_size, 0, 0, INTER_LINEAR_EXACT);
+        bin_barcode = intermediate.clone();
+    }
+    else if (purpose == ZOOMING)
+    {
+        const int width  = cvRound(bin_barcode.size().width  / coeff_expansion);
+        const int height = cvRound(bin_barcode.size().height / coeff_expansion);
+        Size new_size(width, height);
+        Mat intermediate;
+        resize(bin_barcode, intermediate, new_size, 0, 0, INTER_LINEAR_EXACT);
+        bin_barcode = intermediate.clone();
+    }
+    else
+    {
+        bin_barcode = bin_barcode_fullsize.clone();
+    }
+    return num_points;
+}
+
+void QRDetectMulti::findQRCodeContours(vector<Point2f>& tmp_localization_points,
+                                      vector< vector< Point2f > >& true_points_group, const int& num_qrcodes)
+{
+    Mat gray, blur_image, threshold_output;
+    Mat bar = barcode;
+    const int width  = cvRound(bin_barcode.size().width);
+    const int height = cvRound(bin_barcode.size().height);
+    Size new_size(width, height);
+    resize(bar, bar, new_size, 0, 0, INTER_LINEAR_EXACT);
+    blur(bar, blur_image, Size(3, 3));
+    threshold(blur_image, threshold_output, 50, 255, THRESH_BINARY);
+
+    vector< vector< Point > > contours;
+    vector<Vec4i> hierarchy;
+    findContours(threshold_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0));
+    vector<Point2f> all_contours_points;
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        for (size_t j = 0; j < contours[i].size(); j++)
+        {
+            all_contours_points.push_back(contours[i][j]);
+        }
+    }
+    Mat qrcode_labels;
+    vector<Point2f> clustered_localization_points;
+    int count_contours = num_qrcodes;
+    if (all_contours_points.size() < size_t(num_qrcodes))
+        count_contours = (int)all_contours_points.size();
+    kmeans(all_contours_points, count_contours, qrcode_labels,
+          TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1),
+          count_contours, KMEANS_PP_CENTERS, clustered_localization_points);
+
+    vector< vector< Point2f > > qrcode_clusters(count_contours);
+    for (int i = 0; i < count_contours; i++)
+        for (int j = 0; j < int(all_contours_points.size()); j++)
+        {
+            if (qrcode_labels.at<int>(j, 0) == i)
+            {
+                qrcode_clusters[i].push_back(all_contours_points[j]);
+            }
+        }
+    vector< vector< Point2f > > hull(count_contours);
+    for (size_t i = 0; i < qrcode_clusters.size(); i++)
+        convexHull(Mat(qrcode_clusters[i]), hull[i]);
+    not_resized_loc_points = tmp_localization_points;
+    resized_loc_points = tmp_localization_points;
+    if (purpose == SHRINKING)
+    {
+        for (size_t j = 0; j < not_resized_loc_points.size(); j++)
+        {
+            not_resized_loc_points[j] *= coeff_expansion;
+        }
+    }
+    else if (purpose == ZOOMING)
+    {
+        for (size_t j = 0; j < not_resized_loc_points.size(); j++)
+        {
+            not_resized_loc_points[j] /= coeff_expansion;
+        }
+    }
+
+    true_points_group.resize(hull.size());
+
+    for (size_t j = 0; j < hull.size(); j++)
+    {
+        for (size_t i = 0; i < not_resized_loc_points.size(); i++)
+        {
+            if (pointPolygonTest(hull[j], not_resized_loc_points[i], true) > 0)
+            {
+                true_points_group[j].push_back(tmp_localization_points[i]);
+                tmp_localization_points[i].x = -1;
+            }
+
+        }
+    }
+    vector<Point2f> copy;
+    for (size_t j = 0; j < tmp_localization_points.size(); j++)
+    {
+       if (tmp_localization_points[j].x != -1)
+            copy.push_back(tmp_localization_points[j]);
+    }
+    tmp_localization_points = copy;
+}
+
+bool QRDetectMulti::checkSets(vector<vector<Point2f> >& true_points_group, vector<vector<Point2f> >& true_points_group_copy,
+                              vector<Point2f>& tmp_localization_points)
+{
+    for (size_t i = 0; i < true_points_group.size(); i++)
+    {
+        if (true_points_group[i].size() < 3)
+        {
+            for (size_t j = 0; j < true_points_group[i].size(); j++)
+                tmp_localization_points.push_back(true_points_group[i][j]);
+            true_points_group[i].clear();
+        }
+    }
+    vector< vector< Point2f > > temp_for_copy;
+    for (size_t i = 0; i < true_points_group.size(); i++)
+    {
+        if (true_points_group[i].size() != 0)
+            temp_for_copy.push_back(true_points_group[i]);
+    }
+    true_points_group = temp_for_copy;
+    if (true_points_group.size() == 0)
+    {
+        true_points_group.push_back(tmp_localization_points);
+        tmp_localization_points.clear();
+    }
+    if (true_points_group.size() == 0)
+        return false;
+    if (true_points_group[0].size() < 3)
+        return false;
+
+
+    vector<int> set_size(true_points_group.size());
+    for (size_t i = 0; i < true_points_group.size(); i++)
+    {
+        const std::uint64_t true_points_group_size = true_points_group[i].size();
+        // ensure set_size[i] doesn't overflow
+        CV_Assert(true_points_group_size <= 2345);
+        set_size[i] = static_cast<int>((true_points_group_size - 2) * (true_points_group_size - 1) *
+                                       true_points_group_size / 6);
+    }
+
+    vector< vector< Vec3i > > all_points(true_points_group.size());
+    for (size_t i = 0; i < true_points_group.size(); i++)
+        all_points[i].resize(set_size[i]);
+    int cur_cluster = 0;
+    for (size_t i = 0; i < true_points_group.size(); i++)
+    {
+        cur_cluster = 0;
+        for (size_t l = 0; l < true_points_group[i].size() - 2; l++)
+            for (size_t j = l + 1; j < true_points_group[i].size() - 1; j++)
+                for (size_t k = j + 1; k < true_points_group[i].size(); k++)
+                {
+                    all_points[i][cur_cluster][0] = int(l);
+                    all_points[i][cur_cluster][1] = int(j);
+                    all_points[i][cur_cluster][2] = int(k);
+                    cur_cluster++;
+                }
+    }
+
+    for (size_t i = 0; i < true_points_group.size(); i++)
+    {
+        std::sort(all_points[i].begin(), all_points[i].end(), compareSquare(true_points_group[i]));
+    }
+    if (true_points_group.size() == 1)
+    {
+        int check_number = 35;
+        if (set_size[0] > check_number)
+            set_size[0] = check_number;
+        all_points[0].resize(set_size[0]);
+    }
+    int iter = (int)localization_points.size();
+    localization_points.resize(iter + true_points_group.size());
+    transformation_points.resize(iter + true_points_group.size());
+
+    true_points_group_copy = true_points_group;
+    vector<int> end(true_points_group.size());
+    for (size_t i = 0; i < true_points_group.size(); i++)
+        end[i] = iter + set_size[i];
+    ParallelSearch parallelSearch(true_points_group,
+            true_points_group_copy, iter, end, all_points, *this);
+    parallel_for_(Range(0, (int)true_points_group.size()), parallelSearch);
+
+    return true;
+}
+
+void QRDetectMulti::deleteUsedPoints(vector<vector<Point2f> >& true_points_group, vector<vector<Point2f> >& loc,
+                                     vector<Point2f>& tmp_localization_points)
+{
+    size_t iter = localization_points.size() - true_points_group.size() ;
+    for (size_t s = 0; s < true_points_group.size(); s++)
+    {
+        if (localization_points[iter + s].empty())
+            loc[s][0].x = -2;
+
+        if (loc[s].size() == 3)
+        {
+
+            if ((true_points_group.size() > 1) || ((true_points_group.size() == 1) && (tmp_localization_points.size() != 0)) )
+            {
+                for (size_t j = 0; j < true_points_group[s].size(); j++)
+                {
+                    if (loc[s][j].x != -1)
+                    {
+                        loc[s][j].x = -1;
+                        tmp_localization_points.push_back(true_points_group[s][j]);
+                    }
+                }
+            }
+        }
+        vector<Point2f> for_copy;
+        for (size_t j = 0; j < loc[s].size(); j++)
+        {
+            if ((loc[s][j].x != -1) && (loc[s][j].x != -2) )
+            {
+                for_copy.push_back(true_points_group[s][j]);
+            }
+            if ((loc[s][j].x == -2) && (true_points_group.size() > 1))
+            {
+                tmp_localization_points.push_back(true_points_group[s][j]);
+            }
+        }
+        true_points_group[s] = for_copy;
+    }
+
+    vector< vector< Point2f > > for_copy_loc;
+    vector< vector< Point2f > > for_copy_trans;
+
+
+    for (size_t i = 0; i < localization_points.size(); i++)
+    {
+        if ((localization_points[i].size() == 3) && (transformation_points[i].size() == 4))
+        {
+            for_copy_loc.push_back(localization_points[i]);
+            for_copy_trans.push_back(transformation_points[i]);
+        }
+    }
+    localization_points = for_copy_loc;
+    transformation_points = for_copy_trans;
+}
+
+bool QRDetectMulti::localization()
+{
+    CV_TRACE_FUNCTION();
+    vector<Point2f> tmp_localization_points;
+    int num_points = findNumberLocalizationPoints(tmp_localization_points);
+    if (num_points < 3)
+        return false;
+    int num_qrcodes = divUp(num_points, 3);
+    vector<vector<Point2f> > true_points_group;
+    findQRCodeContours(tmp_localization_points, true_points_group, num_qrcodes);
+    for (int q = 0; q < num_qrcodes; q++)
+    {
+       vector<vector<Point2f> > loc;
+       size_t iter = localization_points.size();
+
+       if (!checkSets(true_points_group, loc, tmp_localization_points))
+            break;
+       deleteUsedPoints(true_points_group, loc, tmp_localization_points);
+       if ((localization_points.size() - iter) == 1)
+           q--;
+       if (((localization_points.size() - iter) == 0) && (tmp_localization_points.size() == 0) && (true_points_group.size() == 1) )
+            break;
+    }
+    if ((transformation_points.size() == 0) || (localization_points.size() == 0))
+       return false;
+    return true;
+}
+
+bool QRDetectMulti::computeTransformationPoints(const size_t cur_ind)
+{
+    CV_TRACE_FUNCTION();
+
+    if (localization_points[cur_ind].size() != 3)
+    {
+        return false;
+    }
+
+    vector<Point> locations, non_zero_elem[3], newHull;
+    vector<Point2f> new_non_zero_elem[3];
+    for (size_t i = 0; i < 3 ; i++)
+    {
+        Mat mask = Mat::zeros(bin_barcode.rows + 2, bin_barcode.cols + 2, CV_8UC1);
+        uint8_t next_pixel, future_pixel = 255;
+        int localization_point_x = cvRound(localization_points[cur_ind][i].x);
+        int localization_point_y = cvRound(localization_points[cur_ind][i].y);
+        int count_test_lines = 0, index = localization_point_x;
+        for (; index < bin_barcode.cols - 1; index++)
+        {
+            next_pixel = bin_barcode.at<uint8_t>(localization_point_y, index + 1);
+            if (next_pixel == future_pixel)
+            {
+                future_pixel = static_cast<uint8_t>(~future_pixel);
+                count_test_lines++;
+
+                if (count_test_lines == 2)
+                {
+                    // TODO avoid drawing functions
+                    floodFill(bin_barcode, mask,
+                            Point(index + 1, localization_point_y), 255,
+                            0, Scalar(), Scalar(), FLOODFILL_MASK_ONLY);
+                    break;
+                }
+            }
+
+        }
+        Mat mask_roi = mask(Range(1, bin_barcode.rows - 1), Range(1, bin_barcode.cols - 1));
+        findNonZero(mask_roi, non_zero_elem[i]);
+        newHull.insert(newHull.end(), non_zero_elem[i].begin(), non_zero_elem[i].end());
+    }
+    convexHull(newHull, locations);
+    for (size_t i = 0; i < locations.size(); i++)
+    {
+        for (size_t j = 0; j < 3; j++)
+        {
+            for (size_t k = 0; k < non_zero_elem[j].size(); k++)
+            {
+                if (locations[i] == non_zero_elem[j][k])
+                {
+                    new_non_zero_elem[j].push_back(locations[i]);
+                }
+            }
+        }
+    }
+
+    if (new_non_zero_elem[0].size() == 0)
+        return false;
+
+    double pentagon_diag_norm = -1;
+    Point2f down_left_edge_point, up_right_edge_point, up_left_edge_point;
+    for (size_t i = 0; i < new_non_zero_elem[1].size(); i++)
+    {
+        for (size_t j = 0; j < new_non_zero_elem[2].size(); j++)
+        {
+            double temp_norm = norm(new_non_zero_elem[1][i] - new_non_zero_elem[2][j]);
+            if (temp_norm > pentagon_diag_norm)
+            {
+                down_left_edge_point = new_non_zero_elem[1][i];
+                up_right_edge_point  = new_non_zero_elem[2][j];
+                pentagon_diag_norm = temp_norm;
+            }
+        }
+    }
+
+    if (down_left_edge_point == Point2f(0, 0) ||
+        up_right_edge_point  == Point2f(0, 0))
+    {
+        return false;
+    }
+
+    double max_area = -1;
+    up_left_edge_point = new_non_zero_elem[0][0];
+
+    for (size_t i = 0; i < new_non_zero_elem[0].size(); i++)
+    {
+        vector<Point2f> list_edge_points;
+        list_edge_points.push_back(new_non_zero_elem[0][i]);
+        list_edge_points.push_back(down_left_edge_point);
+        list_edge_points.push_back(up_right_edge_point);
+
+        double temp_area = fabs(contourArea(list_edge_points));
+        if (max_area < temp_area)
+        {
+            up_left_edge_point = new_non_zero_elem[0][i];
+            max_area = temp_area;
+        }
+    }
+
+    Point2f down_max_delta_point, up_max_delta_point;
+    double norm_down_max_delta = -1, norm_up_max_delta = -1;
+    for (size_t i = 0; i < new_non_zero_elem[1].size(); i++)
+    {
+        double temp_norm_delta = norm(up_left_edge_point - new_non_zero_elem[1][i]) + norm(down_left_edge_point - new_non_zero_elem[1][i]);
+        if (norm_down_max_delta < temp_norm_delta)
+        {
+            down_max_delta_point = new_non_zero_elem[1][i];
+            norm_down_max_delta = temp_norm_delta;
+        }
+    }
+
+
+    for (size_t i = 0; i < new_non_zero_elem[2].size(); i++)
+    {
+        double temp_norm_delta = norm(up_left_edge_point - new_non_zero_elem[2][i]) + norm(up_right_edge_point - new_non_zero_elem[2][i]);
+        if (norm_up_max_delta < temp_norm_delta)
+        {
+            up_max_delta_point = new_non_zero_elem[2][i];
+            norm_up_max_delta = temp_norm_delta;
+        }
+    }
+    vector<Point2f> tmp_transformation_points;
+    tmp_transformation_points.push_back(down_left_edge_point);
+    tmp_transformation_points.push_back(up_left_edge_point);
+    tmp_transformation_points.push_back(up_right_edge_point);
+    tmp_transformation_points.push_back(intersectionLines(
+                    down_left_edge_point, down_max_delta_point,
+                    up_right_edge_point, up_max_delta_point));
+    transformation_points[cur_ind] = tmp_transformation_points;
+
+    vector<Point2f> quadrilateral = getQuadrilateral(transformation_points[cur_ind]);
+    transformation_points[cur_ind] = quadrilateral;
+
+    return true;
+}
+
+bool ImplContour::detectMulti(InputArray in, OutputArray points) const {
+    Mat gray;
+    if (!checkQRInputImage(in, gray)) {
+        points.release();
+        return false;
+    }
+    vector<Point2f> result;
+    QRDetectMulti qrdet;
+    qrdet.init(gray, epsX, epsY);
+    if (!qrdet.localization()) {
+        points.release();
+        return false;
+    }
+    vector<vector<Point2f> > pnts2f = qrdet.getTransformationPoints();
+    for(size_t i = 0; i < pnts2f.size(); i++)
+        for(size_t j = 0; j < pnts2f[i].size(); j++)
+            result.push_back(pnts2f[i][j]);
+    if (result.size() >= 4) {
+        updatePointsResult(points, result);
+        return true;
+    }
+    return false;
+}
+
+class ParallelDecodeProcess : public ParallelLoopBody
+{
+public:
+    ParallelDecodeProcess(Mat& inarr_, vector<QRDecode>& qrdec_, vector<std::string>& decoded_info_,
+            vector<Mat>& straight_barcode_, vector< vector< Point2f > >& src_points_)
+        : inarr(inarr_), qrdec(qrdec_), decoded_info(decoded_info_)
+        , straight_barcode(straight_barcode_), src_points(src_points_)
+    {
+        // nothing
+    }
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        for (int i = range.start; i < range.end; i++)
+        {
+            qrdec[i].init(inarr, src_points[i]);
+            bool ok = qrdec[i].straightDecodingProcess();
+            if (ok)
+            {
+                decoded_info[i] = qrdec[i].getDecodeInformation();
+                straight_barcode[i] = qrdec[i].getStraightBarcode();
+            }
+            else if (std::min(inarr.size().width, inarr.size().height) > 512)
+            {
+                const int min_side = std::min(inarr.size().width, inarr.size().height);
+                qrdec[i].coeff_expansion = min_side / 512.f;
+                const int width  = cvRound(inarr.size().width  / qrdec[i].coeff_expansion);
+                const int height = cvRound(inarr.size().height / qrdec[i].coeff_expansion);
+                Size new_size(width, height);
+                Mat inarr2;
+                resize(inarr, inarr2, new_size, 0, 0, INTER_AREA);
+                for (size_t j = 0ull; j < 4ull; j++)
+                {
+                    src_points[i][j] /= qrdec[i].coeff_expansion;
+                }
+                qrdec[i].init(inarr2, src_points[i]);
+                ok = qrdec[i].straightDecodingProcess();
+                if (ok)
+                {
+                    decoded_info[i] = qrdec[i].getDecodeInformation();
+                    straight_barcode[i] = qrdec[i].getStraightBarcode();
+                    for (size_t j = 0ull; j < qrdec[i].alignment_coords.size(); j++)
+                        qrdec[i].alignment_coords[j] *= qrdec[i].coeff_expansion;
+                }
+            }
+            if (decoded_info[i].empty())
+                decoded_info[i] = "";
+        }
+    }
+
+private:
+    Mat& inarr;
+    vector<QRDecode>& qrdec;
+    vector<std::string>& decoded_info;
+    vector<Mat>& straight_barcode;
+    vector< vector< Point2f > >& src_points;
+
+};
+
+bool ImplContour::decodeMulti(
+        InputArray img,
+        InputArray points,
+        CV_OUT std::vector<cv::String>& decoded_info,
+        OutputArrayOfArrays straight_qrcode
+    ) const
+{
+    Mat inarr;
+    if (!checkQRInputImage(img, inarr))
+        return false;
+    CV_Assert(points.size().width > 0);
+    CV_Assert((points.size().width % 4) == 0);
+    vector< vector< Point2f > > src_points ;
+    Mat qr_points = points.getMat();
+    qr_points = qr_points.reshape(2, 1);
+    for (int i = 0; i < qr_points.size().width ; i += 4)
+    {
+        vector<Point2f> tempMat = qr_points.colRange(i, i + 4);
+        if (contourArea(tempMat) > 0.0)
+        {
+            src_points.push_back(tempMat);
+        }
+    }
+    CV_Assert(src_points.size() > 0);
+    vector<QRDecode> qrdec(src_points.size(), useAlignmentMarkers);
+    vector<Mat> straight_barcode(src_points.size());
+    vector<std::string> info(src_points.size());
+    ParallelDecodeProcess parallelDecodeProcess(inarr, qrdec, info, straight_barcode, src_points);
+    parallel_for_(Range(0, int(src_points.size())), parallelDecodeProcess);
+    vector<Mat> for_copy;
+    for (size_t i = 0; i < straight_barcode.size(); i++)
+    {
+        if (!(straight_barcode[i].empty()))
+            for_copy.push_back(straight_barcode[i]);
+    }
+    straight_barcode = for_copy;
+    if (straight_qrcode.needed() && straight_barcode.size() == 0)
+    {
+        straight_qrcode.release();
+    }
+    else if (straight_qrcode.needed())
+    {
+        straight_qrcode.create(Size((int)straight_barcode.size(), 1), CV_8UC1);
+        vector<Mat> tmp_straight_qrcodes(straight_barcode.size());
+        for (size_t i = 0; i < straight_barcode.size(); i++)
+        {
+            straight_barcode[i].convertTo(tmp_straight_qrcodes[i], CV_8UC1);
+        }
+        straight_qrcode.assign(tmp_straight_qrcodes);
+    }
+
+    decoded_info.resize(info.size());
+    encodings.resize(info.size());
+    for (size_t i = 0; i < info.size(); i++)
+    {
+        auto& decoder = qrdec[i];
+        encodings[i] = decoder.eci;
+        if (!decoder.isStructured())
+        {
+            decoded_info[i] = info[i];
+            continue;
+        }
+
+        // Store final message corresponding to 0-th code in a sequence.
+        if (decoder.structure_info.sequence_num != 0)
+        {
+            decoded_info[i] = "";
+            continue;
+        }
+
+        cv::String decoded = info[i];
+        for (size_t idx = 1; idx < decoder.structure_info.total_num; ++idx)
+        {
+            auto it = std::find_if(qrdec.begin(), qrdec.end(), [&](QRDecode& dec) {
+                return dec.structure_info.parity == decoder.structure_info.parity &&
+                       dec.structure_info.sequence_num == idx;
+            });
+            if (it != qrdec.end())
+            {
+                decoded += info[it - qrdec.begin()];
+            }
+            else
+            {
+                decoded = "";
+                break;
+            }
+        }
+        decoded_info[i] = decoded;
+    }
+
+    alignmentMarkers.resize(src_points.size());
+    updateQrCorners.resize(src_points.size()*4ull);
+    for (size_t i = 0ull; i < src_points.size(); i++) {
+        alignmentMarkers[i] = qrdec[i].alignment_coords;
+        for (size_t j = 0ull; j < 4ull; j++)
+            updateQrCorners[i*4ull+j] = qrdec[i].getOriginalPoints()[j] * qrdec[i].coeff_expansion;
+    }
+    if (!decoded_info.empty())
+        return true;
+    else
+        return false;
+}
+
+bool ImplContour::detectAndDecodeMulti(
+        InputArray img,
+        CV_OUT std::vector<cv::String>& decoded_info,
+        OutputArray points_,
+        OutputArrayOfArrays straight_qrcode
+    ) const
+{
+    Mat inarr;
+    if (!checkQRInputImage(img, inarr))
+    {
+        points_.release();
+        return false;
+    }
+
+    vector<Point2f> points;
+    bool ok = detectMulti(inarr, points);
+    if (!ok)
+    {
+        points_.release();
+        return false;
+    }
+    updatePointsResult(points_, points);
+    decoded_info.clear();
+    ok = decodeMulti(inarr, points, decoded_info, straight_qrcode);
+    updatePointsResult(points_, updateQrCorners);
+    return ok;
+}
+
+QRCodeDetector& QRCodeDetector::setUseAlignmentMarkers(bool useAlignmentMarkers) {
+    (std::dynamic_pointer_cast<ImplContour>)(p)->useAlignmentMarkers = useAlignmentMarkers;
+    return *this;
+}
+
+QRCodeDetectorAruco::Params::Params() {
+    minModuleSizeInPyramid = 4.f;
+    maxRotation = (float)CV_PI/12.f;
+    maxModuleSizeMismatch = 1.75f;
+    maxTimingPatternMismatch = 2.f;
+    maxPenalties = 0.4f;
+    maxColorsMismatch = 0.2f;
+    scaleTimingPatternScore = 0.9f;
+}
+
+namespace {
+
+struct FinderPatternInfo {
+    FinderPatternInfo() {}
+
+    FinderPatternInfo(const vector<Point2f>& patternPoints): points(patternPoints) {
+        float minSin = 1.f;
+        for (int i = 0; i < 4; i++) {
+            center += points[i];
+            const Point2f side = points[i]-points[(i+1) % 4];
+            const float lenSide = sqrt(normL2Sqr<float>(side));
+            minSin = min(minSin, abs(side.y) / lenSide);
+            moduleSize += lenSide;
+        }
+        moduleSize /= (4.f * 7.f); // 4 sides, 7 modules in one side
+        center /= 4.f;
+        minQrAngle = asin(minSin);
+    }
+
+    enum TypePattern {
+        CENTER,
+        RIGHT,
+        BOTTOM,
+        NONE
+    };
+
+    void setType(const TypePattern& _typePattern, const Point2f& centerQR) {
+        typePattern = _typePattern;
+        float bestLen = normL2Sqr<float>(centerQR - points[0]);
+        int id = 0;
+        for (int i = 1; i < 4; i++) {
+            float len = normL2Sqr<float>(centerQR - points[i]);
+            if (len < bestLen) {
+                bestLen = len;
+                id = i;
+            }
+        }
+        innerCornerId = id;
+    }
+
+    Point2f getDirectionTo(const TypePattern& other) const {
+        Point2f res = points[innerCornerId];
+        if (typePattern == TypePattern::CENTER) {
+            if (other == TypePattern::RIGHT) {
+                res -= points[(innerCornerId + 1) % 4];
+                res = 0.5f*(res + points[(innerCornerId + 3) % 4] - points[(innerCornerId + 2) % 4]);
+            }
+            else if (other == TypePattern::BOTTOM) {
+                res -= points[(innerCornerId + 3) % 4];
+                res = 0.5f*(res + points[(innerCornerId + 1) % 4] - points[(innerCornerId + 2) % 4]);
+            }
+        }
+        else if (typePattern == TypePattern::RIGHT && other == TypePattern::CENTER) {
+            res = res - points[(innerCornerId + 3) % 4];
+            res = 0.5f*(res + points[(innerCornerId + 1) % 4] - points[(innerCornerId + 2) % 4]);
+        }
+        else if (typePattern == TypePattern::BOTTOM && other == TypePattern::CENTER) {
+            res = res - points[(innerCornerId + 1) % 4];
+            res = 0.5f*(res + points[(innerCornerId + 3) % 4] - points[(innerCornerId + 2) % 4]);
+        }
+        return res;
+    }
+
+    bool checkTriangleAngle(const FinderPatternInfo& patternRight, const FinderPatternInfo& patternBottom, const float length2Vec) {
+        // check the triangle angle btw right & center & bootom sides of QR code
+        // the triangle angle shoud be between 30 and 150 degrees
+        // abs(pi/2 - triangle_angle) should be less 60 degrees
+        const float angle = abs((float)CV_PI/2.f - acos((center - patternRight.center).dot((center - patternBottom.center)) / length2Vec));
+
+        const float maxTriangleDeltaAngle = (float)CV_PI / 3.f;
+        if (angle > maxTriangleDeltaAngle) {
+            return false;
+        }
+        return true;
+    }
+
+    bool checkAngle(const FinderPatternInfo& other, const float maxRotation) {
+        Point2f toOther = getDirectionTo(other.typePattern);
+        Point2f toThis = other.getDirectionTo(typePattern);
+        const float cosAngle = getCosAngle(toOther, toThis);
+        if (cosAngle < 0.f && (CV_PI - acos(cosAngle)) / 2.f < maxRotation) {
+            const float angleCenter = max(acos(getCosAngle(toOther, other.center - center)), acos(getCosAngle(toThis, center - other.center)));
+            if (angleCenter < maxRotation)
+                return true;
+            }
+        return false;
+    }
+
+    static float getCosAngle(const Point2f& vec1, const Point2f& vec2) {
+        float cosAngle = vec1.dot(vec2) / (sqrt(normL2Sqr<float>(vec1)) * sqrt(normL2Sqr<float>(vec2)));
+        cosAngle = std::max(-1.f, cosAngle);
+        cosAngle = std::min(1.f, cosAngle);
+        return cosAngle;
+    }
+
+    pair<int, Point2f> getQRCorner() const {
+        if (typePattern == TypePattern::CENTER) {
+            int id = (innerCornerId + 2) % 4;
+            return std::make_pair(id, points[id]);
+        }
+        else if (typePattern != TypePattern::NONE) {
+            int id = (innerCornerId + 2) % 4;
+            return std::make_pair(id, points[id]);
+        }
+        return std::make_pair(-1, Point2f());
+    }
+
+    pair<int, Point2f> getCornerForIntersection() const {
+        if (typePattern == TypePattern::RIGHT) {
+            int id = (innerCornerId + 3) % 4;
+            return std::make_pair(id, points[id]);
+        }
+        else if (typePattern == TypePattern::BOTTOM) {
+            int id = (innerCornerId + 1) % 4;
+            return std::make_pair(id, points[id]);
+        }
+        return std::make_pair(-1, Point2f());
+    }
+
+    Point2f getTimingStart(TypePattern direction) const {
+        const float timingStartPosition = .5f;
+        const float patternLength = 7.f;
+        Point2f start = points[innerCornerId]*((patternLength - timingStartPosition)/patternLength);
+        if (typePattern == TypePattern::CENTER && direction == TypePattern::RIGHT) {
+            start += points[(innerCornerId + 3) % 4]*(timingStartPosition/patternLength);
+        }
+        else if (typePattern == TypePattern::CENTER && direction == TypePattern::BOTTOM) {
+            start += points[(innerCornerId + 1) % 4]*(timingStartPosition/patternLength);
+        }
+        else if (typePattern == TypePattern::RIGHT && direction == TypePattern::CENTER) {
+            start += points[(innerCornerId + 1) % 4]*(timingStartPosition/patternLength);
+        }
+        else if (typePattern == TypePattern::BOTTOM && direction == TypePattern::CENTER) {
+            start += points[(innerCornerId + 3) % 4]*(timingStartPosition/patternLength);
+        }
+        return start + getDirectionTo(direction)/(patternLength*2.f);
+    }
+
+    // return total white+black modules in timing pattern, total white modules, penaltyPoints
+    Point3i getTimingPatternScore(const Point2f& start, const Point2f& end, Mat &img, const float maxTimingPatternMismatch) const {
+        Rect imageRect(Point(), img.size());
+        int penaltyPoints = 0;
+        int colorCounters[2] = {0, 0};
+        if (imageRect.contains(Point(cvRound(end.x), cvRound(end.y)))) {
+            LineIterator lineIterator(start, end);
+            uint8_t prevValue = img.at<uint8_t>(lineIterator.pos());
+
+            vector<Point> vec = {lineIterator.pos()};
+
+            // the starting position in the timing pattern is the white module white module next to the finder pattern.
+            bool whiteColor = true;
+            lineIterator++;
+            colorCounters[whiteColor]++;
+
+            for(int i = 1; i < lineIterator.count; i++, ++lineIterator) {
+                const uint8_t value = img.at<uint8_t>(lineIterator.pos());
+                if (prevValue != value) {
+                    const float dist = sqrt(normL2Sqr<float>((Point2f)(vec.back()-lineIterator.pos())));
+                    // check long and short lines in timing pattern
+                    const float relativeDiff = max(moduleSize, dist)/min(moduleSize, dist);
+                    if (relativeDiff > maxTimingPatternMismatch) {
+                        if (dist < moduleSize || relativeDiff < maxTimingPatternMismatch*8.f)
+                            penaltyPoints++;
+                        else
+                            penaltyPoints += cvRound(relativeDiff);
+                    }
+                    vec.push_back(lineIterator.pos());
+                    prevValue = value;
+                    whiteColor ^= true;
+                    colorCounters[whiteColor]++;
+                }
+            }
+        }
+        return Point3i(colorCounters[0] + colorCounters[1], colorCounters[1], penaltyPoints);
+    }
+
+    FinderPatternInfo& operator*=(const float scale) {
+        moduleSize *= scale;
+        center *= scale;
+        for (auto& point: points)
+            point *= scale;
+        return *this;
+    }
+
+    float moduleSize = 0.f;
+
+    // Index of inner QR corner.
+    // The inner corner is the corner closest to the center of the QR code.
+    int innerCornerId = 0;
+
+    float minQrAngle = 0.f;
+    TypePattern typePattern = NONE;
+
+    Point2f center;
+    vector<Point2f> points;
+};
+
+struct QRCode {
+    QRCode() {}
+
+    QRCode(const FinderPatternInfo& _centerPattern, const FinderPatternInfo& _rightPattern, const FinderPatternInfo& _bottomPattern,
+           Point2f _center, float dist): centerPattern(_centerPattern), rightPattern(_rightPattern), bottomPattern(_bottomPattern),
+           center(_center), distance(dist) {
+               moduleSize = (centerPattern.moduleSize + rightPattern.moduleSize + bottomPattern.moduleSize) / 3.f;
+           }
+
+    vector<Point2f> getQRCorners() const {
+        Point2f a1 = rightPattern.getQRCorner().second;
+        Point2f a2 = rightPattern.getCornerForIntersection().second;
+
+        Point2f b1 = bottomPattern.getQRCorner().second;
+        Point2f b2 = bottomPattern.getCornerForIntersection().second;
+
+        Point2f rightBottom = intersectionLines(a1, a2, b1, b2);
+
+        return {centerPattern.getQRCorner().second, rightPattern.getQRCorner().second, rightBottom, bottomPattern.getQRCorner().second};
+    }
+
+    static QRCode checkCompatibilityPattern(const FinderPatternInfo &_pattern1, const FinderPatternInfo& _pattern2, const FinderPatternInfo& _pattern3,
+                                            Point3i& index, const QRCodeDetectorAruco::Params& qrDetectorParameters) {
+        FinderPatternInfo pattern1 = _pattern1, pattern2 = _pattern2, pattern3 = _pattern3;
+        Point2f centerQR;
+        float distance = std::numeric_limits<float>::max();
+
+        if (abs(pattern1.minQrAngle - pattern2.minQrAngle) >  qrDetectorParameters.maxRotation ||
+            abs(pattern1.minQrAngle - pattern3.minQrAngle) > qrDetectorParameters.maxRotation) // check maxRotation
+            return QRCode(pattern1, pattern2, pattern3, centerQR, distance);
+        if (max(pattern1.moduleSize, pattern2.moduleSize) / min(pattern1.moduleSize, pattern2.moduleSize) > qrDetectorParameters.maxModuleSizeMismatch ||
+            max(pattern1.moduleSize, pattern3.moduleSize) / min(pattern1.moduleSize, pattern3.moduleSize) > qrDetectorParameters.maxModuleSizeMismatch)
+            return QRCode(pattern1, pattern2, pattern3, centerQR, distance);
+        // QR code:
+        // center       right
+        //    1 ________ 2
+        //     |_|    |_|
+        //     |     /  |
+        //     |    /   |
+        //     |   /    |
+        //     |_ /     |
+        //     |_|______|
+        //    4
+        //  bottom
+
+        // sides length check
+        const float side1 = sqrt(normL2Sqr<float>(pattern1.center - pattern2.center));
+        const float side2 = sqrt(normL2Sqr<float>(pattern1.center - pattern3.center));
+        const float side3 = sqrt(normL2Sqr<float>(pattern2.center - pattern3.center));
+        std::array<float, 3> sides = {side1, side2, side3};
+        std::sort(sides.begin(), sides.end());
+        // check sides diff
+        if (sides[1] / sides[0] < qrDetectorParameters.maxModuleSizeMismatch) {
+            // find center pattern
+            if (side1 > side2 && side1 > side3) { // centerPattern is pattern3
+                std::swap(pattern3, pattern1); // now pattern1 is centerPattern
+                std::swap(index.x, index.z);
+            }
+            else if (side2 > side1 && side2 > side3) { // centerPattern is pattern2
+                std::swap(pattern2, pattern1); // now pattern1 is centerPattern
+                std::swap(index.x, index.y);
+            }
+            // now pattern1 is centerPattern
+            centerQR = (pattern2.center + pattern3.center) / 2.f;
+            pattern1.setType(FinderPatternInfo::TypePattern::CENTER, centerQR);
+            // check triangle angle
+            if (pattern1.checkTriangleAngle(pattern2, pattern3, sides[0]*sides[1]) == false)
+                return QRCode(pattern1, pattern2, pattern3, centerQR, distance);
+            // check that pattern2 is right
+            pattern2.setType(FinderPatternInfo::TypePattern::RIGHT, centerQR);
+            bool ok = pattern1.checkAngle(pattern2, qrDetectorParameters.maxRotation);
+            if (!ok) {
+                // check that pattern3 is right
+                pattern3.setType(FinderPatternInfo::TypePattern::RIGHT, centerQR);
+                ok = pattern1.checkAngle(pattern3, qrDetectorParameters.maxRotation);
+                if (ok) {
+                    std::swap(pattern3, pattern2); // now pattern2 is rightPattern
+                    std::swap(index.y, index.z);
+                }
+            }
+            if (ok) {
+                // check that pattern3 is bottom
+                pattern3.setType(FinderPatternInfo::TypePattern::BOTTOM, centerQR);
+                ok = pattern1.checkAngle(pattern3, qrDetectorParameters.maxRotation);
+                if (ok) {
+                    // intersection check
+                    Point2f c1 = intersectionLines(pattern1.getQRCorner().second, pattern1.points[pattern1.innerCornerId],
+                                                   pattern2.getQRCorner().second, pattern2.points[pattern2.innerCornerId]);
+                    Point2f c2 = intersectionLines(pattern1.getQRCorner().second, pattern1.points[pattern1.innerCornerId],
+                                                   pattern3.getQRCorner().second, pattern3.points[pattern3.innerCornerId]);
+                    const float centerDistance = sqrt(normL2Sqr<float>(c1 - c2));
+                    distance = (sides[0] + sides[1] + centerDistance)*(sides[1] / sides[0]);
+                }
+            }
+        }
+        QRCode qrcode(pattern1, pattern2, pattern3, centerQR, distance);
+        return qrcode;
+    }
+
+     int calculateScoreByTimingPattern(Mat &img, const QRCodeDetectorAruco::Params& params) {
+        const int minModulesInTimingPattern = 4;
+
+        const Point3i v1 = centerPattern.getTimingPatternScore(rightPattern.getTimingStart(FinderPatternInfo::CENTER),
+                                                                centerPattern.getTimingStart(FinderPatternInfo::RIGHT), img,
+                                                                params.maxTimingPatternMismatch);
+
+        if ((float)v1.z > params.maxPenalties*v1.x || v1.x <= minModulesInTimingPattern || abs(v1.y / (float)v1.x - 0.5f) > params.maxColorsMismatch)
+            return std::numeric_limits<int>::max();
+
+        const Point3i v2 = centerPattern.getTimingPatternScore(bottomPattern.getTimingStart(FinderPatternInfo::CENTER),
+                                                                centerPattern.getTimingStart(FinderPatternInfo::BOTTOM), img,
+                                                                params.maxTimingPatternMismatch);
+
+
+        if ((float)v2.z > params.maxPenalties*v2.x || v2.x <= minModulesInTimingPattern || abs(v2.y / (float)v2.x - 0.5f) > params.maxColorsMismatch)
+            return std::numeric_limits<int>::max();
+
+        // TODO: add v1, v2 check, add "y" checks
+        float numModules = (sqrt(normL2Sqr<float>((centerPattern.getQRCorner().second - rightPattern.getQRCorner().second)))*0.5f +
+                            sqrt(normL2Sqr<float>((centerPattern.getQRCorner().second - bottomPattern.getQRCorner().second))*0.5f)) / moduleSize;
+
+        const int sizeDelta = abs(cvRound(numModules) - (14 + v1.z < v2.z ? v1.x : v2.x));
+        const int colorDelta = abs(v1.x - v1.y - v1.y) + abs(v2.x - v2.y - v2.y);
+        const int score = v1.z + v2.z + sizeDelta + colorDelta;
+        return score;
+     }
+
+    QRCode& operator*=(const float scale) {
+        centerPattern *= scale;
+        rightPattern *= scale;
+        bottomPattern *= scale;
+        center *= scale;
+        moduleSize *= scale;
+        return *this;
+    }
+
+    FinderPatternInfo centerPattern;
+    FinderPatternInfo rightPattern;
+    FinderPatternInfo bottomPattern;
+    Point2f center;
+    float distance = std::numeric_limits<float>::max();
+    int timingPatternScore = std::numeric_limits<int>::max();
+    float moduleSize = 0.f;
+};
+
+} // namespace
+
+static
+vector<QRCode> analyzeFinderPatterns(const vector<vector<Point2f> > &corners, const Mat& img,
+                                     const QRCodeDetectorAruco::Params& qrDetectorParameters) {
+    vector<QRCode> qrCodes;
+    vector<FinderPatternInfo> patterns(corners.size());
+    if (img.empty())
+        return qrCodes;
+    float maxModuleSize = 0.f;
+    for (size_t i = 0ull; i < corners.size(); i++) {
+        FinderPatternInfo pattern = FinderPatternInfo(corners[i]);
+        patterns[i] = pattern;
+        maxModuleSize = max(maxModuleSize, pattern.moduleSize);
+    }
+    const int threshold = cvRound(qrDetectorParameters.minModuleSizeInPyramid * 12.5f) +
+                          (cvRound(qrDetectorParameters.minModuleSizeInPyramid * 12.5f) % 2 ? 0 : 1);
+    int maxLevelPyramid = 0;
+    while (maxModuleSize / 2.f > qrDetectorParameters.minModuleSizeInPyramid) {
+        maxLevelPyramid++;
+        maxModuleSize /= 2.f;
+    }
+    vector<Mat> pyramid;
+    buildPyramid(img, pyramid, maxLevelPyramid);
+    // TODO: ADAPTIVE_THRESH_GAUSSIAN_C vs ADAPTIVE_THRESH_MEAN_C
+    for (Mat& pyr: pyramid) {
+        adaptiveThreshold(pyr, pyr, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, threshold, -1);
+    }
+
+    for (size_t i = 0ull; i < patterns.size(); i++) {
+        QRCode qrCode;
+        int indexes[3] = {0};
+        for (size_t j = i + 1ull; j < patterns.size(); j++) {
+            for (size_t k = j + 1ull; k < patterns.size(); k++) {
+                Point3i index((int)i, (int)j, (int)k);
+                QRCode tmp = QRCode::checkCompatibilityPattern(patterns[i], patterns[j], patterns[k], index, qrDetectorParameters);
+                if (tmp.distance != std::numeric_limits<float>::max()) {
+                    int levelPyramid = 0;
+                    QRCode qrCopy = tmp;
+                    while (tmp.moduleSize / 2.f > qrDetectorParameters.minModuleSizeInPyramid) {
+                        tmp *= 0.5f;
+                        levelPyramid++;
+                    }
+                    qrCopy.timingPatternScore = tmp.calculateScoreByTimingPattern(pyramid[levelPyramid], qrDetectorParameters);
+                    if (qrCopy.timingPatternScore != std::numeric_limits<int>::max() &&
+                        qrCopy.timingPatternScore * qrDetectorParameters.scaleTimingPatternScore < (float)qrCode.timingPatternScore
+                        && qrCopy.distance < qrCode.distance)
+                    {
+                        qrCode = qrCopy;
+                        indexes[0] = (int)i;
+                        indexes[1] = (int)j;
+                        indexes[2] = (int)k;
+                    }
+                }
+            }
+        }
+        if (qrCode.distance != std::numeric_limits<float>::max()) {
+            qrCodes.push_back(qrCode);
+            std::swap(patterns[indexes[2]], patterns.back());
+            patterns.pop_back();
+            std::swap(patterns[indexes[1]], patterns.back());
+            patterns.pop_back();
+            std::swap(patterns[indexes[0]], patterns.back());
+            patterns.pop_back();
+            i--;
+        }
+    }
+    return qrCodes;
+}
+
+struct PimplQRAruco : public ImplContour {
+    QRCodeDetectorAruco::Params qrParams;
+    aruco::ArucoDetector arucoDetector;
+
+    PimplQRAruco() {
+        Mat bits = Mat::ones(Size(5, 5), CV_8UC1);
+        Mat(bits, Rect(1, 1, 3, 3)).setTo(Scalar(0));
+        Mat byteList = aruco::Dictionary::getByteListFromBits(bits);
+        aruco::Dictionary dictionary = aruco::Dictionary(byteList, 5, 4);
+        aruco::DetectorParameters arucoParams;
+        arucoParams.minMarkerPerimeterRate = 0.02;
+        arucoDetector = aruco::ArucoDetector(dictionary, arucoParams);
+    }
+
+    bool detectMulti(InputArray in, OutputArray points) const override {
+        Mat gray;
+        if (!checkQRInputImage(in, gray)) {
+            points.release();
+            return false;
+        }
+        vector<Point2f> result;
+        vector<vector<Point2f> > corners;
+        vector<int> ids;
+        arucoDetector.detectMarkers(gray, corners, ids);
+        if (corners.size() >= 3ull) {
+            vector<QRCode> qrCodes = analyzeFinderPatterns(corners, gray.clone(), qrParams);
+            if (qrCodes.size() == 0ull)
+                return false;
+            for (auto& qr : qrCodes) {
+                for (Point2f& corner : qr.getQRCorners()) {
+                    result.push_back(corner);
+                }
+            }
+        }
+        if (result.size() >= 4) {
+            updatePointsResult(points, result);
+            return true;
+        }
+        return false;
+    }
+
+    bool detect(InputArray img, OutputArray points) const override {
+        vector<Point2f> corners, result;
+        bool flag = detectMulti(img, corners);
+        CV_Assert((int)corners.size() % 4 == 0);
+
+        Point2f imageCenter(((float)img.cols())/2.f, ((float)img.rows())/2.f);
+        size_t minQrId = 0ull;
+        float minDist = std::numeric_limits<float>::max();
+        for (size_t i = 0ull; i < corners.size(); i += 4ull) {
+            Point2f qrCenter((corners[i] + corners[i+1ull] + corners[i+2ull] + corners[i+3ull]) / 4.f);
+            float dist = sqrt(normL2Sqr<float>(qrCenter - imageCenter));
+            if (dist < minDist) {
+                minQrId = i;
+                minDist = dist;
+            }
+        }
+        if (flag) {
+            result = {corners[minQrId], corners[minQrId+1ull], corners[minQrId+2ull], corners[minQrId+3ull]};
+            updatePointsResult(points, result);
+        }
+        return flag;
+    }
+};
+
+QRCodeDetectorAruco::QRCodeDetectorAruco() {
+    p = makePtr<PimplQRAruco>();
+}
+
+QRCodeDetectorAruco::QRCodeDetectorAruco(const QRCodeDetectorAruco::Params& params) {
+    p = makePtr<PimplQRAruco>();
+    std::dynamic_pointer_cast<PimplQRAruco>(p)->qrParams = params;
+}
+
+const QRCodeDetectorAruco::Params& QRCodeDetectorAruco::getDetectorParameters() const {
+    return std::dynamic_pointer_cast<PimplQRAruco>(p)->qrParams;
+}
+
+QRCodeDetectorAruco& QRCodeDetectorAruco::setDetectorParameters(const QRCodeDetectorAruco::Params& params) {
+    std::dynamic_pointer_cast<PimplQRAruco>(p)->qrParams = params;
+    return *this;
+}
+
+const aruco::DetectorParameters& QRCodeDetectorAruco::getArucoParameters() const {
+    return std::dynamic_pointer_cast<PimplQRAruco>(p)->arucoDetector.getDetectorParameters();
+}
+
+void QRCodeDetectorAruco::setArucoParameters(const aruco::DetectorParameters& params) {
+    std::dynamic_pointer_cast<PimplQRAruco>(p)->arucoDetector.setDetectorParameters(params);
+}
+
+}  // namespace
diff --git a/upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp b/upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp
new file mode 100644
index 0000000..a58eb08
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/qrcode_encoder.cpp
@@ -0,0 +1,1849 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Intel Corporation, all rights reserved.
+
+#include "precomp.hpp"
+#include "qrcode_encoder_table.inl.hpp"
+#include "graphical_code_detector_impl.hpp"
+
+namespace cv
+{
+using std::vector;
+
+const int MAX_PAYLOAD_LEN = 8896;
+const int MAX_FORMAT_LENGTH = 15;
+const int MAX_VERSION_LENGTH = 18;
+const int MODE_BITS_NUM = 4;
+const uint8_t INVALID_REGION_VALUE = 110;
+
+static void decToBin(const int dec_number, const int total_bits, std::vector<uint8_t> &bin_number);
+static uint8_t gfPow(uint8_t x, int power);
+static uint8_t gfMul(const uint8_t x, const uint8_t y);
+static uint8_t gfDiv(const uint8_t x, const uint8_t y);
+static void gfPolyMul(const vector<uint8_t> &p, const vector<uint8_t> &q, vector<uint8_t> &product);
+static void gfPolyDiv(const vector<uint8_t> &dividend, const vector<uint8_t> &divisor, const int ecc_num, vector<uint8_t> &quotient);
+static void polyGenerator(const int n, vector<uint8_t> &result);
+static int getBits(const int bits, const vector<uint8_t> &payload, int &pay_index);
+
+static void decToBin(const int dec_number, const int total_bits, std::vector<uint8_t> &bin_number)
+{
+    for (int i = 0; i < total_bits; i++)
+    {
+        bin_number[total_bits - i - 1] = (dec_number >> i) % 2;
+    }
+}
+
+static void writeDecNumber(const int dec_number, const int total_bits, vector<uint8_t> &output_bits)
+{
+    std::vector<uint8_t> bin_number(total_bits);
+    decToBin(dec_number, total_bits, bin_number);
+    output_bits.insert(output_bits.end(), bin_number.begin(), bin_number.end());
+}
+
+static uint8_t gfPow(uint8_t x, int power)
+{
+    return gf_exp[(gf_log[x] * power) % 255];
+}
+
+static uint8_t gfMul(const uint8_t x, const uint8_t y)
+{
+    if (x == 0 || y == 0)
+        return 0;
+    return gf_exp[(gf_log[x] + gf_log[y]) % 255];
+}
+
+static uint8_t gfDiv(const uint8_t x, const uint8_t y)
+{
+    if (x == 0 || y == 0)
+        return 0;
+    return gf_exp[(gf_log[x] + 255 - gf_log[y]) % 255];
+}
+
+static void gfPolyMul(const vector<uint8_t> &p, const vector<uint8_t> &q, vector<uint8_t> &product)
+{
+    int len_p = (int)p.size();
+    int len_q = (int)q.size();
+    vector<uint8_t> temp_result(len_p + len_q - 1, 0);
+
+    for (int j = 0; j < len_q; j++)
+    {
+        uint8_t q_val = q[j];
+        if (!q_val)
+            continue;
+        for (int i = 0; i < len_p; i++)
+        {
+            uint8_t p_val = p[i];
+            if (!p_val)
+                continue;
+            temp_result[i + j] ^= gfMul(p_val, q_val);
+        }
+    }
+    product = temp_result;
+}
+
+static void gfPolyDiv(const vector<uint8_t> &dividend, const vector<uint8_t> &divisor, const int bits_needed, vector<uint8_t> &quotient)
+{
+    int dividend_len = (int)dividend.size() - 1;
+    int divisor_len = (int)divisor.size() - 1;
+    vector<uint8_t> temp = dividend;
+
+    int times = dividend_len - divisor_len + 1;
+    for (int i = 0; i < times; i++)
+    {
+        uint8_t dividend_val = temp[dividend_len - i];
+        if(dividend_val != 0)
+        {
+            for (int j = 0; j < divisor_len + 1; j++)
+            {
+                uint8_t divisor_val = divisor[divisor_len - j];
+                if (divisor_val != 0)
+                {
+                    temp[dividend_len - i - j] ^= gfMul(divisor_val, dividend_val);
+                }
+            }
+        }
+    }
+    quotient = vector<uint8_t>(temp.begin(), temp.begin() + bits_needed);
+}
+
+static void polyGenerator(const int n, vector<uint8_t> &result)
+{
+    vector<uint8_t> temp(2, 1);
+    result = vector<uint8_t>(1, 1);
+    for (int i = 1; i <= n; i++)
+    {
+        temp[0] = gfPow(2, i - 1);
+        gfPolyMul(result, temp, result);
+    }
+}
+
+static int getBits(const int bits, const vector<uint8_t> &payload, int &pay_index)
+{
+    int result = 0;
+    for (int i = 0; i < bits; i++)
+    {
+        result = result << 1;
+        result += payload[pay_index++];
+    }
+    return result;
+}
+
+static int mapSymbol(char c)
+{
+    if (c >= '0' && c <= '9')
+        return (int)(c - '0');
+    if (c >= 'A' && c <= 'Z')
+        return (int)(c - 'A') + 10;
+    switch (c)
+    {
+        case ' ': return 36 + 0;
+        case '$': return 36 + 1;
+        case '%': return 36 + 2;
+        case '*': return 36 + 3;
+        case '+': return 36 + 4;
+        case '-': return 36 + 5;
+        case '.': return 36 + 6;
+        case '/': return 36 + 7;
+        case ':': return 36 + 8;
+    }
+    return -1;
+}
+
+static void maskData(const Mat& original, const int mask_type_num, Mat &masked);
+
+QRCodeEncoder::QRCodeEncoder()
+{
+    // nothing
+}
+
+QRCodeEncoder::~QRCodeEncoder()
+{
+    // nothing
+}
+
+QRCodeEncoder::Params::Params()
+{
+    version = 0;
+    correction_level = CORRECT_LEVEL_L;
+    mode = MODE_AUTO;
+    structure_number = 1;
+}
+
+class QRCodeEncoderImpl : public QRCodeEncoder
+{
+public:
+    QRCodeEncoderImpl(const QRCodeEncoder::Params& parameters) : params(parameters)
+    {
+        version_level = parameters.version;
+        ecc_level = parameters.correction_level;
+        mode_type = parameters.mode;
+        struct_num = parameters.structure_number;
+        version_size = 21;
+        mask_type = 0;
+        parity = 0;
+        sequence_num = 0;
+        total_num = 0;
+    }
+
+    void encode(const String& encoded_info, OutputArray qrcode) CV_OVERRIDE;
+    void encodeStructuredAppend(const String& input, OutputArrayOfArrays output) CV_OVERRIDE;
+    QRCodeEncoder::Params params;
+protected:
+    int version_level;
+    CorrectionLevel ecc_level;
+    EncodeMode mode_type;
+    int struct_num;
+    int version_size;
+    int mask_type;
+    vector<uint8_t> format;
+    vector<uint8_t> version_reserved;
+    vector<uint8_t>	payload;
+    vector<uint8_t>	rearranged_data;
+    Mat original;
+    Mat masked_data;
+    uint8_t parity;
+    uint8_t sequence_num;
+    uint8_t total_num;
+    vector<Mat> final_qrcodes;
+
+    const VersionInfo* version_info;
+    const BlockParams* cur_ecc_params;
+
+    bool isNumeric(const std::string& input) const;
+    bool isAlphaNumeric(const std::string& input) const;
+    EncodeMode autoEncodeMode(const std::string &input) const ;
+    bool encodeByte(const std::string& input, vector<uint8_t> &output);
+    bool encodeAlpha(const std::string& input, vector<uint8_t> &output);
+    bool encodeNumeric(const std::string& input, vector<uint8_t> &output);
+    bool encodeECI(const std::string& input, vector<uint8_t> &output);
+    bool encodeKanji(const std::string& input, vector<uint8_t> &output);
+    bool encodeAuto(const std::string& input, vector<uint8_t> &output, EncodeMode *mode = nullptr);
+    bool encodeStructure(const std::string& input, vector<uint8_t> &output);
+    int eccLevelToCode(CorrectionLevel level);
+    void padBitStream();
+    bool stringToBits(const std::string& input_info);
+    void eccGenerate(vector<vector<uint8_t> > &data_blocks, vector<vector<uint8_t> > &ecc_blocks);
+    void rearrangeBlocks(const vector<vector<uint8_t> > &data_blocks, const vector<vector<uint8_t> > &ecc_blocks);
+    void writeReservedArea();
+    bool writeBit(int x, int y, bool value);
+    void writeData();
+    void structureFinalMessage();
+    void formatGenerate(const int mask_type_num, vector<uint8_t> &format_array);
+    void versionInfoGenerate(const int version_level_num, vector<uint8_t> &version_array);
+    void fillReserved(const vector<uint8_t> &format_array, Mat &masked);
+    void findAutoMaskType();
+    bool estimateVersion(const int input_length, EncodeMode mode, vector<int> &possible_version);
+    int versionAuto(const std::string &input_str);
+    int findVersionCapacity(const int input_length, const int ecc, const std::vector<int>& possible_versions);
+    void generatingProcess(const std::string& input, Mat &qrcode);
+    void generateQR(const std::string& input);
+};
+
+int QRCodeEncoderImpl::eccLevelToCode(CorrectionLevel level)
+{
+    switch (level)
+    {
+        case CORRECT_LEVEL_L:
+            return 0b01;
+        case CORRECT_LEVEL_M:
+            return 0b00;
+        case CORRECT_LEVEL_Q:
+            return 0b11;
+        case CORRECT_LEVEL_H:
+            return 0b10;
+    }
+    CV_Error( Error::StsBadArg,
+        "Error correction level is incorrect. Available levels are"
+        "CORRECT_LEVEL_L, CORRECT_LEVEL_M, CORRECT_LEVEL_Q, CORRECT_LEVEL_H." );
+}
+
+int QRCodeEncoderImpl::findVersionCapacity(const int input_length, const int ecc, const std::vector<int>& possible_versions)
+{
+    int data_codewords, version_index = -1;
+    const int byte_len = 8;
+    version_index = -1;
+
+    for (int i : possible_versions)
+    {
+        auto& tmp_ecc_params = version_info_database[i].ecc[ecc];
+        data_codewords = tmp_ecc_params.data_codewords_in_G1 * tmp_ecc_params.num_blocks_in_G1 +
+                         tmp_ecc_params.data_codewords_in_G2 * tmp_ecc_params.num_blocks_in_G2;
+
+        if (data_codewords * byte_len >= input_length)
+        {
+            version_index = i;
+            break;
+        }
+    }
+    return version_index;
+}
+
+static inline int getCapacity(int version, QRCodeEncoder::CorrectionLevel ecc_level, QRCodeEncoder::EncodeMode mode) {
+    const int* capacity = version_capacity_database[version].ec_level[ecc_level].encoding_modes;
+    switch (mode) {
+        case QRCodeEncoder::EncodeMode::MODE_NUMERIC:
+            return capacity[0];
+        case QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC:
+            return capacity[1];
+        case QRCodeEncoder::EncodeMode::MODE_BYTE:
+            return capacity[2];
+        case QRCodeEncoder::EncodeMode::MODE_KANJI:
+            return capacity[3];
+        default:
+            CV_Error(Error::StsNotImplemented, format("Unexpected mode %d", mode));
+    }
+}
+
+bool QRCodeEncoderImpl::estimateVersion(const int input_length, EncodeMode mode, vector<int>& possible_version)
+{
+    possible_version.clear();
+
+    CV_Assert(mode != EncodeMode::MODE_AUTO);
+
+    if (input_length > getCapacity(MAX_VERSION, ecc_level, mode))
+    {
+        return false;
+    }
+
+    int version = MAX_VERSION;
+
+    for (; version > 0; --version)
+    {
+        if (input_length > getCapacity(version, ecc_level, mode)) {
+            break;
+        }
+    }
+
+    if (version < MAX_VERSION)
+    {
+        version += 1;
+    }
+
+    possible_version.push_back(version);
+
+    if (version < MAX_VERSION)
+    {
+        possible_version.push_back(version + 1);
+    }
+
+    return true;
+}
+
+int QRCodeEncoderImpl::versionAuto(const std::string& input_str)
+{
+    vector<uint8_t> payload_tmp;
+    EncodeMode mode;
+    encodeAuto(input_str, payload_tmp, &mode);
+
+    vector<int> possible_version;
+    if (!estimateVersion((int)input_str.length(), mode, possible_version)) {
+        return -1;
+    }
+
+    int nbits = static_cast<int>(payload_tmp.size());
+
+    // Extra info for structure's position, total and parity + mode of final message
+    if (mode_type == MODE_STRUCTURED_APPEND)
+        nbits += 4 + 4 + 8 + 4;
+
+    const auto tmp_version = findVersionCapacity(nbits, ecc_level, possible_version);
+
+    return tmp_version;
+}
+
+void QRCodeEncoderImpl::generateQR(const std::string &input)
+{
+    if (struct_num > 1)
+    {
+        for (size_t i = 0; i < input.length(); i++)
+        {
+            parity ^= input[i];
+        }
+        if (struct_num > 16)
+        {
+            struct_num = 16;
+        }
+        total_num = (uint8_t) struct_num - 1;
+    }
+
+    auto string_itr = input.begin();
+    for (int i = struct_num; i > 0; --i)
+    {
+        sequence_num = (uint8_t) (struct_num - i);
+        size_t segment_begin = string_itr - input.begin();
+        size_t segment_end = (input.end() - string_itr) / i;
+
+        std::string input_info = input.substr(segment_begin, segment_end);
+        string_itr += segment_end;
+
+        int detected_version = versionAuto(input_info);
+        int tmp_version_level = version_level;
+        if (detected_version == -1)
+            CV_Error(Error::StsBadArg, "The given input exceeds the maximum capacity of a QR code with the selected encoding mode and error correction level " );
+        else if (tmp_version_level == 0)
+            tmp_version_level = detected_version;
+        else if (tmp_version_level < detected_version)
+            CV_Error(Error::StsBadArg, "The given version is not suitable for the given input string length ");
+
+        payload.clear();
+        payload.reserve(MAX_PAYLOAD_LEN);
+        format = vector<uint8_t> (15, 255);
+        version_reserved = vector<uint8_t> (18, 255);
+        version_size = (21 + (tmp_version_level - 1) * 4);
+        version_info = &version_info_database[tmp_version_level];
+        cur_ecc_params = &version_info->ecc[ecc_level];
+        original = Mat(Size(version_size, version_size), CV_8UC1, Scalar(255));
+        masked_data = original.clone();
+        Mat qrcode = masked_data.clone();
+        std::swap(version_level, tmp_version_level);
+        generatingProcess(input_info, qrcode);
+        std::swap(version_level, tmp_version_level);
+        final_qrcodes.push_back(qrcode);
+    }
+}
+
+void QRCodeEncoderImpl::formatGenerate(const int mask_type_num, vector<uint8_t> &format_array)
+{
+    int idx = (eccLevelToCode(ecc_level) << 3) | mask_type_num;
+    format_array.resize(MAX_FORMAT_LENGTH);
+    for (int i = 0; i < MAX_FORMAT_LENGTH; ++i) {
+        format_array[i] = (formatInfoLUT[idx] >> i) & 1;
+    }
+}
+
+void QRCodeEncoderImpl::versionInfoGenerate(const int version_level_num, vector<uint8_t> &version_array)
+{
+    const int version_bits_num = 6;
+    std::vector<uint8_t> version_bits(version_bits_num);
+    decToBin(version_level_num, version_bits_num, version_bits);
+
+    std::reverse(version_bits.begin(), version_bits.end());
+    vector<uint8_t> shift(12, 0);
+    vector<uint8_t> polynomial;
+    hconcat(shift, version_bits, polynomial);
+
+    const int generator_len = 13;
+    const uint8_t generator_arr[generator_len] = {1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1};
+    std::vector<uint8_t> format_mask (generator_arr, generator_arr + sizeof(generator_arr) / sizeof(generator_arr[0]));
+
+    vector<uint8_t> ecc_code;
+    gfPolyDiv(polynomial, format_mask, 12, ecc_code);
+    hconcat(ecc_code, version_bits, version_array);
+}
+
+bool QRCodeEncoderImpl::encodeAlpha(const std::string& input, vector<uint8_t>& output)
+{
+    writeDecNumber(MODE_ALPHANUMERIC, MODE_BITS_NUM, output);
+
+    int length_bits_num = 13;
+    if (version_level < 10)
+        length_bits_num = 9;
+    else if (version_level < 27)
+        length_bits_num = 11;
+
+    int str_len = int(input.length());
+    writeDecNumber(str_len, length_bits_num, output);
+
+    const int alpha_symbol_bits = 11;
+    const int residual_bits = 6;
+    for (int i = 0; i < str_len - 1; i += 2)
+    {
+        int index_1 = mapSymbol(input[i]);
+        int index_2 = mapSymbol(input[i + 1]);
+
+        if(index_1 == -1 || (index_2 == -1 && i + 1 < str_len))
+            return false;
+        int alpha = index_1 * 45 + index_2;
+
+        writeDecNumber(alpha, alpha_symbol_bits, output);
+    }
+    if (str_len % 2 != 0)
+    {
+        int index_residual_elem = mapSymbol(*input.rbegin());
+        if(index_residual_elem == -1)
+            return false;
+
+        writeDecNumber(index_residual_elem, residual_bits, output);
+    }
+    return true;
+}
+
+bool QRCodeEncoderImpl::encodeByte(const std::string& input, vector<uint8_t>& output)
+{
+    writeDecNumber(MODE_BYTE, MODE_BITS_NUM, output);
+
+    int length_bits_num = 8;
+    if (version_level > 9)
+        length_bits_num = 16;
+
+    int str_len = int(input.length());
+    writeDecNumber(str_len, length_bits_num, output);
+
+    const int byte_symbol_bits = 8;
+    for (int i = 0; i < str_len; i++)
+    {
+        writeDecNumber(uint8_t(input[i]), byte_symbol_bits, output);
+    }
+    return true;
+}
+
+bool QRCodeEncoderImpl::encodeNumeric(const std::string& input,vector<uint8_t>& output)
+{
+    writeDecNumber(MODE_NUMERIC, MODE_BITS_NUM, output);
+
+    int length_bits_num = 10;
+    if (version_level >= 27)
+        length_bits_num = 14;
+    else if (version_level >= 10)
+        length_bits_num = 12;
+
+    int str_len = int(input.length());
+    writeDecNumber(str_len, length_bits_num, output);
+
+    int count = 0;
+    const int num_symbol_bits = 10;
+    const int residual_bits[2] = {7, 4};
+    while (count + 3 <= str_len)
+    {
+        if (input[count] > '9' || input[count] < '0' ||
+            input[count + 1] > '9' || input[count + 1] < '0' ||
+            input[count + 2] > '9' || input[count + 2] < '0')
+            return false;
+        int num = 100 * (int)(input[count] - '0') +
+                  10 * (int)(input[count + 1] - '0') +
+                  (int)(input[count + 2] - '0');
+
+        writeDecNumber(num, num_symbol_bits, output);
+        count += 3;
+    }
+    if (count + 2 == str_len)
+    {
+        if (input[count] > '9' || input[count] < '0'||
+            input[count + 1] >'9'|| input[count + 1] < '0')
+            return false;
+        int num = 10 * (int)(input[count] - '0') +
+                  (int)(input[count + 1] - '0');
+
+        writeDecNumber(num, residual_bits[0], output);
+    }
+    else if (count + 1 == str_len)
+    {
+        if (input[count] > '9' || input[count] < '0')
+            return false;
+        int num = (int)(input[count] - '0');
+
+        writeDecNumber(num, residual_bits[1], output);
+    }
+    return true;
+}
+
+bool QRCodeEncoderImpl::encodeECI(const std::string& input, vector<uint8_t>& output)
+{
+    writeDecNumber(MODE_ECI, MODE_BITS_NUM, output);
+    const uint32_t assign_value_range[3] = {127, 16383, 999999};
+
+    // by adding other ECI modes `eci_assignment_number` can be moved to algorithm parameters
+    uint32_t eci_assignment_number = ECI_UTF8; // utf-8
+
+    int codewords = 1;
+    if(eci_assignment_number > assign_value_range[2])
+        return false;
+    if (eci_assignment_number > assign_value_range[1])
+        codewords = 3;
+    else if (eci_assignment_number > assign_value_range[0])
+        codewords = 2;
+
+    const int bits = 8;
+    switch (codewords)
+    {
+        case 1:
+            writeDecNumber(0, codewords, output);
+            writeDecNumber(eci_assignment_number, codewords * bits - 1, output);
+            break;
+        case 2:
+            writeDecNumber(2, codewords, output);
+            writeDecNumber(eci_assignment_number, codewords * bits - 2, output);
+            break;
+        case 3:
+            writeDecNumber(6, codewords, output);
+            writeDecNumber(eci_assignment_number, codewords * bits - 3, output);
+            break;
+    }
+
+    encodeByte(input, output);
+    return true;
+}
+
+bool QRCodeEncoderImpl::encodeKanji(const std::string& input, vector<uint8_t>& output)
+{
+    writeDecNumber(MODE_KANJI, MODE_BITS_NUM, output);
+
+    int length_bits_num = 8;
+    if (version_level >= 10)
+        length_bits_num = 10;
+    else if (version_level >= 27)
+        length_bits_num = 12;
+
+    int str_len = int(input.length()) / 2;
+    writeDecNumber(str_len, length_bits_num, output);
+
+    const int kanji_symbol_bits = 13;
+    int i = 0;
+    while(i < str_len * 2)
+    {
+        uint16_t high_byte = (uint16_t)(input[i] & 0xff);
+        uint16_t low_byte = (uint16_t)(input[i+1] & 0xff);
+        uint16_t per_char = (high_byte << 8) + (low_byte);
+
+        if(0x8140 <= per_char && per_char <= 0x9FFC)
+        {
+            per_char -= 0x8140;
+        }
+        else if(0xE040 <= per_char && per_char <= 0xEBBF)
+        {
+            per_char -= 0xC140;
+        }
+        uint16_t new_high = per_char >> 8;
+        uint16_t result = new_high * 0xC0;
+        result += (per_char & 0xFF);
+
+        writeDecNumber(result, kanji_symbol_bits, output);
+        i += 2;
+    }
+    return true;
+}
+
+bool QRCodeEncoderImpl::encodeStructure(const std::string& input, vector<uint8_t>& output)
+{
+    const int num_field = 4;
+    const int checksum_field = 8;
+    writeDecNumber(MODE_STRUCTURED_APPEND, MODE_BITS_NUM, output);
+    writeDecNumber(sequence_num, num_field, output);
+    writeDecNumber(total_num, num_field, output);
+    writeDecNumber(parity, checksum_field, output);
+
+    return encodeAuto(input, output);
+}
+
+bool QRCodeEncoderImpl::isNumeric(const std::string& input) const
+{
+    for (size_t i = 0; i < input.length(); i++)
+    {
+        if (input[i] < '0' || input[i] > '9')
+            return false;
+    }
+    return true;
+}
+
+bool QRCodeEncoderImpl::isAlphaNumeric(const std::string& input) const
+{
+    for (size_t i = 0; i < input.length(); i++)
+    {
+        if (mapSymbol(input[i]) == -1)
+            return false;
+    }
+    return true;
+}
+
+QRCodeEncoder::EncodeMode QRCodeEncoderImpl::autoEncodeMode(const std::string &input) const
+{
+    if (isNumeric(input))
+    {
+        return EncodeMode::MODE_NUMERIC;
+    }
+
+    if (isAlphaNumeric(input))
+    {
+        return EncodeMode::MODE_ALPHANUMERIC;
+    }
+
+    return EncodeMode::MODE_BYTE;
+}
+
+bool QRCodeEncoderImpl::encodeAuto(const std::string& input, vector<uint8_t>& output, EncodeMode *mode)
+{
+    const auto selected_mode = autoEncodeMode(input);
+
+    CV_Assert(selected_mode != EncodeMode::MODE_AUTO);
+
+    switch (selected_mode)
+    {
+        case EncodeMode::MODE_NUMERIC:
+            encodeNumeric(input, output);
+            break;
+        case EncodeMode::MODE_ALPHANUMERIC:
+            encodeAlpha(input, output);
+            break;
+        case EncodeMode::MODE_STRUCTURED_APPEND:
+            encodeByte(input, output);
+            break;
+        case EncodeMode::MODE_BYTE:
+            encodeByte(input, output);
+            break;
+        case EncodeMode::MODE_KANJI:
+            encodeKanji(input, output);
+            break;
+        case EncodeMode::MODE_ECI:
+            encodeECI(input, output);
+            break;
+        default:
+            break;
+    }
+
+    if (mode != nullptr)
+    {
+        *mode = selected_mode;
+    }
+
+    return true;
+}
+
+void QRCodeEncoderImpl::padBitStream()
+{
+    int total_data = version_info->total_codewords -
+                     cur_ecc_params->ecc_codewords * (cur_ecc_params->num_blocks_in_G1 + cur_ecc_params->num_blocks_in_G2);
+    const int bits = 8;
+    total_data *= bits;
+    int pad_num = total_data - (int)payload.size();
+
+    if (pad_num <= 0)
+        return;
+    else if (pad_num <= 4)
+    {
+        int payload_size = (int)payload.size();
+        payload.insert(payload.end(), payload_size, 0);
+    }
+    else
+    {
+        payload.insert(payload.end(), 4, 0);
+
+        int i = payload.size() % bits;
+
+        if (i != 0)
+        {
+            payload.insert(payload.end(), bits - i, 0);
+        }
+        pad_num = total_data - (int)payload.size();
+
+        if (pad_num > 0)
+        {
+            const int pad_patterns[2] = {236, 17};
+            int num = pad_num / bits;
+            const int pattern_size = 8;
+            for (int j = 0; j < num; j++)
+            {
+                writeDecNumber(pad_patterns[j % 2], pattern_size, payload);
+            }
+        }
+    }
+}
+
+bool QRCodeEncoderImpl::stringToBits(const std::string& input_info)
+{
+    switch (mode_type)
+    {
+        case MODE_NUMERIC:
+            return encodeNumeric(input_info, payload);
+        case MODE_ALPHANUMERIC:
+            return encodeAlpha(input_info, payload);
+        case MODE_STRUCTURED_APPEND:
+            return encodeStructure(input_info, payload);
+        case MODE_BYTE:
+            return encodeByte(input_info, payload);
+        case MODE_ECI:
+            return encodeECI(input_info, payload);
+        case MODE_KANJI:
+            return encodeKanji(input_info, payload);
+        default:
+            return encodeAuto(input_info, payload);
+    }
+}
+
+void QRCodeEncoderImpl::eccGenerate(vector<vector<uint8_t> > &data_blocks, vector<vector<uint8_t> > &ecc_blocks)
+{
+    const int ec_codewords = cur_ecc_params->ecc_codewords;
+    int pay_index = 0;
+    vector<uint8_t> g_x;
+    polyGenerator(ec_codewords, g_x);
+    int blocks = cur_ecc_params->num_blocks_in_G2 + cur_ecc_params->num_blocks_in_G1;
+    for (int i = 0; i < blocks; i++)
+    {
+        int block_len = 0;
+
+        if (i < cur_ecc_params->num_blocks_in_G1)
+        {
+            block_len = cur_ecc_params->data_codewords_in_G1;
+        }
+        else
+        {
+            block_len = cur_ecc_params->data_codewords_in_G2;
+        }
+        vector<uint8_t> block_i (block_len, 0);
+
+        for (int j = 0; j < block_len; j++)
+        {
+            block_i[block_len - 1 - j] = (uchar)getBits(8, payload, pay_index);
+        }
+        vector<uint8_t> dividend;
+        vector<uint8_t> shift (ec_codewords, 0);
+        hconcat(shift, block_i, dividend);
+        vector<uint8_t> ecc_i;
+        gfPolyDiv(dividend, g_x, ec_codewords, ecc_i);
+        data_blocks.push_back(block_i);
+        ecc_blocks.push_back(ecc_i);
+    }
+}
+
+void QRCodeEncoderImpl::rearrangeBlocks(const vector<vector<uint8_t> > &data_blocks, const vector<vector<uint8_t> > &ecc_blocks)
+{
+    rearranged_data.clear();
+    int blocks = cur_ecc_params->num_blocks_in_G2 + cur_ecc_params->num_blocks_in_G1;
+    int col_border = max(cur_ecc_params->data_codewords_in_G2, cur_ecc_params->data_codewords_in_G1);
+    int total_codeword_num = version_info->total_codewords;
+    int is_not_equal = cur_ecc_params->data_codewords_in_G2 - cur_ecc_params->data_codewords_in_G1;
+    int add_steps = cur_ecc_params->data_codewords_in_G2 > cur_ecc_params->data_codewords_in_G1 ?
+                   (cur_ecc_params->data_codewords_in_G2 - cur_ecc_params->data_codewords_in_G1) * cur_ecc_params->num_blocks_in_G1 : 0;
+    rearranged_data.reserve(total_codeword_num + add_steps);
+    for (int i = 0; i < total_codeword_num + add_steps; i++)
+    {
+        int cur_col = i / blocks;
+        int cur_row = i % blocks;
+        int data_col = (int)data_blocks[cur_row].size() - 1;
+        int ecc_col = (int)ecc_blocks[cur_row].size() - 1;
+        uint8_t tmp = 0;
+
+        if (cur_col < col_border)
+        {
+            if (is_not_equal && cur_col == cur_ecc_params->data_codewords_in_G2 - 1 && cur_row < cur_ecc_params->num_blocks_in_G1)
+            {
+                continue;
+            }
+            else
+            {
+                tmp = data_blocks[cur_row][data_col - cur_col];
+            }
+        }
+        else
+        {
+            int index = ecc_col - (cur_col - col_border);
+            tmp = ecc_blocks[cur_row][index];
+        }
+        rearranged_data.push_back(tmp);
+    }
+}
+
+void QRCodeEncoderImpl::findAutoMaskType()
+{
+    int best_index = 0;
+    int lowest_penalty = INT_MAX;
+    int penalty_two_value = 3, penalty_three_value = 40;
+    for (int cur_type = 0; cur_type < 8; cur_type++)
+    {
+        Mat test_result = masked_data.clone();
+        vector<uint8_t> test_format = format;
+        maskData(original, cur_type, test_result);
+        formatGenerate(cur_type, test_format);
+        fillReserved(test_format, test_result);
+        int continued_num = 0;
+        int penalty_one = 0, penalty_two = 0, penalty_three = 0, penalty_four = 0, penalty_total = 0;
+        int current_color = -1;
+
+        for (int direction = 0; direction < 2; direction++)
+        {
+            if (direction != 0)
+            {
+                test_result = test_result.t();
+            }
+            for (int i = 0; i < version_size; i++)
+            {
+                int per_row = 0;
+                for (int j = 0; j < version_size; j++)
+                {
+                    if (j == 0)
+                    {
+                        current_color = test_result.at<uint8_t>(i, j);
+                        continued_num = 1;
+                        continue;
+                    }
+                    if (current_color == test_result.at<uint8_t>(i, j))
+                    {
+                        continued_num += 1;
+                    }
+                    if (current_color != test_result.at<uint8_t>(i, j) || j + 1 == version_size)
+                    {
+                        current_color = test_result.at<uint8_t>(i, j);
+                        if (continued_num >= 5)
+                        {
+                            per_row += 3 + continued_num - 5;
+                        }
+                        continued_num = 1;
+                    }
+                }
+                penalty_one += per_row;
+            }
+        }
+        for (int i = 0; i < version_size - 1; i++)
+        {
+            for (int j = 0; j < version_size - 1; j++)
+            {
+                uint8_t color = test_result.at<uint8_t>(i, j);
+                if (color == test_result.at<uint8_t>(i, j + 1) &&
+                    color == test_result.at<uint8_t>(i + 1, j + 1) &&
+                    color == test_result.at<uint8_t>(i + 1, j))
+                {
+                    penalty_two += penalty_two_value;
+                }
+            }
+        }
+        Mat penalty_pattern[2];
+        penalty_pattern[0] = (Mat_<uint8_t >(1, 11) << 255, 255, 255, 255, 0, 255, 0, 0, 0, 255, 0);
+        penalty_pattern[1] = (Mat_<uint8_t >(1, 11) << 0, 255, 0, 0, 0, 255, 0, 255, 255, 255, 255);
+        for (int direction = 0; direction < 2; direction++)
+        {
+            if (direction != 0)
+            {
+                test_result = test_result.t();
+            }
+            for (int i = 0; i < version_size; i++)
+            {
+                int per_row = 0;
+                for (int j = 0; j < version_size - 10; j++)
+                {
+                    Mat cur_test = test_result(Range(i, i + 1), Range(j, j + 11));
+                    for (int pattern_index = 0; pattern_index < 2; pattern_index++)
+                    {
+                        Mat diff = (penalty_pattern[pattern_index] != cur_test);
+                        bool equal = (countNonZero(diff) == 0);
+                        if (equal)
+                        {
+                            per_row += penalty_three_value;
+                        }
+                    }
+                }
+                penalty_three += per_row;
+            }
+        }
+        int dark_modules = 0;
+        int total_modules = 0;
+        for (int i = 0; i < version_size; i++)
+        {
+            for (int j = 0; j < version_size; j++)
+            {
+                if (test_result.at<uint8_t>(i, j) == 0)
+                {
+                    dark_modules += 1;
+                }
+                total_modules += 1;
+            }
+        }
+        if (total_modules == 0)
+            continue; // TODO: refactor, extract functions to reduce complexity
+        int modules_percent = dark_modules * 100 / total_modules;
+        int lower_bound = 45;
+        int upper_bound = 55;
+        int diff = min(abs(modules_percent - lower_bound), abs(modules_percent - upper_bound));
+        penalty_four = (diff / 5) * 10;
+        penalty_total = penalty_one + penalty_two + penalty_three + penalty_four;
+        if (penalty_total < lowest_penalty)
+        {
+            best_index = cur_type;
+            lowest_penalty = penalty_total;
+        }
+    }
+    mask_type = best_index;
+}
+
+void maskData(const Mat& original, const int mask_type_num, Mat& masked)
+{
+    int version_size = original.rows;
+    for (int i = 0; i < version_size; i++)
+    {
+        for (int j = 0; j < version_size; j++)
+        {
+            if (original.at<uint8_t>(i, j) == INVALID_REGION_VALUE)
+            {
+                continue;
+            }
+            else if((mask_type_num == 0 && !((i + j) % 2)) ||
+                    (mask_type_num == 1 && !(i % 2)) ||
+                    (mask_type_num == 2 && !(j % 3)) ||
+                    (mask_type_num == 3 && !((i + j) % 3)) ||
+                    (mask_type_num == 4 && !(((i / 2) + (j / 3)) % 2)) ||
+                    (mask_type_num == 5 && !((i * j) % 2 + (i * j) % 3))||
+                    (mask_type_num == 6 && !(((i * j) % 2 + (i * j) % 3) % 2))||
+                    ((mask_type_num == 7 && !(((i * j) % 3 + (i + j) % 2) % 2))))
+            {
+                masked.at<uint8_t>(i, j) = original.at<uint8_t>(i, j) ^ 255;
+            }
+        }
+    }
+}
+
+void QRCodeEncoderImpl::writeReservedArea()
+{
+    vector<Rect> finder_pattern(3);
+    finder_pattern[0] = Rect(Point(0, 0), Point(9, 9));
+    finder_pattern[1] = Rect(Point(0, (unsigned)version_size - 8), Point(9, version_size));
+    finder_pattern[2] = Rect(Point((unsigned)version_size - 8, 0), Point(version_size, 9));
+    const int coordinates_num = 2;
+    int locator_position[coordinates_num] = {3, version_size - 1 - 3};
+
+    for (int first_coordinate = 0; first_coordinate < coordinates_num; first_coordinate++)
+    {
+        for (int second_coordinate = 0; second_coordinate < coordinates_num; second_coordinate++)
+        {
+            if (first_coordinate == 1 && second_coordinate == 1)
+            {
+                continue;
+            }
+            int x = locator_position[first_coordinate];
+            int y = locator_position[second_coordinate];
+            for (int i = -5; i <= 5; i++)
+            {
+                for (int j = -5; j <= 5; j++)
+                {
+                    if (x + i < 0 || x + i >= version_size || y + j < 0 || y + j >= version_size)
+                    {
+                        continue;
+                    }
+                    if (!(abs(j) == 2 && abs(i) <= 2) &&
+                        !(abs(j) <= 2 && abs(i) == 2) &&
+                        !(abs(i) == 4) && !(abs(j) == 4))
+                    {
+                        masked_data.at<uint8_t>(x + i, y + j) = 0;
+                    }
+                    if ((y == locator_position[1] && j == -5) || (x == locator_position[1] && i == -5))
+                    {
+                        continue;
+                    }
+                    else
+                    {
+                        original.at<uint8_t>(x + i, y + j) = INVALID_REGION_VALUE;
+                    }
+                }
+            }
+
+        }
+    }
+    int x = locator_position[1] - 4;
+    int y = locator_position[0] + 5;
+    masked_data.at<uint8_t>(x, y) = 0;
+    original.at<uint8_t>(x, y) = INVALID_REGION_VALUE;
+    if (version_level >= 7)
+    {
+        for (int i = 0; i <= 5; i++)
+        {
+            for (int j = version_size - 11; j <= version_size - 8; j++)
+            {
+                original.at<uint8_t>(i, j) = INVALID_REGION_VALUE;
+                original.at<uint8_t>(j, i) = INVALID_REGION_VALUE;
+            }
+        }
+    }
+    for (int i = 0; i < version_size; i++)
+    {
+        for (int j = 0; j < version_size; j++)
+        {
+            if (original.at<uint8_t>(i, j) == INVALID_REGION_VALUE)
+            {
+                continue;
+            }
+            if ((i == 6 || j == 6))
+            {
+                original.at<uint8_t>(i, j) = INVALID_REGION_VALUE;
+                if (!((i == 6) && (j - 7) % 2 == 0) &&
+                    !((j == 6) && ((i - 7) % 2 == 0)))
+                {
+                    masked_data.at<uint8_t>(i, j) = 0;
+                }
+            }
+        }
+    }
+    for (int first_coord = 0; first_coord < MAX_ALIGNMENT && version_info->alignment_pattern[first_coord]; first_coord++)
+    {
+        for (int second_coord = 0; second_coord < MAX_ALIGNMENT && version_info->alignment_pattern[second_coord]; second_coord++)
+        {
+            x = version_info->alignment_pattern[first_coord];
+            y = version_info->alignment_pattern[second_coord];
+            bool is_in_finder = false;
+            for (size_t i = 0; i < finder_pattern.size(); i++)
+            {
+                Rect rect = finder_pattern[i];
+                if (x >= rect.tl().x && x <= rect.br().x
+                    &&
+                    y >= rect.tl().y && y <= rect.br().y)
+                {
+                    is_in_finder = true;
+                    break;
+                }
+            }
+            if (!is_in_finder)
+            {
+                for (int i = -2; i <= 2; i++)
+                {
+                    for (int j = -2; j <= 2; j++)
+                    {
+                        original.at<uint8_t>(x + i, y + j) = INVALID_REGION_VALUE;
+                        if ((j == 0 && i == 0) || (abs(j) == 2) || abs(i) == 2)
+                        {
+                            masked_data.at<uint8_t>(x + i, y + j) = 0;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+bool QRCodeEncoderImpl::writeBit(int x, int y, bool value)
+{
+    if (original.at<uint8_t>(y, x) == INVALID_REGION_VALUE)
+    {
+        return false;
+    }
+    if (!value)
+    {
+        original.at<uint8_t>(y, x) = 0;
+        masked_data.at<uint8_t>(y, x) = 0;
+    }
+    original.at<uint8_t>(y, x) = static_cast<uint8_t>(255 * value);
+    masked_data.at<uint8_t>(y, x) = static_cast<uint8_t>(255 * value);
+    return true;
+}
+
+void QRCodeEncoderImpl::writeData()
+{
+    int y = version_size - 1;
+    int x = version_size - 1;
+    int dir = -1;
+    int count = 0;
+    int codeword_value = rearranged_data[0];
+    const int limit_bits = (int)rearranged_data.size() * 8;
+    bool limit_reached = false;
+    while (x > 0)
+    {
+        if (x == 6)
+        {
+            x --;
+        }
+        for(int i = 0; i <= 1; i++)
+        {
+            bool bit_value = (codeword_value & (0x80 >> count % 8)) == 0;
+            bool success = writeBit(x - i, y, bit_value);
+            if (!success)
+            {
+                continue;
+            }
+            count++;
+            if (count == limit_bits)
+            {
+                limit_reached = true;
+                break;
+            }
+            if (count % 8 == 0)
+            {
+                codeword_value = rearranged_data[count / 8];
+            }
+        }
+        if (limit_reached)
+        {
+            break;
+        }
+        y += dir;
+        if (y < 0 || y >= version_size)
+        {
+            dir = -dir;
+            x -= 2;
+            y += dir;
+        }
+    }
+}
+
+void QRCodeEncoderImpl::fillReserved(const vector<uint8_t> &format_array, Mat &masked)
+{
+    for (int i = 0; i < 7; i++)
+    {
+        if (format_array[MAX_FORMAT_LENGTH - 1 - i] == 0)
+        {
+            masked.at<uint8_t>(version_size - 1 - i, 8) = 255;
+        }
+        else
+        {
+            masked.at<uint8_t>(version_size - 1 - i, 8) = 0;
+        }
+    }
+    for (int i = 0; i < 8; i++)
+    {
+        if (format_array[MAX_FORMAT_LENGTH - 1 - (7 + i)] == 0)
+        {
+            masked.at<uint8_t>(8, version_size - 8 + i) = 255;
+        }
+        else
+        {
+            masked.at<uint8_t>(8, version_size - 8 + i) = 0;
+        }
+    }
+    static const int xs_format[MAX_FORMAT_LENGTH] = {
+            8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 4, 3, 2, 1, 0
+    };
+    static const int ys_format[MAX_FORMAT_LENGTH] = {
+            0, 1, 2, 3, 4, 5, 7, 8, 8, 8, 8, 8, 8, 8, 8
+    };
+    for (int i = MAX_FORMAT_LENGTH - 1; i >= 0; i--)
+    {
+        if (format_array[i] == 0)
+        {
+            masked.at<uint8_t>(ys_format[i], xs_format[i]) = 255;
+        }
+        else
+        {
+            masked.at<uint8_t>(ys_format[i], xs_format[i]) = 0;
+        }
+    }
+
+    if (version_level >= 7)
+    {
+        const int max_size = version_size;
+        const int version_block_width = 2;
+        const int xs_version[version_block_width][MAX_VERSION_LENGTH] = {
+                { 5, 5, 5,
+                  4, 4, 4,
+                  3, 3, 3,
+                  2, 2, 2,
+                  1, 1, 1,
+                  0, 0, 0
+                },
+                { max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11
+                }
+        };
+        const int ys_version[version_block_width][MAX_VERSION_LENGTH] = {
+                { max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11,
+                  max_size - 9, max_size - 10, max_size - 11
+                },
+                { 5, 5, 5,
+                  4, 4, 4,
+                  3, 3, 3,
+                  2, 2, 2,
+                  1, 1, 1,
+                  0, 0, 0,
+                }
+        };
+        for (int i = 0; i < version_block_width; i++)
+        {
+            for (int j = 0; j < MAX_VERSION_LENGTH; j++)
+            {
+                if (version_reserved[MAX_VERSION_LENGTH - j - 1] == 0)
+                {
+                    masked.at<uint8_t>(ys_version[i][j], xs_version[i][j]) = 255;
+                }
+                else
+                {
+                    masked.at<uint8_t>(ys_version[i][j], xs_version[i][j]) = 0;
+                }
+            }
+        }
+    }
+}
+
+void QRCodeEncoderImpl::structureFinalMessage()
+{
+    writeReservedArea();
+    writeData();
+    findAutoMaskType();
+    maskData(original, mask_type, masked_data);
+    formatGenerate(mask_type, format);
+    versionInfoGenerate(version_level, version_reserved);
+    fillReserved(format, masked_data);
+}
+
+void QRCodeEncoderImpl::generatingProcess(const std::string& input, Mat& final_result)
+{
+    vector<vector<uint8_t> > data_blocks, ecc_blocks;
+    if (!stringToBits(input))
+    {
+        return;
+    }
+    padBitStream();
+    eccGenerate(data_blocks, ecc_blocks);
+    rearrangeBlocks(data_blocks, ecc_blocks);
+    structureFinalMessage();
+    final_result = masked_data.clone();
+    const int border = 2;
+    copyMakeBorder(final_result, final_result, border, border, border, border, BORDER_CONSTANT, Scalar(255));
+}
+
+void QRCodeEncoderImpl::encode(const String& input, OutputArray output)
+{
+    if (output.kind() != _InputArray::MAT)
+        CV_Error(Error::StsBadArg, "Output should be cv::Mat");
+    CV_Check((int)mode_type, mode_type != MODE_STRUCTURED_APPEND, "For structured append mode please call encodeStructuredAppend() method");
+    CV_Check(struct_num, struct_num == 1, "For structured append mode please call encodeStructuredAppend() method");
+    generateQR(input);
+    CV_Assert(!final_qrcodes.empty());
+    output.assign(final_qrcodes[0]);
+    final_qrcodes.clear();
+}
+
+void QRCodeEncoderImpl::encodeStructuredAppend(const String& input, OutputArrayOfArrays output)
+{
+    if (output.kind() != _InputArray::STD_VECTOR_MAT)
+        CV_Error(Error::StsBadArg, "Output should be vector of cv::Mat");
+    mode_type = MODE_STRUCTURED_APPEND;
+    generateQR(input);
+    CV_Assert(!final_qrcodes.empty());
+    output.create((int)final_qrcodes.size(), 1, final_qrcodes[0].type());
+    vector<Mat> dst;
+    output.getMatVector(dst);
+    for (int i = 0; i < (int)final_qrcodes.size(); i++)
+    {
+        output.getMatRef(i) = final_qrcodes[i];
+    }
+    final_qrcodes.clear();
+}
+
+Ptr<QRCodeEncoder> QRCodeEncoder::create(const QRCodeEncoder::Params& parameters)
+{
+    return makePtr<QRCodeEncoderImpl>(parameters);
+}
+
+class QRCodeDecoderImpl : public QRCodeDecoder {
+public:
+    bool decode(const Mat& straight, String& decoded_info) CV_OVERRIDE;
+
+private:
+    QRCodeEncoder::CorrectionLevel level;
+    int version;
+
+    struct Bitstream {
+        int next(int bits) {
+            CV_Assert(idx < data.size());
+
+            int val = 0;
+            while (bits >= actualBits) {
+                CV_CheckLT(idx, data.size(), "Not enough bits in the bitstream");
+                val |= data[idx++] << (bits - actualBits);
+                bits -= actualBits;
+                actualBits = 8;
+            }
+            if (bits && idx < data.size()) {
+                val |= data[idx] >> (actualBits - bits);
+                actualBits -= bits;
+                data[idx] &= 255 >> (8 - actualBits);
+            }
+            return val;
+        }
+
+        bool empty() {
+            return idx >= data.size();
+        }
+
+        std::vector<uint8_t> data;
+        int actualBits = 8;
+        size_t idx = 0;
+    } bitstream;
+
+    bool run(const Mat& straight, String& decoded_info);
+    bool decodeFormatInfo(const Mat& straight, int& mask);
+    bool correctFormatInfo(uint16_t& format_info);
+    void extractCodewords(Mat& source, std::vector<uint8_t>& codewords);
+    bool errorCorrection(std::vector<uint8_t>& codewords);
+    bool errorCorrectionBlock(std::vector<uint8_t>& codewords);
+    void decodeSymbols(String& result);
+    void decodeNumeric(String& result);
+    void decodeAlpha(String& result);
+    void decodeByte(String& result);
+    void decodeECI(String& result);
+    void decodeKanji(String& result);
+    void decodeStructuredAppend(String& result);
+};
+
+QRCodeDecoder::~QRCodeDecoder()
+{
+    // nothing
+}
+
+Ptr<QRCodeDecoder> QRCodeDecoder::create() {
+    return makePtr<QRCodeDecoderImpl>();
+}
+
+bool QRCodeDecoderImpl::decode(const Mat& _straight, String& decoded_info) {
+    Mat straight = ~_straight;  // Invert modules
+    bool decoded = run(straight, decoded_info);
+    if (!decoded) {
+        cv::transpose(straight, straight);
+        decoded = run(straight, decoded_info);
+    }
+    return decoded;
+}
+
+// Unmask format info bits and apply error correction
+bool QRCodeDecoderImpl::correctFormatInfo(uint16_t& format_info) {
+    static const uint16_t mask_pattern = 0b101010000010010;
+
+    cv::Hamming hd;
+    for (int i = 0; i < 32; ++i) {
+        // Compute Hamming distance
+        int distance = hd(reinterpret_cast<const unsigned char*>(&formatInfoLUT[i]),
+                          reinterpret_cast<const unsigned char*>(&format_info), 2);
+        // Up to 3 bit errors might be corrected.
+        // So if distance is less or equal than 3 - we found a correct format info.
+        if (distance <= 3) {
+            format_info = formatInfoLUT[i] ^ mask_pattern;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool QRCodeDecoderImpl::decodeFormatInfo(const Mat& straight, int& mask) {
+    // Read left-top format info
+    uint16_t format_info = 0;
+    for (int i = 0; i < 6; ++i)
+        format_info |= (straight.at<uint8_t>(i, 8) & 1) << i;
+
+    format_info |= (straight.at<uint8_t>(7, 8) & 1) << 6;
+    format_info |= (straight.at<uint8_t>(8, 8) & 1) << 7;
+    format_info |= (straight.at<uint8_t>(8, 7) & 1) << 8;
+
+    for (int i = 9; i < 15; ++i)
+        format_info |= (straight.at<uint8_t>(8, 14 - i) & 1) << i;
+
+    bool correct = correctFormatInfo(format_info);
+
+    // Format information 15bit sequence appears twice.
+    // Try extract format info from different position.
+    uint16_t format_info_dup = 0;
+    for (int i = 0; i < 8; ++i)
+        format_info_dup |= (straight.at<uint8_t>(8, straight.cols - 1 - i) & 1) << i;
+    for (int i = 0; i < 7; ++i)
+        format_info_dup |= (straight.at<uint8_t>(straight.rows - 7 + i, 8) & 1) << (i + 8);
+
+    if (correctFormatInfo(format_info_dup)) {
+        // Both strings must be the same
+        if (correct && format_info != format_info_dup)
+            return false;
+        format_info = format_info_dup;
+    } else {
+        if (!correct)
+            return false;
+    }
+
+    switch((format_info >> 13) & 0b11) {
+        case 0: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_M; break;
+        case 1: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_L; break;
+        case 2: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_H; break;
+        case 3: level = QRCodeEncoder::CorrectionLevel::CORRECT_LEVEL_Q; break;
+    };
+    mask = (format_info >> 10) & 0b111;
+    return true;
+}
+
+bool QRCodeDecoderImpl::run(const Mat& straight, String& decoded_info) {
+    CV_Assert(straight.rows == straight.cols);
+    version = (straight.rows - 21) / 4 + 1;
+
+    decoded_info = "";
+    mode = static_cast<QRCodeEncoder::EncodeMode>(0);
+    eci = static_cast<QRCodeEncoder::ECIEncodings>(0);
+
+    // Decode format info
+    int maskPattern;
+    bool decoded = decodeFormatInfo(straight, maskPattern);
+    if (!decoded) {
+        return false;
+    }
+
+    // Generate data mask
+    Mat masked = straight.clone();
+    maskData(straight, maskPattern, masked);
+
+    extractCodewords(masked, bitstream.data);
+    if (!errorCorrection(bitstream.data)) {
+        return false;
+    }
+    decodeSymbols(decoded_info);
+    return true;
+}
+
+bool QRCodeDecoderImpl::errorCorrection(std::vector<uint8_t>& codewords) {
+    CV_CheckEQ((int)codewords.size(), version_info_database[version].total_codewords,
+               "Number of codewords");
+
+    int numBlocks = version_info_database[version].ecc[level].num_blocks_in_G1 +
+                    version_info_database[version].ecc[level].num_blocks_in_G2;
+    if (numBlocks == 1) {
+        return errorCorrectionBlock(codewords);
+    }
+
+    size_t numData = 0;
+    std::vector<int> blockSizes;
+    blockSizes.reserve(numBlocks);
+    for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G1; ++i) {
+        blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G1);
+        numData += blockSizes.back();
+    }
+    for (int i = 0; i < version_info_database[version].ecc[level].num_blocks_in_G2; ++i) {
+        blockSizes.push_back(version_info_database[version].ecc[level].data_codewords_in_G2);
+        numData += blockSizes.back();
+    }
+
+    // TODO: parallel_for
+    std::vector<std::vector<uint8_t>> blocks(numBlocks);
+    int minBlockSize = *std::min_element(blockSizes.begin(), blockSizes.end());
+    size_t offset = 0;
+    for (int i = 0; i < minBlockSize; ++i) {
+        for (int j = 0; j < numBlocks; ++j) {
+            blocks[j].push_back(codewords[offset++]);
+        }
+    }
+    // Put remaining data codewords
+    for (int j = 0; j < numBlocks; ++j) {
+        CV_Assert(blockSizes[j] == minBlockSize || blockSizes[j] == minBlockSize + 1);
+        if (blockSizes[j] > minBlockSize)
+            blocks[j].push_back(codewords[offset++]);
+    }
+    // Copy error correction codewords
+    int numEcc = version_info_database[version].ecc[level].ecc_codewords;
+    for (int i = 0; i < numEcc; ++i) {
+        for (int j = 0; j < numBlocks; ++j) {
+            blocks[j].push_back(codewords[offset++]);
+        }
+    }
+
+    parallel_for_(Range(0, numBlocks), [&](const Range& r) {
+        for (int i = r.start; i < r.end; ++i) {
+            if (!errorCorrectionBlock(blocks[i])) {
+                blocks[i].clear();
+                return;
+            }
+        }
+    });
+
+    // Collect blocks back after error correction. Trim error correction codewords.
+    codewords.resize(numData);
+    offset = 0;
+    for (size_t i = 0; i < blocks.size(); ++i) {
+        if (blocks[i].empty())
+            return false;
+        std::copy(blocks[i].begin(), blocks[i].end(), codewords.begin() + offset);
+        offset += blocks[i].size();
+    }
+
+    return true;
+}
+
+bool QRCodeDecoderImpl::errorCorrectionBlock(std::vector<uint8_t>& codewords) {
+    size_t numEcc = version_info_database[version].ecc[level].ecc_codewords;
+    size_t numSyndromes = numEcc;
+
+    // According to the ISO there is a formula for a number of the syndromes.
+    // However several tests don't pass the error correction step because of less number of syndromes:
+    // 1M: qrcodes/detection/lots/image001.jpg from BoofCV (8 syndromes by formula, 10 needed)
+    // 1L: Objdetect_QRCode_Multi.regression/13 (4 syndromes by formula, 6 needed)
+    // 2L: qrcodes/detection/brightness/image011.jpg from BoofCV (8 syndromes by formula, 10 needed)
+    if (numSyndromes % 2 == 1)
+        numSyndromes -= 1;
+
+    // Compute syndromes
+    bool hasError = false;
+    std::vector<uint8_t> syndromes(numSyndromes, codewords[0]);
+    for (size_t i = 0; i < syndromes.size(); ++i) {
+        for (size_t j = 1; j < codewords.size(); ++j) {
+            syndromes[i] = gfMul(syndromes[i], gfPow(2, static_cast<int>(i))) ^ codewords[j];
+        }
+        hasError |= syndromes[i] != 0;
+    }
+    if (!hasError) {
+        // Trim error correction codewords
+        codewords.resize(codewords.size() - numEcc);
+        return true;
+    }
+
+    // Run Berlekamp–Massey algorithm to find error positions (coefficients of locator poly)
+    size_t L = 0;   // number of assumed errors
+    size_t m = 1;   // shift value (between C and B)
+    uint8_t b = 1;  // discrepancy from last L update
+
+    std::vector<uint8_t> C(numSyndromes, 0);  // Error locator polynomial
+    std::vector<uint8_t> B(numSyndromes, 0);  // A copy of error locator from previous L update
+    C[0] = B[0] = 1;
+    for (size_t i = 0; i < numSyndromes; ++i) {
+        CV_Assert(m + L - 1 < C.size());  // m >= 1 on any iteration
+        uint8_t discrepancy = syndromes[i];
+        for (size_t j = 1; j <= L; ++j) {
+            discrepancy ^= gfMul(C[j], syndromes[i - j]);
+        }
+
+        if (discrepancy == 0) {
+            m += 1;
+        } else {
+            std::vector<uint8_t> C_copy = C;
+            uint8_t inv_b = gfDiv(1, b);
+            uint8_t tmp = gfMul(discrepancy, inv_b);
+
+            for (size_t j = 0; j < L; ++j) {
+                C[m + j] ^= gfMul(tmp, B[j]);
+            }
+
+            if (2 * L <= i) {
+                L = i + 1 - L;
+                B = C_copy;
+                b = discrepancy;
+                m = 1;
+            } else {
+                m += 1;
+            }
+        }
+    }
+
+    // There is an error at i-th position if i is a root of locator poly
+    std::vector<size_t> errLocs;
+    errLocs.reserve(L);
+    for (size_t i = 0; i < codewords.size(); ++i) {
+        uint8_t val = 1;
+        uint8_t pos = gfPow(2, static_cast<int>(i));
+        for (size_t j = 1; j <= L; ++j) {
+            val = gfMul(val, pos) ^ C[j];
+        }
+        if (val == 0) {
+            errLocs.push_back(static_cast<int>(codewords.size() - 1 - i));
+        }
+    }
+
+    // Number of assumed errors does not match number of error locations
+    if (errLocs.size() != L)
+        return false;
+
+    // Forney algorithm for error correction using syndromes and known error locations
+    std::vector<uint8_t> errEval;
+    gfPolyMul(C, syndromes, errEval);
+
+    // Precompute all X values for error locations to avoid duplicated computation
+    std::vector<uint8_t> X_values(errLocs.size());
+    for (size_t j = 0; j < errLocs.size(); ++j) {
+        X_values[j] = gfPow(2, static_cast<int>(codewords.size() - 1 - errLocs[j]));
+    }
+
+    for (size_t i = 0; i < errLocs.size(); ++i) {
+        uint8_t numenator = 0, denominator = 0;
+        uint8_t X = X_values[i];
+        uint8_t inv_X = gfDiv(1, X);
+
+        for (size_t j = 0; j < L; ++j) {
+            numenator = gfMul(numenator, inv_X) ^ errEval[L - 1 - j];
+        }
+
+        // Compute demoninator as a product of (1-X_i * X_k) for i != k
+        denominator = 1;
+        for (size_t j = 0; j < errLocs.size(); ++j) {
+            if (i == j)
+                continue;
+            uint8_t Xj = X_values[j];
+            denominator = gfMul(denominator, 1 ^ gfMul(inv_X, Xj));
+        }
+
+        uint8_t errValue = gfDiv(numenator, denominator);
+        codewords[errLocs[i]] ^= errValue;
+    }
+
+    // Trim error correction codewords
+    codewords.resize(codewords.size() - numEcc);
+    return true;
+}
+
+void QRCodeDecoderImpl::extractCodewords(Mat& source, std::vector<uint8_t>& codewords) {
+    const VersionInfo& version_info = version_info_database[version];
+
+    // Mask alignment markers
+    std::vector<int> alignCenters;
+    alignCenters.reserve(MAX_ALIGNMENT);
+    for (int i = 0; i < MAX_ALIGNMENT && version_info.alignment_pattern[i]; i++)
+        alignCenters.push_back(version_info.alignment_pattern[i]);
+
+    for (size_t i = 0; i < alignCenters.size(); i++)
+    {
+        for (size_t j = 0; j < alignCenters.size(); j++)
+        {
+            if ((i == alignCenters.size() - 1 && j == 0) || (i == 0 && j == 0) ||
+                (j == alignCenters.size() - 1 && i == 0))
+                continue;
+            int x = alignCenters[i];
+            int y = alignCenters[j];
+            Mat area = source({x - 2, x + 3}, {y - 2, y + 3});
+            area.setTo(INVALID_REGION_VALUE);
+        }
+    }
+
+    // Mask detection markers
+    source.rowRange(0, 9).colRange(source.cols - 8, source.cols).setTo(INVALID_REGION_VALUE);
+    source.rowRange(0, 9).colRange(0, 9).setTo(INVALID_REGION_VALUE);
+    source.colRange(0, 9).rowRange(source.rows - 8, source.rows).setTo(INVALID_REGION_VALUE);
+
+    // Mask Version Information blocks
+    if (version >= 7) {
+        source.rowRange(0, 6).colRange(source.cols - 12, source.cols - 9).setTo(INVALID_REGION_VALUE);
+        source.colRange(0, 6).rowRange(source.rows - 12, source.rows - 9).setTo(INVALID_REGION_VALUE);
+    }
+
+    // Mask timing pattern
+    source.row(6) = INVALID_REGION_VALUE;
+
+    std::vector<uint8_t> bits;
+    bits.reserve(source.total() - source.cols);
+    bool moveUpwards = true;
+    for (auto& data : {source.colRange(7, source.cols), source.colRange(0, 6)}) {
+        for (int i = data.cols / 2 - 1; i >= 0; --i) {
+            Mat col0 = data.col(i * 2);
+            Mat col1 = data.col(i * 2 + 1);
+            for (int j = 0; j < data.rows; ++j) {
+                if (moveUpwards) {
+                    bits.push_back(col1.at<uint8_t>(data.rows - 1 - j));
+                    bits.push_back(col0.at<uint8_t>(data.rows - 1 - j));
+                } else {
+                    bits.push_back(col1.at<uint8_t>(j));
+                    bits.push_back(col0.at<uint8_t>(j));
+                }
+            }
+            moveUpwards = !moveUpwards;
+        }
+    }
+
+    // Combine bits to codewords
+    size_t numCodewords = version_info.total_codewords;
+    codewords.resize(numCodewords);
+
+    size_t offset = 0;
+    for (size_t i = 0; i < numCodewords; ++i) {
+        codewords[i] = 0;
+        for (size_t j = 0; j < 8; ++j) {
+            while (bits[offset] == INVALID_REGION_VALUE) {
+                offset += 1;
+                CV_Assert(offset < bits.size());
+            }
+            codewords[i] |= (bits[offset] & 1) << (7 - j);
+            offset += 1;
+        }
+    }
+}
+
+void QRCodeDecoderImpl::decodeSymbols(String& result) {
+    CV_Assert(!bitstream.empty());
+
+    // Decode depends on the mode
+    result = "";
+    while (!bitstream.empty()) {
+        // Determine mode
+        auto currMode = static_cast<QRCodeEncoder::EncodeMode>(bitstream.next(4));
+        if (this->mode == 0) {
+            mode = currMode;
+        }
+
+        if (currMode == 0 || bitstream.empty())
+            return;
+        if (currMode == QRCodeEncoder::EncodeMode::MODE_NUMERIC)
+            decodeNumeric(result);
+        else if (currMode == QRCodeEncoder::EncodeMode::MODE_ALPHANUMERIC)
+            decodeAlpha(result);
+        else if (currMode == QRCodeEncoder::EncodeMode::MODE_BYTE)
+            decodeByte(result);
+        else if (currMode == QRCodeEncoder::EncodeMode::MODE_ECI)
+            decodeECI(result);
+        else if (currMode == QRCodeEncoder::EncodeMode::MODE_KANJI)
+            decodeKanji(result);
+        else if (currMode == QRCodeEncoder::EncodeMode::MODE_STRUCTURED_APPEND) {
+            sequence_num = static_cast<uint8_t>(bitstream.next(4));
+            total_num = static_cast<uint8_t>(1 + bitstream.next(4));
+            parity = static_cast<uint8_t>(bitstream.next(8));
+        }
+        else
+            CV_Error(Error::StsNotImplemented, format("mode %d", currMode));
+    }
+}
+
+void QRCodeDecoderImpl::decodeNumeric(String& result) {
+    int numDigits = bitstream.next(version <= 9 ? 10 : (version <= 26 ? 12 : 14));
+    for (int i = 0; i < numDigits / 3; ++i) {
+        int triple = bitstream.next(10);
+        result += static_cast<char>('0' + triple / 100);
+        result += static_cast<char>('0' + (triple / 10) % 10);
+        result += static_cast<char>('0' + triple % 10);
+    }
+    int remainingDigits = numDigits % 3;
+    if (remainingDigits) {
+        int triple = bitstream.next(remainingDigits == 1 ? 4 : 7);
+        if (remainingDigits == 2)
+            result += '0' + (triple / 10) % 10;
+        result += '0' + triple % 10;
+    }
+}
+
+void QRCodeDecoderImpl::decodeAlpha(String& result) {
+    static const char map[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                               'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+                               'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+                               'U', 'V', 'W', 'X', 'Y', 'Z', ' ', '$', '%', '*',
+                               '+', '-', '.', '/', ':'};
+
+    int num = bitstream.next(version <= 9 ? 9 : (version <= 26 ? 11 : 13));
+    for (int i = 0; i < num / 2; ++i) {
+        int tuple = bitstream.next(11);
+        result += map[tuple / 45];
+        result += map[tuple % 45];
+    }
+    if (num % 2) {
+        int value = bitstream.next(6);
+        result += map[value];
+    }
+}
+
+void QRCodeDecoderImpl::decodeByte(String& result) {
+    int num = bitstream.next(version <= 9 ? 8 : 16);
+    for (int i = 0; i < num; ++i) {
+        result += static_cast<char>(bitstream.next(8));
+    }
+}
+
+void QRCodeDecoderImpl::decodeECI(String& result) {
+    int eciAssignValue = bitstream.next(8);
+    for (int i = 0; i < 8; ++i) {
+        if (eciAssignValue & 1 << (7 - i))
+            eciAssignValue |= bitstream.next(8) << (i + 1) * 8;
+        else
+            break;
+    }
+    if (this->eci == 0) {
+        this->eci = static_cast<QRCodeEncoder::ECIEncodings>(eciAssignValue);
+    }
+    decodeSymbols(result);
+
+}
+
+void QRCodeDecoderImpl::decodeKanji(String& result) {
+    int num = bitstream.next(version <= 9 ? 8 : (version <= 26 ? 10 : 12));
+    for (int i = 0; i < num; ++i) {
+        int data = bitstream.next(13);
+        int high_byte = data / 0xC0;
+        int low_byte = data - high_byte * 0xC0;
+        int symbol = (high_byte << 8) + low_byte;
+        if (0 <= symbol && symbol <= 0x9FFC - 0x8140) {
+            symbol += 0x8140;
+        } else if (0xE040 - 0xC140 <= symbol && symbol <= 0xEBBF - 0xC140) {
+            symbol += 0xC140;
+        }
+        result += (symbol >> 8) & 0xff;
+        result += symbol & 0xff;
+    }
+}
+
+}
diff --git a/upstream/opencv/modules/objdetect/src/qrcode_encoder_table.inl.hpp b/upstream/opencv/modules/objdetect/src/qrcode_encoder_table.inl.hpp
new file mode 100644
index 0000000..5a9c071
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/qrcode_encoder_table.inl.hpp
@@ -0,0 +1,869 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Intel Corporation, all rights reserved.
+//
+// This is .hpp file included from qrcode_encoder.cpp
+
+namespace cv {
+
+const int MAX_ALIGNMENT = 7;
+const int MODES = 4;
+const int ERROR_CORR_LEVELS = 4;
+const int MAX_VERSION = 40;
+
+struct BlockParams
+{
+    int ecc_codewords;
+    int num_blocks_in_G1;
+    int data_codewords_in_G1;
+    int num_blocks_in_G2;
+    int data_codewords_in_G2;
+};
+
+struct VersionInfo
+{
+    int	total_codewords;
+    int	alignment_pattern[MAX_ALIGNMENT];
+    BlockParams ecc[ERROR_CORR_LEVELS];
+};
+
+/** numeric_mode;
+    alpha_mode;
+    byte_mode;
+    kanji mode;
+*/
+struct ECLevelCapacity
+{
+    int encoding_modes[MODES];
+};
+struct CharacterCapacity
+{
+    ECLevelCapacity ec_level[ERROR_CORR_LEVELS];
+};
+const CharacterCapacity version_capacity_database[MAX_VERSION + 1] =
+{
+        {
+            {
+                {0, 1, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0}
+            }
+        },
+        {
+            {
+                {41, 25, 17, 10},
+                {34, 20, 14, 8},
+                {27, 16, 11, 7},
+                {17, 10, 7 , 4}
+            }
+        },
+        {
+            {
+                {77, 47, 32, 20},
+                {63, 38, 26, 16},
+                {48, 29, 20, 12},
+                {34, 20, 14, 8}
+            }
+        },
+        {
+            {
+                {127, 77, 53, 32},
+                {101, 61, 42, 26},
+                {77, 47, 32, 20},
+                {58, 35, 24, 15}
+            }
+        },
+        {
+            {
+                {187, 114, 78, 48},
+                {149, 90, 62, 38},
+                {111, 67, 46, 28},
+                {82, 50, 34, 21}
+            }
+        },
+        {
+            {
+                {255, 154, 106, 65},
+                {202, 122, 84, 52},
+                {144, 87, 60, 37},
+                {106, 64, 44, 27}
+            }
+        },
+        {
+            {
+                {322, 195, 134, 82},
+                {255, 154, 106, 65},
+                {178, 108, 74, 45},
+                {139, 84 , 58, 36}
+            }
+        },
+        {
+            {
+                {370, 224, 154, 95},
+                {293, 178, 122, 75},
+                {207, 125, 86, 53},
+                {154, 93 , 64, 39}
+            }
+        },
+        {
+            {
+                {461, 279, 192, 118},
+                {365, 221, 152, 93},
+                {259, 157, 108, 66},
+                {202, 122, 84, 52}
+            }
+        },
+        {
+            {
+                {552, 335, 230, 141},
+                {432, 262, 180, 111},
+                {312, 189, 130, 80},
+                {235, 143, 98, 60}
+            }
+        },
+        {
+            {
+                {652, 395, 271, 167},
+                {513, 311, 213, 131},
+                {364, 221, 151, 93},
+                {288, 174, 119, 74}
+            }
+        },
+        {
+            {
+                {772, 468, 321, 198},
+                {604, 366, 251, 155},
+                {427, 259, 177, 109},
+                {331, 200, 137, 85}
+            }
+        },
+        {
+            {
+                {883, 535, 367, 226},
+                {691, 419, 287, 177},
+                {489, 296, 203, 125},
+                {374, 227, 155, 96}
+            }
+        },
+        {
+            {
+                {1022, 619, 425, 262},
+                {796, 483, 331, 204},
+                {580, 352, 241, 149},
+                {427, 259, 177, 109}
+            }
+        },
+        {
+            {
+                {1101, 667, 458, 282},
+                {871, 528, 362, 223},
+                {621, 376, 258, 159},
+                {468, 283, 194, 120}
+            }
+        },
+        {
+            {
+                {1250, 758, 520, 320},
+                {991, 600, 412, 254},
+                {703, 426, 292, 180},
+                {530, 321, 220, 136}
+            }
+        },
+        {
+            {
+                {1408, 854, 586, 361},
+                {1082, 656, 450, 277},
+                {775, 470, 322, 198},
+                {602, 365, 250, 154}
+            }
+        },
+        {
+            {
+                {1548, 938, 644, 397},
+                {1212, 734, 504, 310},
+                {876, 531, 364, 224},
+                {674, 408, 280, 173}
+            }
+        },
+        {
+            {
+                {1725, 1046, 718, 442},
+                {1346, 816, 560, 345},
+                {948, 574, 394, 243},
+                {746, 452, 310, 191}
+            }
+        },
+        {
+            {
+                {1903, 1153, 792, 488},
+                {1500, 909, 624, 384},
+                {1063, 644, 442, 272},
+                {813, 493, 338, 208}
+            }
+        },
+        {
+            {
+                {2061, 1249, 858, 528},
+                {1600, 970, 666, 410},
+                {1159, 702, 482, 297},
+                {919, 557, 382, 235}
+            }
+        },
+        {
+            {
+                {2232, 1352, 929, 572},
+                {1708, 1035, 711, 438},
+                {1224, 742, 509, 314},
+                {969, 587, 403, 248}
+            }
+        },
+        {
+            {
+                {2409, 1460, 1003, 618},
+                {1872, 1134, 779, 480},
+                {1358, 823, 565, 348},
+                {1056, 640, 439, 270}
+            }
+        },
+        {
+            {
+                {2620, 1588, 1091, 672},
+                {2059, 1248, 857, 528},
+                {1468, 890, 611, 376},
+                {1108, 672, 461, 284}
+            }
+        },
+        {
+            {
+                {2812, 1704, 1171, 721},
+                {2188, 1326, 911, 561},
+                {1588, 963, 661, 407},
+                {1228, 744, 511, 315}
+            }
+        },
+        {
+            {
+                {3057, 1853, 1273, 784},
+                {2395, 1451, 997, 614},
+                {1718, 1041, 715, 440},
+                {1286, 779, 535, 330}
+            }
+        },
+        {
+            {
+                {3283, 1990, 1367, 842},
+                {2544, 1542, 1059, 652},
+                {1804, 1094, 751, 462},
+                {1425, 864, 593, 365}
+            }
+        },
+        {
+            {
+                {3517, 2132, 1465, 902},
+                {2701, 1637, 1125, 692},
+                {1933, 1172, 805, 496},
+                {1501, 910, 625, 385}
+            }
+        },
+        {
+            {
+                {3669, 2223, 1528, 940},
+                {2857, 1732, 1190, 732},
+                {2085, 1263, 868, 534},
+                {1581, 958, 658, 405}
+            }
+        },
+        {
+            {
+                {3909, 2369, 1628, 1002},
+                {3035, 1839, 1264, 778},
+                {2181, 1322, 908, 559},
+                {1677, 1016, 698, 430}
+            }
+        },
+        {
+            {
+                {4158, 2520, 1732, 1066},
+                {3289, 1994, 1370, 843},
+                {2358, 1429, 982, 604},
+                {1782, 1080, 742, 457}
+            }
+        },
+        {
+            {
+                {4417, 2677, 1840, 1132},
+                {3486, 2113, 1452, 894},
+                {2473, 1499, 1030, 634},
+                {1897, 1150, 790, 486}
+            }
+
+        },
+        {
+            {
+                {4686, 2840, 1952, 1201},
+                {3693, 2238, 1538, 947},
+                {2670, 1618, 1112, 684},
+                {2022, 1226, 842, 518}
+            }
+        },
+        {
+            {
+                {4965, 3009, 2068, 1273},
+                {3909, 2369, 1628, 1002},
+                {2805, 1700, 1168, 719},
+                {2157, 1307, 898, 553}
+            }
+        },
+        {
+            {
+                {5253, 3183, 2188, 1347},
+                {4134, 2506, 1722, 1060},
+                {2949, 1787, 1228, 756},
+                {2301, 1394, 958 , 590}
+            }
+        },
+        {
+            {
+                {5529, 3351, 2303, 1417},
+                {4343, 2632, 1809, 1113},
+                {3081, 1867, 1283, 790},
+                {2361, 1431, 983, 605}
+            }
+        },
+        {
+            {
+                {5836, 3537, 2431, 1496},
+                {4588, 2780, 1911, 1176},
+                {3244, 1966, 1351, 832},
+                {2524, 1530, 1051, 647}
+            }
+        },
+        {
+            {
+                {6153, 3729, 2563, 1577},
+                {4775, 2894, 1989, 1224},
+                {3417, 2071, 1423, 876},
+                {2625, 1591, 1093, 673}
+            }
+        },
+        {
+            {
+                {6479, 3927, 2699, 1661},
+                {5039, 3054, 2099, 1292},
+                {3599, 2181, 1499, 923},
+                {2735, 1658, 1139, 701}
+            }
+        },
+        {
+            {
+                {6743, 4087, 2809, 1729},
+                {5313, 3220, 2213, 1362},
+                {3791, 2298, 1579, 972},
+                {2927, 1774, 1219, 750}
+            }
+        },
+        {
+            {
+                {7089, 4296, 2953, 1817},
+                {5596, 3391, 2331, 1435},
+                {3993, 2420, 1663, 1024},
+                {3057, 1852, 1273, 784}
+            }
+        }
+};
+
+const VersionInfo version_info_database[MAX_VERSION + 1] =
+{
+        { /* Version 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}
+            }
+        },
+        { /* Version 1 */
+            26,
+            {0, 0, 0, 0, 0, 0, 0},
+            {
+                {7, 1, 19, 0, 0},
+                {10, 1, 16, 0, 0},
+                {13, 1, 13, 0, 0},
+                {17, 1, 9, 0, 0}
+            }
+        },
+        { /* Version 2 */
+            44,
+            {6, 18, 0, 0, 0, 0, 0},
+            {
+                {10, 1, 34, 0, 0},
+                {16, 1, 28, 0, 0},
+                {22, 1, 22, 0, 0},
+                {28, 1, 16, 0, 0}
+            }
+        },
+        { /* Version 3 */
+            70,
+            {6, 22, 0, 0, 0, 0, 0},
+            {
+                {15, 1, 55, 0, 0},
+                {26, 1, 44, 0, 0},
+                {18, 2, 17, 0, 0},
+                {22, 2, 13, 0, 0}
+            }
+        },
+        { /* Version 4 */
+            100,
+            {6, 26, 0,0,0,0,0},
+            {
+                {20, 1, 80, 0, 0},
+                {18, 2, 32, 0, 0},
+                {26, 2, 24, 0, 0},
+                {16, 4, 9 , 0, 0}
+            }
+        },
+        { /* Version 5 */
+            134,
+            {6, 30, 0, 0, 0, 0, 0},
+            {
+                {26, 1, 108, 0, 0},
+                {24, 2, 43, 0, 0},
+                {18, 2, 15, 2, 16},
+                {22, 2, 11, 2, 12}
+            }
+        },
+        { /* Version 6 */
+            172,
+            {6, 34, 0, 0, 0, 0, 0},
+            {
+                {18, 2, 68, 0, 0},
+                {16, 4, 27, 0, 0},
+                {24, 4, 19, 0, 0},
+                {28, 4, 15, 0, 0}
+            }
+        },
+        { /* Version 7 */
+            196,
+            {6, 22, 38, 0, 0, 0, 0},
+            {
+                {20, 2, 78, 0, 0},
+                {18, 4, 31, 0, 0},
+                {18, 2, 14, 4, 15},
+                {26, 4, 13, 1, 14}
+            }
+        },
+        { /* Version 8 */
+            242,
+            {6, 24, 42, 0, 0, 0, 0},
+            {
+                {24, 2, 97, 0, 0},
+                {22, 2, 38, 2, 39},
+                {22, 4, 18, 2, 19},
+                {26, 4, 14, 2, 15}
+            }
+        },
+        { /* Version 9 */
+            292,
+            {6, 26, 46, 0, 0, 0, 0},
+            {
+                {30, 2, 116, 0, 0},
+                {22, 3, 36, 2, 37},
+                {20, 4, 16, 4, 17},
+                {24, 4, 12, 4, 13}
+            }
+        },
+        { /* Version 10 */
+            346,
+            {6, 28, 50, 0, 0, 0, 0},
+            {
+                {18, 2, 68, 2, 69},
+                {26, 4, 43, 1, 44},
+                {24, 6, 19, 2, 20},
+                {28, 6, 15, 2, 16}
+            }
+        },
+        { /* Version 11 */
+            404,
+            {6, 30, 54, 0, 0, 0, 0},
+            {
+                {20, 4, 81, 0, 0},
+                {30, 1, 50, 4, 51},
+                {28, 4, 22, 4, 23},
+                {24, 3, 12, 8, 13}
+            }
+        },
+        { /* Version 12 */
+            466,
+            {6, 32, 58, 0, 0, 0, 0},
+            {
+                {24, 2, 92, 2, 93},
+                {22, 6, 36, 2, 37},
+                {26, 4, 20, 6, 21},
+                {28, 7, 14, 4, 15}
+            }
+        },
+        { /* Version 13 */
+            532,
+            {6, 34, 62, 0, 0, 0, 0},
+            {
+                {26, 4, 107, 0, 0},
+                {22, 8, 37, 1, 38},
+                {24, 8, 20, 4, 21},
+                {22, 12, 11, 4, 12}
+            }
+        },
+        { /* Version 14 */
+            581,
+            {6, 26, 46, 66, 0, 0, 0},
+            {
+                {30, 3, 115, 1, 116},
+                {24, 4, 40, 5, 41},
+                {20, 11, 16, 5, 17},
+                {24, 11, 12, 5, 13}
+            }
+        },
+        { /* Version 15 */
+            655,
+            {6, 26, 48, 70, 0, 0, 0},
+            {
+                {22, 5, 87, 1, 88},
+                {24, 5, 41, 5, 42},
+                {30, 5, 24, 7, 25},
+                {24, 11, 12, 7, 13}
+            }
+        },
+        { /* Version 16 */
+            733,
+            {6, 26, 50, 74, 0, 0, 0},
+            {
+                {24, 5, 98, 1, 99},
+                {28, 7, 45, 3, 46},
+                {24, 15, 19, 2, 20},
+                {30, 3, 15, 13, 16}
+            }
+        },
+        { /* Version 17 */
+            815,
+            {6, 30, 54, 78, 0, 0, 0},
+            {
+                {28, 1, 107, 5, 108},
+                {28, 10, 46, 1, 47},
+                {28, 1, 22, 15, 23},
+                {28, 2, 14, 17, 15}
+            }
+        },
+        { /* Version 18 */
+            901,
+            {6, 30, 56, 82, 0, 0, 0},
+            {
+                {30, 5, 120, 1, 121},
+                {26, 9, 43, 4, 44},
+                {28, 17, 22, 1, 23},
+                {28, 2, 14, 19, 15}
+            }
+        },
+        { /* Version 19 */
+            991,
+            {6, 30, 58, 86, 0, 0, 0},
+            {
+                {28, 3, 113, 4, 114},
+                {26, 3, 44, 11, 45},
+                {26, 17, 21, 4, 22},
+                {26, 9, 13, 16, 14}
+            }
+        },
+        { /* Version 20 */
+            1085,
+            {6, 34, 62, 90, 0, 0, 0},
+            {
+                {28, 3, 107, 5, 108},
+                {26, 3, 41, 13, 42},
+                {30, 15, 24, 5, 25},
+                {28, 15, 15, 10, 16}
+            }
+        },
+        { /* Version 21 */
+            1156,
+            {6, 28, 50, 72, 92, 0, 0},
+            {
+                {28, 4, 116, 4, 117},
+                {26, 17, 42, 0, 0},
+                {28, 17, 22, 6, 23},
+                {30, 19, 16, 6, 17}
+            }
+        },
+        { /* Version 22 */
+            1258,
+            {6, 26, 50, 74, 98, 0, 0},
+            {
+                {28, 2, 111, 7, 112},
+                {28, 17, 46, 0, 0},
+                {30, 7, 24, 16, 25},
+                {24, 34, 13, 0, 0}
+            }
+        },
+        { /* Version 23 */
+            1364,
+            {6, 30, 54, 78, 102, 0, 0},
+            {
+                {30, 4, 121,5, 122},
+                {28, 4, 47, 14, 48},
+                {30, 11, 24, 14, 25},
+                {30, 16, 15, 14, 16}
+            }
+        },
+        { /* Version 24 */
+            1474,
+            {6, 28, 54, 80, 106, 0, 0},
+            {
+                {30, 6, 117,4, 118},
+                {28, 6, 45, 14, 46},
+                {30, 11, 24, 16, 25},
+                {30, 30, 16, 2, 17}
+            }
+        },
+        { /* Version 25 */
+            1588,
+            {6, 32, 58, 84, 110, 0, 0},
+            {
+                {26, 8, 106, 4, 107},
+                {28, 8, 47, 13, 48},
+                {30, 7, 24, 22, 25},
+                {30, 22, 15, 13, 16}
+            }
+        },
+        { /* Version 26 */
+            1706,
+            {6, 30, 58, 86, 114, 0, 0},
+            {
+                {28, 10, 114, 2, 115},
+                {28, 19, 46, 4, 47},
+                {28, 28, 22, 6, 23},
+                {30, 33, 16, 4, 17}
+            }
+        },
+        { /* Version 27 */
+            1828,
+            {6, 34, 62, 90, 118, 0, 0},
+            {
+                {30, 8, 122, 4, 123},
+                {28, 22, 45, 3, 46},
+                {30, 8, 23, 26, 24},
+                {30, 12, 15, 28, 16}
+            }
+        },
+        { /* Version 28 */
+            1921,
+            {6, 26, 50, 74, 98, 122, 0},
+            {
+                {30, 3, 117, 10, 118},
+                {28, 3, 45, 23, 46},
+                {30, 4, 24, 31, 25},
+                {30, 11, 15, 31, 16}
+            }
+        },
+        { /* Version 29 */
+            2051,
+            {6, 30, 54, 78, 102, 126, 0},
+            {
+                {30, 7, 116, 7, 117},
+                {28, 21, 45, 7, 46},
+                {30, 1, 23, 37, 24},
+                {30, 19, 15, 26, 16}
+            }
+        },
+        { /* Version 30 */
+            2185,
+            {6, 26, 52, 78, 104, 130, 0},
+            {
+                {30, 5, 115, 10, 116},
+                {28, 19, 47, 10, 48},
+                {30, 15, 24, 25, 25},
+                {30, 23, 15, 25, 16}
+            }
+        },
+        { /* Version 31 */
+            2323,
+            {6, 30, 56, 82, 108, 134, 0},
+            {
+                {30, 13, 115, 3, 116},
+                {28, 2, 46, 29, 47},
+                {30, 42, 24, 1, 25},
+                {30, 23, 15, 28, 16}
+            }
+        },
+        { /* Version 32 */
+            2465,
+            {6, 34, 60, 86, 112, 138, 0},
+            {
+                {30, 17, 115, 0, 0},
+                {28, 10, 46, 23, 47},
+                {30, 10, 24, 35, 25},
+                {30, 19, 15, 35, 16}
+            }
+        },
+        { /* Version 33 */
+            2611,
+            {6, 30, 58, 86, 114, 142, 0},
+            {
+                {30, 17, 115, 1, 116},
+                {28, 14, 46, 21, 47},
+                {30, 29, 24, 19, 25},
+                {30, 11, 15, 46, 16}
+            }
+        },
+        { /* Version 34 */
+            2761,
+            {6, 34, 62, 90, 118, 146, 0},
+            {
+                {30, 13, 115, 6, 116},
+                {28, 14, 46, 23, 47},
+                {30, 44, 24, 7, 25},
+                {30, 59, 16, 1, 17}
+            }
+        },
+        { /* Version 35 */
+            2876,
+            {6, 30, 54, 78, 102, 126, 150},
+            {
+                {30, 12, 121, 7, 122},
+                {28, 12, 47, 26, 48},
+                {30, 39, 24, 14, 25},
+                {30, 22, 15, 41, 16}
+            }
+        },
+        { /* Version 36 */
+            3034,
+            {6, 24, 50, 76, 102, 128, 154},
+            {
+                {30, 6, 121, 14, 122},
+                {28, 6, 47, 34, 48},
+                {30, 46, 24, 10, 25},
+                {30, 2, 15, 64, 16}
+            }
+        },
+        { /* Version 37 */
+            3196,
+            {6, 28, 54, 80, 106, 132, 158},
+            {
+                {30, 17, 122, 4, 123},
+                {28, 29, 46, 14, 47},
+                {30, 49, 24, 10, 25},
+                {30, 24, 15, 46, 16}
+            }
+        },
+        { /* Version 38 */
+            3362,
+            {6, 32, 58, 84, 110, 136, 162},
+            {
+                {30, 4, 122, 18, 123},
+                {28, 13, 46, 32, 47},
+                {30, 48, 24, 14, 25},
+                {30, 42, 15, 32, 16}
+            }
+        },
+        { /* Version 39 */
+            3532,
+            {6, 26, 54, 82, 110, 138, 166},
+            {
+                {30, 20, 117,4, 118},
+                {28, 40, 47, 7, 48},
+                {30, 43, 24, 22, 25},
+                {30, 10, 15, 67, 16}
+            }
+        },
+        { /* Version 40 */
+            3706,
+            {6, 30, 58, 86, 114, 142, 170},
+            {
+                {30, 19, 118, 6, 119},
+                {28, 18, 47, 31, 48},
+                {30, 34, 24, 34, 25},
+                {30, 20, 15, 61, 16}
+            }
+        }
+};
+
+static const uint8_t gf_exp[256] = {
+        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+        0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
+        0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9,
+        0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
+        0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35,
+        0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
+        0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0,
+        0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
+        0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc,
+        0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
+        0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f,
+        0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
+        0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88,
+        0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
+        0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93,
+        0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
+        0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9,
+        0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
+        0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa,
+        0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
+        0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e,
+        0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
+        0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4,
+        0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
+        0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e,
+        0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
+        0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef,
+        0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
+        0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5,
+        0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
+        0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83,
+        0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x01
+};
+static const uint8_t gf_log[256] = {
+        0x00, 0xff, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6,
+        0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
+        0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81,
+        0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
+        0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21,
+        0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
+        0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9,
+        0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
+        0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd,
+        0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
+        0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd,
+        0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
+        0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e,
+        0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
+        0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b,
+        0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
+        0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d,
+        0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
+        0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c,
+        0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
+        0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd,
+        0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
+        0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e,
+        0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
+        0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76,
+        0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
+        0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa,
+        0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
+        0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51,
+        0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
+        0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8,
+        0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
+};
+
+// There are only 32 combinations of format info sequences.
+static const uint16_t formatInfoLUT[32] = {
+        0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0,
+        0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976,
+        0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b,
+        0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed
+};
+
+}
diff --git a/upstream/opencv/modules/objdetect/src/quadsubpix.cpp b/upstream/opencv/modules/objdetect/src/quadsubpix.cpp
new file mode 100644
index 0000000..949b544
--- /dev/null
+++ b/upstream/opencv/modules/objdetect/src/quadsubpix.cpp
@@ -0,0 +1,240 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                        Intel License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000, Intel Corporation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of Intel Corporation may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "precomp.hpp"
+
+#include <limits>
+#include <utility>
+#include <algorithm>
+
+#include <math.h>
+
+namespace cv {
+
+inline bool is_smaller(const std::pair<int, float>& p1, const std::pair<int, float>& p2)
+{
+    return p1.second < p2.second;
+}
+
+static void orderContours(const std::vector<std::vector<Point> >& contours, Point2f point, std::vector<std::pair<int, float> >& order)
+{
+    order.clear();
+    size_t i, j, n = contours.size();
+    for(i = 0; i < n; i++)
+    {
+        size_t ni = contours[i].size();
+        float min_dist = std::numeric_limits<float>::max();
+        for(j = 0; j < ni; j++)
+        {
+            double dist = norm(Point2f((float)contours[i][j].x, (float)contours[i][j].y) - point);
+            min_dist = (float)MIN((double)min_dist, dist);
+        }
+        order.push_back(std::pair<int, float>((int)i, min_dist));
+    }
+
+    std::sort(order.begin(), order.end(), is_smaller);
+}
+
+// fit second order curve to a set of 2D points
+inline void fitCurve2Order(const std::vector<Point2f>& /*points*/, std::vector<float>& /*curve*/)
+{
+    // TBD
+}
+
+inline void findCurvesCross(const std::vector<float>& /*curve1*/, const std::vector<float>& /*curve2*/, Point2f& /*cross_point*/)
+{
+}
+
+static void findLinesCrossPoint(Point2f origin1, Point2f dir1, Point2f origin2, Point2f dir2, Point2f& cross_point)
+{
+    float det = dir2.x*dir1.y - dir2.y*dir1.x;
+    Point2f offset = origin2 - origin1;
+
+    float alpha = (dir2.x*offset.y - dir2.y*offset.x)/det;
+    cross_point = origin1 + dir1*alpha;
+}
+
+static void findCorner(const std::vector<Point2f>& contour, Point2f point, Point2f& corner)
+{
+    // find the nearest point
+    double min_dist = std::numeric_limits<double>::max();
+    int min_idx = -1;
+
+    // find corner idx
+    for(size_t i = 0; i < contour.size(); i++)
+    {
+        double dist = norm(contour[i] - point);
+        if(dist < min_dist)
+        {
+            min_dist = dist;
+            min_idx = (int)i;
+        }
+    }
+    CV_Assert(min_idx >= 0);
+
+    // temporary solution, have to make something more precise
+    corner = contour[min_idx];
+    return;
+}
+
+static int segment_hist_max(const Mat& hist, int& low_thresh, int& high_thresh)
+{
+    Mat bw;
+    double total_sum = sum(hist).val[0];
+
+    double quantile_sum = 0.0;
+    //double min_quantile = 0.2;
+    double low_sum = 0;
+    double max_segment_length = 0;
+    int max_start_x = -1;
+    int max_end_x = -1;
+    int start_x = 0;
+    const double out_of_bells_fraction = 0.1;
+    for(int x = 0; x < hist.size[0]; x++)
+    {
+        quantile_sum += hist.at<float>(x);
+        if(quantile_sum < 0.2*total_sum) continue;
+
+        if(quantile_sum - low_sum > out_of_bells_fraction*total_sum)
+        {
+            if(max_segment_length < x - start_x)
+            {
+                max_segment_length = x - start_x;
+                max_start_x = start_x;
+                max_end_x = x;
+            }
+
+            low_sum = quantile_sum;
+            start_x = x;
+        }
+    }
+
+    if(start_x == -1)
+    {
+        return 0;
+    }
+    else
+    {
+        low_thresh = cvRound(max_start_x + 0.25*(max_end_x - max_start_x));
+        high_thresh = cvRound(max_start_x + 0.75*(max_end_x - max_start_x));
+        return 1;
+    }
+}
+
+bool find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size region_size)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat img = _img.getMat(), cornersM = _corners.getMat();
+    int ncorners = cornersM.checkVector(2, CV_32F);
+    CV_Assert( ncorners >= 0 );
+    Point2f* corners = cornersM.ptr<Point2f>();
+    const int nbins = 256;
+    float ranges[] = {0, 256};
+    const float* _ranges = ranges;
+    Mat hist;
+
+    Mat black_comp, white_comp;
+    for(int i = 0; i < ncorners; i++)
+    {
+        int channels = 0;
+        Rect roi(cvRound(corners[i].x - region_size.width), cvRound(corners[i].y - region_size.height),
+            region_size.width*2 + 1, region_size.height*2 + 1);
+        Mat img_roi = img(roi);
+        calcHist(&img_roi, 1, &channels, Mat(), hist, 1, &nbins, &_ranges);
+
+        int black_thresh = 0, white_thresh = 0;
+        segment_hist_max(hist, black_thresh, white_thresh);
+
+        threshold(img, black_comp, black_thresh, 255.0, THRESH_BINARY_INV);
+        threshold(img, white_comp, white_thresh, 255.0, THRESH_BINARY);
+
+        const int erode_count = 1;
+        erode(black_comp, black_comp, Mat(), Point(-1, -1), erode_count);
+        erode(white_comp, white_comp, Mat(), Point(-1, -1), erode_count);
+
+        std::vector<std::vector<Point> > white_contours, black_contours;
+        findContours(black_comp, black_contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
+        findContours(white_comp, white_contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
+
+        if(black_contours.size() < 5 || white_contours.size() < 5) continue;
+
+        // find two white and black blobs that are close to the input point
+        std::vector<std::pair<int, float> > white_order, black_order;
+        orderContours(black_contours, corners[i], black_order);
+        orderContours(white_contours, corners[i], white_order);
+
+        const float max_dist = 10.0f;
+        if(black_order[0].second > max_dist || black_order[1].second > max_dist ||
+           white_order[0].second > max_dist || white_order[1].second > max_dist)
+        {
+            continue; // there will be no improvement in this corner position
+        }
+
+        const std::vector<Point>* quads[4] = {&black_contours[black_order[0].first], &black_contours[black_order[1].first],
+                                         &white_contours[white_order[0].first], &white_contours[white_order[1].first]};
+        std::vector<Point2f> quads_approx[4];
+        Point2f quad_corners[4];
+        for(int k = 0; k < 4; k++)
+        {
+            std::vector<Point2f> temp;
+            for(size_t j = 0; j < quads[k]->size(); j++) temp.push_back((*quads[k])[j]);
+            approxPolyDP(Mat(temp), quads_approx[k], 0.5, true);
+
+            findCorner(quads_approx[k], corners[i], quad_corners[k]);
+            quad_corners[k] += Point2f(0.5f, 0.5f);
+        }
+
+        // cross two lines
+        Point2f origin1 = quad_corners[0];
+        Point2f dir1 = quad_corners[1] - quad_corners[0];
+        Point2f origin2 = quad_corners[2];
+        Point2f dir2 = quad_corners[3] - quad_corners[2];
+        double angle = std::acos(dir1.dot(dir2)/(norm(dir1)*norm(dir2)));
+        if(cvIsNaN(angle) || cvIsInf(angle) || angle < 0.5 || angle > CV_PI - 0.5) continue;
+
+        findLinesCrossPoint(origin1, dir1, origin2, dir2, corners[i]);
+    }
+
+    return true;
+}
+
+}
diff --git a/upstream/opencv/modules/photo/CMakeLists.txt b/upstream/opencv/modules/photo/CMakeLists.txt
new file mode 100644
index 0000000..81d1e32
--- /dev/null
+++ b/upstream/opencv/modules/photo/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(the_description "Computational Photography")
+
+if(HAVE_CUDA)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations -Wshadow)
+endif()
+
+ocv_define_module(photo opencv_imgproc opencv_geometry OPTIONAL opencv_cudaarithm opencv_cudaimgproc WRAP java objc python js)
+
+if(HAVE_CUDA AND ENABLE_CUDA_FIRST_CLASS_LANGUAGE AND HAVE_opencv_cudaarithm AND HAVE_opencv_cudaimgproc)
+  ocv_target_link_libraries(${the_module} PRIVATE CUDA::cudart${CUDA_LIB_EXT})
+endif()
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo.hpp b/upstream/opencv/modules/photo/include/opencv2/photo.hpp
new file mode 100644
index 0000000..158bc24
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo.hpp
@@ -0,0 +1,967 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_PHOTO_HPP
+#define OPENCV_PHOTO_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/photo/ccm.hpp"
+
+/**
+@defgroup photo Computational Photography
+
+This module includes photo processing algorithms
+@{
+    @defgroup photo_inpaint Inpainting
+    @defgroup photo_denoise Denoising
+    @defgroup photo_hdr HDR imaging
+
+    This section describes high dynamic range imaging algorithms namely tonemapping, exposure alignment,
+    camera calibration with multiple exposures and exposure fusion.
+
+    @defgroup photo_decolor Contrast Preserving Decolorization
+
+    Useful links:
+
+    http://www.cse.cuhk.edu.hk/leojia/projects/color2gray/index.html
+
+    @defgroup photo_clone Seamless Cloning
+
+    Useful links:
+
+    https://www.learnopencv.com/seamless-cloning-using-opencv-python-cpp
+
+    @defgroup photo_render Non-Photorealistic Rendering
+
+    Useful links:
+
+    http://www.inf.ufrgs.br/~eslgastal/DomainTransform
+
+    https://www.learnopencv.com/non-photorealistic-rendering-using-opencv-python-c/
+
+@}
+  */
+
+namespace cv
+{
+
+//! @addtogroup photo
+//! @{
+
+//! @addtogroup photo_inpaint
+//! @{
+//! the inpainting algorithm
+enum
+{
+    INPAINT_NS    = 0, //!< Use Navier-Stokes based method
+    INPAINT_TELEA = 1 //!< Use the algorithm proposed by Alexandru Telea @cite Telea04
+};
+
+/** @brief Restores the selected region in an image using the region neighborhood.
+
+@param src Input 8-bit, 16-bit unsigned or 32-bit float 1-channel or 8-bit 3-channel image.
+@param inpaintMask Inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that
+needs to be inpainted.
+@param dst Output image with the same size and type as src .
+@param inpaintRadius Radius of a circular neighborhood of each point inpainted that is considered
+by the algorithm.
+@param flags Inpainting method that could be cv::INPAINT_NS or cv::INPAINT_TELEA
+
+The function reconstructs the selected image area from the pixel near the area boundary. The
+function may be used to remove dust and scratches from a scanned photo, or to remove undesirable
+objects from still images or video. See <http://en.wikipedia.org/wiki/Inpainting> for more details.
+
+@note
+   -   An example using the inpainting technique can be found at
+        opencv_source_code/samples/cpp/inpaint.cpp
+   -   (Python) An example using the inpainting technique can be found at
+        opencv_source_code/samples/python/inpaint.py
+ */
+CV_EXPORTS_W void inpaint( InputArray src, InputArray inpaintMask,
+        OutputArray dst, double inpaintRadius, int flags );
+
+//! @} photo_inpaint
+
+//! @addtogroup photo_denoise
+//! @{
+
+/** @brief Perform image denoising using Non-local Means Denoising algorithm
+<http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational
+optimizations. Noise expected to be a gaussian white noise
+
+@param src Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
+@param dst Output image with the same size and type as src .
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Parameter regulating filter strength. Big h value perfectly removes noise but also
+removes image details, smaller h value preserves details but also preserves some noise
+
+This function expected to be applied to grayscale images. For colored images look at
+fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored
+image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting
+image to CIELAB colorspace and then separately denoise L and AB components with different h
+parameter.
+ */
+CV_EXPORTS_W void fastNlMeansDenoising( InputArray src, OutputArray dst, float h = 3,
+        int templateWindowSize = 7, int searchWindowSize = 21);
+
+/** @brief Perform image denoising using Non-local Means Denoising algorithm
+<http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational
+optimizations. Noise expected to be a gaussian white noise
+
+@param src Input 8-bit or 16-bit (only with NORM_L1) 1-channel,
+2-channel, 3-channel or 4-channel image.
+@param dst Output image with the same size and type as src .
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Array of parameters regulating filter strength, either one
+parameter applied to all channels or one per channel in dst. Big h value
+perfectly removes noise but also removes image details, smaller h
+value preserves details but also preserves some noise
+@param normType Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1
+
+This function expected to be applied to grayscale images. For colored images look at
+fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored
+image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting
+image to CIELAB colorspace and then separately denoise L and AB components with different h
+parameter.
+ */
+CV_EXPORTS_W void fastNlMeansDenoising( InputArray src, OutputArray dst,
+                                        const std::vector<float>& h,
+                                        int templateWindowSize = 7, int searchWindowSize = 21,
+                                        int normType = NORM_L2);
+
+/** @brief Modification of fastNlMeansDenoising function for colored images
+
+@param src Input 8-bit 3-channel image.
+@param dst Output image with the same size and type as src .
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Parameter regulating filter strength for luminance component. Bigger h value perfectly
+removes noise but also removes image details, smaller h value preserves details but also preserves
+some noise
+@param hColor The same as h but for color components. For most images value equals 10
+will be enough to remove colored noise and do not distort colors
+
+The function converts image to CIELAB colorspace and then separately denoise L and AB components
+with given h parameters using fastNlMeansDenoising function.
+ */
+CV_EXPORTS_W void fastNlMeansDenoisingColored( InputArray src, OutputArray dst,
+        float h = 3, float hColor = 3,
+        int templateWindowSize = 7, int searchWindowSize = 21);
+
+/** @brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been
+captured in small period of time. For example video. This version of the function is for grayscale
+images or for manual manipulation with colorspaces. See @cite Buades2005DenoisingIS for more details
+(open access [here](https://static.aminer.org/pdf/PDF/000/317/196/spatio_temporal_wiener_filtering_of_image_sequences_using_a_parametric.pdf)).
+
+@param srcImgs Input 8-bit 1-channel, 2-channel, 3-channel or
+4-channel images sequence. All images should have the same type and
+size.
+@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
+@param temporalWindowSize Number of surrounding images to use for target image denoising. Should
+be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to
+imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to denoise
+srcImgs[imgToDenoiseIndex] image.
+@param dst Output image with the same size and type as srcImgs images.
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Parameter regulating filter strength. Bigger h value
+perfectly removes noise but also removes image details, smaller h
+value preserves details but also preserves some noise
+ */
+CV_EXPORTS_W void fastNlMeansDenoisingMulti( InputArrayOfArrays srcImgs, OutputArray dst,
+        int imgToDenoiseIndex, int temporalWindowSize,
+        float h = 3, int templateWindowSize = 7, int searchWindowSize = 21);
+
+/** @brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been
+captured in small period of time. For example video. This version of the function is for grayscale
+images or for manual manipulation with colorspaces. See @cite Buades2005DenoisingIS for more details
+(open access [here](https://static.aminer.org/pdf/PDF/000/317/196/spatio_temporal_wiener_filtering_of_image_sequences_using_a_parametric.pdf)).
+
+@param srcImgs Input 8-bit or 16-bit (only with NORM_L1) 1-channel,
+2-channel, 3-channel or 4-channel images sequence. All images should
+have the same type and size.
+@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
+@param temporalWindowSize Number of surrounding images to use for target image denoising. Should
+be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to
+imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to denoise
+srcImgs[imgToDenoiseIndex] image.
+@param dst Output image with the same size and type as srcImgs images.
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Array of parameters regulating filter strength, either one
+parameter applied to all channels or one per channel in dst. Big h value
+perfectly removes noise but also removes image details, smaller h
+value preserves details but also preserves some noise
+@param normType Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1
+ */
+CV_EXPORTS_W void fastNlMeansDenoisingMulti( InputArrayOfArrays srcImgs, OutputArray dst,
+                                             int imgToDenoiseIndex, int temporalWindowSize,
+                                             const std::vector<float>& h,
+                                             int templateWindowSize = 7, int searchWindowSize = 21,
+                                             int normType = NORM_L2);
+
+/** @brief Modification of fastNlMeansDenoisingMulti function for colored images sequences
+
+@param srcImgs Input 8-bit 3-channel images sequence. All images should have the same type and
+size.
+@param imgToDenoiseIndex Target image to denoise index in srcImgs sequence
+@param temporalWindowSize Number of surrounding images to use for target image denoising. Should
+be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to
+imgToDenoiseIndex + temporalWindowSize / 2 from srcImgs will be used to denoise
+srcImgs[imgToDenoiseIndex] image.
+@param dst Output image with the same size and type as srcImgs images.
+@param templateWindowSize Size in pixels of the template patch that is used to compute weights.
+Should be odd. Recommended value 7 pixels
+@param searchWindowSize Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater
+denoising time. Recommended value 21 pixels
+@param h Parameter regulating filter strength for luminance component. Bigger h value perfectly
+removes noise but also removes image details, smaller h value preserves details but also preserves
+some noise.
+@param hColor The same as h but for color components.
+
+The function converts images to CIELAB colorspace and then separately denoise L and AB components
+with given h parameters using fastNlMeansDenoisingMulti function.
+ */
+CV_EXPORTS_W void fastNlMeansDenoisingColoredMulti( InputArrayOfArrays srcImgs, OutputArray dst,
+        int imgToDenoiseIndex, int temporalWindowSize,
+        float h = 3, float hColor = 3,
+        int templateWindowSize = 7, int searchWindowSize = 21);
+
+/** @brief Primal-dual algorithm is an algorithm for solving special types of variational problems (that is,
+finding a function to minimize some functional). As the image denoising, in particular, may be seen
+as the variational problem, primal-dual algorithm then can be used to perform denoising and this is
+exactly what is implemented.
+
+It should be noted, that this implementation was taken from the July 2013 blog entry
+@cite MA13 , which also contained (slightly more general) ready-to-use source code on Python.
+Subsequently, that code was rewritten on C++ with the usage of openCV by Vadim Pisarevsky at the end
+of July 2013 and finally it was slightly adapted by later authors.
+
+Although the thorough discussion and justification of the algorithm involved may be found in
+@cite ChambolleEtAl, it might make sense to skim over it here, following @cite MA13 . To begin
+with, we consider the 1-byte gray-level images as the functions from the rectangular domain of
+pixels (it may be seen as set
+\f$\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\}\f$ for some
+\f$m,\;n\in\mathbb{N}\f$) into \f$\{0,1,\dots,255\}\f$. We shall denote the noised images as \f$f_i\f$ and with
+this view, given some image \f$x\f$ of the same size, we may measure how bad it is by the formula
+
+\f[\left\|\left\|\nabla x\right\|\right\| + \lambda\sum_i\left\|\left\|x-f_i\right\|\right\|\f]
+
+\f$\|\|\cdot\|\|\f$ here denotes \f$L_2\f$-norm and as you see, the first addend states that we want our
+image to be smooth (ideally, having zero gradient, thus being constant) and the second states that
+we want our result to be close to the observations we've got. If we treat \f$x\f$ as a function, this is
+exactly the functional what we seek to minimize and here the Primal-Dual algorithm comes into play.
+
+@param observations This array should contain one or more noised versions of the image that is to
+be restored.
+@param result Here the denoised image will be stored. There is no need to do pre-allocation of
+storage space, as it will be automatically allocated, if necessary.
+@param lambda Corresponds to \f$\lambda\f$ in the formulas above. As it is enlarged, the smooth
+(blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly
+speaking, as it becomes smaller, the result will be more blur but more sever outliers will be
+removed.
+@param niters Number of iterations that the algorithm will run. Of course, as more iterations as
+better, but it is hard to quantitatively refine this statement, so just use the default and
+increase it if the results are poor.
+ */
+CV_EXPORTS_W void denoise_TVL1(const std::vector<Mat>& observations,Mat& result, double lambda=1.0, int niters=30);
+
+//! @} photo_denoise
+
+//! @addtogroup photo_hdr
+//! @{
+
+enum { LDR_SIZE = 256 };
+
+/** @brief Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
+ */
+class CV_EXPORTS_W Tonemap : public Algorithm
+{
+public:
+    /** @brief Tonemaps image
+
+    @param src source image - CV_32FC3 Mat (float 32 bits 3 channels)
+    @param dst destination image - CV_32FC3 Mat with values in [0, 1] range
+     */
+    CV_WRAP virtual void process(InputArray src, OutputArray dst) = 0;
+
+    CV_WRAP virtual float getGamma() const = 0;
+    CV_WRAP virtual void setGamma(float gamma) = 0;
+};
+
+/** @brief Creates simple linear mapper with gamma correction
+
+@param gamma positive value for gamma correction. Gamma value of 1.0 implies no correction, gamma
+equal to 2.2f is suitable for most displays.
+Generally gamma \> 1 brightens the image and gamma \< 1 darkens it.
+ */
+CV_EXPORTS_W Ptr<Tonemap> createTonemap(float gamma = 1.0f);
+
+/** @brief Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in
+logarithmic domain.
+
+Since it's a global operator the same function is applied to all the pixels, it is controlled by the
+bias parameter.
+
+Optional saturation enhancement is possible as described in @cite FL02 .
+
+For more information see @cite DM03 .
+ */
+class CV_EXPORTS_W TonemapDrago : public Tonemap
+{
+public:
+
+    CV_WRAP virtual float getSaturation() const = 0;
+    CV_WRAP virtual void setSaturation(float saturation) = 0;
+
+    CV_WRAP virtual float getBias() const = 0;
+    CV_WRAP virtual void setBias(float bias) = 0;
+};
+
+/** @brief Creates TonemapDrago object
+
+@param gamma gamma value for gamma correction. See createTonemap
+@param saturation positive saturation enhancement value. 1.0 preserves saturation, values greater
+than 1 increase saturation and values less than 1 decrease it.
+@param bias value for bias function in [0, 1] range. Values from 0.7 to 0.9 usually give best
+results, default value is 0.85.
+ */
+CV_EXPORTS_W Ptr<TonemapDrago> createTonemapDrago(float gamma = 1.0f, float saturation = 1.0f, float bias = 0.85f);
+
+
+/** @brief This is a global tonemapping operator that models human visual system.
+
+Mapping function is controlled by adaptation parameter, that is computed using light adaptation and
+color adaptation.
+
+For more information see @cite RD05 .
+ */
+class CV_EXPORTS_W TonemapReinhard : public Tonemap
+{
+public:
+    CV_WRAP virtual float getIntensity() const = 0;
+    CV_WRAP virtual void setIntensity(float intensity) = 0;
+
+    CV_WRAP virtual float getLightAdaptation() const = 0;
+    CV_WRAP virtual void setLightAdaptation(float light_adapt) = 0;
+
+    CV_WRAP virtual float getColorAdaptation() const = 0;
+    CV_WRAP virtual void setColorAdaptation(float color_adapt) = 0;
+};
+
+/** @brief Creates TonemapReinhard object
+
+@param gamma gamma value for gamma correction. See createTonemap
+@param intensity result intensity in [-8, 8] range. Greater intensity produces brighter results.
+@param light_adapt light adaptation in [0, 1] range. If 1 adaptation is based only on pixel
+value, if 0 it's global, otherwise it's a weighted mean of this two cases.
+@param color_adapt chromatic adaptation in [0, 1] range. If 1 channels are treated independently,
+if 0 adaptation level is the same for each channel.
+ */
+CV_EXPORTS_W Ptr<TonemapReinhard>
+createTonemapReinhard(float gamma = 1.0f, float intensity = 0.0f, float light_adapt = 1.0f, float color_adapt = 0.0f);
+
+/** @brief This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid,
+transforms contrast values to HVS response and scales the response. After this the image is
+reconstructed from new contrast values.
+
+For more information see @cite MM06 .
+ */
+class CV_EXPORTS_W TonemapMantiuk : public Tonemap
+{
+public:
+    CV_WRAP virtual float getScale() const = 0;
+    CV_WRAP virtual void setScale(float scale) = 0;
+
+    CV_WRAP virtual float getSaturation() const = 0;
+    CV_WRAP virtual void setSaturation(float saturation) = 0;
+};
+
+/** @brief Creates TonemapMantiuk object
+
+@param gamma gamma value for gamma correction. See createTonemap
+@param scale contrast scale factor. HVS response is multiplied by this parameter, thus compressing
+dynamic range. Values from 0.6 to 0.9 produce best results.
+@param saturation saturation enhancement value. See createTonemapDrago
+ */
+CV_EXPORTS_W Ptr<TonemapMantiuk>
+createTonemapMantiuk(float gamma = 1.0f, float scale = 0.7f, float saturation = 1.0f);
+
+/** @brief The base class for algorithms that align images of the same scene with different exposures
+ */
+class CV_EXPORTS_W AlignExposures : public Algorithm
+{
+public:
+    /** @brief Aligns images
+
+    @param src vector of input images
+    @param dst vector of aligned images
+    @param times vector of exposure time values for each image
+    @param response 256x1 matrix with inverse camera response function for each pixel value, it should
+    have the same number of channels as images.
+     */
+    CV_WRAP virtual void process(InputArrayOfArrays src, std::vector<Mat>& dst,
+                                 InputArray times, InputArray response) = 0;
+};
+
+/** @brief This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median
+luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations.
+
+It is invariant to exposure, so exposure values and camera response are not necessary.
+
+In this implementation new image regions are filled with zeros.
+
+For more information see @cite GW03 .
+ */
+class CV_EXPORTS_W AlignMTB : public AlignExposures
+{
+public:
+    CV_WRAP virtual void process(InputArrayOfArrays src, std::vector<Mat>& dst,
+                                 InputArray times, InputArray response) CV_OVERRIDE = 0;
+
+    /** @brief Short version of process, that doesn't take extra arguments.
+
+    @param src vector of input images
+    @param dst vector of aligned images
+     */
+    CV_WRAP virtual void process(InputArrayOfArrays src, std::vector<Mat>& dst) = 0;
+
+    /** @brief Calculates shift between two images, i. e. how to shift the second image to correspond it with the
+    first.
+
+    @param img0 first image
+    @param img1 second image
+     */
+    CV_WRAP virtual Point calculateShift(InputArray img0, InputArray img1) = 0;
+    /** @brief Helper function, that shift Mat filling new regions with zeros.
+
+    @param src input image
+    @param dst result image
+    @param shift shift value
+     */
+    CV_WRAP virtual void shiftMat(InputArray src, OutputArray dst, const Point shift) = 0;
+    /** @brief Computes median threshold and exclude bitmaps of given image.
+
+    @param img input image
+    @param tb median threshold bitmap
+    @param eb exclude bitmap
+     */
+    CV_WRAP virtual void computeBitmaps(InputArray img, OutputArray tb, OutputArray eb) = 0;
+
+    CV_WRAP virtual int getMaxBits() const = 0;
+    CV_WRAP virtual void setMaxBits(int max_bits) = 0;
+
+    CV_WRAP virtual int getExcludeRange() const = 0;
+    CV_WRAP virtual void setExcludeRange(int exclude_range) = 0;
+
+    CV_WRAP virtual bool getCut() const = 0;
+    CV_WRAP virtual void setCut(bool value) = 0;
+};
+
+/** @brief Creates AlignMTB object
+
+@param max_bits logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are
+usually good enough (31 and 63 pixels shift respectively).
+@param exclude_range range for exclusion bitmap that is constructed to suppress noise around the
+median value.
+@param cut if true cuts images, otherwise fills the new regions with zeros.
+ */
+CV_EXPORTS_W Ptr<AlignMTB> createAlignMTB(int max_bits = 6, int exclude_range = 4, bool cut = true);
+
+/** @brief The base class for camera response calibration algorithms.
+ */
+class CV_EXPORTS_W CalibrateCRF : public Algorithm
+{
+public:
+    /** @brief Recovers inverse camera response.
+
+    @param src vector of input images
+    @param dst 256x1 matrix with inverse camera response function
+    @param times vector of exposure time values for each image
+     */
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst, InputArray times) = 0;
+};
+
+/** @brief Inverse camera response function is extracted for each brightness value by minimizing an objective
+function as linear system. Objective function is constructed using pixel values on the same position
+in all images, extra term is added to make the result smoother.
+
+For more information see @cite DM97 .
+ */
+class CV_EXPORTS_W CalibrateDebevec : public CalibrateCRF
+{
+public:
+    CV_WRAP virtual float getLambda() const = 0;
+    CV_WRAP virtual void setLambda(float lambda) = 0;
+
+    CV_WRAP virtual int getSamples() const = 0;
+    CV_WRAP virtual void setSamples(int samples) = 0;
+
+    CV_WRAP virtual bool getRandom() const = 0;
+    CV_WRAP virtual void setRandom(bool random) = 0;
+};
+
+/** @brief Creates CalibrateDebevec object
+
+@param samples number of pixel locations to use
+@param lambda smoothness term weight. Greater values produce smoother results, but can alter the
+response.
+@param random if true sample pixel locations are chosen at random, otherwise they form a
+rectangular grid.
+ */
+CV_EXPORTS_W Ptr<CalibrateDebevec> createCalibrateDebevec(int samples = 70, float lambda = 10.0f, bool random = false);
+
+/** @brief Inverse camera response function is extracted for each brightness value by minimizing an objective
+function as linear system. This algorithm uses all image pixels.
+
+For more information see @cite RB99 .
+ */
+class CV_EXPORTS_W CalibrateRobertson : public CalibrateCRF
+{
+public:
+    CV_WRAP virtual int getMaxIter() const = 0;
+    CV_WRAP virtual void setMaxIter(int max_iter) = 0;
+
+    CV_WRAP virtual float getThreshold() const = 0;
+    CV_WRAP virtual void setThreshold(float threshold) = 0;
+
+    CV_WRAP virtual Mat getRadiance() const = 0;
+};
+
+/** @brief Creates CalibrateRobertson object
+
+@param max_iter maximal number of Gauss-Seidel solver iterations.
+@param threshold target difference between results of two successive steps of the minimization.
+ */
+CV_EXPORTS_W Ptr<CalibrateRobertson> createCalibrateRobertson(int max_iter = 30, float threshold = 0.01f);
+
+/** @brief The base class algorithms that can merge exposure sequence to a single image.
+ */
+class CV_EXPORTS_W MergeExposures : public Algorithm
+{
+public:
+    /** @brief Merges images.
+
+    @param src vector of input images
+    @param dst result image
+    @param times vector of exposure time values for each image
+    @param response 256x1 matrix with inverse camera response function for each pixel value, it should
+    have the same number of channels as images.
+     */
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
+                                 InputArray times, InputArray response) = 0;
+};
+
+/** @brief The resulting HDR image is calculated as weighted average of the exposures considering exposure
+values and camera response.
+
+For more information see @cite DM97 .
+ */
+class CV_EXPORTS_W MergeDebevec : public MergeExposures
+{
+public:
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
+                                 InputArray times, InputArray response) CV_OVERRIDE = 0;
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst, InputArray times) = 0;
+};
+
+/** @brief Creates MergeDebevec object
+ */
+CV_EXPORTS_W Ptr<MergeDebevec> createMergeDebevec();
+
+/** @brief Pixels are weighted using contrast, saturation and well-exposedness measures, than images are
+combined using laplacian pyramids.
+
+The resulting image weight is constructed as weighted average of contrast, saturation and
+well-exposedness measures.
+
+The resulting image doesn't require tonemapping and can be converted to 8-bit image by multiplying
+by 255, but it's recommended to apply gamma correction and/or linear tonemapping.
+
+For more information see @cite MK07 .
+ */
+class CV_EXPORTS_W MergeMertens : public MergeExposures
+{
+public:
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
+                                 InputArray times, InputArray response) CV_OVERRIDE = 0;
+    /** @brief Short version of process, that doesn't take extra arguments.
+
+    @param src vector of input images
+    @param dst result image
+     */
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst) = 0;
+
+    CV_WRAP virtual float getContrastWeight() const = 0;
+    CV_WRAP virtual void setContrastWeight(float contrast_weiht) = 0;
+
+    CV_WRAP virtual float getSaturationWeight() const = 0;
+    CV_WRAP virtual void setSaturationWeight(float saturation_weight) = 0;
+
+    CV_WRAP virtual float getExposureWeight() const = 0;
+    CV_WRAP virtual void setExposureWeight(float exposure_weight) = 0;
+};
+
+/** @brief Creates MergeMertens object
+
+@param contrast_weight contrast measure weight. See MergeMertens.
+@param saturation_weight saturation measure weight
+@param exposure_weight well-exposedness measure weight
+ */
+CV_EXPORTS_W Ptr<MergeMertens>
+createMergeMertens(float contrast_weight = 1.0f, float saturation_weight = 1.0f, float exposure_weight = 0.0f);
+
+/** @brief The resulting HDR image is calculated as weighted average of the exposures considering exposure
+values and camera response.
+
+For more information see @cite RB99 .
+ */
+class CV_EXPORTS_W MergeRobertson : public MergeExposures
+{
+public:
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst,
+                                 InputArray times, InputArray response) CV_OVERRIDE = 0;
+    CV_WRAP virtual void process(InputArrayOfArrays src, OutputArray dst, InputArray times) = 0;
+};
+
+/** @brief Creates MergeRobertson object
+ */
+CV_EXPORTS_W Ptr<MergeRobertson> createMergeRobertson();
+
+//! @} photo_hdr
+
+//! @addtogroup photo_decolor
+//! @{
+
+/** @brief Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized
+black-and-white photograph rendering, and in many single channel image processing applications
+@cite CL12 .
+
+@param src Input 8-bit 3-channel image.
+@param grayscale Output 8-bit 1-channel image.
+@param color_boost Output 8-bit 3-channel image.
+
+This function is to be applied on color images.
+ */
+CV_EXPORTS_W void decolor( InputArray src, OutputArray grayscale, OutputArray color_boost);
+
+//! @} photo_decolor
+
+//! @addtogroup photo_clone
+//! @{
+
+
+//! Flags for the seamlessClone algorithm
+enum SeamlessCloneFlags
+{
+    /**
+    @brief Normal seamless cloning.
+    This method is ideal for inserting objects with complex outlines into a new background.
+    It preserves the original appearance and lighting of the inserted object, ensuring a natural blend.
+     */
+    NORMAL_CLONE = 1,
+
+    /**
+    @brief Mixed seamless cloning.
+    This method addresses cases where simple color-based selection or alpha masking is time-consuming
+    and may result in undesirable halos. By combining structure from the source and texture from the
+    destination, mixed seamless cloning is highly effective, even with loosely defined selections.
+     */
+    MIXED_CLONE = 2,
+
+    /**
+    @brief Monochrome transfer cloning.
+    This method allows users to replace specific features of an object, such as grayscale textures
+    or patterns, with alternative features. It is particularly useful for artistic effects or
+    targeted object modifications.
+     */
+    MONOCHROME_TRANSFER = 3,
+
+    /**
+    @brief Enhanced normal seamless cloning.
+    Similar to `NORMAL_CLONE`, but with an advanced approach to ROI (Region of Interest) calculation.
+    This mode processes a larger source region by considering the entire mask area instead of only
+    the bounding rectangle of non-zero pixels.
+     */
+    NORMAL_CLONE_WIDE = 9,
+
+    /**
+    @brief Enhanced mixed seamless cloning.
+    Similar to `MIXED_CLONE`, but with an advanced approach to ROI (Region of Interest) calculation.
+    This mode processes a larger source region by considering the entire mask area instead of only
+    the bounding rectangle of non-zero pixels.
+     */
+    MIXED_CLONE_WIDE = 10,
+
+    /**
+    @brief Enhanced monochrome transfer cloning.
+    Similar to `MONOCHROME_TRANSFER`, but with an advanced approach to ROI (Region of Interest) calculation.
+    This mode processes a larger source region by considering the entire mask area instead of only
+    the bounding rectangle of non-zero pixels.
+     */
+    MONOCHROME_TRANSFER_WIDE = 11
+};
+
+
+/** @example samples/cpp/tutorial_code/photo/seamless_cloning/cloning_demo.cpp
+An example using seamlessClone function
+*/
+/** @example samples/cpp/snippets/cloning_demo.cpp
+An example using illuminationChange, colorChange, seamlessClone, textureFlattening functions
+*/
+/** @brief Performs seamless cloning to blend a region from a source image into a destination image.
+This function is designed for local image editing, allowing changes restricted to a region
+(manually selected as the ROI) to be applied effortlessly and seamlessly. These changes can
+range from slight distortions to complete replacement by novel content @cite PM03.
+
+@param src The source image (8-bit 3-channel), from which a region will be blended into the destination.
+@param dst The destination image (8-bit 3-channel), where the src image will be blended.
+@param mask A binary mask (8-bit, 1, 3, or 4-channel) specifying the region in the source image to blend.
+Non-zero pixels indicate the region to be blended. If an empty Mat is provided, a mask with
+all non-zero pixels is created internally.
+@param p The point where the center of the src image is placed in the dst image.
+@param blend The output image that stores the result of the seamless cloning. It has the same size and type as `dst`.
+@param flags Flags that control the type of cloning method, can take values of `cv::SeamlessCloneFlags`.
+ */
+CV_EXPORTS_W void seamlessClone( InputArray src, InputArray dst, InputArray mask, Point p,
+        OutputArray blend, int flags);
+
+/** @brief Given an original color image, two differently colored versions of this image can be mixed
+seamlessly.
+
+@param src Input 8-bit 3-channel image.
+@param mask Input 8-bit 1 or 3-channel image.
+@param dst Output image with the same size and type as src .
+@param red_mul R-channel multiply factor.
+@param green_mul G-channel multiply factor.
+@param blue_mul B-channel multiply factor.
+
+Multiplication factor is between .5 to 2.5.
+ */
+CV_EXPORTS_W void colorChange(InputArray src, InputArray mask, OutputArray dst, float red_mul = 1.0f,
+        float green_mul = 1.0f, float blue_mul = 1.0f);
+
+/** @brief Applying an appropriate non-linear transformation to the gradient field inside the selection and
+then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.
+
+@param src Input 8-bit 3-channel image.
+@param mask Input 8-bit 1 or 3-channel image.
+@param dst Output image with the same size and type as src.
+@param alpha Value ranges between 0-2.
+@param beta Value ranges between 0-2.
+
+This is useful to highlight under-exposed foreground objects or to reduce specular reflections.
+ */
+CV_EXPORTS_W void illuminationChange(InputArray src, InputArray mask, OutputArray dst,
+        float alpha = 0.2f, float beta = 0.4f);
+
+/** @brief By retaining only the gradients at edge locations, before integrating with the Poisson solver, one
+washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge %Detector is used.
+
+@param src Input 8-bit 3-channel image.
+@param mask Input 8-bit 1 or 3-channel image.
+@param dst Output image with the same size and type as src.
+@param low_threshold %Range from 0 to 100.
+@param high_threshold Value \> 100.
+@param kernel_size The size of the Sobel kernel to be used.
+
+@note
+The algorithm assumes that the color of the source image is close to that of the destination. This
+assumption means that when the colors don't match, the source image color gets tinted toward the
+color of the destination image.
+ */
+CV_EXPORTS_W void textureFlattening(InputArray src, InputArray mask, OutputArray dst,
+        float low_threshold = 30, float high_threshold = 45,
+        int kernel_size = 3);
+
+//! @} photo_clone
+
+//! @addtogroup photo_render
+//! @{
+
+//! Edge preserving filters
+enum
+{
+    RECURS_FILTER = 1, //!< Recursive Filtering
+    NORMCONV_FILTER = 2 //!< Normalized Convolution Filtering
+};
+
+/** @brief Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing
+filters are used in many different applications @cite EM11 .
+
+@param src Input 8-bit 3-channel image.
+@param dst Output 8-bit 3-channel image.
+@param flags Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
+@param sigma_s %Range between 0 to 200.
+@param sigma_r %Range between 0 to 1.
+ */
+CV_EXPORTS_W void edgePreservingFilter(InputArray src, OutputArray dst, int flags = 1,
+        float sigma_s = 60, float sigma_r = 0.4f);
+
+/** @brief This filter enhances the details of a particular image.
+
+@param src Input 8-bit 3-channel image.
+@param dst Output image with the same size and type as src.
+@param sigma_s %Range between 0 to 200.
+@param sigma_r %Range between 0 to 1.
+ */
+CV_EXPORTS_W void detailEnhance(InputArray src, OutputArray dst, float sigma_s = 10,
+        float sigma_r = 0.15f);
+
+/** @example samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp
+An example using non-photorealistic line drawing functions
+*/
+/** @brief Pencil-like non-photorealistic line drawing
+
+@param src Input 8-bit 3-channel image.
+@param dst1 Output 8-bit 1-channel image.
+@param dst2 Output image with the same size and type as src.
+@param sigma_s %Range between 0 to 200.
+@param sigma_r %Range between 0 to 1.
+@param shade_factor %Range between 0 to 0.1.
+ */
+CV_EXPORTS_W void pencilSketch(InputArray src, OutputArray dst1, OutputArray dst2,
+        float sigma_s = 60, float sigma_r = 0.07f, float shade_factor = 0.02f);
+
+/** @brief Stylization aims to produce digital imagery with a wide variety of effects not focused on
+photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low
+contrast while preserving, or enhancing, high-contrast features.
+
+@param src Input 8-bit 3-channel image.
+@param dst Output image with the same size and type as src.
+@param sigma_s %Range between 0 to 200.
+@param sigma_r %Range between 0 to 1.
+ */
+CV_EXPORTS_W void stylization(InputArray src, OutputArray dst, float sigma_s = 60,
+        float sigma_r = 0.45f);
+
+//! @} photo_render
+
+//! @addtogroup photo_ca_correction Chromatic Aberration Correction
+//! @{
+
+/** @example samples/cpp/snippets/chromatic_aberration_correction.cpp
+An example correcting chromatic aberration with C++
+*/
+/** @example samples/python/snippets/chromatic_aberration_correction.py
+ * An example correcting chromatic aberration with Python
+ */
+/** @brief Corrects lateral chromatic aberration in an image using polynomial distortion model.
+
+This function loads polynomial calibration data from the specified file and applies
+a channel‐specific warp to remove chromatic aberration.
+If @p input_image has one channel, it is assumed to be a raw Bayer image and is
+first demosaiced using @p bayer_pattern. If it has three channels, it is treated
+as a BGR image and @p bayer_pattern is ignored.
+
+Firstly, calibration needs to be done using apps/chromatic-aberration-calibration/ca_calibration.py on a photo of
+a pattern of black discs on white background, included in opencv_extra/testdata/cv/cameracalibration/chromatic_aberration/chromatic_aberration_pattern_a3.png
+
+Calibration and correction are based on the algorithm described in @cite rudakova2013precise.
+The chromatic aberration is modeled as a polynomial of some degree in red and blue channels compared to green.
+In calibration, a photo of many black discs on white background is used, and the displacements
+between the centres of discs in red and blue channels compared to green are minimized. The coefficients
+are then saved in a yaml file which can be used with this function to correct lateral chromatic aberration.
+
+@param input_image Input BGR image to correct
+@param coefficients Coefficient model
+@param output_image Corrected BGR image
+@param image_size Size of images for the calibration coefficient model
+@param calib_degree Degree of the calibration coefficient model
+@param bayer_pattern Bayer pattern code (e.g. cv::COLOR_BayerBG2BGR) used for
+demosaicing when @p input_image has one channel; ignored otherwise.
+
+@sa loadChromaticAberrationParams, demosaicing
+*/
+CV_EXPORTS_W void correctChromaticAberration(InputArray input_image, InputArray coefficients, OutputArray output_image,
+                                             const Size& image_size, int calib_degree, int bayer_pattern = -1);
+
+/** @brief Load chromatic-aberration calibration parameters from opened FileStorage.
+ *
+ R e*ads the red and blue polynomial coefficients from the specified file and
+ packs them into a 4×N CV_32F matrix:
+ row 0 = blue dx coefficients
+ row 1 = blue dy coefficients
+ row 2 = red  dx coefficients
+ row 3 = red  dy coefficients
+
+ @param node       Node of opened cv::FileStorage object.
+ @param coeffMat   Output 4xN coefficient matrix (CV_32F).
+ @param degree     Polynomial degree inferred from N.
+ @param calib_size Calibration image size read from file.
+
+ @sa correctChromaticAberration
+ */
+CV_EXPORTS_W void loadChromaticAberrationParams(
+    const FileNode& node,
+    OutputArray coeffMat,
+    CV_OUT Size& calib_size,
+    CV_OUT int& degree);
+
+//! @} photo_ca_correction
+
+//! @} photo
+
+} // cv
+
+#include "./photo/segmentation.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo/ccm.hpp b/upstream/opencv/modules/photo/include/opencv2/photo/ccm.hpp
new file mode 100644
index 0000000..411ca5a
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo/ccm.hpp
@@ -0,0 +1,322 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef OPENCV_PHOTO_CCM_HPP
+#define OPENCV_PHOTO_CCM_HPP
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+namespace cv
+{
+namespace ccm
+{
+
+/** @defgroup ccm Color Correction module
+@{
+*/
+
+/** @brief Enum of the possible types of ccm.
+*/
+enum CcmType
+{
+    CCM_LINEAR,   ///< Uses a \f$3\times3\f$ matrix to linearly transform RGB values without offsets.
+    CCM_AFFINE,   ///< Uses a \f$4\times3\f$ matrix to affine transform RGB values with both scaling and offset terms.
+};
+
+/** @brief Enum of the possible types of initial method.
+*/
+enum InitialMethodType
+{
+    INITIAL_METHOD_WHITE_BALANCE,      ///< The white balance method. The initial value is:\n
+                                       /// \f$
+                                       /// M_{CCM}=
+                                       /// \begin{bmatrix}
+                                       /// k_R & 0 & 0\\
+                                       /// 0 & k_G & 0\\
+                                       /// 0 & 0 & k_B\\
+                                       /// \end{bmatrix}
+                                       /// \f$\n
+                                       /// where\n
+                                       /// \f$
+                                       /// k_R=mean(R_{li}')/mean(R_{li})\\
+                                       /// k_G=mean(G_{li}')/mean(G_{li})\\
+                                       /// k_B=mean(B_{li}')/mean(B_{li})
+                                       /// \f$
+    INITIAL_METHOD_LEAST_SQUARE,       ///< The least square method is an optimal solution under the linear RGB distance function
+};
+/** @brief  Macbeth and Vinyl ColorChecker with 2deg D50
+*/
+enum ColorCheckerType {
+    COLORCHECKER_MACBETH,                ///< Macbeth ColorChecker
+    COLORCHECKER_VINYL,                  ///< DKK ColorChecker
+    COLORCHECKER_DIGITAL_SG,              ///< DigitalSG ColorChecker with 140 squares
+};
+enum ColorSpace {
+    COLOR_SPACE_SRGB,                       ///< https://en.wikipedia.org/wiki/SRGB , RGB color space
+    COLOR_SPACE_SRGBL,                      ///< https://en.wikipedia.org/wiki/SRGB , linear RGB color space
+    COLOR_SPACE_ADOBE_RGB,                  ///< https://en.wikipedia.org/wiki/Adobe_RGB_color_space , RGB color space
+    COLOR_SPACE_ADOBE_RGBL,                 ///< https://en.wikipedia.org/wiki/Adobe_RGB_color_space , linear RGB color space
+    COLOR_SPACE_WIDE_GAMUT_RGB,             ///< https://en.wikipedia.org/wiki/Wide-gamut_RGB_color_space , RGB color space
+    COLOR_SPACE_WIDE_GAMUT_RGBL,            ///< https://en.wikipedia.org/wiki/Wide-gamut_RGB_color_space , linear RGB color space
+    COLOR_SPACE_PRO_PHOTO_RGB,              ///< https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space , RGB color space
+    COLOR_SPACE_PRO_PHOTO_RGBL,             ///< https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space , linear RGB color space
+    COLOR_SPACE_DCI_P3_RGB,                 ///< https://en.wikipedia.org/wiki/DCI-P3 , RGB color space
+    COLOR_SPACE_DCI_P3_RGBL,                ///< https://en.wikipedia.org/wiki/DCI-P3 , linear RGB color space
+    COLOR_SPACE_APPLE_RGB,                  ///< http://www.brucelindbloom.com/index.html?WorkingSpaceInfo.html , RGB color space
+    COLOR_SPACE_APPLE_RGBL,                 ///< http://www.brucelindbloom.com/index.html?WorkingSpaceInfo.html , linear RGB color space
+    COLOR_SPACE_REC_709_RGB,                ///< https://en.wikipedia.org/wiki/Rec._709 , RGB color space
+    COLOR_SPACE_REC_709_RGBL,               ///< https://en.wikipedia.org/wiki/Rec._709 , linear RGB color space
+    COLOR_SPACE_REC_2020_RGB,               ///< https://en.wikipedia.org/wiki/Rec._2020 , RGB color space
+    COLOR_SPACE_REC_2020_RGBL,              ///< https://en.wikipedia.org/wiki/Rec._2020 , linear RGB color space
+    COLOR_SPACE_XYZ_D65_2,                  ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D65 illuminant, 2 degree
+    COLOR_SPACE_XYZ_D50_2,                  ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D50 illuminant, 2 degree
+    COLOR_SPACE_XYZ_D65_10,                 ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D65 illuminant, 10 degree
+    COLOR_SPACE_XYZ_D50_10,                 ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D50 illuminant, 10 degree
+    COLOR_SPACE_XYZ_A_2,                    ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, A illuminant, 2 degree
+    COLOR_SPACE_XYZ_A_10,                   ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, A illuminant, 10 degree
+    COLOR_SPACE_XYZ_D55_2,                  ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D55 illuminant, 2 degree
+    COLOR_SPACE_XYZ_D55_10,                 ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D55 illuminant, 10 degree
+    COLOR_SPACE_XYZ_D75_2,                  ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D75 illuminant, 2 degree
+    COLOR_SPACE_XYZ_D75_10,                 ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, D75 illuminant, 10 degree
+    COLOR_SPACE_XYZ_E_2,                    ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, E illuminant, 2 degree
+    COLOR_SPACE_XYZ_E_10,                   ///< https://en.wikipedia.org/wiki/CIE_1931_color_space , XYZ color space, E illuminant, 10 degree
+    COLOR_SPACE_LAB_D65_2,                  ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D65 illuminant, 2 degree
+    COLOR_SPACE_LAB_D50_2,                  ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D50 illuminant, 2 degree
+    COLOR_SPACE_LAB_D65_10,                 ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D65 illuminant, 10 degree
+    COLOR_SPACE_LAB_D50_10,                 ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D50 illuminant, 10 degree
+    COLOR_SPACE_LAB_A_2,                    ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, A illuminant, 2 degree
+    COLOR_SPACE_LAB_A_10,                   ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, A illuminant, 10 degree
+    COLOR_SPACE_LAB_D55_2,                  ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D55 illuminant, 2 degree
+    COLOR_SPACE_LAB_D55_10,                 ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D55 illuminant, 10 degree
+    COLOR_SPACE_LAB_D75_2,                  ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D75 illuminant, 2 degree
+    COLOR_SPACE_LAB_D75_10,                 ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, D75 illuminant, 10 degree
+    COLOR_SPACE_LAB_E_2,                    ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, E illuminant, 2 degree
+    COLOR_SPACE_LAB_E_10                    ///< https://en.wikipedia.org/wiki/CIELAB_color_space , Lab color space, E illuminant, 10 degree
+};
+
+/** @brief Linearization transformation type
+*/
+enum LinearizationType
+{
+
+    LINEARIZATION_IDENTITY,                  ///<no change is made
+    LINEARIZATION_GAMMA,                      ///<gamma correction; Need assign a value to gamma simultaneously
+    LINEARIZATION_COLORPOLYFIT,               ///<polynomial fitting channels respectively; Need assign a value to deg simultaneously
+    LINEARIZATION_COLORLOGPOLYFIT,            ///<logarithmic polynomial fitting channels respectively; Need assign a value to deg simultaneously
+    LINEARIZATION_GRAYPOLYFIT,                ///<grayscale polynomial fitting; Need assign a value to deg and dst_whites simultaneously
+    LINEARIZATION_GRAYLOGPOLYFIT              ///<grayscale Logarithmic polynomial fitting;  Need assign a value to deg and dst_whites simultaneously
+};
+
+/** @brief Enum of possible functions to calculate the distance between colors.
+
+See https://en.wikipedia.org/wiki/Color_difference for details
+*/
+enum DistanceType
+{
+    DISTANCE_CIE76,                      ///<The 1976 formula is the first formula that related a measured color difference to a known set of CIELAB coordinates.
+    DISTANCE_CIE94_GRAPHIC_ARTS,         ///<The 1976 definition was extended to address perceptual non-uniformities.
+    DISTANCE_CIE94_TEXTILES,
+    DISTANCE_CIE2000,
+    DISTANCE_CMC_1TO1,                   ///<In 1984, the Colour Measurement Committee of the Society of Dyers and Colourists defined a difference measure, also based on the L*C*h color model.
+    DISTANCE_CMC_2TO1,
+    DISTANCE_RGB,                        ///<Euclidean distance of rgb color space
+    DISTANCE_RGBL                        ///<Euclidean distance of rgbl color space
+};
+
+/**
+ * @brief Applies gamma correction to the input image.
+ * @param src Input image.
+ * @param dst Output image.
+ * @param gamma Gamma correction greater than zero.
+ */
+CV_EXPORTS_W void gammaCorrection(InputArray src, OutputArray dst, double gamma);
+
+/** @brief Core class of ccm model
+
+Produce a ColorCorrectionModel instance for inference
+*/
+class CV_EXPORTS_W ColorCorrectionModel
+{
+public:
+    CV_WRAP ColorCorrectionModel();
+
+    /** @brief Color Correction Model
+
+        Supported list of color cards:
+        - @ref COLORCHECKER_MACBETH, the Macbeth ColorChecker
+        - @ref COLORCHECKER_VINYL, the DKK ColorChecker
+        - @ref COLORCHECKER_DIGITAL_SG, the DigitalSG ColorChecker with 140 squares
+
+        @param src detected colors of ColorChecker patches;
+                    the color type is RGB not BGR, and the color values are in [0, 1];
+        @param constColor the Built-in color card
+    */
+    CV_WRAP ColorCorrectionModel(InputArray src, int constColor);
+
+    /** @brief Color Correction Model
+        @param src detected colors of ColorChecker patches;
+                the color type is RGB not BGR, and the color values are in [0, 1];
+        @param colors the reference color values, the color values are in [0, 1].
+        @param refColorSpace the corresponding color space
+                If the color type is some RGB, the format is RGB not BGR;
+    */
+    CV_WRAP ColorCorrectionModel(InputArray src, InputArray colors, ColorSpace refColorSpace);
+
+    /** @brief Color Correction Model
+        @param src detected colors of ColorChecker patches;
+                    the color type is RGB not BGR, and the color values are in [0, 1];
+        @param colors the reference color values, the color values are in [0, 1].
+        @param refColorSpace the corresponding color space
+                    If the color type is some RGB, the format is RGB not BGR;
+        @param coloredPatchesMask binary mask indicating which patches are colored (non-gray) patches
+    */
+    CV_WRAP ColorCorrectionModel(InputArray src, InputArray colors, ColorSpace refColorSpace, InputArray coloredPatchesMask);
+
+    /** @brief set ColorSpace
+        @note It should be some RGB color space;
+        Supported list of color cards:
+        - @ref COLOR_SPACE_SRGB
+        - @ref COLOR_SPACE_ADOBE_RGB
+        - @ref COLOR_SPACE_WIDE_GAMUT_RGB
+        - @ref COLOR_SPACE_PRO_PHOTO_RGB
+        - @ref COLOR_SPACE_DCI_P3_RGB
+        - @ref COLOR_SPACE_APPLE_RGB
+        - @ref COLOR_SPACE_REC_709_RGB
+        - @ref COLOR_SPACE_REC_2020_RGB
+        @param cs the absolute color space that detected colors convert to;
+              default: @ref COLOR_SPACE_SRGB
+    */
+    CV_WRAP void setColorSpace(ColorSpace cs);
+
+    /** @brief set ccmType
+    @param ccmType the shape of color correction matrix(CCM);
+                    default: @ref CCM_LINEAR
+    */
+    CV_WRAP void setCcmType(CcmType ccmType);
+
+    /** @brief set Distance
+    @param distance the type of color distance;
+                    default: @ref DISTANCE_CIE2000
+    */
+    CV_WRAP void setDistance(DistanceType distance);
+
+    /** @brief set Linear
+    @param linearizationType the method of linearization;
+                       default: @ref LINEARIZATION_GAMMA
+    */
+    CV_WRAP void setLinearization(LinearizationType linearizationType);
+
+    /** @brief set Gamma
+
+    @note only valid when linear is set to "gamma";
+
+    @param gamma the gamma value of gamma correction;
+                 default: 2.2;
+    */
+    CV_WRAP void setLinearizationGamma(double gamma);
+
+    /** @brief set degree
+        @note only valid when linear is set to
+        - @ref LINEARIZATION_COLORPOLYFIT
+        - @ref LINEARIZATION_GRAYPOLYFIT
+        - @ref LINEARIZATION_COLORLOGPOLYFIT
+        - @ref LINEARIZATION_GRAYLOGPOLYFIT
+
+        @param deg the degree of linearization polynomial
+            default: 3
+
+    */
+    CV_WRAP void setLinearizationDegree(int deg);
+
+    /** @brief set SaturatedThreshold.
+                The colors in the closed interval [lower, upper] are reserved to participate
+                in the calculation of the loss function and initialization parameters
+        @param lower the lower threshold to determine saturation;
+                default: 0;
+        @param upper the upper threshold to determine saturation;
+                default: 0
+    */
+    CV_WRAP void setSaturatedThreshold(double lower, double upper);
+
+    /** @brief set WeightsList
+    @param weightsList the list of weight of each color;
+                        default: empty array
+    */
+    CV_WRAP void setWeightsList(const Mat& weightsList);
+
+    /** @brief set WeightCoeff
+    @param weightsCoeff the exponent number of L* component of the reference color in CIE Lab color space;
+                         default: 0
+    */
+    CV_WRAP void setWeightCoeff(double weightsCoeff);
+
+    /** @brief set InitialMethod
+    @param initialMethodType the method of calculating CCM initial value;
+            default: INITIAL_METHOD_LEAST_SQUARE
+    */
+    CV_WRAP void setInitialMethod(InitialMethodType initialMethodType);
+
+    /** @brief set MaxCount
+    @param maxCount used in MinProblemSolver-DownhillSolver;
+        Terminal criteria to the algorithm;
+                     default: 5000;
+    */
+    CV_WRAP void setMaxCount(int maxCount);
+
+    /** @brief set Epsilon
+    @param epsilon used in MinProblemSolver-DownhillSolver;
+        Terminal criteria to the algorithm;
+                   default: 1e-4;
+    */
+    CV_WRAP void setEpsilon(double epsilon);
+
+    /** @brief Set whether the input image is in RGB color space
+    @param rgb If true, the model expects input images in RGB format.
+                 If false, input is assumed to be in BGR (default).
+    */
+    CV_WRAP void setRGB(bool rgb);
+
+    /** @brief make color correction */
+    CV_WRAP Mat compute();
+
+    CV_WRAP Mat getColorCorrectionMatrix() const;
+    CV_WRAP double getLoss() const;
+    CV_WRAP Mat getSrcLinearRGB() const;
+    CV_WRAP Mat getRefLinearRGB() const;
+    CV_WRAP Mat getMask() const;
+    CV_WRAP Mat getWeights() const;
+
+    /** @brief Applies color correction to the input image using a fitted color correction matrix.
+     *
+     * The conventional ranges for R, G, and B channel values are:
+     -   0 to 255 for CV_8U images
+     -   0 to 65535 for CV_16U images
+     -   0 to 1 for CV_32F images
+        @param src Input 8-bit, 16-bit unsigned or 32-bit float 3-channel image..
+        @param dst Output image of the same size and datatype as src.
+        @param islinear default false.
+    */
+    CV_WRAP void correctImage(InputArray src, OutputArray dst, bool islinear = false);
+
+    CV_WRAP void write(cv::FileStorage& fs) const;
+    CV_WRAP void read(const cv::FileNode& node);
+
+    class Impl;
+private:
+    std::shared_ptr<Impl> p;
+};
+
+CV_EXPORTS void write(cv::FileStorage& fs, const std::string&, const ColorCorrectionModel& ccm);
+CV_EXPORTS void read(const cv::FileNode& node, ColorCorrectionModel& ccm, const ColorCorrectionModel& defaultValue = ColorCorrectionModel());
+
+//! @} ccm
+} // namespace ccm
+} // namespace cv
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo/cuda.hpp b/upstream/opencv/modules/photo/include/opencv2/photo/cuda.hpp
new file mode 100644
index 0000000..709ad2d
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo/cuda.hpp
@@ -0,0 +1,157 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_PHOTO_CUDA_HPP
+#define OPENCV_PHOTO_CUDA_HPP
+
+#include "opencv2/core/cuda.hpp"
+
+namespace cv { namespace cuda {
+
+//! @addtogroup photo_denoise
+//! @{
+
+/** @brief Performs pure non local means denoising without any simplification, and thus it is not fast.
+
+@param src Source image. Supports only CV_8UC1, CV_8UC2 and CV_8UC3.
+@param dst Destination image.
+@param h Filter sigma regulating filter strength for color.
+@param search_window Size of search window.
+@param block_size Size of block used for computing weights.
+@param borderMode Border type. See borderInterpolate for details. BORDER_REFLECT101 ,
+BORDER_REPLICATE , BORDER_CONSTANT , BORDER_REFLECT and BORDER_WRAP are supported for now.
+@param stream Stream for the asynchronous version.
+
+@sa
+   fastNlMeansDenoising
+ */
+CV_EXPORTS void nonLocalMeans(InputArray src, OutputArray dst,
+                            float h,
+                            int search_window = 21,
+                            int block_size = 7,
+                            int borderMode = BORDER_DEFAULT,
+                            Stream& stream = Stream::Null());
+CV_WRAP inline void nonLocalMeans(const GpuMat& src, CV_OUT GpuMat& dst,
+                            float h,
+                            int search_window = 21,
+                            int block_size = 7,
+                            int borderMode = BORDER_DEFAULT,
+                            Stream& stream = Stream::Null())
+{
+    nonLocalMeans(InputArray(src), OutputArray(dst), h, search_window, block_size, borderMode, stream);
+}
+
+/** @brief Perform image denoising using Non-local Means Denoising algorithm
+<http://www.ipol.im/pub/algo/bcm_non_local_means_denoising> with several computational
+optimizations. Noise expected to be a gaussian white noise
+
+@param src Input 8-bit 1-channel, 2-channel or 3-channel image.
+@param dst Output image with the same size and type as src .
+@param h Parameter regulating filter strength. Big h value perfectly removes noise but also
+removes image details, smaller h value preserves details but also preserves some noise
+@param search_window Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater search_window - greater
+denoising time. Recommended value 21 pixels
+@param block_size Size in pixels of the template patch that is used to compute weights. Should be
+odd. Recommended value 7 pixels
+@param stream Stream for the asynchronous invocations.
+
+This function expected to be applied to grayscale images. For colored images look at
+FastNonLocalMeansDenoising::labMethod.
+
+@sa
+   fastNlMeansDenoising
+ */
+CV_EXPORTS void fastNlMeansDenoising(InputArray src, OutputArray dst,
+                                    float h,
+                                    int search_window = 21,
+                                    int block_size = 7,
+                                    Stream& stream = Stream::Null());
+CV_WRAP inline void fastNlMeansDenoising(const GpuMat& src, CV_OUT GpuMat& dst,
+                                    float h,
+                                    int search_window = 21,
+                                    int block_size = 7,
+                                    Stream& stream = Stream::Null())
+{
+    fastNlMeansDenoising(InputArray(src), OutputArray(dst), h, search_window, block_size, stream);
+}
+
+/** @brief Modification of fastNlMeansDenoising function for colored images
+
+@param src Input 8-bit 3-channel image.
+@param dst Output image with the same size and type as src .
+@param h_luminance Parameter regulating filter strength. Big h value perfectly removes noise but
+also removes image details, smaller h value preserves details but also preserves some noise
+@param photo_render float The same as h but for color components. For most images value equals 10 will be
+enough to remove colored noise and do not distort colors
+@param search_window Size in pixels of the window that is used to compute weighted average for
+given pixel. Should be odd. Affect performance linearly: greater search_window - greater
+denoising time. Recommended value 21 pixels
+@param block_size Size in pixels of the template patch that is used to compute weights. Should be
+odd. Recommended value 7 pixels
+@param stream Stream for the asynchronous invocations.
+
+The function converts image to CIELAB colorspace and then separately denoise L and AB components
+with given h parameters using FastNonLocalMeansDenoising::simpleMethod function.
+
+@sa
+   fastNlMeansDenoisingColored
+ */
+CV_EXPORTS void fastNlMeansDenoisingColored(InputArray src, OutputArray dst,
+                                            float h_luminance, float photo_render,
+                                            int search_window = 21,
+                                            int block_size = 7,
+                                            Stream& stream = Stream::Null());
+CV_WRAP inline void fastNlMeansDenoisingColored(const GpuMat& src, CV_OUT GpuMat& dst,
+                                            float h_luminance, float photo_render,
+                                            int search_window = 21,
+                                            int block_size = 7,
+                                            Stream& stream = Stream::Null())
+{
+    fastNlMeansDenoisingColored(InputArray(src), OutputArray(dst), h_luminance, photo_render, search_window, block_size, stream);
+}
+
+//! @} photo
+
+}} // namespace cv { namespace cuda {
+
+#endif /* OPENCV_PHOTO_CUDA_HPP */
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo/legacy/constants_c.h b/upstream/opencv/modules/photo/include/opencv2/photo/legacy/constants_c.h
new file mode 100644
index 0000000..ec1d440
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo/legacy/constants_c.h
@@ -0,0 +1,14 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_PHOTO_LEGACY_CONSTANTS_H
+#define OPENCV_PHOTO_LEGACY_CONSTANTS_H
+
+enum InpaintingModes
+{
+    CV_INPAINT_NS      =0,
+    CV_INPAINT_TELEA   =1
+};
+
+#endif // OPENCV_PHOTO_LEGACY_CONSTANTS_H
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo/photo.hpp b/upstream/opencv/modules/photo/include/opencv2/photo/photo.hpp
new file mode 100644
index 0000000..8af5e9f
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo/photo.hpp
@@ -0,0 +1,48 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/photo.hpp"
diff --git a/upstream/opencv/modules/photo/include/opencv2/photo/segmentation.hpp b/upstream/opencv/modules/photo/include/opencv2/photo/segmentation.hpp
new file mode 100644
index 0000000..c0ca8da
--- /dev/null
+++ b/upstream/opencv/modules/photo/include/opencv2/photo/segmentation.hpp
@@ -0,0 +1,141 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_PHOTO_SEGMENTATION_HPP
+#define OPENCV_PHOTO_SEGMENTATION_HPP
+
+#include "opencv2/photo.hpp"
+
+namespace cv {
+
+namespace segmentation {
+
+//! @addtogroup photo_segmentation
+//! @{
+
+
+/** @brief Intelligent Scissors image segmentation
+ *
+ * This class is used to find the path (contour) between two points
+ * which can be used for image segmentation.
+ *
+ * Usage example:
+ * @snippet snippets/photo_segmentation.cpp usage_example_intelligent_scissors
+ *
+ * Reference: <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.3811&rep=rep1&type=pdf">"Intelligent Scissors for Image Composition"</a>
+ * algorithm designed by Eric N. Mortensen and William A. Barrett, Brigham Young University
+ * @cite Mortensen95intelligentscissors
+ */
+class CV_EXPORTS_W_SIMPLE IntelligentScissorsMB
+{
+public:
+    CV_WRAP
+    IntelligentScissorsMB();
+
+    /** @brief Specify weights of feature functions
+     *
+     * Consider keeping weights normalized (sum of weights equals to 1.0)
+     * Discrete dynamic programming (DP) goal is minimization of costs between pixels.
+     *
+     * @param weight_non_edge Specify cost of non-edge pixels (default: 0.43f)
+     * @param weight_gradient_direction Specify cost of gradient direction function (default: 0.43f)
+     * @param weight_gradient_magnitude Specify cost of gradient magnitude function (default: 0.14f)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setWeights(float weight_non_edge, float weight_gradient_direction, float weight_gradient_magnitude);
+
+    /** @brief Specify gradient magnitude max value threshold
+     *
+     * Zero limit value is used to disable gradient magnitude thresholding (default behavior, as described in original article).
+     * Otherwize pixels with `gradient magnitude >= threshold` have zero cost.
+     *
+     * @note Thresholding should be used for images with irregular regions (to avoid stuck on parameters from high-contract areas, like embedded logos).
+     *
+     * @param gradient_magnitude_threshold_max Specify gradient magnitude max value threshold (default: 0, disabled)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setGradientMagnitudeMaxLimit(float gradient_magnitude_threshold_max = 0.0f);
+
+    /** @brief Switch to "Laplacian Zero-Crossing" edge feature extractor and specify its parameters
+     *
+     * This feature extractor is used by default according to article.
+     *
+     * Implementation has additional filtering for regions with low-amplitude noise.
+     * This filtering is enabled through parameter of minimal gradient amplitude (use some small value 4, 8, 16).
+     *
+     * @note Current implementation of this feature extractor is based on processing of grayscale images (color image is converted to grayscale image first).
+     *
+     * @note Canny edge detector is a bit slower, but provides better results (especially on color images): use setEdgeFeatureCannyParameters().
+     *
+     * @param gradient_magnitude_min_value Minimal gradient magnitude value for edge pixels (default: 0, check is disabled)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setEdgeFeatureZeroCrossingParameters(float gradient_magnitude_min_value = 0.0f);
+
+    /** @brief Switch edge feature extractor to use Canny edge detector
+     *
+     * @note "Laplacian Zero-Crossing" feature extractor is used by default (following to original article)
+     *
+     * @sa Canny
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setEdgeFeatureCannyParameters(
+            double threshold1, double threshold2,
+            int apertureSize = 3, bool L2gradient = false
+    );
+
+    /** @brief Specify input image and extract image features
+     *
+     * @param image input image. Type is #CV_8UC1 / #CV_8UC3
+     */
+    CV_WRAP
+    IntelligentScissorsMB& applyImage(InputArray image);
+
+    /** @brief Specify custom features of input image
+     *
+     * Customized advanced variant of applyImage() call.
+     *
+     * @param non_edge Specify cost of non-edge pixels. Type is CV_8UC1. Expected values are `{0, 1}`.
+     * @param gradient_direction Specify gradient direction feature. Type is CV_32FC2. Values are expected to be normalized: `x^2 + y^2 == 1`
+     * @param gradient_magnitude Specify cost of gradient magnitude function: Type is CV_32FC1. Values should be in range `[0, 1]`.
+     * @param image **Optional parameter**. Must be specified if subset of features is specified (non-specified features are calculated internally)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& applyImageFeatures(
+            InputArray non_edge, InputArray gradient_direction, InputArray gradient_magnitude,
+            InputArray image = noArray()
+    );
+
+    /** @brief Prepares a map of optimal paths for the given source point on the image
+     *
+     * @note applyImage() / applyImageFeatures() must be called before this call
+     *
+     * @param sourcePt The source point used to find the paths
+     */
+    CV_WRAP void buildMap(const Point& sourcePt);
+
+    /** @brief Extracts optimal contour for the given target point on the image
+     *
+     * @note buildMap() must be called before this call
+     *
+     * @param targetPt The target point
+     * @param[out] contour The list of pixels which contains optimal path between the source and the target points of the image. Type is CV_32SC2 (compatible with `std::vector<Point>`)
+     * @param backward Flag to indicate reverse order of retrieved pixels (use "true" value to fetch points from the target to the source point)
+     */
+    CV_WRAP void getContour(const Point& targetPt, OutputArray contour, bool backward = false) const;
+
+#ifndef CV_DOXYGEN
+    struct Impl;
+    inline Impl* getImpl() const { return impl.get(); }
+protected:
+    std::shared_ptr<Impl> impl;
+#endif
+};
+
+//! @}
+
+}  // namespace segmentation
+}  // namespace cv
+
+#endif // OPENCV_PHOTO_SEGMENTATION_HPP
diff --git a/upstream/opencv/modules/photo/src/align.cpp b/upstream/opencv/modules/photo/src/align.cpp
new file mode 100644
index 0000000..6a39720
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/align.cpp
@@ -0,0 +1,281 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "hdr_common.hpp"
+
+namespace cv
+{
+
+class AlignMTBImpl CV_FINAL : public AlignMTB
+{
+public:
+    AlignMTBImpl(int _max_bits, int _exclude_range, bool _cut) :
+        name("AlignMTB"),
+        max_bits(_max_bits),
+        exclude_range(_exclude_range),
+        cut(_cut)
+    {
+    }
+
+    void process(InputArrayOfArrays src, std::vector<Mat>& dst,
+                 InputArray, InputArray) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        process(src, dst);
+    }
+
+    void process(InputArrayOfArrays _src, std::vector<Mat>& dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        std::vector<Mat> src;
+        _src.getMatVector(src);
+
+        checkImageDimensions(src);
+        dst.resize(src.size());
+
+        size_t pivot = src.size() / 2;
+        dst[pivot] = src[pivot];
+        Mat gray_base;
+        cvtColor(src[pivot], gray_base, COLOR_RGB2GRAY);
+        std::vector<Point> shifts;
+
+        for(size_t i = 0; i < src.size(); i++) {
+            if(i == pivot) {
+                shifts.push_back(Point(0, 0));
+                continue;
+            }
+            Mat gray;
+            cvtColor(src[i], gray, COLOR_RGB2GRAY);
+            Point shift = calculateShift(gray_base, gray);
+            shifts.push_back(shift);
+            shiftMat(src[i], dst[i], shift);
+        }
+        if(cut) {
+            Point max(0, 0), min(0, 0);
+            for(size_t i = 0; i < shifts.size(); i++) {
+                if(shifts[i].x > max.x) {
+                    max.x = shifts[i].x;
+                }
+                if(shifts[i].y > max.y) {
+                    max.y = shifts[i].y;
+                }
+                if(shifts[i].x < min.x) {
+                    min.x = shifts[i].x;
+                }
+                if(shifts[i].y < min.y) {
+                    min.y = shifts[i].y;
+                }
+            }
+            Point size = dst[0].size();
+            for(size_t i = 0; i < dst.size(); i++) {
+                dst[i] = dst[i](Rect(max, min + size));
+            }
+        }
+    }
+
+    Point calculateShift(InputArray _img0, InputArray _img1) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat img0 = _img0.getMat();
+        Mat img1 = _img1.getMat();
+        CV_Assert(img0.channels() == 1 && img0.type() == img1.type());
+        CV_Assert(img0.size() == img1.size());
+
+        int maxlevel = static_cast<int>(log((double)max(img0.rows, img0.cols)) / log(2.0)) - 1;
+        maxlevel = min(maxlevel, max_bits - 1);
+
+        std::vector<Mat> pyr0;
+        std::vector<Mat> pyr1;
+        buildPyr(img0, pyr0, maxlevel);
+        buildPyr(img1, pyr1, maxlevel);
+
+        Point shift(0, 0);
+        for(int level = maxlevel; level >= 0; level--) {
+
+            shift *= 2;
+            Mat tb1, tb2, eb1, eb2;
+            computeBitmaps(pyr0[level], tb1, eb1);
+            computeBitmaps(pyr1[level], tb2, eb2);
+
+            int min_err = (int)pyr0[level].total();
+            Point new_shift(shift);
+            for(int i = -1; i <= 1; i++) {
+                for(int j = -1; j <= 1; j++) {
+                    Point test_shift = shift + Point(i, j);
+                    Mat shifted_tb2, shifted_eb2, diff;
+                    shiftMat(tb2, shifted_tb2, test_shift);
+                    shiftMat(eb2, shifted_eb2, test_shift);
+                    bitwise_xor(tb1, shifted_tb2, diff);
+                    bitwise_and(diff, eb1, diff);
+                    bitwise_and(diff, shifted_eb2, diff);
+                    int err = countNonZero(diff);
+                    if(err < min_err) {
+                        new_shift = test_shift;
+                        min_err = err;
+                    }
+                }
+            }
+            shift = new_shift;
+        }
+        return shift;
+    }
+
+    void shiftMat(InputArray _src, OutputArray _dst, const Point shift) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat src = _src.getMat();
+        _dst.create(src.size(), src.type());
+        Mat dst = _dst.getMat();
+
+        Mat res = Mat::zeros(src.size(), src.type());
+        int width = src.cols - abs(shift.x);
+        int height = src.rows - abs(shift.y);
+        Rect dst_rect(max(shift.x, 0), max(shift.y, 0), width, height);
+        Rect src_rect(max(-shift.x, 0), max(-shift.y, 0), width, height);
+        src(src_rect).copyTo(res(dst_rect));
+        res.copyTo(dst);
+    }
+
+    int getMaxBits() const CV_OVERRIDE { return max_bits; }
+    void setMaxBits(int val) CV_OVERRIDE { max_bits = val; }
+
+    int getExcludeRange() const CV_OVERRIDE { return exclude_range; }
+    void setExcludeRange(int val) CV_OVERRIDE { exclude_range = val; }
+
+    bool getCut() const CV_OVERRIDE { return cut; }
+    void setCut(bool val) CV_OVERRIDE { cut = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "max_bits" << max_bits
+           << "exclude_range" << exclude_range
+           << "cut" << static_cast<int>(cut);
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        max_bits = fn["max_bits"];
+        exclude_range = fn["exclude_range"];
+        int cut_val = fn["cut"];
+        cut = (cut_val != 0);
+    }
+
+    void computeBitmaps(InputArray _img, OutputArray _tb, OutputArray _eb) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat img = _img.getMat();
+        _tb.create(img.size(), CV_8U);
+        _eb.create(img.size(), CV_8U);
+        Mat tb = _tb.getMat(), eb = _eb.getMat();
+        int median = getMedian(img);
+        compare(img, median, tb, CMP_GT);
+        compare(abs(img - median), exclude_range, eb, CMP_GT);
+    }
+
+protected:
+    String name;
+    int max_bits, exclude_range;
+    bool cut;
+
+    void downsample(Mat& src, Mat& dst)
+    {
+        dst = Mat(src.rows / 2, src.cols / 2, CV_8UC1);
+
+        int offset = src.cols * 2;
+        uchar *src_ptr = src.ptr();
+        uchar *dst_ptr = dst.ptr();
+        for(int y = 0; y < dst.rows; y ++) {
+            uchar *ptr = src_ptr;
+            for(int x = 0; x < dst.cols; x++) {
+                dst_ptr[0] = ptr[0];
+                dst_ptr++;
+                ptr += 2;
+            }
+            src_ptr += offset;
+        }
+    }
+
+    void buildPyr(Mat& img, std::vector<Mat>& pyr, int maxlevel)
+    {
+        pyr.resize(maxlevel + 1);
+        pyr[0] = img.clone();
+        for(int level = 0; level < maxlevel; level++) {
+            downsample(pyr[level], pyr[level + 1]);
+        }
+    }
+
+    int getMedian(Mat& img)
+    {
+        int channels = 0;
+        Mat hist;
+        int hist_size = LDR_SIZE;
+        float range[] = {0, LDR_SIZE} ;
+        const float* ranges[] = {range};
+        calcHist(&img, 1, &channels, Mat(), hist, 1, &hist_size, ranges);
+        float *ptr = hist.ptr<float>();
+        int median = 0, sum = 0;
+        int thresh = (int)img.total() / 2;
+        while(sum < thresh && median < LDR_SIZE) {
+            sum += static_cast<int>(ptr[median]);
+            median++;
+        }
+        return median;
+    }
+};
+
+Ptr<AlignMTB> createAlignMTB(int max_bits, int exclude_range, bool cut)
+{
+    return makePtr<AlignMTBImpl>(max_bits, exclude_range, cut);
+}
+
+}
diff --git a/upstream/opencv/modules/photo/src/arrays.hpp b/upstream/opencv/modules/photo/src/arrays.hpp
new file mode 100644
index 0000000..cdd59a3
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/arrays.hpp
@@ -0,0 +1,184 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/core/base.hpp"
+
+#ifndef __OPENCV_DENOISING_ARRAYS_HPP__
+#define __OPENCV_DENOISING_ARRAYS_HPP__
+
+namespace cv
+{
+
+template <class T>
+struct Array2d
+{
+    T* a;
+    int n1,n2;
+    bool needToDeallocArray;
+
+    Array2d(const Array2d& array2d):
+        a(array2d.a), n1(array2d.n1), n2(array2d.n2), needToDeallocArray(false)
+    {
+        if (array2d.needToDeallocArray)
+        {
+            CV_Error(Error::BadDataPtr, "Copy constructor for self allocating arrays not supported");
+        }
+    }
+
+    Array2d(T* _a, int _n1, int _n2):
+        a(_a), n1(_n1), n2(_n2), needToDeallocArray(false)
+    {
+    }
+
+    Array2d(int _n1, int _n2):
+        n1(_n1), n2(_n2), needToDeallocArray(true)
+    {
+        a = new T[n1*n2];
+    }
+
+    ~Array2d()
+    {
+        if (needToDeallocArray)
+            delete[] a;
+    }
+
+    T* operator [] (int i)
+    {
+        return a + i*n2;
+    }
+
+    inline T* row_ptr(int i)
+    {
+        return (*this)[i];
+    }
+};
+
+template <class T>
+struct Array3d
+{
+    T* a;
+    int n1,n2,n3;
+    bool needToDeallocArray;
+
+    Array3d(T* _a, int _n1, int _n2, int _n3):
+        a(_a), n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(false)
+    {
+    }
+
+    Array3d(int _n1, int _n2, int _n3):
+        n1(_n1), n2(_n2), n3(_n3), needToDeallocArray(true)
+    {
+        a = new T[n1*n2*n3];
+    }
+
+    ~Array3d()
+    {
+        if (needToDeallocArray)
+            delete[] a;
+    }
+
+    Array2d<T> operator [] (int i)
+    {
+        Array2d<T> array2d(a + i*n2*n3, n2, n3);
+        return array2d;
+    }
+
+    inline T* row_ptr(int i1, int i2)
+    {
+        return a + i1*n2*n3 + i2*n3;
+    }
+};
+
+template <class T>
+struct Array4d
+{
+    T* a;
+    int n1,n2,n3,n4;
+    bool needToDeallocArray;
+    int steps[4];
+
+    void init_steps()
+    {
+        steps[0] = n2*n3*n4;
+        steps[1] = n3*n4;
+        steps[2] = n4;
+        steps[3] = 1;
+    }
+
+    Array4d(T* _a, int _n1, int _n2, int _n3, int _n4) :
+        a(_a), n1(_n1), n2(_n2), n3(_n3), n4(_n4), needToDeallocArray(false)
+    {
+        init_steps();
+    }
+
+    Array4d(int _n1, int _n2, int _n3, int _n4) :
+        n1(_n1), n2(_n2), n3(_n3), n4(_n4), needToDeallocArray(true)
+    {
+        a = new T[n1*n2*n3*n4];
+        init_steps();
+    }
+
+    ~Array4d()
+    {
+        if (needToDeallocArray)
+            delete[] a;
+    }
+
+    Array3d<T> operator [] (int i)
+    {
+        Array3d<T> array3d(a + i*n2*n3*n4, n2, n3, n4);
+        return array3d;
+    }
+
+    inline T* row_ptr(int i1, int i2, int i3)
+    {
+        return a + i1*n2*n3*n4 + i2*n3*n4 + i3*n4;
+    }
+
+    inline int step_size(int dimension)
+    {
+        return steps[dimension];
+    }
+};
+
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/calibrate.cpp b/upstream/opencv/modules/photo/src/calibrate.cpp
new file mode 100644
index 0000000..0a399af
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/calibrate.cpp
@@ -0,0 +1,311 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "hdr_common.hpp"
+
+namespace cv
+{
+
+class CalibrateDebevecImpl CV_FINAL : public CalibrateDebevec
+{
+public:
+    CalibrateDebevecImpl(int _samples, float _lambda, bool _random) :
+        name("CalibrateDebevec"),
+        samples(_samples),
+        lambda(_lambda),
+        random(_random),
+        w(triangleWeights())
+    {
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray _times) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        // check inputs
+        std::vector<Mat> images;
+        src.getMatVector(images);
+        Mat times = _times.getMat();
+
+        CV_Assert(images.size() == times.total());
+        checkImageDimensions(images);
+        CV_Assert(images[0].depth() == CV_8U);
+        CV_Assert(times.type() == CV_32FC1);
+
+        // create output
+        int channels = images[0].channels();
+        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);
+        int rows = images[0].rows;
+        int cols = images[0].cols;
+
+        dst.create(LDR_SIZE, 1, CV_32FCC);
+        Mat result = dst.getMat();
+
+        // pick pixel locations (either random or in a rectangular grid)
+        std::vector<Point> points;
+        points.reserve(samples);
+        if(random) {
+            for(int i = 0; i < samples; i++) {
+                points.push_back(Point(rand() % cols, rand() % rows));
+            }
+        } else {
+            int x_points = static_cast<int>(sqrt(static_cast<double>(samples) * cols / rows));
+            CV_Assert(0 < x_points && x_points <= cols);
+            int y_points = samples / x_points;
+            CV_Assert(0 < y_points && y_points <= rows);
+            int step_x = cols / x_points;
+            int step_y = rows / y_points;
+            for(int i = 0, x = step_x / 2; i < x_points; i++, x += step_x) {
+                for(int j = 0, y = step_y / 2; j < y_points; j++, y += step_y) {
+                    if( 0 <= x && x < cols && 0 <= y && y < rows ) {
+                        points.push_back(Point(x, y));
+                    }
+                }
+            }
+            // we can have slightly less grid points than specified
+            //samples = static_cast<int>(points.size());
+        }
+
+        // we need enough equations to ensure a sufficiently overdetermined system
+        // (maybe only as a warning)
+        //CV_Assert(points.size() * (images.size() - 1) >= LDR_SIZE);
+
+        // solve for imaging system response function, over each channel separately
+        std::vector<Mat> result_split(channels);
+        for(int ch = 0; ch < channels; ch++) {
+            // initialize system of linear equations
+            Mat A = Mat::zeros((int)points.size() * (int)images.size() + LDR_SIZE + 1,
+                LDR_SIZE + (int)points.size(), CV_32F);
+            Mat B = Mat::zeros(A.rows, 1, CV_32F);
+
+            // include the data-fitting equations
+            int k = 0;
+            for(size_t i = 0; i < points.size(); i++) {
+                for(size_t j = 0; j < images.size(); j++) {
+                    // val = images[j].at<Vec3b>(points[i].y, points[i].x)[ch]
+                    int val = images[j].ptr()[channels*(points[i].y * cols + points[i].x) + ch];
+                    float wij = w.at<float>(val);
+                    A.at<float>(k, val) = wij;
+                    A.at<float>(k, LDR_SIZE + (int)i) = -wij;
+                    B.at<float>(k, 0) = wij * log(times.at<float>((int)j));
+                    k++;
+                }
+            }
+
+            // fix the curve by setting its middle value to 0
+            A.at<float>(k, LDR_SIZE / 2) = 1;
+            k++;
+
+            // include the smoothness equations
+            for(int i = 0; i < (LDR_SIZE - 2); i++) {
+                float wi = w.at<float>(i + 1);
+                A.at<float>(k, i) = lambda * wi;
+                A.at<float>(k, i + 1) = -2 * lambda * wi;
+                A.at<float>(k, i + 2) = lambda * wi;
+                k++;
+            }
+
+            // solve the overdetermined system using SVD (least-squares problem)
+            Mat solution;
+            solve(A, B, solution, DECOMP_SVD);
+            solution.rowRange(0, LDR_SIZE).copyTo(result_split[ch]);
+        }
+
+        // combine log-exposures and take its exponent
+        merge(result_split, result);
+        exp(result, result);
+    }
+
+    int getSamples() const CV_OVERRIDE { return samples; }
+    void setSamples(int val) CV_OVERRIDE { samples = val; }
+
+    float getLambda() const CV_OVERRIDE { return lambda; }
+    void setLambda(float val) CV_OVERRIDE { lambda = val; }
+
+    bool getRandom() const CV_OVERRIDE { return random; }
+    void setRandom(bool val) CV_OVERRIDE { random = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "samples" << samples
+           << "lambda" << lambda
+           << "random" << static_cast<int>(random);
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        samples = fn["samples"];
+        lambda = fn["lambda"];
+        int random_val = fn["random"];
+        random = (random_val != 0);
+    }
+
+protected:
+    String name;  // calibration algorithm identifier
+    int samples;  // number of pixel locations to sample
+    float lambda; // constant that determines the amount of smoothness
+    bool random;  // whether to sample locations randomly or in a grid shape
+    Mat w;        // weighting function for corresponding pixel values
+};
+
+Ptr<CalibrateDebevec> createCalibrateDebevec(int samples, float lambda, bool random)
+{
+    return makePtr<CalibrateDebevecImpl>(samples, lambda, random);
+}
+
+class CalibrateRobertsonImpl CV_FINAL : public CalibrateRobertson
+{
+public:
+    CalibrateRobertsonImpl(int _max_iter, float _threshold) :
+        name("CalibrateRobertson"),
+        max_iter(_max_iter),
+        threshold(_threshold),
+        weight(RobertsonWeights())
+    {
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray _times) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        std::vector<Mat> images;
+        src.getMatVector(images);
+        Mat times = _times.getMat();
+
+        CV_Assert(images.size() == times.total());
+        checkImageDimensions(images);
+        CV_Assert(images[0].depth() == CV_8U);
+
+        int channels = images[0].channels();
+        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);
+        CV_Assert(channels >= 1 && channels <= 3);
+
+        dst.create(LDR_SIZE, 1, CV_32FCC);
+        Mat response = dst.getMat();
+        response = linearResponse(3) / (static_cast<float>(LDR_SIZE) / 2.0f);
+
+        Mat card = Mat::zeros(LDR_SIZE, 1, CV_32FCC);
+        for(size_t i = 0; i < images.size(); i++) {
+           uchar *ptr = images[i].ptr();
+           for(size_t pos = 0; pos < images[i].total(); pos++) {
+               for(int c = 0; c < channels; c++, ptr++) {
+                   card.at<Vec3f>(*ptr)[c] += 1;
+               }
+           }
+        }
+        card = 1.0 / card;
+
+        Ptr<MergeRobertson> merge = createMergeRobertson();
+        for(int iter = 0; iter < max_iter; iter++) {
+
+            radiance = Mat::zeros(images[0].size(), CV_32FCC);
+            merge->process(images, radiance, times, response);
+
+            Mat new_response = Mat::zeros(LDR_SIZE, 1, CV_32FC3);
+            for(size_t i = 0; i < images.size(); i++) {
+                uchar *ptr = images[i].ptr();
+                float* rad_ptr = radiance.ptr<float>();
+                for(size_t pos = 0; pos < images[i].total(); pos++) {
+                    for(int c = 0; c < channels; c++, ptr++, rad_ptr++) {
+                        new_response.at<Vec3f>(*ptr)[c] += times.at<float>((int)i) * *rad_ptr;
+                    }
+                }
+            }
+            new_response = new_response.mul(card);
+            for(int c = 0; c < 3; c++) {
+                float middle = new_response.at<Vec3f>(LDR_SIZE / 2)[c];
+                for(int i = 0; i < LDR_SIZE; i++) {
+                    new_response.at<Vec3f>(i)[c] /= middle;
+                }
+            }
+            float diff = static_cast<float>(sum(sum(abs(new_response - response)))[0] / channels);
+            new_response.copyTo(response);
+            if(diff < threshold) {
+                break;
+            }
+        }
+    }
+
+    int getMaxIter() const CV_OVERRIDE { return max_iter; }
+    void setMaxIter(int val) CV_OVERRIDE { max_iter = val; }
+
+    float getThreshold() const CV_OVERRIDE { return threshold; }
+    void setThreshold(float val) CV_OVERRIDE { threshold = val; }
+
+    Mat getRadiance() const CV_OVERRIDE { return radiance; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "max_iter" << max_iter
+           << "threshold" << threshold;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        max_iter = fn["max_iter"];
+        threshold = fn["threshold"];
+    }
+
+protected:
+    String name;
+    int max_iter;
+    float threshold;
+    Mat weight, radiance;
+};
+
+Ptr<CalibrateRobertson> createCalibrateRobertson(int max_iter, float threshold)
+{
+    return makePtr<CalibrateRobertsonImpl>(max_iter, threshold);
+}
+
+}
diff --git a/upstream/opencv/modules/photo/src/ccm/ccm.cpp b/upstream/opencv/modules/photo/src/ccm/ccm.cpp
new file mode 100644
index 0000000..26edc00
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/ccm.cpp
@@ -0,0 +1,557 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "opencv2/photo.hpp"
+#include "linearize.hpp"
+#include <cmath>
+namespace cv {
+namespace ccm {
+
+class ColorCorrectionModel::Impl
+{
+public:
+    Mat src;
+
+    Color ref = Color();
+    Mat dist;
+    RGBBase_& cs;
+    // Track initialization parameters for serialization
+    ColorSpace csEnum;
+    Mat mask;
+
+    // RGBl of detected data and the reference
+    Mat srcRgbl;
+    Mat dstRgbl;
+
+    // ccm type and shape
+    CcmType ccmType;
+    int shape;
+
+    // linear method and distance
+    std::shared_ptr<Linear> linear = std::make_shared<Linear>();
+    DistanceType distance;
+    LinearizationType linearizationType;
+
+    Mat weights;
+    Mat weightsList;
+    Mat ccm;
+    Mat ccm0;
+    double gamma;
+    int deg;
+    std::vector<double> saturatedThreshold;
+    InitialMethodType initialMethodType;
+    double weightsCoeff;
+    int maskedLen;
+    double loss;
+    int maxCount;
+    double epsilon;
+    bool rgb;
+    Impl();
+
+    /** @brief Make no change for CCM_LINEAR.
+             convert cv::Mat A to [A, 1] in CCM_AFFINE.
+        @param inp the input array, type of cv::Mat.
+        @return the output array, type of cv::Mat
+    */
+    Mat prepare(const Mat& inp);
+
+    /** @brief Calculate weights and mask.
+        @param weightsList the input array, type of cv::Mat.
+        @param weightsCoeff type of double.
+        @param saturateMask the input array, type of cv::Mat.
+    */
+    void calWeightsMasks(const Mat& weightsList, double weightsCoeff, Mat saturateMask);
+
+    /** @brief Fitting nonlinear - optimization initial value by white balance.
+        @return the output array, type of Mat
+    */
+    void initialWhiteBalance(void);
+
+    /** @brief Fitting nonlinear-optimization initial value by least square.
+        @param fit if fit is True, return optimalization for rgbl distance function.
+    */
+    void initialLeastSquare(bool fit = false);
+
+    double calcLoss_(Color color);
+    double calcLoss(const Mat ccm_);
+
+    /** @brief Fitting ccm if distance function is associated with CIE Lab color space.
+             see details in https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/optim.hpp
+            Set terminal criteria for solver is possible.
+    */
+    void fitting(void);
+
+    void getColor(Mat& img_, bool islinear = false);
+    void getColor(ColorCheckerType constColor);
+    void getColor(Mat colors_, ColorSpace cs_, Mat colored_);
+    void getColor(Mat colors_, ColorSpace refColorSpace_);
+
+    /** @brief Loss function base on cv::MinProblemSolver::Function.
+             see details in https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/optim.hpp
+    */
+    class LossFunction : public MinProblemSolver::Function
+    {
+    public:
+        ColorCorrectionModel::Impl* ccmLoss;
+        LossFunction(ColorCorrectionModel::Impl* ccm)
+            : ccmLoss(ccm) {};
+
+        /** @brief Reset dims to ccm->shape.
+        */
+        int getDims() const CV_OVERRIDE
+        {
+            return ccmLoss->shape;
+        }
+
+        /** @brief Reset calculation.
+        */
+        double calc(const double* x) const CV_OVERRIDE
+        {
+            Mat ccm_(ccmLoss->shape, 1, CV_64F);
+            for (int i = 0; i < ccmLoss->shape; i++)
+            {
+                ccm_.at<double>(i, 0) = x[i];
+            }
+            ccm_ = ccm_.reshape(0, ccmLoss->shape / 3);
+            return ccmLoss->calcLoss(ccm_);
+        }
+    };
+};
+
+ColorCorrectionModel::Impl::Impl()
+    : cs(*GetCS::getInstance().getRgb(COLOR_SPACE_SRGB))
+    , csEnum(COLOR_SPACE_SRGB)
+    , ccmType(CCM_LINEAR)
+    , distance(DISTANCE_CIE2000)
+    , linearizationType(LINEARIZATION_GAMMA)
+    , weights(Mat())
+    , gamma(2.2)
+    , deg(3)
+    , saturatedThreshold({ 0, 0.98 })
+    , initialMethodType(INITIAL_METHOD_LEAST_SQUARE)
+    , weightsCoeff(0)
+    , maxCount(5000)
+    , epsilon(1.e-4)
+    , rgb(true)
+{}
+
+Mat ColorCorrectionModel::Impl::prepare(const Mat& inp)
+{
+    switch (ccmType)
+    {
+    case cv::ccm::CCM_LINEAR:
+        shape = 9;
+        return inp;
+    case cv::ccm::CCM_AFFINE:
+    {
+        shape = 12;
+        Mat ones(inp.size(), CV_64F, Scalar(1));
+        Mat out(inp.size(), CV_64FC4);
+        const Mat srcs[] = { inp, ones };
+        const int fromTo[] = { 0,0, 1,1, 2,2, 3,3 };         // inp[ch] → out[ch]
+        mixChannels(srcs, 2, &out, 1, fromTo, 4);
+        return out;
+    }
+    default:
+        CV_Error(Error::StsBadArg, "Wrong ccmType!");
+        break;
+    }
+}
+
+void ColorCorrectionModel::Impl::calWeightsMasks(const Mat& weightsList_, double weightsCoeff_, Mat saturateMask)
+{
+    // weights
+    if (!weightsList_.empty())
+    {
+        weights = weightsList_;
+    }
+    else if (weightsCoeff_ != 0)
+    {
+        pow(ref.toLuminant(cs.illumobserver), weightsCoeff_, weights);
+    }
+
+    // masks
+    Mat weight_mask = Mat::ones(src.rows, 1, CV_8U);
+    if (!weights.empty())
+    {
+        weight_mask = weights > 0;
+    }
+    this->mask = (weight_mask) & (saturateMask);
+
+    // weights' mask
+    if (!weights.empty())
+    {
+        Mat weights_masked = maskCopyTo(this->weights, this->mask);
+        weights = weights_masked / mean(weights_masked)[0];
+    }
+    maskedLen = (int)sum(mask)[0];
+}
+
+void ColorCorrectionModel::Impl::initialWhiteBalance()
+{
+    // sum over all pixels – Scalar holds per-channel sums
+    const cv::Scalar srcSum = cv::sum(srcRgbl);
+    const cv::Scalar dstSum = cv::sum(dstRgbl);
+
+    // channel-wise gain factors
+    const double gR = dstSum[0] / srcSum[0];
+    const double gG = dstSum[1] / srcSum[1];
+    const double gB = dstSum[2] / srcSum[2];
+
+    // shape == 9 for a 3×3 linear CCM, or 12 for a 3×4 affine CCM
+    if (shape == 9) {
+        // 3×3 diagonal matrix
+        ccm0 = cv::Mat::zeros(3, 3, CV_64F);
+        ccm0.at<double>(0, 0) = gR;
+        ccm0.at<double>(1, 1) = gG;
+        ccm0.at<double>(2, 2) = gB;
+    }
+    else {
+        // 3×4 affine matrix (last column = zeros)
+        ccm0 = cv::Mat::zeros(3, 4, CV_64F);
+        ccm0.at<double>(0, 0) = gR;
+        ccm0.at<double>(1, 1) = gG;
+        ccm0.at<double>(2, 2) = gB;
+    }
+}
+
+
+void ColorCorrectionModel::Impl::initialLeastSquare(bool fit)
+{
+    Mat A, B, w;
+    if (weights.empty())
+    {
+        A = srcRgbl;
+        B = dstRgbl;
+    }
+    else
+    {
+        pow(weights, 0.5, w);
+        Mat w_;
+        merge(std::vector<Mat> { w, w, w }, w_);
+        A = w_.mul(srcRgbl);
+        B = w_.mul(dstRgbl);
+    }
+    solve(A.reshape(1, A.rows), B.reshape(1, B.rows), ccm0, DECOMP_SVD);
+
+    // if fit is True, return optimalization for rgbl distance function.
+    if (fit)
+    {
+        ccm = ccm0;
+        Mat residual = A.reshape(1, A.rows) * ccm.reshape(0, shape / 3) - B.reshape(1, B.rows);
+        Scalar s = residual.dot(residual);
+        double sum = s[0];
+        loss = sqrt(sum / maskedLen);
+    }
+}
+
+double ColorCorrectionModel::Impl::calcLoss_(Color color)
+{
+    Mat distlist = color.diff(ref, distance);
+    Color lab = color.to(COLOR_SPACE_LAB_D50_2);
+    Mat dist_;
+    pow(distlist, 2, dist_);
+    if (!weights.empty())
+    {
+        dist_ = weights.mul(dist_);
+    }
+    Scalar ss = sum(dist_);
+    return ss[0];
+}
+
+double ColorCorrectionModel::Impl::calcLoss(const Mat ccm_)
+{
+    Mat converted = srcRgbl.reshape(1, 0) * ccm_;
+    Color color(converted.reshape(3, 0), *(cs.l));
+    return calcLoss_(color);
+}
+
+void ColorCorrectionModel::Impl::fitting(void)
+{
+    cv::Ptr<DownhillSolver> solver = cv::DownhillSolver::create();
+    cv::Ptr<LossFunction> ptr_F(new LossFunction(this));
+    solver->setFunction(ptr_F);
+    Mat reshapeCcm = ccm0.clone().reshape(0, 1);
+    Mat step = Mat::ones(reshapeCcm.size(), CV_64F);
+    solver->setInitStep(step);
+    TermCriteria termcrit = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, maxCount, epsilon);
+    solver->setTermCriteria(termcrit);
+    double res = solver->minimize(reshapeCcm);
+    ccm = reshapeCcm.reshape(0, shape / 3);
+    loss = sqrt(res / maskedLen);
+}
+
+ColorCorrectionModel::ColorCorrectionModel()
+: p(std::make_shared<Impl>())
+{}
+
+void ColorCorrectionModel::correctImage(InputArray src, OutputArray ref, bool islinear)
+{
+    if (!p->ccm.data)
+    {
+        CV_Error(Error::StsBadArg, "No CCM values!" );
+    }
+    Mat img, normImg;
+    if (p->rgb){
+        cvtColor(src.getMat(), img, COLOR_BGR2RGB);
+    } else {
+        img = src.getMat();
+    }
+
+    double scale;
+    int type = img.type();
+    switch (type) {
+        case CV_8UC3:
+            scale = 1.0 / 255.0;
+            break;
+        case CV_16UC3:
+            scale = 1.0 / 65535.0;
+            break;
+        case CV_32FC3:
+            scale = 1.0;  // Already in [0,1] range
+            break;
+        default:
+            CV_Error( cv::Error::StsUnsupportedFormat, "8-bit, 16-bit unsigned or 32-bit float 3-channel input images are supported");
+    }
+
+    img.convertTo(normImg, CV_64F, scale);
+    Mat linearImg = (p->linear)->linearize(normImg);
+    Mat ccm = p->ccm.reshape(0, p->shape / 3);
+    Mat imgCcm = multiple(p->prepare(linearImg), ccm);
+    if (islinear == true)
+    {
+        imgCcm.copyTo(ref);
+    }
+    Mat imgCorrected = p->cs.fromLFunc(imgCcm, linearImg);
+
+    imgCorrected *= 1.0/scale;
+    imgCorrected.convertTo(imgCorrected, type);
+
+    if (p->rgb)
+        cvtColor(imgCorrected, imgCorrected, COLOR_RGB2BGR);
+    imgCorrected.copyTo(ref);
+}
+
+void ColorCorrectionModel::Impl::getColor(ColorCheckerType constColor)
+{
+    ref = GetColor().getColor(constColor);
+}
+
+void ColorCorrectionModel::Impl::getColor(Mat colors_, ColorSpace refColorSpace_)
+{
+    ref = Color(colors_, *GetCS::getInstance().getCS(refColorSpace_));
+}
+
+void ColorCorrectionModel::Impl::getColor(Mat colors_, ColorSpace cs_, Mat colored_)
+{
+    ref = Color(colors_, *GetCS::getInstance().getCS(cs_), colored_);
+}
+
+ColorCorrectionModel::ColorCorrectionModel(InputArray src_, int constColor): p(std::make_shared<Impl>())
+{
+    p->src = src_.getMat();
+    p->getColor(static_cast<ColorCheckerType>(constColor));
+}
+
+ColorCorrectionModel::ColorCorrectionModel(InputArray src_, InputArray colors_, ColorSpace refColorSpace_): p(std::make_shared<Impl>())
+{
+    p->src = src_.getMat();
+    p->getColor(colors_.getMat(), refColorSpace_);
+}
+
+ColorCorrectionModel::ColorCorrectionModel(InputArray src_, InputArray colors_, ColorSpace cs_, InputArray coloredPatchesMask_): p(std::make_shared<Impl>())
+{
+    p->src = src_.getMat();
+    p->getColor(colors_.getMat(), cs_, coloredPatchesMask_.getMat());
+}
+
+void ColorCorrectionModel::setColorSpace(ColorSpace cs_)
+{
+    p->cs = *GetCS::getInstance().getRgb(cs_);
+}
+void ColorCorrectionModel::setCcmType(CcmType ccmType_)
+{
+    p->ccmType = ccmType_;
+}
+void ColorCorrectionModel::setDistance(DistanceType distance_)
+{
+    p->distance = distance_;
+}
+void ColorCorrectionModel::setLinearization(LinearizationType linearizationType)
+{
+    p->linearizationType = linearizationType;
+}
+void ColorCorrectionModel::setLinearizationGamma(double gamma)
+{
+    p->gamma = gamma;
+}
+void ColorCorrectionModel::setLinearizationDegree(int deg)
+{
+    p->deg = deg;
+}
+void ColorCorrectionModel::setSaturatedThreshold(double lower, double upper)
+{  //std::vector<double> saturatedThreshold
+    p->saturatedThreshold = { lower, upper };
+}
+void ColorCorrectionModel::setWeightsList(const Mat& weightsList)
+{
+    p->weightsList = weightsList;
+}
+void ColorCorrectionModel::setWeightCoeff(double weightsCoeff)
+{
+    p->weightsCoeff = weightsCoeff;
+}
+void ColorCorrectionModel::setInitialMethod(InitialMethodType initialMethodType)
+{
+    p->initialMethodType = initialMethodType;
+}
+void ColorCorrectionModel::setMaxCount(int maxCount_)
+{
+    p->maxCount = maxCount_;
+}
+void ColorCorrectionModel::setEpsilon(double epsilon_)
+{
+    p->epsilon = epsilon_;
+}
+void ColorCorrectionModel::setRGB(bool rgb_)
+{
+    p->rgb = rgb_;
+}
+Mat ColorCorrectionModel::compute()
+{
+
+    Mat saturateMask = saturate(p->src, p->saturatedThreshold[0], p->saturatedThreshold[1]);
+    p->linear = getLinear(p->gamma, p->deg, p->src, p->ref, saturateMask, (p->cs), p->linearizationType);
+    p->calWeightsMasks(p->weightsList, p->weightsCoeff, saturateMask);
+    p->srcRgbl = p->linear->linearize(maskCopyTo(p->src, p->mask));
+    p->ref.colors = maskCopyTo(p->ref.colors, p->mask);
+    p->dstRgbl = p->ref.to(*(p->cs.l)).colors;
+
+    // make no change for CCM_LINEAR, make change for CCM_AFFINE.
+    p->srcRgbl = p->prepare(p->srcRgbl);
+
+    // distance function may affect the loss function and the fitting function
+    switch (p->distance)
+    {
+    case cv::ccm::DISTANCE_RGBL:
+        p->initialLeastSquare(true);
+        break;
+    default:
+        switch (p->initialMethodType)
+        {
+        case cv::ccm::INITIAL_METHOD_WHITE_BALANCE:
+            p->initialWhiteBalance();
+            break;
+        case cv::ccm::INITIAL_METHOD_LEAST_SQUARE:
+            p->initialLeastSquare();
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "Wrong initial_methoddistance_type!" );
+            break;
+        }
+        break;
+    }
+    p->fitting();
+
+    return p->ccm;
+}
+Mat ColorCorrectionModel::getColorCorrectionMatrix() const
+{
+    return p->ccm;
+}
+double ColorCorrectionModel::getLoss() const
+{
+    return p->loss;
+}
+Mat ColorCorrectionModel::getSrcLinearRGB() const{
+    return p->srcRgbl;
+}
+Mat ColorCorrectionModel::getRefLinearRGB() const{
+    return p->dstRgbl;
+}
+Mat ColorCorrectionModel::getMask() const{
+    return p->mask;
+}
+Mat ColorCorrectionModel::getWeights() const{
+    return p->weights;
+}
+
+void ColorCorrectionModel::write(FileStorage& fs) const
+{
+    fs << "ColorCorrectionModel" << "{"
+       << "ccm" << p->ccm
+       << "loss" << p->loss
+       << "csEnum" << p->csEnum
+       << "ccm_type" << p->ccmType
+       << "shape" << p->shape
+       << "linear" << *p->linear
+       << "distance" << p->distance
+       << "linear_type" << p->linearizationType
+       << "gamma" << p->gamma
+       << "deg" << p->deg
+       << "saturated_threshold" << p->saturatedThreshold
+       << "}";
+}
+
+void ColorCorrectionModel::read(const FileNode& node)
+{
+    node["ccm"] >> p->ccm;
+    node["loss"] >> p->loss;
+    node["ccm_type"] >> p->ccmType;
+    node["shape"] >> p->shape;
+    node["distance"] >> p->distance;
+    node["gamma"] >> p->gamma;
+    node["deg"] >> p->deg;
+    node["saturated_threshold"] >> p->saturatedThreshold;
+
+    ColorSpace csEnum;
+    node["csEnum"] >> csEnum;
+    setColorSpace(csEnum);
+
+    node["linear_type"] >> p->linearizationType;
+    switch (p->linearizationType) {
+        case cv::ccm::LINEARIZATION_GAMMA:
+            p->linear = std::shared_ptr<Linear>(new LinearGamma());
+            break;
+        case cv::ccm::LINEARIZATION_COLORPOLYFIT:
+            p->linear = std::shared_ptr<Linear>(new LinearColor<Polyfit>());
+            break;
+        case cv::ccm::LINEARIZATION_IDENTITY:
+            p->linear = std::shared_ptr<Linear>(new LinearIdentity());
+            break;
+        case cv::ccm::LINEARIZATION_COLORLOGPOLYFIT:
+            p->linear = std::shared_ptr<Linear>(new LinearColor<LogPolyfit>());
+            break;
+        case cv::ccm::LINEARIZATION_GRAYPOLYFIT:
+            p->linear = std::shared_ptr<Linear>(new LinearGray<Polyfit>());
+            break;
+        case cv::ccm::LINEARIZATION_GRAYLOGPOLYFIT:
+            p->linear = std::shared_ptr<Linear>(new LinearGray<LogPolyfit>());
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "Wrong linear_type!");
+            break;
+    }
+    node["linear"] >> *p->linear;
+}
+
+void write(FileStorage& fs, const std::string&, const cv::ccm::ColorCorrectionModel& ccm)
+{
+    ccm.write(fs);
+}
+
+void read(const cv::FileNode& node, cv::ccm::ColorCorrectionModel& ccm, const cv::ccm::ColorCorrectionModel& defaultValue)
+{
+    if (node.empty())
+        ccm = defaultValue;
+    else
+        ccm.read(node);
+}
+
+}
+}  // namespace cv::ccm
diff --git a/upstream/opencv/modules/photo/src/ccm/color.cpp b/upstream/opencv/modules/photo/src/ccm/color.cpp
new file mode 100644
index 0000000..756804f
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/color.cpp
@@ -0,0 +1,391 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "color.hpp"
+
+namespace cv {
+namespace ccm {
+Color::Color()
+    : colors(Mat())
+    , cs(std::make_shared<ColorSpaceBase>())
+{}
+Color::Color(Mat colors_, enum ColorSpace cs_)
+    : colors(colors_)
+    , cs(GetCS::getInstance().getCS(cs_))
+{}
+
+Color::Color(Mat colors_, enum ColorSpace cs_, Mat colored_)
+    : colors(colors_)
+    , cs(GetCS::getInstance().getCS(cs_))
+    , colored(colored_)
+{
+    grays = ~colored;
+}
+Color::Color(Mat colors_, const ColorSpaceBase& cs_, Mat colored_)
+    : colors(colors_)
+    , cs(std::make_shared<ColorSpaceBase>(cs_))
+    , colored(colored_)
+{
+    grays = ~colored;
+}
+
+Color::Color(Mat colors_, const ColorSpaceBase& cs_)
+    : colors(colors_)
+    , cs(std::make_shared<ColorSpaceBase>(cs_))
+{}
+
+Color::Color(Mat colors_, std::shared_ptr<ColorSpaceBase> cs_)
+    : colors(colors_)
+    , cs(cs_)
+{}
+
+Color Color::to(const ColorSpaceBase& other, ChromaticAdaptationType method, bool save)
+{
+    auto it = history.find(other);
+    if ( it != history.end() )
+    {
+        return *(it->second);
+    }
+    if (cs->relate(other))
+    {
+        return Color(cs->relation(other).run(colors), other);
+    }
+    Operations ops;
+    ops.add(cs->to).add(XYZ(cs->illumobserver).cam(other.illumobserver, method)).add(other.from);
+    Mat converted = ops.run(colors);
+    if (save)
+    {
+        auto ptr = std::make_shared<Color>(converted, other);
+        history[other] = ptr;
+        return *ptr;
+    }
+    else
+    {
+        return Color(converted, other);
+    }
+}
+
+Color Color::to(ColorSpace other, ChromaticAdaptationType method, bool save)
+{
+    return to(*GetCS::getInstance().getCS(other), method, save);
+}
+
+Mat Color::channel(Mat m, int i)
+{
+    Mat dchannels[3];
+    split(m, dchannels);
+    return dchannels[i];
+}
+
+Mat Color::toGray(const IllumObserver& illumobserver, ChromaticAdaptationType method, bool save)
+{
+    XYZ xyz = *XYZ::get(illumobserver);
+    return channel(this->to(xyz, method, save).colors, 1);
+}
+
+Mat Color::toLuminant(const IllumObserver& illumobserver, ChromaticAdaptationType method, bool save)
+{
+    Lab lab = *Lab::get(illumobserver);
+    return channel(this->to(lab, method, save).colors, 0);
+}
+
+Mat Color::diff(Color& other, DistanceType method)
+{
+    return diff(other, cs->illumobserver, method);
+}
+
+Mat Color::diff(Color& other, const IllumObserver& illumobserver, DistanceType method)
+{
+    Lab lab = *Lab::get(illumobserver);
+    switch (method)
+    {
+    case cv::ccm::DISTANCE_CIE76:
+    case cv::ccm::DISTANCE_CIE94_GRAPHIC_ARTS:
+    case cv::ccm::DISTANCE_CIE94_TEXTILES:
+    case cv::ccm::DISTANCE_CIE2000:
+    case cv::ccm::DISTANCE_CMC_1TO1:
+    case cv::ccm::DISTANCE_CMC_2TO1:
+        return distance(to(lab).colors, other.to(lab).colors, method);
+    case cv::ccm::DISTANCE_RGB:
+        return distance(to(*cs->nl).colors, other.to(*cs->nl).colors, method);
+    case cv::ccm::DISTANCE_RGBL:
+        return distance(to(*cs->l).colors, other.to(*cs->l).colors, method);
+    default:
+        CV_Error(Error::StsBadArg, "Wrong method!" );
+        break;
+    }
+}
+
+void Color::getGray(double JDN)
+{
+    if (!grays.empty())
+    {
+        return;
+    }
+    Mat lab = to(COLOR_SPACE_LAB_D65_2).colors;
+    Mat gray(colors.size(), colors.type());
+    int fromto[] = { 0, 0, -1, 1, -1, 2 };
+    mixChannels(&lab, 1, &gray, 1, fromto, 3);
+    Mat d = distance(lab, gray, DISTANCE_CIE2000);
+    this->grays = d < JDN;
+    this->colored = ~grays;
+}
+
+Color Color::operator[](Mat mask)
+{
+    return Color(maskCopyTo(colors, mask), cs);
+}
+
+Mat GetColor::getColorChecker(const double* checker, int row)
+{
+    Mat res(row, 1, CV_64FC3);
+    for (int i = 0; i < row; ++i)
+    {
+        res.at<Vec3d>(i, 0) = Vec3d(checker[3 * i], checker[3 * i + 1], checker[3 * i + 2]);
+    }
+    return res;
+}
+
+Mat GetColor::getColorCheckerMask(const uchar* checker, int row)
+{
+    Mat res(row, 1, CV_8U);
+    for (int i = 0; i < row; ++i)
+    {
+        res.at<uchar>(i, 0) = checker[i];
+    }
+    return res;
+}
+
+Color GetColor::getColor(ColorCheckerType const_color)
+{
+
+    /** @brief Data is from https://www.imatest.com/wp-content/uploads/2011/11/Lab-data-Iluminate-D65-D50-spectro.xls
+           see Miscellaneous.md for details.
+*/
+    static const double ColorChecker2005_LAB_D50_2[24][3] = { { 37.986, 13.555, 14.059 },
+        { 65.711, 18.13, 17.81 },
+        { 49.927, -4.88, -21.925 },
+        { 43.139, -13.095, 21.905 },
+        { 55.112, 8.844, -25.399 },
+        { 70.719, -33.397, -0.199 },
+        { 62.661, 36.067, 57.096 },
+        { 40.02, 10.41, -45.964 },
+        { 51.124, 48.239, 16.248 },
+        { 30.325, 22.976, -21.587 },
+        { 72.532, -23.709, 57.255 },
+        { 71.941, 19.363, 67.857 },
+        { 28.778, 14.179, -50.297 },
+        { 55.261, -38.342, 31.37 },
+        { 42.101, 53.378, 28.19 },
+        { 81.733, 4.039, 79.819 },
+        { 51.935, 49.986, -14.574 },
+        { 51.038, -28.631, -28.638 },
+        { 96.539, -0.425, 1.186 },
+        { 81.257, -0.638, -0.335 },
+        { 66.766, -0.734, -0.504 },
+        { 50.867, -0.153, -0.27 },
+        { 35.656, -0.421, -1.231 },
+        { 20.461, -0.079, -0.973 } };
+
+    static const uchar ColorChecker2005_COLORED_MASK[24] = { 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0 };
+    static const double Vinyl_LAB_D50_2[18][3] = { { 100, 0.00520000001, -0.0104 },
+        { 73.0833969, -0.819999993, -2.02099991 },
+        { 62.493, 0.425999999, -2.23099995 },
+        { 50.4640007, 0.446999997, -2.32399988 },
+        { 37.7970009, 0.0359999985, -1.29700005 },
+        { 0, 0, 0 },
+        { 51.5880013, 73.5179977, 51.5690002 },
+        { 93.6989975, -15.7340002, 91.9420013 },
+        { 69.4079971, -46.5940018, 50.4869995 },
+        { 66.61000060000001, -13.6789999, -43.1720009 },
+        { 11.7110004, 16.9799995, -37.1759987 },
+        { 51.973999, 81.9440002, -8.40699959 },
+        { 40.5489998, 50.4399986, 24.8490009 },
+        { 60.8160019, 26.0690002, 49.4420013 },
+        { 52.2529984, -19.9500008, -23.9960003 },
+        { 51.2859993, 48.4700012, -15.0579996 },
+        { 68.70700069999999, 12.2959995, 16.2129993 },
+        { 63.6839981, 10.2930002, 16.7639999 } };
+    static const uchar Vinyl_COLORED_MASK[18] = { 0, 0, 0, 0, 0, 0,
+        1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1 };
+    static const double DigitalSG_LAB_D50_2[140][3] = { { 96.55, -0.91, 0.57 },
+        { 6.43, -0.06, -0.41 },
+        { 49.7, -0.18, 0.03 },
+        { 96.5, -0.89, 0.59 },
+        { 6.5, -0.06, -0.44 },
+        { 49.66, -0.2, 0.01 },
+        { 96.52, -0.91, 0.58 },
+        { 6.49, -0.02, -0.28 },
+        { 49.72, -0.2, 0.04 },
+        { 96.43, -0.91, 0.67 },
+        { 49.72, -0.19, 0 },
+        { 32.6, 51.58, -10.85 },
+        { 60.75, 26.22, -18.6 },
+        { 28.69, 48.28, -39 },
+        { 49.38, -15.43, -48.48 },
+        { 60.63, -30.77, -26.23 },
+        { 19.29, -26.37, -6.15 },
+        { 60.15, -41.77, -12.6 },
+        { 21.42, 1.67, 8.79 },
+        { 49.69, -0.2, 0.01 },
+        { 6.5, -0.03, -0.67 },
+        { 21.82, 17.33, -18.35 },
+        { 41.53, 18.48, -37.26 },
+        { 19.99, -0.16, -36.29 },
+        { 60.16, -18.45, -31.42 },
+        { 19.94, -17.92, -20.96 },
+        { 60.68, -6.05, -32.81 },
+        { 50.81, -49.8, -9.63 },
+        { 60.65, -39.77, 20.76 },
+        { 6.53, -0.03, -0.43 },
+        { 96.56, -0.91, 0.59 },
+        { 84.19, -1.95, -8.23 },
+        { 84.75, 14.55, 0.23 },
+        { 84.87, -19.07, -0.82 },
+        { 85.15, 13.48, 6.82 },
+        { 84.17, -10.45, 26.78 },
+        { 61.74, 31.06, 36.42 },
+        { 64.37, 20.82, 18.92 },
+        { 50.4, -53.22, 14.62 },
+        { 96.51, -0.89, 0.65 },
+        { 49.74, -0.19, 0.03 },
+        { 31.91, 18.62, 21.99 },
+        { 60.74, 38.66, 70.97 },
+        { 19.35, 22.23, -58.86 },
+        { 96.52, -0.91, 0.62 },
+        { 6.66, 0, -0.3 },
+        { 76.51, 20.81, 22.72 },
+        { 72.79, 29.15, 24.18 },
+        { 22.33, -20.7, 5.75 },
+        { 49.7, -0.19, 0.01 },
+        { 6.53, -0.05, -0.61 },
+        { 63.42, 20.19, 19.22 },
+        { 34.94, 11.64, -50.7 },
+        { 52.03, -44.15, 39.04 },
+        { 79.43, 0.29, -0.17 },
+        { 30.67, -0.14, -0.53 },
+        { 63.6, 14.44, 26.07 },
+        { 64.37, 14.5, 17.05 },
+        { 60.01, -44.33, 8.49 },
+        { 6.63, -0.01, -0.47 },
+        { 96.56, -0.93, 0.59 },
+        { 46.37, -5.09, -24.46 },
+        { 47.08, 52.97, 20.49 },
+        { 36.04, 64.92, 38.51 },
+        { 65.05, 0, -0.32 },
+        { 40.14, -0.19, -0.38 },
+        { 43.77, 16.46, 27.12 },
+        { 64.39, 17, 16.59 },
+        { 60.79, -29.74, 41.5 },
+        { 96.48, -0.89, 0.64 },
+        { 49.75, -0.21, 0.01 },
+        { 38.18, -16.99, 30.87 },
+        { 21.31, 29.14, -27.51 },
+        { 80.57, 3.85, 89.61 },
+        { 49.71, -0.2, 0.03 },
+        { 60.27, 0.08, -0.41 },
+        { 67.34, 14.45, 16.9 },
+        { 64.69, 16.95, 18.57 },
+        { 51.12, -49.31, 44.41 },
+        { 49.7, -0.2, 0.02 },
+        { 6.67, -0.05, -0.64 },
+        { 51.56, 9.16, -26.88 },
+        { 70.83, -24.26, 64.77 },
+        { 48.06, 55.33, -15.61 },
+        { 35.26, -0.09, -0.24 },
+        { 75.16, 0.25, -0.2 },
+        { 44.54, 26.27, 38.93 },
+        { 35.91, 16.59, 26.46 },
+        { 61.49, -52.73, 47.3 },
+        { 6.59, -0.05, -0.5 },
+        { 96.58, -0.9, 0.61 },
+        { 68.93, -34.58, -0.34 },
+        { 69.65, 20.09, 78.57 },
+        { 47.79, -33.18, -30.21 },
+        { 15.94, -0.42, -1.2 },
+        { 89.02, -0.36, -0.48 },
+        { 63.43, 25.44, 26.25 },
+        { 65.75, 22.06, 27.82 },
+        { 61.47, 17.1, 50.72 },
+        { 96.53, -0.89, 0.66 },
+        { 49.79, -0.2, 0.03 },
+        { 85.17, 10.89, 17.26 },
+        { 89.74, -16.52, 6.19 },
+        { 84.55, 5.07, -6.12 },
+        { 84.02, -13.87, -8.72 },
+        { 70.76, 0.07, -0.35 },
+        { 45.59, -0.05, 0.23 },
+        { 20.3, 0.07, -0.32 },
+        { 61.79, -13.41, 55.42 },
+        { 49.72, -0.19, 0.02 },
+        { 6.77, -0.05, -0.44 },
+        { 21.85, 34.37, 7.83 },
+        { 42.66, 67.43, 48.42 },
+        { 60.33, 36.56, 3.56 },
+        { 61.22, 36.61, 17.32 },
+        { 62.07, 52.8, 77.14 },
+        { 72.42, -9.82, 89.66 },
+        { 62.03, 3.53, 57.01 },
+        { 71.95, -27.34, 73.69 },
+        { 6.59, -0.04, -0.45 },
+        { 49.77, -0.19, 0.04 },
+        { 41.84, 62.05, 10.01 },
+        { 19.78, 29.16, -7.85 },
+        { 39.56, 65.98, 33.71 },
+        { 52.39, 68.33, 47.84 },
+        { 81.23, 24.12, 87.51 },
+        { 81.8, 6.78, 95.75 },
+        { 71.72, -16.23, 76.28 },
+        { 20.31, 14.45, 16.74 },
+        { 49.68, -0.19, 0.05 },
+        { 96.48, -0.88, 0.68 },
+        { 49.69, -0.18, 0.03 },
+        { 6.39, -0.04, -0.33 },
+        { 96.54, -0.9, 0.67 },
+        { 49.72, -0.18, 0.05 },
+        { 6.49, -0.03, -0.41 },
+        { 96.51, -0.9, 0.69 },
+        { 49.7, -0.19, 0.07 },
+        { 6.47, 0, -0.38 },
+        { 96.46, -0.89, 0.7 } };
+
+    switch (const_color)
+    {
+
+    case cv::ccm::COLORCHECKER_MACBETH:
+    {
+        Mat ColorChecker2005_LAB_D50_2_ = GetColor::getColorChecker(*ColorChecker2005_LAB_D50_2, 24);
+        Mat ColorChecker2005_COLORED_MASK_ = GetColor::getColorCheckerMask(ColorChecker2005_COLORED_MASK, 24);
+        Color Macbeth_D50_2 = Color(ColorChecker2005_LAB_D50_2_, COLOR_SPACE_LAB_D50_2, ColorChecker2005_COLORED_MASK_);
+        return Macbeth_D50_2;
+    }
+
+    case cv::ccm::COLORCHECKER_VINYL:
+    {
+        Mat Vinyl_LAB_D50_2__ = GetColor::getColorChecker(*Vinyl_LAB_D50_2, 18);
+        Mat Vinyl_COLORED_MASK__ = GetColor::getColorCheckerMask(Vinyl_COLORED_MASK, 18);
+        Color Vinyl_D50_2 = Color(Vinyl_LAB_D50_2__, COLOR_SPACE_LAB_D50_2, Vinyl_COLORED_MASK__);
+        return Vinyl_D50_2;
+    }
+
+    case cv::ccm::COLORCHECKER_DIGITAL_SG:
+    {
+        Mat DigitalSG_LAB_D50_2__ = GetColor::getColorChecker(*DigitalSG_LAB_D50_2, 140);
+        Color DigitalSG_D50_2 = Color(DigitalSG_LAB_D50_2__, COLOR_SPACE_LAB_D50_2);
+        return DigitalSG_D50_2;
+    }
+    }
+    CV_Error(Error::StsNotImplemented, "");
+}
+
+}
+}  // namespace cv::ccm
diff --git a/upstream/opencv/modules/photo/src/ccm/color.hpp b/upstream/opencv/modules/photo/src/ccm/color.hpp
new file mode 100644
index 0000000..669904c
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/color.hpp
@@ -0,0 +1,108 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_COLOR_HPP__
+#define __OPENCV_CCM_COLOR_HPP__
+
+#include "distance.hpp"
+#include "colorspace.hpp"
+#include "opencv2/photo.hpp"
+
+namespace cv {
+namespace ccm {
+
+/** @brief Color defined by color_values and color space
+*/
+
+class Color
+{
+public:
+    /** @param grays mask of grayscale color
+        @param colored mask of colored color
+        @param history storage of historical conversion
+    */
+    Mat colors;
+    std::shared_ptr<ColorSpaceBase> cs;
+    Mat grays;
+    Mat colored;
+    std::map<ColorSpaceBase, std::shared_ptr<Color>> history;
+
+    Color();
+    Color(Mat colors_, enum ColorSpace cs_);
+    Color(Mat colors_, enum ColorSpace cs_, Mat colored);
+    Color(Mat colors_, const ColorSpaceBase& cs, Mat colored);
+    Color(Mat colors_, const ColorSpaceBase& cs);
+    Color(Mat colors_, std::shared_ptr<ColorSpaceBase> cs_);
+    virtual ~Color() {};
+
+    /** @brief Change to other color space.
+                 The conversion process incorporates linear transformations to speed up.
+        @param other type of ColorSpaceBase.
+        @param  method the chromatic adapation method.
+        @param save when save if True, get data from history first.
+        @return Color.
+    */
+    Color to(const ColorSpaceBase& other, ChromaticAdaptationType method = BRADFORD, bool save = true);
+
+    /** @brief Convert color to another color space using ColorSpace enum.
+        @param other type of ColorSpace.
+        @param method the method of chromatic adaptation.
+        @param save whether to save the conversion history.
+        @return the output array, type of Color.
+    */
+    Color to(ColorSpace other, ChromaticAdaptationType method = BRADFORD, bool save = true);
+
+    /** @brief Channels split.
+       @return each channel.
+    */
+    Mat channel(Mat m, int i);
+
+    /** @brief To Gray.
+    */
+    Mat toGray(const IllumObserver& illumobserver, ChromaticAdaptationType method = BRADFORD, bool save = true);
+
+    /** @brief To Luminant.
+    */
+    Mat toLuminant(const IllumObserver& illumobserver, ChromaticAdaptationType method = BRADFORD, bool save = true);
+
+    /** @brief Diff without IllumObserver.
+        @param other type of Color.
+        @param method type of distance.
+        @return distance between self and other
+    */
+    Mat diff(Color& other, DistanceType method = DISTANCE_CIE2000);
+
+    /** @brief Diff with IllumObserver.
+        @param other type of Color.
+        @param illumobserver type of IllumObserver.
+        @param method type of distance.
+        @return distance between self and other
+    */
+    Mat diff(Color& other, const IllumObserver& illumobserver, DistanceType method = DISTANCE_CIE2000);
+
+    /** @brief Calculate gray mask.
+    */
+    void getGray(double JDN = 2.0);
+
+    /** @brief Operator for mask copy.
+    */
+    Color operator[](Mat mask);
+};
+
+class GetColor
+{
+public:
+    Color getColor(ColorCheckerType const_color);
+    static Mat getColorChecker(const double* checker, int row);
+    static Mat getColorCheckerMask(const uchar* checker, int row);
+};
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/colorspace.cpp b/upstream/opencv/modules/photo/src/ccm/colorspace.cpp
new file mode 100644
index 0000000..e9f73e4
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/colorspace.cpp
@@ -0,0 +1,769 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "colorspace.hpp"
+#include "operations.hpp"
+#include "illumobserver.hpp"
+
+namespace cv {
+namespace ccm {
+static const std::vector<double>& getIlluminants(const IllumObserver& illumobserver)
+{
+    static const std::map<IllumObserver, std::vector<double>> illuminants = {
+        { IllumObserver::getIllumObservers(A_2), { 1.098466069456375, 1, 0.3558228003436005 } },
+        { IllumObserver::getIllumObservers(A_10), { 1.111420406956693, 1, 0.3519978321919493 } },
+        { IllumObserver::getIllumObservers(D50_2), { 0.9642119944211994, 1, 0.8251882845188288 } },
+        { IllumObserver::getIllumObservers(D50_10), { 0.9672062750333777, 1, 0.8142801513128616 } },
+        { IllumObserver::getIllumObservers(D55_2), { 0.956797052643698, 1, 0.9214805860173273 } },
+        { IllumObserver::getIllumObservers(D55_10), { 0.9579665682254781, 1, 0.9092525159847462 } },
+        { IllumObserver::getIllumObservers(D65_2), { 0.95047, 1., 1.08883 } },
+        { IllumObserver::getIllumObservers(D65_10), { 0.94811, 1., 1.07304 } },
+        { IllumObserver::getIllumObservers(D75_2), { 0.9497220898840717, 1, 1.226393520724154 } },
+        { IllumObserver::getIllumObservers(D75_10), { 0.9441713925645873, 1, 1.2064272211720228 } },
+        { IllumObserver::getIllumObservers(E_2), { 1., 1., 1. } },
+        { IllumObserver::getIllumObservers(E_10), { 1., 1., 1. } },
+    };
+    auto it = illuminants.find(illumobserver);
+    CV_Assert(it != illuminants.end());
+    return it->second;
+};
+
+/* @brief Basic class for ColorSpaceBase.
+ */
+bool ColorSpaceBase::relate(const ColorSpaceBase& other) const
+{
+    return (type == other.type) && (illumobserver == other.illumobserver);
+};
+
+Operations ColorSpaceBase::relation(const ColorSpaceBase& /*other*/) const
+{
+    return Operations::getIdentityOps();
+}
+
+bool ColorSpaceBase::operator<(const ColorSpaceBase& other) const
+{
+    return (illumobserver < other.illumobserver || (illumobserver == other.illumobserver && type < other.type) || (illumobserver == other.illumobserver && type == other.type && linear < other.linear));
+}
+
+/* @brief Base of RGB color space;
+ *        the argument values are from AdobeRGB;
+ *        Data from https://en.wikipedia.org/wiki/Adobe_RGB_color_space
+ */
+Operations RGBBase_::relation(const ColorSpaceBase& other) const
+{
+    if (linear == other.linear)
+    {
+        return Operations::getIdentityOps();
+    }
+    if (linear)
+    {
+        return Operations({ Operation([this](Mat rgbl) -> Mat { return fromLFunc(rgbl); }) });
+    }
+    return Operations({ Operation([this](Mat rgb) -> Mat { return toLFunc(rgb); })});
+}
+
+/* @brief Initial operations.
+ */
+void RGBBase_::init()
+{
+    setParameter();
+    calLinear();
+    calM();
+    calOperations();
+}
+
+/* @brief Produce color space instance with linear and non-linear versions.
+ * @param rgbl type of RGBBase_.
+ */
+void RGBBase_::bind(RGBBase_& rgbl)
+{
+    init();
+    rgbl.init();
+    l = &rgbl;
+    rgbl.l = &rgbl;
+    nl = this;
+    rgbl.nl = this;
+}
+
+/* @brief Calculation of M_RGBL2XYZ_base.
+ */
+void RGBBase_::calM()
+{
+    Mat XYZr, XYZg, XYZb, XYZ_rgbl, Srgb;
+    XYZr = Mat(xyY2XYZ({ xr, yr }), true);
+    XYZg = Mat(xyY2XYZ({ xg, yg }), true);
+    XYZb = Mat(xyY2XYZ({ xb, yb }), true);
+    merge(std::vector<Mat> { XYZr, XYZg, XYZb }, XYZ_rgbl);
+    XYZ_rgbl = XYZ_rgbl.reshape(1, (int)XYZ_rgbl.total());
+    Mat XYZw = Mat(getIlluminants(illumobserver), true);
+    XYZw = XYZw.reshape(1, (int)XYZw.total());
+    solve(XYZ_rgbl, XYZw, Srgb);
+    merge(std::vector<Mat> { Srgb.at<double>(0) * XYZr, Srgb.at<double>(1) * XYZg,
+                  Srgb.at<double>(2) * XYZb },
+            M_to);
+    M_to = M_to.reshape(1, (int)M_to.total());
+    M_from = M_to.inv();
+};
+
+/* @brief operations to or from XYZ.
+ */
+void RGBBase_::calOperations()
+{
+    if (linear)
+    {
+        to = Operations({ Operation(M_to.t()) });
+        from = Operations({ Operation(M_from.t()) });
+    }
+    else
+    {
+        // rgb -> rgbl
+        to = Operations({ Operation([this](Mat rgb) -> Mat { return toLFunc(rgb); }), Operation(M_to.t()) });
+        // rgbl -> rgb
+        from = Operations({ Operation(M_from.t()), Operation([this](Mat rgbl) -> Mat { return fromLFunc(rgbl); }) });
+    }
+}
+
+Mat RGBBase_::toLFunc(Mat& /*rgb*/) const { return Mat(); }
+
+Mat RGBBase_::fromLFunc(Mat& /*rgbl*/, Mat dst) const { return dst; }
+
+/* @brief Base of Adobe RGB color space;
+ */
+
+Mat AdobeRGBBase_::toLFunc(Mat& rgb) const
+{
+    Mat out;
+    gammaCorrection(rgb, out, gamma);
+    return out;
+}
+
+Mat AdobeRGBBase_::fromLFunc(Mat& rgbl, Mat dst) const
+{
+    gammaCorrection(rgbl, dst, 1. / gamma);
+    return dst;
+}
+
+/* @brief Base of sRGB color space;
+ */
+
+void sRGBBase_::calLinear()
+{
+    alpha = a + 1;
+    K0 = a / (gamma - 1);
+    phi = (pow(alpha, gamma) * pow(gamma - 1, gamma - 1)) / (pow(a, gamma - 1) * pow(gamma, gamma));
+    beta = K0 / phi;
+}
+
+/* @brief Used by toLFunc.
+ */
+double sRGBBase_::toLFuncEW(double x) const
+{
+    if (x > K0)
+    {
+        return pow(((x + alpha - 1) / alpha), gamma);
+    }
+    else if (x >= -K0)
+    {
+        return x / phi;
+    }
+    else
+    {
+        return -(pow(((-x + alpha - 1) / alpha), gamma));
+    }
+}
+
+/* @brief Linearization.
+ * @param rgb the input array, type of cv::Mat.
+ * @return the output array, type of cv::Mat.
+ */
+Mat sRGBBase_::toLFunc(Mat& rgb) const
+{
+    return elementWise(rgb,
+            [this](double a_) -> double { return toLFuncEW(a_); });
+}
+
+/* @brief Used by fromLFunc.
+ */
+double sRGBBase_::fromLFuncEW(double x) const
+{
+    if (x > beta)
+    {
+        return alpha * pow(x, 1 / gamma) - (alpha - 1);
+    }
+    else if (x >= -beta)
+    {
+        return x * phi;
+    }
+    else
+    {
+        return -(alpha * pow(-x, 1 / gamma) - (alpha - 1));
+    }
+}
+
+/* @brief Delinearization.
+ * @param rgbl the input array, type of cv::Mat.
+ * @return the output array, type of cv::Mat.
+ */
+Mat sRGBBase_::fromLFunc(Mat& rgbl, Mat dst) const
+{
+    return elementWise(rgbl, [this](double a_) -> double { return fromLFuncEW(a_); }, dst);
+}
+
+/* @brief sRGB color space.
+ *        data from https://en.wikipedia.org/wiki/SRGB.
+ */
+void sRGB_::setParameter()
+{
+    xr = 0.64;
+    yr = 0.33;
+    xg = 0.3;
+    yg = 0.6;
+    xb = 0.15;
+    yb = 0.06;
+    a = 0.055;
+    gamma = 2.4;
+}
+
+/* @brief Adobe RGB color space.
+ */
+void AdobeRGB_::setParameter()
+{
+    xr = 0.64;
+    yr = 0.33;
+    xg = 0.21;
+    yg = 0.71;
+    xb = 0.15;
+    yb = 0.06;
+    gamma = 2.2;
+}
+
+/* @brief Wide-gamut RGB color space.
+ *        data from https://en.wikipedia.org/wiki/Wide-gamut_RGB_color_space.
+ */
+void WideGamutRGB_::setParameter()
+{
+    xr = 0.7347;
+    yr = 0.2653;
+    xg = 0.1152;
+    yg = 0.8264;
+    xb = 0.1566;
+    yb = 0.0177;
+    gamma = 2.2;
+}
+
+/* @brief ProPhoto RGB color space.
+ *        data from https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space.
+ */
+void ProPhotoRGB_::setParameter()
+{
+    xr = 0.734699;
+    yr = 0.265301;
+    xg = 0.159597;
+    yg = 0.840403;
+    xb = 0.036598;
+    yb = 0.000105;
+    gamma = 1.8;
+}
+
+/* @brief DCI-P3 RGB color space.
+ *        data from https://en.wikipedia.org/wiki/DCI-P3.
+ */
+
+void DCI_P3_RGB_::setParameter()
+{
+    xr = 0.68;
+    yr = 0.32;
+    xg = 0.265;
+    yg = 0.69;
+    xb = 0.15;
+    yb = 0.06;
+    gamma = 2.2;
+}
+
+/* @brief Apple RGB color space.
+ *        data from
+ * http://www.brucelindbloom.com/index.html?WorkingSpaceInfo.html.
+ */
+void AppleRGB_::setParameter()
+{
+    xr = 0.625;
+    yr = 0.34;
+    xg = 0.28;
+    yg = 0.595;
+    xb = 0.155;
+    yb = 0.07;
+    gamma = 1.8;
+}
+
+/* @brief REC_709 RGB color space.
+ *        data from https://en.wikipedia.org/wiki/Rec._709.
+ */
+void REC_709_RGB_::setParameter()
+{
+    xr = 0.64;
+    yr = 0.33;
+    xg = 0.3;
+    yg = 0.6;
+    xb = 0.15;
+    yb = 0.06;
+    a = 0.099;
+    gamma = 1 / 0.45;
+}
+
+/* @brief REC_2020 RGB color space.
+ *        data from https://en.wikipedia.org/wiki/Rec._2020.
+ */
+
+void REC_2020_RGB_::setParameter()
+{
+    xr = 0.708;
+    yr = 0.292;
+    xg = 0.17;
+    yg = 0.797;
+    xb = 0.131;
+    yb = 0.046;
+    a = 0.09929682680944;
+    gamma = 1 / 0.45;
+}
+
+Operations XYZ::cam(IllumObserver dio, ChromaticAdaptationType method)
+{
+    return (illumobserver == dio) ? Operations()
+                       : Operations({ Operation(cam_(illumobserver, dio, method).t()) });
+}
+Mat XYZ::cam_(IllumObserver sio, IllumObserver dio, ChromaticAdaptationType method) const
+{
+    static std::map<std::tuple<IllumObserver, IllumObserver, ChromaticAdaptationType>, Mat> cams;
+
+    if (sio == dio)
+    {
+        return Mat::eye(cv::Size(3, 3), CV_64FC1);
+    }
+    if (cams.count(std::make_tuple(dio, sio, method)) == 1)
+    {
+        return cams[std::make_tuple(dio, sio, method)];
+    }
+    /* @brief XYZ color space.
+    *        Chromatic adaption matrices.
+    */
+
+    static const Mat Von_Kries = (Mat_<double>(3, 3) << 0.40024, 0.7076, -0.08081, -0.2263, 1.16532, 0.0457, 0., 0., 0.91822);
+    static const Mat Bradford = (Mat_<double>(3, 3) << 0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296);
+    static const std::map<ChromaticAdaptationType, std::vector<Mat>> MAs = {
+        { IDENTITY, { Mat::eye(Size(3, 3), CV_64FC1), Mat::eye(Size(3, 3), CV_64FC1) } },
+        { VON_KRIES, { Von_Kries, Von_Kries.inv() } },
+        { BRADFORD, { Bradford, Bradford.inv() } }
+    };
+
+    // Function from http://www.brucelindbloom.com/index.html?ColorCheckerRGB.html.
+    Mat XYZws = Mat(getIlluminants(dio));
+    Mat XYZWd = Mat(getIlluminants(sio));
+    XYZws = XYZws.reshape(1, (int)XYZws.total());
+    XYZWd = XYZWd.reshape(1, (int)XYZWd.total());
+    Mat MA = MAs.at(method)[0];
+    Mat MA_inv = MAs.at(method)[1];
+    Mat M = MA_inv * Mat::diag((MA * XYZws) / (MA * XYZWd)) * MA;
+    cams[std::make_tuple(dio, sio, method)] = M;
+    cams[std::make_tuple(sio, dio, method)] = M.inv();
+    return M;
+}
+
+std::shared_ptr<XYZ> XYZ::get(IllumObserver illumobserver)
+{
+    static std::map<IllumObserver, std::shared_ptr<XYZ>> xyz_cs;
+
+    if (xyz_cs.count(illumobserver) == 1)
+    {
+        return xyz_cs[illumobserver];
+    }
+    std::shared_ptr<XYZ> XYZ_CS = std::make_shared<XYZ>(illumobserver);
+    xyz_cs[illumobserver] = XYZ_CS;
+    return xyz_cs[illumobserver];
+}
+
+/* @brief Lab color space.
+ */
+Lab::Lab(IllumObserver illumobserver_)
+    : ColorSpaceBase(illumobserver_, "Lab", true)
+{
+    to = { Operation([this](Mat src) -> Mat { return tosrc(src); }) };
+    from = { Operation([this](Mat src) -> Mat { return fromsrc(src); }) };
+}
+
+Vec3d Lab::fromxyz(const Vec3d& xyz)
+{
+    auto& il = getIlluminants(illumobserver);
+    double x = xyz[0] / il[0],
+           y = xyz[1] / il[1],
+           z = xyz[2] / il[2];
+    auto f = [](double t) -> double {
+        return t > T0 ? std::cbrt(t) : (M * t + C);
+    };
+    double fx = f(x), fy = f(y), fz = f(z);
+    return { 116. * fy - 16., 500 * (fx - fy), 200 * (fy - fz) };
+}
+
+/* @brief Calculate From.
+ * @param src the input array, type of cv::Mat.
+ * @return the output array, type of cv::Mat
+ */
+Mat Lab::fromsrc(Mat& src)
+{
+    return channelWise(src,
+            [this](cv::Vec3d a) -> cv::Vec3d { return fromxyz(a); });
+}
+
+Vec3d Lab::tolab(const Vec3d& lab)
+{
+    auto f_inv = [](double t) -> double {
+        return t > DELTA ? pow(t, 3.0) : (t - C) / M;
+    };
+    double L = (lab[0] + 16.) / 116., a = lab[1] / 500., b = lab[2] / 200.;
+    auto& il = getIlluminants(illumobserver);
+    return { il[0] * f_inv(L + a),
+        il[1] * f_inv(L),
+        il[2] * f_inv(L - b) };
+}
+
+/* @brief Calculate To.
+ * @param src the input array, type of cv::Mat.
+ * @return the output array, type of cv::Mat
+ */
+Mat Lab::tosrc(Mat& src)
+{
+    return channelWise(src,
+            [this](cv::Vec3d a) -> cv::Vec3d { return tolab(a); });
+}
+
+std::shared_ptr<Lab> Lab::get(IllumObserver illumobserver)
+{
+    static std::map<IllumObserver, std::shared_ptr<Lab>> 	lab_cs;
+
+    if (lab_cs.count(illumobserver) == 1)
+    {
+        return lab_cs[illumobserver];
+    }
+    std::shared_ptr<Lab> Lab_CS(new Lab(illumobserver));
+    lab_cs[illumobserver] = Lab_CS;
+    return lab_cs[illumobserver];
+}
+
+GetCS::GetCS()
+{
+    // nothing
+}
+
+GetCS& GetCS::getInstance()
+{
+    static GetCS instance;
+    return instance;
+}
+
+std::shared_ptr<RGBBase_> GetCS::getRgb(enum ColorSpace cs_name)
+{
+    switch (cs_name)
+    {
+    case cv::ccm::COLOR_SPACE_SRGB:
+        if (map_cs.find(COLOR_SPACE_SRGB) == map_cs.end())
+        {
+            std::shared_ptr<sRGB_> sRGB_CS(new sRGB_(false));
+            std::shared_ptr<sRGB_> sRGBL_CS(new sRGB_(true));
+            (*sRGB_CS).bind(*sRGBL_CS);
+            map_cs[COLOR_SPACE_SRGB] = sRGB_CS;
+            map_cs[COLOR_SPACE_SRGBL] = sRGBL_CS;
+        }
+        return std::dynamic_pointer_cast<RGBBase_>(map_cs[COLOR_SPACE_SRGB]);
+
+    case cv::ccm::COLOR_SPACE_ADOBE_RGB:
+        if (map_cs.find(COLOR_SPACE_ADOBE_RGB) == map_cs.end())
+        {
+            std::shared_ptr<AdobeRGB_> AdobeRGB_CS(new AdobeRGB_(false));
+            std::shared_ptr<AdobeRGB_> AdobeRGBL_CS(new AdobeRGB_(true));
+            (*AdobeRGB_CS).bind(*AdobeRGBL_CS);
+            map_cs[COLOR_SPACE_ADOBE_RGB] = AdobeRGB_CS;
+            map_cs[COLOR_SPACE_ADOBE_RGBL] = AdobeRGBL_CS;
+        }
+        return std::dynamic_pointer_cast<RGBBase_>(map_cs[COLOR_SPACE_ADOBE_RGB]);
+
+    case cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<WideGamutRGB_> WideGamutRGB_CS(new WideGamutRGB_(false));
+            std::shared_ptr<WideGamutRGB_> WideGamutRGBL_CS(new WideGamutRGB_(true));
+            (*WideGamutRGB_CS).bind(*WideGamutRGBL_CS);
+            map_cs[COLOR_SPACE_WIDE_GAMUT_RGB] = WideGamutRGB_CS;
+            map_cs[COLOR_SPACE_WIDE_GAMUT_RGBL] = WideGamutRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_PRO_PHOTO_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<ProPhotoRGB_> ProPhotoRGB_CS(new ProPhotoRGB_(false));
+            std::shared_ptr<ProPhotoRGB_> ProPhotoRGBL_CS(new ProPhotoRGB_(true));
+            (*ProPhotoRGB_CS).bind(*ProPhotoRGBL_CS);
+            map_cs[COLOR_SPACE_PRO_PHOTO_RGB] = ProPhotoRGB_CS;
+            map_cs[COLOR_SPACE_PRO_PHOTO_RGBL] = ProPhotoRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_DCI_P3_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<DCI_P3_RGB_> DCI_P3_RGB_CS(new DCI_P3_RGB_(false));
+            std::shared_ptr<DCI_P3_RGB_> DCI_P3_RGBL_CS(new DCI_P3_RGB_(true));
+            (*DCI_P3_RGB_CS).bind(*DCI_P3_RGBL_CS);
+            map_cs[COLOR_SPACE_DCI_P3_RGB] = DCI_P3_RGB_CS;
+            map_cs[COLOR_SPACE_DCI_P3_RGBL] = DCI_P3_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_APPLE_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<AppleRGB_> AppleRGB_CS(new AppleRGB_(false));
+            std::shared_ptr<AppleRGB_> AppleRGBL_CS(new AppleRGB_(true));
+            (*AppleRGB_CS).bind(*AppleRGBL_CS);
+            map_cs[COLOR_SPACE_APPLE_RGB] = AppleRGB_CS;
+            map_cs[COLOR_SPACE_APPLE_RGBL] = AppleRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_REC_709_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<REC_709_RGB_> REC_709_RGB_CS(new REC_709_RGB_(false));
+            std::shared_ptr<REC_709_RGB_> REC_709_RGBL_CS(new REC_709_RGB_(true));
+            (*REC_709_RGB_CS).bind(*REC_709_RGBL_CS);
+            map_cs[COLOR_SPACE_REC_709_RGB] = REC_709_RGB_CS;
+            map_cs[COLOR_SPACE_REC_709_RGBL] = REC_709_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_REC_2020_RGB:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<REC_2020_RGB_> REC_2020_RGB_CS(new REC_2020_RGB_(false));
+            std::shared_ptr<REC_2020_RGB_> REC_2020_RGBL_CS(new REC_2020_RGB_(true));
+            (*REC_2020_RGB_CS).bind(*REC_2020_RGBL_CS);
+            map_cs[COLOR_SPACE_REC_2020_RGB] = REC_2020_RGB_CS;
+            map_cs[COLOR_SPACE_REC_2020_RGBL] = REC_2020_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_SRGBL:
+    case cv::ccm::COLOR_SPACE_ADOBE_RGBL:
+    case cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGBL:
+    case cv::ccm::COLOR_SPACE_PRO_PHOTO_RGBL:
+    case cv::ccm::COLOR_SPACE_DCI_P3_RGBL:
+    case cv::ccm::COLOR_SPACE_APPLE_RGBL:
+    case cv::ccm::COLOR_SPACE_REC_709_RGBL:
+    case cv::ccm::COLOR_SPACE_REC_2020_RGBL:
+        CV_Error(Error::StsBadArg, "linear RGB colorspaces are not supported, you should assigned as normal RGB color space");
+        break;
+
+    default:
+        CV_Error(Error::StsBadArg, "Only RGB color spaces are supported");
+    }
+    return (std::dynamic_pointer_cast<RGBBase_>)(map_cs[cs_name]);
+}
+
+std::shared_ptr<ColorSpaceBase> GetCS::getCS(enum ColorSpace cs_name)
+{
+    switch (cs_name)
+    {
+    case cv::ccm::COLOR_SPACE_SRGB:
+    case cv::ccm::COLOR_SPACE_SRGBL:
+        if (map_cs.find(COLOR_SPACE_SRGB) == map_cs.end())
+        {
+            std::shared_ptr<sRGB_> sRGB_CS(new sRGB_(false));
+            std::shared_ptr<sRGB_> sRGBL_CS(new sRGB_(true));
+            (*sRGB_CS).bind(*sRGBL_CS);
+            map_cs[COLOR_SPACE_SRGB] = sRGB_CS;
+            map_cs[COLOR_SPACE_SRGBL] = sRGBL_CS;
+        }
+        return map_cs[cs_name];
+
+    case cv::ccm::COLOR_SPACE_ADOBE_RGB:
+    case cv::ccm::COLOR_SPACE_ADOBE_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<AdobeRGB_> AdobeRGB_CS(new AdobeRGB_(false));
+            std::shared_ptr<AdobeRGB_> AdobeRGBL_CS(new AdobeRGB_(true));
+            (*AdobeRGB_CS).bind(*AdobeRGBL_CS);
+            map_cs[COLOR_SPACE_ADOBE_RGB] = AdobeRGB_CS;
+            map_cs[COLOR_SPACE_ADOBE_RGBL] = AdobeRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGB:
+    case cv::ccm::COLOR_SPACE_WIDE_GAMUT_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<WideGamutRGB_> WideGamutRGB_CS(new WideGamutRGB_(false));
+            std::shared_ptr<WideGamutRGB_> WideGamutRGBL_CS(new WideGamutRGB_(true));
+            (*WideGamutRGB_CS).bind(*WideGamutRGBL_CS);
+            map_cs[COLOR_SPACE_WIDE_GAMUT_RGB] = WideGamutRGB_CS;
+            map_cs[COLOR_SPACE_WIDE_GAMUT_RGBL] = WideGamutRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_PRO_PHOTO_RGB:
+    case cv::ccm::COLOR_SPACE_PRO_PHOTO_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<ProPhotoRGB_> ProPhotoRGB_CS(new ProPhotoRGB_(false));
+            std::shared_ptr<ProPhotoRGB_> ProPhotoRGBL_CS(new ProPhotoRGB_(true));
+            (*ProPhotoRGB_CS).bind(*ProPhotoRGBL_CS);
+            map_cs[COLOR_SPACE_PRO_PHOTO_RGB] = ProPhotoRGB_CS;
+            map_cs[COLOR_SPACE_PRO_PHOTO_RGBL] = ProPhotoRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_DCI_P3_RGB:
+    case cv::ccm::COLOR_SPACE_DCI_P3_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<DCI_P3_RGB_> DCI_P3_RGB_CS(new DCI_P3_RGB_(false));
+            std::shared_ptr<DCI_P3_RGB_> DCI_P3_RGBL_CS(new DCI_P3_RGB_(true));
+            (*DCI_P3_RGB_CS).bind(*DCI_P3_RGBL_CS);
+            map_cs[COLOR_SPACE_DCI_P3_RGB] = DCI_P3_RGB_CS;
+            map_cs[COLOR_SPACE_DCI_P3_RGBL] = DCI_P3_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_APPLE_RGB:
+    case cv::ccm::COLOR_SPACE_APPLE_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<AppleRGB_> AppleRGB_CS(new AppleRGB_(false));
+            std::shared_ptr<AppleRGB_> AppleRGBL_CS(new AppleRGB_(true));
+            (*AppleRGB_CS).bind(*AppleRGBL_CS);
+            map_cs[COLOR_SPACE_APPLE_RGB] = AppleRGB_CS;
+            map_cs[COLOR_SPACE_APPLE_RGBL] = AppleRGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_REC_709_RGB:
+    case cv::ccm::COLOR_SPACE_REC_709_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<REC_709_RGB_> REC_709_RGB_CS(new REC_709_RGB_(false));
+            std::shared_ptr<REC_709_RGB_> REC_709_RGBL_CS(new REC_709_RGB_(true));
+            (*REC_709_RGB_CS).bind(*REC_709_RGBL_CS);
+            map_cs[COLOR_SPACE_REC_709_RGB] = REC_709_RGB_CS;
+            map_cs[COLOR_SPACE_REC_709_RGBL] = REC_709_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_REC_2020_RGB:
+    case cv::ccm::COLOR_SPACE_REC_2020_RGBL:
+    {
+        if (map_cs.count(cs_name) < 1)
+        {
+            std::shared_ptr<REC_2020_RGB_> REC_2020_RGB_CS(new REC_2020_RGB_(false));
+            std::shared_ptr<REC_2020_RGB_> REC_2020_RGBL_CS(new REC_2020_RGB_(true));
+            (*REC_2020_RGB_CS).bind(*REC_2020_RGBL_CS);
+            map_cs[COLOR_SPACE_REC_2020_RGB] = REC_2020_RGB_CS;
+            map_cs[COLOR_SPACE_REC_2020_RGBL] = REC_2020_RGBL_CS;
+        }
+        break;
+    }
+    case cv::ccm::COLOR_SPACE_XYZ_D65_2:
+        return XYZ::get(IllumObserver::getIllumObservers(D65_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D50_2:
+        return XYZ::get(IllumObserver::getIllumObservers(D50_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D65_10:
+        return XYZ::get(IllumObserver::getIllumObservers(D65_10));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D50_10:
+        return XYZ::get(IllumObserver::getIllumObservers(D50_10));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_A_2:
+        return XYZ::get(IllumObserver::getIllumObservers(A_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_A_10:
+        return XYZ::get(IllumObserver::getIllumObservers(A_10));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D55_2:
+        return XYZ::get(IllumObserver::getIllumObservers(D55_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D55_10:
+        return XYZ::get(IllumObserver::getIllumObservers(D55_10));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D75_2:
+        return XYZ::get(IllumObserver::getIllumObservers(D75_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_D75_10:
+        return XYZ::get(IllumObserver::getIllumObservers(D75_10));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_E_2:
+        return XYZ::get(IllumObserver::getIllumObservers(E_2));
+        break;
+    case cv::ccm::COLOR_SPACE_XYZ_E_10:
+        return XYZ::get(IllumObserver::getIllumObservers(E_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D65_2:
+        return Lab::get(IllumObserver::getIllumObservers(D65_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D50_2:
+        return Lab::get(IllumObserver::getIllumObservers(D50_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D65_10:
+        return Lab::get(IllumObserver::getIllumObservers(D65_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D50_10:
+        return Lab::get(IllumObserver::getIllumObservers(D50_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_A_2:
+        return Lab::get(IllumObserver::getIllumObservers(A_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_A_10:
+        return Lab::get(IllumObserver::getIllumObservers(A_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D55_2:
+        return Lab::get(IllumObserver::getIllumObservers(D55_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D55_10:
+        return Lab::get(IllumObserver::getIllumObservers(D55_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D75_2:
+        return Lab::get(IllumObserver::getIllumObservers(D75_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_D75_10:
+        return Lab::get(IllumObserver::getIllumObservers(D75_10));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_E_2:
+        return Lab::get(IllumObserver::getIllumObservers(E_2));
+        break;
+    case cv::ccm::COLOR_SPACE_LAB_E_10:
+        return Lab::get(IllumObserver::getIllumObservers(E_10));
+        break;
+    default:
+        break;
+    }
+
+    return map_cs[cs_name];
+}
+
+}
+}  // namespace cv::ccm
diff --git a/upstream/opencv/modules/photo/src/ccm/colorspace.hpp b/upstream/opencv/modules/photo/src/ccm/colorspace.hpp
new file mode 100644
index 0000000..853d9ee
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/colorspace.hpp
@@ -0,0 +1,343 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_COLORSPACE_HPP__
+#define __OPENCV_CCM_COLORSPACE_HPP__
+
+#include "operations.hpp"
+#include "illumobserver.hpp"
+#include "opencv2/photo.hpp"
+
+namespace cv {
+namespace ccm {
+
+/** @brief Basic class for ColorSpace.
+*/
+class ColorSpaceBase
+{
+public:
+    typedef std::function<Mat(Mat)> MatFunc;
+    IllumObserver illumobserver;
+    std::string type;
+    bool linear;
+    Operations to;
+    Operations from;
+    ColorSpaceBase* l;
+    ColorSpaceBase* nl;
+
+    ColorSpaceBase() {};
+
+    ColorSpaceBase(IllumObserver illumobserver_, std::string type_, bool linear_)
+        : illumobserver(illumobserver_)
+        , type(type_)
+        , linear(linear_) {};
+
+    virtual ~ColorSpaceBase()
+    {
+        l = 0;
+        nl = 0;
+    };
+    virtual bool relate(const ColorSpaceBase& other) const;
+
+    virtual Operations relation(const ColorSpaceBase& /*other*/) const;
+
+    bool operator<(const ColorSpaceBase& other) const;
+};
+
+/** @brief Base of RGB color space;
+           the argument values are from AdobeRGB;
+           Data from https://en.wikipedia.org/wiki/Adobe_RGB_color_space
+*/
+
+class RGBBase_ : public ColorSpaceBase
+{
+public:
+    // primaries
+    double xr;
+    double yr;
+    double xg;
+    double yg;
+    double xb;
+    double yb;
+    Mat M_to;
+    Mat M_from;
+
+    using ColorSpaceBase::ColorSpaceBase;
+
+    /** @brief There are 3 kinds of relationships for RGB:
+               1. Different types;    - no operation
+               1. Same type, same linear; - copy
+               2. Same type, different linear, self is nonlinear; - 2 toL
+               3. Same type, different linear, self is linear - 3 fromL
+        @param other type of ColorSpaceBase.
+        @return Operations.
+    */
+    Operations relation(const ColorSpaceBase& other) const CV_OVERRIDE;
+
+    /** @brief Initial operations.
+    */
+    void init();
+    /** @brief Produce color space instance with linear and non-linear versions.
+        @param rgbl type of RGBBase_.
+    */
+    void bind(RGBBase_& rgbl);
+
+    virtual Mat toLFunc(Mat& /*rgb*/) const;
+
+    virtual Mat fromLFunc(Mat& /*rgbl*/, Mat dst=Mat()) const;
+private:
+    virtual void setParameter() {};
+
+    /** @brief Calculation of M_RGBL2XYZ_base.
+    */
+    virtual void calM();
+
+    /** @brief operations to or from XYZ.
+    */
+    virtual void calOperations();
+
+    virtual void calLinear() {};
+};
+
+/** @brief Base of Adobe RGB color space;
+*/
+class AdobeRGBBase_ : public RGBBase_
+
+{
+public:
+    using RGBBase_::RGBBase_;
+    double gamma;
+
+private:
+    Mat toLFunc(Mat& rgb) const CV_OVERRIDE;
+    Mat fromLFunc(Mat& rgbl, Mat dst=Mat()) const CV_OVERRIDE;
+};
+
+/** @brief Base of sRGB color space;
+*/
+class sRGBBase_ : public RGBBase_
+
+{
+public:
+    using RGBBase_::RGBBase_;
+    double a;
+    double gamma;
+    double alpha;
+    double beta;
+    double phi;
+    double K0;
+
+private:
+    /** @brief linearization parameters
+    */
+    virtual void calLinear() CV_OVERRIDE;
+    /** @brief Used by toLFunc.
+    */
+    double toLFuncEW(double x) const;
+
+    /** @brief Linearization.
+        @param rgb the input array, type of cv::Mat.
+        @return the output array, type of cv::Mat.
+    */
+    Mat toLFunc(Mat& rgb) const CV_OVERRIDE;
+
+    /** @brief Used by fromLFunc.
+    */
+    double fromLFuncEW(double x) const;
+
+    /** @brief Delinearization.
+        @param rgbl the input array, type of cv::Mat.
+        @return the output array, type of cv::Mat.
+    */
+    Mat fromLFunc(Mat& rgbl, Mat dst=Mat()) const CV_OVERRIDE;
+};
+
+/** @brief sRGB color space.
+           data from https://en.wikipedia.org/wiki/SRGB.
+*/
+class sRGB_ : public sRGBBase_
+
+{
+public:
+    sRGB_(bool linear_)
+        : sRGBBase_(IllumObserver::getIllumObservers(D65_2), "sRGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief Adobe RGB color space.
+*/
+class AdobeRGB_ : public AdobeRGBBase_
+{
+public:
+    AdobeRGB_(bool linear_ = false)
+        : AdobeRGBBase_(IllumObserver::getIllumObservers(D65_2), "AdobeRGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief Wide-gamut RGB color space.
+           data from https://en.wikipedia.org/wiki/Wide-gamut_RGB_color_space.
+*/
+class WideGamutRGB_ : public AdobeRGBBase_
+{
+public:
+    WideGamutRGB_(bool linear_ = false)
+        : AdobeRGBBase_(IllumObserver::getIllumObservers(D50_2), "WideGamutRGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief ProPhoto RGB color space.
+           data from https://en.wikipedia.org/wiki/ProPhoto_RGB_color_space.
+*/
+
+class ProPhotoRGB_ : public AdobeRGBBase_
+{
+public:
+    ProPhotoRGB_(bool linear_ = false)
+        : AdobeRGBBase_(IllumObserver::getIllumObservers(D50_2), "ProPhotoRGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief DCI-P3 RGB color space.
+           data from https://en.wikipedia.org/wiki/DCI-P3.
+*/
+class DCI_P3_RGB_ : public AdobeRGBBase_
+{
+public:
+    DCI_P3_RGB_(bool linear_ = false)
+        : AdobeRGBBase_(IllumObserver::getIllumObservers(D65_2), "DCI_P3_RGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief Apple RGB color space.
+           data from http://www.brucelindbloom.com/index.html?WorkingSpaceInfo.html.
+*/
+class AppleRGB_ : public AdobeRGBBase_
+{
+public:
+    AppleRGB_(bool linear_ = false)
+        : AdobeRGBBase_(IllumObserver::getIllumObservers(D65_2), "AppleRGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief REC_709 RGB color space.
+           data from https://en.wikipedia.org/wiki/Rec._709.
+*/
+class REC_709_RGB_ : public sRGBBase_
+{
+public:
+    REC_709_RGB_(bool linear_)
+        : sRGBBase_(IllumObserver::getIllumObservers(D65_2), "REC_709_RGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief REC_2020 RGB color space.
+           data from https://en.wikipedia.org/wiki/Rec._2020.
+*/
+class REC_2020_RGB_ : public sRGBBase_
+{
+public:
+    REC_2020_RGB_(bool linear_)
+        : sRGBBase_(IllumObserver::getIllumObservers(D65_2), "REC_2020_RGB", linear_) {};
+
+private:
+    void setParameter() CV_OVERRIDE;
+};
+
+/** @brief Enum of the possible types of Chromatic Adaptation Models.
+*/
+enum ChromaticAdaptationType
+{
+    IDENTITY,
+    VON_KRIES,
+    BRADFORD
+};
+
+
+/** @brief XYZ color space.
+           Chromatic adaption matrices.
+*/
+class XYZ : public ColorSpaceBase
+{
+public:
+    XYZ(IllumObserver illumobserver_)
+        : ColorSpaceBase(illumobserver_, "XYZ", true) {};
+    Operations cam(IllumObserver dio, ChromaticAdaptationType method = BRADFORD);
+    static std::shared_ptr<XYZ> get(IllumObserver illumobserver);
+
+private:
+    /** @brief Get cam.
+        @param sio the input IllumObserver of src.
+        @param dio the input IllumObserver of dst.
+        @param method type of Chromatic Adaptation Model.
+        @return the output array, type of cv::Mat.
+    */
+    Mat cam_(IllumObserver sio, IllumObserver dio, ChromaticAdaptationType method = BRADFORD) const;
+};
+
+/** @brief Lab color space.
+*/
+class Lab : public ColorSpaceBase
+{
+public:
+    Lab(IllumObserver illumobserver_);
+    static std::shared_ptr<Lab> get(IllumObserver illumobserver);
+
+private:
+    static constexpr double DELTA = (6. / 29.);
+    static constexpr double M = 1. / (3. * DELTA * DELTA);
+    static constexpr double T0 = DELTA * DELTA * DELTA;
+    static constexpr double C = 4. / 29.;
+
+    Vec3d fromxyz(const Vec3d& xyz);
+
+    /** @brief Calculate From.
+        @param src the input array, type of cv::Mat.
+        @return the output array, type of cv::Mat
+    */
+    Mat fromsrc(Mat& src);
+
+    Vec3d tolab(const Vec3d& lab);
+
+    /** @brief Calculate To.
+        @param src the input array, type of cv::Mat.
+        @return the output array, type of cv::Mat
+    */
+    Mat tosrc(Mat& src);
+};
+
+class GetCS
+{
+protected:
+    std::map<enum ColorSpace, std::shared_ptr<ColorSpaceBase>> map_cs;
+
+    GetCS();  // singleton, use getInstance()
+public:
+    static GetCS& getInstance();
+
+    std::shared_ptr<RGBBase_> getRgb(enum ColorSpace cs_name);
+    std::shared_ptr<ColorSpaceBase> getCS(enum ColorSpace cs_name);
+};
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/distance.cpp b/upstream/opencv/modules/photo/src/ccm/distance.cpp
new file mode 100644
index 0000000..fde973b
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/distance.cpp
@@ -0,0 +1,204 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "distance.hpp"
+
+namespace cv {
+namespace ccm {
+
+double deltaCIE76(const Vec3d& lab1, const Vec3d& lab2) { return norm(lab1 - lab2); };
+
+double deltaCIE94(const Vec3d& lab1, const Vec3d& lab2, double kH,
+        double kC, double kL, double k1, double k2)
+{
+    double dl = lab1[0] - lab2[0];
+    double c1 = sqrt(pow(lab1[1], 2) + pow(lab1[2], 2));
+    double c2 = sqrt(pow(lab2[1], 2) + pow(lab2[2], 2));
+    double dc = c1 - c2;
+    double da = lab1[1] - lab2[1];
+    double db = lab1[2] - lab2[2];
+    double dh = pow(da, 2) + pow(db, 2) - pow(dc, 2);
+    double sc = 1.0 + k1 * c1;
+    double sh = 1.0 + k2 * c1;
+    double sl = 1.0;
+    double res = pow(dl / (kL * sl), 2) + pow(dc / (kC * sc), 2) + dh / pow(kH * sh, 2);
+
+    return res > 0 ? sqrt(res) : 0;
+}
+
+double deltaCIE94GraphicArts(const Vec3d& lab1, const Vec3d& lab2)
+{
+    return deltaCIE94(lab1, lab2);
+}
+
+double toRad(double degree) { return degree / 180 * CV_PI; };
+
+double deltaCIE94Textiles(const Vec3d& lab1, const Vec3d& lab2)
+{
+    return deltaCIE94(lab1, lab2, 1.0, 1.0, 2.0, 0.048, 0.014);
+}
+
+double deltaCIEDE2000_(const Vec3d& lab1, const Vec3d& lab2, double kL,
+        double kC, double kH)
+{
+    double deltaLApo = lab2[0] - lab1[0];
+    double lBarApo = (lab1[0] + lab2[0]) / 2.0;
+    double C1 = sqrt(pow(lab1[1], 2) + pow(lab1[2], 2));
+    double C2 = sqrt(pow(lab2[1], 2) + pow(lab2[2], 2));
+    double cBar = (C1 + C2) / 2.0;
+    double G = sqrt(pow(cBar, 7) / (pow(cBar, 7) + pow(25, 7)));
+    double a1Apo = lab1[1] + lab1[1] / 2.0 * (1.0 - G);
+    double a2Apo = lab2[1] + lab2[1] / 2.0 * (1.0 - G);
+    double c1Apo = sqrt(pow(a1Apo, 2) + pow(lab1[2], 2));
+    double c2Apo = sqrt(pow(a2Apo, 2) + pow(lab2[2], 2));
+    double cBarApo = (c1Apo + c2Apo) / 2.0;
+    double deltaCApo = c2Apo - c1Apo;
+
+    double h1Apo;
+    if (c1Apo == 0)
+    {
+        h1Apo = 0.0;
+    }
+    else
+    {
+        h1Apo = atan2(lab1[2], a1Apo);
+        if (h1Apo < 0.0)
+            h1Apo += 2. * CV_PI;
+    }
+
+    double h2Apo;
+    if (c2Apo == 0)
+    {
+        h2Apo = 0.0;
+    }
+    else
+    {
+        h2Apo = atan2(lab2[2], a2Apo);
+        if (h2Apo < 0.0)
+            h2Apo += 2. * CV_PI;
+    }
+
+    double deltaHApo;
+    if (abs(h2Apo - h1Apo) <= CV_PI)
+    {
+        deltaHApo = h2Apo - h1Apo;
+    }
+    else if (h2Apo <= h1Apo)
+    {
+        deltaHApo = h2Apo - h1Apo + 2. * CV_PI;
+    }
+    else
+    {
+        deltaHApo = h2Apo - h1Apo - 2. * CV_PI;
+    }
+
+    double hBarApo;
+    if (c1Apo == 0 || c2Apo == 0)
+    {
+        hBarApo = h1Apo + h2Apo;
+    }
+    else if (abs(h1Apo - h2Apo) <= CV_PI)
+    {
+        hBarApo = (h1Apo + h2Apo) / 2.0;
+    }
+    else if (h1Apo + h2Apo < 2. * CV_PI)
+    {
+        hBarApo = (h1Apo + h2Apo + 2. * CV_PI) / 2.0;
+    }
+    else
+    {
+        hBarApo = (h1Apo + h2Apo - 2. * CV_PI) / 2.0;
+    }
+
+    double deltaH_Apo = 2.0 * sqrt(c1Apo * c2Apo) * sin(deltaHApo / 2.0);
+    double T = 1.0 - 0.17 * cos(hBarApo - toRad(30.)) + 0.24 * cos(2.0 * hBarApo) + 0.32 * cos(3.0 * hBarApo + toRad(6.0)) - 0.2 * cos(4.0 * hBarApo - toRad(63.0));
+    double sC = 1.0 + 0.045 * cBarApo;
+    double sH = 1.0 + 0.015 * cBarApo * T;
+    double sL = 1.0 + ((0.015 * pow(lBarApo - 50.0, 2.0)) / sqrt(20.0 + pow(lBarApo - 50.0, 2.0)));
+    double rC = 2.0 * sqrt(pow(cBarApo, 7.0) / (pow(cBarApo, 7.0) + pow(25, 7)));
+    double rT = -sin(toRad(60.0) * exp(-pow((hBarApo - toRad(275.0)) / toRad(25.0), 2.0))) * rC;
+    double res = (pow(deltaLApo / (kL * sL), 2.0) + pow(deltaCApo / (kC * sC), 2.0) + pow(deltaH_Apo / (kH * sH), 2.0) + rT * (deltaCApo / (kC * sC)) * (deltaH_Apo / (kH * sH)));
+    return res > 0 ? sqrt(res) : 0;
+}
+
+double deltaCIEDE2000(const Vec3d& lab1, const Vec3d& lab2)
+{
+    return deltaCIEDE2000_(lab1, lab2);
+}
+
+double deltaCMC(const Vec3d& lab1, const Vec3d& lab2, double kL, double kC)
+{
+    double dL = lab2[0] - lab1[0];
+    double da = lab2[1] - lab1[1];
+    double db = lab2[2] - lab1[2];
+    double C1 = sqrt(pow(lab1[1], 2.0) + pow(lab1[2], 2.0));
+    double C2 = sqrt(pow(lab2[1], 2.0) + pow(lab2[2], 2.0));
+    double dC = C2 - C1;
+    double dH = sqrt(pow(da, 2) + pow(db, 2) - pow(dC, 2));
+
+    double H1;
+    if (C1 == 0.)
+    {
+        H1 = 0.0;
+    }
+    else
+    {
+        H1 = atan2(lab1[2], lab1[1]);
+        if (H1 < 0.0)
+            H1 += 2. * CV_PI;
+    }
+
+    double F = pow(C1, 2) / sqrt(pow(C1, 4) + 1900);
+    double T = (H1 > toRad(164) && H1 <= toRad(345))
+            ? 0.56 + abs(0.2 * cos(H1 + toRad(168)))
+            : 0.36 + abs(0.4 * cos(H1 + toRad(35)));
+    double sL = lab1[0] < 16. ? 0.511 : (0.040975 * lab1[0]) / (1.0 + 0.01765 * lab1[0]);
+    double sC = (0.0638 * C1) / (1.0 + 0.0131 * C1) + 0.638;
+    double sH = sC * (F * T + 1.0 - F);
+
+    return sqrt(pow(dL / (kL * sL), 2.0) + pow(dC / (kC * sC), 2.0) + pow(dH / sH, 2.0));
+}
+
+double deltaCMC1To1(const Vec3d& lab1, const Vec3d& lab2)
+{
+    return deltaCMC(lab1, lab2);
+}
+
+double deltaCMC2To1(const Vec3d& lab1, const Vec3d& lab2)
+{
+    return deltaCMC(lab1, lab2, 2, 1);
+}
+
+Mat distance(Mat src, Mat ref, DistanceType distanceType)
+{
+    switch (distanceType)
+    {
+    case cv::ccm::DISTANCE_CIE76:
+        return distanceWise(src, ref, deltaCIE76);
+    case cv::ccm::DISTANCE_CIE94_GRAPHIC_ARTS:
+        return distanceWise(src, ref, deltaCIE94GraphicArts);
+    case cv::ccm::DISTANCE_CIE94_TEXTILES:
+        return distanceWise(src, ref, deltaCIE94Textiles);
+    case cv::ccm::DISTANCE_CIE2000:
+        return distanceWise(src, ref, deltaCIEDE2000);
+    case cv::ccm::DISTANCE_CMC_1TO1:
+        return distanceWise(src, ref, deltaCMC1To1);
+    case cv::ccm::DISTANCE_CMC_2TO1:
+        return distanceWise(src, ref, deltaCMC2To1);
+    case cv::ccm::DISTANCE_RGB:
+        return distanceWise(src, ref, deltaCIE76);
+    case cv::ccm::DISTANCE_RGBL:
+        return distanceWise(src, ref, deltaCIE76);
+    default:
+        CV_Error(Error::StsBadArg, "Wrong distanceType!" );
+        break;
+    }
+};
+
+}
+}  // namespace ccm
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/distance.hpp b/upstream/opencv/modules/photo/src/ccm/distance.hpp
new file mode 100644
index 0000000..705067c
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/distance.hpp
@@ -0,0 +1,80 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_DISTANCE_HPP__
+#define __OPENCV_CCM_DISTANCE_HPP__
+
+#include "utils.hpp"
+#include "opencv2/photo.hpp"
+
+namespace cv {
+namespace ccm {
+/** possibale functions to calculate the distance between
+    colors.see https://en.wikipedia.org/wiki/Color_difference for details;*/
+
+/** @brief  distance between two points in formula CIE76
+    @param lab1 a 3D vector
+    @param lab2 a 3D vector
+    @return distance between lab1 and lab2
+*/
+
+double deltaCIE76(const Vec3d& lab1, const Vec3d& lab2);
+
+/** @brief  distance between two points in formula CIE94
+    @param lab1 a 3D vector
+    @param lab2 a 3D vector
+    @param kH Hue scale
+    @param kC Chroma scale
+    @param kL Lightness scale
+    @param k1 first scale parameter
+    @param k2 second scale parameter
+    @return distance between lab1 and lab2
+*/
+
+double deltaCIE94(const Vec3d& lab1, const Vec3d& lab2, double kH = 1.0,
+        double kC = 1.0, double kL = 1.0, double k1 = 0.045,
+        double k2 = 0.015);
+
+double deltaCIE94GraphicArts(const Vec3d& lab1, const Vec3d& lab2);
+
+double toRad(double degree);
+
+double deltaCIE94Textiles(const Vec3d& lab1, const Vec3d& lab2);
+
+/** @brief  distance between two points in formula CIE2000
+    @param lab1 a 3D vector
+    @param lab2 a 3D vector
+    @param kL Lightness scale
+    @param kC Chroma scale
+    @param kH Hue scale
+    @return distance between lab1 and lab2
+*/
+double deltaCIEDE2000_(const Vec3d& lab1, const Vec3d& lab2, double kL = 1.0,
+        double kC = 1.0, double kH = 1.0);
+double deltaCIEDE2000(const Vec3d& lab1, const Vec3d& lab2);
+
+/** @brief  distance between two points in formula CMC
+    @param lab1 a 3D vector
+    @param lab2 a 3D vector
+    @param kL Lightness scale
+    @param kC Chroma scale
+    @return distance between lab1 and lab2
+*/
+
+double deltaCMC(const Vec3d& lab1, const Vec3d& lab2, double kL = 1, double kC = 1);
+
+double deltaCMC1To1(const Vec3d& lab1, const Vec3d& lab2);
+
+double deltaCMC2To1(const Vec3d& lab1, const Vec3d& lab2);
+
+Mat distance(Mat src,Mat ref, DistanceType distanceType);
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/illumobserver.cpp b/upstream/opencv/modules/photo/src/ccm/illumobserver.cpp
new file mode 100644
index 0000000..00231f6
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/illumobserver.cpp
@@ -0,0 +1,114 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "illumobserver.hpp"
+namespace cv {
+namespace ccm {
+IllumObserver::IllumObserver(std::string illuminant_, std::string observer_)
+    : illuminant(illuminant_)
+    , observer(observer_) {};
+
+bool IllumObserver::operator<(const IllumObserver& other) const
+{
+    return (illuminant < other.illuminant || ((illuminant == other.illuminant) && (observer < other.observer)));
+}
+
+bool IllumObserver::operator==(const IllumObserver& other) const
+{
+    return illuminant == other.illuminant && observer == other.observer;
+};
+
+IllumObserver IllumObserver::getIllumObservers(IllumObserverType illumobserver)
+{
+    switch (illumobserver)
+    {
+    case cv::ccm::A_2:
+    {
+        IllumObserver A_2_IllumObserver("A", "2");
+        return A_2_IllumObserver;
+        break;
+    }
+    case cv::ccm::A_10:
+    {
+        IllumObserver A_1O_IllumObserver("A", "10");
+        return A_1O_IllumObserver;
+        break;
+    }
+    case cv::ccm::D50_2:
+    {
+        IllumObserver D50_2_IllumObserver("D50", "2");
+        return D50_2_IllumObserver;
+        break;
+    }
+    case cv::ccm::D50_10:
+    {
+        IllumObserver D50_10_IllumObserver("D50", "10");
+        return D50_10_IllumObserver;
+        break;
+    }
+    case cv::ccm::D55_2:
+    {
+        IllumObserver D55_2_IllumObserver("D55", "2");
+        return D55_2_IllumObserver;
+        break;
+    }
+    case cv::ccm::D55_10:
+    {
+        IllumObserver D55_10_IllumObserver("D55", "10");
+        return D55_10_IllumObserver;
+        break;
+    }
+    case cv::ccm::D65_2:
+    {
+        IllumObserver D65_2_IllumObserver("D65", "2");
+        return D65_2_IllumObserver;
+    }
+    case cv::ccm::D65_10:
+    {
+        IllumObserver D65_10_IllumObserver("D65", "10");
+        return D65_10_IllumObserver;
+        break;
+    }
+    case cv::ccm::D75_2:
+    {
+        IllumObserver D75_2_IllumObserver("D75", "2");
+        return D75_2_IllumObserver;
+        break;
+    }
+    case cv::ccm::D75_10:
+    {
+        IllumObserver D75_10_IllumObserver("D75", "10");
+        return D75_10_IllumObserver;
+        break;
+    }
+    case cv::ccm::E_2:
+    {
+        IllumObserver E_2_IllumObserver("E", "2");
+        return E_2_IllumObserver;
+        break;
+    }
+    case cv::ccm::E_10:
+    {
+        IllumObserver E_10_IllumObserver("E", "10");
+        return E_10_IllumObserver;
+        break;
+    }
+    default:
+        return IllumObserver();
+        break;
+    }
+}
+// data from https://en.wikipedia.org/wiki/Standard_illuminant.
+std::vector<double> xyY2XYZ(const std::vector<double>& xyY)
+{
+    double Y = xyY.size() >= 3 ? xyY[2] : 1;
+    return { Y * xyY[0] / xyY[1], Y, Y / xyY[1] * (1 - xyY[0] - xyY[1]) };
+}
+
+}
+}  // namespace cv::ccm
diff --git a/upstream/opencv/modules/photo/src/ccm/illumobserver.hpp b/upstream/opencv/modules/photo/src/ccm/illumobserver.hpp
new file mode 100644
index 0000000..9f46e61
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/illumobserver.hpp
@@ -0,0 +1,53 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_IllumObserver_HPP__
+#define __OPENCV_CCM_IllumObserver_HPP__
+
+#include <opencv2/core.hpp>
+#include <map>
+
+namespace cv {
+namespace ccm {
+
+enum IllumObserverType
+{
+    A_2,
+    A_10,
+    D50_2,
+    D50_10,
+    D55_2,
+    D55_10,
+    D65_2,
+    D65_10,
+    D75_2,
+    D75_10,
+    E_2,
+    E_10
+};
+
+/** @brief IllumObserver is the meaning of illuminant and observer. See notes of ccm.hpp
+           for supported list for illuminant and observer*/
+class IllumObserver
+{
+public:
+    std::string illuminant;
+    std::string observer;
+    IllumObserver() {};
+    IllumObserver(std::string illuminant, std::string observer);
+    virtual ~IllumObserver() {};
+    bool operator<(const IllumObserver& other) const;
+    bool operator==(const IllumObserver& other) const;
+    static IllumObserver getIllumObservers(IllumObserverType illumobserver);
+};
+std::vector<double> xyY2XYZ(const std::vector<double>& xyY);
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/linearize.cpp b/upstream/opencv/modules/photo/src/ccm/linearize.cpp
new file mode 100644
index 0000000..d50b5ec
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/linearize.cpp
@@ -0,0 +1,284 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "linearize.hpp"
+
+namespace cv {
+namespace ccm {
+
+Polyfit::Polyfit() : deg(0) {}
+
+void Polyfit::write(cv::FileStorage& fs) const {
+    fs << "{" << "deg" << deg << "p" << p << "}";
+}
+
+void Polyfit::read(const cv::FileNode& node) {
+    node["deg"] >> deg;
+    node["p"] >> p;
+}
+
+// Global functions to support FileStorage for Polyfit
+void write(cv::FileStorage& fs, const std::string&, const Polyfit& polyfit) {
+    polyfit.write(fs);
+}
+void read(const cv::FileNode& node, Polyfit& polyfit, const Polyfit& defaultValue) {
+    if(node.empty())
+        polyfit = defaultValue;
+    else
+        polyfit.read(node);
+}
+
+Polyfit::Polyfit(Mat x, Mat y, int deg_)
+    : deg(deg_)
+{
+    int n = x.cols * x.rows * x.channels();
+    x = x.reshape(1, n);
+    y = y.reshape(1, n);
+    Mat_<double> A = Mat_<double>::ones(n, deg + 1);
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 1; j < A.cols; ++j)
+        {
+            A.at<double>(i, j) = x.at<double>(i) * A.at<double>(i, j - 1);
+        }
+    }
+    Mat y_(y);
+    cv::solve(A, y_, p, DECOMP_SVD);
+}
+
+Mat Polyfit::operator()(const Mat& inp)
+{
+    return elementWise(inp, [this](double x) -> double { return fromEW(x); });
+};
+
+double Polyfit::fromEW(double x)
+{
+    double res = 0;
+    for (int d = 0; d <= deg; ++d)
+    {
+        res += pow(x, d) * p.at<double>(d, 0);
+    }
+    return res;
+};
+
+// Default constructor for LogPolyfit
+LogPolyfit::LogPolyfit() : deg(0) {}
+
+void LogPolyfit::write(cv::FileStorage& fs) const {
+    fs << "{" << "deg" << deg << "p" << p << "}";
+}
+
+void LogPolyfit::read(const cv::FileNode& node) {
+    node["deg"] >> deg;
+    node["p"] >> p;
+}
+
+// Global functions to support FileStorage for LogPolyfit
+void write(cv::FileStorage& fs, const std::string&, const LogPolyfit& logpolyfit) {
+    logpolyfit.write(fs);
+}
+void read(const cv::FileNode& node, LogPolyfit& logpolyfit, const LogPolyfit& defaultValue) {
+    if(node.empty())
+        logpolyfit = defaultValue;
+    else
+        logpolyfit.read(node);
+}
+
+LogPolyfit::LogPolyfit(Mat x, Mat y, int deg_)
+    : deg(deg_)
+{
+    Mat mask_ = (x > 0) & (y > 0);
+    Mat src_, dst_, s_, d_;
+    src_ = maskCopyTo(x, mask_);
+    dst_ = maskCopyTo(y, mask_);
+    log(src_, s_);
+    log(dst_, d_);
+    p = Polyfit(s_, d_, deg);
+}
+
+Mat LogPolyfit::operator()(const Mat& inp)
+{
+    Mat mask_ = inp >= 0;
+    Mat y, y_, res;
+    log(inp, y);
+    y = p(y);
+    exp(y, y_);
+    y_.copyTo(res, mask_);
+    return res;
+};
+
+void LinearIdentity::write(cv::FileStorage& fs) const
+{
+    fs << "{" << "}";
+}
+
+void LinearIdentity::read(const cv::FileNode&)
+{
+}
+
+void LinearGamma::write(cv::FileStorage& fs) const
+{
+    fs << "{" << "gamma" << gamma << "}";
+}
+
+void LinearGamma::read(const cv::FileNode& node)
+{
+    node["gamma"] >> gamma;
+}
+
+template <typename T>
+void LinearColor<T>::write(cv::FileStorage& fs) const
+{
+    fs << "{" << "deg" << deg << "pr" << pr << "pg" << pg << "pb" << pb << "}";
+}
+
+template <typename T>
+void LinearColor<T>::read(const cv::FileNode& node)
+{
+    node["deg"] >> deg;
+    node["pr"] >> pr;
+    node["pg"] >> pg;
+    node["pb"] >> pb;
+}
+
+template <typename T>
+void LinearGray<T>::write(cv::FileStorage& fs) const
+{
+    fs << "{" << "deg" << deg << "p" << p << "}";
+}
+
+template <typename T>
+void LinearGray<T>::read(const cv::FileNode& node)
+{
+    node["deg"] >> deg;
+    node["p"] >> p;
+}
+
+void Linear::write(cv::FileStorage&) const
+{
+    CV_Error(Error::StsNotImplemented, "This is a base class, so this shouldn't be called");
+}
+
+void Linear::read(const cv::FileNode&)
+{
+    CV_Error(Error::StsNotImplemented, "This is a base class, so this shouldn't be called");
+}
+
+void write(cv::FileStorage& fs, const std::string&, const Linear& linear)
+{
+    linear.write(fs);
+}
+
+void read(const cv::FileNode& node, Linear& linear, const Linear& defaultValue)
+{
+    if (node.empty())
+        linear = defaultValue;
+    else
+        linear.read(node);
+}
+
+void write(cv::FileStorage& fs, const std::string&, const LinearIdentity& linearidentity)
+{
+    linearidentity.write(fs);
+}
+
+void read(const cv::FileNode& node, LinearIdentity& linearidentity, const LinearIdentity& defaultValue)
+{
+    if (node.empty())
+        linearidentity = defaultValue;
+    else
+        linearidentity.read(node);
+}
+
+void write(cv::FileStorage& fs, const std::string&, const LinearGamma& lineargamma)
+{
+    lineargamma.write(fs);
+}
+
+void read(const cv::FileNode& node, LinearGamma& lineargamma, const LinearGamma& defaultValue)
+{
+    if (node.empty())
+        lineargamma = defaultValue;
+    else
+        lineargamma.read(node);
+}
+
+template <typename T>
+void write(cv::FileStorage& fs, const std::string&, const LinearColor<T>& linearcolor)
+{
+    linearcolor.write(fs);
+}
+
+template <typename T>
+void read(const cv::FileNode& node, LinearColor<T>& linearcolor, const LinearColor<T>& defaultValue)
+{
+    if (node.empty())
+        linearcolor = defaultValue;
+    else
+        linearcolor.read(node);
+}
+
+template <typename T>
+void write(cv::FileStorage& fs, const std::string&, const LinearGray<T>& lineargray)
+{
+    lineargray.write(fs);
+}
+
+template <typename T>
+void read(const cv::FileNode& node, LinearGray<T>& lineargray, const LinearGray<T>& defaultValue)
+{
+    if (node.empty())
+        lineargray = defaultValue;
+    else
+        lineargray.read(node);
+}
+
+Mat Linear::linearize(Mat inp)
+{
+    return inp;
+};
+
+Mat LinearGamma::linearize(Mat inp)
+{
+    Mat out;
+    gammaCorrection(inp, out, gamma);
+    return out;
+};
+
+std::shared_ptr<Linear> getLinear(double gamma, int deg, Mat src, Color dst, Mat mask, RGBBase_ cs, LinearizationType linearizationType)
+{
+    std::shared_ptr<Linear> p = std::make_shared<Linear>();
+    switch (linearizationType)
+    {
+    case cv::ccm::LINEARIZATION_IDENTITY:
+        p = std::make_shared<LinearIdentity>();
+        break;
+    case cv::ccm::LINEARIZATION_GAMMA:
+        p = std::make_shared<LinearGamma>(gamma);
+        break;
+    case cv::ccm::LINEARIZATION_COLORPOLYFIT:
+        p = std::make_shared<LinearColor<Polyfit>>(deg, src, dst, mask, cs);
+        break;
+    case cv::ccm::LINEARIZATION_COLORLOGPOLYFIT:
+        p = std::make_shared<LinearColor<LogPolyfit>>(deg, src, dst, mask, cs);
+        break;
+    case cv::ccm::LINEARIZATION_GRAYPOLYFIT:
+        p = std::make_shared<LinearGray<Polyfit>>(deg, src, dst, mask, cs);
+        break;
+    case cv::ccm::LINEARIZATION_GRAYLOGPOLYFIT:
+        p = std::make_shared<LinearGray<LogPolyfit>>(deg, src, dst, mask, cs);
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "Wrong linearizationType!" );
+        break;
+    }
+    return p;
+};
+
+}
+}  // namespace cv::ccm
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/linearize.hpp b/upstream/opencv/modules/photo/src/ccm/linearize.hpp
new file mode 100644
index 0000000..6fad0f5
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/linearize.hpp
@@ -0,0 +1,260 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_LINEARIZE_HPP__
+#define __OPENCV_CCM_LINEARIZE_HPP__
+
+#include <opencv2/core.hpp>
+#include <map>
+#include "color.hpp"
+#include "opencv2/photo.hpp"
+namespace cv {
+namespace ccm {
+
+/** @brief Polyfit model.
+*/
+class Polyfit
+{
+public:
+    int deg;
+    Mat p;
+    Polyfit();
+
+    /** @brief Polyfit method.
+    https://en.wikipedia.org/wiki/Polynomial_regression
+    polynomial: yi = a0 + a1*xi + a2*xi^2 + ... + an*xi^deg (i = 1,2,...,n)
+    and deduct: Ax = y
+    */
+    Polyfit(Mat x, Mat y, int deg);
+    virtual ~Polyfit() {};
+    Mat operator()(const Mat& inp);
+
+    // Serialization support
+    void write(cv::FileStorage& fs) const;
+    void read(const cv::FileNode& node);
+
+private:
+    double fromEW(double x);
+};
+
+// Global functions for FileStorage for Polyfit
+void write(cv::FileStorage& fs, const std::string&, const Polyfit& polyfit);
+void read(const cv::FileNode& node, Polyfit& polyfit, const Polyfit& defaultValue = Polyfit());
+
+/** @brief Logpolyfit model.
+*/
+class LogPolyfit
+{
+public:
+    int deg;
+    Polyfit p;
+
+    LogPolyfit();
+
+    /** @brief Logpolyfit method.
+    */
+    LogPolyfit(Mat x, Mat y, int deg);
+    virtual ~LogPolyfit() {};
+    Mat operator()(const Mat& inp);
+
+    // Serialization support
+    void write(cv::FileStorage& fs) const;
+    void read(const cv::FileNode& node);
+};
+
+// Global functions for FileStorage for LogPolyfit
+void write(cv::FileStorage& fs, const std::string&, const LogPolyfit& logpolyfit);
+void read(const cv::FileNode& node, LogPolyfit& logpolyfit, const LogPolyfit& defaultValue = LogPolyfit());
+
+/** @brief Linearization base.
+*/
+
+class Linear
+{
+public:
+    Linear() {};
+    virtual ~Linear() {};
+
+    /** @brief Inference.
+        @param inp the input array, type of cv::Mat.
+    */
+    virtual Mat linearize(Mat inp);
+    /** @brief Evaluate linearization model.
+    */
+    virtual void value(void) {};
+
+    // Serialization support
+    virtual void write(cv::FileStorage& fs) const;
+    virtual void read(const cv::FileNode& node);
+};
+
+// Global functions for FileStorage for Linear
+void write(cv::FileStorage& fs, const std::string&, const Linear& linear);
+void read(const cv::FileNode& node, Linear& linear, const Linear& defaultValue = Linear());
+
+/** @brief Linearization identity.
+           make no change.
+*/
+class LinearIdentity : public Linear
+{
+    public:
+    void write(cv::FileStorage& fs) const CV_OVERRIDE;
+    void read(const cv::FileNode& node) CV_OVERRIDE;
+};
+
+// Global functions for FileStorage for LinearIdentity
+void write(cv::FileStorage& fs, const std::string&, const LinearIdentity& linearidentity);
+void read(const cv::FileNode& node, LinearIdentity& linearidentity, const LinearIdentity& defaultValue = LinearIdentity());
+
+/** @brief Linearization gamma correction.
+*/
+class LinearGamma : public Linear
+{
+public:
+    double gamma;
+
+    LinearGamma()
+        : gamma(1.0) {};
+
+    LinearGamma(double gamma_)
+        : gamma(gamma_) {};
+
+    Mat linearize(Mat inp) CV_OVERRIDE;
+
+    // Serialization support
+    void write(cv::FileStorage& fs) const CV_OVERRIDE;
+    void read(const cv::FileNode& node) CV_OVERRIDE;
+};
+
+// Global functions for FileStorage for LinearGamma
+void write(cv::FileStorage& fs, const std::string&, const LinearGamma& lineargamma);
+void read(const cv::FileNode& node, LinearGamma& lineargamma, const LinearGamma& defaultValue = LinearGamma());
+
+/** @brief Linearization.
+           Grayscale polynomial fitting.
+*/
+template <class T>
+class LinearGray : public Linear
+{
+public:
+    int deg;
+    T p;
+
+    LinearGray(): deg(3) {};
+
+    LinearGray(int deg_, Mat src, Color dst, Mat mask, RGBBase_ cs)
+        : deg(deg_)
+    {
+        dst.getGray();
+        Mat lear_gray_mask = mask & dst.grays;
+
+        // the grayscale function is approximate for src is in relative color space.
+        Mat gray;
+        cvtColor(src, gray, COLOR_RGB2GRAY);
+        gray.copyTo(src);
+
+        Mat dst_ = maskCopyTo(dst.toGray(cs.illumobserver), lear_gray_mask);
+        calc(src, dst_);
+    }
+
+    /** @brief monotonically increase is not guaranteed.
+        @param src the input array, type of cv::Mat.
+        @param dst the input array, type of cv::Mat.
+    */
+    void calc(const Mat& src, const Mat& dst)
+    {
+        p = T(src, dst, deg);
+    };
+
+    Mat linearize(Mat inp) CV_OVERRIDE
+    {
+        return p(inp);
+    };
+
+    // Serialization support
+    void write(cv::FileStorage& fs) const CV_OVERRIDE;
+    void read(const cv::FileNode& node) CV_OVERRIDE;
+};
+
+// Global functions for FileStorage for LinearGray
+template <typename T>
+void write(cv::FileStorage& fs, const std::string&, const LinearGray<T>& lineargray);
+template <typename T>
+void read(const cv::FileNode& node, LinearGray<T>& lineargray, const LinearGray<T>& defaultValue = LinearGray<T>());
+
+/** @brief Linearization.
+           Fitting channels respectively.
+*/
+template <class T>
+class LinearColor : public Linear
+{
+public:
+    int deg;
+    T pr;
+    T pg;
+    T pb;
+
+    LinearColor(): deg(3) {};
+
+    LinearColor(int deg_, Mat src_, Color dst, Mat mask, RGBBase_ cs)
+        : deg(deg_)
+    {
+        Mat src = maskCopyTo(src_, mask);
+        Mat dst_ = maskCopyTo(dst.to(*cs.l).colors, mask);
+        calc(src, dst_);
+    }
+
+    void calc(const Mat& src, const Mat& dst)
+    {
+        Mat schannels[3];
+        Mat dchannels[3];
+        split(src, schannels);
+        split(dst, dchannels);
+        pr = T(schannels[0], dchannels[0], deg);
+        pg = T(schannels[1], dchannels[1], deg);
+        pb = T(schannels[2], dchannels[2], deg);
+    };
+
+    Mat linearize(Mat inp) CV_OVERRIDE
+    {
+        Mat channels[3];
+        split(inp, channels);
+        std::vector<Mat> channel;
+        Mat res;
+        merge(std::vector<Mat> { pr(channels[0]), pg(channels[1]), pb(channels[2]) }, res);
+        return res;
+    };
+
+    // Serialization support
+    void write(cv::FileStorage& fs) const CV_OVERRIDE;
+    void read(const cv::FileNode& node) CV_OVERRIDE;
+};
+
+// Global functions for FileStorage for LinearColor
+template <typename T>
+void write(cv::FileStorage& fs, const std::string&, const LinearColor<T>& linearcolor);
+template <typename T>
+void read(const cv::FileNode& node, LinearColor<T>& linearcolor, const LinearColor<T>& defaultValue = LinearColor<T>());
+
+/** @brief Get linearization method.
+           used in ccm model.
+    @param gamma used in LinearGamma.
+    @param deg degrees.
+    @param src the input array, type of cv::Mat.
+    @param dst the input array, type of cv::Mat.
+    @param mask the input array, type of cv::Mat.
+    @param cs type of RGBBase_.
+    @param linearizationType type of linear.
+*/
+
+std::shared_ptr<Linear> getLinear(double gamma, int deg, Mat src, Color dst, Mat mask, RGBBase_ cs, LinearizationType linearizationType);
+
+}
+}  // namespace cv::ccm
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/ccm/operations.cpp b/upstream/opencv/modules/photo/src/ccm/operations.cpp
new file mode 100644
index 0000000..b8d0114
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/operations.cpp
@@ -0,0 +1,71 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "operations.hpp"
+#include "utils.hpp"
+namespace cv {
+namespace ccm {
+
+Mat Operation::operator()(Mat& abc)
+{
+    if (!linear)
+    {
+        return f(abc);
+    }
+    if (M.empty())
+    {
+        return abc;
+    }
+    return multiple(abc, M);
+};
+
+void Operation::add(const Operation& other)
+{
+    if (M.empty())
+    {
+        M = other.M.clone();
+    }
+    else
+    {
+        M = M * other.M;
+    }
+};
+
+void Operation::clear()
+{
+    M = Mat();
+};
+
+Operations& Operations::add(const Operations& other)
+{
+    ops.insert(ops.end(), other.ops.begin(), other.ops.end());
+    return *this;
+};
+
+Mat Operations::run(Mat abc)
+{
+    Operation hd;
+    for (auto& op : ops)
+    {
+        if (op.linear)
+        {
+            hd.add(op);
+        }
+        else
+        {
+            abc = hd(abc);
+            hd.clear();
+            abc = op(abc);
+        }
+    }
+    abc = hd(abc);
+    return abc;
+}
+
+}
+}  // namespace cv::ccm
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/operations.hpp b/upstream/opencv/modules/photo/src/ccm/operations.hpp
new file mode 100644
index 0000000..1459be0
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/operations.hpp
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_OPERATIONS_HPP__
+#define __OPENCV_CCM_OPERATIONS_HPP__
+
+#include "utils.hpp"
+
+namespace cv {
+namespace ccm {
+
+/** @brief Operation class contains some operarions used for color space
+           conversion containing linear transformation and non-linear transformation
+   */
+class Operation
+{
+public:
+    typedef std::function<Mat(Mat)> MatFunc;
+    bool linear;
+    Mat M;
+    MatFunc f;
+
+    Operation()
+        : linear(true)
+        , M(Mat()) {};
+    Operation(Mat M_)
+        : linear(true)
+        , M(M_) {};
+    Operation(MatFunc f_)
+        : linear(false)
+        , f(f_) {};
+    virtual ~Operation() {};
+
+    /** @brief operator function will run operation
+    */
+    Mat operator()(Mat& abc);
+
+    /** @brief add function will conbine this operation
+               with other linear transformation operation
+    */
+    void add(const Operation& other);
+
+    void clear();
+    static Operation& getIdentityOp()
+    {
+        static Operation identity_op([](Mat x) { return x; });
+        return identity_op;
+    }
+};
+
+class Operations
+{
+public:
+    std::vector<Operation> ops;
+    Operations()
+        : ops {} {};
+    Operations(std::initializer_list<Operation> op)
+        : ops { op } {};
+    virtual ~Operations() {};
+
+    /** @brief add function will conbine this operation with other transformation operations
+    */
+    Operations& add(const Operations& other);
+
+    /** @brief run operations to make color conversion
+    */
+    Mat run(Mat abc);
+    static const Operations& getIdentityOps()
+    {
+        static Operations Operation_op {Operation::getIdentityOp()};
+        return Operation_op;
+    }
+};
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/ccm/utils.cpp b/upstream/opencv/modules/photo/src/ccm/utils.cpp
new file mode 100644
index 0000000..71cd854
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/utils.cpp
@@ -0,0 +1,113 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#include "utils.hpp"
+
+namespace cv {
+namespace ccm {
+
+void gammaCorrection(InputArray _src, OutputArray _dst, double gamma)
+{
+    Mat src = _src.getMat();
+    CV_Assert(gamma > 0);
+
+    double  maxVal;
+    int     depth = src.depth();
+    switch (depth)
+    {
+        case CV_8U:  maxVal = 255.0;    break;
+        case CV_16U: maxVal = 65535.0;  break;
+        case CV_16S: maxVal = 32767.0;  break;
+        case CV_32F: maxVal = 1.0;      break;
+        case CV_64F: maxVal = 1.0;      break;
+        default:
+            CV_Error(Error::StsUnsupportedFormat,
+                "gammaCorrection: unsupported image depth");
+    }
+
+    // Special‐case for uint8 with a LUT
+    if (depth == CV_8U)
+    {
+        Mat lut(1, 256, CV_8U);
+        uchar* p = lut.ptr<uchar>();
+        for (int i = 0; i < 256; ++i)
+        {
+            double fn = std::pow(i / 255.0, gamma) * 255.0;
+            p[i] = cv::saturate_cast<uchar>(fn + 0.5);
+        }
+        _dst.create(src.size(), src.type());
+        Mat dst = _dst.getMat();
+        cv::LUT(src, lut, dst);
+        return;
+    }
+
+    Mat f;
+    src.convertTo(f, CV_64F, 1.0 / maxVal);
+    cv::pow(f, gamma, f);
+
+    _dst.create(src.size(), src.type());
+    Mat dst = _dst.getMat();
+    f.convertTo(dst, src.type(), maxVal);
+}
+
+
+Mat maskCopyTo(const Mat& src, const Mat& mask)
+{
+    Mat fullMasked;
+    src.copyTo(fullMasked, mask);
+
+    std::vector<Point> nonZeroLocations;
+    findNonZero(mask, nonZeroLocations);
+
+    Mat dst(static_cast<int>(nonZeroLocations.size()), 1, src.type());
+
+    int channels = src.channels();
+    if (channels == 1)
+    {
+        for (size_t i = 0; i < nonZeroLocations.size(); i++)
+        {
+            dst.at<double>(static_cast<int>(i), 0) = fullMasked.at<double>(nonZeroLocations[i]);
+        }
+    }
+    else if (channels == 3)
+    {
+        for (size_t i = 0; i < nonZeroLocations.size(); i++)
+        {
+            dst.at<Vec3d>(static_cast<int>(i), 0) = fullMasked.at<Vec3d>(nonZeroLocations[i]);
+        }
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "Unsupported number of channels");
+    }
+
+    return dst;
+}
+
+Mat multiple(const Mat& xyz, const Mat& ccm)
+{
+    Mat tmp = xyz.reshape(1, xyz.rows * xyz.cols);
+    Mat res = tmp * ccm;
+    res = res.reshape(res.cols, xyz.rows);
+    return res;
+}
+
+Mat saturate(Mat& src, double low, double up)
+{
+    CV_Assert(src.type() == CV_64FC3);
+    Scalar lower_bound(low, low, low);
+    Scalar upper_bound(up, up, up);
+
+    Mat mask;
+    inRange(src, lower_bound, upper_bound, mask);
+    mask /= 255;
+
+    return mask;
+}
+}
+}  // namespace cv::ccm
diff --git a/upstream/opencv/modules/photo/src/ccm/utils.hpp b/upstream/opencv/modules/photo/src/ccm/utils.hpp
new file mode 100644
index 0000000..aad7f97
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/ccm/utils.hpp
@@ -0,0 +1,145 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Author: Longbu Wang <wanglongbu@huawei.com.com>
+//         Jinheng Zhang <zhangjinheng1@huawei.com>
+//         Chenqi Shan <shanchenqi@huawei.com>
+
+#ifndef __OPENCV_CCM_UTILS_HPP__
+#define __OPENCV_CCM_UTILS_HPP__
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+
+namespace cv {
+namespace ccm {
+/** @brief gamma correction.
+           \f[
+            C_l=C_n^{\gamma},\qquad C_n\ge0\\
+            C_l=-(-C_n)^{\gamma},\qquad C_n<0\\\\
+            \f]
+    @param src the input array,type of Mat.
+    @param gamma a constant for gamma correction greater than zero.
+    @param dst the output array, type of Mat.
+ */
+ CV_EXPORTS_W void gammaCorrection(InputArray src, OutputArray dst, double gamma);
+
+/** @brief maskCopyTo a function to delete unsatisfied elementwise.
+    @param src the input array, type of Mat.
+    @param mask operation mask that used to choose satisfided elementwise.
+ */
+Mat maskCopyTo(const Mat& src, const Mat& mask);
+
+/** @brief multiple the function used to compute an array with n channels
+      mulipied by ccm.
+    @param xyz the input array, type of Mat.
+    @param ccm the ccm matrix to make color correction.
+ */
+Mat multiple(const Mat& xyz, const Mat& ccm);
+
+/** @brief multiple the function used to get the mask of saturated colors,
+            colors between low and up will be choosed.
+    @param src the input array, type of Mat.
+    @param low  the threshold to choose saturated colors
+    @param up  the threshold to choose saturated colors
+*/
+Mat saturate(Mat& src, double low, double up);
+
+/** @brief function for elementWise operation
+    @param src the input array, type of Mat
+    @param lambda a for operation
+ */
+template <typename F>
+Mat elementWise(const Mat& src, F&& lambda, Mat dst=Mat())
+{
+    if (dst.empty() || !dst.isContinuous() || dst.total() != src.total() || dst.type() != src.type())
+        dst = Mat(src.rows, src.cols, src.type());
+    const int channel = src.channels();
+    if (src.isContinuous()) {
+        const int num_elements = (int)src.total()*channel;
+        const double *psrc = (double*)src.data;
+        double *pdst = (double*)dst.data;
+        const int batch = getNumThreads() > 1 ? 128 : num_elements;
+        const int N = (num_elements / batch) + ((num_elements % batch) > 0);
+        parallel_for_(Range(0, N),[&](const Range& range) {
+            const int start = range.start * batch;
+            const int end = std::min(range.end*batch, num_elements);
+            for (int i = start; i < end; i++) {
+                pdst[i] = lambda(psrc[i]);
+            }
+        });
+        return dst;
+    }
+    switch (channel)
+    {
+    case 1:
+    {
+
+        MatIterator_<double> it, end;
+        for (it = dst.begin<double>(), end = dst.end<double>(); it != end; ++it)
+        {
+            (*it) = lambda((*it));
+        }
+        break;
+    }
+    case 3:
+    {
+        MatIterator_<Vec3d> it, end;
+        for (it = dst.begin<Vec3d>(), end = dst.end<Vec3d>(); it != end; ++it)
+        {
+            for (int j = 0; j < 3; j++)
+            {
+                (*it)[j] = lambda((*it)[j]);
+            }
+        }
+        break;
+    }
+    default:
+        CV_Error(Error::StsBadArg, "Wrong channel!" );
+        break;
+    }
+    return dst;
+}
+
+/** @brief function for channel operation
+      @param src the input array, type of Mat
+      @param lambda the function for operation
+*/
+template <typename F>
+Mat channelWise(const Mat& src, F&& lambda)
+{
+    Mat dst = src.clone();
+    MatIterator_<Vec3d> it, end;
+    for (it = dst.begin<Vec3d>(), end = dst.end<Vec3d>(); it != end; ++it)
+    {
+        *it = lambda(*it);
+    }
+    return dst;
+}
+
+/** @brief function for distance operation.
+    @param src the input array, type of Mat.
+    @param ref another input array, type of Mat.
+    @param lambda the computing method for distance .
+ */
+template <typename F>
+Mat distanceWise(Mat& src, Mat& ref, F&& lambda)
+{
+    Mat dst = Mat(src.size(), CV_64FC1);
+    MatIterator_<Vec3d> it_src = src.begin<Vec3d>(), end_src = src.end<Vec3d>(),
+                        it_ref = ref.begin<Vec3d>();
+    MatIterator_<double> it_dst = dst.begin<double>();
+    for (; it_src != end_src; ++it_src, ++it_ref, ++it_dst)
+    {
+        *it_dst = lambda(*it_src, *it_ref);
+    }
+    return dst;
+}
+
+Mat multiple(const Mat& xyz, const Mat& ccm);
+
+}
+}  // namespace cv::ccm
+
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp b/upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp
new file mode 100644
index 0000000..869ec46
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/chromatic_aberration_correction.cpp
@@ -0,0 +1,242 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv {
+
+CV_EXPORTS_W void loadChromaticAberrationParams(const FileNode& fs,
+                                                OutputArray coeffMat,
+                                                Size& calib_size,
+                                                int& degree)
+{
+    int imgW = 0, imgH = 0;
+    fs["image_width"]  >> imgW;
+    fs["image_height"] >> imgH;
+
+    CV_Assert(imgW > 0 && imgH > 0);
+
+    auto readChannel = [&](const char* key,
+                            std::vector<double>& coeffs_x,
+                           std::vector<double>& coeffs_y,
+                           int& deg_out)
+    {
+        FileNode ch = fs[key];
+        if (ch.empty())
+            CV_Error_(Error::StsParseError,
+                        ("Missing channel \"%s\"", key));
+
+        ch["coeffs_x"] >> coeffs_x;
+        ch["coeffs_y"] >> coeffs_y;
+
+        if (coeffs_x.empty() || coeffs_y.empty())
+            CV_Error_(Error::StsParseError,
+                        ("%s: coeffs_x/coeffs_y missing", key));
+
+        if (coeffs_x.size() != coeffs_y.size())
+            CV_Error_(Error::StsBadSize,
+                        ("%s: coeffs_x (%zu) vs coeffs_y (%zu)",
+                        key, coeffs_x.size(), coeffs_y.size()));
+
+        if (!checkRange(coeffs_x, true) || !checkRange(coeffs_y, true))
+            CV_Error_(Error::StsBadArg,
+                      ("%s: coefficient array contains NaN/Inf", key));
+        size_t m = coeffs_x.size();
+        double n_float = (std::sqrt(1.0 + 8.0 * m) - 3.0) / 2.0;
+        int deg = static_cast<int>(std::round(n_float));
+        size_t expected_m = static_cast<size_t>((deg + 1) * (deg + 2) / 2);
+        if (m != expected_m){
+            CV_Error_(Error::StsBadArg,
+                    ("Coefficient count %zu is not triangular for degree %d "
+                    "(expected %zu)", m, deg, expected_m));
+        }
+        deg_out = deg;
+    };
+
+    std::vector<double> red_x, red_y, blue_x, blue_y;
+    int deg_red = 0, deg_blue = 0;
+    readChannel("red_channel",  red_x,  red_y,  deg_red);
+    readChannel("blue_channel", blue_x, blue_y, deg_blue);
+
+
+    if (red_x.size() != blue_x.size()){
+        CV_Error_(Error::StsBadSize,
+                    ("Red (%zu) and blue (%zu) coefficient counts differ",
+                    red_x.size(), blue_x.size()));
+    }
+    if (deg_red != deg_blue){
+        CV_Error_(Error::StsBadArg,
+                    ("Red (%d) and blue (%d) degrees differ",
+                    deg_red, deg_blue));
+    }
+
+    const int mterms = (int)red_x.size();
+
+    Mat tmp(4, mterms, CV_32F);
+
+    float* Bx = tmp.ptr<float>(0);
+    float* By = tmp.ptr<float>(1);
+    float* Rx = tmp.ptr<float>(2);
+    float* Ry = tmp.ptr<float>(3);
+
+    for (int i = 0; i < mterms; ++i) {
+        Bx[i] = static_cast<float>(blue_x[i]);
+        By[i] = static_cast<float>(blue_y[i]);
+        Rx[i] = static_cast<float>(red_x[i]);
+        Ry[i] = static_cast<float>(red_y[i]);
+    }
+
+    calib_size = Size(imgW, imgH);
+    degree = deg_red;
+    tmp.copyTo(coeffMat);
+}
+
+static void buildRemapsFromCoeffMat(int height, int width,
+                             const Mat& coeffs,
+                             int degree,
+                             int rowX, int rowY,
+                             Mat& map_x, Mat& map_y)
+{
+    if (coeffs.type() != CV_32F) {
+        CV_Error_(Error::StsUnsupportedFormat,
+                  ("coeffs Mat must be CV_32F (got type=%d)", coeffs.type()));
+    }
+
+    if (coeffs.rows != 4) {
+        CV_Error_(Error::StsBadSize,
+                  ("coeffs.rows must be 4 (Bx,By,Rx,Ry); got %d", coeffs.rows));
+    }
+
+    if (rowX < 0 || rowX >= coeffs.rows) {
+        CV_Error_(Error::StsOutOfRange,
+                  ("rowX index %d out of range [0,%d)", rowX, coeffs.rows));
+    }
+    if (rowY < 0 || rowY >= coeffs.rows) {
+        CV_Error_(Error::StsOutOfRange,
+                  ("rowY index %d out of range [0,%d)", rowY, coeffs.rows));
+    }
+
+    if (degree < 0) {
+        CV_Error_(Error::StsBadArg,
+                  ("degree must be non-negative; got %d", degree));
+    }
+
+    const int expected_terms = (degree + 1) * (degree + 2) / 2;
+    if (coeffs.cols != expected_terms) {
+        CV_Error_(Error::StsBadSize,
+                  ("coeffs.cols (%d) != expected polynomial term count (%d) for degree=%d",
+                   coeffs.cols, expected_terms, degree));
+    }
+
+    if (width <= 0 || height <= 0) {
+        CV_Error_(Error::StsBadArg,
+                  ("width (%d) and height (%d) must be positive", width, height));
+    }
+
+    Mat X(1, width, CV_32F), Y(height, 1, CV_32F);
+    for (int i = 0; i < width;  ++i) X.at<float>(0,i) = (float)i;
+    for (int j = 0; j < height; ++j) Y.at<float>(j,0) = (float)j;
+
+    Mat Xgrid, Ygrid;
+    repeat(X, height, 1, Xgrid);
+    repeat(Y, 1, width,  Ygrid);
+
+    Mat dx(height, width, CV_32F);
+    Mat dy(height, width, CV_32F);
+
+    const double mean_x    = width  * 0.5;
+    const double mean_y    = height * 0.5;
+    const double inv_std_x = 1.0 / mean_x;
+    const double inv_std_y = 1.0 / mean_y;
+
+    const float* Cx = coeffs.ptr<float>(rowX);
+    const float* Cy = coeffs.ptr<float>(rowY);
+
+
+    parallel_for_(Range(0, height), [&](const Range& rows){
+        std::vector<double> x_pow(degree + 1);
+        std::vector<double> y_pow(degree + 1);
+        for (int y = rows.start; y < rows.end; ++y) {
+            const float* XR = Xgrid.ptr<float>(y);
+            const float* YR = Ygrid.ptr<float>(y);
+            float* DX = dx.ptr<float>(y);
+            float* DY = dy.ptr<float>(y);
+            for (int x = 0; x < width; ++x) {
+                const double xn = (XR[x] - mean_x) * inv_std_x;
+                const double yn = (YR[x] - mean_y) * inv_std_y;
+
+                x_pow[0] = y_pow[0] = 1.0;
+                for (int k = 1; k <= degree; ++k) {
+                    x_pow[k] = x_pow[k-1] * xn;
+                    y_pow[k] = y_pow[k-1] * yn;
+                }
+
+                double dxv = 0.0, dyv = 0.0;
+                int idx = 0;
+                for (int t = 0; t <= degree; ++t){
+                    for (int i = 0; i <= t; ++i){
+                        const int j = t - i;
+                        const double term = x_pow[i] * y_pow[j];
+                        dxv += Cx[idx] * term;
+                        dyv += Cy[idx] * term;
+                        ++idx;
+                    }
+                }
+
+                DX[x] = (float)dxv;
+                DY[x] = (float)dyv;
+            }
+        }
+    });
+
+    map_x = Xgrid - dx;
+    map_y = Ygrid - dy;
+}
+
+void correctChromaticAberration(InputArray input_image,
+                                InputArray coefficients,
+                                OutputArray output_image,
+                                const Size& calib_size,
+                                int calib_degree,
+                                int bayer_pattern)
+{
+    Mat image = input_image.getMat();
+    const Mat coeffMat = coefficients.getMat();
+
+    if (image.channels() == 1) {
+        if (bayer_pattern < 0) {
+            CV_Error_(Error::StsBadArg,
+                      ("Single-channel input detected: must pass a valid bayer_pattern"));
+        }
+        Mat dem;
+        demosaicing(image, dem, bayer_pattern);
+        image = dem;
+    }
+
+    const int height = image.rows;
+    const int width  = image.cols;
+
+    if (height != calib_size.height || width != calib_size.width) {
+        CV_Error_(Error::StsBadArg,
+                  ("Image size %dx%d does not match calibration %dx%d",
+                   width, height, calib_size.width, calib_size.height));
+    }
+
+    std::vector<Mat> channels;
+    split(image, channels);
+    Mat b = channels[0], g = channels[1], r = channels[2];
+
+    Mat map_x_r, map_y_r, map_x_b, map_y_b;
+    buildRemapsFromCoeffMat(height, width, coeffMat, calib_degree, 2, 3, map_x_r, map_y_r);
+    buildRemapsFromCoeffMat(height, width, coeffMat, calib_degree, 0, 1, map_x_b, map_y_b);
+
+    Mat r_corr, b_corr;
+    remap(r, r_corr, map_x_r, map_y_r, INTER_LINEAR, BORDER_REPLICATE);
+    remap(b, b_corr, map_x_b, map_y_b, INTER_LINEAR, BORDER_REPLICATE);
+
+    std::vector<Mat> corrected_channels = {b_corr, g, r_corr};
+    Mat corrected_image;
+    merge(corrected_channels, output_image);
+}
+}
diff --git a/upstream/opencv/modules/photo/src/contrast_preserve.cpp b/upstream/opencv/modules/photo/src/contrast_preserve.cpp
new file mode 100644
index 0000000..3321593
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/contrast_preserve.cpp
@@ -0,0 +1,174 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <cmath>
+#include <vector>
+#include <limits>
+#include "contrast_preserve.hpp"
+
+using namespace std;
+using namespace cv;
+
+void cv::decolor(InputArray _src, OutputArray _dst, OutputArray _color_boost)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC1);
+    Mat dst = _dst.getMat();
+
+    _color_boost.create(I.size(), CV_8UC3);
+    Mat color_boost = _color_boost.getMat();
+
+    CV_Assert(!I.empty() && (I.channels()==3));
+
+    // Parameter Setting
+    const int maxIter = 15;
+    const double tol = .0001;
+    int iterCount = 0;
+    double E = 0;
+    double pre_E = std::numeric_limits<double>::infinity();
+
+    Mat img;
+    I.convertTo(img, CV_32FC3, 1.0/255.0);
+
+    // Initialization
+    Decolor obj;
+
+    vector <double> Cg;
+    vector < vector <double> > polyGrad;
+    vector <Vec3i> comb;
+    vector <double> alf;
+
+    obj.grad_system(img,polyGrad,Cg,comb);
+    obj.weak_order(img,alf);
+
+    // Solver
+    Mat Mt = Mat(int(polyGrad.size()),int(polyGrad[0].size()), CV_32FC1);
+    obj.wei_update_matrix(polyGrad,Cg,Mt);
+
+    vector <double> wei;
+    obj.wei_inti(comb,wei);
+
+    //////////////////////////////// main loop starting ////////////////////////////////////////
+
+    vector <double> G_pos(alf.size());
+    vector <double> G_neg(alf.size());
+    vector <double> EXPsum(G_pos.size());
+    vector <double> EXPterm(G_pos.size());
+    vector <double> temp(polyGrad[0].size());
+    vector <double> temp1(polyGrad[0].size());
+    vector <double> temp2(EXPsum.size());
+    vector <double> wei1(polyGrad.size());
+
+    while(std::abs(E-pre_E) > tol)
+    {
+        iterCount +=1;
+        pre_E = E;
+
+        for(size_t i=0; i<polyGrad[0].size(); i++)
+        {
+            double val = 0.0;
+            for(size_t j=0; j<polyGrad.size(); j++)
+                val = val + (polyGrad[j][i] * wei[j]);
+            temp[i] = val - Cg[i];
+            temp1[i] = val + Cg[i];
+        }
+
+        for(size_t i=0; i<alf.size(); i++)
+        {
+            const double sqSigma = obj.sigma * obj.sigma;
+            const double pos = ((1 + alf[i])/2) * exp(-1.0 * 0.5 * (temp[i] * temp[i]) / sqSigma);
+            const double neg = ((1 - alf[i])/2) * exp(-1.0 * 0.5 * (temp1[i] * temp1[i]) / sqSigma);
+            G_pos[i] = pos;
+            G_neg[i] = neg;
+        }
+
+        for(size_t i=0; i<G_pos.size(); i++)
+            EXPsum[i] = G_pos[i]+G_neg[i];
+
+        for(size_t i=0; i<EXPsum.size(); i++)
+            temp2[i] = (EXPsum[i] == 0) ? 1.0 : 0.0;
+
+        for(size_t i=0; i<G_pos.size(); i++)
+            EXPterm[i] = (G_pos[i] - G_neg[i])/(EXPsum[i] + temp2[i]);
+
+        for(int i=0; i<int(polyGrad.size()); i++)
+        {
+            double val1 = 0.0;
+            for(int j=0; j<int(polyGrad[0].size()); j++)
+            {
+                val1 = val1 + (Mt.at<float>(i,j) * EXPterm[j]);
+            }
+            wei1[i] = val1;
+        }
+
+        for(size_t i=0; i<wei.size(); i++)
+            wei[i] = wei1[i];
+
+        E = obj.energyCalcu(Cg, polyGrad, wei);
+
+        if(iterCount > maxIter)
+            break;
+    }
+
+    Mat Gray = Mat::zeros(img.size(),CV_32FC1);
+    obj.grayImContruct(wei, img, Gray);
+
+    Gray.convertTo(dst,CV_8UC1,255);
+
+    ///////////////////////////////////       Contrast Boosting   /////////////////////////////////
+
+    Mat lab;
+    cvtColor(I,lab,COLOR_BGR2Lab);
+
+    vector <Mat> lab_channel;
+    split(lab,lab_channel);
+
+    dst.copyTo(lab_channel[0]);
+
+    merge(lab_channel,lab);
+
+    cvtColor(lab,color_boost,COLOR_Lab2BGR);
+}
diff --git a/upstream/opencv/modules/photo/src/contrast_preserve.hpp b/upstream/opencv/modules/photo/src/contrast_preserve.hpp
new file mode 100644
index 0000000..d0a1948
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/contrast_preserve.hpp
@@ -0,0 +1,383 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <cmath>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+class Decolor
+{
+    private:
+        Mat kernelx;
+        Mat kernely;
+        int order;
+
+    public:
+        float sigma;
+
+        Decolor();
+        static vector<double> product(const vector <Vec3i> &comb, const double initRGB[3]);
+        double energyCalcu(const vector <double> &Cg, const vector < vector <double> > &polyGrad, const vector <double> &wei) const;
+        void singleChannelGradx(const Mat &img, Mat& dest) const;
+        void singleChannelGrady(const Mat &img, Mat& dest) const;
+        void gradvector(const Mat &img, vector <double> &grad) const;
+        void colorGrad(const Mat &img, vector <double> &Cg) const;
+        static void add_vector(vector <Vec3i> &comb, int &idx, int r,int g,int b);
+        static void add_to_vector_poly(vector < vector <double> > &polyGrad, const vector <double> &curGrad, int &idx1);
+        void weak_order(const Mat &img, vector <double> &alf) const;
+        void grad_system(const Mat &img, vector < vector < double > > &polyGrad,
+                vector < double > &Cg, vector <Vec3i>& comb) const;
+        static void wei_update_matrix(const vector < vector <double> > &poly, const vector <double> &Cg, Mat &X);
+        static void wei_inti(const vector <Vec3i> &comb, vector <double> &wei);
+        void grayImContruct(vector <double> &wei, const Mat &img, Mat &Gray) const;
+};
+
+double Decolor::energyCalcu(const vector <double> &Cg, const vector < vector <double> > &polyGrad, const vector <double> &wei) const
+{
+    const size_t size = polyGrad[0].size();
+    vector <double> energy(size);
+    vector <double> temp(size);
+    vector <double> temp1(size);
+
+    for(size_t i=0;i< polyGrad[0].size();i++)
+    {
+        double val = 0.0;
+        for(size_t j =0;j<polyGrad.size();j++)
+            val = val + (polyGrad[j][i] * wei[j]);
+        temp[i] = val - Cg[i];
+        temp1[i] = val + Cg[i];
+    }
+
+    for(size_t i=0;i<polyGrad[0].size();i++)
+        energy[i] = -1.0*log(exp(-1.0*std::pow(temp[i],2)/sigma) + exp(-1.0*std::pow(temp1[i],2)/sigma));
+
+    double sum = 0.0;
+    for(size_t i=0;i<polyGrad[0].size();i++)
+        sum +=energy[i];
+
+    return (sum/polyGrad[0].size());
+
+}
+
+Decolor::Decolor()
+{
+    kernelx = Mat(1,2, CV_32FC1);
+    kernely = Mat(2,1, CV_32FC1);
+    kernelx.at<float>(0,0)=1.0;
+    kernelx.at<float>(0,1)=-1.0;
+    kernely.at<float>(0,0)=1.0;
+    kernely.at<float>(1,0)=-1.0;
+    order = 2;
+    sigma = 0.02f;
+}
+
+vector<double> Decolor::product(const vector<Vec3i> &comb, const double initRGB[3])
+{
+    vector <double> res(comb.size());
+    for (size_t i=0;i<comb.size();i++)
+    {
+        double dp = 0.0;
+        for(int j=0;j<3;j++)
+        {
+            dp = dp + (comb[i][j] * initRGB[j]);
+        }
+        res[i] = dp;
+    }
+    return res;
+}
+
+void Decolor::singleChannelGradx(const Mat &img, Mat& dest) const
+{
+    const int w = img.size().width;
+    const Point anchor(kernelx.cols - kernelx.cols/2 - 1, kernelx.rows - kernelx.rows/2 - 1);
+    filter2D(img, dest, -1, kernelx, anchor, 0.0, BORDER_CONSTANT);
+    dest.col(w - 1) = 0.0;
+}
+
+void Decolor::singleChannelGrady(const Mat &img, Mat& dest) const
+{
+    const int h = img.size().height;
+    const Point anchor(kernely.cols - kernely.cols/2 - 1, kernely.rows - kernely.rows/2 - 1);
+    filter2D(img, dest, -1, kernely, anchor, 0.0, BORDER_CONSTANT);
+    dest.row(h - 1) = 0.0;
+}
+
+void Decolor::gradvector(const Mat &img, vector <double> &grad) const
+{
+    Mat dest;
+    Mat dest1;
+    singleChannelGradx(img,dest);
+    singleChannelGrady(img,dest1);
+
+    // the function uses transposed dest and dest1 here and bellow
+    const int height = dest.size().width;
+    const int width = dest.size().height;
+
+    grad.resize(width * height * 2);
+
+    for(int i=0;i<height;i++)
+        for(int j=0;j<width;j++)
+            grad[i*width + j] = dest.at<float>(j, i);
+
+    const int offset = width * height;
+    for(int i=0;i<height;i++)
+        for(int j=0;j<width;j++)
+            grad[offset + i * width + j] = dest1.at<float>(j, i);
+}
+
+void Decolor::colorGrad(const Mat &img, vector <double> &Cg) const
+{
+    Mat lab;
+
+    cvtColor(img,lab,COLOR_BGR2Lab);
+
+    vector <Mat> lab_channel;
+    split(lab,lab_channel);
+
+    vector <double> ImL;
+    vector <double> Ima;
+    vector <double> Imb;
+
+    gradvector(lab_channel[0],ImL);
+    gradvector(lab_channel[1],Ima);
+    gradvector(lab_channel[2],Imb);
+
+    Cg.resize(ImL.size());
+    for(size_t i=0;i<ImL.size();i++)
+    {
+        const double res = sqrt(std::pow(ImL[i],2) + std::pow(Ima[i],2) + std::pow(Imb[i],2))/100;
+        Cg[i] = res;
+    }
+}
+
+void Decolor::add_vector(vector <Vec3i> &comb, int &idx, int r,int g,int b)
+{
+    comb.push_back(Vec3i(r, g, b));
+    idx++;
+}
+
+void Decolor::add_to_vector_poly(vector < vector <double> > &polyGrad, const vector <double> &curGrad, int &idx1)
+{
+    polyGrad.push_back(curGrad);
+    idx1++;
+}
+
+void Decolor::weak_order(const Mat &im, vector <double> &alf) const
+{
+    Mat img;
+    const int h = im.size().height;
+    const int w = im.size().width;
+    if((h + w) > 800)
+    {
+        const double sizefactor = double(800)/(h+w);
+        resize(im, img, Size(cvRound(w*sizefactor), cvRound(h*sizefactor)));
+    }
+    else
+    {
+        img = im;
+    }
+
+    Mat curIm = Mat(img.size(),CV_32FC1);
+    vector <Mat> rgb_channel;
+    split(img,rgb_channel);
+
+    vector <double> Rg, Gg, Bg;
+    gradvector(rgb_channel[2],Rg);
+    gradvector(rgb_channel[1],Gg);
+    gradvector(rgb_channel[0],Bg);
+
+    vector <double> t1(Rg.size()), t2(Rg.size()), t3(Rg.size());
+    vector <double> tmp1(Rg.size()), tmp2(Rg.size()), tmp3(Rg.size());
+
+    const double level = .05;
+
+    for(size_t i=0;i<Rg.size();i++)
+    {
+        t1[i] = (Rg[i] > level) ? 1.0 : 0.0;
+        t2[i] = (Gg[i] > level) ? 1.0 : 0.0;
+        t3[i] = (Bg[i] > level) ? 1.0 : 0.0;
+        tmp1[i] = (Rg[i] < -1.0*level) ? 1.0 : 0.0;
+        tmp2[i] = (Gg[i] < -1.0*level) ? 1.0 : 0.0;
+        tmp3[i] = (Bg[i] < -1.0*level) ? 1.0 : 0.0;
+    }
+
+    alf.resize(Rg.size());
+    for(size_t i =0 ;i < Rg.size();i++)
+        alf[i] = (t1[i] * t2[i] * t3[i]);
+
+    for(size_t i =0 ;i < Rg.size();i++)
+        alf[i] -= tmp1[i] * tmp2[i] * tmp3[i];
+}
+
+void Decolor::grad_system(const Mat &im, vector < vector < double > > &polyGrad,
+        vector < double > &Cg, vector <Vec3i>& comb) const
+{
+    Mat img;
+    int h = im.size().height;
+    int w = im.size().width;
+    if((h + w) > 800)
+    {
+        const double sizefactor = double(800)/(h+w);
+        resize(im, img, Size(cvRound(w*sizefactor), cvRound(h*sizefactor)));
+    }
+    else
+    {
+        img = im;
+    }
+
+    h = img.size().height;
+    w = img.size().width;
+    colorGrad(img,Cg);
+
+    Mat curIm = Mat(img.size(),CV_32FC1);
+    vector <Mat> rgb_channel;
+    split(img,rgb_channel);
+
+    int idx = 0, idx1 = 0;
+    for(int r=0 ;r <=order; r++)
+    {
+        for(int g=0; g<=order;g++)
+        {
+            for(int b =0; b <=order;b++)
+            {
+                if((r+g+b)<=order && (r+g+b) > 0)
+                {
+                    add_vector(comb,idx,r,g,b);
+                    for(int i = 0;i<h;i++)
+                        for(int j=0;j<w;j++)
+                            curIm.at<float>(i,j)=static_cast<float>(
+                                std::pow(rgb_channel[2].at<float>(i,j),r)*std::pow(rgb_channel[1].at<float>(i,j),g)*
+                                std::pow(rgb_channel[0].at<float>(i,j),b));
+                    vector <double> curGrad;
+                    gradvector(curIm,curGrad);
+                    add_to_vector_poly(polyGrad,curGrad,idx1);
+                }
+            }
+        }
+    }
+}
+
+void Decolor::wei_update_matrix(const vector < vector <double> > &poly, const vector <double> &Cg, Mat &X)
+{
+    const int size = static_cast<int>(poly.size());
+    const int size0 = static_cast<int>(poly[0].size());
+    Mat P = Mat(size, size0, CV_32FC1);
+
+    for (int i = 0; i < size; i++)
+        for (int j = 0; j < size0;j++)
+            P.at<float>(i,j) = static_cast<float>(poly[i][j]);
+
+    Mat B = Mat(size, size0, CV_32FC1);
+    for(int i =0;i < size;i++)
+    {
+        for(int j = 0, end = int(Cg.size()); j < end;j++)
+            B.at<float>(i,j) = static_cast<float>(poly[i][j] * Cg[j]);
+    }
+
+    Mat A;
+    mulTransposed(P, A, false);
+    solve(A, B, X, DECOMP_NORMAL);
+
+}
+
+void Decolor::wei_inti(const vector <Vec3i> &comb, vector <double> &wei)
+{
+    double initRGB[3] = { .33, .33, .33 };
+
+    wei = product(comb,initRGB);
+
+    vector <int> sum(comb.size());
+
+    for(size_t i=0;i<comb.size();i++)
+        sum[i] = (comb[i][0] + comb[i][1] + comb[i][2]);
+
+    for(size_t i=0;i<sum.size();i++)
+    {
+        if(sum[i] == 1)
+            wei[i] = wei[i] * double(1);
+        else
+            wei[i] = wei[i] * double(0);
+    }
+
+    sum.clear();
+
+}
+
+void Decolor::grayImContruct(vector <double> &wei, const Mat &img, Mat &Gray) const
+{
+    const int h = img.size().height;
+    const int w = img.size().width;
+
+    vector <Mat> rgb_channel;
+    split(img,rgb_channel);
+
+    int kk =0;
+
+    for(int r =0;r<=order;r++)
+    {
+        for(int g=0;g<=order;g++)
+        {
+            for(int b=0;b<=order;b++)
+            {
+                if((r + g + b) <=order && (r+g+b) > 0)
+                {
+                    for(int i = 0;i<h;i++)
+                        for(int j=0;j<w;j++)
+                            Gray.at<float>(i,j)=static_cast<float>(Gray.at<float>(i,j) +
+                                static_cast<float>(wei[kk])*std::pow(rgb_channel[2].at<float>(i,j),r)*std::pow(rgb_channel[1].at<float>(i,j),g)*
+                                std::pow(rgb_channel[0].at<float>(i,j),b));
+
+                    kk=kk+1;
+                }
+            }
+        }
+    }
+
+    double minval, maxval;
+    minMaxLoc(Gray, &minval, &maxval);
+
+    Gray -= minval;
+    Gray /= maxval - minval;
+}
diff --git a/upstream/opencv/modules/photo/src/cuda/nlm.cu b/upstream/opencv/modules/photo/src/cuda/nlm.cu
new file mode 100644
index 0000000..07e9a74
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/cuda/nlm.cu
@@ -0,0 +1,564 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/core/cuda/common.hpp"
+#include "opencv2/core/cuda/vec_traits.hpp"
+#include "opencv2/core/cuda/vec_math.hpp"
+#include "opencv2/core/cuda/functional.hpp"
+#include "opencv2/core/cuda/reduce.hpp"
+#include "opencv2/core/cuda/border_interpolate.hpp"
+
+using namespace cv::cuda;
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+
+//////////////////////////////////////////////////////////////////////////////////
+//// Non Local Means Denosing
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+        __device__ __forceinline__ float norm2(const float& v) { return v*v; }
+        __device__ __forceinline__ float norm2(const float2& v) { return v.x*v.x + v.y*v.y; }
+        __device__ __forceinline__ float norm2(const float3& v) { return v.x*v.x + v.y*v.y + v.z*v.z; }
+        __device__ __forceinline__ float norm2(const float4& v) { return v.x*v.x + v.y*v.y + v.z*v.z  + v.w*v.w; }
+
+        template<typename T, typename B>
+        __global__ void nlm_kernel(const PtrStep<T> src, PtrStepSz<T> dst, const B b, int search_radius, int block_radius, float noise_mult)
+        {
+            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+
+            const int i = blockDim.y * blockIdx.y + threadIdx.y;
+            const int j = blockDim.x * blockIdx.x + threadIdx.x;
+
+            if (j >= dst.cols || i >= dst.rows)
+                return;
+
+            int bsize = search_radius + block_radius;
+            int search_window = 2 * search_radius + 1;
+            float minus_search_window2_inv = -1.f/(search_window * search_window);
+
+            value_type sum1 = VecTraits<value_type>::all(0);
+            float sum2 = 0.f;
+
+            if (j - bsize >= 0 && j + bsize < dst.cols && i - bsize >= 0 && i + bsize < dst.rows)
+            {
+                for(float y = -search_radius; y <= search_radius; ++y)
+                    for(float x = -search_radius; x <= search_radius; ++x)
+                    {
+                        float dist2 = 0;
+                        for(float ty = -block_radius; ty <= block_radius; ++ty)
+                            for(float tx = -block_radius; tx <= block_radius; ++tx)
+                            {
+                                value_type bv = saturate_cast<value_type>(src(i + y + ty, j + x + tx));
+                                value_type av = saturate_cast<value_type>(src(i +     ty, j +     tx));
+
+                                dist2 += norm2(av - bv);
+                            }
+
+                        float w = __expf(dist2 * noise_mult + (x * x + y * y) * minus_search_window2_inv);
+
+                        /*if (i == 255 && j == 255)
+                            printf("%f %f\n", w, dist2 * minus_h2_inv + (x * x + y * y) * minus_search_window2_inv);*/
+
+                        sum1 = sum1 + w * saturate_cast<value_type>(src(i + y, j + x));
+                        sum2 += w;
+                    }
+            }
+            else
+            {
+                for(float y = -search_radius; y <= search_radius; ++y)
+                    for(float x = -search_radius; x <= search_radius; ++x)
+                    {
+                        float dist2 = 0;
+                        for(float ty = -block_radius; ty <= block_radius; ++ty)
+                            for(float tx = -block_radius; tx <= block_radius; ++tx)
+                            {
+                                value_type bv = saturate_cast<value_type>(b.at(i + y + ty, j + x + tx, src));
+                                value_type av = saturate_cast<value_type>(b.at(i +     ty, j +     tx, src));
+                                dist2 += norm2(av - bv);
+                            }
+
+                        float w = __expf(dist2 * noise_mult + (x * x + y * y) * minus_search_window2_inv);
+
+                        sum1 = sum1 + w * saturate_cast<value_type>(b.at(i + y, j + x, src));
+                        sum2 += w;
+                    }
+
+            }
+
+            dst(i, j) = saturate_cast<T>(sum1 / sum2);
+
+        }
+
+        template<typename T, template <typename> class B>
+        void nlm_caller(const PtrStepSzb src, PtrStepSzb dst, int search_radius, int block_radius, float h, cudaStream_t stream)
+        {
+            dim3 block (32, 8);
+            dim3 grid (divUp (src.cols, block.x), divUp (src.rows, block.y));
+
+            B<T> b(src.rows, src.cols);
+
+            int block_window = 2 * block_radius + 1;
+            float minus_h2_inv = -1.f/(h * h * VecTraits<T>::cn);
+            float noise_mult = minus_h2_inv/(block_window * block_window);
+
+            cudaSafeCall( cudaFuncSetCacheConfig (nlm_kernel<T, B<T> >, cudaFuncCachePreferL1) );
+            nlm_kernel<<<grid, block>>>((PtrStepSz<T>)src, (PtrStepSz<T>)dst, b, search_radius, block_radius, noise_mult);
+            cudaSafeCall ( cudaGetLastError () );
+
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        template<typename T>
+        void nlm_bruteforce_gpu(const PtrStepSzb& src, PtrStepSzb dst, int search_radius, int block_radius, float h, int borderMode, cudaStream_t stream)
+        {
+            typedef void (*func_t)(const PtrStepSzb src, PtrStepSzb dst, int search_radius, int block_radius, float h, cudaStream_t stream);
+
+            static func_t funcs[] =
+            {
+                nlm_caller<T, BrdConstant>,
+                nlm_caller<T, BrdReplicate>,
+                nlm_caller<T, BrdReflect>,
+                nlm_caller<T, BrdWrap>,
+                nlm_caller<T, BrdReflect101>
+            };
+            funcs[borderMode](src, dst, search_radius, block_radius, h, stream);
+        }
+
+        template void nlm_bruteforce_gpu<uchar>(const PtrStepSzb&, PtrStepSzb, int, int, float, int, cudaStream_t);
+        template void nlm_bruteforce_gpu<uchar2>(const PtrStepSzb&, PtrStepSzb, int, int, float, int, cudaStream_t);
+        template void nlm_bruteforce_gpu<uchar3>(const PtrStepSzb&, PtrStepSzb, int, int, float, int, cudaStream_t);
+    }
+}}}
+
+//////////////////////////////////////////////////////////////////////////////////
+//// Non Local Means Denosing (fast approximate version)
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+
+        template <int cn> struct Unroll;
+        template <> struct Unroll<1>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::cuda::device::smem_tuple(smem, smem + BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&> tie(float& val1, float& val2)
+            {
+                return thrust::tie(val1, val2);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return { op, op };
+            }
+        };
+        template <> struct Unroll<2>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::cuda::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&> tie(float& val1, float2& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return { op, op, op };
+            }
+        };
+        template <> struct Unroll<3>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::cuda::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&> tie(float& val1, float3& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y, val2.z);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return { op, op, op, op };
+            }
+        };
+        template <> struct Unroll<4>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::cuda::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE, smem + 4 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&, float&> tie(float& val1, float4& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y, val2.z, val2.w);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return thrust::make_tuple(op, op, op, op, op);
+            }
+        };
+
+        __device__ __forceinline__ int calcDist(const uchar&  a, const uchar&  b) { return (a-b)*(a-b); }
+        __device__ __forceinline__ int calcDist(const uchar2& a, const uchar2& b) { return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y); }
+        __device__ __forceinline__ int calcDist(const uchar3& a, const uchar3& b) { return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) + (a.z-b.z)*(a.z-b.z); }
+
+        template <class T> struct FastNonLocalMeans
+        {
+            enum
+            {
+                CTA_SIZE = 128,
+
+                TILE_COLS = 128,
+                TILE_ROWS = 32,
+
+                STRIDE = CTA_SIZE
+            };
+
+            struct plus
+            {
+                __device__ __forceinline__ float operator()(float v1, float v2) const { return v1 + v2; }
+            };
+
+            int search_radius;
+            int block_radius;
+
+            int search_window;
+            int block_window;
+            float minus_h2_inv;
+
+            FastNonLocalMeans(int search_window_, int block_window_, float h) : search_radius(search_window_/2), block_radius(block_window_/2),
+                search_window(search_window_), block_window(block_window_), minus_h2_inv(-1.f/(h * h * VecTraits<T>::cn)) {}
+
+            PtrStep<T> src;
+            mutable PtrStepi buffer;
+
+            __device__ __forceinline__ void initSums_BruteForce(int i, int j, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+            {
+                for(int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+                {
+                    dist_sums[index] = 0;
+
+                    for(int tx = 0; tx < block_window; ++tx)
+                        col_sums(tx, index) = 0;
+
+                    int y = index / search_window;
+                    int x = index - y * search_window;
+
+                    int ay = i;
+                    int ax = j;
+
+                    int by = i + y - search_radius;
+                    int bx = j + x - search_radius;
+
+#if 1
+                    for (int tx = -block_radius; tx <= block_radius; ++tx)
+                    {
+                        int col_sum = 0;
+                        for (int ty = -block_radius; ty <= block_radius; ++ty)
+                        {
+                            int dist = calcDist(src(ay + ty, ax + tx), src(by + ty, bx + tx));
+
+                            dist_sums[index] += dist;
+                            col_sum += dist;
+                        }
+                        col_sums(tx + block_radius, index) = col_sum;
+                    }
+#else
+                    for (int ty = -block_radius; ty <= block_radius; ++ty)
+                        for (int tx = -block_radius; tx <= block_radius; ++tx)
+                        {
+                            int dist = calcDist(src(ay + ty, ax + tx), src(by + ty, bx + tx));
+
+                            dist_sums[index] += dist;
+                            col_sums(tx + block_radius, index) += dist;
+                        }
+#endif
+
+                    up_col_sums(j, index) = col_sums(block_window - 1, index);
+                }
+            }
+
+            __device__ __forceinline__ void shiftRight_FirstRow(int i, int j, int first, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+            {
+                for(int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+                {
+                    int y = index / search_window;
+                    int x = index - y * search_window;
+
+                    int ay = i;
+                    int ax = j + block_radius;
+
+                    int by = i + y - search_radius;
+                    int bx = j + x - search_radius + block_radius;
+
+                    int col_sum = 0;
+
+                    for (int ty = -block_radius; ty <= block_radius; ++ty)
+                        col_sum += calcDist(src(ay + ty, ax), src(by + ty, bx));
+
+                    dist_sums[index] += col_sum - col_sums(first, index);
+
+                    col_sums(first, index) = col_sum;
+                    up_col_sums(j, index) = col_sum;
+                }
+            }
+
+            __device__ __forceinline__ void shiftRight_UpSums(int i, int j, int first, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+            {
+                int ay = i;
+                int ax = j + block_radius;
+
+                T a_up   = src(ay - block_radius - 1, ax);
+                T a_down = src(ay + block_radius, ax);
+
+                for(int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+                {
+                    int y = index / search_window;
+                    int x = index - y * search_window;
+
+                    int by = i + y - search_radius;
+                    int bx = j + x - search_radius + block_radius;
+
+                    T b_up   = src(by - block_radius - 1, bx);
+                    T b_down = src(by + block_radius, bx);
+
+                    int col_sum = up_col_sums(j, index) + calcDist(a_down, b_down) - calcDist(a_up, b_up);
+
+                    dist_sums[index] += col_sum  - col_sums(first, index);
+                    col_sums(first, index) = col_sum;
+                    up_col_sums(j, index) = col_sum;
+                }
+            }
+
+            __device__ __forceinline__ void convolve_window(int i, int j, const int* dist_sums, T& dst) const
+            {
+                typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_type;
+
+                float weights_sum = 0;
+                sum_type sum = VecTraits<sum_type>::all(0);
+
+                float bw2_inv = 1.f/(block_window * block_window);
+
+                int sx = j - search_radius;
+                int sy = i - search_radius;
+
+                for(int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+                {
+                    int y = index / search_window;
+                    int x = index - y * search_window;
+
+                    float avg_dist = dist_sums[index] * bw2_inv;
+                    float weight = __expf(avg_dist * minus_h2_inv);
+                    weights_sum += weight;
+
+                    sum = sum + weight * saturate_cast<sum_type>(src(sy + y, sx + x));
+                }
+
+                __shared__ float cta_buffer[CTA_SIZE * (VecTraits<T>::cn + 1)];
+
+                reduce<CTA_SIZE>(Unroll<VecTraits<T>::cn>::template smem_tuple<CTA_SIZE>(cta_buffer),
+                                 Unroll<VecTraits<T>::cn>::tie(weights_sum, sum),
+                                 threadIdx.x,
+                                 Unroll<VecTraits<T>::cn>::op());
+
+                if (threadIdx.x == 0)
+                    dst = saturate_cast<T>(sum / weights_sum);
+            }
+
+            __device__ __forceinline__ void operator()(PtrStepSz<T>& dst) const
+            {
+                int tbx = blockIdx.x * TILE_COLS;
+                int tby = blockIdx.y * TILE_ROWS;
+
+                int tex = ::min(tbx + TILE_COLS, dst.cols);
+                int tey = ::min(tby + TILE_ROWS, dst.rows);
+
+                PtrStepi col_sums;
+                col_sums.data = buffer.ptr(dst.cols + blockIdx.x * block_window) + blockIdx.y * search_window * search_window;
+                col_sums.step = buffer.step;
+
+                PtrStepi up_col_sums;
+                up_col_sums.data = buffer.data + blockIdx.y * search_window * search_window;
+                up_col_sums.step = buffer.step;
+
+                extern __shared__ int dist_sums[]; //search_window * search_window
+
+                int first = 0;
+
+                for (int i = tby; i < tey; ++i)
+                    for (int j = tbx; j < tex; ++j)
+                    {
+                        __syncthreads();
+
+                        if (j == tbx)
+                        {
+                            initSums_BruteForce(i, j, dist_sums, col_sums, up_col_sums);
+                            first = 0;
+                        }
+                        else
+                        {
+                            if (i == tby)
+                              shiftRight_FirstRow(i, j, first, dist_sums, col_sums, up_col_sums);
+                            else
+                              shiftRight_UpSums(i, j, first, dist_sums, col_sums, up_col_sums);
+
+                            first = (first + 1) % block_window;
+                        }
+
+                        __syncthreads();
+
+                        convolve_window(i, j, dist_sums, dst(i, j));
+                    }
+            }
+
+        };
+
+        template<typename T>
+        __global__ void fast_nlm_kernel(const FastNonLocalMeans<T> fnlm, PtrStepSz<T> dst) { fnlm(dst); }
+
+        void nln_fast_get_buffer_size(const PtrStepSzb& src, int search_window, int block_window, int& buffer_cols, int& buffer_rows)
+        {
+            typedef FastNonLocalMeans<uchar> FNLM;
+            dim3 grid(divUp(src.cols, FNLM::TILE_COLS), divUp(src.rows, FNLM::TILE_ROWS));
+
+            buffer_cols = search_window * search_window * grid.y;
+            buffer_rows = src.cols + block_window * grid.x;
+        }
+
+        template<typename T>
+        void nlm_fast_gpu(const PtrStepSzb& src, PtrStepSzb dst, PtrStepi buffer,
+                          int search_window, int block_window, float h, cudaStream_t stream)
+        {
+            typedef FastNonLocalMeans<T> FNLM;
+            FNLM fnlm(search_window, block_window, h);
+
+            fnlm.src = (PtrStepSz<T>)src;
+            fnlm.buffer = buffer;
+
+            dim3 block(FNLM::CTA_SIZE, 1);
+            dim3 grid(divUp(src.cols, FNLM::TILE_COLS), divUp(src.rows, FNLM::TILE_ROWS));
+            int smem = search_window * search_window * sizeof(int);
+
+
+            fast_nlm_kernel<<<grid, block, smem>>>(fnlm, (PtrStepSz<T>)dst);
+            cudaSafeCall ( cudaGetLastError () );
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        template void nlm_fast_gpu<uchar>(const PtrStepSzb&, PtrStepSzb, PtrStepi, int, int, float,  cudaStream_t);
+        template void nlm_fast_gpu<uchar2>(const PtrStepSzb&, PtrStepSzb, PtrStepi, int, int, float, cudaStream_t);
+        template void nlm_fast_gpu<uchar3>(const PtrStepSzb&, PtrStepSzb, PtrStepi, int, int, float, cudaStream_t);
+
+
+
+        __global__ void fnlm_split_kernel(const PtrStepSz<uchar3> lab, PtrStepb l, PtrStep<uchar2> ab)
+        {
+            int x = threadIdx.x + blockIdx.x * blockDim.x;
+            int y = threadIdx.y + blockIdx.y * blockDim.y;
+
+            if (x < lab.cols && y < lab.rows)
+            {
+                uchar3 p = lab(y, x);
+                ab(y,x) = make_uchar2(p.y, p.z);
+                l(y,x) = p.x;
+            }
+        }
+
+        void fnlm_split_channels(const PtrStepSz<uchar3>& lab, PtrStepb l, PtrStep<uchar2> ab, cudaStream_t stream)
+        {
+            dim3 b(32, 8);
+            dim3 g(divUp(lab.cols, b.x), divUp(lab.rows, b.y));
+
+            fnlm_split_kernel<<<g, b>>>(lab, l, ab);
+            cudaSafeCall ( cudaGetLastError () );
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );
+        }
+
+        __global__ void fnlm_merge_kernel(const PtrStepb l, const PtrStep<uchar2> ab, PtrStepSz<uchar3> lab)
+        {
+            int x = threadIdx.x + blockIdx.x * blockDim.x;
+            int y = threadIdx.y + blockIdx.y * blockDim.y;
+
+            if (x < lab.cols && y < lab.rows)
+            {
+                uchar2 p = ab(y, x);
+                lab(y, x) = make_uchar3(l(y, x), p.x, p.y);
+            }
+        }
+
+        void fnlm_merge_channels(const PtrStepb& l, const PtrStep<uchar2>& ab, PtrStepSz<uchar3> lab, cudaStream_t stream)
+        {
+            dim3 b(32, 8);
+            dim3 g(divUp(lab.cols, b.x), divUp(lab.rows, b.y));
+
+            fnlm_merge_kernel<<<g, b>>>(l, ab, lab);
+            cudaSafeCall ( cudaGetLastError () );
+            if (stream == 0)
+                cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    }
+}}}
diff --git a/upstream/opencv/modules/photo/src/denoise_tvl1.cpp b/upstream/opencv/modules/photo/src/denoise_tvl1.cpp
new file mode 100644
index 0000000..5f49de1
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/denoise_tvl1.cpp
@@ -0,0 +1,151 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the OpenCV Foundation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+#include <vector>
+#include <algorithm>
+
+namespace cv{
+
+    class AddFloatToCharScaled{
+        public:
+            AddFloatToCharScaled(double scale):_scale(scale){}
+            inline double operator()(double a,uchar b){
+                return a+_scale*((double)b);
+            }
+        private:
+            double _scale;
+    };
+
+    using std::transform;
+
+    void denoise_TVL1(const std::vector<Mat>& observations,Mat& result, double lambda, int niters){
+
+        CV_Assert(observations.size()>0 && niters>0 && lambda>0);
+
+        const double L2 = 8.0, tau = 0.02, sigma = 1./(L2*tau), theta = 1.0;
+        double clambda = (double)lambda;
+        double s=0;
+        const int workdepth = CV_64F;
+
+        int i, x, y, rows=observations[0].rows, cols=observations[0].cols,count;
+        for(i=1;i<(int)observations.size();i++){
+            CV_Assert(observations[i].rows==rows && observations[i].cols==cols);
+        }
+
+        Mat X, P = Mat::zeros(rows, cols, CV_MAKETYPE(workdepth, 2));
+        observations[0].convertTo(X, workdepth, 1./255);
+        std::vector< Mat_<double> > Rs(observations.size());
+        for(count=0;count<(int)Rs.size();count++){
+            Rs[count]=Mat::zeros(rows,cols,workdepth);
+        }
+
+        for( i = 0; i < niters; i++ )
+        {
+            double currsigma = i == 0 ? 1 + sigma : sigma;
+
+            // P_ = P + sigma*nabla(X)
+            // P(x,y) = P_(x,y)/max(||P(x,y)||,1)
+            for( y = 0; y < rows; y++ )
+            {
+                const double* x_curr = X.ptr<double>(y);
+                const double* x_next = X.ptr<double>(std::min(y+1, rows-1));
+                Point2d* p_curr = P.ptr<Point2d>(y);
+                double dx, dy, m;
+                for( x = 0; x < cols-1; x++ )
+                {
+                    dx = (x_curr[x+1] - x_curr[x])*currsigma + p_curr[x].x;
+                    dy = (x_next[x] - x_curr[x])*currsigma + p_curr[x].y;
+                    m = 1.0/std::max(std::sqrt(dx*dx + dy*dy), 1.0);
+                    p_curr[x].x = dx*m;
+                    p_curr[x].y = dy*m;
+                }
+                dy = (x_next[x] - x_curr[x])*currsigma + p_curr[x].y;
+                m = 1.0/std::max(std::abs(dy), 1.0);
+                p_curr[x].x = 0.0;
+                p_curr[x].y = dy*m;
+            }
+
+
+            //Rs = clip(Rs + sigma*(X-imgs), -clambda, clambda)
+            for(count=0;count<(int)Rs.size();count++){
+                transform<MatIterator_<double>,MatConstIterator_<uchar>,MatIterator_<double>,AddFloatToCharScaled>(
+                        Rs[count].begin(),Rs[count].end(),observations[count].begin<uchar>(),
+                        Rs[count].begin(),AddFloatToCharScaled(-sigma/255.0));
+                Rs[count]+=sigma*X;
+                min(Rs[count],clambda,Rs[count]);
+                max(Rs[count],-clambda,Rs[count]);
+            }
+
+            for( y = 0; y < rows; y++ )
+            {
+                double* x_curr = X.ptr<double>(y);
+                const Point2d* p_curr = P.ptr<Point2d>(y);
+                const Point2d* p_prev = P.ptr<Point2d>(std::max(y - 1, 0));
+
+                // X1 = X + tau*(-nablaT(P))
+                x = 0;
+                s=0.0;
+                for(count=0;count<(int)Rs.size();count++){
+                    s=s+Rs[count](y,x);
+                }
+                double x_new = x_curr[x] + tau*(p_curr[x].y - p_prev[x].y)-tau*s;
+                    // X = X2 + theta*(X2 - X)
+                x_curr[x] = x_new + theta*(x_new - x_curr[x]);
+
+
+                for(x = 1; x < cols; x++ )
+                {
+                    s=0.0;
+                    for(count=0;count<(int)Rs.size();count++){
+                        s+=Rs[count](y,x);
+                    }
+                        // X1 = X + tau*(-nablaT(P))
+                    x_new = x_curr[x] + tau*(p_curr[x].x - p_curr[x-1].x + p_curr[x].y - p_prev[x].y)-tau*s;
+                        // X = X2 + theta*(X2 - X)
+                    x_curr[x] = x_new + theta*(x_new - x_curr[x]);
+                }
+            }
+        }
+
+        result.create(X.rows,X.cols,CV_8U);
+        X.convertTo(result, CV_8U, 255);
+    }
+}
diff --git a/upstream/opencv/modules/photo/src/denoising.cpp b/upstream/opencv/modules/photo/src/denoising.cpp
new file mode 100644
index 0000000..df7794c
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/denoising.cpp
@@ -0,0 +1,440 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#include "fast_nlmeans_denoising_invoker.hpp"
+#include "fast_nlmeans_multi_denoising_invoker.hpp"
+#include "fast_nlmeans_denoising_opencl.hpp"
+
+template<typename ST, typename IT, typename UIT, typename D>
+static void fastNlMeansDenoising_( const Mat& src, Mat& dst, const std::vector<float>& h,
+                                   int templateWindowSize, int searchWindowSize)
+{
+    int hn = (int)h.size();
+    double granularity = (double)std::max(1., (double)dst.total()/(1 << 17));
+
+    switch (CV_MAT_CN(src.type())) {
+        case 1:
+            parallel_for_(cv::Range(0, src.rows),
+                          FastNlMeansDenoisingInvoker<ST, IT, UIT, D, int>(
+                              src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                          granularity);
+            break;
+        case 2:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 2>, IT, UIT, D, int>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 2>, IT, UIT, D, Vec2i>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+        case 3:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 3>, IT, UIT, D, int>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 3>, IT, UIT, D, Vec3i>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+        case 4:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 4>, IT, UIT, D, int>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, src.rows),
+                              FastNlMeansDenoisingInvoker<Vec<ST, 4>, IT, UIT, D, Vec4i>(
+                                  src, dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+        default:
+            CV_Error(Error::StsBadArg,
+                     "Unsupported number of channels! Only 1, 2, 3, and 4 are supported");
+    }
+}
+
+void cv::fastNlMeansDenoising( InputArray _src, OutputArray _dst, float h,
+                               int templateWindowSize, int searchWindowSize)
+{
+    CV_INSTRUMENT_REGION();
+
+    fastNlMeansDenoising(_src, _dst, std::vector<float>(1, h),
+                         templateWindowSize, searchWindowSize);
+}
+
+void cv::fastNlMeansDenoising( InputArray _src, OutputArray _dst, const std::vector<float>& h,
+                               int templateWindowSize, int searchWindowSize, int normType)
+{
+    CV_INSTRUMENT_REGION();
+
+    int hn = (int)h.size(), type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(!_src.empty());
+    CV_Assert(hn == 1 || hn == cn);
+
+    Size src_size = _src.size();
+    CV_OCL_RUN(_src.dims() <= 2 && (_src.isUMat() || _dst.isUMat()) &&
+               src_size.width > 5 && src_size.height > 5, // low accuracy on small sizes
+               ocl_fastNlMeansDenoising(_src, _dst, &h[0], hn,
+                                        templateWindowSize, searchWindowSize, normType))
+
+    Mat src = _src.getMat();
+    _dst.create(src_size, src.type());
+    Mat dst = _dst.getMat();
+
+    switch (normType) {
+        case NORM_L2:
+            switch (depth) {
+                case CV_8U:
+                    fastNlMeansDenoising_<uchar, int, unsigned, DistSquared>(src, dst, h,
+                                                                             templateWindowSize,
+                                                                             searchWindowSize);
+                    break;
+                default:
+                    CV_Error(Error::StsBadArg,
+                             "Unsupported depth! Only CV_8U is supported for NORM_L2");
+            }
+            break;
+        case NORM_L1:
+            switch (depth) {
+                case CV_8U:
+                    fastNlMeansDenoising_<uchar, int, unsigned, DistAbs>(src, dst, h,
+                                                                         templateWindowSize,
+                                                                         searchWindowSize);
+                    break;
+                case CV_16U:
+                    fastNlMeansDenoising_<ushort, int64, uint64, DistAbs>(src, dst, h,
+                                                                          templateWindowSize,
+                                                                          searchWindowSize);
+                    break;
+                default:
+                    CV_Error(Error::StsBadArg,
+                             "Unsupported depth! Only CV_8U and CV_16U are supported for NORM_L1");
+            }
+            break;
+        default:
+            CV_Error(Error::StsBadArg,
+                     "Unsupported norm type! Only NORM_L2 and NORM_L1 are supported");
+    }
+}
+
+void cv::fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst,
+                                      float h, float hForColorComponents,
+                                      int templateWindowSize, int searchWindowSize)
+{
+    CV_INSTRUMENT_REGION();
+
+    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    Size src_size = _src.size();
+    if (type != CV_8UC3 && type != CV_8UC4)
+    {
+        CV_Error(Error::StsBadArg, "Type of input image should be CV_8UC3 or CV_8UC4!");
+        return;
+    }
+
+    CV_OCL_RUN(_src.dims() <= 2 && (_dst.isUMat() || _src.isUMat()) &&
+                src_size.width > 5 && src_size.height > 5, // low accuracy on small sizes
+                ocl_fastNlMeansDenoisingColored(_src, _dst, h, hForColorComponents,
+                                                templateWindowSize, searchWindowSize))
+
+    Mat src = _src.getMat();
+    _dst.create(src_size, type);
+    Mat dst = _dst.getMat();
+
+    Mat src_lab;
+    cvtColor(src, src_lab, COLOR_LBGR2Lab);
+
+    Mat l(src_size, CV_MAKE_TYPE(depth, 1));
+    Mat ab(src_size, CV_MAKE_TYPE(depth, 2));
+    Mat l_ab[] = { l, ab };
+    int from_to[] = { 0,0, 1,1, 2,2 };
+    mixChannels(&src_lab, 1, l_ab, 2, from_to, 3);
+
+    fastNlMeansDenoising(l, l, h, templateWindowSize, searchWindowSize);
+    fastNlMeansDenoising(ab, ab, hForColorComponents, templateWindowSize, searchWindowSize);
+
+    Mat l_ab_denoised[] = { l, ab };
+    Mat dst_lab(src_size, CV_MAKE_TYPE(depth, 3));
+    mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3);
+
+    cvtColor(dst_lab, dst, COLOR_Lab2LBGR, cn);
+}
+
+static void fastNlMeansDenoisingMultiCheckPreconditions(
+                               const std::vector<Mat>& srcImgs,
+                               int imgToDenoiseIndex, int temporalWindowSize,
+                               int templateWindowSize, int searchWindowSize)
+{
+    int src_imgs_size = static_cast<int>(srcImgs.size());
+    if (src_imgs_size == 0)
+    {
+        CV_Error(Error::StsBadArg, "Input images vector should not be empty!");
+    }
+
+    if (temporalWindowSize % 2 == 0 ||
+        searchWindowSize % 2 == 0 ||
+        templateWindowSize % 2 == 0) {
+        CV_Error(Error::StsBadArg, "All windows sizes should be odd!");
+    }
+
+    int temporalWindowHalfSize = temporalWindowSize / 2;
+    if (imgToDenoiseIndex - temporalWindowHalfSize < 0 ||
+        imgToDenoiseIndex + temporalWindowHalfSize >= src_imgs_size)
+    {
+        CV_Error(Error::StsBadArg,
+            "imgToDenoiseIndex and temporalWindowSize "
+            "should be chosen corresponding srcImgs size!");
+    }
+
+    for (int i = 1; i < src_imgs_size; i++)
+        if (srcImgs[0].size() != srcImgs[i].size() || srcImgs[0].type() != srcImgs[i].type())
+        {
+            CV_Error(Error::StsBadArg, "Input images should have the same size and type!");
+        }
+}
+
+template<typename ST, typename IT, typename UIT, typename D>
+static void fastNlMeansDenoisingMulti_( const std::vector<Mat>& srcImgs, Mat& dst,
+                                        int imgToDenoiseIndex, int temporalWindowSize,
+                                        const std::vector<float>& h,
+                                        int templateWindowSize, int searchWindowSize)
+{
+    int hn = (int)h.size();
+    double granularity = (double)std::max(1., (double)dst.total()/(1 << 16));
+
+    switch (CV_MAT_CN(srcImgs[0].type())) {
+        case 1:
+            parallel_for_(cv::Range(0, srcImgs[0].rows),
+                          FastNlMeansMultiDenoisingInvoker<ST, IT, UIT, D, int>(
+                              srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                              dst, templateWindowSize, searchWindowSize, &h[0]),
+                          granularity);
+            break;
+        case 2:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 2>, IT, UIT, D, int>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 2>, IT, UIT, D, Vec2i>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+        case 3:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 3>, IT, UIT, D, int>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 3>, IT, UIT, D, Vec3i>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+        case 4:
+            if (hn == 1)
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 4>, IT, UIT, D, int>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            else
+                parallel_for_(cv::Range(0, srcImgs[0].rows),
+                              FastNlMeansMultiDenoisingInvoker<Vec<ST, 4>, IT, UIT, D, Vec4i>(
+                                  srcImgs, imgToDenoiseIndex, temporalWindowSize,
+                                  dst, templateWindowSize, searchWindowSize, &h[0]),
+                              granularity);
+            break;
+       default:
+            CV_Error(Error::StsBadArg,
+                     "Unsupported number of channels! Only 1, 2, 3, and 4 are supported");
+    }
+}
+
+void cv::fastNlMeansDenoisingMulti( InputArrayOfArrays _srcImgs, OutputArray _dst,
+                                    int imgToDenoiseIndex, int temporalWindowSize,
+                                    float h, int templateWindowSize, int searchWindowSize)
+{
+    CV_INSTRUMENT_REGION();
+
+    fastNlMeansDenoisingMulti(_srcImgs, _dst, imgToDenoiseIndex, temporalWindowSize,
+                              std::vector<float>(1, h), templateWindowSize, searchWindowSize);
+}
+
+void cv::fastNlMeansDenoisingMulti( InputArrayOfArrays _srcImgs, OutputArray _dst,
+                                    int imgToDenoiseIndex, int temporalWindowSize,
+                                    const std::vector<float>& h,
+                                    int templateWindowSize, int searchWindowSize, int normType)
+{
+    CV_INSTRUMENT_REGION();
+
+    std::vector<Mat> srcImgs;
+    _srcImgs.getMatVector(srcImgs);
+
+    fastNlMeansDenoisingMultiCheckPreconditions(
+        srcImgs, imgToDenoiseIndex,
+        temporalWindowSize, templateWindowSize, searchWindowSize);
+
+    int hn = (int)h.size();
+    int type = srcImgs[0].type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    CV_Assert(hn == 1 || hn == cn);
+
+    _dst.create(srcImgs[0].size(), srcImgs[0].type());
+    Mat dst = _dst.getMat();
+
+    switch (normType) {
+        case NORM_L2:
+            switch (depth) {
+                case CV_8U:
+                    fastNlMeansDenoisingMulti_<uchar, int, unsigned,
+                                               DistSquared>(srcImgs, dst,
+                                                            imgToDenoiseIndex, temporalWindowSize,
+                                                            h,
+                                                            templateWindowSize, searchWindowSize);
+                    break;
+                default:
+                    CV_Error(Error::StsBadArg,
+                             "Unsupported depth! Only CV_8U is supported for NORM_L2");
+            }
+            break;
+        case NORM_L1:
+            switch (depth) {
+                case CV_8U:
+                    fastNlMeansDenoisingMulti_<uchar, int, unsigned,
+                                               DistAbs>(srcImgs, dst,
+                                                        imgToDenoiseIndex, temporalWindowSize,
+                                                        h,
+                                                        templateWindowSize, searchWindowSize);
+                    break;
+                case CV_16U:
+                    fastNlMeansDenoisingMulti_<ushort, int64, uint64,
+                                               DistAbs>(srcImgs, dst,
+                                                        imgToDenoiseIndex, temporalWindowSize,
+                                                        h,
+                                                        templateWindowSize, searchWindowSize);
+                    break;
+                default:
+                    CV_Error(Error::StsBadArg,
+                             "Unsupported depth! Only CV_8U and CV_16U are supported for NORM_L1");
+            }
+            break;
+        default:
+            CV_Error(Error::StsBadArg,
+                     "Unsupported norm type! Only NORM_L2 and NORM_L1 are supported");
+    }
+}
+
+void cv::fastNlMeansDenoisingColoredMulti( InputArrayOfArrays _srcImgs, OutputArray _dst,
+                                           int imgToDenoiseIndex, int temporalWindowSize,
+                                           float h, float hForColorComponents,
+                                           int templateWindowSize, int searchWindowSize)
+{
+    CV_INSTRUMENT_REGION();
+
+    std::vector<Mat> srcImgs;
+    _srcImgs.getMatVector(srcImgs);
+
+    fastNlMeansDenoisingMultiCheckPreconditions(
+        srcImgs, imgToDenoiseIndex,
+        temporalWindowSize, templateWindowSize, searchWindowSize);
+
+    _dst.create(srcImgs[0].size(), srcImgs[0].type());
+    Mat dst = _dst.getMat();
+
+    int type = srcImgs[0].type(), depth = CV_MAT_DEPTH(type);
+    int src_imgs_size = static_cast<int>(srcImgs.size());
+
+    if (type != CV_8UC3)
+    {
+        CV_Error(Error::StsBadArg, "Type of input images should be CV_8UC3!");
+        return;
+    }
+
+    int from_to[] = { 0,0, 1,1, 2,2 };
+
+    // TODO convert only required images
+    std::vector<Mat> src_lab(src_imgs_size);
+    std::vector<Mat> l(src_imgs_size);
+    std::vector<Mat> ab(src_imgs_size);
+    for (int i = 0; i < src_imgs_size; i++)
+    {
+        src_lab[i] = Mat::zeros(srcImgs[0].size(), type);
+        l[i] = Mat::zeros(srcImgs[0].size(), CV_MAKE_TYPE(depth, 1));
+        ab[i] = Mat::zeros(srcImgs[0].size(), CV_MAKE_TYPE(depth, 2));
+        cvtColor(srcImgs[i], src_lab[i], COLOR_LBGR2Lab);
+
+        Mat l_ab[] = { l[i], ab[i] };
+        mixChannels(&src_lab[i], 1, l_ab, 2, from_to, 3);
+    }
+
+    Mat dst_l;
+    Mat dst_ab;
+
+    fastNlMeansDenoisingMulti(
+        l, dst_l, imgToDenoiseIndex, temporalWindowSize,
+        h, templateWindowSize, searchWindowSize);
+
+    fastNlMeansDenoisingMulti(
+        ab, dst_ab, imgToDenoiseIndex, temporalWindowSize,
+        hForColorComponents, templateWindowSize, searchWindowSize);
+
+    Mat l_ab_denoised[] = { dst_l, dst_ab };
+    Mat dst_lab(srcImgs[0].size(), srcImgs[0].type());
+    mixChannels(l_ab_denoised, 2, &dst_lab, 1, from_to, 3);
+
+    cvtColor(dst_lab, dst, COLOR_Lab2LBGR);
+}
diff --git a/upstream/opencv/modules/photo/src/denoising.cuda.cpp b/upstream/opencv/modules/photo/src/denoising.cuda.cpp
new file mode 100644
index 0000000..12735df
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/denoising.cuda.cpp
@@ -0,0 +1,175 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#include "opencv2/photo/cuda.hpp"
+
+#include "opencv2/opencv_modules.hpp"
+
+#if !defined (HAVE_CUDA) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_CUDAIMGPROC)
+#include "opencv2/core/private/cuda_stubs.hpp"
+#else
+#include "opencv2/core/private.cuda.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_CUDAIMGPROC
+#  include "opencv2/cudaimgproc.hpp"
+#endif
+
+using namespace cv;
+using namespace cv::cuda;
+
+#if !defined (HAVE_CUDA) || !defined(HAVE_OPENCV_CUDAARITHM) || !defined(HAVE_OPENCV_CUDAIMGPROC)
+
+void cv::cuda::nonLocalMeans(InputArray, OutputArray, float, int, int, int, Stream&) { throw_no_cuda(); }
+void cv::cuda::fastNlMeansDenoising(InputArray, OutputArray, float, int, int, Stream&) { throw_no_cuda(); }
+void cv::cuda::fastNlMeansDenoisingColored(InputArray, OutputArray, float, float, int, int, Stream&) { throw_no_cuda(); }
+
+#else
+
+//////////////////////////////////////////////////////////////////////////////////
+//// Non Local Means Denosing (brute force)
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+        template<typename T>
+        void nlm_bruteforce_gpu(const PtrStepSzb& src, PtrStepSzb dst, int search_radius, int block_radius, float h, int borderMode, cudaStream_t stream);
+    }
+}}}
+
+void cv::cuda::nonLocalMeans(InputArray _src, OutputArray _dst, float h, int search_window, int block_window, int borderMode, Stream& stream)
+{
+    using cv::cuda::device::imgproc::nlm_bruteforce_gpu;
+    typedef void (*func_t)(const PtrStepSzb& src, PtrStepSzb dst, int search_radius, int block_radius, float h, int borderMode, cudaStream_t stream);
+
+    static const func_t funcs[4] = { nlm_bruteforce_gpu<uchar>, nlm_bruteforce_gpu<uchar2>, nlm_bruteforce_gpu<uchar3>, 0/*nlm_bruteforce_gpu<uchar4>,*/ };
+
+    const GpuMat src = _src.getGpuMat();
+
+    CV_Assert(src.type() == CV_8U || src.type() == CV_8UC2 || src.type() == CV_8UC3);
+
+    const func_t func = funcs[src.channels() - 1];
+    CV_Assert(func != 0);
+
+    int b = borderMode;
+    CV_Assert(b == BORDER_REFLECT101 || b == BORDER_REPLICATE || b == BORDER_CONSTANT || b == BORDER_REFLECT || b == BORDER_WRAP);
+
+    _dst.create(src.size(), src.type());
+    GpuMat dst = _dst.getGpuMat();
+
+    func(src, dst, search_window/2, block_window/2, h, borderMode, StreamAccessor::getStream(stream));
+}
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+        void nln_fast_get_buffer_size(const PtrStepSzb& src, int search_window, int block_window, int& buffer_cols, int& buffer_rows);
+
+        template<typename T>
+        void nlm_fast_gpu(const PtrStepSzb& src, PtrStepSzb dst, PtrStepi buffer,
+                          int search_window, int block_window, float h, cudaStream_t stream);
+
+        void fnlm_split_channels(const PtrStepSz<uchar3>& lab, PtrStepb l, PtrStep<uchar2> ab, cudaStream_t stream);
+        void fnlm_merge_channels(const PtrStepb& l, const PtrStep<uchar2>& ab, PtrStepSz<uchar3> lab, cudaStream_t stream);
+     }
+}}}
+
+void cv::cuda::fastNlMeansDenoising(InputArray _src, OutputArray _dst, float h, int search_window, int block_window, Stream& stream)
+{
+    const GpuMat src = _src.getGpuMat();
+
+    CV_Assert(src.depth() == CV_8U && src.channels() < 4);
+
+    int border_size = search_window/2 + block_window/2;
+    Size esize = src.size() + Size(border_size, border_size) * 2;
+
+    BufferPool pool(stream);
+
+    GpuMat extended_src = pool.getBuffer(esize, src.type());
+    cv::cuda::copyMakeBorder(src, extended_src, border_size, border_size, border_size, border_size, cv::BORDER_DEFAULT, Scalar(), stream);
+    GpuMat src_hdr = extended_src(Rect(Point2i(border_size, border_size), src.size()));
+
+    int bcols, brows;
+    device::imgproc::nln_fast_get_buffer_size(src_hdr, search_window, block_window, bcols, brows);
+    GpuMat buffer = pool.getBuffer(brows, bcols, CV_32S);
+
+    using namespace cv::cuda::device::imgproc;
+    typedef void (*nlm_fast_t)(const PtrStepSzb&, PtrStepSzb, PtrStepi, int, int, float, cudaStream_t);
+    static const nlm_fast_t funcs[] = { nlm_fast_gpu<uchar>, nlm_fast_gpu<uchar2>, nlm_fast_gpu<uchar3>, 0};
+
+    _dst.create(src.size(), src.type());
+    GpuMat dst = _dst.getGpuMat();
+
+    funcs[src.channels()-1](src_hdr, dst, buffer, search_window, block_window, h, StreamAccessor::getStream(stream));
+}
+
+void cv::cuda::fastNlMeansDenoisingColored(InputArray _src, OutputArray _dst, float h_luminance, float h_color, int search_window, int block_window, Stream& stream)
+{
+    const GpuMat src = _src.getGpuMat();
+
+    CV_Assert(src.type() == CV_8UC3);
+
+    BufferPool pool(stream);
+
+    GpuMat lab = pool.getBuffer(src.size(), src.type());
+    cv::cuda::cvtColor(src, lab, cv::COLOR_BGR2Lab, 0, stream);
+
+    GpuMat l = pool.getBuffer(src.size(), CV_8U);
+    GpuMat ab = pool.getBuffer(src.size(), CV_8UC2);
+    device::imgproc::fnlm_split_channels(lab, l, ab, StreamAccessor::getStream(stream));
+
+    fastNlMeansDenoising(l, l, h_luminance, search_window, block_window, stream);
+    fastNlMeansDenoising(ab, ab, h_color, search_window, block_window, stream);
+
+    device::imgproc::fnlm_merge_channels(l, ab, lab, StreamAccessor::getStream(stream));
+    cv::cuda::cvtColor(lab, _dst, cv::COLOR_Lab2BGR, 0, stream);
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker.hpp b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker.hpp
new file mode 100644
index 0000000..1c71e10
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker.hpp
@@ -0,0 +1,321 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_FAST_NLMEANS_DENOISING_INVOKER_HPP__
+#define __OPENCV_FAST_NLMEANS_DENOISING_INVOKER_HPP__
+
+#include "precomp.hpp"
+#include <limits>
+
+#include "fast_nlmeans_denoising_invoker_commons.hpp"
+#include "arrays.hpp"
+
+using namespace cv;
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+struct FastNlMeansDenoisingInvoker :
+        public ParallelLoopBody
+{
+public:
+    FastNlMeansDenoisingInvoker(const Mat& src, Mat& dst,
+        int template_window_size, int search_window_size, const float *h);
+
+    void operator() (const Range& range) const CV_OVERRIDE;
+
+private:
+    void operator= (const FastNlMeansDenoisingInvoker&);
+
+    const Mat& src_;
+    Mat& dst_;
+
+    Mat extended_src_;
+    int border_size_;
+
+    int template_window_size_;
+    int search_window_size_;
+
+    int template_window_half_size_;
+    int search_window_half_size_;
+
+    typename pixelInfo<WT>::sampleType fixed_point_mult_;
+    int almost_template_window_size_sq_bin_shift_;
+    std::vector<WT> almost_dist2weight_;
+
+    void calcDistSumsForFirstElementInRow(
+        int i, Array2d<int>& dist_sums,
+        Array3d<int>& col_dist_sums,
+        Array3d<int>& up_col_dist_sums) const;
+
+    void calcDistSumsForElementInFirstRow(
+        int i, int j, int first_col_num,
+        Array2d<int>& dist_sums,
+        Array3d<int>& col_dist_sums,
+        Array3d<int>& up_col_dist_sums) const;
+};
+
+inline int getNearestPowerOf2(int value)
+{
+    int p = 0;
+    while( 1 << p < value)
+        ++p;
+    return p;
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+FastNlMeansDenoisingInvoker<T, IT, UIT, D, WT>::FastNlMeansDenoisingInvoker(
+    const Mat& src, Mat& dst,
+    int template_window_size,
+    int search_window_size,
+    const float *h) :
+    src_(src), dst_(dst)
+{
+    CV_Assert(src.channels() == pixelInfo<T>::channels);
+
+    template_window_half_size_ = template_window_size / 2;
+    search_window_half_size_   = search_window_size   / 2;
+    template_window_size_      = template_window_half_size_ * 2 + 1;
+    search_window_size_        = search_window_half_size_   * 2 + 1;
+
+    border_size_ = search_window_half_size_ + template_window_half_size_;
+    copyMakeBorder(src_, extended_src_, border_size_, border_size_, border_size_, border_size_, BORDER_DEFAULT);
+
+    const IT max_estimate_sum_value =
+        (IT)search_window_size_ * (IT)search_window_size_ * (IT)pixelInfo<T>::sampleMax();
+    fixed_point_mult_ = (int)std::min<IT>(std::numeric_limits<IT>::max() / max_estimate_sum_value,
+                                          pixelInfo<WT>::sampleMax());
+
+    // precalc weight for every possible l2 dist between blocks
+    // additional optimization of precalced weights to replace division(averaging) by binary shift
+    CV_Assert(template_window_size_ <= 46340); // sqrt(INT_MAX)
+    int template_window_size_sq = template_window_size_ * template_window_size_;
+    almost_template_window_size_sq_bin_shift_ = getNearestPowerOf2(template_window_size_sq);
+    double almost_dist2actual_dist_multiplier = ((double)(1 << almost_template_window_size_sq_bin_shift_)) / template_window_size_sq;
+
+    int max_dist = D::template maxDist<T>();
+    int almost_max_dist = (int)(max_dist / almost_dist2actual_dist_multiplier + 1);
+    almost_dist2weight_.resize(almost_max_dist);
+
+    for (int almost_dist = 0; almost_dist < almost_max_dist; almost_dist++)
+    {
+        double dist = almost_dist * almost_dist2actual_dist_multiplier;
+        almost_dist2weight_[almost_dist] =
+            D::template calcWeight<T, WT>(dist, h, fixed_point_mult_);
+    }
+
+    // additional optimization init end
+    if (dst_.empty())
+        dst_ = Mat::zeros(src_.size(), src_.type());
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+void FastNlMeansDenoisingInvoker<T, IT, UIT, D, WT>::operator() (const Range& range) const
+{
+    int row_from = range.start;
+    int row_to = range.end - 1;
+
+    // sums of cols anf rows for current pixel p
+    Array2d<int> dist_sums(search_window_size_, search_window_size_);
+
+    // for lazy calc optimization (sum of cols for current pixel)
+    Array3d<int> col_dist_sums(template_window_size_, search_window_size_, search_window_size_);
+
+    int first_col_num = -1;
+    // last elements of column sum (for each element in row)
+    Array3d<int> up_col_dist_sums(src_.cols, search_window_size_, search_window_size_);
+
+    for (int i = row_from; i <= row_to; i++)
+    {
+        for (int j = 0; j < src_.cols; j++)
+        {
+            int search_window_y = i - search_window_half_size_;
+            int search_window_x = j - search_window_half_size_;
+
+            // calc dist_sums
+            if (j == 0)
+            {
+                calcDistSumsForFirstElementInRow(i, dist_sums, col_dist_sums, up_col_dist_sums);
+                first_col_num = 0;
+            }
+            else
+            {
+                // calc cur dist_sums using previous dist_sums
+                if (i == row_from)
+                {
+                    calcDistSumsForElementInFirstRow(i, j, first_col_num,
+                        dist_sums, col_dist_sums, up_col_dist_sums);
+                }
+                else
+                {
+                    int ay = border_size_ + i;
+                    int ax = border_size_ + j + template_window_half_size_;
+
+                    int start_by = border_size_ + i - search_window_half_size_;
+                    int start_bx = border_size_ + j - search_window_half_size_ + template_window_half_size_;
+
+                    T a_up = extended_src_.at<T>(ay - template_window_half_size_ - 1, ax);
+                    T a_down = extended_src_.at<T>(ay + template_window_half_size_, ax);
+
+                    // copy class member to local variable for optimization
+                    int search_window_size = search_window_size_;
+
+                    for (int y = 0; y < search_window_size; y++)
+                    {
+                        int * dist_sums_row = dist_sums.row_ptr(y);
+                        int * col_dist_sums_row = col_dist_sums.row_ptr(first_col_num, y);
+                        int * up_col_dist_sums_row = up_col_dist_sums.row_ptr(j, y);
+
+                        const T * b_up_ptr = extended_src_.ptr<T>(start_by - template_window_half_size_ - 1 + y);
+                        const T * b_down_ptr = extended_src_.ptr<T>(start_by + template_window_half_size_ + y);
+
+// MSVC 2015 generates unaligned destination for "movaps" instruction for 32-bit builds
+#if defined _MSC_VER && _MSC_VER == 1900 && !defined _WIN64
+#pragma loop(no_vector)
+#endif
+                        for (int x = 0; x < search_window_size; x++)
+                        {
+                            // remove from current pixel sum column sum with index "first_col_num"
+                            dist_sums_row[x] -= col_dist_sums_row[x];
+
+                            int bx = start_bx + x;
+                            col_dist_sums_row[x] = up_col_dist_sums_row[x] + D::template calcUpDownDist<T>(a_up, a_down, b_up_ptr[bx], b_down_ptr[bx]);
+
+                            dist_sums_row[x] += col_dist_sums_row[x];
+                            up_col_dist_sums_row[x] = col_dist_sums_row[x];
+                        }
+                    }
+                }
+
+                first_col_num = (first_col_num + 1) % template_window_size_;
+            }
+
+            // calc weights
+            IT estimation[pixelInfo<T>::channels], weights_sum[pixelInfo<WT>::channels];
+            for (int channel_num = 0; channel_num < pixelInfo<T>::channels; channel_num++)
+                estimation[channel_num] = 0;
+            for (int channel_num = 0; channel_num < pixelInfo<WT>::channels; channel_num++)
+                weights_sum[channel_num] = 0;
+
+            for (int y = 0; y < search_window_size_; y++)
+            {
+                const T* cur_row_ptr = extended_src_.ptr<T>(border_size_ + search_window_y + y);
+                int* dist_sums_row = dist_sums.row_ptr(y);
+                for (int x = 0; x < search_window_size_; x++)
+                {
+                    int almostAvgDist = dist_sums_row[x] >> almost_template_window_size_sq_bin_shift_;
+                    WT weight = almost_dist2weight_[almostAvgDist];
+                    T p = cur_row_ptr[border_size_ + search_window_x + x];
+                    incWithWeight<T, IT, WT>(estimation, weights_sum, weight, p);
+                }
+            }
+
+            divByWeightsSum<IT, UIT, pixelInfo<T>::channels, pixelInfo<WT>::channels>(estimation,
+                                                                                      weights_sum);
+            dst_.at<T>(i,j) = saturateCastFromArray<T, IT>(estimation);
+        }
+    }
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+inline void FastNlMeansDenoisingInvoker<T, IT, UIT, D, WT>::calcDistSumsForFirstElementInRow(
+    int i,
+    Array2d<int>& dist_sums,
+    Array3d<int>& col_dist_sums,
+    Array3d<int>& up_col_dist_sums) const
+{
+    int j = 0;
+
+    for (int y = 0; y < search_window_size_; y++)
+        for (int x = 0; x < search_window_size_; x++)
+        {
+            dist_sums[y][x] = 0;
+            for (int tx = 0; tx < template_window_size_; tx++)
+                col_dist_sums[tx][y][x] = 0;
+
+            int start_y = i + y - search_window_half_size_;
+            int start_x = j + x - search_window_half_size_;
+
+            for (int ty = -template_window_half_size_; ty <= template_window_half_size_; ty++)
+                for (int tx = -template_window_half_size_; tx <= template_window_half_size_; tx++)
+                {
+                    int dist = D::template calcDist<T>(extended_src_,
+                        border_size_ + i + ty, border_size_ + j + tx,
+                        border_size_ + start_y + ty, border_size_ + start_x + tx);
+
+                    dist_sums[y][x] += dist;
+                    col_dist_sums[tx + template_window_half_size_][y][x] += dist;
+                }
+
+            up_col_dist_sums[j][y][x] = col_dist_sums[template_window_size_ - 1][y][x];
+        }
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+inline void FastNlMeansDenoisingInvoker<T, IT, UIT, D, WT>::calcDistSumsForElementInFirstRow(
+    int i, int j, int first_col_num,
+    Array2d<int>& dist_sums,
+    Array3d<int>& col_dist_sums,
+    Array3d<int>& up_col_dist_sums) const
+{
+    int ay = border_size_ + i;
+    int ax = border_size_ + j + template_window_half_size_;
+
+    int start_by = border_size_ + i - search_window_half_size_;
+    int start_bx = border_size_ + j - search_window_half_size_ + template_window_half_size_;
+
+    int new_last_col_num = first_col_num;
+
+    for (int y = 0; y < search_window_size_; y++)
+        for (int x = 0; x < search_window_size_; x++)
+        {
+            dist_sums[y][x] -= col_dist_sums[first_col_num][y][x];
+
+            col_dist_sums[new_last_col_num][y][x] = 0;
+            int by = start_by + y;
+            int bx = start_bx + x;
+            for (int ty = -template_window_half_size_; ty <= template_window_half_size_; ty++)
+                col_dist_sums[new_last_col_num][y][x] += D::template calcDist<T>(extended_src_, ay + ty, ax, by + ty, bx);
+
+            dist_sums[y][x] += col_dist_sums[new_last_col_num][y][x];
+            up_col_dist_sums[j][y][x] = col_dist_sums[new_last_col_num][y][x];
+        }
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker_commons.hpp b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker_commons.hpp
new file mode 100644
index 0000000..9da5c0c
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_invoker_commons.hpp
@@ -0,0 +1,489 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_FAST_NLMEANS_DENOISING_INVOKER_COMMONS_HPP__
+#define __OPENCV_FAST_NLMEANS_DENOISING_INVOKER_COMMONS_HPP__
+
+using namespace cv;
+
+// std::isnan is a part of C++11 and it is not supported in MSVS2010/2012
+#if defined _MSC_VER && _MSC_VER < 1800 /* MSVC 2013 */
+#include <float.h>
+namespace std {
+template <typename T> bool isnan(T value) { return _isnan(value) != 0; }
+}
+#endif
+
+template <typename T> struct pixelInfo_
+{
+    static const int channels = 1;
+    typedef T sampleType;
+};
+
+template <typename ET, int n> struct pixelInfo_<Vec<ET, n> >
+{
+    static const int channels = n;
+    typedef ET sampleType;
+};
+
+template <typename T> struct pixelInfo: public pixelInfo_<T>
+{
+    typedef typename pixelInfo_<T>::sampleType sampleType;
+
+    static inline sampleType sampleMax()
+    {
+        return std::numeric_limits<sampleType>::max();
+    }
+
+    static inline sampleType sampleMin()
+    {
+        return std::numeric_limits<sampleType>::min();
+    }
+
+    static inline size_t sampleBytes()
+    {
+        return sizeof(sampleType);
+    }
+
+    static inline size_t sampleBits()
+    {
+        return 8*sampleBytes();
+    }
+};
+
+class DistAbs
+{
+    template <typename T> struct calcDist_
+    {
+        static inline int f(const T a, const T b)
+        {
+            return std::abs((int)(a-b));
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 2> >
+    {
+        static inline int f(const Vec<ET, 2> a, const Vec<ET, 2> b)
+        {
+            return std::abs((int)(a[0]-b[0])) + std::abs((int)(a[1]-b[1]));
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 3> >
+    {
+        static inline int f(const Vec<ET, 3> a, const Vec<ET, 3> b)
+        {
+            return
+                std::abs((int)(a[0]-b[0])) +
+                std::abs((int)(a[1]-b[1])) +
+                std::abs((int)(a[2]-b[2]));
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 4> >
+    {
+        static inline int f(const Vec<ET, 4> a, const Vec<ET, 4> b)
+        {
+            return
+                std::abs((int)(a[0]-b[0])) +
+                std::abs((int)(a[1]-b[1])) +
+                std::abs((int)(a[2]-b[2])) +
+                std::abs((int)(a[3]-b[3]));
+        }
+    };
+
+    template <typename T, typename WT> struct calcWeight_
+    {
+        static inline WT f(double dist, const float *h, WT fixed_point_mult)
+        {
+            double w = std::exp(-dist*dist / (h[0]*h[0] * pixelInfo<T>::channels));
+            if (std::isnan(w)) w = 1.0; // Handle h = 0.0
+
+            static const double WEIGHT_THRESHOLD = 0.001;
+            WT weight = (WT)cvRound(fixed_point_mult * w);
+            if (weight < WEIGHT_THRESHOLD * fixed_point_mult) weight = 0;
+
+            return weight;
+        }
+    };
+
+    template <typename T, typename ET, int n> struct calcWeight_<T, Vec<ET, n> >
+    {
+        static inline Vec<ET, n> f(double dist, const float *h, ET fixed_point_mult)
+        {
+            Vec<ET, n> res;
+            for (int i=0; i<n; i++)
+                res[i] = calcWeight<T, ET>(dist, &h[i], fixed_point_mult);
+            return res;
+        }
+    };
+
+public:
+    template <typename T> static inline int calcDist(const T a, const T b)
+    {
+        return calcDist_<T>::f(a, b);
+    }
+
+    template <typename T>
+    static inline int calcDist(const Mat& m, int i1, int j1, int i2, int j2)
+    {
+        const T a = m.at<T>(i1, j1);
+        const T b = m.at<T>(i2, j2);
+        return calcDist<T>(a,b);
+    }
+
+    template <typename T>
+    static inline int calcUpDownDist(T a_up, T a_down, T b_up, T b_down)
+    {
+        return calcDist<T>(a_down, b_down) - calcDist<T>(a_up, b_up);
+    }
+
+    template <typename T, typename WT>
+    static inline WT calcWeight(double dist, const float *h,
+                                typename pixelInfo<WT>::sampleType fixed_point_mult)
+    {
+        return calcWeight_<T, WT>::f(dist, h, fixed_point_mult);
+    }
+
+    template <typename T>
+    static inline int maxDist()
+    {
+        return (int)pixelInfo<T>::sampleMax() * pixelInfo<T>::channels;
+    }
+};
+
+class DistSquared
+{
+    template <typename T> struct calcDist_
+    {
+        static inline int f(const T a, const T b)
+        {
+            return (int)(a-b) * (int)(a-b);
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 2> >
+    {
+        static inline int f(const Vec<ET, 2> a, const Vec<ET, 2> b)
+        {
+            return (int)(a[0]-b[0])*(int)(a[0]-b[0]) + (int)(a[1]-b[1])*(int)(a[1]-b[1]);
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 3> >
+    {
+        static inline int f(const Vec<ET, 3> a, const Vec<ET, 3> b)
+        {
+            return
+                (int)(a[0]-b[0])*(int)(a[0]-b[0]) +
+                (int)(a[1]-b[1])*(int)(a[1]-b[1]) +
+                (int)(a[2]-b[2])*(int)(a[2]-b[2]);
+        }
+    };
+
+    template <typename ET> struct calcDist_<Vec<ET, 4> >
+    {
+        static inline int f(const Vec<ET, 4> a, const Vec<ET, 4> b)
+        {
+            return
+                (int)(a[0]-b[0])*(int)(a[0]-b[0]) +
+                (int)(a[1]-b[1])*(int)(a[1]-b[1]) +
+                (int)(a[2]-b[2])*(int)(a[2]-b[2]) +
+                (int)(a[3]-b[3])*(int)(a[3]-b[3]);
+        }
+    };
+
+    template <typename T> struct calcUpDownDist_
+    {
+        static inline int f(T a_up, T a_down, T b_up, T b_down)
+        {
+            int A = a_down - b_down;
+            int B = a_up - b_up;
+            return (A-B)*(A+B);
+        }
+    };
+
+    template <typename ET, int n> struct calcUpDownDist_<Vec<ET, n> >
+    {
+    private:
+        typedef Vec<ET, n> T;
+    public:
+        static inline int f(T a_up, T a_down, T b_up, T b_down)
+        {
+            return calcDist<T>(a_down, b_down) - calcDist<T>(a_up, b_up);
+        }
+    };
+
+    template <typename T, typename WT> struct calcWeight_
+    {
+        static inline WT f(double dist, const float *h, WT fixed_point_mult)
+        {
+            double w = std::exp(-dist / (h[0]*h[0] * pixelInfo<T>::channels));
+            if (std::isnan(w)) w = 1.0; // Handle h = 0.0
+
+            static const double WEIGHT_THRESHOLD = 0.001;
+            WT weight = (WT)cvRound(fixed_point_mult * w);
+            if (weight < WEIGHT_THRESHOLD * fixed_point_mult) weight = 0;
+
+            return weight;
+        }
+    };
+
+    template <typename T, typename ET, int n> struct calcWeight_<T, Vec<ET, n> >
+    {
+        static inline Vec<ET, n> f(double dist, const float *h, ET fixed_point_mult)
+        {
+            Vec<ET, n> res;
+            for (int i=0; i<n; i++)
+                res[i] = calcWeight<T, ET>(dist, &h[i], fixed_point_mult);
+            return res;
+        }
+    };
+
+public:
+    template <typename T> static inline int calcDist(const T a, const T b)
+    {
+        return calcDist_<T>::f(a, b);
+    }
+
+    template <typename T>
+    static inline int calcDist(const Mat& m, int i1, int j1, int i2, int j2)
+    {
+        const T a = m.at<T>(i1, j1);
+        const T b = m.at<T>(i2, j2);
+        return calcDist<T>(a,b);
+    }
+
+    template <typename T>
+    static inline int calcUpDownDist(T a_up, T a_down, T b_up, T b_down)
+    {
+        return calcUpDownDist_<T>::f(a_up, a_down, b_up, b_down);
+    }
+
+    template <typename T, typename WT>
+    static inline WT calcWeight(double dist, const float *h,
+                                typename pixelInfo<WT>::sampleType fixed_point_mult)
+    {
+        return calcWeight_<T, WT>::f(dist, h, fixed_point_mult);
+    }
+
+    template <typename T>
+    static inline int maxDist()
+    {
+        return (int)pixelInfo<T>::sampleMax() * (int)pixelInfo<T>::sampleMax() *
+            pixelInfo<T>::channels;
+    }
+};
+
+template <typename T, typename IT, typename WT> struct incWithWeight_
+{
+    static inline void f(IT* estimation, IT* weights_sum, WT weight, T p)
+    {
+        estimation[0] += (IT)weight * p;
+        weights_sum[0] += (IT)weight;
+    }
+};
+
+template <typename ET, typename IT, typename WT> struct incWithWeight_<Vec<ET, 2>, IT, WT>
+{
+    static inline void f(IT* estimation, IT* weights_sum, WT weight, Vec<ET, 2> p)
+    {
+        estimation[0] += (IT)weight * p[0];
+        estimation[1] += (IT)weight * p[1];
+        weights_sum[0] += (IT)weight;
+    }
+};
+
+template <typename ET, typename IT, typename WT> struct incWithWeight_<Vec<ET, 3>, IT, WT>
+{
+    static inline void f(IT* estimation, IT* weights_sum, WT weight, Vec<ET, 3> p)
+    {
+        estimation[0] += (IT)weight * p[0];
+        estimation[1] += (IT)weight * p[1];
+        estimation[2] += (IT)weight * p[2];
+        weights_sum[0] += (IT)weight;
+    }
+};
+
+template <typename ET, typename IT, typename WT> struct incWithWeight_<Vec<ET, 4>, IT, WT>
+{
+    static inline void f(IT* estimation, IT* weights_sum, WT weight, Vec<ET, 4> p)
+    {
+        estimation[0] += (IT)weight * p[0];
+        estimation[1] += (IT)weight * p[1];
+        estimation[2] += (IT)weight * p[2];
+        estimation[3] += (IT)weight * p[3];
+        weights_sum[0] += (IT)weight;
+    }
+};
+
+template <typename ET, typename IT, typename EW> struct incWithWeight_<Vec<ET, 2>, IT, Vec<EW, 2> >
+{
+    static inline void f(IT* estimation, IT* weights_sum, Vec<EW, 2> weight, Vec<ET, 2> p)
+    {
+        estimation[0] += (IT)weight[0] * p[0];
+        estimation[1] += (IT)weight[1] * p[1];
+        weights_sum[0] += (IT)weight[0];
+        weights_sum[1] += (IT)weight[1];
+    }
+};
+
+template <typename ET, typename IT, typename EW> struct incWithWeight_<Vec<ET, 3>, IT, Vec<EW, 3> >
+{
+    static inline void f(IT* estimation, IT* weights_sum, Vec<EW, 3> weight, Vec<ET, 3> p)
+    {
+        estimation[0] += (IT)weight[0] * p[0];
+        estimation[1] += (IT)weight[1] * p[1];
+        estimation[2] += (IT)weight[2] * p[2];
+        weights_sum[0] += (IT)weight[0];
+        weights_sum[1] += (IT)weight[1];
+        weights_sum[2] += (IT)weight[2];
+    }
+};
+
+template <typename ET, typename IT, typename EW> struct incWithWeight_<Vec<ET, 4>, IT, Vec<EW, 4> >
+{
+    static inline void f(IT* estimation, IT* weights_sum, Vec<EW, 4> weight, Vec<ET, 4> p)
+    {
+        estimation[0] += (IT)weight[0] * p[0];
+        estimation[1] += (IT)weight[1] * p[1];
+        estimation[2] += (IT)weight[2] * p[2];
+        estimation[3] += (IT)weight[3] * p[3];
+        weights_sum[0] += (IT)weight[0];
+        weights_sum[1] += (IT)weight[1];
+        weights_sum[2] += (IT)weight[2];
+        weights_sum[3] += (IT)weight[3];
+    }
+};
+
+template <typename T, typename IT, typename WT>
+static inline void incWithWeight(IT* estimation, IT* weights_sum, WT weight, T p)
+{
+    incWithWeight_<T, IT, WT>::f(estimation, weights_sum, weight, p);
+}
+
+template <typename IT, typename UIT, int nc, int nw> struct divByWeightsSum_
+{
+    static inline void f(IT* estimation, IT* weights_sum);
+};
+
+template <typename IT, typename UIT> struct divByWeightsSum_<IT, UIT, 1, 1>
+{
+    static inline void f(IT* estimation, IT* weights_sum)
+    {
+        estimation[0] = (static_cast<UIT>(estimation[0]) + weights_sum[0]/2) / weights_sum[0];
+    }
+};
+
+template <typename IT, typename UIT, int n> struct divByWeightsSum_<IT, UIT, n, 1>
+{
+    static inline void f(IT* estimation, IT* weights_sum)
+    {
+        for (size_t i = 0; i < n; i++)
+            estimation[i] = (static_cast<UIT>(estimation[i]) + weights_sum[0]/2) / weights_sum[0];
+    }
+};
+
+template <typename IT, typename UIT, int n> struct divByWeightsSum_<IT, UIT, n, n>
+{
+    static inline void f(IT* estimation, IT* weights_sum)
+    {
+        for (size_t i = 0; i < n; i++)
+            estimation[i] = (static_cast<UIT>(estimation[i]) + weights_sum[i]/2) / weights_sum[i];
+    }
+};
+
+template <typename IT, typename UIT, int nc, int nw>
+static inline void divByWeightsSum(IT* estimation, IT* weights_sum)
+{
+    divByWeightsSum_<IT, UIT, nc, nw>::f(estimation, weights_sum);
+}
+
+template <typename T, typename IT> struct saturateCastFromArray_
+{
+    static inline T f(IT* estimation)
+    {
+        return saturate_cast<T>(estimation[0]);
+    }
+};
+
+template <typename ET, typename IT> struct saturateCastFromArray_<Vec<ET, 2>, IT>
+{
+    static inline Vec<ET, 2> f(IT* estimation)
+    {
+        Vec<ET, 2> res;
+        res[0] = saturate_cast<ET>(estimation[0]);
+        res[1] = saturate_cast<ET>(estimation[1]);
+        return res;
+    }
+};
+
+template <typename ET, typename IT> struct saturateCastFromArray_<Vec<ET, 3>, IT>
+{
+    static inline Vec<ET, 3> f(IT* estimation)
+    {
+        Vec<ET, 3> res;
+        res[0] = saturate_cast<ET>(estimation[0]);
+        res[1] = saturate_cast<ET>(estimation[1]);
+        res[2] = saturate_cast<ET>(estimation[2]);
+        return res;
+    }
+};
+
+template <typename ET, typename IT> struct saturateCastFromArray_<Vec<ET, 4>, IT>
+{
+    static inline Vec<ET, 4> f(IT* estimation)
+    {
+        Vec<ET, 4> res;
+        res[0] = saturate_cast<ET>(estimation[0]);
+        res[1] = saturate_cast<ET>(estimation[1]);
+        res[2] = saturate_cast<ET>(estimation[2]);
+        res[3] = saturate_cast<ET>(estimation[3]);
+        return res;
+    }
+};
+
+template <typename T, typename IT> static inline T saturateCastFromArray(IT* estimation)
+{
+    return saturateCastFromArray_<T, IT>::f(estimation);
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_opencl.hpp b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_opencl.hpp
new file mode 100644
index 0000000..1551422
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/fast_nlmeans_denoising_opencl.hpp
@@ -0,0 +1,217 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#include "precomp.hpp"
+#ifndef __OPENCV_FAST_NLMEANS_DENOISING_OPENCL_HPP__
+#define __OPENCV_FAST_NLMEANS_DENOISING_OPENCL_HPP__
+
+#include "opencl_kernels_photo.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace cv {
+
+enum
+{
+    BLOCK_ROWS = 32,
+    BLOCK_COLS = 32,
+    CTA_SIZE_INTEL = 64,
+    CTA_SIZE_DEFAULT = 256
+};
+
+template <typename FT, typename ST, typename WT>
+static bool ocl_calcAlmostDist2Weight(UMat & almostDist2Weight,
+                                      int searchWindowSize, int templateWindowSize,
+                                      const FT *h, int hn, int cn, int normType,
+                                      int & almostTemplateWindowSizeSqBinShift)
+{
+    const WT maxEstimateSumValue = searchWindowSize * searchWindowSize *
+        std::numeric_limits<ST>::max();
+    int fixedPointMult = (int)std::min<WT>(std::numeric_limits<WT>::max() / maxEstimateSumValue,
+                                           std::numeric_limits<int>::max());
+    int depth = DataType<FT>::depth;
+    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;
+
+    if (depth == CV_64F && !doubleSupport)
+        return false;
+
+    // precalc weight for every possible l2 dist between blocks
+    // additional optimization of precalced weights to replace division(averaging) by binary shift
+    CV_Assert(templateWindowSize <= 46340); // sqrt(INT_MAX)
+    int templateWindowSizeSq = templateWindowSize * templateWindowSize;
+    almostTemplateWindowSizeSqBinShift = getNearestPowerOf2(templateWindowSizeSq);
+    FT almostDist2ActualDistMultiplier = (FT)(1 << almostTemplateWindowSizeSqBinShift) / templateWindowSizeSq;
+
+    const FT WEIGHT_THRESHOLD = 1e-3f;
+    WT maxDist = normType == NORM_L1 ? (WT)std::numeric_limits<ST>::max() * cn :
+        (WT)std::numeric_limits<ST>::max() * (WT)std::numeric_limits<ST>::max() * cn;
+    int almostMaxDist = (int)(maxDist / almostDist2ActualDistMultiplier + 1);
+    FT den[4];
+    CV_Assert(hn > 0 && hn <= 4);
+    for (int i=0; i<hn; i++)
+        den[i] = 1.0f / (h[i] * h[i] * cn);
+
+    almostDist2Weight.create(1, almostMaxDist, CV_32SC(hn == 3 ? 4 : hn));
+
+    char buf[50];
+    ocl::Kernel k("calcAlmostDist2Weight", ocl::photo::nlmeans_oclsrc,
+                  format("-D OP_CALC_WEIGHTS -D FT=%s -D w_t=%s"
+                         " -D wlut_t=%s -D convert_wlut_t=%s%s%s",
+                         ocl::typeToStr(depth), ocl::typeToStr(CV_MAKE_TYPE(depth, hn)),
+                         ocl::typeToStr(CV_32SC(hn)), ocl::convertTypeStr(depth, CV_32S, hn, buf, sizeof(buf)),
+                         doubleSupport ? " -D DOUBLE_SUPPORT" : "",
+                         normType == NORM_L1 ? " -D ABS" : ""));
+    if (k.empty())
+        return false;
+
+    k.args(ocl::KernelArg::PtrWriteOnly(almostDist2Weight), almostMaxDist,
+           almostDist2ActualDistMultiplier, fixedPointMult,
+           ocl::KernelArg::Constant(den, (hn == 3 ? 4 : hn)*sizeof(FT)), WEIGHT_THRESHOLD);
+
+    size_t globalsize[1] = { (size_t)almostMaxDist };
+    return k.run(1, globalsize, NULL, false);
+}
+
+static bool ocl_fastNlMeansDenoising(InputArray _src, OutputArray _dst, const float *h, int hn,
+                                     int templateWindowSize, int searchWindowSize, int normType)
+{
+    int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+    int ctaSize = ocl::Device::getDefault().isIntel() ? CTA_SIZE_INTEL : CTA_SIZE_DEFAULT;
+    Size size = _src.size();
+
+    if (cn < 1 || cn > 4 || ((normType != NORM_L2 || depth != CV_8U) &&
+                             (normType != NORM_L1 || (depth != CV_8U && depth != CV_16U))))
+        return false;
+
+    int templateWindowHalfWize = templateWindowSize / 2;
+    int searchWindowHalfSize = searchWindowSize / 2;
+    templateWindowSize  = templateWindowHalfWize * 2 + 1;
+    searchWindowSize = searchWindowHalfSize * 2 + 1;
+    int nblocksx = divUp(size.width, BLOCK_COLS), nblocksy = divUp(size.height, BLOCK_ROWS);
+    int almostTemplateWindowSizeSqBinShift = -1;
+
+    char buf[4][40];
+    const unsigned psz = (depth == CV_8U ? sizeof(uchar) : sizeof(ushort)) * (cn == 3 ? 4 : cn);
+    String opts = format("-D OP_CALC_FASTNLMEANS -D TEMPLATE_SIZE=%d -D SEARCH_SIZE=%d"
+                         " -D pixel_t=%s -D int_t=%s -D wlut_t=%s"
+                         " -D weight_t=%s -D convert_weight_t=%s -D sum_t=%s -D convert_sum_t=%s"
+                         " -D BLOCK_COLS=%d -D BLOCK_ROWS=%d"
+                         " -D CTA_SIZE=%d -D TEMPLATE_SIZE2=%d -D SEARCH_SIZE2=%d"
+                         " -D convert_int_t=%s -D cn=%d -D psz=%u -D convert_pixel_t=%s%s",
+                         templateWindowSize, searchWindowSize,
+                         ocl::typeToStr(type), ocl::typeToStr(CV_32SC(cn)),
+                         ocl::typeToStr(CV_32SC(hn)),
+                         depth == CV_8U ? ocl::typeToStr(CV_32SC(hn)) :
+                         format("long%s", hn > 1 ? format("%d", hn).c_str() : "").c_str(),
+                         depth == CV_8U ? ocl::convertTypeStr(CV_32S, CV_32S, hn, buf[0], sizeof(buf[0])) :
+                         format("convert_long%s", hn > 1 ? format("%d", hn).c_str() : "").c_str(),
+                         depth == CV_8U ? ocl::typeToStr(CV_32SC(cn)) :
+                         format("long%s", cn > 1 ? format("%d", cn).c_str() : "").c_str(),
+                         depth == CV_8U ? ocl::convertTypeStr(depth, CV_32S, cn, buf[1], sizeof(buf[1])) :
+                         format("convert_long%s", cn > 1 ? format("%d", cn).c_str() : "").c_str(),
+                         BLOCK_COLS, BLOCK_ROWS,
+                         ctaSize, templateWindowHalfWize, searchWindowHalfSize,
+                         ocl::convertTypeStr(depth, CV_32S, cn, buf[2], sizeof(buf[2])), cn,
+                         psz,
+                         ocl::convertTypeStr(CV_32S, depth, cn, buf[3], sizeof(buf[3])),
+                         normType == NORM_L1 ? " -D ABS" : "");
+
+    ocl::Kernel k("fastNlMeansDenoising", ocl::photo::nlmeans_oclsrc, opts);
+    if (k.empty())
+        return false;
+
+    UMat almostDist2Weight;
+    if ((depth == CV_8U &&
+         !ocl_calcAlmostDist2Weight<float, uchar, int>(almostDist2Weight,
+                                                       searchWindowSize, templateWindowSize,
+                                                       h, hn, cn, normType,
+                                                       almostTemplateWindowSizeSqBinShift)) ||
+        (depth == CV_16U &&
+         !ocl_calcAlmostDist2Weight<float, ushort, int64>(almostDist2Weight,
+                                                          searchWindowSize, templateWindowSize,
+                                                          h, hn, cn, normType,
+                                                          almostTemplateWindowSizeSqBinShift)))
+        return false;
+    CV_Assert(almostTemplateWindowSizeSqBinShift >= 0);
+
+    UMat srcex;
+    int borderSize = searchWindowHalfSize + templateWindowHalfWize;
+    if (cn == 3) {
+        srcex.create(size.height + 2*borderSize, size.width + 2*borderSize, CV_MAKE_TYPE(depth, 4));
+        UMat src(srcex, Rect(borderSize, borderSize, size.width, size.height));
+        int from_to[] = { 0,0, 1,1, 2,2 };
+        mixChannels(std::vector<UMat>(1, _src.getUMat()), std::vector<UMat>(1, src), from_to, 3);
+        copyMakeBorder(src, srcex, borderSize, borderSize, borderSize, borderSize,
+                       BORDER_DEFAULT|BORDER_ISOLATED); // create borders in place
+    }
+    else
+        copyMakeBorder(_src, srcex, borderSize, borderSize, borderSize, borderSize, BORDER_DEFAULT);
+
+    _dst.create(size, type);
+    UMat dst;
+    if (cn == 3)
+        dst.create(size, CV_MAKE_TYPE(depth, 4));
+    else
+        dst = _dst.getUMat();
+
+    int searchWindowSizeSq = searchWindowSize * searchWindowSize;
+    Size upColSumSize(size.width, searchWindowSizeSq * nblocksy);
+    Size colSumSize(nblocksx * templateWindowSize, searchWindowSizeSq * nblocksy);
+    UMat buffer(upColSumSize + colSumSize, CV_32SC(cn));
+
+    srcex = srcex(Rect(Point(borderSize, borderSize), size));
+    k.args(ocl::KernelArg::ReadOnlyNoSize(srcex), ocl::KernelArg::WriteOnly(dst),
+           ocl::KernelArg::PtrReadOnly(almostDist2Weight),
+           ocl::KernelArg::PtrReadOnly(buffer), almostTemplateWindowSizeSqBinShift);
+
+    size_t globalsize[2] = { (size_t)nblocksx * ctaSize, (size_t)nblocksy }, localsize[2] = { (size_t)ctaSize, 1 };
+    if (!k.run(2, globalsize, localsize, false)) return false;
+
+    if (cn == 3) {
+        int from_to[] = { 0,0, 1,1, 2,2 };
+        mixChannels(std::vector<UMat>(1, dst), std::vector<UMat>(1, _dst.getUMat()), from_to, 3);
+    }
+
+    return true;
+}
+
+static bool ocl_fastNlMeansDenoisingColored( InputArray _src, OutputArray _dst,
+                                      float h, float hForColorComponents,
+                                      int templateWindowSize, int searchWindowSize)
+{
+    UMat src = _src.getUMat();
+    _dst.create(src.size(), src.type());
+    UMat dst = _dst.getUMat();
+
+    UMat src_lab;
+    cvtColor(src, src_lab, COLOR_LBGR2Lab);
+
+    UMat l(src.size(), CV_8U);
+    UMat ab(src.size(), CV_8UC2);
+    std::vector<UMat> l_ab(2), l_ab_denoised(2);
+    l_ab[0] = l;
+    l_ab[1] = ab;
+    l_ab_denoised[0].create(src.size(), CV_8U);
+    l_ab_denoised[1].create(src.size(), CV_8UC2);
+
+    int from_to[] = { 0,0, 1,1, 2,2 };
+    mixChannels(std::vector<UMat>(1, src_lab), l_ab, from_to, 3);
+
+    fastNlMeansDenoising(l_ab[0], l_ab_denoised[0], h, templateWindowSize, searchWindowSize);
+    fastNlMeansDenoising(l_ab[1], l_ab_denoised[1], hForColorComponents, templateWindowSize, searchWindowSize);
+
+    UMat dst_lab(src.size(), CV_8UC3);
+    mixChannels(l_ab_denoised, std::vector<UMat>(1, dst_lab), from_to, 3);
+
+    cvtColor(dst_lab, dst, COLOR_Lab2LBGR, src.channels());
+    return true;
+}
+
+}
+
+#endif
+#endif
diff --git a/upstream/opencv/modules/photo/src/fast_nlmeans_multi_denoising_invoker.hpp b/upstream/opencv/modules/photo/src/fast_nlmeans_multi_denoising_invoker.hpp
new file mode 100644
index 0000000..4c0c784
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/fast_nlmeans_multi_denoising_invoker.hpp
@@ -0,0 +1,360 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_FAST_NLMEANS_MULTI_DENOISING_INVOKER_HPP__
+#define __OPENCV_FAST_NLMEANS_MULTI_DENOISING_INVOKER_HPP__
+
+#include "precomp.hpp"
+#include <limits>
+
+#include "fast_nlmeans_denoising_invoker_commons.hpp"
+#include "arrays.hpp"
+
+using namespace cv;
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+struct FastNlMeansMultiDenoisingInvoker :
+        ParallelLoopBody
+{
+public:
+    FastNlMeansMultiDenoisingInvoker(const std::vector<Mat>& srcImgs, int imgToDenoiseIndex,
+                                     int temporalWindowSize, Mat& dst, int template_window_size,
+                                     int search_window_size, const float *h);
+
+    void operator() (const Range& range) const CV_OVERRIDE;
+
+private:
+    void operator= (const FastNlMeansMultiDenoisingInvoker&);
+
+    int rows_;
+    int cols_;
+
+    Mat& dst_;
+
+    std::vector<Mat> extended_srcs_;
+    Mat main_extended_src_;
+    int border_size_;
+
+    int template_window_size_;
+    int search_window_size_;
+    int temporal_window_size_;
+
+    int template_window_half_size_;
+    int search_window_half_size_;
+    int temporal_window_half_size_;
+
+    typename pixelInfo<WT>::sampleType fixed_point_mult_;
+    int almost_template_window_size_sq_bin_shift;
+    std::vector<WT> almost_dist2weight;
+
+    void calcDistSumsForFirstElementInRow(int i, Array3d<int>& dist_sums,
+                                          Array4d<int>& col_dist_sums,
+                                          Array4d<int>& up_col_dist_sums) const;
+
+    void calcDistSumsForElementInFirstRow(int i, int j, int first_col_num,
+                                          Array3d<int>& dist_sums, Array4d<int>& col_dist_sums,
+                                          Array4d<int>& up_col_dist_sums) const;
+};
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+FastNlMeansMultiDenoisingInvoker<T, IT, UIT, D, WT>::FastNlMeansMultiDenoisingInvoker(
+    const std::vector<Mat>& srcImgs,
+    int imgToDenoiseIndex,
+    int temporalWindowSize,
+    cv::Mat& dst,
+    int template_window_size,
+    int search_window_size,
+    const float *h) :
+        dst_(dst), extended_srcs_(srcImgs.size())
+{
+    CV_Assert(srcImgs.size() > 0);
+    CV_Assert(srcImgs[0].channels() == pixelInfo<T>::channels);
+
+    rows_ = srcImgs[0].rows;
+    cols_ = srcImgs[0].cols;
+
+    template_window_half_size_ = template_window_size / 2;
+    search_window_half_size_ = search_window_size / 2;
+    temporal_window_half_size_ = temporalWindowSize / 2;
+
+    template_window_size_ = template_window_half_size_ * 2 + 1;
+    search_window_size_ = search_window_half_size_ * 2 + 1;
+    temporal_window_size_ = temporal_window_half_size_ * 2 + 1;
+
+    border_size_ = search_window_half_size_ + template_window_half_size_;
+    for (int i = 0; i < temporal_window_size_; i++)
+        copyMakeBorder(srcImgs[imgToDenoiseIndex - temporal_window_half_size_ + i], extended_srcs_[i],
+            border_size_, border_size_, border_size_, border_size_, cv::BORDER_DEFAULT);
+
+    main_extended_src_ = extended_srcs_[temporal_window_half_size_];
+    const IT max_estimate_sum_value =
+        (IT)temporal_window_size_ * (IT)search_window_size_ * (IT)search_window_size_ * (IT)pixelInfo<T>::sampleMax();
+    fixed_point_mult_ = (int)std::min<IT>(std::numeric_limits<IT>::max() / max_estimate_sum_value,
+                                          pixelInfo<WT>::sampleMax());
+
+    // precalc weight for every possible l2 dist between blocks
+    // additional optimization of precalced weights to replace division(averaging) by binary shift
+    int template_window_size_sq = template_window_size_ * template_window_size_;
+    almost_template_window_size_sq_bin_shift = 0;
+    while (1 << almost_template_window_size_sq_bin_shift < template_window_size_sq)
+        almost_template_window_size_sq_bin_shift++;
+
+    int almost_template_window_size_sq = 1 << almost_template_window_size_sq_bin_shift;
+    double almost_dist2actual_dist_multiplier = (double) almost_template_window_size_sq / template_window_size_sq;
+
+    int max_dist = D::template maxDist<T>();
+    int almost_max_dist = (int)(max_dist / almost_dist2actual_dist_multiplier + 1);
+    almost_dist2weight.resize(almost_max_dist);
+
+    for (int almost_dist = 0; almost_dist < almost_max_dist; almost_dist++)
+    {
+        double dist = almost_dist * almost_dist2actual_dist_multiplier;
+        almost_dist2weight[almost_dist] =
+            D::template calcWeight<T, WT>(dist, h, fixed_point_mult_);
+    }
+
+    // additional optimization init end
+    if (dst_.empty())
+        dst_ = Mat::zeros(srcImgs[0].size(), srcImgs[0].type());
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+void FastNlMeansMultiDenoisingInvoker<T, IT, UIT, D, WT>::operator() (const Range& range) const
+{
+    int row_from = range.start;
+    int row_to = range.end - 1;
+
+    Array3d<int> dist_sums(temporal_window_size_, search_window_size_, search_window_size_);
+
+    // for lazy calc optimization
+    Array4d<int> col_dist_sums(template_window_size_, temporal_window_size_, search_window_size_, search_window_size_);
+
+    int first_col_num = -1;
+    Array4d<int> up_col_dist_sums(cols_, temporal_window_size_, search_window_size_, search_window_size_);
+
+    for (int i = row_from; i <= row_to; i++)
+    {
+        for (int j = 0; j < cols_; j++)
+        {
+            int search_window_y = i - search_window_half_size_;
+            int search_window_x = j - search_window_half_size_;
+
+            // calc dist_sums
+            if (j == 0)
+            {
+                calcDistSumsForFirstElementInRow(i, dist_sums, col_dist_sums, up_col_dist_sums);
+                first_col_num = 0;
+            }
+            else
+            {
+                // calc cur dist_sums using previous dist_sums
+                if (i == row_from)
+                {
+                    calcDistSumsForElementInFirstRow(i, j, first_col_num,
+                        dist_sums, col_dist_sums, up_col_dist_sums);
+
+                }
+                else
+                {
+                    int ay = border_size_ + i;
+                    int ax = border_size_ + j + template_window_half_size_;
+
+                    int start_by =
+                        border_size_ + i - search_window_half_size_;
+
+                    int start_bx =
+                        border_size_ + j - search_window_half_size_ + template_window_half_size_;
+
+                    T a_up = main_extended_src_.at<T>(ay - template_window_half_size_ - 1, ax);
+                    T a_down = main_extended_src_.at<T>(ay + template_window_half_size_, ax);
+
+                    // copy class member to local variable for optimization
+                    int search_window_size = search_window_size_;
+
+                    for (int d = 0; d < temporal_window_size_; d++)
+                    {
+                        Mat cur_extended_src = extended_srcs_[d];
+                        Array2d<int> cur_dist_sums = dist_sums[d];
+                        Array2d<int> cur_col_dist_sums = col_dist_sums[first_col_num][d];
+                        Array2d<int> cur_up_col_dist_sums = up_col_dist_sums[j][d];
+                        for (int y = 0; y < search_window_size; y++)
+                        {
+                            int* dist_sums_row = cur_dist_sums.row_ptr(y);
+
+                            int* col_dist_sums_row = cur_col_dist_sums.row_ptr(y);
+                            int* up_col_dist_sums_row = cur_up_col_dist_sums.row_ptr(y);
+
+                            const T* b_up_ptr = cur_extended_src.ptr<T>(start_by - template_window_half_size_ - 1 + y);
+                            const T* b_down_ptr = cur_extended_src.ptr<T>(start_by + template_window_half_size_ + y);
+
+                            for (int x = 0; x < search_window_size; x++)
+                            {
+                                dist_sums_row[x] -= col_dist_sums_row[x];
+
+                                col_dist_sums_row[x] = up_col_dist_sums_row[x] +
+                                    D::template calcUpDownDist<T>(a_up, a_down, b_up_ptr[start_bx + x], b_down_ptr[start_bx + x]);
+
+                                dist_sums_row[x] += col_dist_sums_row[x];
+                                up_col_dist_sums_row[x] = col_dist_sums_row[x];
+                            }
+                        }
+                    }
+                }
+
+                first_col_num = (first_col_num + 1) % template_window_size_;
+            }
+
+            // calc weights
+            IT estimation[pixelInfo<T>::channels], weights_sum[pixelInfo<WT>::channels];
+            for (size_t channel_num = 0; channel_num < pixelInfo<T>::channels; channel_num++)
+                estimation[channel_num] = 0;
+            for (size_t channel_num = 0; channel_num < pixelInfo<WT>::channels; channel_num++)
+                weights_sum[channel_num] = 0;
+
+            for (int d = 0; d < temporal_window_size_; d++)
+            {
+                const Mat& esrc_d = extended_srcs_[d];
+                for (int y = 0; y < search_window_size_; y++)
+                {
+                    const T* cur_row_ptr = esrc_d.ptr<T>(border_size_ + search_window_y + y);
+
+                    int* dist_sums_row = dist_sums.row_ptr(d, y);
+
+                    for (int x = 0; x < search_window_size_; x++)
+                    {
+                        int almostAvgDist = dist_sums_row[x] >> almost_template_window_size_sq_bin_shift;
+
+                        WT weight =  almost_dist2weight[almostAvgDist];
+                        T p = cur_row_ptr[border_size_ + search_window_x + x];
+                        incWithWeight<T, IT, WT>(estimation, weights_sum, weight, p);
+                    }
+                }
+            }
+
+            divByWeightsSum<IT, UIT, pixelInfo<T>::channels, pixelInfo<WT>::channels>(estimation,
+                                                                                      weights_sum);
+            dst_.at<T>(i,j) = saturateCastFromArray<T, IT>(estimation);
+        }
+    }
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+inline void FastNlMeansMultiDenoisingInvoker<T, IT, UIT, D, WT>::calcDistSumsForFirstElementInRow(
+        int i, Array3d<int>& dist_sums, Array4d<int>& col_dist_sums, Array4d<int>& up_col_dist_sums) const
+{
+    int j = 0;
+
+    for (int d = 0; d < temporal_window_size_; d++)
+    {
+        Mat cur_extended_src = extended_srcs_[d];
+        for (int y = 0; y < search_window_size_; y++)
+            for (int x = 0; x < search_window_size_; x++)
+            {
+                dist_sums[d][y][x] = 0;
+                for (int tx = 0; tx < template_window_size_; tx++)
+                    col_dist_sums[tx][d][y][x] = 0;
+
+                int start_y = i + y - search_window_half_size_;
+                int start_x = j + x - search_window_half_size_;
+
+                int* dist_sums_ptr = &dist_sums[d][y][x];
+                int* col_dist_sums_ptr = &col_dist_sums[0][d][y][x];
+                int col_dist_sums_step = col_dist_sums.step_size(0);
+                for (int tx = -template_window_half_size_; tx <= template_window_half_size_; tx++)
+                {
+                    for (int ty = -template_window_half_size_; ty <= template_window_half_size_; ty++)
+                    {
+                        int dist = D::template calcDist<T>(
+                                    main_extended_src_.at<T>(border_size_ + i + ty, border_size_ + j + tx),
+                                    cur_extended_src.at<T>(border_size_ + start_y + ty, border_size_ + start_x + tx));
+
+                        *dist_sums_ptr += dist;
+                        *col_dist_sums_ptr += dist;
+                    }
+                    col_dist_sums_ptr += col_dist_sums_step;
+                }
+
+                up_col_dist_sums[j][d][y][x] = col_dist_sums[template_window_size_ - 1][d][y][x];
+            }
+    }
+}
+
+template <typename T, typename IT, typename UIT, typename D, typename WT>
+inline void FastNlMeansMultiDenoisingInvoker<T, IT, UIT, D, WT>::calcDistSumsForElementInFirstRow(
+    int i, int j, int first_col_num, Array3d<int>& dist_sums,
+    Array4d<int>& col_dist_sums, Array4d<int>& up_col_dist_sums) const
+{
+    int ay = border_size_ + i;
+    int ax = border_size_ + j + template_window_half_size_;
+
+    int start_by = border_size_ + i - search_window_half_size_;
+    int start_bx = border_size_ + j - search_window_half_size_ + template_window_half_size_;
+
+    int new_last_col_num = first_col_num;
+
+    for (int d = 0; d < temporal_window_size_; d++)
+    {
+        Mat cur_extended_src = extended_srcs_[d];
+        for (int y = 0; y < search_window_size_; y++)
+            for (int x = 0; x < search_window_size_; x++)
+            {
+                dist_sums[d][y][x] -= col_dist_sums[first_col_num][d][y][x];
+
+                col_dist_sums[new_last_col_num][d][y][x] = 0;
+                int by = start_by + y;
+                int bx = start_bx + x;
+
+                int* col_dist_sums_ptr = &col_dist_sums[new_last_col_num][d][y][x];
+                for (int ty = -template_window_half_size_; ty <= template_window_half_size_; ty++)
+                {
+                    *col_dist_sums_ptr += D::template calcDist<T>(
+                                main_extended_src_.at<T>(ay + ty, ax),
+                                cur_extended_src.at<T>(by + ty, bx));
+                }
+
+                dist_sums[d][y][x] += col_dist_sums[new_last_col_num][d][y][x];
+
+                up_col_dist_sums[j][d][y][x] = col_dist_sums[new_last_col_num][d][y][x];
+            }
+    }
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/hdr_common.cpp b/upstream/opencv/modules/photo/src/hdr_common.cpp
new file mode 100644
index 0000000..b2f2def
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/hdr_common.cpp
@@ -0,0 +1,135 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "hdr_common.hpp"
+
+namespace cv
+{
+
+void checkImageDimensions(const std::vector<Mat>& images)
+{
+    CV_Assert(!images.empty());
+    int width = images[0].cols;
+    int height = images[0].rows;
+    int type = images[0].type();
+
+    for(size_t i = 0; i < images.size(); i++) {
+        CV_Assert(images[i].cols == width && images[i].rows == height);
+        CV_Assert(images[i].type() == type);
+    }
+}
+
+Mat triangleWeights(int length)
+{
+    // hat function
+    CV_Assert(length >= 2);
+    Mat w(length, 1, CV_32F);
+    int half   = length / 2;
+    int maxVal = length - 1;
+    float epsilon = 1e-6f;
+    w.at<float>(0) = epsilon;
+    w.at<float>(length - 1) = epsilon;
+    for (int i = 1; i < length - 1; i++){
+        w.at<float>(i) = (i < half)
+            ? static_cast<float>(i)
+            : static_cast<float>(maxVal - i);
+    }
+    return w;
+}
+
+Mat RobertsonWeights(int length)
+{
+    CV_Assert(length >= 1);
+    Mat weight(length, 1, CV_32FC3);
+    float q = (length - 1) / 4.0f;
+    float e4 = exp(4.f);
+    float scale = e4/(e4 - 1.f);
+    float shift = 1 / (1.f - e4);
+
+    for(int i = 0; i < length; i++) {
+        float value = i / q - 2.0f;
+        value = scale*exp(-value * value) + shift;
+        weight.at<Vec3f>(i) = Vec3f::all(value);
+    }
+    return weight;
+}
+
+void mapLuminance(Mat src, Mat dst, Mat lum, Mat new_lum, float saturation)
+{
+    std::vector<Mat> channels(3);
+    split(src, channels);
+    for(int i = 0; i < 3; i++) {
+        channels[i] = channels[i].mul(1.0f / lum);
+        pow(channels[i], saturation, channels[i]);
+        channels[i] = channels[i].mul(new_lum);
+    }
+    merge(channels, dst);
+}
+
+Mat linearResponse(int channels, int length)
+{
+    CV_Assert(length >= 1);
+    Mat response = Mat(length, 1, CV_MAKETYPE(CV_32F, channels));
+
+    if (channels == 1)
+    {
+        for (int i = 0; i < length; i++)
+        {
+            response.at<float>(i) = static_cast<float>(i);
+        }
+    }
+    else if (channels == 3)
+    {
+        for (int i = 0; i < length; i++)
+        {
+            response.at<Vec3f>(i) = Vec3f::all(static_cast<float>(i));
+        }
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "Unsupported number of channels in linearResponse");
+    }
+    return response;
+}
+
+}
diff --git a/upstream/opencv/modules/photo/src/hdr_common.hpp b/upstream/opencv/modules/photo/src/hdr_common.hpp
new file mode 100644
index 0000000..cb96068
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/hdr_common.hpp
@@ -0,0 +1,62 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_HDR_COMMON_HPP__
+#define __OPENCV_HDR_COMMON_HPP__
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+
+namespace cv
+{
+
+void checkImageDimensions(const std::vector<Mat>& images);
+
+Mat triangleWeights(int length = LDR_SIZE);
+
+void mapLuminance(Mat src, Mat dst, Mat lum, Mat new_lum, float saturation);
+
+Mat RobertsonWeights(int length = LDR_SIZE);
+
+Mat linearResponse(int channels, int length = LDR_SIZE);
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/inpaint.cpp b/upstream/opencv/modules/photo/src/inpaint.cpp
new file mode 100644
index 0000000..2f2f368
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/inpaint.cpp
@@ -0,0 +1,800 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective icvers.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/* ////////////////////////////////////////////////////////////////////
+//
+//  Geometrical transforms on images and matrices: rotation, zoom etc.
+//
+// */
+
+#include <queue>
+#include <type_traits>
+
+#include "precomp.hpp"
+
+using namespace cv;
+
+#undef CV_MAT_ELEM_PTR_FAST
+#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size )  \
+     ((mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))
+
+template<typename T>
+typename std::enable_if<std::is_floating_point<T>::value, T>::type round_cast(float val) {
+   return cv::saturate_cast<T>(val);
+}
+
+template<typename T>
+typename std::enable_if<!std::is_floating_point<T>::value, T>::type round_cast(float val) {
+   return cv::saturate_cast<T>(val + 0.5);
+}
+
+inline float
+min4( float a, float b, float c, float d )
+{
+    a = MIN(a,b);
+    c = MIN(c,d);
+    return MIN(a,c);
+}
+
+#define KNOWN  0  //known outside narrow band
+#define BAND   1  //narrow band (known)
+#define INSIDE 2  //unknown
+#define CHANGE 3  //servise
+
+typedef struct CvHeapElem
+{
+    float T;
+    int i,j;
+    int order;  // to keep insertion order
+
+    bool operator > (const CvHeapElem& rhs) const {
+        if (T > rhs.T) {
+            return true;
+        } else if (T < rhs.T) {
+            return false;
+        }
+        return order > rhs.order;
+    }
+}
+CvHeapElem;
+
+
+class CvPriorityQueueFloat
+{
+private:
+    CvPriorityQueueFloat(const CvPriorityQueueFloat & ); // copy disabled
+    CvPriorityQueueFloat& operator=(const CvPriorityQueueFloat &); // assign disabled
+
+protected:
+    std::priority_queue<CvHeapElem, std::vector<CvHeapElem>,std::greater<CvHeapElem> > queue;
+    int next_order;
+
+public:
+    bool Add(const Mat &f) {
+        int i,j;
+        for (i=0; i<f.rows; i++) {
+            for (j=0; j<f.cols; j++) {
+                if (f.at<uchar>(i, j)!=0) {
+                    if (!Push(i,j,0)) return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    bool Push(int i, int j, float T) {
+        queue.push({T, i, j, next_order});
+        ++next_order;
+        return true;
+    }
+
+    bool Pop(int *i, int *j) {
+        if (queue.empty()) {
+            return false;
+        }
+        *i = queue.top().i;
+        *j = queue.top().j;
+        queue.pop();
+        return true;
+    }
+
+    bool Pop(int *i, int *j, float *T) {
+        if (queue.empty()) {
+            return false;
+        }
+        *i = queue.top().i;
+        *j = queue.top().j;
+        *T = queue.top().T;
+        queue.pop();
+        return true;
+    }
+
+    CvPriorityQueueFloat(void) : queue(), next_order() {
+    }
+};
+
+static inline float VectorScalMult(const cv::Point2f& v1, const cv::Point2f& v2)
+{
+   return v1.x*v2.x+v1.y*v2.y;
+}
+
+static inline float VectorLength(const cv::Point2f& v1)
+{
+    return v1.x*v1.x+v1.y*v1.y;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+//HEAP::iterator Heap_Iterator;
+//HEAP Heap;
+
+static float FastMarching_solve(int i1,int j1,int i2,int j2, const Mat &f, const Mat &t)
+{
+    double sol, a11, a22, m12;
+    a11=t.at<float>(i1,j1);
+    a22=t.at<float>(i2,j2);
+    m12=MIN(a11,a22);
+
+    if( f.at<uchar>(i1,j1) != INSIDE )
+        if( f.at<uchar>(i2,j2) != INSIDE )
+            if( fabs(a11-a22) >= 1.0 )
+                sol = 1+m12;
+            else
+                sol = (a11+a22+sqrt((double)(2-(a11-a22)*(a11-a22))))*0.5;
+        else
+            sol = 1+a11;
+    else if( f.at<uchar>(i2,j2) != INSIDE )
+        sol = 1+a22;
+    else
+        sol = 1+m12;
+
+    return (float)sol;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+
+static void
+icvCalcFMM(Mat &f, Mat &t, CvPriorityQueueFloat *Heap, bool negate) {
+   int i, j, ii = 0, jj = 0, q;
+   float dist;
+
+   while (Heap->Pop(&ii,&jj)) {
+
+      unsigned known=(negate)?CHANGE:KNOWN;
+      f.at<uchar>(ii,jj) = (uchar)known;
+
+      for (q=0; q<4; q++) {
+         i=0; j=0;
+         if     (q==0) {i=ii-1; j=jj;}
+         else if(q==1) {i=ii;   j=jj-1;}
+         else if(q==2) {i=ii+1; j=jj;}
+         else {i=ii;   j=jj+1;}
+         if ((i<=0)||(j<=0)||(i>f.rows)||(j>f.cols)) continue;
+
+         if (f.at<uchar>(i,j)==INSIDE) {
+            dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
+                        FastMarching_solve(i+1,j,i,j-1,f,t),
+                        FastMarching_solve(i-1,j,i,j+1,f,t),
+                        FastMarching_solve(i+1,j,i,j+1,f,t));
+            t.at<float>(i,j) = dist;
+            f.at<uchar>(i,j) = BAND;
+            Heap->Push(i,j,dist);
+         }
+      }
+   }
+
+   if (negate) {
+      for (i=0; i<f.rows; i++) {
+         for(j=0; j<f.cols; j++) {
+            if (f.at<uchar>(i,j) == CHANGE) {
+               f.at<uchar>(i,j) = KNOWN;
+               t.at<float>(i,j) = -t.at<float>(i,j);
+            }
+         }
+      }
+   }
+}
+
+template <typename data_type>
+static void
+icvTeleaInpaintFMM(Mat &f, Mat &t, Mat &out, int range, CvPriorityQueueFloat *Heap ) {
+   int i = 0, j = 0, ii = 0, jj = 0, k, l, q, color = 0;
+   float dist;
+
+   if (out.channels()==3) {
+      typedef Vec<uchar, 3> PixelT;
+
+      while (Heap->Pop(&ii,&jj)) {
+
+         f.at<uchar>(ii,jj) = KNOWN;
+         for(q=0; q<4; q++) {
+            if     (q==0) {i=ii-1; j=jj;}
+            else if(q==1) {i=ii;   j=jj-1;}
+            else if(q==2) {i=ii+1; j=jj;}
+            else if(q==3) {i=ii;   j=jj+1;}
+            if ((i<=0)||(j<=0)||(i>t.rows-1)||(j>t.cols-1)) continue;
+
+            if (f.at<uchar>(i,j)==INSIDE) {
+               dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
+                           FastMarching_solve(i+1,j,i,j-1,f,t),
+                           FastMarching_solve(i-1,j,i,j+1,f,t),
+                           FastMarching_solve(i+1,j,i,j+1,f,t));
+               t.at<float>(i,j) = dist;
+
+               cv::Point2f gradT[3];
+               for (color=0; color<=2; color++) {
+                  if (f.at<uchar>(i,j+1)!=INSIDE) {
+                     if (f.at<uchar>(i,j-1)!=INSIDE) {
+                        gradT[color].x=(float)((t.at<float>(i,j+1)-t.at<float>(i,j-1)))*0.5f;
+                     } else {
+                        gradT[color].x=(float)((t.at<float>(i,j+1)-t.at<float>(i,j)));
+                     }
+                  } else {
+                     if (f.at<uchar>(i,j-1)!=INSIDE) {
+                        gradT[color].x=(float)((t.at<float>(i,j)-t.at<float>(i,j-1)));
+                     } else {
+                        gradT[color].x=0;
+                     }
+                  }
+                  if (f.at<uchar>(i+1,j)!=INSIDE) {
+                     if (f.at<uchar>(i-1,j)!=INSIDE) {
+                        gradT[color].y=(float)((t.at<float>(i+1,j)-t.at<float>(i-1,j)))*0.5f;
+                     } else {
+                        gradT[color].y=(float)((t.at<float>(i+1,j)-t.at<float>(i,j)));
+                     }
+                  } else {
+                     if (f.at<uchar>(i-1,j)!=INSIDE) {
+                        gradT[color].y=(float)((t.at<float>(i,j)-t.at<float>(i-1,j)));
+                     } else {
+                        gradT[color].y=0;
+                     }
+                  }
+               }
+
+               cv::Point2f gradI,r;
+               float Jx[3] = {0,0,0};
+               float Jy[3] = {0,0,0};
+               float Ia[3] = {0,0,0};
+               float s[3] = {1.0e-20f,1.0e-20f,1.0e-20f};
+               float w,dst,lev,dir,sat;
+
+               for (k=i-range; k<=i+range; k++) {
+                  int km=k-1+(k==1),kp=k-1-(k==t.rows-2);
+                  for (l=j-range; l<=j+range; l++) {
+                     int lm=l-1+(l==1),lp=l-1-(l==t.cols-2);
+                     if (k>0&&l>0&&k<t.rows-1&&l<t.cols-1) {
+                        if ((f.at<uchar>(k,l)!=INSIDE)&&
+                            ((l-j)*(l-j)+(k-i)*(k-i)<=range*range)) {
+                           for (color=0; color<=2; color++) {
+                              r.y     = (float)(i-k);
+                              r.x     = (float)(j-l);
+
+                              dst = (float)(1./(VectorLength(r)*sqrt((double)VectorLength(r))));
+                              lev = (float)(1./(1+fabs(t.at<float>(k,l)-t.at<float>(i,j))));
+
+                              dir=VectorScalMult(r,gradT[color]);
+                              if (fabs(dir)<=0.01) dir=0.000001f;
+                              w = (float)fabs(dst*lev*dir);
+
+                              if (f.at<uchar>(k,l+1)!=INSIDE) {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.x=(float)((out.at<PixelT>(km,lp+1)[color]-out.at<PixelT>(km,lm-1)[color]))*2.0f;
+                                 } else {
+                                    gradI.x=(float)((out.at<PixelT>(km,lp+1)[color]-out.at<PixelT>(km,lm)[color]));
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.x=(float)((out.at<PixelT>(km,lp)[color]-out.at<PixelT>(km,lm-1)[color]));
+                                 } else {
+                                    gradI.x=0;
+                                 }
+                              }
+                              if (f.at<uchar>(k+1,l)!=INSIDE) {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.y=(float)((out.at<PixelT>(kp+1,lm)[color]-out.at<PixelT>(km-1,lm)[color]))*2.0f;
+                                 } else {
+                                    gradI.y=(float)((out.at<PixelT>(kp+1,lm)[color]-out.at<PixelT>(km,lm)[color]));
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.y=(float)((out.at<PixelT>(kp,lm)[color]-out.at<PixelT>(km-1,lm)[color]));
+                                 } else {
+                                    gradI.y=0;
+                                 }
+                              }
+                              Ia[color] += (float)w * (float)(out.at<PixelT>(k-1,l-1)[color]);
+                              Jx[color] -= (float)w * (float)(gradI.x*r.x);
+                              Jy[color] -= (float)w * (float)(gradI.y*r.y);
+                              s[color]  += w;
+                           }
+                        }
+                     }
+                  }
+               }
+               for (color=0; color<=2; color++) {
+                  sat = (float)(Ia[color]/s[color]+(Jx[color]+Jy[color])/(sqrt(Jx[color]*Jx[color]+Jy[color]*Jy[color])+1.0e-20f));
+                  out.at<PixelT>(i-1,j-1)[color] = round_cast<uchar>(sat);
+               }
+
+               f.at<uchar>(i,j) = BAND;
+               Heap->Push(i,j,dist);
+            }
+         }
+      }
+
+   } else if (out.channels()==1) {
+
+      while (Heap->Pop(&ii,&jj)) {
+
+         f.at<uchar>(ii,jj) = KNOWN;
+         for(q=0; q<4; q++) {
+            if     (q==0) {i=ii-1; j=jj;}
+            else if(q==1) {i=ii;   j=jj-1;}
+            else if(q==2) {i=ii+1; j=jj;}
+            else if(q==3) {i=ii;   j=jj+1;}
+            if ((i<=0)||(j<=0)||(i>t.rows-1)||(j>t.cols-1)) continue;
+
+            if (f.at<uchar>(i,j)==INSIDE) {
+               dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
+                           FastMarching_solve(i+1,j,i,j-1,f,t),
+                           FastMarching_solve(i-1,j,i,j+1,f,t),
+                           FastMarching_solve(i+1,j,i,j+1,f,t));
+               t.at<float>(i,j) = dist;
+
+               for (color=0; color<=0; color++) {
+                  cv::Point2f gradI,gradT,r;
+                  float Ia=0,Jx=0,Jy=0,s=1.0e-20f,w,dst,lev,dir,sat;
+
+                  if (f.at<uchar>(i,j+1)!=INSIDE) {
+                     if (f.at<uchar>(i,j-1)!=INSIDE) {
+                        gradT.x=(float)((t.at<float>(i,j+1)-t.at<float>(i,j-1)))*0.5f;
+                     } else {
+                        gradT.x=(float)((t.at<float>(i,j+1)-t.at<float>(i,j)));
+                     }
+                  } else {
+                     if (f.at<uchar>(i,j-1)!=INSIDE) {
+                        gradT.x=(float)((t.at<float>(i,j)-t.at<float>(i,j-1)));
+                     } else {
+                        gradT.x=0;
+                     }
+                  }
+                  if (f.at<uchar>(i+1,j)!=INSIDE) {
+                     if (f.at<uchar>(i-1,j)!=INSIDE) {
+                        gradT.y=(float)((t.at<float>(i+1,j)-t.at<float>(i-1,j)))*0.5f;
+                     } else {
+                        gradT.y=(float)((t.at<float>(i+1,j)-t.at<float>(i,j)));
+                     }
+                  } else {
+                     if (f.at<uchar>(i-1,j)!=INSIDE) {
+                        gradT.y=(float)((t.at<float>(i,j)-t.at<float>(i-1,j)));
+                     } else {
+                        gradT.y=0;
+                     }
+                  }
+                  for (k=i-range; k<=i+range; k++) {
+                     int km=k-1+(k==1),kp=k-1-(k==t.rows-2);
+                     for (l=j-range; l<=j+range; l++) {
+                        int lm=l-1+(l==1),lp=l-1-(l==t.cols-2);
+                        if (k>0&&l>0&&k<t.rows-1&&l<t.cols-1) {
+                           if ((f.at<uchar>(k,l)!=INSIDE)&&
+                               ((l-j)*(l-j)+(k-i)*(k-i)<=range*range)) {
+                              r.y     = (float)(i-k);
+                              r.x     = (float)(j-l);
+
+                              dst = (float)(1./(VectorLength(r)*sqrt(VectorLength(r))));
+                              lev = (float)(1./(1+fabs(t.at<float>(k,l)-t.at<float>(i,j))));
+
+                              dir=VectorScalMult(r,gradT);
+                              if (fabs(dir)<=0.01) dir=0.000001f;
+                              w = (float)fabs(dst*lev*dir);
+
+                              if (f.at<uchar>(k,l+1)!=INSIDE) {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.x=(float)((out.at<data_type>(km,lp+1)-out.at<data_type>(km,lm-1)))*2.0f;
+                                 } else {
+                                    gradI.x=(float)((out.at<data_type>(km,lp+1)-out.at<data_type>(km,lm)));
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.x=(float)((out.at<data_type>(km,lp)-out.at<data_type>(km,lm-1)));
+                                 } else {
+                                    gradI.x=0;
+                                 }
+                              }
+                              if (f.at<uchar>(k+1,l)!=INSIDE) {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.y=(float)((out.at<data_type>(kp+1,lm)-out.at<data_type>(km-1,lm)))*2.0f;
+                                 } else {
+                                    gradI.y=(float)((out.at<data_type>(kp+1,lm)-out.at<data_type>(km,lm)));
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.y=(float)((out.at<data_type>(kp,lm)-out.at<data_type>(km-1,lm)));
+                                 } else {
+                                    gradI.y=0;
+                                 }
+                              }
+                              Ia += (float)w * (float)(out.at<data_type>(k-1,l-1));
+                              Jx -= (float)w * (float)(gradI.x*r.x);
+                              Jy -= (float)w * (float)(gradI.y*r.y);
+                              s  += w;
+                           }
+                        }
+                     }
+                  }
+                  sat = (float)(Ia/s+(Jx+Jy)/(sqrt(Jx*Jx+Jy*Jy)+1.0e-20f));
+                  {
+                  out.at<data_type>(i-1,j-1) = round_cast<data_type>(sat);
+                  }
+               }
+
+               f.at<uchar>(i,j) = BAND;
+               Heap->Push(i,j,dist);
+            }
+         }
+      }
+   }
+}
+
+template <typename data_type>
+static void
+icvNSInpaintFMM(Mat &f, Mat &t, Mat &out, int range, CvPriorityQueueFloat *Heap) {
+   int i = 0, j = 0, ii = 0, jj = 0, k, l, q, color = 0;
+   float dist;
+
+   if (out.channels()==3) {
+      typedef Vec<uchar, 3> PixelT;
+
+      while (Heap->Pop(&ii,&jj)) {
+
+         f.at<uchar>(ii,jj) = KNOWN;
+         for(q=0; q<4; q++) {
+            if     (q==0) {i=ii-1; j=jj;}
+            else if(q==1) {i=ii;   j=jj-1;}
+            else if(q==2) {i=ii+1; j=jj;}
+            else if(q==3) {i=ii;   j=jj+1;}
+            if ((i<=0)||(j<=0)||(i>t.rows-1)||(j>t.cols-1)) continue;
+
+            if (f.at<uchar>(i,j)==INSIDE) {
+               dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
+                           FastMarching_solve(i+1,j,i,j-1,f,t),
+                           FastMarching_solve(i-1,j,i,j+1,f,t),
+                           FastMarching_solve(i+1,j,i,j+1,f,t));
+               t.at<float>(i,j) = dist;
+
+               cv::Point2f gradI,r;
+               float Ia[3]={0,0,0};
+               float s[3]={1.0e-20f,1.0e-20f,1.0e-20f};
+               float w,dst,dir;
+
+               for (k=i-range; k<=i+range; k++) {
+                  int km=k-1+(k==1),kp=k-1-(k==f.rows-2);
+                  for (l=j-range; l<=j+range; l++) {
+                     int lm=l-1+(l==1),lp=l-1-(l==f.cols-2);
+                     if (k>0&&l>0&&k<f.rows-1&&l<f.cols-1) {
+                        if ((f.at<uchar>(k,l)!=INSIDE)&&
+                            ((l-j)*(l-j)+(k-i)*(k-i)<=range*range)) {
+                           for (color=0; color<=2; color++) {
+                              r.y=(float)(k-i);
+                              r.x=(float)(l-j);
+
+                              dst = 1/(VectorLength(r)*VectorLength(r)+1);
+
+                              if (f.at<uchar>(k+1,l)!=INSIDE) {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.x=(float)(abs(out.at<PixelT>(kp+1,lm)[color]-out.at<PixelT>(kp,lm)[color])+
+                                                    abs(out.at<PixelT>(kp,lm)[color]-out.at<PixelT>(km-1,lm)[color]));
+                                 } else {
+                                    gradI.x=(float)(abs(out.at<PixelT>(kp+1,lm)[color]-out.at<PixelT>(kp,lm)[color]))*2.0f;
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.x=(float)(abs(out.at<PixelT>(kp,lm)[color]-out.at<PixelT>(km-1,lm)[color]))*2.0f;
+                                 } else {
+                                    gradI.x=0;
+                                 }
+                              }
+                              if (f.at<uchar>(k,l+1)!=INSIDE) {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.y=(float)(abs(out.at<PixelT>(km,lp+1)[color]-out.at<PixelT>(km,lm)[color])+
+                                                    abs(out.at<PixelT>(km,lm)[color]-out.at<PixelT>(km,lm-1)[color]));
+                                 } else {
+                                    gradI.y=(float)(abs(out.at<PixelT>(km,lp+1)[color]-out.at<PixelT>(km,lm)[color]))*2.0f;
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.y=(float)(abs(out.at<PixelT>(km,lm)[color]-out.at<PixelT>(km,lm-1)[color]))*2.0f;
+                                 } else {
+                                    gradI.y=0;
+                                 }
+                              }
+
+                              gradI.x=-gradI.x;
+                              dir=VectorScalMult(r,gradI);
+
+                              if (fabs(dir)<=0.01) {
+                                 dir=0.000001f;
+                              } else {
+                                 dir = (float)fabs(VectorScalMult(r,gradI)/sqrt(VectorLength(r)*VectorLength(gradI)));
+                              }
+                              w = dst*dir;
+                              Ia[color] += (float)w * (float)(out.at<PixelT>(k-1,l-1)[color]);
+                              s[color]  += w;
+                           }
+                        }
+                     }
+                  }
+               }
+               for (color=0; color<=2; color++) {
+                  out.at<PixelT>(i-1,j-1)[color] = cv::saturate_cast<uchar>((double)Ia[color]/s[color]);
+               }
+
+               f.at<uchar>(i,j) = BAND;
+               Heap->Push(i,j,dist);
+            }
+         }
+      }
+
+   } else if (out.channels()==1) {
+
+      while (Heap->Pop(&ii,&jj)) {
+
+         f.at<uchar>(ii,jj) = KNOWN;
+         for(q=0; q<4; q++) {
+            if     (q==0) {i=ii-1; j=jj;}
+            else if(q==1) {i=ii;   j=jj-1;}
+            else if(q==2) {i=ii+1; j=jj;}
+            else if(q==3) {i=ii;   j=jj+1;}
+            if ((i<=0)||(j<=0)||(i>t.rows-1)||(j>t.cols-1)) continue;
+
+            if (f.at<uchar>(i,j)==INSIDE) {
+               dist = min4(FastMarching_solve(i-1,j,i,j-1,f,t),
+                           FastMarching_solve(i+1,j,i,j-1,f,t),
+                           FastMarching_solve(i-1,j,i,j+1,f,t),
+                           FastMarching_solve(i+1,j,i,j+1,f,t));
+               t.at<float>(i,j) = dist;
+
+               {
+                  cv::Point2f gradI,r;
+                  float Ia=0,s=1.0e-20f,w,dst,dir;
+
+                  for (k=i-range; k<=i+range; k++) {
+                     int km=k-1+(k==1),kp=k-1-(k==t.rows-2);
+                     for (l=j-range; l<=j+range; l++) {
+                        int lm=l-1+(l==1),lp=l-1-(l==t.cols-2);
+                        if (k>0&&l>0&&k<t.rows-1&&l<t.cols-1) {
+                           if ((f.at<uchar>(k,l)!=INSIDE)&&
+                               ((l-j)*(l-j)+(k-i)*(k-i)<=range*range)) {
+                              r.y=(float)(i-k);
+                              r.x=(float)(j-l);
+
+                              dst = 1/(VectorLength(r)*VectorLength(r)+1);
+
+                              if (f.at<uchar>(k+1,l)!=INSIDE) {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.x=(float)(std::abs(out.at<data_type>(kp+1,lm)-out.at<data_type>(kp,lm))+
+                                                    std::abs(out.at<data_type>(kp,lm)-out.at<data_type>(km-1,lm)));
+                                 } else {
+                                    gradI.x=(float)(std::abs(out.at<data_type>(kp+1,lm)-out.at<data_type>(kp,lm)))*2.0f;
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k-1,l)!=INSIDE) {
+                                    gradI.x=(float)(std::abs(out.at<data_type>(kp,lm)-out.at<data_type>(km-1,lm)))*2.0f;
+                                 } else {
+                                    gradI.x=0;
+                                 }
+                              }
+                              if (f.at<uchar>(k,l+1)!=INSIDE) {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.y=(float)(std::abs(out.at<data_type>(km,lp+1)-out.at<data_type>(km,lm))+
+                                                    std::abs(out.at<data_type>(km,lm)-out.at<data_type>(km,lm-1)));
+                                 } else {
+                                    gradI.y=(float)(std::abs(out.at<data_type>(km,lp+1)-out.at<data_type>(km,lm)))*2.0f;
+                                 }
+                              } else {
+                                 if (f.at<uchar>(k,l-1)!=INSIDE) {
+                                    gradI.y=(float)(std::abs(out.at<data_type>(km,lm)-out.at<data_type>(km,lm-1)))*2.0f;
+                                 } else {
+                                    gradI.y=0;
+                                 }
+                              }
+
+                              gradI.x=-gradI.x;
+                              dir=VectorScalMult(r,gradI);
+
+                              if (fabs(dir)<=0.01) {
+                                 dir=0.000001f;
+                              } else {
+                                 dir = (float)fabs(VectorScalMult(r,gradI)/sqrt(VectorLength(r)*VectorLength(gradI)));
+                              }
+                              w = dst*dir;
+                              Ia += (float)w * (float)(out.at<data_type>(k-1,l-1));
+                              s  += w;
+                           }
+                        }
+                     }
+                  }
+                  out.at<data_type>(i-1,j-1) = cv::saturate_cast<data_type>((double)Ia/s);
+               }
+
+               f.at<uchar>(i,j) = BAND;
+               Heap->Push(i,j,dist);
+            }
+         }
+      }
+
+   }
+}
+
+#define SET_BORDER1_C1(image,type,value) {\
+      int i,j;\
+      for(j=0; j<image.cols; j++) {\
+         image.at<type>(0,j) = value;\
+      }\
+      for (i=1; i<image.rows-1; i++) {\
+         image.at<type>(i,0) = image.at<type>(i,image.cols-1) = value;\
+      }\
+      for(j=0; j<image.cols; j++) {\
+         image.at<type>(erows-1,j) = value;\
+      }\
+   }
+
+#define COPY_MASK_BORDER1_C1(src,dst,type) {\
+      int i,j;\
+      for (i=0; i<src.rows; i++) {\
+         for(j=0; j<src.cols; j++) {\
+            if (src.at<type>(i,j)!=0)\
+               dst.at<type>(i+1,j+1) = INSIDE;\
+         }\
+      }\
+   }
+
+static void
+icvInpaint( const Mat &input_img, const Mat &inpaint_mask, Mat &output_img,
+           double inpaintRange, int flags )
+{
+    cv::Mat mask, band, f, t, out;
+    cv::Ptr<CvPriorityQueueFloat> Heap, Out;
+    cv::Mat el_range, el_cross; // structuring elements for dilate
+
+    int range=cvRound(inpaintRange);
+    int erows, ecols;
+
+    if((input_img.size() != output_img.size()) || (input_img.size() != inpaint_mask.size()))
+        CV_Error( cv::Error::StsUnmatchedSizes, "All the input and output images must have the same size" );
+
+    if( (input_img.type() != CV_8U &&
+         input_img.type() != CV_16U &&
+         input_img.type() != CV_32F &&
+        input_img.type() != CV_8UC3) ||
+        (input_img.type() != output_img.type()) )
+        CV_Error( cv::Error::StsUnsupportedFormat,
+        "8-bit, 16-bit unsigned or 32-bit float 1-channel and 8-bit 3-channel input/output images are supported" );
+
+    if( inpaint_mask.type() != CV_8UC1 )
+        CV_Error( cv::Error::StsUnsupportedFormat, "The mask must be 8-bit 1-channel image" );
+
+    range = MAX(range,1);
+    range = MIN(range,100);
+
+    ecols = input_img.cols + 2;
+    erows = input_img.rows + 2;
+
+    f.create(erows, ecols, CV_8UC1);
+    t.create(erows, ecols, CV_32FC1);
+    band.create(erows, ecols, CV_8UC1);
+    mask.create(erows, ecols, CV_8UC1);
+    el_cross = cv::getStructuringElement(cv::MORPH_CROSS, cv::Size(3, 3), cv::Point(1, 1));
+
+    input_img.copyTo( output_img );
+    mask.setTo(Scalar(KNOWN,0,0,0));
+    COPY_MASK_BORDER1_C1(inpaint_mask,mask,uchar);
+    SET_BORDER1_C1(mask,uchar,0);
+    f.setTo(Scalar(KNOWN,0,0,0));
+    t.setTo(Scalar(1.0e6f,0,0,0));
+    cv::dilate(mask, band, el_cross, cv::Point(1, 1));
+    Heap=cv::makePtr<CvPriorityQueueFloat>();
+    subtract(band, mask, band);
+    SET_BORDER1_C1(band,uchar,0);
+    if (!Heap->Add(band))
+        return;
+
+    f.setTo(Scalar(BAND,0,0,0),band);
+    f.setTo(Scalar(INSIDE,0,0,0),mask);
+    t.setTo(Scalar(0,0,0,0),band);
+
+    if( flags == cv::INPAINT_TELEA )
+    {
+        out.create(erows, ecols, CV_8UC1);
+        el_range = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2 * range + 1, 2 * range + 1));
+        cv::dilate(mask, out, el_range);
+        subtract(out, mask, out);
+        Out=cv::makePtr<CvPriorityQueueFloat>();
+        if (!Out->Add(band))
+            return;
+        subtract(out, band, out);
+        SET_BORDER1_C1(out,uchar,0);
+        icvCalcFMM(out,t,Out,true);
+        switch(output_img.depth())
+        {
+            case CV_8U:
+                icvTeleaInpaintFMM<uchar>(mask,t,output_img,range,Heap);
+                break;
+            case CV_16U:
+                icvTeleaInpaintFMM<ushort>(mask,t,output_img,range,Heap);
+                break;
+            case CV_32F:
+                icvTeleaInpaintFMM<float>(mask,t,output_img,range,Heap);
+                break;
+            default:
+                CV_Error( cv::Error::StsBadArg, "Unsupportedformat of the input image" );
+        }
+    }
+    else if (flags == cv::INPAINT_NS) {
+        switch(output_img.depth())
+        {
+            case CV_8U:
+                icvNSInpaintFMM<uchar>(mask,t,output_img,range,Heap);
+                break;
+            case CV_16U:
+                icvNSInpaintFMM<ushort>(mask,t,output_img,range,Heap);
+                break;
+            case CV_32F:
+                icvNSInpaintFMM<float>(mask,t,output_img,range,Heap);
+                break;
+            default:
+                CV_Error( cv::Error::StsBadArg, "Unsupported format of the input image" );
+        }
+    } else {
+        CV_Error( cv::Error::StsBadArg, "The flags argument must be one of INPAINT_TELEA or INPAINT_NS" );
+    }
+}
+
+void cv::inpaint( InputArray _src, InputArray _mask, OutputArray _dst,
+                  double inpaintRange, int flags )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat src = _src.getMat(), mask = _mask.getMat();
+    _dst.create( src.size(), src.type() );
+    Mat dst = _dst.getMat();
+    icvInpaint( src, mask, dst, inpaintRange, flags );
+}
diff --git a/upstream/opencv/modules/photo/src/intelligent_scissors.cpp b/upstream/opencv/modules/photo/src/intelligent_scissors.cpp
new file mode 100644
index 0000000..2007575
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/intelligent_scissors.cpp
@@ -0,0 +1,793 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2020, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+
+#include "precomp.hpp"
+//#include "opencv2/imgproc/segmentation.hpp"
+
+#include <opencv2/core/utils/logger.hpp>
+
+#include <queue>  // std::priority_queue
+
+namespace cv {
+namespace segmentation {
+
+namespace {
+
+// 0 1 2
+// 3 x 4
+// 5 6 7
+static const int neighbors[8][2] = {
+    { -1, -1 },
+    {  0, -1 },
+    {  1, -1 },
+    { -1,  0 },
+    {  1,  0 },
+    { -1,  1 },
+    {  0,  1 },
+    {  1,  1 },
+};
+
+// encoded reverse direction
+static const int neighbors_encode[8] = {
+    7+1, 6+1, 5+1,
+    4+1,      3+1,
+    2+1, 1+1, 0+1
+};
+
+#define ACOS_TABLE_SIZE 64
+// acos_table[x + ACOS_TABLE_SIZE] = acos(x / ACOS_TABLE_SIZE) / CV_PI (see add_local_cost)
+//    x = [ -ACOS_TABLE_SIZE .. ACOS_TABLE_SIZE ]
+float* getAcosTable()
+{
+    constexpr int N = ACOS_TABLE_SIZE;
+    static bool initialized = false;
+    static float acos_table[2*N + 1] = { 0 };
+    if (!initialized)
+    {
+        const float CV_PI_inv = static_cast<float>(1.0 / CV_PI);
+        for (int i = -N; i <= N; i++)
+        {
+           acos_table[i + N] = acosf(i / (float)N) * CV_PI_inv;
+        }
+        initialized = true;
+    }
+    return acos_table;
+}
+
+} // namespace anon
+
+struct IntelligentScissorsMB::Impl
+{
+    // proposed weights from the article (sum = 1.0)
+    float weight_non_edge = 0.43f;
+    float weight_gradient_direction = 0.43f;
+    float weight_gradient_magnitude = 0.14f;
+
+    enum EdgeFeatureMode {
+        FEATURE_ZERO_CROSSING = 0,
+        FEATURE_CANNY
+    };
+    EdgeFeatureMode edge_mode = FEATURE_ZERO_CROSSING;
+
+    // FEATURE_ZERO_CROSSING
+    float edge_gradient_magnitude_min_value = 0.0f;
+
+    // FEATURE_CANNY
+    double edge_canny_threshold1 = 10;
+    double edge_canny_threshold2 = 100;
+    int edge_canny_apertureSize = 3;
+    bool edge_canny_L2gradient = false;
+
+
+    float gradient_magnitude_threshold_max = 0.0f;  // disabled thresholding
+
+    int sobelKernelSize = 3;  // 1 or 3
+    int laplacianKernelSize = 3;  // 1 or 3
+
+    // image features
+    Mat_<Point2f> gradient_direction;  ///< I: normalized laplacian x/y components
+    Mat_<float> gradient_magnitude;  ///< Fg: gradient cost function
+    Mat_<uchar> non_edge_feature;  ///< Fz: zero-crossing function
+
+    float weight_non_edge_compute = 0.0f;
+
+    // encoded paths map (produced by `buildMap()`)
+    Mat_<uchar> optimalPathsMap;
+
+    void resetFeatures_()
+    {
+        CV_TRACE_FUNCTION();
+
+        gradient_direction.release();
+        gradient_magnitude.release();
+        non_edge_feature.release();
+
+        weight_non_edge_compute = weight_non_edge;
+
+        optimalPathsMap.release();
+    }
+
+    Size src_size;
+    Mat image_;
+    Mat grayscale_;
+    void initImage_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+        if (!image_.empty())
+            return;
+        CV_CheckType(image.type(), image.type() == CV_8UC1 || image.type() == CV_8UC3 || image.type() == CV_8UC4, "");
+        src_size = image.size();
+        image_ = image.getMat();
+    }
+    void initGrayscale_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+        if (!grayscale_.empty())
+            return;
+        CV_Assert(!image.empty());
+        CV_CheckType(image.type(), image.type() == CV_8UC1 || image.type() == CV_8UC3 || image.type() == CV_8UC4, "");
+        src_size = image.size();
+        if (image.channels() > 1)
+            cvtColor(image, grayscale_, COLOR_BGR2GRAY);
+        else
+            grayscale_ = image.getMat();
+    }
+    Mat Ix_, Iy_;
+    void initImageDerives_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+        if (!Ix_.empty())
+            return;
+        initGrayscale_(image);
+        Sobel(grayscale_, Ix_, CV_32FC1, 1, 0, sobelKernelSize);
+        Sobel(grayscale_, Iy_, CV_32FC1, 0, 1, sobelKernelSize);
+    }
+    Mat image_magnitude_;
+    void initImageMagnitude_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+        if (!image_magnitude_.empty())
+            return;
+        initImageDerives_(image);
+        magnitude(Ix_, Iy_, image_magnitude_);
+    }
+
+    void cleanupFeaturesTemporaryArrays_()
+    {
+        CV_TRACE_FUNCTION();
+        image_.release();
+        grayscale_.release();
+        Ix_.release();
+        Iy_.release();
+        image_magnitude_.release();
+    }
+
+    Impl()
+    {
+        // nothing
+        CV_TRACE_FUNCTION();
+    }
+
+    void setWeights(float weight_non_edge_, float weight_gradient_direction_, float weight_gradient_magnitude_)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_CheckGE(weight_non_edge_, 0.0f, "");
+        CV_CheckGE(weight_gradient_direction_, 0.0f, "");
+        CV_CheckGE(weight_gradient_magnitude_, 0.0f, "");
+        CV_CheckGE(weight_non_edge_ + weight_gradient_direction_ + weight_gradient_magnitude_, FLT_EPSILON, "Sum of weights must be greater than zero");
+        weight_non_edge = weight_non_edge_;
+        weight_gradient_direction = weight_gradient_direction_;
+        weight_gradient_magnitude = weight_gradient_magnitude_;
+        resetFeatures_();
+    }
+
+    void setGradientMagnitudeMaxLimit(float gradient_magnitude_threshold_max_)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_CheckGE(gradient_magnitude_threshold_max_, 0.0f, "");
+        gradient_magnitude_threshold_max = gradient_magnitude_threshold_max_;
+        resetFeatures_();
+    }
+
+    void setEdgeFeatureZeroCrossingParameters(float gradient_magnitude_min_value_)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_CheckGE(gradient_magnitude_min_value_, 0.0f, "");
+        edge_mode = FEATURE_ZERO_CROSSING;
+        edge_gradient_magnitude_min_value = gradient_magnitude_min_value_;
+        resetFeatures_();
+    }
+
+    void setEdgeFeatureCannyParameters(
+            double threshold1, double threshold2,
+            int apertureSize = 3, bool L2gradient = false
+    )
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_CheckGE(threshold1, 0.0, "");
+        CV_CheckGE(threshold2, 0.0, "");
+        edge_mode = FEATURE_CANNY;
+        edge_canny_threshold1 = threshold1;
+        edge_canny_threshold2 = threshold2;
+        edge_canny_apertureSize = apertureSize;
+        edge_canny_L2gradient = L2gradient;
+        resetFeatures_();
+    }
+
+    void applyImageFeatures(
+            InputArray non_edge, InputArray gradient_direction_, InputArray gradient_magnitude_,
+            InputArray image
+    )
+    {
+        CV_TRACE_FUNCTION();
+
+        resetFeatures_();
+        cleanupFeaturesTemporaryArrays_();
+
+        src_size = Size(0, 0);
+        if (!non_edge.empty())
+            src_size = non_edge.size();
+        if (!gradient_direction_.empty())
+        {
+            Size gradient_direction_size = gradient_direction_.size();
+            if (!src_size.empty())
+                CV_CheckEQ(src_size, gradient_direction_size, "");
+            else
+                src_size = gradient_direction_size;
+        }
+        if (!gradient_magnitude_.empty())
+        {
+            Size gradient_magnitude_size = gradient_magnitude_.size();
+            if (!src_size.empty())
+                CV_CheckEQ(src_size, gradient_magnitude_size, "");
+            else
+                src_size = gradient_magnitude_size;
+        }
+        if (!image.empty())
+        {
+            Size image_size = image.size();
+            if (!src_size.empty())
+                CV_CheckEQ(src_size, image_size, "");
+            else
+                src_size = image_size;
+        }
+        // src_size must be filled
+        CV_Assert(!src_size.empty());
+
+        if (!non_edge.empty())
+        {
+            CV_CheckTypeEQ(non_edge.type(), CV_8UC1, "");
+            non_edge_feature = non_edge.getMat();
+        }
+        else
+        {
+            if (weight_non_edge == 0.0f)
+            {
+                non_edge_feature.create(src_size);
+                non_edge_feature.setTo(0);
+            }
+            else
+            {
+                if (image.empty())
+                    CV_Error(Error::StsBadArg, "Non-edge feature parameter is missing. Input image parameter is required to extract this feature");
+                extractEdgeFeature_(image);
+            }
+        }
+
+        if (!gradient_direction_.empty())
+        {
+            CV_CheckTypeEQ(gradient_direction_.type(), CV_32FC2, "");
+            gradient_direction = gradient_direction_.getMat();
+        }
+        else
+        {
+            if (weight_gradient_direction == 0.0f)
+            {
+                gradient_direction.create(src_size);
+                gradient_direction.setTo(Scalar::all(0));
+            }
+            else
+            {
+                if (image.empty())
+                    CV_Error(Error::StsBadArg, "Gradient direction feature parameter is missing. Input image parameter is required to extract this feature");
+                extractGradientDirection_(image);
+            }
+        }
+
+        if (!gradient_magnitude_.empty())
+        {
+            CV_CheckTypeEQ(gradient_magnitude_.type(), CV_32FC1, "");
+            gradient_magnitude = gradient_magnitude_.getMat();
+        }
+        else
+        {
+            if (weight_gradient_magnitude == 0.0f)
+            {
+                gradient_magnitude.create(src_size);
+                gradient_magnitude.setTo(Scalar::all(0));
+            }
+            else
+            {
+                if (image.empty())
+                    CV_Error(Error::StsBadArg, "Gradient magnitude feature parameter is missing. Input image parameter is required to extract this feature");
+                extractGradientMagnitude_(image);
+            }
+        }
+
+        cleanupFeaturesTemporaryArrays_();
+    }
+
+
+    void extractEdgeFeature_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+
+        if (edge_mode == FEATURE_CANNY)
+        {
+            CV_LOG_DEBUG(NULL, "Canny(" << edge_canny_threshold1 << ", " << edge_canny_threshold2 << ")");
+            Mat img_canny;
+            Canny(image, img_canny, edge_canny_threshold1, edge_canny_threshold2, edge_canny_apertureSize, edge_canny_L2gradient);
+#if 0
+            threshold(img_canny, non_edge_feature, 254, 1, THRESH_BINARY_INV);
+#else
+            // Canny result values are 0 or 255
+            bitwise_not(img_canny, non_edge_feature);
+            weight_non_edge_compute = weight_non_edge * (1.0f / 255.0f);
+#endif
+        }
+        else // if (edge_mode == FEATURE_ZERO_CROSSING)
+        {
+            initGrayscale_(image);
+            Mat_<short> laplacian;
+            Laplacian(grayscale_, laplacian, CV_16S, laplacianKernelSize);
+            Mat_<uchar> zero_crossing(src_size, 1);
+
+            const size_t zstep = zero_crossing.step[0];
+            for (int y = 0; y < src_size.height - 1; y++)
+            {
+                const short* row0 = laplacian.ptr<short>(y);
+                const short* row1 = laplacian.ptr<short>(y + 1);
+                uchar* zrow0 = zero_crossing.ptr<uchar>(y);
+                //uchar* zrow1 = zero_crossing.ptr<uchar>(y + 1);
+                for (int x = 0; x < src_size.width - 1; x++)
+                {
+                    const int v = row0[x];
+                    const int neg_v = -v;
+                    //  - * 1
+                    //  2 3 4
+                    const int v1 = row0[x + 1];
+                    const int v2 = (x > 0) ? row1[x - 1] : v;
+                    const int v3 = row1[x + 0];
+                    const int v4 = row1[x + 1];
+                    if (v < 0)
+                    {
+                        if (v1 > 0)
+                        {
+                            zrow0[x + ((v1 < neg_v) ? 1 : 0)] = 0;
+                        }
+                        if (v2 > 0)
+                        {
+                            zrow0[x + ((v2 < neg_v) ? (zstep - 1) : 0)] = 0;
+                        }
+                        if (v3 > 0)
+                        {
+                            zrow0[x + ((v3 < neg_v) ? (zstep + 0) : 0)] = 0;
+                        }
+                        if (v4 > 0)
+                        {
+                            zrow0[x + ((v4 < neg_v) ? (zstep + 1) : 0)] = 0;
+                        }
+                    }
+                    else
+                    {
+                        if (v1 < 0)
+                        {
+                            zrow0[x + ((v1 > neg_v) ? 1 : 0)] = 0;
+                        }
+                        if (v2 < 0)
+                        {
+                            zrow0[x + ((v2 > neg_v) ? (zstep - 1) : 0)] = 0;
+                        }
+                        if (v3 < 0)
+                        {
+                            zrow0[x + ((v3 > neg_v) ? (zstep + 0) : 0)] = 0;
+                        }
+                        if (v4 < 0)
+                        {
+                            zrow0[x + ((v4 > neg_v) ? (zstep + 1) : 0)] = 0;
+                        }
+                    }
+                }
+            }
+
+            if (edge_gradient_magnitude_min_value > 0)
+            {
+                initImageMagnitude_(image);
+                Mat mask = image_magnitude_ < edge_gradient_magnitude_min_value;
+                zero_crossing.setTo(1, mask);  // reset low-amplitude noise
+            }
+
+            non_edge_feature = zero_crossing;
+        }
+    }
+
+
+    void extractGradientDirection_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+
+        initImageMagnitude_(image);  // calls internally: initImageDerives_(image);
+        gradient_direction.create(src_size);
+        for (int y = 0; y < src_size.height; y++)
+        {
+            const float* magnitude_row = image_magnitude_.ptr<float>(y);
+            const float* Ix_row = Ix_.ptr<float>(y);
+            const float* Iy_row = Iy_.ptr<float>(y);
+            Point2f* gradient_direction_row = gradient_direction.ptr<Point2f>(y);
+            for (int x = 0; x < src_size.width; x++)
+            {
+                const float m = magnitude_row[x];
+                if (m > FLT_EPSILON)
+                {
+                    float m_inv = 1.0f / m;
+                    gradient_direction_row[x] = Point2f(Ix_row[x] * m_inv, Iy_row[x] * m_inv);
+                }
+                else
+                {
+                    gradient_direction_row[x] = Point2f(0, 0);
+                }
+            }
+        }
+    }
+
+    void extractGradientMagnitude_(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+
+        initImageMagnitude_(image);  // calls internally: initImageDerives_(image);
+        Mat m;
+        double max_m = 0;
+        if (gradient_magnitude_threshold_max > 0)
+        {
+            threshold(image_magnitude_, m, gradient_magnitude_threshold_max, 0, THRESH_TRUNC);
+            max_m = gradient_magnitude_threshold_max;
+        }
+        else
+        {
+            m = image_magnitude_;
+            minMaxLoc(m, 0, &max_m);
+        }
+        if (max_m <= FLT_EPSILON)
+        {
+            CV_LOG_INFO(NULL, "IntelligentScissorsMB: input image gradient is almost zero")
+            gradient_magnitude.create(src_size);
+            gradient_magnitude.setTo(0);
+        }
+        else
+        {
+            m.convertTo(gradient_magnitude, CV_32F, -1.0 / max_m, 1.0);  // normalize and inverse to range 0..1
+        }
+    }
+
+    void applyImage(InputArray image)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_CheckType(image.type(), image.type() == CV_8UC1 || image.type() == CV_8UC3 || image.type() == CV_8UC4, "");
+
+        resetFeatures_();
+        cleanupFeaturesTemporaryArrays_();
+        extractEdgeFeature_(image);
+        extractGradientDirection_(image);
+        extractGradientMagnitude_(image);
+        cleanupFeaturesTemporaryArrays_();
+    }
+
+
+    // details: see section 3.1 of the article
+    const float* acos_table = getAcosTable();
+    const float sqrt2_inv = 0.7071067811865475f; // 1.0 / sqrt(2)
+
+    /** @brief Adds local_cost(p, q) to cost_p.
+     *
+     * local_cost(p, q) is computed as
+          weight_non_edge_compute * non_edge_feature.at<uchar>(q) +
+          weight_gradient_direction * fD +
+          weight_gradient_magnitude * fG
+     *
+     * @param p point p (input)
+     * @param q point q (input)
+     * @param cost_p cost for p (input/output)
+     * @param cost_q cost for q (input)
+     *
+     * @return The boolean result of the (cost_p < cost_q) comparison.
+     *
+     * @note The computed output cost_p can be partial if (cost_p < cost_q) is false.
+     */
+    bool add_local_cost(const Point& p, const Point& q, float& cost_p, const float cost_q) const
+    {
+        if ((cost_p += weight_non_edge_compute * non_edge_feature.at<uchar>(q)) < cost_q)
+        {
+            const bool isDiag = (p.x != q.x) && (p.y != q.y);
+
+            float fG = gradient_magnitude.at<float>(q);
+            if (!isDiag)
+            {
+                fG *= sqrt2_inv;
+            }
+
+            if ((cost_p += weight_gradient_magnitude * fG) < cost_q)
+            {
+
+                const Point2f diff((float)(q.x - p.x), (float)(q.y - p.y));
+
+                const Point2f Ip = gradient_direction(p);
+                const Point2f Iq = gradient_direction(q);
+
+                const Point2f Dp(Ip.y, -Ip.x);  // D(p) - 90 degrees clockwise
+                const Point2f Dq(Iq.y, -Iq.x);  // D(q) - 90 degrees clockwise
+
+                float dp = Dp.dot(diff);  // dp(p, q)
+                float dq = Dq.dot(diff);  // dq(p, q)
+                if (dp < 0)
+                {
+                    dp = -dp;  // ensure dp >= 0
+                    dq = -dq;
+                }
+
+                if (isDiag)
+                {
+                    dp *= sqrt2_inv;  // normalize length of (q - p)
+                    dq *= sqrt2_inv;  // normalize length of (q - p)
+                }
+
+#if 1
+                int dp_i = cvFloor(dp * ACOS_TABLE_SIZE);  // dp is in range 0..1
+                dp_i = std::min(ACOS_TABLE_SIZE, std::max(0, dp_i));
+                int dq_i = cvFloor(dq * ACOS_TABLE_SIZE);  // dq is in range -1..1
+                dq_i = std::min(ACOS_TABLE_SIZE, std::max(-ACOS_TABLE_SIZE, dq_i));
+                const float fD = acos_table[dp_i + ACOS_TABLE_SIZE] + acos_table[dq_i + ACOS_TABLE_SIZE];
+#else
+                const float CV_PI_inv = static_cast<float>(1.0 / CV_PI);
+                const float fD = (acosf(dp) + acosf(dq)) * CV_PI_inv;  // TODO optimize acos calls (through tables)
+#endif
+
+                cost_p += weight_gradient_direction * fD;
+            }
+        }
+        return cost_p < cost_q;
+    }
+
+    struct Pix
+    {
+        Point pt;
+        float cost;  // NOTE: do not remove cost from here through replacing by cost(pt) map access
+
+        inline bool operator > (const Pix &b) const
+        {
+            return cost > b.cost;
+        }
+    };
+
+    void buildMap(const Point& start_point)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_Assert(!src_size.empty());
+        CV_Assert(!gradient_magnitude.empty() && "Features are missing. applyImage() must be called first");
+
+        CV_CheckGE(weight_non_edge + weight_gradient_direction + weight_gradient_magnitude, FLT_EPSILON, "");
+
+#if 0  // debug
+        Rect wholeImage(0, 0, src_size.width, src_size.height);
+        Rect roi = Rect(start_point.x - 5, start_point.y - 5, 11, 11) & wholeImage;
+        std::cout << roi << std::endl;
+        std::cout << gradient_magnitude(roi) << std::endl;
+        std::cout << gradient_direction(roi) << std::endl;
+        std::cout << non_edge_feature(roi) << std::endl;
+#endif
+
+        optimalPathsMap.release();
+        optimalPathsMap.create(src_size);
+        optimalPathsMap.setTo(0);  // optimalPathsMap(start_point) = 0;
+
+        //
+        // Section 3.2
+        // Live-Wire 2-D DP graph search.
+        //
+
+        Mat_<float> cost_map(src_size, FLT_MAX);  // g(q)
+        Mat_<uchar> processed(src_size, (uchar)0);  // e(q)
+
+        // Note: std::vector is faster than std::deque
+        // TODO check std::set
+        std::priority_queue< Pix, std::vector<Pix>, std::greater<Pix> > L;
+
+        cost_map(start_point) = 0;
+        L.emplace(Pix{ start_point, 0/*cost*/ });
+
+        while (!L.empty())
+        {
+            Pix pix = L.top(); L.pop();
+            Point q = pix.pt;  // 'q' from the article
+            if (processed(q))
+                continue;  // already processed (with lower cost, see note below)
+            processed(q) = 1;
+#if 1
+            const float cost_q = pix.cost;
+#else
+            const float cost_q = cost_map(q);
+            CV_Assert(cost_q == pix.cost);
+#endif
+            for (int n = 0; n < 8; n++)  // scan neighbours
+            {
+                Point r(q.x + neighbors[n][0], q.y + neighbors[n][1]);  // 'r' from the article
+                if (r.x < 0 || r.x >= src_size.width || r.y < 0 || r.y >= src_size.height)
+                    continue;  // out of range
+
+#if !defined(__EMSCRIPTEN__)  // slower in JS
+                float& cost_r = cost_map(r);
+                if (cost_r < cost_q)
+                    continue;  // already processed
+#else
+                if (processed(r))
+                    continue;  // already processed
+
+                float& cost_r = cost_map(r);
+                CV_DbgCheckLE(cost_q, cost_r, "INTERNAL ERROR: sorted queue is corrupted");
+#endif
+
+                float cost = cost_q;
+                if (add_local_cost(q, r, cost, cost_r))
+                {
+#if 0  // avoid compiler warning
+                    if (cost_r != FLT_MAX)
+                    {
+                        // In article the point 'r' is removed from the queue L
+                        // to be re-inserted again with sorting against new optimized cost.
+                        // We can do nothing, because "new point" will be placed before in the sorted queue.
+                        // Old point will be skipped through "if (processed(q))" check above after processing of new optimal candidate.
+                        //
+                        // This approach leads to some performance impact, however it is much smaller than element removal from the sorted queue.
+                        // So, do nothing.
+                    }
+#endif
+                    cost_r = cost;
+                    L.emplace(Pix{ r, cost });
+                    optimalPathsMap(r) = (uchar)neighbors_encode[n];
+                }
+            }
+        }
+    }
+
+    void getContour(const Point& target, OutputArray contour_, bool backward)
+    {
+        CV_TRACE_FUNCTION();
+
+        CV_Assert(!optimalPathsMap.empty() && "buildMap() must be called before getContour()");
+
+        const int cols = optimalPathsMap.cols;
+        const int rows = optimalPathsMap.rows;
+
+        std::vector<Point> result; result.reserve(512);
+
+        size_t loop_check = 4096;
+        Point pt = target;
+        for (size_t i = 0; i < (size_t)rows * cols; i++)  // don't hang on invalid maps
+        {
+            CV_CheckLT(pt.x, cols, "");
+            CV_CheckLT(pt.y, rows, "");
+            result.push_back(pt);
+            int direction = (int)optimalPathsMap(pt);
+            if (direction == 0)
+                break;  // stop, start point is reached
+            CV_CheckLT(direction, 9, "Map is invalid");
+            Point next(pt.x + neighbors[direction - 1][0], pt.y + neighbors[direction - 1][1]);
+            pt = next;
+
+            if (result.size() == loop_check)  // optional sanity check of invalid maps with loops (don't eat huge amount of memory)
+            {
+                loop_check *= 4;  // next limit for loop check
+                for (const auto& pt_check : result)
+                {
+                    CV_CheckNE(pt_check, pt, "Map is invalid. Contour loop is detected");
+                }
+            }
+        }
+
+        if (backward)
+        {
+            _InputArray(result).copyTo(contour_);
+        }
+        else
+        {
+            const int N = (int)result.size();
+            const int sz[1] = { N };
+            contour_.create(1, sz, CV_32SC2);
+            Mat_<Point> contour = contour_.getMat();
+            for (int i = 0; i < N; i++)
+            {
+                contour.at<Point>(i) = result[N - (i + 1)];
+            }
+        }
+    }
+};
+
+
+
+IntelligentScissorsMB::IntelligentScissorsMB()
+    : impl(std::make_shared<Impl>())
+{
+    // nothing
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::setWeights(float weight_non_edge, float weight_gradient_direction, float weight_gradient_magnitude)
+{
+    CV_DbgAssert(impl);
+    impl->setWeights(weight_non_edge, weight_gradient_direction, weight_gradient_magnitude);
+    return *this;
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::setGradientMagnitudeMaxLimit(float gradient_magnitude_threshold_max)
+{
+    CV_DbgAssert(impl);
+    impl->setGradientMagnitudeMaxLimit(gradient_magnitude_threshold_max);
+    return *this;
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::setEdgeFeatureZeroCrossingParameters(float gradient_magnitude_min_value)
+{
+    CV_DbgAssert(impl);
+    impl->setEdgeFeatureZeroCrossingParameters(gradient_magnitude_min_value);
+    return *this;
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::setEdgeFeatureCannyParameters(
+        double threshold1, double threshold2,
+        int apertureSize, bool L2gradient
+)
+{
+    CV_DbgAssert(impl);
+    impl->setEdgeFeatureCannyParameters(threshold1, threshold2, apertureSize, L2gradient);
+    return *this;
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::applyImage(InputArray image)
+{
+    CV_DbgAssert(impl);
+    impl->applyImage(image);
+    return *this;
+}
+
+IntelligentScissorsMB& IntelligentScissorsMB::applyImageFeatures(
+        InputArray non_edge, InputArray gradient_direction, InputArray gradient_magnitude,
+        InputArray image
+)
+{
+    CV_DbgAssert(impl);
+    impl->applyImageFeatures(non_edge, gradient_direction, gradient_magnitude, image);
+    return *this;
+}
+
+void IntelligentScissorsMB::buildMap(const Point& pt)
+{
+    CV_DbgAssert(impl);
+    impl->buildMap(pt);
+}
+
+void IntelligentScissorsMB::getContour(const Point& target, OutputArray contour, bool backward) const
+{
+    CV_DbgAssert(impl);
+    impl->getContour(target, contour, backward);
+}
+
+}}  // namespace
diff --git a/upstream/opencv/modules/photo/src/merge.cpp b/upstream/opencv/modules/photo/src/merge.cpp
new file mode 100644
index 0000000..2f7868b
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/merge.cpp
@@ -0,0 +1,426 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "hdr_common.hpp"
+
+namespace cv
+{
+
+class MergeDebevecImpl CV_FINAL : public MergeDebevec
+{
+public:
+    MergeDebevecImpl() :
+        name("MergeDebevec"),
+        weights(triangleWeights())
+    {
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray _times, InputArray input_response) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        std::vector<Mat> images;
+        src.getMatVector(images);
+        Mat times = _times.getMat();
+
+        CV_Assert(images.size() == times.total());
+        checkImageDimensions(images);
+        int depth = images[0].depth();
+        CV_Assert(depth == CV_8U || depth == CV_16U || depth == CV_32F);
+
+        int channels = images[0].channels();
+        Size size = images[0].size();
+        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);
+
+        const bool use16bitLUT = (depth == CV_16U || depth == CV_32F);
+        const int lutLength = use16bitLUT ? 65536 : LDR_SIZE;
+
+        std::vector<Mat> lutImages(images.size());
+        if (depth == CV_8U || depth == CV_16U)
+        {
+            lutImages = images;
+        }
+        else
+        {
+            const double scale = static_cast<double>(lutLength - 1);
+            for (size_t i = 0; i < images.size(); ++i)
+            {
+                Mat clipped;
+                cv::max(images[i], 0.0, clipped);
+                cv::min(clipped, 1.0, clipped);
+                clipped.convertTo(lutImages[i], CV_16U, scale);
+            }
+        }
+
+        dst.create(images[0].size(), CV_32FCC);
+        Mat result = dst.getMat();
+
+        Mat response = input_response.getMat();
+
+        if(response.empty()) {
+            response = linearResponse(channels, lutLength);
+            response.at<Vec3f>(0) = response.at<Vec3f>(1);
+        }
+
+        Mat log_response;
+        log(response, log_response);
+        CV_Assert(log_response.rows == lutLength && log_response.cols == 1 &&
+                  log_response.channels() == channels);
+
+        Mat exp_values(times.clone());
+        log(exp_values, exp_values);
+
+        result = Mat::zeros(size, CV_32FCC);
+        std::vector<Mat> result_split;
+        split(result, result_split);
+        Mat weight_sum = Mat::zeros(size, CV_32F);
+
+        Mat weights_lut = use16bitLUT
+            ? triangleWeights(lutLength)
+            : weights;
+
+        for(size_t i = 0; i < images.size(); i++) {
+            std::vector<Mat> splitted;
+            split(lutImages[i], splitted);
+
+            Mat w = Mat::zeros(size, CV_32F);
+            for(int c = 0; c < channels; c++) {
+                LUT(splitted[c], weights_lut, splitted[c]);
+                w += splitted[c];
+            }
+            w /= channels;
+
+            Mat response_img;
+            LUT(lutImages[i], log_response, response_img);
+            split(response_img, splitted);
+            for(int c = 0; c < channels; c++) {
+                result_split[c] += w.mul(splitted[c] - exp_values.at<float>((int)i));
+            }
+            weight_sum += w;
+        }
+        weight_sum = 1.0f / weight_sum;
+        for(int c = 0; c < channels; c++) {
+            result_split[c] = result_split[c].mul(weight_sum);
+        }
+        merge(result_split, result);
+        exp(result, result);
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray times) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        process(src, dst, times, Mat());
+    }
+
+protected:
+    String name;
+    Mat weights;
+};
+
+Ptr<MergeDebevec> createMergeDebevec()
+{
+    return makePtr<MergeDebevecImpl>();
+}
+
+class MergeMertensImpl CV_FINAL : public MergeMertens
+{
+public:
+    MergeMertensImpl(float _wcon, float _wsat, float _wexp) :
+        name("MergeMertens"),
+        wcon(_wcon),
+        wsat(_wsat),
+        wexp(_wexp)
+    {
+    }
+
+    void process(InputArrayOfArrays src, OutputArrayOfArrays dst, InputArray, InputArray) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        process(src, dst);
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        std::vector<Mat> images;
+        src.getMatVector(images);
+        checkImageDimensions(images);
+
+        int channels = images[0].channels();
+        CV_Assert(channels == 1 || channels == 3);
+        Size size = images[0].size();
+        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);
+
+        std::vector<Mat> weights(images.size());
+        Mat weight_sum = Mat::zeros(size, CV_32F);
+        Mutex weight_sum_mutex;
+
+        parallel_for_(Range(0, static_cast<int>(images.size())), [&](const Range& range) {
+            for(int i = range.start; i < range.end; i++) {
+                Mat img, gray, contrast, saturation, wellexp;
+                std::vector<Mat> splitted(channels);
+
+                images[i].convertTo(img, CV_32F, 1.0f/255.0f);
+                if(channels == 3) {
+                    cvtColor(img, gray, COLOR_RGB2GRAY);
+                } else {
+                    img.copyTo(gray);
+                }
+                images[i] = img;
+                split(img, splitted);
+
+                Laplacian(gray, contrast, CV_32F);
+                contrast = abs(contrast);
+
+                Mat mean = Mat::zeros(size, CV_32F);
+                for(int c = 0; c < channels; c++) {
+                    mean += splitted[c];
+                }
+                mean /= channels;
+
+                saturation = Mat::zeros(size, CV_32F);
+                for(int c = 0; c < channels;  c++) {
+                    Mat deviation = splitted[c] - mean;
+                    pow(deviation, 2.0f, deviation);
+                    saturation += deviation;
+                }
+                sqrt(saturation, saturation);
+
+                wellexp = Mat::ones(size, CV_32F);
+                for(int c = 0; c < channels; c++) {
+                    Mat expo = splitted[c] - 0.5f;
+                    pow(expo, 2.0f, expo);
+                    expo = -expo / 0.08f;
+                    exp(expo, expo);
+                    wellexp = wellexp.mul(expo);
+                }
+
+                pow(contrast, wcon, contrast);
+                pow(saturation, wsat, saturation);
+                pow(wellexp, wexp, wellexp);
+
+                weights[i] = contrast;
+                if(channels == 3) {
+                    weights[i] = weights[i].mul(saturation);
+                }
+                weights[i] = weights[i].mul(wellexp) + 1e-12f;
+
+                AutoLock lock(weight_sum_mutex);
+                weight_sum += weights[i];
+            }
+        });
+
+        int maxlevel = static_cast<int>(logf(static_cast<float>(min(size.width, size.height))) / logf(2.0f));
+        std::vector<Mat> res_pyr(maxlevel + 1);
+        std::vector<Mutex> res_pyr_mutexes(maxlevel + 1);
+
+        parallel_for_(Range(0, static_cast<int>(images.size())), [&](const Range& range) {
+            for(int i = range.start; i < range.end; i++) {
+                weights[i] /= weight_sum;
+
+                std::vector<Mat> img_pyr, weight_pyr;
+                buildPyramid(images[i], img_pyr, maxlevel);
+                buildPyramid(weights[i], weight_pyr, maxlevel);
+
+                for(int lvl = 0; lvl < maxlevel; lvl++) {
+                    Mat up;
+                    pyrUp(img_pyr[lvl + 1], up, img_pyr[lvl].size());
+                    img_pyr[lvl] -= up;
+                }
+                for(int lvl = 0; lvl <= maxlevel; lvl++) {
+                    std::vector<Mat> splitted(channels);
+                    split(img_pyr[lvl], splitted);
+                    for(int c = 0; c < channels; c++) {
+                        splitted[c] = splitted[c].mul(weight_pyr[lvl]);
+                    }
+                    merge(splitted, img_pyr[lvl]);
+
+                    AutoLock lock(res_pyr_mutexes[lvl]);
+                    if(res_pyr[lvl].empty()) {
+                        res_pyr[lvl] = img_pyr[lvl];
+                    } else {
+                        res_pyr[lvl] += img_pyr[lvl];
+                    }
+                }
+            }
+        });
+        for(int lvl = maxlevel; lvl > 0; lvl--) {
+            Mat up;
+            pyrUp(res_pyr[lvl], up, res_pyr[lvl - 1].size());
+            res_pyr[lvl - 1] += up;
+        }
+        dst.create(size, CV_32FCC);
+        res_pyr[0].copyTo(dst);
+    }
+
+    float getContrastWeight() const CV_OVERRIDE { return wcon; }
+    void setContrastWeight(float val) CV_OVERRIDE { wcon = val; }
+
+    float getSaturationWeight() const CV_OVERRIDE { return wsat; }
+    void setSaturationWeight(float val) CV_OVERRIDE { wsat = val; }
+
+    float getExposureWeight() const CV_OVERRIDE { return wexp; }
+    void setExposureWeight(float val) CV_OVERRIDE { wexp = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "contrast_weight" << wcon
+           << "saturation_weight" << wsat
+           << "exposure_weight" << wexp;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        wcon = fn["contrast_weight"];
+        wsat = fn["saturation_weight"];
+        wexp = fn["exposure_weight"];
+    }
+
+protected:
+    String name;
+    float wcon, wsat, wexp;
+};
+
+Ptr<MergeMertens> createMergeMertens(float wcon, float wsat, float wexp)
+{
+    return makePtr<MergeMertensImpl>(wcon, wsat, wexp);
+}
+
+class MergeRobertsonImpl CV_FINAL : public MergeRobertson
+{
+public:
+    MergeRobertsonImpl() :
+        name("MergeRobertson"),
+        weight(RobertsonWeights())
+    {
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray _times, InputArray input_response) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        std::vector<Mat> images;
+        src.getMatVector(images);
+        Mat times = _times.getMat();
+
+        CV_Assert(images.size() == times.total());
+        checkImageDimensions(images);
+        int depth = images[0].depth();
+        CV_Assert(depth == CV_8U || depth == CV_16U || depth == CV_32F);
+
+        int channels = images[0].channels();
+        int CV_32FCC = CV_MAKETYPE(CV_32F, channels);
+
+        const bool use16bitLUT = (depth == CV_16U || depth == CV_32F);
+        const int lutLength = use16bitLUT ? 65536 : LDR_SIZE;
+
+        // Build LUT index images (see MergeDebevecImpl for details).
+        std::vector<Mat> lutImages(images.size());
+        if (depth == CV_8U || depth == CV_16U)
+        {
+            lutImages = images;
+        }
+        else // CV_32F
+        {
+            const double scale = static_cast<double>(lutLength - 1);
+            for (size_t i = 0; i < images.size(); ++i)
+            {
+                images[i].convertTo(lutImages[i], CV_16U, scale);
+            }
+        }
+
+        dst.create(images[0].size(), CV_32FCC);
+        Mat result = dst.getMat();
+
+        Mat response = input_response.getMat();
+        if(response.empty()) {
+            float middle = static_cast<float>(lutLength) / 2.0f;
+            response = linearResponse(channels, lutLength) / middle;
+        }
+        CV_Assert(response.rows == lutLength && response.cols == 1 &&
+                  response.channels() == channels);
+
+        result = Mat::zeros(images[0].size(), CV_32FCC);
+        Mat wsum = Mat::zeros(images[0].size(), CV_32FCC);
+
+        Mat weight_lut = use16bitLUT
+            ? RobertsonWeights(lutLength)
+            : weight;
+
+        for(size_t i = 0; i < images.size(); i++) {
+            Mat im, w;
+            LUT(lutImages[i], weight_lut, w);
+            LUT(lutImages[i], response, im);
+
+            result += times.at<float>((int)i) * w.mul(im);
+            wsum += times.at<float>((int)i) * times.at<float>((int)i) * w;
+        }
+        result = result.mul(1 / (wsum + Scalar::all(DBL_EPSILON)));
+    }
+
+    void process(InputArrayOfArrays src, OutputArray dst, InputArray times) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        process(src, dst, times, Mat());
+    }
+
+protected:
+    String name;
+    Mat weight;
+};
+
+Ptr<MergeRobertson> createMergeRobertson()
+{
+    return makePtr<MergeRobertsonImpl>();
+}
+
+}
diff --git a/upstream/opencv/modules/photo/src/npr.cpp b/upstream/opencv/modules/photo/src/npr.cpp
new file mode 100644
index 0000000..804a2aa
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/npr.cpp
@@ -0,0 +1,163 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <iostream>
+#include <stdlib.h>
+
+#include "npr.hpp"
+
+using namespace std;
+using namespace cv;
+
+void cv::edgePreservingFilter(InputArray _src, OutputArray dst, int flags, float sigma_s, float sigma_r)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat I = _src.getMat();
+
+    Domain_Filter obj;
+
+    Mat img;
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    Mat res;
+    obj.filter(img, res, sigma_s, sigma_r, flags);
+
+    convertScaleAbs(res, dst, 255,0);
+}
+
+void cv::detailEnhance(InputArray _src, OutputArray dst, float sigma_s, float sigma_r)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat I = _src.getMat();
+
+    float factor = 3.0f;
+
+    Mat img;
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    Mat lab;
+    vector <Mat> lab_channel;
+    cvtColor(img,lab,COLOR_BGR2Lab);
+    split(lab,lab_channel);
+
+    Mat L;
+    lab_channel[0].convertTo(L,CV_32FC1,1.0/255.0);
+
+    Domain_Filter obj;
+
+    Mat res;
+    obj.filter(L, res, sigma_s, sigma_r, 1);
+
+    Mat detail = L - res;
+    multiply(detail,factor,detail);
+    L = res + detail;
+
+    L.convertTo(lab_channel[0],CV_32FC1,255);
+
+    merge(lab_channel,lab);
+
+    cvtColor(lab,res,COLOR_Lab2BGR);
+    res.convertTo(dst,CV_8UC3,255);
+}
+
+void cv::pencilSketch(InputArray _src, OutputArray _dst1, OutputArray _dst2, float sigma_s, float sigma_r, float shade_factor)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat I = _src.getMat();
+    _dst1.create(I.size(), CV_8UC1);
+    Mat dst1 = _dst1.getMat();
+
+    _dst2.create(I.size(), CV_8UC3);
+    Mat dst2 = _dst2.getMat();
+
+    Mat img = Mat(I.size(),CV_32FC3);
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    Domain_Filter obj;
+
+    Mat sketch = Mat(I.size(),CV_32FC1);
+    Mat color_sketch = Mat(I.size(),CV_32FC3);
+
+    obj.pencil_sketch(img, sketch, color_sketch, sigma_s, sigma_r, shade_factor);
+
+    sketch.convertTo(dst1,CV_8UC1,255);
+    color_sketch.convertTo(dst2,CV_8UC3,255);
+
+}
+
+void cv::stylization(InputArray _src, OutputArray _dst, float sigma_s, float sigma_r)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat I = _src.getMat();
+    _dst.create(I.size(), CV_8UC3);
+    Mat dst = _dst.getMat();
+
+    Mat img;
+    I.convertTo(img,CV_32FC3,1.0/255.0);
+
+    int h = img.size().height;
+    int w = img.size().width;
+
+    Mat res;
+    Mat magnitude = Mat(h,w,CV_32FC1);
+
+    Domain_Filter obj;
+    obj.filter(img, res, sigma_s, sigma_r, NORMCONV_FILTER);
+
+    obj.find_magnitude(res,magnitude);
+
+    Mat stylized;
+
+    vector <Mat> temp;
+    split(res,temp);
+    multiply(temp[0],magnitude,temp[0]);
+    multiply(temp[1],magnitude,temp[1]);
+    multiply(temp[2],magnitude,temp[2]);
+    merge(temp,stylized);
+
+    stylized.convertTo(dst,CV_8UC3,255);
+}
diff --git a/upstream/opencv/modules/photo/src/npr.hpp b/upstream/opencv/modules/photo/src/npr.hpp
new file mode 100644
index 0000000..6e4bb73
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/npr.hpp
@@ -0,0 +1,591 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include <iostream>
+#include <stdlib.h>
+#include <limits>
+#include "math.h"
+
+
+using namespace std;
+using namespace cv;
+
+double myinf = std::numeric_limits<double>::infinity();
+
+class Domain_Filter
+{
+    public:
+        Mat ct_H, ct_V, horiz, vert, O, O_t, lower_idx, upper_idx;
+        void init(const Mat &img, int flags, float sigma_s, float sigma_r);
+        void getGradientx( const Mat &img, Mat &gx);
+        void getGradienty( const Mat &img, Mat &gy);
+        void diffx(const Mat &img, Mat &temp);
+        void diffy(const Mat &img, Mat &temp);
+        void find_magnitude(Mat &img, Mat &mag);
+        void compute_boxfilter(Mat &output, Mat &hz, Mat &psketch, float radius);
+        void compute_Rfilter(Mat &O, Mat &horiz, float sigma_h);
+        void compute_NCfilter(Mat &O, Mat &horiz, Mat &psketch, float radius);
+        void filter(const Mat &img, Mat &res, float sigma_s, float sigma_r, int flags);
+        void pencil_sketch(const Mat &img, Mat &sketch, Mat &color_res, float sigma_s, float sigma_r, float shade_factor);
+        void Depth_of_field(const Mat &img, Mat &img1, float sigma_s, float sigma_r);
+};
+
+void Domain_Filter::diffx(const Mat &img, Mat &temp)
+{
+    int channel = img.channels();
+
+    for(int i = 0; i < img.size().height; i++)
+        for(int j = 0; j < img.size().width-1; j++)
+        {
+            for(int c =0; c < channel; c++)
+            {
+                temp.at<float>(i,j*channel+c) =
+                    img.at<float>(i,(j+1)*channel+c) - img.at<float>(i,j*channel+c);
+            }
+        }
+}
+
+void Domain_Filter::diffy(const Mat &img, Mat &temp)
+{
+    int channel = img.channels();
+
+    for(int i = 0; i < img.size().height-1; i++)
+        for(int j = 0; j < img.size().width; j++)
+        {
+            for(int c =0; c < channel; c++)
+            {
+                temp.at<float>(i,j*channel+c) =
+                    img.at<float>((i+1),j*channel+c) - img.at<float>(i,j*channel+c);
+            }
+        }
+}
+
+void Domain_Filter::getGradientx( const Mat &img, Mat &gx)
+{
+    int w = img.cols;
+    int h = img.rows;
+    int channel = img.channels();
+
+    for(int i=0;i<h;i++)
+        for(int j=0;j<w;j++)
+            for(int c=0;c<channel;++c)
+            {
+                gx.at<float>(i,j*channel+c) =
+                    img.at<float>(i,(j+1)*channel+c) - img.at<float>(i,j*channel+c);
+            }
+}
+
+void Domain_Filter::getGradienty( const Mat &img, Mat &gy)
+{
+    int w = img.cols;
+    int h = img.rows;
+    int channel = img.channels();
+
+    for(int i=0;i<h;i++)
+        for(int j=0;j<w;j++)
+            for(int c=0;c<channel;++c)
+            {
+                gy.at<float>(i,j*channel+c) =
+                    img.at<float>(i+1,j*channel+c) - img.at<float>(i,j*channel+c);
+
+            }
+}
+
+void Domain_Filter::find_magnitude(Mat &img, Mat &mag)
+{
+    int h = img.rows;
+    int w = img.cols;
+
+    vector <Mat> planes;
+    split(img, planes);
+
+    Mat magXR = Mat(h, w, CV_32FC1);
+    Mat magYR = Mat(h, w, CV_32FC1);
+
+    Mat magXG = Mat(h, w, CV_32FC1);
+    Mat magYG = Mat(h, w, CV_32FC1);
+
+    Mat magXB = Mat(h, w, CV_32FC1);
+    Mat magYB = Mat(h, w, CV_32FC1);
+
+    Sobel(planes[0], magXR, CV_32FC1, 1, 0, 3);
+    Sobel(planes[0], magYR, CV_32FC1, 0, 1, 3);
+
+    Sobel(planes[1], magXG, CV_32FC1, 1, 0, 3);
+    Sobel(planes[1], magYG, CV_32FC1, 0, 1, 3);
+
+    Sobel(planes[2], magXB, CV_32FC1, 1, 0, 3);
+    Sobel(planes[2], magYB, CV_32FC1, 0, 1, 3);
+
+    Mat mag1 = Mat(h,w,CV_32FC1);
+    Mat mag2 = Mat(h,w,CV_32FC1);
+    Mat mag3 = Mat(h,w,CV_32FC1);
+
+    magnitude(magXR,magYR,mag1);
+    magnitude(magXG,magYG,mag2);
+    magnitude(magXB,magYB,mag3);
+
+    mag = mag1 + mag2 + mag3;
+    mag = 1.0f - mag;
+}
+
+void Domain_Filter::compute_Rfilter(Mat &output, Mat &hz, float sigma_h)
+{
+    int h = output.rows;
+    int w = output.cols;
+    int channel = output.channels();
+
+    float a = (float) exp((-1.0 * sqrt(2.0)) / sigma_h);
+
+    Mat temp = Mat(h,w,CV_32FC3);
+
+    output.copyTo(temp);
+    Mat V = Mat(h,w,CV_32FC1);
+
+    for(int i=0;i<h;i++)
+        for(int j=0;j<w;j++)
+            V.at<float>(i,j) = std::pow(a,hz.at<float>(i,j));
+
+   for(int i=0; i<h; i++)
+    {
+        for(int j =1; j < w; j++)
+        {
+            for(int c = 0; c<channel; c++)
+            {
+                temp.at<float>(i,j*channel+c) = temp.at<float>(i,j*channel+c) +
+                    (temp.at<float>(i,(j-1)*channel+c) - temp.at<float>(i,j*channel+c)) * V.at<float>(i,j);
+            }
+        }
+    }
+
+    for(int i=0; i<h; i++)
+    {
+        for(int j =w-2; j >= 0; j--)
+        {
+            for(int c = 0; c<channel; c++)
+            {
+                temp.at<float>(i,j*channel+c) = temp.at<float>(i,j*channel+c) +
+                    (temp.at<float>(i,(j+1)*channel+c) - temp.at<float>(i,j*channel+c))*V.at<float>(i,j+1);
+            }
+        }
+    }
+
+    temp.copyTo(output);
+}
+
+void Domain_Filter::compute_boxfilter(Mat &output, Mat &hz, Mat &psketch, float radius)
+{
+    int h = output.rows;
+    int w = output.cols;
+    Mat lower_pos = Mat(h,w,CV_32FC1);
+    Mat upper_pos = Mat(h,w,CV_32FC1);
+
+    lower_pos = hz - radius;
+    upper_pos = hz + radius;
+
+    lower_idx = Mat::zeros(h,w,CV_32FC1);
+    upper_idx = Mat::zeros(h,w,CV_32FC1);
+
+    Mat domain_row = Mat::zeros(1,w+1,CV_32FC1);
+
+    for(int i=0;i<h;i++)
+    {
+        for(int j=0;j<w;j++)
+            domain_row.at<float>(0,j) = hz.at<float>(i,j);
+        domain_row.at<float>(0,w) = (float) myinf;
+
+        Mat lower_pos_row = Mat::zeros(1,w,CV_32FC1);
+        Mat upper_pos_row = Mat::zeros(1,w,CV_32FC1);
+
+        for(int j=0;j<w;j++)
+        {
+            lower_pos_row.at<float>(0,j) = lower_pos.at<float>(i,j);
+            upper_pos_row.at<float>(0,j) = upper_pos.at<float>(i,j);
+        }
+
+        Mat temp_lower_idx = Mat::zeros(1,w,CV_32FC1);
+        Mat temp_upper_idx = Mat::zeros(1,w,CV_32FC1);
+
+        for(int j=0;j<w;j++)
+        {
+            if(domain_row.at<float>(0,j) > lower_pos_row.at<float>(0,0))
+            {
+                temp_lower_idx.at<float>(0,0) = (float) j;
+                break;
+            }
+        }
+        for(int j=0;j<w;j++)
+        {
+            if(domain_row.at<float>(0,j) > upper_pos_row.at<float>(0,0))
+            {
+                temp_upper_idx.at<float>(0,0) = (float) j;
+                break;
+            }
+        }
+
+        int temp = 0;
+        for(int j=1;j<w;j++)
+        {
+            int count=0;
+            for(int k=(int) temp_lower_idx.at<float>(0,j-1);k<w+1;k++)
+            {
+                if(domain_row.at<float>(0,k) > lower_pos_row.at<float>(0,j))
+                {
+                    temp = count;
+                    break;
+                }
+                count++;
+            }
+
+            temp_lower_idx.at<float>(0,j) = temp_lower_idx.at<float>(0,j-1) + temp;
+
+            count = 0;
+            for(int k=(int) temp_upper_idx.at<float>(0,j-1);k<w+1;k++)
+            {
+
+
+                if(domain_row.at<float>(0,k) > upper_pos_row.at<float>(0,j))
+                {
+                    temp = count;
+                    break;
+                }
+                count++;
+            }
+
+            temp_upper_idx.at<float>(0,j) = temp_upper_idx.at<float>(0,j-1) + temp;
+        }
+
+        for(int j=0;j<w;j++)
+        {
+            lower_idx.at<float>(i,j) = temp_lower_idx.at<float>(0,j) + 1;
+            upper_idx.at<float>(i,j) = temp_upper_idx.at<float>(0,j) + 1;
+        }
+
+    }
+    psketch = upper_idx - lower_idx;
+}
+void Domain_Filter::compute_NCfilter(Mat &output, Mat &hz, Mat &psketch, float radius)
+{
+    int h = output.rows;
+    int w = output.cols;
+    int channel = output.channels();
+
+    compute_boxfilter(output,hz,psketch,radius);
+
+    Mat box_filter = Mat::zeros(h,w+1,CV_32FC3);
+
+    for(int i = 0; i < h; i++)
+    {
+        box_filter.at<float>(i,1*channel+0) = output.at<float>(i,0*channel+0);
+        box_filter.at<float>(i,1*channel+1) = output.at<float>(i,0*channel+1);
+        box_filter.at<float>(i,1*channel+2) = output.at<float>(i,0*channel+2);
+        for(int j = 2; j < w+1; j++)
+        {
+            for(int c=0;c<channel;c++)
+                box_filter.at<float>(i,j*channel+c) = output.at<float>(i,(j-1)*channel+c) + box_filter.at<float>(i,(j-1)*channel+c);
+        }
+    }
+
+    Mat indices = Mat::zeros(h,w,CV_32FC1);
+    Mat final =   Mat::zeros(h,w,CV_32FC3);
+
+    for(int i=0;i<h;i++)
+        for(int j=0;j<w;j++)
+            indices.at<float>(i,j) = (float) i+1;
+
+    Mat a = Mat::zeros(h,w,CV_32FC1);
+    Mat b = Mat::zeros(h,w,CV_32FC1);
+
+    // Compute the box filter using a summed area table.
+    for(int c=0;c<channel;c++)
+    {
+        Mat flag = Mat::ones(h,w,CV_32FC1);
+        multiply(flag,c+1,flag);
+
+        Mat temp1, temp2;
+        multiply(flag - 1,h*(w+1),temp1);
+        multiply(lower_idx - 1,h,temp2);
+        a = temp1 + temp2 + indices;
+
+        multiply(flag - 1,h*(w+1),temp1);
+        multiply(upper_idx - 1,h,temp2);
+        b = temp1 + temp2 + indices;
+
+        int p,q,r,rem;
+        int p1,q1,r1,rem1;
+
+        // Calculating indices
+        for(int i=0;i<h;i++)
+        {
+            for(int j=0;j<w;j++)
+            {
+
+                r = (int) b.at<float>(i,j)/(h*(w+1));
+                rem = (int) b.at<float>(i,j) - r*h*(w+1);
+                q = rem/h;
+                p = rem - q*h;
+                if(q==0)
+                {
+                    p=h;
+                    q=w;
+                    r=r-1;
+                }
+                if(p==0)
+                {
+                    p=h;
+                    q=q-1;
+                }
+
+                r1 = (int) a.at<float>(i,j)/(h*(w+1));
+                rem1 = (int) a.at<float>(i,j) - r1*h*(w+1);
+                q1 = rem1/h;
+                p1 = rem1 - q1*h;
+                if(p1==0)
+                {
+                    p1=h;
+                    q1=q1-1;
+                }
+
+                final.at<float>(i,j*channel+2-c) = (box_filter.at<float>(p-1,q*channel+(2-r)) - box_filter.at<float>(p1-1,q1*channel+(2-r1)))
+                    /(upper_idx.at<float>(i,j) - lower_idx.at<float>(i,j));
+            }
+        }
+    }
+
+    final.copyTo(output);
+}
+void Domain_Filter::init(const Mat &img, int flags, float sigma_s, float sigma_r)
+{
+    int h = img.size().height;
+    int w = img.size().width;
+    int channel = img.channels();
+
+    ////////////////////////////////////     horizontal and vertical partial derivatives /////////////////////////////////
+
+    Mat derivx = Mat::zeros(h,w-1,CV_32FC3);
+    Mat derivy = Mat::zeros(h-1,w,CV_32FC3);
+
+    diffx(img,derivx);
+    diffy(img,derivy);
+
+    Mat distx = Mat::zeros(h,w,CV_32FC1);
+    Mat disty = Mat::zeros(h,w,CV_32FC1);
+
+    //////////////////////// Compute the l1-norm distance of neighbor pixels ////////////////////////////////////////////////
+
+    for(int i = 0; i < h; i++)
+        for(int j = 0,k=1; j < w-1; j++,k++)
+            for(int c = 0; c < channel; c++)
+            {
+                distx.at<float>(i,k) =
+                    distx.at<float>(i,k) + abs(derivx.at<float>(i,j*channel+c));
+            }
+
+    for(int i = 0,k=1; i < h-1; i++,k++)
+        for(int j = 0; j < w; j++)
+            for(int c = 0; c < channel; c++)
+            {
+                disty.at<float>(k,j) =
+                    disty.at<float>(k,j) + abs(derivy.at<float>(i,j*channel+c));
+            }
+
+    ////////////////////// Compute the derivatives of the horizontal and vertical domain transforms. /////////////////////////////
+
+    horiz = Mat(h,w,CV_32FC1);
+    vert = Mat(h,w,CV_32FC1);
+
+    Mat final = Mat(h,w,CV_32FC3);
+
+    Mat tempx,tempy;
+    multiply(distx,sigma_s/sigma_r,tempx);
+    multiply(disty,sigma_s/sigma_r,tempy);
+
+    horiz = 1.0f + tempx;
+    vert = 1.0f + tempy;
+
+    O = Mat(h,w,CV_32FC3);
+    img.copyTo(O);
+
+    O_t = Mat(w,h,CV_32FC3);
+
+    if(flags == 2)
+    {
+
+        ct_H = Mat(h,w,CV_32FC1);
+        ct_V = Mat(h,w,CV_32FC1);
+
+        for(int i = 0; i < h; i++)
+        {
+            ct_H.at<float>(i,0) = horiz.at<float>(i,0);
+            for(int j = 1; j < w; j++)
+            {
+                ct_H.at<float>(i,j) = horiz.at<float>(i,j) + ct_H.at<float>(i,j-1);
+            }
+        }
+
+        for(int j = 0; j < w; j++)
+        {
+            ct_V.at<float>(0,j) = vert.at<float>(0,j);
+            for(int i = 1; i < h; i++)
+            {
+                ct_V.at<float>(i,j) = vert.at<float>(i,j) + ct_V.at<float>(i-1,j);
+            }
+        }
+    }
+
+}
+
+void Domain_Filter::filter(const Mat &img, Mat &res, float sigma_s = 60, float sigma_r = 0.4, int flags = 1)
+{
+    int no_of_iter = 3;
+    int h = img.size().height;
+    int w = img.size().width;
+    float sigma_h = sigma_s;
+
+    init(img,flags,sigma_s,sigma_r);
+
+    if(flags == 1)
+    {
+        Mat vert_t = vert.t();
+
+        for(int i=0;i<no_of_iter;i++)
+        {
+            sigma_h = (float) (sigma_s * sqrt(3.0) * std::pow(2,(no_of_iter - (i+1))) / sqrt(std::pow(4,no_of_iter) -1));
+
+            compute_Rfilter(O, horiz, sigma_h);
+
+            O_t = O.t();
+
+            compute_Rfilter(O_t, vert_t, sigma_h);
+
+            O = O_t.t();
+
+        }
+    }
+    else if(flags == 2)
+    {
+
+        Mat vert_t = ct_V.t();
+        Mat temp = Mat(h,w,CV_32FC1);
+        Mat temp1 = Mat(w,h,CV_32FC1);
+
+        float radius;
+
+        for(int i=0;i<no_of_iter;i++)
+        {
+            sigma_h = (float) (sigma_s * sqrt(3.0) * std::pow(2,(no_of_iter - (i+1))) / sqrt(std::pow(4,no_of_iter) -1));
+
+            radius = (float) sqrt(3.0) * sigma_h;
+
+            compute_NCfilter(O, ct_H, temp,radius);
+
+            O_t = O.t();
+
+            compute_NCfilter(O_t, vert_t, temp1, radius);
+
+            O = O_t.t();
+        }
+    }
+
+    res = O.clone();
+}
+
+void Domain_Filter::pencil_sketch(const Mat &img, Mat &sketch, Mat &color_res, float sigma_s, float sigma_r, float shade_factor)
+{
+
+    int no_of_iter = 3;
+    init(img,2,sigma_s,sigma_r);
+    int h = img.size().height;
+    int w = img.size().width;
+
+    /////////////////////// convert to YCBCR model for color pencil drawing //////////////////////////////////////////////////////
+
+    Mat color_sketch = Mat(h,w,CV_32FC3);
+
+    cvtColor(img,color_sketch,COLOR_BGR2YCrCb);
+
+    vector <Mat> YUV_channel;
+    Mat vert_t = ct_V.t();
+
+    float sigma_h = sigma_s;
+
+    Mat penx = Mat(h,w,CV_32FC1);
+
+    Mat pen_res = Mat::zeros(h,w,CV_32FC1);
+    Mat peny = Mat(w,h,CV_32FC1);
+
+    Mat peny_t;
+
+    float radius;
+
+    for(int i=0;i<no_of_iter;i++)
+    {
+        sigma_h = (float) (sigma_s * sqrt(3.0) * std::pow(2,(no_of_iter - (i+1))) / sqrt(std::pow(4,no_of_iter) -1));
+
+        radius = (float) sqrt(3.0) * sigma_h;
+
+        compute_boxfilter(O, ct_H, penx, radius);
+
+        O_t = O.t();
+
+        compute_boxfilter(O_t, vert_t, peny, radius);
+
+        O = O_t.t();
+
+        peny_t = peny.t();
+
+        for(int k=0;k<h;k++)
+            for(int j=0;j<w;j++)
+                pen_res.at<float>(k,j) = (shade_factor * (penx.at<float>(k,j) + peny_t.at<float>(k,j)));
+
+        if(i==0)
+        {
+            sketch = pen_res.clone();
+            split(color_sketch,YUV_channel);
+            pen_res.copyTo(YUV_channel[0]);
+            merge(YUV_channel,color_sketch);
+            cvtColor(color_sketch,color_res,COLOR_YCrCb2BGR);
+        }
+
+    }
+}
diff --git a/upstream/opencv/modules/photo/src/opencl/nlmeans.cl b/upstream/opencv/modules/photo/src/opencl/nlmeans.cl
new file mode 100644
index 0000000..879665f
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/opencl/nlmeans.cl
@@ -0,0 +1,302 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#ifdef cl_amd_printf
+#pragma OPENCL_EXTENSION cl_amd_printf:enable
+#endif
+
+#ifdef DOUBLE_SUPPORT
+#ifdef cl_amd_fp64
+#pragma OPENCL EXTENSION cl_amd_fp64:enable
+#elif defined cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64:enable
+#endif
+#endif
+
+
+#ifdef OP_CALC_WEIGHTS
+
+__kernel void calcAlmostDist2Weight(__global wlut_t * almostDist2Weight, int almostMaxDist,
+                                    FT almostDist2ActualDistMultiplier, int fixedPointMult,
+                                    w_t den, FT WEIGHT_THRESHOLD)
+{
+    int almostDist = get_global_id(0);
+
+    if (almostDist < almostMaxDist)
+    {
+        FT dist = almostDist * almostDist2ActualDistMultiplier;
+#ifdef ABS
+        w_t w = exp((w_t)(-dist*dist) * den);
+#else
+        w_t w = exp((w_t)(-dist) * den);
+#endif
+        wlut_t weight = convert_wlut_t(fixedPointMult * (isnan(w) ? (w_t)1.0 : w));
+        almostDist2Weight[almostDist] =
+            weight < (wlut_t)(WEIGHT_THRESHOLD * fixedPointMult) ? (wlut_t)0 : weight;
+    }
+}
+
+#elif defined OP_CALC_FASTNLMEANS
+
+#define noconvert
+
+#define SEARCH_SIZE_SQ (SEARCH_SIZE * SEARCH_SIZE)
+
+inline int calcDist(pixel_t a, pixel_t b)
+{
+#ifdef ABS
+    int_t retval = convert_int_t(abs_diff(a, b));
+#else
+    int_t diff = convert_int_t(a) - convert_int_t(b);
+    int_t retval = diff * diff;
+#endif
+
+#if cn == 1
+    return retval;
+#elif cn == 2
+    return retval.x + retval.y;
+#elif cn == 3
+    return retval.x + retval.y + retval.z;
+#elif cn == 4
+    return retval.x + retval.y + retval.z + retval.w;
+#else
+#error "cn should be either 1, 2, 3 or 4"
+#endif
+}
+
+#ifdef ABS
+inline int calcDistUpDown(pixel_t down_value, pixel_t down_value_t, pixel_t up_value, pixel_t up_value_t)
+{
+    return calcDist(down_value, down_value_t) - calcDist(up_value, up_value_t);
+}
+#else
+inline int calcDistUpDown(pixel_t down_value, pixel_t down_value_t, pixel_t up_value, pixel_t up_value_t)
+{
+    int_t A = convert_int_t(down_value) - convert_int_t(down_value_t);
+    int_t B = convert_int_t(up_value) - convert_int_t(up_value_t);
+    int_t retval = (A - B) * (A + B);
+
+#if cn == 1
+    return retval;
+#elif cn == 2
+    return retval.x + retval.y;
+#elif cn == 3
+    return retval.x + retval.y + retval.z;
+#elif cn == 4
+    return retval.x + retval.y + retval.z + retval.w;
+#else
+#error "cn should be either 1, 2, 3 or 4"
+#endif
+}
+#endif
+
+#define COND if (x == 0 && y == 0)
+
+inline void calcFirstElementInRow(__global const uchar * src, int src_step, int src_offset,
+                                  __local int * dists, int y, int x, int id,
+                                  __global int * col_dists, __global int * up_col_dists)
+{
+    y -= TEMPLATE_SIZE2;
+    int sx = x - SEARCH_SIZE2, sy = y - SEARCH_SIZE2;
+    int col_dists_current_private[TEMPLATE_SIZE];
+
+    for (int i = id; i < SEARCH_SIZE_SQ; i += CTA_SIZE)
+    {
+        int dist = 0, value;
+
+        __global const pixel_t * src_template = (__global const pixel_t *)(src +
+            mad24(sy + i / SEARCH_SIZE, src_step, mad24(psz, sx + i % SEARCH_SIZE, src_offset)));
+        __global const pixel_t * src_current = (__global const pixel_t *)(src + mad24(y, src_step, mad24(psz, x, src_offset)));
+        __global int * col_dists_current = col_dists + i * TEMPLATE_SIZE;
+
+        #pragma unroll
+        for (int j = 0; j < TEMPLATE_SIZE; ++j)
+            col_dists_current_private[j] = 0;
+
+        for (int ty = 0; ty < TEMPLATE_SIZE; ++ty)
+        {
+            #pragma unroll
+            for (int tx = -TEMPLATE_SIZE2; tx <= TEMPLATE_SIZE2; ++tx)
+            {
+                value = calcDist(src_template[tx], src_current[tx]);
+
+                col_dists_current_private[tx + TEMPLATE_SIZE2] += value;
+                dist += value;
+            }
+
+            src_current = (__global const pixel_t *)((__global const uchar *)src_current + src_step);
+            src_template = (__global const pixel_t *)((__global const uchar *)src_template + src_step);
+        }
+
+        #pragma unroll
+        for (int j = 0; j < TEMPLATE_SIZE; ++j)
+            col_dists_current[j] = col_dists_current_private[j];
+
+        dists[i] = dist;
+        up_col_dists[0 + i] = col_dists[TEMPLATE_SIZE - 1];
+    }
+}
+
+inline void calcElementInFirstRow(__global const uchar * src, int src_step, int src_offset,
+                                  __local int * dists, int y, int x0, int x, int id, int first,
+                                  __global int * col_dists, __global int * up_col_dists)
+{
+    x += TEMPLATE_SIZE2;
+    y -= TEMPLATE_SIZE2;
+    int sx = x - SEARCH_SIZE2, sy = y - SEARCH_SIZE2;
+
+    for (int i = id; i < SEARCH_SIZE_SQ; i += CTA_SIZE)
+    {
+        __global const pixel_t * src_current = (__global const pixel_t *)(src + mad24(y, src_step, mad24(psz, x, src_offset)));
+        __global const pixel_t * src_template = (__global const pixel_t *)(src +
+            mad24(sy + i / SEARCH_SIZE, src_step, mad24(psz, sx + i % SEARCH_SIZE, src_offset)));
+        __global int * col_dists_current = col_dists + TEMPLATE_SIZE * i;
+
+        int col_dist = 0;
+
+        #pragma unroll
+        for (int ty = 0; ty < TEMPLATE_SIZE; ++ty)
+        {
+            col_dist += calcDist(src_current[0], src_template[0]);
+
+            src_current = (__global const pixel_t *)((__global const uchar *)src_current + src_step);
+            src_template = (__global const pixel_t *)((__global const uchar *)src_template + src_step);
+        }
+
+        dists[i] += col_dist - col_dists_current[first];
+        col_dists_current[first] = col_dist;
+        up_col_dists[mad24(x0, SEARCH_SIZE_SQ, i)] = col_dist;
+    }
+}
+
+inline void calcElement(__global const uchar * src, int src_step, int src_offset,
+                        __local int * dists, int y, int x0, int x, int id, int first,
+                        __global int * col_dists, __global int * up_col_dists)
+{
+    int sx = x + TEMPLATE_SIZE2;
+    int sy_up = y - TEMPLATE_SIZE2 - 1;
+    int sy_down = y + TEMPLATE_SIZE2;
+
+    pixel_t up_value = *(__global const pixel_t *)(src + mad24(sy_up, src_step, mad24(psz, sx, src_offset)));
+    pixel_t down_value = *(__global const pixel_t *)(src + mad24(sy_down, src_step, mad24(psz, sx, src_offset)));
+
+    sx -= SEARCH_SIZE2;
+    sy_up -= SEARCH_SIZE2;
+    sy_down -= SEARCH_SIZE2;
+
+    for (int i = id; i < SEARCH_SIZE_SQ; i += CTA_SIZE)
+    {
+        int wx = i % SEARCH_SIZE, wy = i / SEARCH_SIZE;
+
+        pixel_t up_value_t = *(__global const pixel_t *)(src + mad24(sy_up + wy, src_step, mad24(psz, sx + wx, src_offset)));
+        pixel_t down_value_t = *(__global const pixel_t *)(src + mad24(sy_down + wy, src_step, mad24(psz, sx + wx, src_offset)));
+
+        __global int * col_dists_current = col_dists + mad24(i, TEMPLATE_SIZE, first);
+        __global int * up_col_dists_current = up_col_dists + mad24(x0, SEARCH_SIZE_SQ, i);
+
+        int col_dist = up_col_dists_current[0] + calcDistUpDown(down_value, down_value_t, up_value, up_value_t);
+
+        dists[i] += col_dist - col_dists_current[0];
+        col_dists_current[0] = col_dist;
+        up_col_dists_current[0] = col_dist;
+    }
+}
+
+inline void convolveWindow(__global const uchar * src, int src_step, int src_offset,
+                           __local int * dists, __global const wlut_t * almostDist2Weight,
+                           __global uchar * dst, int dst_step, int dst_offset,
+                           int y, int x, int id, __local weight_t * weights_local,
+                           __local sum_t * weighted_sum_local, int almostTemplateWindowSizeSqBinShift)
+{
+    int sx = x - SEARCH_SIZE2, sy = y - SEARCH_SIZE2;
+    weight_t weights = (weight_t)0;
+    sum_t weighted_sum = (sum_t)0;
+
+    for (int i = id; i < SEARCH_SIZE_SQ; i += CTA_SIZE)
+    {
+        int src_index = mad24(sy + i / SEARCH_SIZE, src_step, mad24(i % SEARCH_SIZE + sx, psz, src_offset));
+        sum_t src_value = convert_sum_t(*(__global const pixel_t *)(src + src_index));
+
+        int almostAvgDist = dists[i] >> almostTemplateWindowSizeSqBinShift;
+        weight_t weight = convert_weight_t(almostDist2Weight[almostAvgDist]);
+
+        weights += weight;
+        weighted_sum += (sum_t)weight * src_value;
+    }
+
+    weights_local[id] = weights;
+    weighted_sum_local[id] = weighted_sum;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for (int lsize = CTA_SIZE >> 1; lsize > 2; lsize >>= 1)
+    {
+        if (id < lsize)
+        {
+           int id2 = lsize + id;
+           weights_local[id] += weights_local[id2];
+           weighted_sum_local[id] += weighted_sum_local[id2];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    if (id == 0)
+    {
+        int dst_index = mad24(y, dst_step, mad24(psz, x, dst_offset));
+        sum_t weighted_sum_local_0 = weighted_sum_local[0] + weighted_sum_local[1] +
+            weighted_sum_local[2] + weighted_sum_local[3];
+        weight_t weights_local_0 = weights_local[0] + weights_local[1] + weights_local[2] + weights_local[3];
+
+        *(__global pixel_t *)(dst + dst_index) = convert_pixel_t(weighted_sum_local_0 / (sum_t)weights_local_0);
+    }
+}
+
+__kernel void fastNlMeansDenoising(__global const uchar * src, int src_step, int src_offset,
+                                   __global uchar * dst, int dst_step, int dst_offset, int dst_rows, int dst_cols,
+                                   __global const wlut_t * almostDist2Weight, __global uchar * buffer,
+                                   int almostTemplateWindowSizeSqBinShift)
+{
+    int block_x = get_group_id(0), nblocks_x = get_num_groups(0);
+    int block_y = get_group_id(1);
+    int id = get_local_id(0), first;
+
+    __local int dists[SEARCH_SIZE_SQ];
+    __local weight_t weights[CTA_SIZE];
+    __local sum_t weighted_sum[CTA_SIZE];
+
+    int x0 = block_x * BLOCK_COLS, x1 = min(x0 + BLOCK_COLS, dst_cols);
+    int y0 = block_y * BLOCK_ROWS, y1 = min(y0 + BLOCK_ROWS, dst_rows);
+
+    // for each group we need SEARCH_SIZE_SQ * TEMPLATE_SIZE integer buffer for storing part column sum for current element
+    // and SEARCH_SIZE_SQ * BLOCK_COLS integer buffer for storing last column sum for each element of search window of up row
+    int block_data_start = SEARCH_SIZE_SQ * (mad24(block_y, dst_cols, x0) + mad24(block_y, nblocks_x, block_x) * TEMPLATE_SIZE);
+    __global int * col_dists = (__global int *)(buffer + block_data_start * sizeof(int));
+    __global int * up_col_dists = col_dists + SEARCH_SIZE_SQ * TEMPLATE_SIZE;
+
+    for (int y = y0; y < y1; ++y)
+        for (int x = x0; x < x1; ++x)
+        {
+            if (x == x0)
+            {
+                calcFirstElementInRow(src, src_step, src_offset, dists, y, x, id, col_dists, up_col_dists);
+                first = 0;
+            }
+            else
+            {
+                if (y == y0)
+                    calcElementInFirstRow(src, src_step, src_offset, dists, y, x - x0, x, id, first, col_dists, up_col_dists);
+                else
+                    calcElement(src, src_step, src_offset, dists, y, x - x0, x, id, first, col_dists, up_col_dists);
+
+                first = (first + 1) % TEMPLATE_SIZE;
+            }
+
+            convolveWindow(src, src_step, src_offset, dists, almostDist2Weight, dst, dst_step, dst_offset,
+                y, x, id, weights, weighted_sum, almostTemplateWindowSizeSqBinShift);
+        }
+}
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/precomp.hpp b/upstream/opencv/modules/photo/src/precomp.hpp
new file mode 100644
index 0000000..1834881
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/precomp.hpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/imgproc.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/photo/src/seamless_cloning.cpp b/upstream/opencv/modules/photo/src/seamless_cloning.cpp
new file mode 100644
index 0000000..1b9e3d1
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/seamless_cloning.cpp
@@ -0,0 +1,155 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/geometry.hpp"
+
+#include "seamless_cloning.hpp"
+
+using namespace std;
+using namespace cv;
+
+static Mat checkMask(InputArray mask, Size size)
+{
+    Mat gray;
+    if (mask.channels() == 3 || mask.channels() == 4)
+        cvtColor(mask, gray, COLOR_BGRA2GRAY);
+    else
+    {
+        if (mask.empty())
+            gray = Mat(size.height, size.width, CV_8UC1, Scalar(255));
+        else
+            return mask.getMat();
+    }
+
+    return gray;
+}
+
+void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point p, OutputArray _blend, int flags)
+{
+    CV_INSTRUMENT_REGION();
+    CV_Assert(!_src.empty());
+    CV_Assert(!_dst.empty());
+
+    const Mat src  = _src.getMat();
+    const Mat dest = _dst.getMat();
+
+    Mat mask = checkMask(_mask, src.size());
+    dest.copyTo(_blend);
+    Mat blend = _blend.getMat();
+
+    Mat mask_inner = mask(Rect(1, 1, mask.cols - 2, mask.rows - 2));
+    copyMakeBorder(mask_inner, mask, 1, 1, 1, 1, BORDER_ISOLATED | BORDER_CONSTANT, Scalar(0));
+
+    Rect roi_s = boundingRect(mask);
+    if (roi_s.empty()) return;
+
+    int l_from_center = p.x - roi_s.width / 2;
+    int t_from_center = p.y - roi_s.height / 2;
+
+    if (flags >= NORMAL_CLONE_WIDE)
+    {
+        l_from_center = p.x - (mask.cols / 2 - roi_s.x);
+        t_from_center = p.y - (mask.rows / 2 - roi_s.y);
+    }
+
+    Rect roi_d(l_from_center, t_from_center, roi_s.width, roi_s.height);
+    Mat destinationROI = dest(roi_d);
+    Mat sourceROI = Mat::zeros(roi_s.height, roi_s.width, src.type());
+    src(roi_s).copyTo(sourceROI,mask(roi_s));
+
+    Mat maskROI = mask(roi_s);
+    Mat recoveredROI = blend(roi_d);
+
+    Cloning obj;
+    obj.normalClone(destinationROI,sourceROI,maskROI,recoveredROI,flags);
+}
+
+void cv::colorChange(InputArray _src, InputArray _mask, OutputArray _dst, float red, float green, float blue)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat src  = _src.getMat();
+    Mat mask = checkMask(_mask, src.size());
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+
+    Mat cs_mask = Mat::zeros(src.size(), src.type());
+    src.copyTo(cs_mask, mask);
+
+    Cloning obj;
+    obj.localColorChange(src, cs_mask, mask, blend, red, green, blue);
+}
+
+void cv::illuminationChange(InputArray _src, InputArray _mask, OutputArray _dst, float alpha, float beta)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat src  = _src.getMat();
+    Mat mask = checkMask(_mask, src.size());
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+
+    Mat cs_mask = Mat::zeros(src.size(), src.type());
+    src.copyTo(cs_mask, mask);
+
+    Cloning obj;
+    obj.illuminationChange(src, cs_mask, mask, blend, alpha, beta);
+
+}
+
+void cv::textureFlattening(InputArray _src, InputArray _mask, OutputArray _dst,
+                           float low_threshold, float high_threshold, int kernel_size)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat src  = _src.getMat();
+    Mat mask = checkMask(_mask, src.size());
+    _dst.create(src.size(), src.type());
+    Mat blend = _dst.getMat();
+
+    Mat cs_mask = Mat::zeros(src.size(), src.type());
+    src.copyTo(cs_mask, mask);
+
+    Cloning obj;
+    obj.textureFlatten(src, cs_mask, mask, low_threshold, high_threshold, kernel_size, blend);
+}
diff --git a/upstream/opencv/modules/photo/src/seamless_cloning.hpp b/upstream/opencv/modules/photo/src/seamless_cloning.hpp
new file mode 100644
index 0000000..4d43970
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/seamless_cloning.hpp
@@ -0,0 +1,89 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef CV_SEAMLESS_CLONING_HPP___
+#define CV_SEAMLESS_CLONING_HPP___
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+
+#include <vector>
+
+namespace cv
+{
+
+    class Cloning
+    {
+        public:
+            void normalClone(const cv::Mat& destination, const cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, int flag);
+            void illuminationChange(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float alpha, float beta);
+            void localColorChange(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float red_mul, float green_mul, float blue_mul);
+            void textureFlatten(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, float low_threshold, float high_threhold, int kernel_size, cv::Mat &cloned);
+
+        protected:
+
+            void initVariables(const cv::Mat &destination, const cv::Mat &binaryMask);
+            void computeDerivatives(const cv::Mat &destination, const cv::Mat &patch, cv::Mat &binaryMask);
+            void scalarProduct(cv::Mat mat, float r, float g, float b);
+            void poisson(const cv::Mat &destination);
+            void evaluate(const cv::Mat &I, cv::Mat &wmask, const cv::Mat &cloned);
+            void dst(const Mat& src, Mat& dest, bool invert = false);
+            void solve(const Mat &img, Mat& mod_diff, Mat &result);
+
+            void poissonSolver(const cv::Mat &img, cv::Mat &gxx , cv::Mat &gyy, cv::Mat &result);
+
+            void arrayProduct(const cv::Mat& lhs, const cv::Mat& rhs, cv::Mat& result) const;
+
+            void computeGradientX(const cv::Mat &img, cv::Mat &gx);
+            void computeGradientY(const cv::Mat &img, cv::Mat &gy);
+            void computeLaplacianX(const cv::Mat &img, cv::Mat &gxx);
+            void computeLaplacianY(const cv::Mat &img, cv::Mat &gyy);
+
+        private:
+            std::vector <cv::Mat> rgbx_channel, rgby_channel, output;
+            cv::Mat destinationGradientX, destinationGradientY;
+            cv::Mat patchGradientX, patchGradientY;
+            cv::Mat binaryMaskFloat, binaryMaskFloatInverted;
+
+            std::vector<float> filter_X, filter_Y;
+    };
+}
+#endif
\ No newline at end of file
diff --git a/upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp b/upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp
new file mode 100644
index 0000000..c2e5c13
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/seamless_cloning_impl.cpp
@@ -0,0 +1,451 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "seamless_cloning.hpp"
+
+using namespace cv;
+using namespace std;
+
+
+void Cloning::computeGradientX( const Mat &img, Mat &gx)
+{
+    Mat kernel = Mat::zeros(1, 3, CV_8S);
+    kernel.at<char>(0,2) = 1;
+    kernel.at<char>(0,1) = -1;
+
+    if(img.channels() == 3)
+    {
+        filter2D(img, gx, CV_32F, kernel);
+    }
+    else if (img.channels() == 1)
+    {
+        filter2D(img, gx, CV_32F, kernel);
+        cvtColor(gx, gx, COLOR_GRAY2BGR);
+    }
+}
+
+void Cloning::computeGradientY( const Mat &img, Mat &gy)
+{
+    Mat kernel = Mat::zeros(3, 1, CV_8S);
+    kernel.at<char>(2,0) = 1;
+    kernel.at<char>(1,0) = -1;
+
+    if(img.channels() == 3)
+    {
+        filter2D(img, gy, CV_32F, kernel);
+    }
+    else if (img.channels() == 1)
+    {
+        filter2D(img, gy, CV_32F, kernel);
+        cvtColor(gy, gy, COLOR_GRAY2BGR);
+    }
+}
+
+void Cloning::computeLaplacianX( const Mat &img, Mat &laplacianX)
+{
+    Mat kernel = Mat::zeros(1, 3, CV_8S);
+    kernel.at<char>(0,0) = -1;
+    kernel.at<char>(0,1) = 1;
+    filter2D(img, laplacianX, CV_32F, kernel);
+}
+
+void Cloning::computeLaplacianY( const Mat &img, Mat &laplacianY)
+{
+    Mat kernel = Mat::zeros(3, 1, CV_8S);
+    kernel.at<char>(0,0) = -1;
+    kernel.at<char>(1,0) = 1;
+    filter2D(img, laplacianY, CV_32F, kernel);
+}
+
+void Cloning::dst(const Mat& src, Mat& dest, bool invert)
+{
+    Mat temp = Mat::zeros(src.rows, 2 * src.cols + 2, CV_32F);
+
+    int flag = invert ? DFT_ROWS + DFT_SCALE + DFT_INVERSE: DFT_ROWS;
+
+    src.copyTo(temp(Rect(1,0, src.cols, src.rows)));
+
+    for(int j = 0 ; j < src.rows ; ++j)
+    {
+        float * tempLinePtr = temp.ptr<float>(j);
+        const float * srcLinePtr = src.ptr<float>(j);
+        for(int i = 0 ; i < src.cols ; ++i)
+        {
+            tempLinePtr[src.cols + 2 + i] = - srcLinePtr[src.cols - 1 - i];
+        }
+    }
+
+    Mat planes[] = {temp, Mat::zeros(temp.size(), CV_32F)};
+    Mat complex;
+
+    merge(planes, 2, complex);
+    dft(complex, complex, flag);
+    split(complex, planes);
+    temp = Mat::zeros(src.cols, 2 * src.rows + 2, CV_32F);
+
+    for(int j = 0 ; j < src.cols ; ++j)
+    {
+        float * tempLinePtr = temp.ptr<float>(j);
+        for(int i = 0 ; i < src.rows ; ++i)
+        {
+            float val = planes[1].ptr<float>(i)[j + 1];
+            tempLinePtr[i + 1] = val;
+            tempLinePtr[temp.cols - 1 - i] = - val;
+        }
+    }
+
+    Mat planes2[] = {temp, Mat::zeros(temp.size(), CV_32F)};
+
+    merge(planes2, 2, complex);
+    dft(complex, complex, flag);
+    split(complex, planes2);
+
+    temp = planes2[1].t();
+    temp(Rect( 0, 1, src.cols, src.rows)).copyTo(dest);
+}
+
+void Cloning::solve(const Mat &img, Mat& mod_diff, Mat &result)
+{
+    const int w = img.cols;
+    const int h = img.rows;
+
+    Mat res;
+    dst(mod_diff, res);
+
+    for(int j = 0 ; j < h-2; j++)
+    {
+        float * resLinePtr = res.ptr<float>(j);
+        for(int i = 0 ; i < w-2; i++)
+        {
+            resLinePtr[i] /= (filter_X[i] + filter_Y[j] - 4);
+        }
+    }
+
+    dst(res, mod_diff, true);
+
+    unsigned char *  resLinePtr = result.ptr<unsigned char>(0);
+    const unsigned char * imgLinePtr = img.ptr<unsigned char>(0);
+    const float * interpLinePtr = NULL;
+
+     //first col
+    for(int i = 0 ; i < w ; ++i)
+        result.ptr<unsigned char>(0)[i] = img.ptr<unsigned char>(0)[i];
+
+    for(int j = 1 ; j < h-1 ; ++j)
+    {
+        resLinePtr = result.ptr<unsigned char>(j);
+        imgLinePtr  = img.ptr<unsigned char>(j);
+        interpLinePtr = mod_diff.ptr<float>(j-1);
+
+        //first row
+        resLinePtr[0] = imgLinePtr[0];
+
+        for(int i = 1 ; i < w-1 ; ++i)
+        {
+            //saturate cast is not used here, because it behaves differently from the previous implementation
+            //most notable, saturate_cast rounds before truncating, here it's the opposite.
+            float value = interpLinePtr[i-1];
+            if(value < 0.)
+                resLinePtr[i] = 0;
+            else if (value > 255.0)
+                resLinePtr[i] = 255;
+            else
+                resLinePtr[i] = static_cast<unsigned char>(value);
+        }
+
+        //last row
+        resLinePtr[w-1] = imgLinePtr[w-1];
+    }
+
+    //last col
+    resLinePtr = result.ptr<unsigned char>(h-1);
+    imgLinePtr = img.ptr<unsigned char>(h-1);
+    for(int i = 0 ; i < w ; ++i)
+        resLinePtr[i] = imgLinePtr[i];
+}
+
+void Cloning::poissonSolver(const Mat &img, Mat &laplacianX , Mat &laplacianY, Mat &result)
+{
+    const int w = img.cols;
+    const int h = img.rows;
+
+    Mat lap = laplacianX + laplacianY;
+
+    Mat bound = img.clone();
+
+    rectangle(bound, Point(1, 1), Point(img.cols-2, img.rows-2), Scalar::all(0), -1);
+    Mat boundary_points;
+    Laplacian(bound, boundary_points, CV_32F);
+
+    boundary_points = lap - boundary_points;
+
+    Mat mod_diff = boundary_points(Rect(1, 1, w-2, h-2));
+
+    solve(img,mod_diff,result);
+}
+
+void Cloning::initVariables(const Mat &destination, const Mat &binaryMask)
+{
+    destinationGradientX = Mat(destination.size(),CV_32FC3);
+    destinationGradientY = Mat(destination.size(),CV_32FC3);
+    patchGradientX = Mat(destination.size(),CV_32FC3);
+    patchGradientY = Mat(destination.size(),CV_32FC3);
+
+    binaryMaskFloat = Mat(binaryMask.size(),CV_32FC1);
+    binaryMaskFloatInverted = Mat(binaryMask.size(),CV_32FC1);
+
+    //init of the filters used in the dst
+    const int w = destination.cols;
+    filter_X.resize(w - 2);
+    double scale = CV_PI / (w - 1);
+    for(int i = 0 ; i < w-2 ; ++i)
+        filter_X[i] = 2.0f * (float)std::cos(scale * (i + 1));
+
+    const int h  = destination.rows;
+    filter_Y.resize(h - 2);
+    scale = CV_PI / (h - 1);
+    for(int j = 0 ; j < h - 2 ; ++j)
+        filter_Y[j] = 2.0f * (float)std::cos(scale * (j + 1));
+}
+
+void Cloning::computeDerivatives(const Mat& destination, const Mat &patch, Mat &binaryMask)
+{
+    initVariables(destination, binaryMask);
+
+    computeGradientX(destination, destinationGradientX);
+    computeGradientY(destination, destinationGradientY);
+
+    computeGradientX(patch, patchGradientX);
+    computeGradientY(patch, patchGradientY);
+
+    Mat Kernel(Size(3, 3), CV_8UC1);
+    Kernel.setTo(Scalar(1));
+    erode(binaryMask, binaryMask, Kernel, Point(-1,-1), 3);
+
+    binaryMask.convertTo(binaryMaskFloat, CV_32FC1, 1.0/255.0);
+}
+
+void Cloning::scalarProduct(Mat mat, float r, float g, float b)
+{
+    vector <Mat> channels;
+    split(mat,channels);
+    multiply(channels[2],r,channels[2]);
+    multiply(channels[1],g,channels[1]);
+    multiply(channels[0],b,channels[0]);
+    merge(channels,mat);
+}
+
+void Cloning::arrayProduct(const cv::Mat& lhs, const cv::Mat& rhs, cv::Mat& result) const
+{
+    vector <Mat> lhs_channels;
+    vector <Mat> result_channels;
+
+    split(lhs,lhs_channels);
+    split(result,result_channels);
+
+    for(int chan = 0 ; chan < 3 ; ++chan)
+        multiply(lhs_channels[chan],rhs,result_channels[chan]);
+
+    merge(result_channels,result);
+}
+
+void Cloning::poisson(const Mat &destination)
+{
+    Mat laplacianX = destinationGradientX + patchGradientX;
+    Mat laplacianY = destinationGradientY + patchGradientY;
+
+    computeLaplacianX(laplacianX,laplacianX);
+    computeLaplacianY(laplacianY,laplacianY);
+
+    split(laplacianX,rgbx_channel);
+    split(laplacianY,rgby_channel);
+
+    split(destination,output);
+
+    for(int chan = 0 ; chan < 3 ; ++chan)
+    {
+        poissonSolver(output[chan], rgbx_channel[chan], rgby_channel[chan], output[chan]);
+    }
+}
+
+void Cloning::evaluate(const Mat &I, Mat &wmask, const Mat &cloned)
+{
+    bitwise_not(wmask,wmask);
+
+    wmask.convertTo(binaryMaskFloatInverted,CV_32FC1,1.0/255.0);
+
+    arrayProduct(destinationGradientX, binaryMaskFloatInverted, destinationGradientX);
+    arrayProduct(destinationGradientY, binaryMaskFloatInverted, destinationGradientY);
+
+    poisson(I);
+
+    merge(output,cloned);
+}
+
+void Cloning::normalClone(const Mat &destination, const Mat &patch, Mat &binaryMask, Mat &cloned, int flag)
+{
+    const int w = destination.cols;
+    const int h = destination.rows;
+    const int channel = destination.channels();
+    const int n_elem_in_line = w * channel;
+
+    computeDerivatives(destination,patch,binaryMask);
+
+    switch(flag)
+    {
+        case NORMAL_CLONE:
+        case NORMAL_CLONE_WIDE:
+            arrayProduct(patchGradientX, binaryMaskFloat, patchGradientX);
+            arrayProduct(patchGradientY, binaryMaskFloat, patchGradientY);
+            break;
+
+        case MIXED_CLONE:
+        case MIXED_CLONE_WIDE:
+        {
+            AutoBuffer<int> maskIndices(n_elem_in_line);
+            for (int i = 0; i < n_elem_in_line; ++i)
+                maskIndices[i] = i / channel;
+
+            for(int i=0;i < h; i++)
+            {
+                float * patchXLinePtr = patchGradientX.ptr<float>(i);
+                float * patchYLinePtr = patchGradientY.ptr<float>(i);
+                const float * destinationXLinePtr = destinationGradientX.ptr<float>(i);
+                const float * destinationYLinePtr = destinationGradientY.ptr<float>(i);
+                const float * binaryMaskLinePtr = binaryMaskFloat.ptr<float>(i);
+
+                for(int j=0; j < n_elem_in_line; j++)
+                {
+                    int maskIndex = maskIndices[j];
+
+                    if(abs(patchXLinePtr[j] - patchYLinePtr[j]) >
+                       abs(destinationXLinePtr[j] - destinationYLinePtr[j]))
+                    {
+                        patchXLinePtr[j] *= binaryMaskLinePtr[maskIndex];
+                        patchYLinePtr[j] *= binaryMaskLinePtr[maskIndex];
+                    }
+                    else
+                    {
+                        patchXLinePtr[j] = destinationXLinePtr[j]
+                            * binaryMaskLinePtr[maskIndex];
+                        patchYLinePtr[j] = destinationYLinePtr[j]
+                            * binaryMaskLinePtr[maskIndex];
+                    }
+                }
+            }
+        }
+        break;
+
+        case MONOCHROME_TRANSFER:
+        case MONOCHROME_TRANSFER_WIDE:
+            Mat gray;
+            cvtColor(patch, gray, COLOR_BGR2GRAY );
+
+            computeGradientX(gray,patchGradientX);
+            computeGradientY(gray,patchGradientY);
+
+            arrayProduct(patchGradientX, binaryMaskFloat, patchGradientX);
+            arrayProduct(patchGradientY, binaryMaskFloat, patchGradientY);
+        break;
+
+    }
+
+    evaluate(destination,binaryMask,cloned);
+}
+
+void Cloning::localColorChange(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul=1.0,
+                                 float green_mul=1.0, float blue_mul=1.0)
+{
+    computeDerivatives(I,mask,wmask);
+
+    arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX);
+    arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY);
+    scalarProduct(patchGradientX,red_mul,green_mul,blue_mul);
+    scalarProduct(patchGradientY,red_mul,green_mul,blue_mul);
+
+    evaluate(I,wmask,cloned);
+}
+
+void Cloning::illuminationChange(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta)
+{
+    CV_INSTRUMENT_REGION();
+
+    computeDerivatives(I,mask,wmask);
+
+    arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX);
+    arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY);
+
+    Mat mag;
+    magnitude(patchGradientX,patchGradientY,mag);
+
+    Mat multX, multY, multx_temp, multy_temp;
+
+    multiply(patchGradientX,pow(alpha,beta),multX);
+    pow(mag,-1*beta, multx_temp);
+    multiply(multX,multx_temp, patchGradientX);
+    patchNaNs(patchGradientX);
+
+    multiply(patchGradientY,pow(alpha,beta),multY);
+    pow(mag,-1*beta, multy_temp);
+    multiply(multY,multy_temp,patchGradientY);
+    patchNaNs(patchGradientY);
+
+    evaluate(I,wmask,cloned);
+}
+
+void Cloning::textureFlatten(Mat &I, Mat &mask, Mat &wmask, float low_threshold,
+        float high_threshold, int kernel_size, Mat &cloned)
+{
+    computeDerivatives(I,mask,wmask);
+
+    Mat out;
+    Canny(mask,out,low_threshold,high_threshold,kernel_size);
+
+    Mat zeros = Mat::zeros(patchGradientX.size(), CV_32FC3);
+    Mat zerosMask = (out != 255);
+    zeros.copyTo(patchGradientX, zerosMask);
+    zeros.copyTo(patchGradientY, zerosMask);
+
+    arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX);
+    arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY);
+
+    evaluate(I,wmask,cloned);
+}
diff --git a/upstream/opencv/modules/photo/src/tonemap.cpp b/upstream/opencv/modules/photo/src/tonemap.cpp
new file mode 100644
index 0000000..05f2488
--- /dev/null
+++ b/upstream/opencv/modules/photo/src/tonemap.cpp
@@ -0,0 +1,476 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/photo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "hdr_common.hpp"
+
+namespace cv
+{
+
+inline void log_(const Mat& src, Mat& dst)
+{
+    max(src, Scalar::all(1e-4), dst);
+    log(dst, dst);
+}
+
+class TonemapImpl CV_FINAL : public Tonemap
+{
+public:
+    TonemapImpl(float _gamma) : name("Tonemap"), gamma(_gamma)
+    {
+    }
+
+    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat src = _src.getMat();
+        CV_Assert(!src.empty());
+        CV_Assert(_src.dims() == 2 && _src.type() == CV_32FC3);
+        _dst.create(src.size(), CV_32FC3);
+        Mat dst = _dst.getMat();
+
+        double min, max;
+        minMaxLoc(src, &min, &max);
+        float fmin = static_cast<float>(min);
+        float fmax = static_cast<float>(max);
+        if(max - min > DBL_EPSILON) {
+            dst = (src - fmin) / (fmax - fmin);
+        } else {
+            src.copyTo(dst);
+        }
+
+        pow(dst, 1.0f / gamma, dst);
+    }
+
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "gamma" << gamma;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        gamma = fn["gamma"];
+    }
+
+protected:
+    String name;
+    float gamma;
+};
+
+Ptr<Tonemap> createTonemap(float gamma)
+{
+    return makePtr<TonemapImpl>(gamma);
+}
+
+class TonemapDragoImpl CV_FINAL : public TonemapDrago
+{
+public:
+    TonemapDragoImpl(float _gamma, float _saturation, float _bias) :
+        name("TonemapDrago"),
+        gamma(_gamma),
+        saturation(_saturation),
+        bias(_bias)
+    {
+    }
+
+    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat src = _src.getMat();
+        CV_Assert(!src.empty());
+        _dst.create(src.size(), CV_32FC3);
+        Mat img = _dst.getMat();
+
+        Ptr<Tonemap> linear = createTonemap(1.0f);
+        linear->process(src, img);
+
+        Mat gray_img;
+        cvtColor(img, gray_img, COLOR_RGB2GRAY);
+        Mat log_img;
+        log_(gray_img, log_img);
+        float mean = expf(static_cast<float>(sum(log_img)[0]) / log_img.total());
+        gray_img /= mean;
+        log_img.release();
+
+        double dmax;
+        minMaxLoc(gray_img, NULL, &dmax);
+        float max = static_cast<float>(dmax);
+        CV_Assert(max > 0);
+
+        Mat map;
+        log(gray_img + 1.0f, map);
+        Mat div;
+        pow(gray_img / static_cast<float>(max), logf(bias) / logf(0.5f), div);
+        log(2.0f + 8.0f * div, div);
+        map = map.mul(1.0f / div);
+        div.release();
+        mapLuminance(img, img, gray_img, map, saturation);
+
+        linear->setGamma(gamma);
+        linear->process(img, img);
+    }
+
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+
+    float getSaturation() const CV_OVERRIDE { return saturation; }
+    void setSaturation(float val) CV_OVERRIDE { saturation = val; }
+
+    float getBias() const CV_OVERRIDE { return bias; }
+    void setBias(float val) CV_OVERRIDE { bias = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "gamma" << gamma
+           << "bias" << bias
+           << "saturation" << saturation;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        gamma = fn["gamma"];
+        bias = fn["bias"];
+        saturation = fn["saturation"];
+    }
+
+protected:
+    String name;
+    float gamma, saturation, bias;
+};
+
+Ptr<TonemapDrago> createTonemapDrago(float gamma, float saturation, float bias)
+{
+    return makePtr<TonemapDragoImpl>(gamma, saturation, bias);
+}
+
+class TonemapReinhardImpl CV_FINAL : public TonemapReinhard
+{
+public:
+    TonemapReinhardImpl(float _gamma, float _intensity, float _light_adapt, float _color_adapt) :
+        name("TonemapReinhard"),
+        gamma(_gamma),
+        intensity(_intensity),
+        light_adapt(_light_adapt),
+        color_adapt(_color_adapt)
+    {
+    }
+
+    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat src = _src.getMat();
+        CV_Assert(!src.empty());
+        _dst.create(src.size(), CV_32FC3);
+        Mat img = _dst.getMat();
+        Ptr<Tonemap> linear = createTonemap(1.0f);
+        linear->process(src, img);
+
+        Mat gray_img;
+        cvtColor(img, gray_img, COLOR_RGB2GRAY);
+        Mat log_img;
+        log_(gray_img, log_img);
+
+        float log_mean = static_cast<float>(sum(log_img)[0] / log_img.total());
+        double dlog_min, dlog_max;
+        minMaxLoc(log_img, &dlog_min, &dlog_max);
+        float log_max = static_cast<float>(dlog_max);
+        float log_min = static_cast<float>(dlog_min);
+        log_img.release();
+
+        float key = (log_max - log_mean) / (log_max - log_min);
+        float map_key = 0.3f + 0.7f * std::pow(key, 1.4f);
+        intensity = exp(-intensity);
+        Scalar chan_mean = mean(img);
+        float gray_mean = static_cast<float>(mean(gray_img)[0]);
+
+        std::vector<Mat> channels(3);
+        split(img, channels);
+
+        for(int i = 0; i < 3; i++) {
+            float global = color_adapt * static_cast<float>(chan_mean[i]) + (1.0f - color_adapt) * gray_mean;
+            Mat adapt = color_adapt * channels[i] + (1.0f - color_adapt) * gray_img;
+            adapt = light_adapt * adapt + (1.0f - light_adapt) * global;
+            pow(intensity * adapt, map_key, adapt);
+            channels[i] = channels[i].mul(1.0f / (adapt + channels[i]));
+        }
+        gray_img.release();
+        merge(channels, img);
+
+        linear->setGamma(gamma);
+        linear->process(img, img);
+    }
+
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+
+    float getIntensity() const CV_OVERRIDE { return intensity; }
+    void setIntensity(float val) CV_OVERRIDE { intensity = val; }
+
+    float getLightAdaptation() const CV_OVERRIDE { return light_adapt; }
+    void setLightAdaptation(float val) CV_OVERRIDE { light_adapt = val; }
+
+    float getColorAdaptation() const CV_OVERRIDE { return color_adapt; }
+    void setColorAdaptation(float val) CV_OVERRIDE { color_adapt = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "gamma" << gamma
+           << "intensity" << intensity
+           << "light_adapt" << light_adapt
+           << "color_adapt" << color_adapt;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        gamma = fn["gamma"];
+        intensity = fn["intensity"];
+        light_adapt = fn["light_adapt"];
+        color_adapt = fn["color_adapt"];
+    }
+
+protected:
+    String name;
+    float gamma, intensity, light_adapt, color_adapt;
+};
+
+Ptr<TonemapReinhard> createTonemapReinhard(float gamma, float intensity, float light_adapt, float color_adapt)
+{
+    return makePtr<TonemapReinhardImpl>(gamma, intensity, light_adapt, color_adapt);
+}
+
+class TonemapMantiukImpl CV_FINAL : public TonemapMantiuk
+{
+public:
+    TonemapMantiukImpl(float _gamma, float _scale, float _saturation) :
+        name("TonemapMantiuk"),
+        gamma(_gamma),
+        scale(_scale),
+        saturation(_saturation)
+    {
+    }
+
+    void process(InputArray _src, OutputArray _dst) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat src = _src.getMat();
+        CV_Assert(!src.empty());
+        _dst.create(src.size(), CV_32FC3);
+        Mat img = _dst.getMat();
+        Ptr<Tonemap> linear = createTonemap(1.0f);
+        linear->process(src, img);
+
+        Mat gray_img;
+        cvtColor(img, gray_img, COLOR_RGB2GRAY);
+        Mat log_img;
+        log_(gray_img, log_img);
+
+        std::vector<Mat> x_contrast, y_contrast;
+        getContrast(log_img, x_contrast, y_contrast);
+
+        for(size_t i = 0; i < x_contrast.size(); i++) {
+            mapContrast(x_contrast[i]);
+            mapContrast(y_contrast[i]);
+        }
+
+        Mat right(src.size(), CV_32F);
+        calculateSum(x_contrast, y_contrast, right);
+
+        Mat p, r, product, x = log_img;
+        calculateProduct(x, r);
+        r = right - r;
+        r.copyTo(p);
+
+        const float target_error = 1e-3f;
+        float target_norm = static_cast<float>(right.dot(right)) * powf(target_error, 2.0f);
+        int max_iterations = 100;
+        float rr = static_cast<float>(r.dot(r));
+
+        for(int i = 0; i < max_iterations; i++)
+        {
+            calculateProduct(p, product);
+            double dprod = p.dot(product);
+            CV_Assert(fabs(dprod) > 0);
+            float alpha = rr / static_cast<float>(dprod);
+
+            r -= alpha * product;
+            x += alpha * p;
+
+            float new_rr = static_cast<float>(r.dot(r));
+            CV_Assert(fabs(rr) > 0);
+            p = r + (new_rr / rr) * p;
+            rr = new_rr;
+
+            if(rr < target_norm) {
+                break;
+            }
+        }
+        exp(x, x);
+        mapLuminance(img, img, gray_img, x, saturation);
+
+        linear = createTonemap(gamma);
+        linear->process(img, img);
+    }
+
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+
+    float getScale() const CV_OVERRIDE { return scale; }
+    void setScale(float val) CV_OVERRIDE { scale = val; }
+
+    float getSaturation() const CV_OVERRIDE { return saturation; }
+    void setSaturation(float val) CV_OVERRIDE { saturation = val; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name
+           << "gamma" << gamma
+           << "scale" << scale
+           << "saturation" << saturation;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert(n.isString() && String(n) == name);
+        gamma = fn["gamma"];
+        scale = fn["scale"];
+        saturation = fn["saturation"];
+    }
+
+protected:
+    String name;
+    float gamma, scale, saturation;
+
+    void signedPow(Mat src, float power, Mat& dst)
+    {
+        Mat sign = (src > 0);
+        sign.convertTo(sign, CV_32F, 1.0f/255.0f);
+        sign = sign * 2.0f - 1.0f;
+        pow(abs(src), power, dst);
+        dst = dst.mul(sign);
+    }
+
+    void mapContrast(Mat& contrast)
+    {
+        const float response_power = 0.4185f;
+        signedPow(contrast, response_power, contrast);
+        contrast *= scale;
+        signedPow(contrast, 1.0f / response_power, contrast);
+    }
+
+    void getGradient(Mat src, Mat& dst, int pos)
+    {
+        dst = Mat::zeros(src.size(), CV_32F);
+        Mat a, b;
+        Mat grad = src.colRange(1, src.cols) - src.colRange(0, src.cols - 1);
+        grad.copyTo(dst.colRange(pos, src.cols + pos - 1));
+        if(pos == 1) {
+            src.col(0).copyTo(dst.col(0));
+        }
+    }
+
+    void getContrast(Mat src, std::vector<Mat>& x_contrast, std::vector<Mat>& y_contrast)
+    {
+        int levels = static_cast<int>(logf(static_cast<float>(min(src.rows, src.cols))) / logf(2.0f));
+        x_contrast.resize(levels);
+        y_contrast.resize(levels);
+
+        Mat layer;
+        src.copyTo(layer);
+        for(int i = 0; i < levels; i++) {
+            getGradient(layer, x_contrast[i], 0);
+            getGradient(layer.t(), y_contrast[i], 0);
+            resize(layer, layer, Size(layer.cols / 2, layer.rows / 2), 0, 0, INTER_LINEAR);
+        }
+    }
+
+    void calculateSum(std::vector<Mat>& x_contrast, std::vector<Mat>& y_contrast, Mat& sum)
+    {
+        if (x_contrast.empty())
+            return;
+        const int last = (int)x_contrast.size() - 1;
+        sum = Mat::zeros(x_contrast[last].size(), CV_32F);
+        for(int i = last; i >= 0; i--)
+        {
+            Mat grad_x, grad_y;
+            getGradient(x_contrast[i], grad_x, 1);
+            getGradient(y_contrast[i], grad_y, 1);
+            resize(sum, sum, x_contrast[i].size(), 0, 0, INTER_LINEAR);
+            sum += grad_x + grad_y.t();
+        }
+    }
+
+    void calculateProduct(Mat src, Mat& dst)
+    {
+        std::vector<Mat> x_contrast, y_contrast;
+        getContrast(src, x_contrast, y_contrast);
+        calculateSum(x_contrast, y_contrast, dst);
+    }
+};
+
+Ptr<TonemapMantiuk> createTonemapMantiuk(float gamma, float scale, float saturation)
+{
+    return makePtr<TonemapMantiukImpl>(gamma, scale, saturation);
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/CMakeLists.txt b/upstream/opencv/modules/ptcloud/CMakeLists.txt
new file mode 100644
index 0000000..7602feb
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(the_description "High level point cloud and mesh operations")
+
+set(debug_modules "")
+if(DEBUG_opencv_ptcloud)
+  list(APPEND debug_modules opencv_highgui)
+endif()
+ocv_define_module(ptcloud opencv_geometry opencv_imgproc opencv_flann ${debug_modules}
+    WRAP java objc python js
+)
+ocv_target_link_libraries(${the_module} ${LAPACK_LIBRARIES})
+
+if(NOT HAVE_EIGEN)
+  message(STATUS "Geometry: Eigen support is disabled. Eigen is Required for Posegraph optimization")
+endif()
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud.hpp
new file mode 100644
index 0000000..ea1b092
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud.hpp
@@ -0,0 +1,415 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef POINT_CLOUD_MODULE_HPP
+#define POINT_CLOUD_MODULE_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/ptcloud/depth.hpp"
+#include "opencv2/ptcloud/volume.hpp"
+#include "opencv2/ptcloud/odometry.hpp"
+#include "opencv2/ptcloud/odometry_frame.hpp"
+#include "opencv2/ptcloud/odometry_settings.hpp"
+
+/**
+@defgroup ptcloud Point Clound Processing
+*/
+
+//! @addtogroup ptcloud
+//! @{
+
+namespace cv {
+
+/** @brief Loads a point cloud from a file.
+ *
+ * The function loads point cloud from the specified file and returns it.
+ * If the cloud cannot be read, throws an error.
+ * Vertex coordinates, normals and colors are returned as they are saved in the file
+ * even if these arrays have different sizes and their elements do not correspond to each other
+ * (which is typical for OBJ files for example)
+ *
+ * Currently, the following file formats are supported:
+ * -  [Wavefront obj file *.obj](https://en.wikipedia.org/wiki/Wavefront_.obj_file)
+ * -  [Polygon File Format *.ply](https://en.wikipedia.org/wiki/PLY_(file_format))
+ *
+ * @param filename Name of the file
+ * @param vertices vertex coordinates, each value contains 3 floats
+ * @param normals per-vertex normals, each value contains 3 floats
+ * @param rgb per-vertex colors, each value contains 3 floats
+ */
+CV_EXPORTS_W void loadPointCloud(const String &filename, OutputArray vertices, OutputArray normals = noArray(), OutputArray rgb = noArray());
+
+/** @brief Saves a point cloud to a specified file.
+ *
+ * The function saves point cloud to the specified file.
+ * File format is chosen based on the filename extension.
+ *
+ * @param filename Name of the file
+ * @param vertices vertex coordinates, each value contains 3 floats
+ * @param normals per-vertex normals, each value contains 3 floats
+ * @param rgb per-vertex colors, each value contains 3 floats
+ */
+CV_EXPORTS_W void savePointCloud(const String &filename, InputArray vertices, InputArray normals = noArray(), InputArray rgb = noArray());
+
+/** @brief Loads a mesh from a file.
+ *
+ * The function loads mesh from the specified file and returns it.
+ * If the mesh cannot be read, throws an error
+ * Vertex attributes (i.e. space and texture coodinates, normals and colors) are returned in same-sized
+ * arrays with corresponding elements having the same indices.
+ * This means that if a face uses a vertex with a normal or a texture coordinate with different indices
+ * (which is typical for OBJ files for example), this vertex will be duplicated for each face it uses.
+ *
+ * Currently, the following file formats are supported:
+ * -  [Wavefront obj file *.obj](https://en.wikipedia.org/wiki/Wavefront_.obj_file) (ONLY TRIANGULATED FACES)
+ * -  [Polygon File Format *.ply](https://en.wikipedia.org/wiki/PLY_(file_format))
+ * @param filename Name of the file
+ * @param vertices vertex coordinates, each value contains 3 floats
+ * @param indices per-face list of vertices, each value is a vector of ints
+ * @param normals per-vertex normals, each value contains 3 floats
+ * @param colors per-vertex colors, each value contains 3 floats
+ * @param texCoords per-vertex texture coordinates, each value contains 2 or 3 floats
+ */
+CV_EXPORTS_W void loadMesh(const String &filename, OutputArray vertices, OutputArrayOfArrays indices,
+                           OutputArray normals = noArray(), OutputArray colors = noArray(),
+                           OutputArray texCoords = noArray());
+
+/** @brief Saves a mesh to a specified file.
+ *
+ * The function saves mesh to the specified file.
+ * File format is chosen based on the filename extension.
+ *
+ * @param filename Name of the file.
+ * @param vertices vertex coordinates, each value contains 3 floats
+ * @param indices per-face list of vertices, each value is a vector of ints
+ * @param normals per-vertex normals, each value contains 3 floats
+ * @param colors per-vertex colors, each value contains 3 floats
+ * @param texCoords per-vertex texture coordinates, each value contains 2 or 3 floats
+ */
+CV_EXPORTS_W void saveMesh(const String &filename, InputArray vertices, InputArrayOfArrays indices,
+                           InputArray normals = noArray(), InputArray colors = noArray(), InputArray texCoords = noArray());
+
+
+//! Triangle fill settings
+enum TriangleShadingType
+{
+    RASTERIZE_SHADING_WHITE  = 0, //!< a white color is used for the whole triangle
+    RASTERIZE_SHADING_FLAT   = 1, //!< a color of 1st vertex of each triangle is used
+    RASTERIZE_SHADING_SHADED = 2  //!< a color is interpolated between 3 vertices with perspective correction
+};
+
+//! Face culling settings: what faces are drawn after face culling
+enum TriangleCullingMode
+{
+    RASTERIZE_CULLING_NONE = 0, //!< all faces are drawn, no culling is actually performed
+    RASTERIZE_CULLING_CW   = 1, //!< triangles which vertices are given in clockwork order are drawn
+    RASTERIZE_CULLING_CCW  = 2  //!< triangles which vertices are given in counterclockwork order are drawn
+};
+
+//! GL compatibility settings
+enum TriangleGlCompatibleMode
+{
+    RASTERIZE_COMPAT_DISABLED = 0, //!< Color and depth have their natural values and converted to internal formats if needed
+    RASTERIZE_COMPAT_INVDEPTH = 1  //!< Color is natural, Depth is transformed from [-zNear; -zFar] to [0; 1]
+    //!< by the following formula: \f$ \frac{z_{far} \left(z + z_{near}\right)}{z \left(z_{far} - z_{near}\right)} \f$ \n
+    //!< In this mode the input/output depthBuf is considered to be in this format,
+    //!< therefore it's faster since there're no conversions performed
+};
+
+/**
+ * @brief Structure to keep settings for rasterization
+ */
+struct CV_EXPORTS_W_SIMPLE TriangleRasterizeSettings
+{
+    TriangleRasterizeSettings();
+
+    CV_WRAP TriangleRasterizeSettings& setShadingType(TriangleShadingType st) { shadingType = st; return *this; }
+    CV_WRAP TriangleRasterizeSettings& setCullingMode(TriangleCullingMode cm) { cullingMode = cm; return *this; }
+    CV_WRAP TriangleRasterizeSettings& setGlCompatibleMode(TriangleGlCompatibleMode gm) { glCompatibleMode = gm; return *this; }
+
+    TriangleShadingType shadingType;
+    TriangleCullingMode cullingMode;
+    TriangleGlCompatibleMode glCompatibleMode;
+};
+
+
+/** @brief Renders a set of triangles on a depth and color image
+ *
+ * Triangles can be drawn white (1.0, 1.0, 1.0), flat-shaded or with a color interpolation between vertices.
+ * In flat-shaded mode the 1st vertex color of each triangle is used to fill the whole triangle.
+ *
+ * The world2cam is an inverted camera pose matrix in fact. It transforms vertices from world to
+ * camera coordinate system.
+ *
+ * The camera coordinate system emulates the OpenGL's coordinate system having coordinate origin in a screen center,
+ * X axis pointing right, Y axis pointing up and Z axis pointing towards the viewer
+ * except that image is vertically flipped after the render.
+ * This means that all visible objects are placed in z-negative area, or exactly in -zNear > z > -zFar since
+ * zNear and zFar are positive.
+ * For example, at fovY = PI/2 the point (0, 1, -1) will be projected to (width/2, 0) screen point,
+ * (1, 0, -1) to (width/2 + height/2, height/2). Increasing fovY makes projection smaller and vice versa.
+ *
+ * The function does not create or clear output images before the rendering. This means that it can be used
+ * for drawing over an existing image or for rendering a model into a 3D scene using pre-filled Z-buffer.
+ *
+ * Empty scene results in a depth buffer filled by the maximum value since every pixel is infinitely far from the camera.
+ * Therefore, before rendering anything from scratch the depthBuf should be filled by zFar values (or by ones in INVDEPTH mode).
+ *
+ * There are special versions of this function named triangleRasterizeDepth and triangleRasterizeColor
+ * for cases if a user needs a color image or a depth image alone; they may run slightly faster.
+ *
+ * @param vertices vertices coordinates array. Should contain values of CV_32FC3 type or a compatible one (e.g. cv::Vec3f, etc.)
+ * @param indices triangle vertices index array, 3 per triangle. Each index indicates a vertex in a vertices array.
+ * Should contain CV_32SC3 values or compatible
+ * @param colors per-vertex colors of CV_32FC3 type or compatible. Can be empty or the same size as vertices array.
+ * If the values are out of [0; 1] range, the result correctness is not guaranteed
+ * @param colorBuf an array representing the final rendered image. Should containt CV_32FC3 values and be the same size as depthBuf.
+ * Not cleared before rendering, i.e. the content is reused as there is some pre-rendered scene.
+ * @param depthBuf an array of floats containing resulting Z buffer. Should contain float values and be the same size as colorBuf.
+ * Not cleared before rendering, i.e. the content is reused as there is some pre-rendered scene.
+ * Empty scene corresponds to all values set to zFar (or to 1.0 in INVDEPTH mode)
+ * @param world2cam a 4x3 or 4x4 float or double matrix containing inverted (sic!) camera pose
+ * @param fovY field of view in vertical direction, given in radians
+ * @param zNear minimum Z value to render, everything closer is clipped
+ * @param zFar maximum Z value to render, everything farther is clipped
+ * @param settings see TriangleRasterizeSettings. By default the smooth shading is on,
+ * with CW culling and with disabled GL compatibility
+ */
+CV_EXPORTS_W void triangleRasterize(InputArray vertices, InputArray indices, InputArray colors,
+                                    InputOutputArray colorBuf, InputOutputArray depthBuf,
+                                    InputArray world2cam, double fovY, double zNear, double zFar,
+                                    const TriangleRasterizeSettings& settings = TriangleRasterizeSettings());
+
+/** @brief Overloaded version of triangleRasterize() with depth-only rendering
+ *
+ * @param vertices vertices coordinates array. Should contain values of CV_32FC3 type or a compatible one (e.g. cv::Vec3f, etc.)
+ * @param indices triangle vertices index array, 3 per triangle. Each index indicates a vertex in a vertices array.
+ * Should contain CV_32SC3 values or compatible
+ * @param depthBuf an array of floats containing resulting Z buffer. Should contain float values and be the same size as colorBuf.
+ * Not cleared before rendering, i.e. the content is reused as there is some pre-rendered scene.
+ * Empty scene corresponds to all values set to zFar (or to 1.0 in INVDEPTH mode)
+ * @param world2cam a 4x3 or 4x4 float or double matrix containing inverted (sic!) camera pose
+ * @param fovY field of view in vertical direction, given in radians
+ * @param zNear minimum Z value to render, everything closer is clipped
+ * @param zFar maximum Z value to render, everything farther is clipped
+ * @param settings see TriangleRasterizeSettings. By default the smooth shading is on,
+ * with CW culling and with disabled GL compatibility
+ */
+CV_EXPORTS_W void triangleRasterizeDepth(InputArray vertices, InputArray indices, InputOutputArray depthBuf,
+                                         InputArray world2cam, double fovY, double zNear, double zFar,
+                                         const TriangleRasterizeSettings& settings = TriangleRasterizeSettings());
+
+/** @brief Overloaded version of triangleRasterize() with color-only rendering
+ *
+ * @param vertices vertices coordinates array. Should contain values of CV_32FC3 type or a compatible one (e.g. cv::Vec3f, etc.)
+ * @param indices triangle vertices index array, 3 per triangle. Each index indicates a vertex in a vertices array.
+ * Should contain CV_32SC3 values or compatible
+ * @param colors per-vertex colors of CV_32FC3 type or compatible. Can be empty or the same size as vertices array.
+ * If the values are out of [0; 1] range, the result correctness is not guaranteed
+ * @param colorBuf an array representing the final rendered image. Should containt CV_32FC3 values and be the same size as depthBuf.
+ * Not cleared before rendering, i.e. the content is reused as there is some pre-rendered scene.
+ * @param world2cam a 4x3 or 4x4 float or double matrix containing inverted (sic!) camera pose
+ * @param fovY field of view in vertical direction, given in radians
+ * @param zNear minimum Z value to render, everything closer is clipped
+ * @param zFar maximum Z value to render, everything farther is clipped
+ * @param settings see TriangleRasterizeSettings. By default the smooth shading is on,
+ * with CW culling and with disabled GL compatibility
+ */
+CV_EXPORTS_W void triangleRasterizeColor(InputArray vertices, InputArray indices, InputArray colors, InputOutputArray colorBuf,
+                                         InputArray world2cam, double fovY, double zNear, double zFar,
+                                         const TriangleRasterizeSettings& settings = TriangleRasterizeSettings());
+
+/** @brief Octree for 3D vision.
+ *
+ * In 3D vision filed, the Octree is used to process and accelerate the pointcloud data. The class Octree represents
+ * the Octree data structure. Each Octree will have a fixed depth. The depth of Octree refers to the distance from
+ * the root node to the leaf node.All OctreeNodes will not exceed this depth.Increasing the depth will increase
+ * the amount of calculation exponentially. And the small number of depth refers low resolution of Octree.
+ * Each node contains 8 children, which are used to divide the space cube into eight parts. Each octree node represents
+ * a cube. And these eight children will have a fixed order, the order is described as follows:
+ *
+ * For illustration, assume,
+ *
+ * rootNode: origin == (0, 0, 0), size == 2
+ *
+ * Then,
+ *
+ * children[0]: origin == (0, 0, 0), size == 1
+ *
+ * children[1]: origin == (1, 0, 0), size == 1, along X-axis next to child 0
+ *
+ * children[2]: origin == (0, 1, 0), size == 1, along Y-axis next to child 0
+ *
+ * children[3]: origin == (1, 1, 0), size == 1, in X-Y plane
+ *
+ * children[4]: origin == (0, 0, 1), size == 1, along Z-axis next to child 0
+ *
+ * children[5]: origin == (1, 0, 1), size == 1, in X-Z plane
+ *
+ * children[6]: origin == (0, 1, 1), size == 1, in Y-Z plane
+ *
+ * children[7]: origin == (1, 1, 1), size == 1, furthest from child 0
+ */
+
+class CV_EXPORTS_W Octree
+{
+public:
+    //! Default constructor.
+    Octree();
+
+    /** @overload
+     * @brief Creates an empty Octree with given maximum depth
+     *
+     * @param maxDepth The max depth of the Octree
+     * @param size bounding box size for the Octree
+     * @param origin Initial center coordinate
+     * @param withColors Whether to keep per-point colors or not
+     * @return resulting Octree
+     */
+    CV_WRAP static Ptr<Octree> createWithDepth(int maxDepth, double size, const Point3f& origin = { }, bool withColors = false);
+
+    /** @overload
+     * @brief Create an Octree from the PointCloud data with the specific maxDepth
+     *
+     * @param maxDepth Max depth of the octree
+     * @param pointCloud point cloud data, should be 3-channel float array
+     * @param colors color attribute of point cloud in the same 3-channel float format
+     * @return resulting Octree
+     */
+    CV_WRAP static Ptr<Octree> createWithDepth(int maxDepth, InputArray pointCloud, InputArray colors = noArray());
+
+    /** @overload
+     * @brief Creates an empty Octree with given resolution
+     *
+     * @param resolution The size of the octree leaf node
+     * @param size bounding box size for the Octree
+     * @param origin Initial center coordinate
+     * @param withColors Whether to keep per-point colors or not
+     * @return resulting Octree
+     */
+    CV_WRAP static Ptr<Octree> createWithResolution(double resolution, double size, const Point3f& origin = { }, bool withColors = false);
+
+    /** @overload
+     * @brief Create an Octree from the PointCloud data with the specific resolution
+     *
+     * @param resolution The size of the octree leaf node
+     * @param pointCloud point cloud data, should be 3-channel float array
+     * @param colors color attribute of point cloud in the same 3-channel float format
+     * @return resulting octree
+     */
+    CV_WRAP static Ptr<Octree> createWithResolution(double resolution, InputArray pointCloud, InputArray colors = noArray());
+
+    //! Default destructor
+    ~Octree();
+
+    /** @overload
+     * @brief Insert a point data with color to a OctreeNode.
+     *
+     * @param point The point data in Point3f format.
+     * @param color The color attribute of point in Point3f format.
+     * @return Returns whether the insertion is successful.
+     */
+    CV_WRAP bool insertPoint(const Point3f& point, const Point3f& color = { });
+
+    /** @brief Determine whether the point is within the space range of the specific cube.
+     *
+     * @param point The point coordinates.
+     * @return If point is in bound, return ture. Otherwise, false.
+     */
+    CV_WRAP bool isPointInBound(const Point3f& point) const;
+
+    //! returns true if the rootnode is NULL.
+    CV_WRAP bool empty() const;
+
+    /** @brief Reset all octree parameter.
+     *
+     *  Clear all the nodes of the octree and initialize the parameters.
+     */
+    CV_WRAP void clear();
+
+    /** @brief Delete a given point from the Octree.
+     *
+     * Delete the corresponding element from the pointList in the corresponding leaf node. If the leaf node
+     * does not contain other points after deletion, this node will be deleted. In the same way,
+     * its parent node may also be deleted if its last child is deleted.
+     * @param point The point coordinates, comparison is epsilon-based
+     * @return return ture if the point is deleted successfully.
+     */
+    CV_WRAP bool deletePoint(const Point3f& point);
+
+    /** @brief restore point cloud data from Octree.
+     *
+     * Restore the point cloud data from existing octree. The points in same leaf node will be seen as the same point.
+     * This point is the center of the leaf node. If the resolution is small, it will work as a downSampling function.
+     * @param restoredPointCloud The output point cloud data, can be replaced by noArray() if not needed
+     * @param restoredColor The color attribute of point cloud data, can be omitted if not needed
+     */
+    CV_WRAP void getPointCloudByOctree(OutputArray restoredPointCloud, OutputArray restoredColor = noArray());
+
+    /** @brief Radius Nearest Neighbor Search in Octree.
+     *
+     * Search all points that are less than or equal to radius.
+     * And return the number of searched points.
+     * @param query Query point.
+     * @param radius Retrieved radius value.
+     * @param points Point output. Contains searched points in 3-float format, and output vector is not in order,
+     * can be replaced by noArray() if not needed
+     * @param squareDists Dist output. Contains searched squared distance in floats, and output vector is not in order,
+     * can be omitted if not needed
+     * @return the number of searched points.
+     */
+    CV_WRAP int radiusNNSearch(const Point3f& query, float radius, OutputArray points, OutputArray squareDists = noArray()) const;
+
+    /** @overload
+     *  @brief Radius Nearest Neighbor Search in Octree.
+     *
+     * Search all points that are less than or equal to radius.
+     * And return the number of searched points.
+     * @param query Query point.
+     * @param radius Retrieved radius value.
+     * @param points Point output. Contains searched points in 3-float format, and output vector is not in order,
+     * can be replaced by noArray() if not needed
+     * @param colors Color output. Contains colors corresponding to points in pointSet, can be replaced by noArray() if not needed
+     * @param squareDists Dist output. Contains searched squared distance in floats, and output vector is not in order,
+     * can be replaced by noArray() if not needed
+     * @return the number of searched points.
+     */
+    CV_WRAP int radiusNNSearch(const Point3f& query, float radius, OutputArray points, OutputArray colors, OutputArray squareDists) const;
+
+    /** @brief K Nearest Neighbor Search in Octree.
+     *
+     * Find the K nearest neighbors to the query point.
+     * @param query Query point.
+     * @param K amount of nearest neighbors to find
+     * @param points Point output. Contains K points in 3-float format, arranged in order of distance from near to far,
+     * can be replaced by noArray() if not needed
+     * @param squareDists Dist output. Contains K squared distance in floats, arranged in order of distance from near to far,
+     * can be omitted if not needed
+     */
+    CV_WRAP void KNNSearch(const Point3f& query, const int K, OutputArray points, OutputArray squareDists = noArray()) const;
+
+    /** @overload
+     *  @brief K Nearest Neighbor Search in Octree.
+     *
+     * Find the K nearest neighbors to the query point.
+     * @param query Query point.
+     * @param K amount of nearest neighbors to find
+     * @param points Point output. Contains K points in 3-float format, arranged in order of distance from near to far,
+     * can be replaced by noArray() if not needed
+     * @param colors Color output. Contains colors corresponding to points in pointSet, can be replaced by noArray() if not needed
+     * @param squareDists Dist output. Contains K squared distance in floats, arranged in order of distance from near to far,
+     * can be replaced by noArray() if not needed
+     */
+    CV_WRAP void KNNSearch(const Point3f& query, const int K, OutputArray points, OutputArray colors, OutputArray squareDists) const;
+
+protected:
+    struct Impl;
+    Ptr<Impl> p;
+};
+
+} // namespace cv
+
+//! @} ptcloud
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/depth.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/depth.hpp
new file mode 100644
index 0000000..2a40c3d
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/depth.hpp
@@ -0,0 +1,181 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_DEPTH_HPP
+#define OPENCV_3D_DEPTH_HPP
+
+#include <opencv2/core.hpp>
+#include <limits>
+
+namespace cv
+{
+//! @addtogroup rgbd
+//! @{
+
+/** Object that can compute the normals in an image.
+ * It is an object as it can cache data for speed efficiency
+ * The implemented methods are either:
+ * - FALS (the fastest) and SRI from
+ * ``Fast and Accurate Computation of Surface Normals from Range Images``
+ * by H. Badino, D. Huber, Y. Park and T. Kanade
+ * - the normals with bilateral filtering on a depth image from
+ * ``Gradient Response Maps for Real-Time Detection of Texture-Less Objects``
+ * by S. Hinterstoisser, C. Cagniart, S. Ilic, P. Sturm, N. Navab, P. Fua, and V. Lepetit
+ */
+class CV_EXPORTS_W RgbdNormals
+{
+public:
+    enum RgbdNormalsMethod
+    {
+      RGBD_NORMALS_METHOD_FALS = 0,
+      RGBD_NORMALS_METHOD_LINEMOD = 1,
+      RGBD_NORMALS_METHOD_SRI = 2,
+      RGBD_NORMALS_METHOD_CROSS_PRODUCT = 3
+    };
+
+    RgbdNormals() { }
+    virtual ~RgbdNormals() { }
+
+    /** Creates new RgbdNormals object
+     * @param rows the number of rows of the depth image normals will be computed on
+     * @param cols the number of cols of the depth image normals will be computed on
+     * @param depth the depth of the normals (only CV_32F or CV_64F)
+     * @param K the calibration matrix to use
+     * @param window_size the window size to compute the normals: can only be 1,3,5 or 7
+     * @param diff_threshold threshold in depth difference, used in LINEMOD algirithm
+     * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS
+     */
+    CV_WRAP static Ptr<RgbdNormals> create(int rows = 0, int cols = 0, int depth = 0, InputArray K = noArray(), int window_size = 5,
+                                           float diff_threshold = 50.f,
+                                           RgbdNormals::RgbdNormalsMethod method = RgbdNormals::RgbdNormalsMethod::RGBD_NORMALS_METHOD_FALS);
+
+    /** Given a set of 3d points in a depth image, compute the normals at each point.
+     * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S
+     * @param normals a rows x cols x 3 matrix
+     */
+    CV_WRAP virtual void apply(InputArray points, OutputArray normals) const = 0;
+
+    /** Prepares cached data required for calculation
+    * If not called by user, called automatically at first calculation
+    */
+    CV_WRAP virtual void cache() const = 0;
+
+    CV_WRAP virtual int getRows() const = 0;
+    CV_WRAP virtual void setRows(int val) = 0;
+    CV_WRAP virtual int getCols() const = 0;
+    CV_WRAP virtual void setCols(int val) = 0;
+    CV_WRAP virtual int getWindowSize() const = 0;
+    CV_WRAP virtual void setWindowSize(int val) = 0;
+    CV_WRAP virtual int getDepth() const = 0;
+    CV_WRAP virtual void getK(OutputArray val) const = 0;
+    CV_WRAP virtual void setK(InputArray val) = 0;
+    CV_WRAP virtual RgbdNormals::RgbdNormalsMethod getMethod() const = 0;
+};
+
+
+/** Registers depth data to an external camera
+ * Registration is performed by creating a depth cloud, transforming the cloud by
+ * the rigid body transformation between the cameras, and then projecting the
+ * transformed points into the RGB camera.
+ *
+ * uv_rgb = K_rgb * [R | t] * z * inv(K_ir) * uv_ir
+ *
+ * Currently does not check for negative depth values.
+ *
+ * @param unregisteredCameraMatrix the camera matrix of the depth camera
+ * @param registeredCameraMatrix the camera matrix of the external camera
+ * @param registeredDistCoeffs the distortion coefficients of the external camera
+ * @param Rt the rigid body transform between the cameras. Transforms points from depth camera frame to external camera frame.
+ * @param unregisteredDepth the input depth data
+ * @param outputImagePlaneSize the image plane dimensions of the external camera (width, height)
+ * @param registeredDepth the result of transforming the depth into the external camera
+ * @param depthDilation whether or not the depth is dilated to avoid holes and occlusion errors (optional)
+ */
+CV_EXPORTS_W void registerDepth(InputArray unregisteredCameraMatrix, InputArray registeredCameraMatrix, InputArray registeredDistCoeffs,
+                                InputArray Rt, InputArray unregisteredDepth, const Size& outputImagePlaneSize,
+                                OutputArray registeredDepth, bool depthDilation=false);
+
+/**
+ * @param depth the depth image
+ * @param in_K
+ * @param in_points the list of xy coordinates
+ * @param points3d the resulting 3d points (point is represented by 4 chanels value [x, y, z, 0])
+ */
+CV_EXPORTS_W void depthTo3dSparse(InputArray depth, InputArray in_K, InputArray in_points, OutputArray points3d);
+
+/** Converts a depth image to 3d points. If the mask is empty then the resulting array has the same dimensions as `depth`,
+ * otherwise it is 1d vector containing mask-enabled values only.
+ * The coordinate system is x pointing left, y down and z away from the camera
+ * @param depth the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
+ *              (as done with the Microsoft Kinect), otherwise, if given as CV_32F or CV_64F, it is assumed in meters)
+ * @param K The calibration matrix
+ * @param points3d the resulting 3d points (point is represented by 4 channels value [x, y, z, 0]). They are of the same depth as `depth` if it is CV_32F or CV_64F, and the
+ *        depth of `K` if `depth` is of depth CV_16U or CV_16S
+ * @param mask the mask of the points to consider (can be empty)
+ */
+CV_EXPORTS_W void depthTo3d(InputArray depth, InputArray K, OutputArray points3d, InputArray mask = noArray());
+
+/** If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
+ * by depth_factor to get a depth in meters, and the values 0 are converted to std::numeric_limits<float>::quiet_NaN()
+ * Otherwise, the image is simply converted to floats
+ * @param in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
+ *              (as done with the Microsoft Kinect), it is assumed in meters)
+ * @param type the desired output depth (CV_32F or CV_64F)
+ * @param out The rescaled float depth image
+ * @param depth_factor (optional) factor by which depth is converted to distance (by default = 1000.0 for Kinect sensor)
+ */
+CV_EXPORTS_W void rescaleDepth(InputArray in, int type, OutputArray out, double depth_factor = 1000.0);
+
+/** Warps depth or RGB-D image by reprojecting it in 3d, applying Rt transformation
+ * and then projecting it back onto the image plane.
+ * This function can be used to visualize the results of the Odometry algorithm.
+ * @param depth Depth data, should be 1-channel CV_16U, CV_16S, CV_32F or CV_64F
+ * @param image RGB image (optional), should be 1-, 3- or 4-channel CV_8U
+ * @param mask Mask of used pixels (optional), should be CV_8UC1, CV_8SC1 or CV_BoolC1
+ * @param Rt Rotation+translation matrix (3x4 or 4x4) to be applied to depth points
+ * @param cameraMatrix Camera intrinsics matrix (3x3)
+ * @param warpedDepth The warped depth data (optional)
+ * @param warpedImage The warped RGB image (optional)
+ * @param warpedMask The mask of valid pixels in warped image (optional)
+ */
+CV_EXPORTS_W void warpFrame(InputArray depth, InputArray image, InputArray mask, InputArray Rt, InputArray cameraMatrix,
+                            OutputArray warpedDepth = noArray(), OutputArray warpedImage = noArray(), OutputArray warpedMask = noArray());
+
+enum RgbdPlaneMethod
+{
+    RGBD_PLANE_METHOD_DEFAULT
+};
+
+/** Find the planes in a depth image
+ * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels
+ * @param normals the normals for every point in the depth image; optional, can be empty
+ * @param mask An image where each pixel is labeled with the plane it belongs to
+ *        and 255 if it does not belong to any plane
+ * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1
+ *        and c < 0 (so that the normal points towards the camera)
+ * @param block_size The size of the blocks to look at for a stable MSE
+ * @param min_size The minimum size of a cluster to be considered a plane
+ * @param threshold The maximum distance of a point from a plane to belong to it (in meters)
+ * @param sensor_error_a coefficient of the sensor error. 0 by default, use 0.0075 for a Kinect
+ * @param sensor_error_b coefficient of the sensor error. 0 by default
+ * @param sensor_error_c coefficient of the sensor error. 0 by default
+ * @param method The method to use to compute the planes.
+ */
+CV_EXPORTS_W void findPlanes(InputArray points3d, InputArray normals, OutputArray mask, OutputArray plane_coefficients,
+                             int block_size = 40, int min_size = 40*40, double threshold = 0.01,
+                             double sensor_error_a = 0, double sensor_error_b = 0,
+                             double sensor_error_c = 0,
+                             RgbdPlaneMethod method = RGBD_PLANE_METHOD_DEFAULT);
+
+
+
+// TODO Depth interpolation
+// Curvature
+// Get rescaleDepth return dubles if asked for
+
+//! @}
+
+} /* namespace cv */
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/kinfu_frame.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/kinfu_frame.hpp
new file mode 100644
index 0000000..bac9dfe
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/kinfu_frame.hpp
@@ -0,0 +1,19 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_DETAIL_KINFU_FRAME_HPP
+#define OPENCV_3D_DETAIL_KINFU_FRAME_HPP
+
+#include <opencv2/core/affine.hpp>
+
+namespace cv {
+namespace detail {
+
+CV_EXPORTS void renderPointsNormals(InputArray _points, InputArray _normals, OutputArray image, cv::Vec3f lightLoc);
+CV_EXPORTS void renderPointsNormalsColors(InputArray _points, InputArray _normals, InputArray _colors, OutputArray image);
+
+} // namespace detail
+} // namespace cv
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/pose_graph.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/pose_graph.hpp
new file mode 100644
index 0000000..78d98e8
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/pose_graph.hpp
@@ -0,0 +1,77 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef POINTCLOUD_POSE_GRAPTH_HPP
+#define POINTCLOUD_POSE_GRAPTH_HPP
+
+#include "opencv2/core/affine.hpp"
+#include "opencv2/core/quaternion.hpp"
+#include "opencv2/geometry/3d.hpp"
+#include "opencv2/geometry/detail/optimizer.hpp"
+
+namespace cv
+{
+namespace detail
+{
+
+// ATTENTION! This class is used internally in Large KinFu.
+// It has been pushed to publicly available headers for tests only.
+// Source compatibility of this API is not guaranteed in the future.
+
+// This class provides tools to solve so-called pose graph problem often arisen in SLAM problems
+// The pose graph format, cost function and optimization techniques
+// repeat the ones used in Ceres 3D Pose Graph Optimization:
+// http://ceres-solver.org/nnls_tutorial.html#other-examples, pose_graph_3d.cc bullet
+class CV_EXPORTS_W PoseGraph
+{
+public:
+    static Ptr<PoseGraph> create();
+    virtual ~PoseGraph();
+
+    // Node may have any id >= 0
+    virtual void addNode(size_t _nodeId, const Affine3d& _pose, bool fixed) = 0;
+    virtual bool isNodeExist(size_t nodeId) const = 0;
+    virtual bool setNodeFixed(size_t nodeId, bool fixed) = 0;
+    virtual bool isNodeFixed(size_t nodeId) const = 0;
+    virtual Affine3d getNodePose(size_t nodeId) const = 0;
+    virtual std::vector<size_t> getNodesIds() const = 0;
+    virtual size_t getNumNodes() const = 0;
+
+    // Edges have consequent indices starting from 0
+    virtual void addEdge(size_t _sourceNodeId, size_t _targetNodeId, const Affine3f& _transformation,
+                         const Matx66f& _information = Matx66f::eye()) = 0;
+    virtual size_t getEdgeStart(size_t i) const = 0;
+    virtual size_t getEdgeEnd(size_t i) const = 0;
+    virtual Affine3d getEdgePose(size_t i) const = 0;
+    virtual Matx66f getEdgeInfo(size_t i) const = 0;
+    virtual size_t getNumEdges() const = 0;
+
+    // checks if graph is connected and each edge connects exactly 2 nodes
+    virtual bool isValid() const = 0;
+
+    // Calculates an initial pose estimate using the Minimum Spanning Tree (Prim's MST) algorithm.
+    // The result serves as a starting point for further optimization.
+    // Edge weights are calculated as:
+    //     weight = translationNorm + lambda * rotationAngle
+    // The default lambda value (0.485) was empirically chosen based on its impact on optimizer performance,
+    // but can/should be tuned for different datasets.
+    virtual void initializePosesWithMST(double lambda = 0.485) = 0;
+
+    // creates an optimizer with user-defined settings and returns a pointer on it
+    virtual Ptr<cv::detail::LevMarqBase> createOptimizer(const LevMarq::Settings& settings) = 0;
+    // creates an optimizer with default settings and returns a pointer on it
+    virtual Ptr<cv::detail::LevMarqBase> createOptimizer() = 0;
+
+    // Creates an optimizer (with default settings) if it wasn't created before and runs it
+    // Returns number of iterations elapsed or -1 if failed to optimize
+    virtual LevMarq::Report optimize() = 0;
+
+    // calculate cost function based on current nodes parameters
+    virtual double calcEnergy() const = 0;
+};
+
+}  // namespace detail
+}  // namespace cv
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/submap.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/submap.hpp
new file mode 100644
index 0000000..e112562
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/detail/submap.hpp
@@ -0,0 +1,558 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_DETAIL_SUBMAP_HPP
+#define OPENCV_3D_DETAIL_SUBMAP_HPP
+
+#include <opencv2/core.hpp>
+#include <opencv2/core/affine.hpp>
+#include "opencv2/geometry/detail/optimizer.hpp"
+
+//TODO: remove it when it is rewritten to robust pose graph
+#include "opencv2/core/dualquaternion.hpp"
+
+#include <type_traits>
+#include <vector>
+#include <map>
+#include <unordered_map>
+
+
+namespace cv
+{
+namespace detail
+{
+template<typename MatType>
+class Submap
+{
+public:
+    struct PoseConstraint
+    {
+        Affine3f estimatedPose;
+        int weight;
+
+        PoseConstraint() : weight(0){};
+
+        void accumulatePose(const Affine3f& _pose, int _weight = 1)
+        {
+            DualQuatf accPose = DualQuatf::createFromAffine3(estimatedPose) * float(weight) + DualQuatf::createFromAffine3(_pose) * float(_weight);
+            weight += _weight;
+            accPose = accPose / float(weight);
+            estimatedPose = accPose.toAffine3();
+        }
+    };
+    typedef std::map<int, PoseConstraint> Constraints;
+
+    Submap(int _id, const VolumeSettings& settings, const cv::Affine3f& _pose = cv::Affine3f::Identity(),
+           int _startFrameId = 0)
+        : id(_id), pose(_pose), cameraPose(Affine3f::Identity()), startFrameId(_startFrameId),
+          volume(VolumeType::HashTSDF, settings)
+    { }
+    virtual ~Submap() = default;
+
+    virtual void integrate(InputArray _depth, const int currframeId);
+    virtual void raycast(const cv::Affine3f& cameraPose, cv::Size frameSize, cv::Matx33f K,
+                         OutputArray points = noArray(), OutputArray normals = noArray());
+
+    virtual int getTotalAllocatedBlocks() const { return int(volume.getTotalVolumeUnits()); };
+    virtual int getVisibleBlocks(int currFrameId) const
+    {
+        CV_Assert(currFrameId >= startFrameId);
+        //return volume.getVisibleBlocks(currFrameId, FRAME_VISIBILITY_THRESHOLD);
+        return volume.getVisibleBlocks();
+
+    }
+
+    float calcVisibilityRatio(int currFrameId) const
+    {
+        int allocate_blocks = getTotalAllocatedBlocks();
+        int visible_blocks  = getVisibleBlocks(currFrameId);
+        return float(visible_blocks) / float(allocate_blocks);
+    }
+
+    // Adding new Edge for Loop Closure Detection. Return true or false to indicate whether adding success.
+    bool addEdgeToSubmap(const int tarSubmapID, const Affine3f& tarPose);
+
+    //! TODO: Possibly useless
+    virtual void setStartFrameId(int _startFrameId) { startFrameId = _startFrameId; };
+    virtual void setStopFrameId(int _stopFrameId) { stopFrameId = _stopFrameId; };
+
+    void composeCameraPose(const cv::Affine3f& _relativePose) { cameraPose = cameraPose * _relativePose; }
+    PoseConstraint& getConstraint(const int _id)
+    {
+        //! Creates constraints if doesn't exist yet
+        return constraints[_id];
+    }
+
+public:
+    const int id;
+    cv::Affine3f pose;
+    cv::Affine3f cameraPose;
+    Constraints constraints;
+
+    int startFrameId;
+    int stopFrameId;
+    //! TODO: Should we support submaps for regular volumes?
+    static constexpr int FRAME_VISIBILITY_THRESHOLD = 5;
+
+    //! TODO: Add support for GPU arrays (UMat)
+    OdometryFrame frame;
+    OdometryFrame renderFrame;
+
+    Volume volume;
+};
+
+template<typename MatType>
+
+void Submap<MatType>::integrate(InputArray _depth, const int currFrameId)
+{
+    CV_Assert(currFrameId >= startFrameId);
+    volume.integrate(_depth, cameraPose.matrix);
+}
+
+template<typename MatType>
+void Submap<MatType>::raycast(const cv::Affine3f& _cameraPose, cv::Size frameSize, cv::Matx33f K,
+                              OutputArray points, OutputArray normals)
+{
+    if (!points.needed() && !normals.needed())
+    {
+        MatType pts, nrm;
+        //TODO: get depth instead of pts from raycast
+        volume.raycast(_cameraPose.matrix, frameSize.height, frameSize.width, K, pts, nrm);
+
+        std::vector<MatType> pch(3);
+        split(pts, pch);
+
+        renderFrame = frame;
+
+        frame = OdometryFrame(pch[2]);
+    }
+    else
+    {
+        volume.raycast(_cameraPose.matrix, frameSize.height, frameSize.width, K, points, normals);
+    }
+}
+
+template<typename MatType>
+bool Submap<MatType>::addEdgeToSubmap(const int tarSubmapID, const Affine3f& tarPose)
+{
+    auto iter = constraints.find(tarSubmapID);
+
+    // if there is NO edge of currSubmap to tarSubmap.
+    if(iter == constraints.end())
+    {
+        // Frome pose to tarPose transformation
+        Affine3f estimatePose = tarPose * pose.inv();
+
+        // Create new Edge.
+        PoseConstraint& preConstrain = getConstraint(tarSubmapID);
+        preConstrain.accumulatePose(estimatePose, 1);
+
+        return true;
+    } else
+    {
+        return false;
+    }
+}
+
+/**
+ * @brief: Manages all the created submaps for a particular scene
+ */
+template<typename MatType>
+class SubmapManager
+{
+public:
+    enum class Type
+    {
+        NEW            = 0,
+        CURRENT        = 1,
+        RELOCALISATION = 2,
+        LOOP_CLOSURE   = 3,
+        LOST           = 4
+    };
+
+    struct ActiveSubmapData
+    {
+        Type type;
+        std::vector<Affine3f> constraints;
+        int trackingAttempts;
+    };
+
+    typedef Submap<MatType> SubmapT;
+    typedef std::map<int, Ptr<SubmapT>> IdToSubmapPtr;
+    typedef std::unordered_map<int, ActiveSubmapData> IdToActiveSubmaps;
+
+    explicit SubmapManager(const VolumeSettings& _volumeSettings) : volumeSettings(_volumeSettings) {}
+    virtual ~SubmapManager() = default;
+
+    void reset() { submapList.clear(); };
+
+    bool shouldCreateSubmap(int frameId);
+    bool shouldChangeCurrSubmap(int _frameId, int toSubmapId);
+
+    //! Adds a new submap/volume into the current list of managed/Active submaps
+    int createNewSubmap(bool isCurrentActiveMap, const int currFrameId = 0, const Affine3f& pose = cv::Affine3f::Identity());
+
+    void removeSubmap(int _id);
+    size_t numOfSubmaps(void) const { return submapList.size(); };
+    size_t numOfActiveSubmaps(void) const { return activeSubmaps.size(); };
+
+    Ptr<SubmapT> getSubmap(int _id) const;
+    Ptr<SubmapT> getCurrentSubmap(void) const;
+
+    int estimateConstraint(int fromSubmapId, int toSubmapId, int& inliers, Affine3f& inlierPose);
+    bool updateMap(int frameId, const OdometryFrame& frame);
+
+    bool addEdgeToCurrentSubmap(const int currentSubmapID, const int tarSubmapID);
+
+    Ptr<detail::PoseGraph> MapToPoseGraph();
+    void PoseGraphToMap(const Ptr<detail::PoseGraph>& updatedPoseGraph);
+
+    VolumeSettings volumeSettings;
+
+    std::vector<Ptr<SubmapT>> submapList;
+    IdToActiveSubmaps activeSubmaps;
+
+    Ptr<detail::PoseGraph> poseGraph;
+};
+
+template<typename MatType>
+int SubmapManager<MatType>::createNewSubmap(bool isCurrentMap, int currFrameId, const Affine3f& pose)
+{
+    int newId = int(submapList.size());
+
+    Ptr<SubmapT> newSubmap = cv::makePtr<SubmapT>(newId, volumeSettings, pose, currFrameId);
+    submapList.push_back(newSubmap);
+
+    ActiveSubmapData newSubmapData;
+    newSubmapData.trackingAttempts = 0;
+    newSubmapData.type             = isCurrentMap ? Type::CURRENT : Type::NEW;
+    activeSubmaps[newId]           = newSubmapData;
+
+    return newId;
+}
+
+template<typename MatType>
+Ptr<Submap<MatType>> SubmapManager<MatType>::getSubmap(int _id) const
+{
+    CV_Assert(submapList.size() > 0);
+    CV_Assert(_id >= 0 && _id < int(submapList.size()));
+    return submapList.at(_id);
+}
+
+template<typename MatType>
+Ptr<Submap<MatType>> SubmapManager<MatType>::getCurrentSubmap(void) const
+{
+    for (const auto& it : activeSubmaps)
+    {
+        if (it.second.type == Type::CURRENT)
+            return getSubmap(it.first);
+    }
+    return nullptr;
+}
+
+template<typename MatType>
+bool SubmapManager<MatType>::shouldCreateSubmap(int currFrameId)
+{
+    int currSubmapId = -1;
+    for (const auto& it : activeSubmaps)
+    {
+        auto submapData = it.second;
+        // No more than 1 new submap at a time!
+        if (submapData.type == Type::NEW)
+        {
+            return false;
+        }
+        if (submapData.type == Type::CURRENT)
+        {
+            currSubmapId = it.first;
+        }
+    }
+    //! TODO: This shouldn't be happening? since there should always be one active current submap
+    if (currSubmapId < 0)
+    {
+        return false;
+    }
+
+    Ptr<SubmapT> currSubmap = getSubmap(currSubmapId);
+    float ratio             = currSubmap->calcVisibilityRatio(currFrameId);
+
+    //TODO: fix this when a new pose graph is ready
+    // if (ratio < 0.2f)
+    if (ratio < 0.5f)
+        return true;
+    return false;
+}
+
+template<typename MatType>
+int SubmapManager<MatType>::estimateConstraint(int fromSubmapId, int toSubmapId, int& inliers, Affine3f& inlierPose)
+{
+    static constexpr int MAX_ITER                    = 10;
+    static constexpr float CONVERGE_WEIGHT_THRESHOLD = 0.01f;
+    static constexpr float INLIER_WEIGHT_THRESH      = 0.8f;
+    static constexpr int MIN_INLIERS                 = 10;
+    static constexpr int MAX_TRACKING_ATTEMPTS = 25;
+
+    //! thresh = HUBER_THRESH
+    auto huberWeight = [](float residual, float thresh = 0.1f) -> float {
+        float rAbs = abs(residual);
+        if (rAbs < thresh)
+            return 1.0;
+        float numerator = sqrt(2 * thresh * rAbs - thresh * thresh);
+        return numerator / rAbs;
+    };
+
+    Ptr<SubmapT> fromSubmap          = getSubmap(fromSubmapId);
+    Ptr<SubmapT> toSubmap            = getSubmap(toSubmapId);
+    ActiveSubmapData& fromSubmapData = activeSubmaps.at(fromSubmapId);
+
+    Affine3f TcameraToFromSubmap = fromSubmap->cameraPose;
+    Affine3f TcameraToToSubmap   = toSubmap->cameraPose;
+
+    // FromSubmap -> ToSubmap transform
+    Affine3f candidateConstraint = TcameraToToSubmap * TcameraToFromSubmap.inv();
+    fromSubmapData.trackingAttempts++;
+    fromSubmapData.constraints.push_back(candidateConstraint);
+
+    std::vector<float> weights(fromSubmapData.constraints.size() + 1, 1.0f);
+
+    Affine3f prevConstraint = fromSubmap->getConstraint(toSubmap->id).estimatedPose;
+    int prevWeight          = fromSubmap->getConstraint(toSubmap->id).weight;
+
+    // Iterative reweighted least squares with huber threshold to find the inliers in the past observations
+    Vec6f meanConstraint;
+    float sumWeight = 0.0f;
+    for (int i = 0; i < MAX_ITER; i++)
+    {
+        Vec6f constraintVec;
+        for (int j = 0; j < int(weights.size() - 1); j++)
+        {
+            Affine3f currObservation = fromSubmapData.constraints[j];
+            cv::vconcat(currObservation.rvec(), currObservation.translation(), constraintVec);
+            meanConstraint += weights[j] * constraintVec;
+            sumWeight += weights[j];
+        }
+        // Heavier weight given to the estimatedPose
+        cv::vconcat(prevConstraint.rvec(), prevConstraint.translation(), constraintVec);
+        meanConstraint += weights.back() * prevWeight * constraintVec;
+        sumWeight += prevWeight;
+        meanConstraint /= float(sumWeight);
+
+        float residual = 0.0f;
+        float diff     = 0.0f;
+        for (int j = 0; j < int(weights.size()); j++)
+        {
+            int w;
+            if (j == int(weights.size() - 1))
+            {
+                cv::vconcat(prevConstraint.rvec(), prevConstraint.translation(), constraintVec);
+                w = prevWeight;
+            }
+            else
+            {
+                Affine3f currObservation = fromSubmapData.constraints[j];
+                cv::vconcat(currObservation.rvec(), currObservation.translation(), constraintVec);
+                w = 1;
+            }
+
+            cv::Vec6f residualVec = (constraintVec - meanConstraint);
+            residual         = float(norm(residualVec));
+            float newWeight = huberWeight(residual);
+            diff += w * abs(newWeight - weights[j]);
+            weights[j] = newWeight;
+        }
+
+        if (diff / (prevWeight + weights.size() - 1) < CONVERGE_WEIGHT_THRESHOLD)
+            break;
+    }
+
+    int localInliers = 0;
+    DualQuatf inlierConstraint;
+    for (int i = 0; i < int(weights.size()); i++)
+    {
+        if (weights[i] > INLIER_WEIGHT_THRESH)
+        {
+            localInliers++;
+            if (i == int(weights.size() - 1))
+                inlierConstraint += DualQuatf::createFromMat(prevConstraint.matrix);
+            else
+                inlierConstraint += DualQuatf::createFromMat(fromSubmapData.constraints[i].matrix);
+        }
+    }
+    inlierConstraint = inlierConstraint * 1.0f/float(max(localInliers, 1));
+    inlierPose = inlierConstraint.toAffine3();
+    inliers    = localInliers;
+
+    if (inliers >= MIN_INLIERS)
+    {
+        return 1;
+    }
+    if(fromSubmapData.trackingAttempts - inliers > (MAX_TRACKING_ATTEMPTS - MIN_INLIERS))
+    {
+        return -1;
+    }
+
+    return 0;
+}
+
+template<typename MatType>
+bool SubmapManager<MatType>::shouldChangeCurrSubmap(int _frameId, int toSubmapId)
+{
+    auto toSubmap         = getSubmap(toSubmapId);
+    auto toSubmapData     = activeSubmaps.at(toSubmapId);
+    auto currActiveSubmap = getCurrentSubmap();
+
+    int blocksInNewMap = toSubmap->getTotalAllocatedBlocks();
+    float newRatio     = toSubmap->calcVisibilityRatio(_frameId);
+
+    float currRatio = currActiveSubmap->calcVisibilityRatio(_frameId);
+
+    //! TODO: Check for a specific threshold?
+    if (blocksInNewMap <= 0)
+        return false;
+    if ((newRatio > currRatio) && (toSubmapData.type == Type::NEW))
+        return true;
+
+    return false;
+}
+
+template<typename MatType>
+bool SubmapManager<MatType>::addEdgeToCurrentSubmap(const int currentSubmapID, const int tarSubmapID)
+{
+    Ptr<SubmapT> currentSubmap = getSubmap(currentSubmapID);
+    Ptr<SubmapT> tarSubmap = getSubmap(tarSubmapID);
+
+    return currentSubmap->addEdgeToSubmap(tarSubmapID, tarSubmap->pose);
+}
+
+template<typename MatType>
+bool SubmapManager<MatType>::updateMap(int _frameId, const OdometryFrame& _frame)
+{
+    bool mapUpdated = false;
+    int changedCurrentMapId = -1;
+
+    const int currSubmapId  = getCurrentSubmap()->id;
+
+    for (auto& it : activeSubmaps)
+    {
+        int submapId     = it.first;
+        auto& submapData = it.second;
+        if (submapData.type == Type::NEW || submapData.type == Type::LOOP_CLOSURE)
+        {
+            // Check with previous estimate
+            int inliers;
+            Affine3f inlierPose;
+            int constraintUpdate = estimateConstraint(submapId, currSubmapId, inliers, inlierPose);
+            if (constraintUpdate == 1)
+            {
+                typename SubmapT::PoseConstraint& submapConstraint = getSubmap(submapId)->getConstraint(currSubmapId);
+                submapConstraint.accumulatePose(inlierPose, inliers);
+                submapData.constraints.clear();
+                submapData.trackingAttempts = 0;
+
+                if (shouldChangeCurrSubmap(_frameId, submapId))
+                {
+                    changedCurrentMapId = submapId;
+                }
+                mapUpdated = true;
+            }
+            else if(constraintUpdate == -1)
+            {
+                submapData.type = Type::LOST;
+            }
+        }
+    }
+
+    std::vector<int> createNewConstraintsList;
+    for (auto& it : activeSubmaps)
+    {
+        int submapId     = it.first;
+        auto& submapData = it.second;
+
+        if (submapId == changedCurrentMapId)
+        {
+            submapData.type = Type::CURRENT;
+        }
+        if ((submapData.type == Type::CURRENT) && (changedCurrentMapId >= 0) && (submapId != changedCurrentMapId))
+        {
+            submapData.type = Type::LOST;
+            createNewConstraintsList.push_back(submapId);
+        }
+        if ((submapData.type == Type::NEW || submapData.type == Type::LOOP_CLOSURE) && (changedCurrentMapId >= 0))
+        {
+            //! TODO: Add a new type called NEW_LOST?
+            submapData.type = Type::LOST;
+            createNewConstraintsList.push_back(submapId);
+        }
+    }
+
+    for (typename IdToActiveSubmaps::iterator it = activeSubmaps.begin(); it != activeSubmaps.end();)
+    {
+        auto& submapData = it->second;
+        if (submapData.type == Type::LOST)
+            it = activeSubmaps.erase(it);
+        else
+            it++;
+    }
+
+    for (std::vector<int>::const_iterator it = createNewConstraintsList.begin(); it != createNewConstraintsList.end(); ++it)
+    {
+        int dataId = *it;
+        ActiveSubmapData newSubmapData;
+        newSubmapData.trackingAttempts = 0;
+        newSubmapData.type             = Type::LOOP_CLOSURE;
+        activeSubmaps[dataId]          = newSubmapData;
+    }
+
+    if (shouldCreateSubmap(_frameId))
+    {
+        Ptr<SubmapT> currActiveSubmap = getCurrentSubmap();
+        Affine3f newSubmapPose        = currActiveSubmap->pose * currActiveSubmap->cameraPose;
+        int submapId                  = createNewSubmap(false, _frameId, newSubmapPose);
+        auto newSubmap                = getSubmap(submapId);
+        newSubmap->frame              = _frame;
+    }
+
+    return mapUpdated;
+}
+
+template<typename MatType>
+Ptr<detail::PoseGraph> SubmapManager<MatType>::MapToPoseGraph()
+{
+    Ptr<detail::PoseGraph> localPoseGraph = detail::PoseGraph::create();
+
+    for(const auto& currSubmap : submapList)
+    {
+        const typename SubmapT::Constraints& constraintList = currSubmap->constraints;
+        for(const auto& currConstraintPair : constraintList)
+        {
+            // TODO: Handle case with duplicate constraints A -> B and B -> A
+            /* Matx66f informationMatrix = Matx66f::eye() * (currConstraintPair.second.weight/10); */
+            Matx66f informationMatrix = Matx66f::eye();
+            localPoseGraph->addEdge(currSubmap->id, currConstraintPair.first, currConstraintPair.second.estimatedPose, informationMatrix);
+        }
+    }
+
+    for(const auto& currSubmap : submapList)
+    {
+        localPoseGraph->addNode(currSubmap->id, currSubmap->pose, (currSubmap->id == 0));
+    }
+
+    return localPoseGraph;
+}
+
+template <typename MatType>
+void SubmapManager<MatType>::PoseGraphToMap(const Ptr<detail::PoseGraph>& updatedPoseGraph)
+{
+    for(const auto& currSubmap : submapList)
+    {
+        Affine3d pose = updatedPoseGraph->getNodePose(currSubmap->id);
+        if(!updatedPoseGraph->isNodeFixed(currSubmap->id))
+            currSubmap->pose = pose;
+    }
+}
+
+}  // namespace detail
+}  // namespace cv
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry.hpp
new file mode 100644
index 0000000..b1454e0
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry.hpp
@@ -0,0 +1,112 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_ODOMETRY_HPP
+#define OPENCV_3D_ODOMETRY_HPP
+
+#include <opencv2/core.hpp>
+
+#include "odometry_frame.hpp"
+#include "odometry_settings.hpp"
+
+namespace cv
+{
+
+/** These constants are used to set a type of data which odometry will use
+* @param DEPTH     only depth data
+* @param RGB       only rgb image
+* @param RGB_DEPTH depth and rgb data simultaneously
+*/
+enum class OdometryType
+{
+    DEPTH     = 0,
+    RGB       = 1,
+    RGB_DEPTH = 2
+};
+
+/** These constants are used to set the speed and accuracy of odometry
+* @param COMMON accurate but not so fast
+* @param FAST   less accurate but faster
+*/
+enum class OdometryAlgoType
+{
+    COMMON = 0,
+    FAST = 1
+};
+
+class CV_EXPORTS_W Odometry
+{
+public:
+    CV_WRAP Odometry();
+    CV_WRAP explicit Odometry(OdometryType otype);
+    CV_WRAP Odometry(OdometryType otype, const OdometrySettings& settings, OdometryAlgoType algtype);
+    ~Odometry();
+
+    /** Prepare frame for odometry calculation
+     * @param frame odometry prepare this frame as src frame and dst frame simultaneously
+     */
+    CV_WRAP void prepareFrame(OdometryFrame& frame) const;
+
+    /** Prepare frame for odometry calculation
+     * @param srcFrame frame will be prepared as src frame ("original" image)
+     * @param dstFrame frame will be prepared as dsr frame ("rotated" image)
+     */
+    CV_WRAP void prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const;
+
+    /** Compute Rigid Transformation between two frames so that Rt * src = dst
+     * Both frames, source and destination, should have been prepared by calling prepareFrame() first
+     *
+     * @param srcFrame src frame ("original" image)
+     * @param dstFrame dst frame ("rotated" image)
+     * @param Rt Rigid transformation, which will be calculated, in form:
+     * { 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  }
+     * @return true on success, false if failed to find the transformation
+     */
+    CV_WRAP bool compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const;
+    /**
+     * @brief Compute Rigid Transformation between two frames so that Rt * src = dst
+     *
+     * @param srcDepth source depth ("original" image)
+     * @param dstDepth destination depth ("rotated" image)
+     * @param Rt Rigid transformation, which will be calculated, in form:
+     * { 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  }
+     * @return true on success, false if failed to find the transformation
+     */
+    CV_WRAP bool compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const;
+    /**
+     * @brief Compute Rigid Transformation between two frames so that Rt * src = dst
+     *
+     * @param srcDepth source depth ("original" image)
+     * @param srcRGB source RGB
+     * @param dstDepth destination depth ("rotated" image)
+     * @param dstRGB destination RGB
+     * @param Rt Rigid transformation, which will be calculated, in form:
+     * { 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  }
+     * @return true on success, false if failed to find the transformation
+     */
+    CV_WRAP bool compute(InputArray srcDepth, InputArray srcRGB, InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const;
+
+    /**
+     * @brief Get the normals computer object used for normals calculation (if presented).
+     * The normals computer is generated at first need during prepareFrame when normals are required for the ICP algorithm
+     * but not presented by a user. Re-generated each time the related settings change or a new frame arrives with the different size.
+     */
+    CV_WRAP Ptr<RgbdNormals> getNormalsComputer() const;
+
+    class Impl;
+private:
+    Ptr<Impl> impl;
+};
+
+}
+#endif //OPENCV_3D_ODOMETRY_HPP
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_frame.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_frame.hpp
new file mode 100644
index 0000000..8492206
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_frame.hpp
@@ -0,0 +1,108 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_ODOMETRY_FRAME_HPP
+#define OPENCV_3D_ODOMETRY_FRAME_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+/** Indicates what pyramid is to access using getPyramidAt() method:
+*/
+
+enum OdometryFramePyramidType
+{
+    PYR_IMAGE = 0,    //!< The pyramid of grayscale images
+    PYR_DEPTH = 1,    //!< The pyramid of depth images
+    PYR_MASK = 2,     //!< The pyramid of masks
+    PYR_CLOUD = 3,    //!< The pyramid of point clouds, produced from the pyramid of depths
+    PYR_DIX = 4,      //!< The pyramid of dI/dx derivative images
+    PYR_DIY = 5,      //!< The pyramid of dI/dy derivative images
+    PYR_TEXMASK = 6,  //!< The pyramid of "textured" masks (i.e. additional masks for normals or grayscale images)
+    PYR_NORM = 7,     //!< The pyramid of normals
+    PYR_NORMMASK = 8, //!< The pyramid of normals masks
+    N_PYRAMIDS
+};
+
+/**
+ * @brief An object that keeps per-frame data for Odometry algorithms from user-provided images to algorithm-specific precalculated data.
+ * When not empty, it contains a depth image, a mask of valid pixels and a set of pyramids generated from that data.
+ * A BGR/Gray image and normals are optional.
+ * OdometryFrame is made to be used together with Odometry class to reuse precalculated data between Rt data calculations.
+ * A correct way to do that is to call Odometry::prepareFrames() on prev and next frames and then pass them to Odometry::compute() method.
+ */
+class CV_EXPORTS_W_SIMPLE OdometryFrame
+{
+public:
+    /**
+     * @brief Construct a new OdometryFrame object. All non-empty images should have the same size.
+     *
+     * @param depth A depth image, should be CV_8UC1
+     * @param image An BGR or grayscale image (or noArray() if it's not required for used ICP algorithm).
+     * Should be CV_8UC3 or CV_8C4 if it's BGR image or CV_8UC1 if it's grayscale. If it's BGR then it's converted to grayscale
+     * image automatically.
+     * @param mask A user-provided mask of valid pixels, should be CV_8UC1
+     * @param normals A user-provided normals to the depth surface, should be CV_32FC4
+     */
+    CV_WRAP explicit OdometryFrame(InputArray depth = noArray(), InputArray image = noArray(), InputArray mask = noArray(), InputArray normals = noArray());
+    ~OdometryFrame() {};
+
+    /**
+     * @brief Get the original user-provided BGR/Gray image
+     *
+     * @param image Output image
+     */
+    CV_WRAP void getImage(OutputArray image) const;
+    /**
+     * @brief Get the gray image generated from the user-provided BGR/Gray image
+     *
+     * @param image Output image
+     */
+    CV_WRAP void getGrayImage(OutputArray image) const;
+    /**
+     * @brief Get the original user-provided depth image
+     *
+     * @param depth Output image
+     */
+    CV_WRAP void getDepth(OutputArray depth) const;
+    /**
+     * @brief Get the depth image generated from the user-provided one after conversion, rescale or filtering for ICP algorithm needs
+     *
+     * @param depth Output image
+     */
+    CV_WRAP void getProcessedDepth(OutputArray depth) const;
+    /**
+     * @brief Get the valid pixels mask generated for the ICP calculations intersected with the user-provided mask
+     *
+     * @param mask Output image
+     */
+    CV_WRAP void getMask(OutputArray mask) const;
+    /**
+     * @brief Get the normals image either generated for the ICP calculations or user-provided
+     *
+     * @param normals Output image
+     */
+    CV_WRAP void getNormals(OutputArray normals) const;
+
+    /**
+     * @brief Get the amount of levels in pyramids (all of them if not empty should have the same number of levels)
+     * or 0 if no pyramids were prepared yet
+     */
+    CV_WRAP int getPyramidLevels() const;
+    /**
+     * @brief Get the image generated for the ICP calculations from one of the pyramids specified by pyrType. Returns empty image if
+     * the pyramid is empty or there's no such pyramid level
+     *
+     * @param img Output image
+     * @param pyrType Type of pyramid
+     * @param level Level in the pyramid
+     */
+    CV_WRAP void getPyramidAt(OutputArray img, OdometryFramePyramidType pyrType, size_t level) const;
+
+    class Impl;
+    Ptr<Impl> impl;
+};
+}
+#endif // !OPENCV_3D_ODOMETRY_FRAME_HPP
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_settings.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_settings.hpp
new file mode 100644
index 0000000..4212473
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/odometry_settings.hpp
@@ -0,0 +1,65 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_ODOMETRY_SETTINGS_HPP
+#define OPENCV_3D_ODOMETRY_SETTINGS_HPP
+
+#include <opencv2/core.hpp>
+
+namespace cv
+{
+
+class CV_EXPORTS_W_SIMPLE OdometrySettings
+{
+public:
+    CV_WRAP OdometrySettings();
+    OdometrySettings(const OdometrySettings&);
+    OdometrySettings& operator=(const OdometrySettings&);
+    ~OdometrySettings() {};
+    CV_WRAP void setCameraMatrix(InputArray val);
+    CV_WRAP void getCameraMatrix(OutputArray val) const;
+    CV_WRAP void setIterCounts(InputArray val);
+    CV_WRAP void getIterCounts(OutputArray val) const;
+
+    CV_WRAP void  setMinDepth(float val);
+    CV_WRAP float getMinDepth() const;
+    CV_WRAP void  setMaxDepth(float val);
+    CV_WRAP float getMaxDepth() const;
+    CV_WRAP void  setMaxDepthDiff(float val);
+    CV_WRAP float getMaxDepthDiff() const;
+    CV_WRAP void  setMaxPointsPart(float val);
+    CV_WRAP float getMaxPointsPart() const;
+
+    CV_WRAP void setSobelSize(int val);
+    CV_WRAP int  getSobelSize() const;
+    CV_WRAP void   setSobelScale(double val);
+    CV_WRAP double getSobelScale() const;
+
+    CV_WRAP void setNormalWinSize(int val);
+    CV_WRAP int  getNormalWinSize() const;
+    CV_WRAP void setNormalDiffThreshold(float val);
+    CV_WRAP float getNormalDiffThreshold() const;
+    CV_WRAP void setNormalMethod(RgbdNormals::RgbdNormalsMethod nm);
+    CV_WRAP RgbdNormals::RgbdNormalsMethod getNormalMethod() const;
+
+    CV_WRAP void  setAngleThreshold(float val);
+    CV_WRAP float getAngleThreshold() const;
+    CV_WRAP void  setMaxTranslation(float val);
+    CV_WRAP float getMaxTranslation() const;
+    CV_WRAP void  setMaxRotation(float val);
+    CV_WRAP float getMaxRotation() const;
+
+    CV_WRAP void  setMinGradientMagnitude(float val);
+    CV_WRAP float getMinGradientMagnitude() const;
+    CV_WRAP void setMinGradientMagnitudes(InputArray val);
+    CV_WRAP void getMinGradientMagnitudes(OutputArray val) const;
+
+    class Impl;
+
+private:
+    Ptr<Impl> impl;
+};
+
+}
+#endif //OPENCV_3D_ODOMETRY_SETTINGS_HPP
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume.hpp
new file mode 100644
index 0000000..fe7cc7c
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume.hpp
@@ -0,0 +1,172 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_VOLUME_HPP
+#define OPENCV_3D_VOLUME_HPP
+
+#include "volume_settings.hpp"
+
+#include "opencv2/ptcloud/odometry_frame.hpp"
+#include "opencv2/core/affine.hpp"
+
+namespace cv
+{
+
+class CV_EXPORTS_W Volume
+{
+public:
+    /** @brief Constructor of custom volume.
+    * @param vtype the volume type [TSDF, HashTSDF, ColorTSDF].
+    * @param settings the custom settings for volume.
+    */
+    CV_WRAP explicit Volume(VolumeType vtype = VolumeType::TSDF,
+                            const VolumeSettings& settings = VolumeSettings(VolumeType::TSDF));
+    ~Volume();
+
+    /** @brief Integrates the input data to the volume.
+
+    Camera intrinsics are taken from volume settings structure.
+
+    * @param frame the object from which to take depth and image data.
+      For color TSDF a depth data should be registered with color data, i.e. have the same intrinsics & camera pose.
+      This can be done using function registerDepth() from 3d module.
+    * @param pose the pose of camera in global coordinates.
+    */
+    CV_WRAP_AS(integrateFrame) void integrate(const OdometryFrame& frame, InputArray pose);
+
+    /** @brief Integrates the input data to the volume.
+
+    Camera intrinsics are taken from volume settings structure.
+
+    * @param depth the depth image.
+    * @param pose the pose of camera in global coordinates.
+    */
+    CV_WRAP_AS(integrate) void integrate(InputArray depth, InputArray pose);
+
+    /** @brief Integrates the input data to the volume.
+
+    Camera intrinsics are taken from volume settings structure.
+
+    * @param depth the depth image.
+    * @param image the color image (only for ColorTSDF).
+      For color TSDF a depth data should be registered with color data, i.e. have the same intrinsics & camera pose.
+      This can be done using function registerDepth() from 3d module.
+    * @param pose the pose of camera in global coordinates.
+    */
+    CV_WRAP_AS(integrateColor) void integrate(InputArray depth, InputArray image, InputArray pose);
+
+    // Python bindings do not process noArray() default argument correctly, so the raycast() method is repeated several times
+
+    /** @brief Renders the volume contents into an image. The resulting points and normals are in camera's coordinate system.
+
+    Rendered image size and camera intrinsics are taken from volume settings structure.
+
+    * @param cameraPose the pose of camera in global coordinates.
+    * @param points image to store rendered points.
+    * @param normals image to store rendered normals corresponding to points.
+    */
+    CV_WRAP void raycast(InputArray cameraPose, OutputArray points, OutputArray normals) const;
+
+    /** @brief Renders the volume contents into an image. The resulting points and normals are in camera's coordinate system.
+
+    Rendered image size and camera intrinsics are taken from volume settings structure.
+
+    * @param cameraPose the pose of camera in global coordinates.
+    * @param points image to store rendered points.
+    * @param normals image to store rendered normals corresponding to points.
+    * @param colors image to store rendered colors corresponding to points (only for ColorTSDF).
+    */
+    CV_WRAP_AS(raycastColor) void raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors) const;
+
+    /** @brief Renders the volume contents into an image. The resulting points and normals are in camera's coordinate system.
+
+    Rendered image size and camera intrinsics are taken from volume settings structure.
+
+    * @param cameraPose the pose of camera in global coordinates.
+    * @param height the height of result image
+    * @param width the width of result image
+    * @param K camera raycast intrinsics
+    * @param points image to store rendered points.
+    * @param normals image to store rendered normals corresponding to points.
+    */
+    CV_WRAP_AS(raycastEx) void raycast(InputArray cameraPose, int height, int width, InputArray K, OutputArray points, OutputArray normals) const;
+
+
+    /** @brief Renders the volume contents into an image. The resulting points and normals are in camera's coordinate system.
+
+    Rendered image size and camera intrinsics are taken from volume settings structure.
+
+    * @param cameraPose the pose of camera in global coordinates.
+    * @param height the height of result image
+    * @param width the width of result image
+    * @param K camera raycast intrinsics
+    * @param points image to store rendered points.
+    * @param normals image to store rendered normals corresponding to points.
+    * @param colors image to store rendered colors corresponding to points (only for ColorTSDF).
+    */
+    CV_WRAP_AS(raycastExColor) void raycast(InputArray cameraPose, int height, int width, InputArray K, OutputArray points, OutputArray normals, OutputArray colors) const;
+
+    /** @brief Extract the all data from volume.
+    * @param points the input exist point.
+    * @param normals the storage of normals (corresponding to input points) in the image.
+    */
+    CV_WRAP void fetchNormals(InputArray points, OutputArray normals) const;
+    /** @brief Extract the all data from volume.
+    * @param points the storage of all points.
+    * @param normals the storage of all normals, corresponding to points.
+    */
+    CV_WRAP void fetchPointsNormals(OutputArray points, OutputArray normals) const;
+    /** @brief Extract the all data from volume.
+    * @param points the storage of all points.
+    * @param normals the storage of all normals, corresponding to points.
+    * @param colors the storage of all colors, corresponding to points (only for ColorTSDF).
+    */
+    CV_WRAP void fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const;
+
+    /** @brief clear all data in volume.
+    */
+    CV_WRAP void reset();
+
+    //TODO: remove this
+    /** @brief return visible blocks in volume.
+    */
+    CV_WRAP int getVisibleBlocks() const;
+
+    /** @brief return number of volume units in volume.
+    */
+    CV_WRAP size_t getTotalVolumeUnits() const;
+
+    enum BoundingBoxPrecision
+    {
+        VOLUME_UNIT = 0,
+        VOXEL = 1
+    };
+
+    /**
+     * @brief Gets bounding box in volume coordinates with given precision:
+     * VOLUME_UNIT - up to volume unit
+     * VOXEL - up to voxel (currently not supported)
+     * @param bb 6-float 1d array containing (min_x, min_y, min_z, max_x, max_y, max_z) in volume coordinates
+     * @param precision bounding box calculation precision
+     */
+    CV_WRAP void getBoundingBox(OutputArray bb, int precision) const;
+
+    /**
+     * @brief Enables or disables new volume unit allocation during integration.
+     * Makes sense for HashTSDF only.
+     */
+    CV_WRAP void setEnableGrowth(bool v);
+    /**
+     * @brief Returns if new volume units are allocated during integration or not.
+     * Makes sense for HashTSDF only.
+     */
+    CV_WRAP bool getEnableGrowth() const;
+
+    class Impl;
+private:
+    Ptr<Impl> impl;
+};
+
+}  // namespace cv
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume_settings.hpp b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume_settings.hpp
new file mode 100644
index 0000000..cb030ee
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/include/opencv2/ptcloud/volume_settings.hpp
@@ -0,0 +1,208 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+
+#ifndef OPENCV_3D_VOLUME_SETTINGS_HPP
+#define OPENCV_3D_VOLUME_SETTINGS_HPP
+
+#include <opencv2/core.hpp>
+#include <opencv2/ptcloud/volume.hpp>
+
+namespace cv
+{
+
+enum class VolumeType
+{
+    TSDF = 0,
+    HashTSDF = 1,
+    ColorTSDF = 2
+};
+
+
+class CV_EXPORTS_W_SIMPLE VolumeSettings
+{
+public:
+    /** @brief Constructor of settings for custom Volume type.
+    * @param volumeType volume type.
+    */
+    CV_WRAP explicit VolumeSettings(VolumeType volumeType = VolumeType::TSDF);
+
+    VolumeSettings(const VolumeSettings& vs);
+    VolumeSettings& operator=(const VolumeSettings&);
+    ~VolumeSettings();
+
+    /** @brief Sets the width of the image for integration.
+    * @param val input value.
+    */
+    CV_WRAP void setIntegrateWidth(int val);
+
+    /** @brief Returns the width of the image for integration.
+    */
+    CV_WRAP int getIntegrateWidth() const;
+
+    /** @brief Sets the height of the image for integration.
+    * @param val input value.
+    */
+    CV_WRAP void setIntegrateHeight(int val);
+
+    /** @brief Returns the height of the image for integration.
+    */
+    CV_WRAP int getIntegrateHeight() const;
+
+    /** @brief Sets the width of the raycasted image, used when user does not provide it at raycast() call.
+    * @param val input value.
+    */
+    CV_WRAP void setRaycastWidth(int val);
+
+    /** @brief Returns the width of the raycasted image, used when user does not provide it at raycast() call.
+    */
+    CV_WRAP int getRaycastWidth() const;
+
+    /** @brief Sets the height of the raycasted image, used when user does not provide it at raycast() call.
+    * @param val input value.
+    */
+    CV_WRAP void setRaycastHeight(int val);
+
+    /** @brief Returns the height of the raycasted image, used when user does not provide it at raycast() call.
+    */
+    CV_WRAP int getRaycastHeight() const;
+
+    /** @brief Sets depth factor, witch is the number for depth scaling.
+    * @param val input value.
+    */
+    CV_WRAP void setDepthFactor(float val);
+
+    /** @brief Returns depth factor, witch is the number for depth scaling.
+    */
+    CV_WRAP float getDepthFactor() const;
+
+    /** @brief Sets the size of voxel.
+    * @param val input value.
+    */
+    CV_WRAP void setVoxelSize(float val);
+
+    /** @brief Returns the size of voxel.
+    */
+    CV_WRAP float getVoxelSize() const;
+
+    /** @brief Sets TSDF truncation distance. Distances greater than value from surface will be truncated to 1.0.
+    * @param val input value.
+    */
+    CV_WRAP void setTsdfTruncateDistance(float val);
+
+    /** @brief Returns TSDF truncation distance. Distances greater than value from surface will be truncated to 1.0.
+    */
+    CV_WRAP float getTsdfTruncateDistance() const;
+
+    /** @brief Sets threshold for depth truncation in meters. Truncates the depth greater than threshold to 0.
+    * @param val input value.
+    */
+    CV_WRAP void setMaxDepth(float val);
+
+    /** @brief Returns threshold for depth truncation in meters. Truncates the depth greater than threshold to 0.
+    */
+    CV_WRAP float getMaxDepth() const;
+
+    /** @brief Sets max number of frames to integrate per voxel.
+        Represents the max number of frames over which a running average of the TSDF is calculated for a voxel.
+    * @param val input value.
+    */
+    CV_WRAP void setMaxWeight(int val);
+
+    /** @brief Returns max number of frames to integrate per voxel.
+        Represents the max number of frames over which a running average of the TSDF is calculated for a voxel.
+    */
+    CV_WRAP int getMaxWeight() const;
+
+    /** @brief Sets length of single raycast step.
+        Describes the percentage of voxel length that is skipped per march.
+    * @param val input value.
+    */
+    CV_WRAP void setRaycastStepFactor(float val);
+
+    /** @brief Returns length of single raycast step.
+        Describes the percentage of voxel length that is skipped per march.
+    */
+    CV_WRAP float getRaycastStepFactor() const;
+
+    /** @brief Sets volume pose.
+    * @param val input value.
+    */
+    CV_WRAP void setVolumePose(InputArray val);
+
+    /** @brief Sets volume pose.
+    * @param val output value.
+    */
+    CV_WRAP void getVolumePose(OutputArray val) const;
+
+    /** @brief Resolution of voxel space.
+        Number of voxels in each dimension.
+        Applicable only for TSDF Volume.
+        HashTSDF volume only supports equal resolution in all three dimensions.
+    * @param val input value.
+    */
+    CV_WRAP void setVolumeResolution(InputArray val);
+
+    /** @brief Resolution of voxel space.
+        Number of voxels in each dimension.
+        Applicable only for TSDF Volume.
+        HashTSDF volume only supports equal resolution in all three dimensions.
+    * @param val output value.
+    */
+    CV_WRAP void getVolumeResolution(OutputArray val) const;
+
+    /** @brief Returns 3 integers representing strides by x, y and z dimension.
+        Can be used to iterate over raw volume unit data.
+    * @param val output value.
+    */
+    CV_WRAP void getVolumeStrides(OutputArray val) const;
+
+    /** @brief Sets intrinsics of camera for integrations.
+    * Format of input:
+    * [ fx  0 cx ]
+    * [  0 fy cy ]
+    * [  0  0  1 ]
+    * where fx and fy are focus points of Ox and Oy axises, and cx and cy are central points of Ox and Oy axises.
+    * @param val input value.
+    */
+    CV_WRAP void setCameraIntegrateIntrinsics(InputArray val);
+
+    /** @brief Returns intrinsics of camera for integrations.
+    * Format of output:
+    * [ fx  0 cx ]
+    * [  0 fy cy ]
+    * [  0  0  1 ]
+    * where fx and fy are focus points of Ox and Oy axises, and cx and cy are central points of Ox and Oy axises.
+    * @param val output value.
+    */
+    CV_WRAP void getCameraIntegrateIntrinsics(OutputArray val) const;
+
+    /** @brief Sets camera intrinsics for raycast image which, used when user does not provide them at raycast() call.
+    * Format of input:
+    * [ fx  0 cx ]
+    * [  0 fy cy ]
+    * [  0  0  1 ]
+    * where fx and fy are focus points of Ox and Oy axises, and cx and cy are central points of Ox and Oy axises.
+    * @param val input value.
+    */
+    CV_WRAP void setCameraRaycastIntrinsics(InputArray val);
+
+    /** @brief Returns camera intrinsics for raycast image, used when user does not provide them at raycast() call.
+    * Format of output:
+    * [ fx  0 cx ]
+    * [  0 fy cy ]
+    * [  0  0  1 ]
+    * where fx and fy are focus points of Ox and Oy axises, and cx and cy are central points of Ox and Oy axises.
+    * @param val output value.
+    */
+    CV_WRAP void getCameraRaycastIntrinsics(OutputArray val) const;
+
+    class Impl;
+private:
+    Ptr<Impl> impl;
+};
+
+}
+
+#endif // !OPENCV_3D_VOLUME_SETTINGS_HPP
diff --git a/upstream/opencv/modules/ptcloud/samples/odometry_evaluation.cpp b/upstream/opencv/modules/ptcloud/samples/odometry_evaluation.cpp
new file mode 100644
index 0000000..0a3a0fb
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/samples/odometry_evaluation.cpp
@@ -0,0 +1,225 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include <opencv2/ptcloud.hpp>
+
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/core/utility.hpp>
+#include <opencv2/core/quaternion.hpp>
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+using namespace cv;
+
+#define BILATERAL_FILTER 0// if 1 then bilateral filter will be used for the depth
+
+static
+void writeResults( const string& filename, const vector<string>& timestamps, const vector<Mat>& Rt )
+{
+    CV_Assert( timestamps.size() == Rt.size() );
+
+    ofstream file( filename.c_str() );
+    if( !file.is_open() )
+        return;
+
+    cout.precision(4);
+    for( size_t i = 0; i < Rt.size(); i++ )
+    {
+        const Mat& Rt_curr = Rt[i];
+        if( Rt_curr.empty() )
+            continue;
+
+        CV_Assert( Rt_curr.type() == CV_64FC1 );
+
+        Quatd rot = Quatd::createFromRotMat(Rt_curr(Rect(0, 0, 3, 3)));
+
+        // timestamp tx ty tz qx qy qz qw
+        file << timestamps[i] << " " << fixed
+             << Rt_curr.at<double>(0,3) << " " << Rt_curr.at<double>(1,3) << " " << Rt_curr.at<double>(2,3) << " "
+             << rot.x << " " << rot.y << " " << rot.z << " " << rot.w << endl;
+
+    }
+    file.close();
+}
+
+static
+void setCameraMatrixFreiburg1(float& fx, float& fy, float& cx, float& cy)
+{
+    fx = 517.3f; fy = 516.5f; cx = 318.6f; cy = 255.3f;
+}
+
+static
+void setCameraMatrixFreiburg2(float& fx, float& fy, float& cx, float& cy)
+{
+    fx = 520.9f; fy = 521.0f; cx = 325.1f; cy = 249.7f;
+}
+
+/*
+ * This sample helps to evaluate odometry on TUM datasets and benchmark http://vision.in.tum.de/data/datasets/rgbd-dataset.
+ * At this link you can find instructions for evaluation. The sample runs some opencv odometry and saves a camera trajectory
+ * to file of format that the benchmark requires. Saved file can be used for online evaluation.
+ */
+int main(int argc, char** argv)
+{
+    if(argc != 4)
+    {
+        cout << "Format: file_with_rgb_depth_pairs trajectory_file odometry_name [Rgbd or ICP or RgbdICP or FastICP]" << endl;
+        return -1;
+    }
+
+    vector<string> timestamps;
+    vector<Mat> Rts;
+
+    const string filename = argv[1];
+    ifstream file( filename.c_str() );
+    if( !file.is_open() )
+        return -1;
+
+    char dlmrt1 = '/';
+    char dlmrt2 = '\\';
+
+    size_t pos1 = filename.rfind(dlmrt1);
+    size_t pos2 = filename.rfind(dlmrt2);
+    size_t pos = pos1 < pos2 ? pos1 : pos2;
+    char dlmrt = pos1 < pos2 ? dlmrt1 : dlmrt2;
+
+    string dirname = pos == string::npos ? "" : filename.substr(0, pos) + dlmrt;
+
+    const int timestampLength = 17;
+    const int rgbPathLehgth = 17+8;
+    const int depthPathLehgth = 17+10;
+
+    float fx = 525.0f, // default
+          fy = 525.0f,
+          cx = 319.5f,
+          cy = 239.5f;
+    if(filename.find("freiburg1") != string::npos)
+        setCameraMatrixFreiburg1(fx, fy, cx, cy);
+    if(filename.find("freiburg2") != string::npos)
+        setCameraMatrixFreiburg2(fx, fy, cx, cy);
+    Mat cameraMatrix = Mat::eye(3,3,CV_32FC1);
+    {
+        cameraMatrix.at<float>(0,0) = fx;
+        cameraMatrix.at<float>(1,1) = fy;
+        cameraMatrix.at<float>(0,2) = cx;
+        cameraMatrix.at<float>(1,2) = cy;
+    }
+
+    OdometrySettings ods;
+    ods.setCameraMatrix(cameraMatrix);
+    Odometry odometry;
+    String odname = string(argv[3]);
+    if (odname == "Rgbd")
+        odometry = Odometry(OdometryType::RGB, ods, OdometryAlgoType::COMMON);
+    else if (odname == "ICP")
+        odometry = Odometry(OdometryType::DEPTH, ods, OdometryAlgoType::COMMON);
+    else if (odname == "RgbdICP")
+        odometry = Odometry(OdometryType::RGB_DEPTH, ods, OdometryAlgoType::COMMON);
+    else if (odname == "FastICP")
+        odometry = Odometry(OdometryType::DEPTH, ods, OdometryAlgoType::FAST);
+    else
+    {
+        std::cout << "Can not create Odometry algorithm. Check the passed odometry name." << std::endl;
+        return -1;
+    }
+
+    OdometryFrame frame_prev, frame_curr;
+
+    TickMeter gtm;
+    int count = 0;
+    for(int i = 0; !file.eof(); i++)
+    {
+        string str;
+        std::getline(file, str);
+        if(str.empty()) break;
+        if(str.at(0) == '#') continue; /* comment */
+
+        Mat image, depth;
+        // Read one pair (rgb and depth)
+        // example: 1305031453.359684 rgb/1305031453.359684.png 1305031453.374112 depth/1305031453.374112.png
+#if BILATERAL_FILTER
+        TickMeter tm_bilateral_filter;
+#endif
+        {
+            string rgbFilename = str.substr(timestampLength + 1, rgbPathLehgth );
+            string timestap = str.substr(0, timestampLength);
+            string depthFilename = str.substr(2*timestampLength + rgbPathLehgth + 3, depthPathLehgth );
+
+            image = imread(dirname + rgbFilename);
+            depth = imread(dirname + depthFilename, -1);
+
+            CV_Assert(!image.empty());
+            CV_Assert(!depth.empty());
+            CV_Assert(depth.type() == CV_16UC1);
+
+            // scale depth
+            Mat depth_flt;
+            depth.convertTo(depth_flt, CV_32FC1, 1.f/5000.f);
+#if !BILATERAL_FILTER
+            depth_flt.setTo(std::numeric_limits<float>::quiet_NaN(), depth == 0);
+            depth = depth_flt;
+#else
+            tm_bilateral_filter.start();
+            depth = Mat(depth_flt.size(), CV_32FC1, Scalar(0));
+            const double depth_sigma = 0.03;
+            const double space_sigma = 4.5;  // in pixels
+            Mat invalidDepthMask = depth_flt == 0.f;
+            depth_flt.setTo(-5*depth_sigma, invalidDepthMask);
+            bilateralFilter(depth_flt, depth, -1, depth_sigma, space_sigma);
+            depth.setTo(std::numeric_limits<float>::quiet_NaN(), invalidDepthMask);
+            tm_bilateral_filter.stop();
+            cout << "Time filter " << tm_bilateral_filter.getTimeSec() << endl;
+#endif
+            timestamps.push_back( timestap );
+        }
+
+        {
+            Mat gray;
+            cvtColor(image, gray, COLOR_BGR2GRAY);
+            frame_curr = OdometryFrame(depth, gray);
+
+            Mat Rt;
+            if(!Rts.empty())
+            {
+                TickMeter tm;
+                tm.start();
+                gtm.start();
+                odometry.prepareFrames(frame_curr, frame_prev);
+                bool res = odometry.compute(frame_curr, frame_prev, Rt);
+                gtm.stop();
+                tm.stop();
+                count++;
+                cout << "Time " << tm.getTimeSec() << endl;
+#if BILATERAL_FILTER
+                cout << "Time ratio " << tm_bilateral_filter.getTimeSec() / tm.getTimeSec() << endl;
+#endif
+                if(!res)
+                    Rt = Mat::eye(4,4,CV_64FC1);
+            }
+
+            if( Rts.empty() )
+                Rts.push_back(Mat::eye(4,4,CV_64FC1));
+            else
+            {
+                Mat& prevRt = *Rts.rbegin();
+                cout << "Rt " << Rt << endl;
+                Rts.push_back( prevRt * Rt );
+            }
+
+            //if (!frame_prev.empty())
+            //    frame_prev.release();
+            frame_prev = frame_curr;
+            frame_curr = OdometryFrame();
+            //std::swap(frame_prev, frame_curr);
+        }
+    }
+
+    std::cout << "Average time " << gtm.getAvgTimeSec() << std::endl;
+    writeResults(argv[2], timestamps, Rts);
+
+    return 0;
+}
diff --git a/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp b/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp
new file mode 100644
index 0000000..52c92d5
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.cpp
@@ -0,0 +1,1229 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#include "precomp.hpp"
+#include "color_tsdf_functions.hpp"
+#include "opencl_kernels_ptcloud.hpp"
+
+namespace cv {
+
+
+void integrateColorTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose,
+                                  InputArray _depth, InputArray _rgb, InputArray _pixNorms, InputArray _volume)
+{
+    Matx44f volumePose;
+    settings.getVolumePose(volumePose);
+    integrateColorTsdfVolumeUnit(settings, volumePose, cameraPose, _depth, _rgb, _pixNorms, _volume);
+}
+
+
+void integrateColorTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& volumePose, const Matx44f& cameraPose,
+                                  InputArray _depth, InputArray _rgb, InputArray _pixNorms, InputArray _volume)
+{
+    CV_TRACE_FUNCTION();
+
+    Depth depth = _depth.getMat();
+    Colors color = _rgb.getMat();
+    Mat volume = _volume.getMat();
+    Mat pixNorms = _pixNorms.getMat();
+
+    RGBTsdfVoxel* volDataStart = volume.ptr<RGBTsdfVoxel>();
+
+    Vec4i volStrides;
+    settings.getVolumeStrides(volStrides);
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    float voxelSize = settings.getVoxelSize();
+
+    const Affine3f pose = Affine3f(volumePose);
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    const Intr::Projector projDepth = Intr(intr).makeProjector();
+
+    const float dfac(1.f / settings.getDepthFactor());
+    const float truncDist = settings.getTsdfTruncateDistance();
+    const float truncDistInv = 1.f / truncDist;
+    const int maxWeight = settings.getMaxWeight();
+
+    Range integrateRange(0, volResolution.x);
+
+#if USE_INTRINSICS
+    auto IntegrateInvoker = [&](const Range& range)
+    {
+        // zStep == vol2cam*(Point3f(x, y, 1)*voxelSize) - basePt;
+        Point3f zStepPt = Point3f(vol2cam.matrix(0, 2),
+            vol2cam.matrix(1, 2),
+            vol2cam.matrix(2, 2)) * voxelSize;
+
+        v_float32x4 zStep(zStepPt.x, zStepPt.y, zStepPt.z, 0);
+        v_float32x4 vfxy(projDepth.fx, projDepth.fy, 0.f, 0.f), vcxy(projDepth.cx, projDepth.cy, 0.f, 0.f);
+        const v_float32x4 upLimits = v_cvt_f32(v_int32x4(depth.cols - 1, depth.rows - 1, 0, 0));
+
+        for (int x = range.start; x < range.end; x++)
+        {
+            RGBTsdfVoxel* volDataX = volDataStart + x * volStrides[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                RGBTsdfVoxel* volDataY = volDataX + y * volStrides[1];
+                // optimization of camSpace transformation (vector addition instead of matmul at each z)
+                Point3f basePt = vol2cam * (Point3f((float)x, (float)y, 0) * voxelSize);
+                v_float32x4 camSpacePt(basePt.x, basePt.y, basePt.z, 0);
+
+                int startZ, endZ;
+                if (abs(zStepPt.z) > 1e-5)
+                {
+                    int baseZ = (int)(-basePt.z / zStepPt.z);
+                    if (zStepPt.z > 0)
+                    {
+                        startZ = baseZ;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        startZ = 0;
+                        endZ = baseZ;
+                    }
+                }
+                else
+                {
+                    if (basePt.z > 0)
+                    {
+                        startZ = 0;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        // z loop shouldn't be performed
+                        startZ = endZ = 0;
+                    }
+                }
+                startZ = max(0, startZ);
+                endZ = min(int(volResolution.z), endZ);
+                for (int z = startZ; z < endZ; z++)
+                {
+                    // optimization of the following:
+                    //Point3f volPt = Point3f(x, y, z)*voxelSize;
+                    //Point3f camSpacePt = vol2cam * volPt;
+                    camSpacePt = v_add(camSpacePt, zStep);
+
+                    float zCamSpace = v_get0(v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(camSpacePt))));
+                    if (zCamSpace <= 0.f)
+                        continue;
+
+                    v_float32x4 camPixVec = v_div(camSpacePt, v_setall_f32(zCamSpace));
+                    v_float32x4 projected = v_muladd(camPixVec, vfxy, vcxy);
+                    // leave only first 2 lanes
+                    projected = v_reinterpret_as_f32(v_and(v_reinterpret_as_u32(projected),
+                                                           v_uint32x4(0xFFFFFFFF, 0xFFFFFFFF, 0, 0)));
+
+                    depthType v;
+                    // bilinearly interpolate depth at projected
+                    {
+                        const v_float32x4& pt = projected;
+                        // check coords >= 0 and < imgSize
+                        v_uint32x4 limits = v_or(v_reinterpret_as_u32(v_lt(pt, v_setzero_f32())),
+                                                 v_reinterpret_as_u32(v_ge(pt, upLimits)));
+                        limits = v_or(limits, v_rotate_right<1>(limits));
+                        if (v_get0(limits))
+                            continue;
+
+                        // xi, yi = floor(pt)
+                        v_int32x4 ip = v_floor(pt);
+                        v_int32x4 ipshift = ip;
+                        int xi = v_get0(ipshift);
+                        ipshift = v_rotate_right<1>(ipshift);
+                        int yi = v_get0(ipshift);
+
+                        const depthType* row0 = depth[yi + 0];
+                        const depthType* row1 = depth[yi + 1];
+
+                        // v001 = [v(xi + 0, yi + 0), v(xi + 1, yi + 0)]
+                        v_float32x4 v001 = v_load_low(row0 + xi);
+                        // v101 = [v(xi + 0, yi + 1), v(xi + 1, yi + 1)]
+                        v_float32x4 v101 = v_load_low(row1 + xi);
+
+                        v_float32x4 vall = v_combine_low(v001, v101);
+
+                        // assume correct depth is positive
+                        // don't fix missing data
+                        if (v_check_all( v_gt(vall, v_setzero_f32())))
+                        {
+                            v_float32x4 t = v_sub(pt, v_cvt_f32(ip));
+                            float tx = v_get0(t);
+                            t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+                            v_float32x4 ty = v_setall_f32(v_get0(t));
+                            // vx is y-interpolated between rows 0 and 1
+                            v_float32x4 vx = v_add(v001, v_mul(ty, v_sub(v101, v001)));
+                            float v0 = v_get0(vx);
+                            vx = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vx)));
+                            float v1 = v_get0(vx);
+                            v = v0 + tx * (v1 - v0);
+                        }
+                        else
+                            continue;
+                    }
+
+                    // norm(camPixVec) produces double which is too slow
+                    int _u = (int)v_get0(projected);
+                    int _v = (int)v_get0(v_rotate_right<1>(projected));
+
+                    if (!(_u >= 0 && _u < depth.cols && _v >= 0 && _v < depth.rows))
+                        continue;
+                    float pixNorm = pixNorms.at<float>(_v, _u);
+                    // TODO: Add support of 3point and 4 point representation
+                    Vec3f colorRGB = color.at<Vec3f>(_v, _u);
+                    //float pixNorm = sqrt(v_reduce_sum(camPixVec*camPixVec));
+                    // difference between distances of point and of surface to camera
+                    float sdf = pixNorm * (v * dfac - zCamSpace);
+                    // possible alternative is:
+                    // kftype sdf = norm(camSpacePt)*(v*dfac/camSpacePt.z - 1);
+                    if (sdf >= -truncDist)
+                    {
+                        TsdfType tsdf = floatToTsdf(fmin(1.f, sdf * truncDistInv));
+
+                        RGBTsdfVoxel& voxel = volDataY[z * volStrides[2]];
+                        WeightType& weight = voxel.weight;
+                        TsdfType& value = voxel.tsdf;
+                        ColorType& r = voxel.r;
+                        ColorType& g = voxel.g;
+                        ColorType& b = voxel.b;
+
+                        // update RGB
+                        r = (ColorType)((float)(r * weight) + (colorRGB[0])) / (weight + 1);
+                        g = (ColorType)((float)(g * weight) + (colorRGB[1])) / (weight + 1);
+                        b = (ColorType)((float)(b * weight) + (colorRGB[2])) / (weight + 1);
+                        colorFix(r, g, b);
+                        // update TSDF
+                        value = floatToTsdf((tsdfToFloat(value) * weight + tsdfToFloat(tsdf)) / (weight + 1));
+                        weight = WeightType(min(int(weight + 1), int(maxWeight)));
+                    }
+                }
+            }
+        }
+    };
+#else
+    auto IntegrateInvoker = [&](const Range& range)
+    {
+        for (int x = range.start; x < range.end; x++)
+        {
+            RGBTsdfVoxel* volDataX = volDataStart + x * volStrides[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                RGBTsdfVoxel* volDataY = volDataX + y * volStrides[1];
+                // optimization of camSpace transformation (vector addition instead of matmul at each z)
+                Point3f basePt = vol2cam * (Point3f(float(x), float(y), 0.0f) * voxelSize);
+                Point3f camSpacePt = basePt;
+                // zStep == vol2cam*(Point3f(x, y, 1)*voxelSize) - basePt;
+                // zStep == vol2cam*[Point3f(x, y, 1) - Point3f(x, y, 0)]*voxelSize
+                Point3f zStep = Point3f(vol2cam.matrix(0, 2),
+                    vol2cam.matrix(1, 2),
+                    vol2cam.matrix(2, 2)) * voxelSize;
+                int startZ, endZ;
+                if (abs(zStep.z) > 1e-5)
+                {
+                    int baseZ = int(-basePt.z / zStep.z);
+                    if (zStep.z > 0)
+                    {
+                        startZ = baseZ;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        startZ = 0;
+                        endZ = baseZ;
+                    }
+                }
+                else
+                {
+                    if (basePt.z > 0)
+                    {
+                        startZ = 0;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        // z loop shouldn't be performed
+                        startZ = endZ = 0;
+                    }
+                }
+                startZ = max(0, startZ);
+                endZ = min(int(volResolution.z), endZ);
+
+                for (int z = startZ; z < endZ; z++)
+                {
+                    // optimization of the following:
+                    //Point3f volPt = Point3f(x, y, z)*volume.voxelSize;
+                    //Point3f camSpacePt = vol2cam * volPt;
+
+                    camSpacePt += zStep;
+                    if (camSpacePt.z <= 0)
+                        continue;
+
+                    Point3f camPixVec;
+                    Point2f projected = projDepth(camSpacePt, camPixVec);
+
+                    depthType v = bilinearDepth(depth, projected);
+                    if (v == 0) {
+                        continue;
+                    }
+                    int _u = (int)projected.x;
+                    int _v = (int)projected.y;
+
+                    if (!(_u >= 0 && _u < depth.cols && _v >= 0 && _v < depth.rows))
+                        continue;
+
+                    float pixNorm = pixNorms.at<float>(_v, _u);
+                    // TODO: Add support of 3point and 4 point representation
+                    Vec3f colorRGB = color.at<Vec3f>(_v, _u);
+
+                    // difference between distances of point and of surface to camera
+                    float sdf = pixNorm * (v * dfac - camSpacePt.z);
+                    // possible alternative is:
+                    // kftype sdf = norm(camSpacePt)*(v*dfac/camSpacePt.z - 1);
+                    if (sdf >= -truncDist)
+                    {
+                        TsdfType tsdf = floatToTsdf(fmin(1.f, sdf * truncDistInv));
+
+                        RGBTsdfVoxel& voxel = volDataY[z * volStrides[2]];
+                        WeightType& weight = voxel.weight;
+                        TsdfType& value = voxel.tsdf;
+
+                        ColorType& r = voxel.r;
+                        ColorType& g = voxel.g;
+                        ColorType& b = voxel.b;
+                        // update RGB
+                        if (weight < 1)
+                        {
+                            r = (ColorType)((float)(r * weight) + (colorRGB[0])) / (weight + 1);
+                            g = (ColorType)((float)(g * weight) + (colorRGB[1])) / (weight + 1);
+                            b = (ColorType)((float)(b * weight) + (colorRGB[2])) / (weight + 1);
+                        }
+
+                        // update TSDF
+                        value = floatToTsdf((tsdfToFloat(value) * weight + tsdfToFloat(tsdf)) / (weight + 1));
+                        weight = (WeightType)min(weight + 1, maxWeight);
+                    }
+                }
+            }
+        }
+    };
+#endif
+    parallel_for_(integrateRange, IntegrateInvoker);
+}
+
+
+
+#if USE_INTRINSICS
+// all coordinate checks should be done in inclosing cycle
+
+inline float interpolateColorVoxel(const Mat& volume,
+                                   const Vec4i& volDims, const Vec8i& neighbourCoords,
+                                   const v_float32x4& p)
+{
+    // tx, ty, tz = floor(p)
+    v_int32x4 ip = v_floor(p);
+    v_float32x4 t = v_sub(p, v_cvt_f32(ip));
+    float tx = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float ty = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float tz = v_get0(t);
+
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    int ix = v_get0(ip);
+    ip = v_rotate_right<1>(ip);
+    int iy = v_get0(ip);
+    ip = v_rotate_right<1>(ip);
+    int iz = v_get0(ip);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    TsdfType vx[8];
+    for (int i = 0; i < 8; i++)
+        vx[i] = volData[neighbourCoords[i] + coordBase].tsdf;
+
+    v_float32x4 v0246 = tsdfToFloat_INTR(v_int32x4(vx[0], vx[2], vx[4], vx[6]));
+    v_float32x4 v1357 = tsdfToFloat_INTR(v_int32x4(vx[1], vx[3], vx[5], vx[7]));
+    v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+    v_float32x4 v00_10 = vxx;
+    v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+    v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+    float v0 = v_get0(v0_1);
+    v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+    float v1 = v_get0(v0_1);
+
+    return v0 + tx * (v1 - v0);
+}
+
+inline float interpolateColorVoxel(const Mat& volume,
+                                   const Vec4i& volDims, const Vec8i& neighbourCoords,
+                                   const Point3f& _p)
+{
+    v_float32x4 p(_p.x, _p.y, _p.z, 0);
+    return interpolateColorVoxel(volume, volDims, neighbourCoords, p);
+}
+
+
+#else
+inline float interpolateColorVoxel(const Mat& volume,
+                                   const Vec4i& volDims, const Vec8i& neighbourCoords,
+                                   const Point3f& p)
+{
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+
+    int ix = cvFloor(p.x);
+    int iy = cvFloor(p.y);
+    int iz = cvFloor(p.z);
+
+    float tx = p.x - ix;
+    float ty = p.y - iy;
+    float tz = p.z - iz;
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    float vx[8];
+    for (int i = 0; i < 8; i++)
+        vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase].tsdf);
+
+    float v00 = vx[0] + tz * (vx[1] - vx[0]);
+    float v01 = vx[2] + tz * (vx[3] - vx[2]);
+    float v10 = vx[4] + tz * (vx[5] - vx[4]);
+    float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+    float v0 = v00 + ty * (v01 - v00);
+    float v1 = v10 + ty * (v11 - v10);
+
+    return v0 + tx * (v1 - v0);
+
+}
+#endif
+
+
+#if USE_INTRINSICS
+//gradientDeltaFactor is fixed at 1.0 of voxel size
+
+inline v_float32x4 getNormalColorVoxel(const Mat& volume,
+                                       const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+                                       const v_float32x4& p)
+{
+    if (v_check_any(v_lt(p, v_float32x4(1.f, 1.f, 1.f, 0.f))) ||
+        v_check_any(v_ge(p, v_float32x4((float)(volResolution.x - 2),
+            (float)(volResolution.y - 2),
+            (float)(volResolution.z - 2), 1.f)))
+        )
+        return nanv;
+
+    v_int32x4 ip = v_floor(p);
+    v_float32x4 t = v_sub(p, v_cvt_f32(ip));
+    float tx = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float ty = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float tz = v_get0(t);
+
+    const int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    int ix = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iy = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iz = v_get0(ip);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    float CV_DECL_ALIGNED(16) an[4];
+    an[0] = an[1] = an[2] = an[3] = 0.f;
+    for (int c = 0; c < 3; c++)
+    {
+        const int dim = volDims[c];
+        float& nv = an[c];
+
+        float vx[8];
+        for (int i = 0; i < 8; i++)
+            vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase + 1 * dim].tsdf) -
+            tsdfToFloat(volData[neighbourCoords[i] + coordBase - 1 * dim].tsdf);
+
+        v_float32x4 v0246(vx[0], vx[2], vx[4], vx[6]);
+        v_float32x4 v1357(vx[1], vx[3], vx[5], vx[7]);
+        v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+        v_float32x4 v00_10 = vxx;
+        v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+        v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+        float v0 = v_get0(v0_1);
+        v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+        float v1 = v_get0(v0_1);
+
+        nv = v0 + tx * (v1 - v0);
+    }
+
+    v_float32x4 n = v_load_aligned(an);
+    v_float32x4 Norm = v_sqrt(v_setall_f32(v_reduce_sum(v_mul(n, n))));
+
+    return v_get0(Norm) < 0.0001f ? nanv : v_div(n, Norm);
+}
+
+inline Point3f getNormalColorVoxel(const Mat& volume,
+                                   const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+                                   const Point3f& _p)
+{
+    v_float32x4 p(_p.x, _p.y, _p.z, 0.f);
+    v_float32x4 result = getNormalColorVoxel(volume, volDims, neighbourCoords, volResolution, p);
+    float CV_DECL_ALIGNED(16) ares[4];
+    v_store_aligned(ares, result);
+    return Point3f(ares[0], ares[1], ares[2]);
+}
+#else
+inline Point3f getNormalColorVoxel(const Mat& volume,
+                                   const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+                                   const Point3f& p)
+{
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    if (p.x < 1 || p.x >= volResolution.x - 2 ||
+        p.y < 1 || p.y >= volResolution.y - 2 ||
+        p.z < 1 || p.z >= volResolution.z - 2)
+        return nan3;
+
+    int ix = cvFloor(p.x);
+    int iy = cvFloor(p.y);
+    int iz = cvFloor(p.z);
+
+    float tx = p.x - ix;
+    float ty = p.y - iy;
+    float tz = p.z - iz;
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    Vec3f an;
+    for (int c = 0; c < 3; c++)
+    {
+        const int dim = volDims[c];
+        float& nv = an[c];
+
+        float vx[8];
+        for (int i = 0; i < 8; i++)
+            vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase + 1 * dim].tsdf) -
+            tsdfToFloat(volData[neighbourCoords[i] + coordBase - 1 * dim].tsdf);
+
+        float v00 = vx[0] + tz * (vx[1] - vx[0]);
+        float v01 = vx[2] + tz * (vx[3] - vx[2]);
+        float v10 = vx[4] + tz * (vx[5] - vx[4]);
+        float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+        float v0 = v00 + ty * (v01 - v00);
+        float v1 = v10 + ty * (v11 - v10);
+
+        nv = v0 + tx * (v1 - v0);
+    }
+
+    float nv = sqrt(an[0] * an[0] +
+        an[1] * an[1] +
+        an[2] * an[2]);
+    return nv < 0.0001f ? nan3 : an / nv;
+}
+#endif
+
+#if USE_INTRINSICS
+inline float interpolateColor(float tx, float ty, float tz, float vx[8])
+{
+    v_float32x4 v0246, v1357;
+    v_load_deinterleave(vx, v0246, v1357);
+
+    v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+    v_float32x4 v00_10 = vxx;
+    v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+    v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+    float v0 = v_get0(v0_1);
+    v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+    float v1 = v_get0(v0_1);
+
+    return v0 + tx * (v1 - v0);
+}
+#else
+inline float interpolateColor(float tx, float ty, float tz, float vx[8])
+{
+    float v00 = vx[0] + tz * (vx[1] - vx[0]);
+    float v01 = vx[2] + tz * (vx[3] - vx[2]);
+    float v10 = vx[4] + tz * (vx[5] - vx[4]);
+    float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+    float v0 = v00 + ty * (v01 - v00);
+    float v1 = v10 + ty * (v11 - v10);
+
+    return v0 + tx * (v1 - v0);
+}
+#endif
+
+
+#if USE_INTRINSICS
+//gradientDeltaFactor is fixed at 1.0 of voxel size
+
+inline v_float32x4 getColorVoxel(const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const float voxelSizeInv, const v_float32x4& p)
+{
+    if (v_check_any(v_lt(p, v_float32x4(1.f, 1.f, 1.f, 0.f))) ||
+        v_check_any(v_ge(p, v_float32x4((float)(volResolution.x - 2),
+            (float)(volResolution.y - 2),
+            (float)(volResolution.z - 2), 1.f)))
+        )
+        return nanv;
+
+    v_int32x4 ip = v_floor(p);
+
+    const int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    int ix = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iy = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iz = v_get0(ip);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+    float CV_DECL_ALIGNED(16) rgb[4];
+
+#if USE_INTERPOLATION_IN_GETNORMAL
+    float r[8], g[8], b[8];
+    for (int i = 0; i < 8; i++)
+    {
+        r[i] = (float)volData[neighbourCoords[i] + coordBase].r;
+        g[i] = (float)volData[neighbourCoords[i] + coordBase].g;
+        b[i] = (float)volData[neighbourCoords[i] + coordBase].b;
+    }
+
+    v_float32x4 vsi(voxelSizeInv, voxelSizeInv, voxelSizeInv, voxelSizeInv);
+    v_float32x4 ptVox = v_mul(p, vsi);
+    v_int32x4 iptVox = v_floor(ptVox);
+    v_float32x4 t = v_sub(ptVox, v_cvt_f32(iptVox));
+    float tx = v_get0(t); t = v_rotate_right<1>(t);
+    float ty = v_get0(t); t = v_rotate_right<1>(t);
+    float tz = v_get0(t);
+    rgb[0] = interpolateColor(tx, ty, tz, r);
+    rgb[1] = interpolateColor(tx, ty, tz, g);
+    rgb[2] = interpolateColor(tx, ty, tz, b);
+    rgb[3] = 0.f;
+#else
+    rgb[0] = volData[coordBase].r;
+    rgb[1] = volData[coordBase].g;
+    rgb[2] = volData[coordBase].b;
+    rgb[3] = 0.f;
+#endif
+    v_float32x4 res = v_load_aligned(rgb);
+    return res;
+}
+
+inline Point3f getColorVoxel(const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const float voxelSizeInv, const Point3f& _p)
+{
+    v_float32x4 p(_p.x, _p.y, _p.z, 0.f);
+    v_float32x4 result = getColorVoxel(volume, volDims, neighbourCoords, volResolution, voxelSizeInv, p);
+    float CV_DECL_ALIGNED(16) ares[4];
+    v_store_aligned(ares, result);
+    return Point3f(ares[0], ares[1], ares[2]);
+}
+
+
+#else
+inline Point3f getColorVoxel(const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const float voxelSizeInv, const Point3f& p)
+{
+    const int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const RGBTsdfVoxel* volData = volume.ptr<RGBTsdfVoxel>();
+
+    if (p.x < 1 || p.x >= volResolution.x - 2 ||
+        p.y < 1 || p.y >= volResolution.y - 2 ||
+        p.z < 1 || p.z >= volResolution.z - 2)
+        return nan3;
+
+    int ix = cvFloor(p.x);
+    int iy = cvFloor(p.y);
+    int iz = cvFloor(p.z);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+    Point3f res;
+
+#if USE_INTERPOLATION_IN_GETNORMAL
+    // TODO: create better interpolation or remove this simple version
+    float r[8], g[8], b[8];
+    for (int i = 0; i < 8; i++)
+    {
+        r[i] = (float)volData[neighbourCoords[i] + coordBase].r;
+        g[i] = (float)volData[neighbourCoords[i] + coordBase].g;
+        b[i] = (float)volData[neighbourCoords[i] + coordBase].b;
+    }
+
+    Point3f ptVox = p * voxelSizeInv;
+    Vec3i iptVox(cvFloor(ptVox.x), cvFloor(ptVox.y), cvFloor(ptVox.z));
+    float tx = ptVox.x - iptVox[0];
+    float ty = ptVox.y - iptVox[1];
+    float tz = ptVox.z - iptVox[2];
+
+    res = Point3f(interpolateColor(tx, ty, tz, r),
+        interpolateColor(tx, ty, tz, g),
+        interpolateColor(tx, ty, tz, b));
+#else
+    res = Point3f(volData[coordBase].r, volData[coordBase].g, volData[coordBase].b);
+#endif
+    colorFix(res);
+    return res;
+}
+#endif
+
+
+void raycastColorTsdfVolumeUnit(const VolumeSettings &settings, const Matx44f &cameraPose,
+                                int height, int width, InputArray intr,
+                                InputArray _volume, OutputArray _points, OutputArray _normals, OutputArray _colors)
+{
+    CV_TRACE_FUNCTION();
+
+    Size frameSize(width, height);
+    CV_Assert(frameSize.area() > 0);
+
+    Matx33f mintr(intr.getMat());
+
+    _points.create(frameSize, POINT_TYPE);
+    _normals.create(frameSize, POINT_TYPE);
+    _colors.create(frameSize, COLOR_TYPE);
+
+    Points points = _points.getMat();
+    Normals normals = _normals.getMat();
+    Colors colors = _colors.getMat();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const Point3f volSize = Point3f(volResolution) * settings.getVoxelSize();
+
+    const Intr::Reprojector reprojDepth = Intr(mintr).makeReprojector();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+
+    const Point3f boxMax(volSize - Point3f(settings.getVoxelSize(), settings.getVoxelSize(), settings.getVoxelSize()));
+    const Point3f boxMin = Point3f(0, 0, 0);
+    const Affine3f cam2vol(pose.inv() * Affine3f(cameraPose));
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    const Mat volume = _volume.getMat();
+    float voxelSize = settings.getVoxelSize();
+    float voxelSizeInv = 1.0f / voxelSize;
+    float tstep = settings.getTsdfTruncateDistance() * settings.getRaycastStepFactor();
+
+    Range raycastRange = Range(0, points.rows);
+
+#if USE_INTRINSICS
+    auto RaycastInvoker = [&](const Range& range)
+    {
+        const v_float32x4 vfxy(reprojDepth.fxinv, reprojDepth.fyinv, 0, 0);
+        const v_float32x4 vcxy(reprojDepth.cx, reprojDepth.cy, 0, 0);
+
+        const float(&cm)[16] = cam2vol.matrix.val;
+        const v_float32x4 camRot0(cm[0], cm[4], cm[8], 0);
+        const v_float32x4 camRot1(cm[1], cm[5], cm[9], 0);
+        const v_float32x4 camRot2(cm[2], cm[6], cm[10], 0);
+        const v_float32x4 camTrans(cm[3], cm[7], cm[11], 0);
+
+        const v_float32x4 boxDown(boxMin.x, boxMin.y, boxMin.z, 0.f);
+        const v_float32x4 boxUp(boxMax.x, boxMax.y, boxMax.z, 0.f);
+
+        const v_float32x4 invVoxelSize = v_float32x4(voxelSizeInv,
+            voxelSizeInv,
+            voxelSizeInv, 1.f);
+
+        const float(&vm)[16] = vol2cam.matrix.val;
+        const v_float32x4 volRot0(vm[0], vm[4], vm[8], 0);
+        const v_float32x4 volRot1(vm[1], vm[5], vm[9], 0);
+        const v_float32x4 volRot2(vm[2], vm[6], vm[10], 0);
+        const v_float32x4 volTrans(vm[3], vm[7], vm[11], 0);
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            ptype* ptsRow = points[y];
+            ptype* nrmRow = normals[y];
+            ptype* clrRow = colors[y];
+
+            for (int x = 0; x < points.cols; x++)
+            {
+                v_float32x4 point = nanv, normal = nanv, color = nanv;
+
+                v_float32x4 orig = camTrans;
+
+                // get direction through pixel in volume space:
+
+                // 1. reproject (x, y) on projecting plane where z = 1.f
+                v_float32x4 planed = v_mul(v_sub(v_float32x4((float)x, (float)y, 0.f, 0.f), vcxy), vfxy);
+                planed = v_combine_low(planed, v_float32x4(1.f, 0.f, 0.f, 0.f));
+
+                // 2. rotate to volume space
+                planed = v_matmuladd(planed, camRot0, camRot1, camRot2, v_setzero_f32());
+
+                // 3. normalize
+                v_float32x4 invNorm = v_invsqrt(v_setall_f32(v_reduce_sum(v_mul(planed, planed))));
+                v_float32x4 dir = v_mul(planed, invNorm);
+
+                // compute intersection of ray with all six bbox planes
+                v_float32x4 rayinv = v_div(v_setall_f32(1.f), dir);
+                // div by zero should be eliminated by these products
+                v_float32x4 tbottom = v_mul(rayinv, v_sub(boxDown, orig));
+                v_float32x4 ttop = v_mul(rayinv, v_sub(boxUp, orig));
+
+                // re-order intersections to find smallest and largest on each axis
+                v_float32x4 minAx = v_min(ttop, tbottom);
+                v_float32x4 maxAx = v_max(ttop, tbottom);
+
+                // near clipping plane
+                const float clip = 0.f;
+                float _minAx[4], _maxAx[4];
+                v_store(_minAx, minAx);
+                v_store(_maxAx, maxAx);
+                float tmin = max({ _minAx[0], _minAx[1], _minAx[2], clip });
+                float tmax = min({ _maxAx[0], _maxAx[1], _maxAx[2] });
+
+                // precautions against getting coordinates out of bounds
+                tmin = tmin + tstep;
+                tmax = tmax - tstep;
+
+                if (tmin < tmax)
+                {
+                    // interpolation optimized a little
+                    orig = v_mul(orig, invVoxelSize);
+                    dir = v_mul(dir, invVoxelSize);
+
+                    int xdim = volDims[0];
+                    int ydim = volDims[1];
+                    int zdim = volDims[2];
+                    v_float32x4 rayStep = v_mul(dir, v_setall_f32(tstep));
+                    v_float32x4 next = v_add(orig, v_mul(dir, v_setall_f32(tmin)));
+                    float f = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+                    float fnext = f;
+
+                    //raymarch
+                    int steps = 0;
+                    int nSteps = cvFloor((tmax - tmin) / tstep);
+                    for (; steps < nSteps; steps++)
+                    {
+                        next = v_add(next, rayStep);
+                        v_int32x4 ip = v_round(next);
+                        int ix = v_get0(ip); ip = v_rotate_right<1>(ip);
+                        int iy = v_get0(ip); ip = v_rotate_right<1>(ip);
+                        int iz = v_get0(ip);
+                        int coord = ix * xdim + iy * ydim + iz * zdim;
+
+                        fnext = tsdfToFloat(volume.at<RGBTsdfVoxel>(coord).tsdf);
+                        if (fnext != f)
+                        {
+                            fnext = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+
+                            // when ray crosses a surface
+                            if (std::signbit(f) != std::signbit(fnext))
+                                break;
+
+                            f = fnext;
+                        }
+                    }
+
+                    // if ray penetrates a surface from outside
+                    // linearly interpolate t between two f values
+                    if (f > 0.f && fnext < 0.f)
+                    {
+                        v_float32x4 tp = v_sub(next, rayStep);
+                        float ft = interpolateColorVoxel(volume, volDims, neighbourCoords, tp);
+                        float ftdt = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+                        float ts = tmin + tstep * (steps - ft / (ftdt - ft));
+
+                        // avoid division by zero
+                        if (!cvIsNaN(ts) && !cvIsInf(ts))
+                        {
+                            v_float32x4 pv = v_add(orig, v_mul(dir, v_setall_f32(ts)));
+                            v_float32x4 nv = getNormalColorVoxel(volume, volDims, neighbourCoords, volResolution, pv);
+                            v_float32x4 cv = getColorVoxel(volume, volDims, neighbourCoords, volResolution, voxelSizeInv, pv);
+
+                            if (!isNaN(nv))
+                            {
+                                color = cv;
+                                //convert pv and nv to camera space
+                                normal = v_matmuladd(nv, volRot0, volRot1, volRot2, v_setzero_f32());
+                                // interpolation optimized a little
+                                point = v_matmuladd(v_mul(pv, v_float32x4(voxelSize, voxelSize, voxelSize, 1.f)),
+                                    volRot0, volRot1, volRot2, volTrans);
+                            }
+                        }
+                    }
+                }
+
+                v_store((float*)(&ptsRow[x]), point);
+                v_store((float*)(&nrmRow[x]), normal);
+                v_store((float*)(&clrRow[x]), color);
+            }
+        }
+    };
+#else
+    auto RaycastInvoker = [&](const Range& range)
+    {
+        const Point3f camTrans = cam2vol.translation();
+        const Matx33f  camRot = cam2vol.rotation();
+        const Matx33f  volRot = vol2cam.rotation();
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            ptype* ptsRow = points[y];
+            ptype* nrmRow = normals[y];
+            ptype* clrRow = colors[y];
+
+            for (int x = 0; x < points.cols; x++)
+            {
+                Point3f point = nan3, normal = nan3, color = nan3;
+
+                Point3f orig = camTrans;
+                // direction through pixel in volume space
+                Point3f dir = normalize(Vec3f(camRot * reprojDepth(Point3f(float(x), float(y), 1.f))));
+
+                // compute intersection of ray with all six bbox planes
+                Vec3f rayinv(1.f / dir.x, 1.f / dir.y, 1.f / dir.z);
+                Point3f tbottom = rayinv.mul(boxMin - orig);
+                Point3f ttop = rayinv.mul(boxMax - orig);
+
+                // re-order intersections to find smallest and largest on each axis
+                Point3f minAx(min(ttop.x, tbottom.x), min(ttop.y, tbottom.y), min(ttop.z, tbottom.z));
+                Point3f maxAx(max(ttop.x, tbottom.x), max(ttop.y, tbottom.y), max(ttop.z, tbottom.z));
+
+                // near clipping plane
+                const float clip = 0.f;
+                //float tmin = max(max(max(minAx.x, minAx.y), max(minAx.x, minAx.z)), clip);
+                //float tmax =     min(min(maxAx.x, maxAx.y), min(maxAx.x, maxAx.z));
+                float tmin = max({ minAx.x, minAx.y, minAx.z, clip });
+                float tmax = min({ maxAx.x, maxAx.y, maxAx.z });
+
+                // precautions against getting coordinates out of bounds
+                tmin = tmin + tstep;
+                tmax = tmax - tstep;
+
+                if (tmin < tmax)
+                {
+                    // interpolation optimized a little
+                    orig = orig * voxelSizeInv;
+                    dir = dir * voxelSizeInv;
+
+                    Point3f rayStep = dir * tstep;
+                    Point3f next = (orig + dir * tmin);
+                    float f = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+                    float fnext = f;
+
+                    //raymarch
+                    int steps = 0;
+                    int nSteps = int(floor((tmax - tmin) / tstep));
+                    for (; steps < nSteps; steps++)
+                    {
+                        next += rayStep;
+                        int xdim = volDims[0];
+                        int ydim = volDims[1];
+                        int zdim = volDims[2];
+                        int ix = cvRound(next.x);
+                        int iy = cvRound(next.y);
+                        int iz = cvRound(next.z);
+                        fnext = tsdfToFloat(volume.at<RGBTsdfVoxel>(ix * xdim + iy * ydim + iz * zdim).tsdf);
+                        if (fnext != f)
+                        {
+                            fnext = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+                            // when ray crosses a surface
+                            if (std::signbit(f) != std::signbit(fnext))
+                                break;
+
+                            f = fnext;
+                        }
+                    }
+                    // if ray penetrates a surface from outside
+                    // linearly interpolate t between two f values
+                    if (f > 0.f && fnext < 0.f)
+                    {
+                        Point3f tp = next - rayStep;
+                        float ft = interpolateColorVoxel(volume, volDims, neighbourCoords, tp);
+                        float ftdt = interpolateColorVoxel(volume, volDims, neighbourCoords, next);
+                        // float t = tmin + steps*tstep;
+                        // float ts = t - tstep*ft/(ftdt - ft);
+                        float ts = tmin + tstep * (steps - ft / (ftdt - ft));
+
+                        // avoid division by zero
+                        if (!cvIsNaN(ts) && !cvIsInf(ts))
+                        {
+                            Point3f pv = (orig + dir * ts);
+                            Point3f nv = getNormalColorVoxel(volume, volDims, neighbourCoords, volResolution, pv);
+                            Point3f cv = getColorVoxel(volume, volDims, neighbourCoords, volResolution, voxelSizeInv, pv);
+                            if (!isNaN(nv))
+                            {
+                                //convert pv and nv to camera space
+                                normal = volRot * nv;
+                                color = cv;
+                                // interpolation optimized a little
+                                point = vol2cam * (pv * voxelSize);
+                            }
+                        }
+                    }
+                }
+                ptsRow[x] = toPtype(point);
+                nrmRow[x] = toPtype(normal);
+                clrRow[x] = toPtype(color);
+            }
+        }
+
+    };
+#endif
+
+    parallel_for_(raycastRange, RaycastInvoker);
+}
+
+
+void fetchNormalsFromColorTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume,
+                                         InputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    CV_Assert(!_points.empty());
+    if (!_normals.needed())
+        return;
+
+    Points points = _points.getMat();
+    CV_Assert(points.type() == POINT_TYPE);
+
+    _normals.createSameSize(_points, _points.type());
+    Normals normals = _normals.getMat();
+
+    const Mat volume = _volume.getMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    Affine3f invPose(pose.inv());
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+    auto PushNormals = [&](const ptype& pp, const int* position)
+    {
+        Point3f p = fromPtype(pp);
+        Point3f n = nan3;
+        if (!isNaN(p))
+        {
+            Point3f voxPt = (invPose * p);
+            voxPt = voxPt * voxelSizeInv;
+            n = pose.rotation() * getNormalColorVoxel(volume, volDims, neighbourCoords, volResolution, voxPt);
+        }
+        normals(position[0], position[1]) = toPtype(n);
+    };
+    points.forEach(PushNormals);
+
+}
+
+inline void coord(
+    const Mat& volume, const RGBTsdfVoxel* volDataStart, std::vector<ptype>& points, std::vector<ptype>& normals, std::vector<ptype>& colors,
+    const Point3i volResolution, const Vec4i volDims, const Vec8i neighbourCoords, const Affine3f pose,
+    const float voxelSize, const float voxelSizeInv, bool needNormals, bool needColors, int x, int y, int z, Point3f V, float v0, int axis)
+{
+    // 0 for x, 1 for y, 2 for z
+    bool limits = false;
+    Point3i shift;
+    float Vc = 0.f;
+    if (axis == 0)
+    {
+        shift = Point3i(1, 0, 0);
+        limits = (x + 1 < volResolution.x);
+        Vc = V.x;
+    }
+    if (axis == 1)
+    {
+        shift = Point3i(0, 1, 0);
+        limits = (y + 1 < volResolution.y);
+        Vc = V.y;
+    }
+    if (axis == 2)
+    {
+        shift = Point3i(0, 0, 1);
+        limits = (z + 1 < volResolution.z);
+        Vc = V.z;
+    }
+
+    if (limits)
+    {
+        const RGBTsdfVoxel& voxeld = volDataStart[(x + shift.x) * volDims[0] +
+            (y + shift.y) * volDims[1] +
+            (z + shift.z) * volDims[2]];
+        float vd = tsdfToFloat(voxeld.tsdf);
+
+        if (voxeld.weight != 0 && vd != 1.f)
+        {
+            if ((v0 > 0 && vd < 0) || (v0 < 0 && vd > 0))
+            {
+                //linearly interpolate coordinate
+                float Vn = Vc + voxelSize;
+                float dinv = 1.f / (abs(v0) + abs(vd));
+                float inter = (Vc * abs(vd) + Vn * abs(v0)) * dinv;
+
+                Point3f p(shift.x ? inter : V.x,
+                    shift.y ? inter : V.y,
+                    shift.z ? inter : V.z);
+                {
+                    points.push_back(toPtype(pose * p));
+                    if (needNormals)
+                        normals.push_back(toPtype(pose.rotation() *
+                            getNormalColorVoxel(volume, volDims, neighbourCoords, volResolution, p * voxelSizeInv)));
+                    if (needColors)
+                        colors.push_back(toPtype(pose.rotation() *
+                            getColorVoxel(volume, volDims, neighbourCoords, volResolution, voxelSizeInv, p * voxelSizeInv)));
+                }
+            }
+        }
+    }
+}
+
+void fetchPointsNormalsFromColorTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume,
+    OutputArray _points, OutputArray _normals)
+{
+    fetchPointsNormalsColorsFromColorTsdfVolumeUnit(settings, _volume, _points, _normals, noArray());
+}
+
+void fetchPointsNormalsColorsFromColorTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume,
+    OutputArray _points, OutputArray _normals, OutputArray _colors)
+{
+    if (!_points.needed())
+        return;
+    const Mat volume = _volume.getMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    float voxelSize = settings.getVoxelSize();
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+    bool needNormals = _normals.needed();
+    bool needColors  = _colors.needed();
+
+    std::vector<std::vector<ptype>> pVecs, nVecs, cVecs;
+    Range fetchRange(0, volResolution.x);
+    const int nstripes = -1;
+    const RGBTsdfVoxel* volDataStart = volume.ptr<RGBTsdfVoxel>();
+    Mutex mutex;
+    auto FetchPointsNormalsInvoker = [&](const Range& range) {
+
+        std::vector<ptype> points, normals, colors;
+        for (int x = range.start; x < range.end; x++)
+        {
+            const RGBTsdfVoxel* volDataX = volDataStart + x * volDims[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                const RGBTsdfVoxel* volDataY = volDataX + y * volDims[1];
+                for (int z = 0; z < volResolution.z; z++)
+                {
+                    const RGBTsdfVoxel& voxel0 = volDataY[z * volDims[2]];
+                    float v0 = tsdfToFloat(voxel0.tsdf);
+                    if (voxel0.weight != 0 && v0 != 1.f)
+                    {
+                        Point3f V(Point3f((float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f) * voxelSize);
+
+                        coord(volume, volDataStart, points, normals, colors, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, needColors, x, y, z, V, v0, 0);
+                        coord(volume, volDataStart, points, normals, colors, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, needColors, x, y, z, V, v0, 1);
+                        coord(volume, volDataStart, points, normals, colors, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, needColors, x, y, z, V, v0, 2);
+
+                    } // if voxel is not empty
+                }
+            }
+        }
+        AutoLock al(mutex);
+        pVecs.push_back(points);
+        nVecs.push_back(normals);
+        cVecs.push_back(colors);
+    };
+
+    parallel_for_(fetchRange, FetchPointsNormalsInvoker, nstripes);
+
+    std::vector<ptype> points, normals, colors;
+    for (size_t i = 0; i < pVecs.size(); i++)
+    {
+        points.insert(points.end(), pVecs[i].begin(), pVecs[i].end());
+        normals.insert(normals.end(), nVecs[i].begin(), nVecs[i].end());
+        colors.insert(colors.end(), cVecs[i].begin(), cVecs[i].end());
+    }
+
+    _points.create((int)points.size(), 1, POINT_TYPE);
+    if (!points.empty())
+        Mat((int)points.size(), 1, POINT_TYPE, &points[0]).copyTo(_points.getMat());
+
+    if (_normals.needed())
+    {
+        _normals.create((int)normals.size(), 1, POINT_TYPE);
+        if (!normals.empty())
+            Mat((int)normals.size(), 1, POINT_TYPE, &normals[0]).copyTo(_normals.getMat());
+    }
+
+    if (_colors.needed())
+    {
+        _colors.create((int)colors.size(), 1, COLOR_TYPE);
+        if (!colors.empty())
+            Mat((int)colors.size(), 1, COLOR_TYPE, &colors[0]).copyTo(_colors.getMat());
+    }
+}
+
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.hpp b/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.hpp
new file mode 100644
index 0000000..217033e
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/color_tsdf_functions.hpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#ifndef OPENCV_3D_COLORED_TSDF_FUNCTIONS_HPP
+#define OPENCV_3D_COLORED_TSDF_FUNCTIONS_HPP
+
+#include <unordered_set>
+
+#include "utils.hpp"
+#include "tsdf_functions.hpp"
+
+#define USE_INTERPOLATION_IN_GETNORMAL 1
+
+namespace cv
+{
+void integrateColorTsdfVolumeUnit(const VolumeSettings &settings, const Matx44f &cameraPose,
+                                  InputArray _depth, InputArray _rgb, InputArray _pixNorms, InputArray _volume);
+void integrateColorTsdfVolumeUnit(const VolumeSettings &settings, const Matx44f &volumePose, const Matx44f &cameraPose,
+                                  InputArray _depth, InputArray _rgb, InputArray _pixNorms, InputArray _volume);
+void raycastColorTsdfVolumeUnit(const VolumeSettings &settings, const Matx44f &cameraPose,
+                                int height, int width, InputArray intr,
+                                InputArray _volume, OutputArray _points, OutputArray _normals, OutputArray _colors);
+void fetchNormalsFromColorTsdfVolumeUnit(const VolumeSettings &settings, InputArray _volume,
+                                         InputArray _points, OutputArray _normals);
+void fetchPointsNormalsFromColorTsdfVolumeUnit(const VolumeSettings &settings, InputArray _volume,
+                                               OutputArray _points, OutputArray _normals);
+void fetchPointsNormalsColorsFromColorTsdfVolumeUnit(const VolumeSettings &settings, InputArray _volume,
+                                                     OutputArray _points, OutputArray _normals, OutputArray _colors);
+
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/depth_registration.cpp b/upstream/opencv/modules/ptcloud/src/depth_registration.cpp
new file mode 100644
index 0000000..265520a
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/depth_registration.cpp
@@ -0,0 +1,315 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+///////////////////////////////////////////////////////////////////////////////////
+
+// Our three input types have a different value for a depth pixel with no depth
+template<typename DepthDepth>
+inline DepthDepth noDepthSentinelValue()
+{
+    return 0;
+}
+
+template<>
+inline float
+noDepthSentinelValue<float>()
+{
+    return std::numeric_limits<float>::quiet_NaN();
+}
+
+template<>
+inline double
+noDepthSentinelValue<double>()
+{
+    return std::numeric_limits<double>::quiet_NaN();
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+
+// Testing for depth pixels with no depth isn't straightforward for NaN values. We
+// need to specialize the equality check for floats and doubles.
+template<typename DepthDepth>
+inline bool
+isEqualToNoDepthSentinelValue(const DepthDepth& value)
+{
+    return value == noDepthSentinelValue<DepthDepth>();
+}
+
+template<>
+inline bool
+isEqualToNoDepthSentinelValue<float>(const float& value)
+{
+    return cvIsNaN(value) != 0;
+}
+
+template<>
+inline bool
+isEqualToNoDepthSentinelValue<double>(const double& value)
+{
+    return cvIsNaN(value) != 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+
+
+// When using the unsigned short representation, we'd like to round the values to the nearest
+// integer value. The float/double representations don't need to be rounded
+template<typename DepthDepth>
+inline DepthDepth
+floatToInputDepth(const float& value)
+{
+    return (DepthDepth)value;
+}
+
+template<>
+inline unsigned short
+floatToInputDepth<unsigned short>(const float& value)
+{
+    return (unsigned short)(value + 0.5);
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+
+
+/** Computes a registered depth image from an unregistered image.
+ *
+ * @param unregisteredDepth the input depth data
+ * @param unregisteredCameraMatrix the camera matrix of the depth camera
+ * @param registeredCameraMatrix the camera matrix of the external camera
+ * @param registeredDistCoeffs the distortion coefficients of the external camera
+ * @param rbtRgb2Depth the rigid body transform between the cameras.
+ * @param outputImagePlaneSize the image plane dimensions of the external camera (width, height)
+ * @param depthDilation whether or not the depth is dilated to avoid holes and occlusion errors
+ * @param inputDepthToMetersScale the scale needed to transform the input depth units to meters
+ * @param registeredDepth the result of transforming the depth into the external camera
+ */
+template<typename DepthDepth>
+void performRegistration(const Mat_<DepthDepth>& unregisteredDepth,
+                         const Matx33f& unregisteredCameraMatrix,
+                         const Matx33f& registeredCameraMatrix,
+                         const Mat_<float>& registeredDistCoeffs,
+                         const Matx44f& rbtRgb2Depth,
+                         const Size outputImagePlaneSize,
+                         const bool depthDilation,
+                         const float inputDepthToMetersScale,
+                         Mat& registeredDepth)
+{
+    // Create output Mat of the correct type, filled with an initial value indicating no depth
+    registeredDepth = Mat_<DepthDepth>(outputImagePlaneSize, noDepthSentinelValue<DepthDepth>());
+
+    // Figure out whether we'll have to apply a distortion
+    bool hasDistortion = (countNonZero(registeredDistCoeffs) > 0);
+
+    // A point (i,j,1) will have to be converted to 3d first, by multiplying it by K.inv()
+    // It will then be transformed by rbtRgb2Depth.
+    // Finally, it will be projected into the external camera via registeredCameraMatrix and
+    // its distortion coefficients. If there is no distortion in the external camera, we
+    // can linearly chain all three operations together.
+
+    Matx44f K = Matx44f::zeros();
+    for (unsigned char j = 0; j < 3; ++j)
+        for (unsigned char i = 0; i < 3; ++i)
+        {
+            K(j, i) = unregisteredCameraMatrix(j, i);
+        }
+    K(3, 3) = 1;
+
+    Matx44f initialProjection;
+    if (hasDistortion)
+    {
+        // The projection into the external camera will be done separately with distortion
+        initialProjection = rbtRgb2Depth * K.inv();
+    }
+    else
+    {
+        // No distortion, so all operations can be chained
+        initialProjection = Matx44f::zeros();
+        for (unsigned char j = 0; j < 3; ++j)
+            for (unsigned char i = 0; i < 3; ++i)
+                initialProjection(j, i) = registeredCameraMatrix(j, i);
+        initialProjection(3, 3) = 1;
+
+        initialProjection = initialProjection * rbtRgb2Depth * K.inv();
+    }
+
+    // Apply the initial projection to the input depth
+    Mat_<Point3f> transformedCloud;
+    {
+        Mat_<Point3f> point_tmp(outputImagePlaneSize, Point3f(0., 0., 0.));
+        for (int j = 0; j < unregisteredDepth.rows; ++j)
+        {
+            const DepthDepth* unregisteredDepthPtr = unregisteredDepth[j];
+
+            Point3f* point = point_tmp[j];
+            for (int i = 0; i < unregisteredDepth.cols; ++i, ++unregisteredDepthPtr, ++point)
+            {
+                float rescaled_depth = float(*unregisteredDepthPtr) * inputDepthToMetersScale;
+
+                // If the DepthDepth is of type unsigned short, zero is a sentinel value to indicate
+                // no depth. CV_32F and CV_64F should already have NaN for no depth values.
+                if (rescaled_depth == 0)
+                {
+                    rescaled_depth = std::numeric_limits<float>::quiet_NaN();
+                }
+
+                point->x = i * rescaled_depth;
+                point->y = j * rescaled_depth;
+                point->z = rescaled_depth;
+            }
+        }
+
+        perspectiveTransform(point_tmp, transformedCloud, initialProjection);
+    }
+
+    std::vector<Point2f> transformedAndProjectedPoints(transformedCloud.cols);
+    const float metersToInputUnitsScale = 1 / inputDepthToMetersScale;
+    const Rect registeredDepthBounds(Point(), outputImagePlaneSize);
+
+    for (int y = 0; y < transformedCloud.rows; y++)
+    {
+        if (hasDistortion)
+        {
+
+            // Project an entire row of points with distortion.
+            // Doing this for the entire image at once would require more memory.
+            projectPoints(transformedCloud.row(y),
+                          Vec3f(0, 0, 0),
+                          Vec3f(0, 0, 0),
+                          registeredCameraMatrix,
+                          registeredDistCoeffs,
+                          transformedAndProjectedPoints);
+        }
+        else
+        {
+            // With no distortion, we just have to dehomogenize the point since all major transforms
+            // already happened with initialProjection.
+            Point2f* point2d = &transformedAndProjectedPoints[0];
+            const Point2f* point2d_end = point2d + transformedAndProjectedPoints.size();
+            const Point3f* point3d = transformedCloud[y];
+            for (; point2d < point2d_end; ++point2d, ++point3d)
+            {
+                point2d->x = point3d->x / point3d->z;
+                point2d->y = point3d->y / point3d->z;
+            }
+        }
+
+        const Point2f* outputProjectedPoint = &transformedAndProjectedPoints[0];
+        const Point3f* p = transformedCloud[y], * p_end = p + transformedCloud.cols;
+
+        for (; p < p_end; ++outputProjectedPoint, ++p)
+        {
+            // Skip this one if there isn't a valid depth
+            const Point2f projectedPixelFloatLocation = *outputProjectedPoint;
+            if (cvIsNaN(projectedPixelFloatLocation.x))
+                continue;
+
+            //Get integer pixel location
+            const Point2i projectedPixelLocation = projectedPixelFloatLocation;
+
+            // Ensure that the projected point is actually contained in our output image
+            if (!registeredDepthBounds.contains(projectedPixelLocation))
+                continue;
+
+            // Go back to our original scale, since that's what our output will be
+            // The templated function is to ensure that integer values are rounded to the nearest integer
+            const DepthDepth cloudDepth = floatToInputDepth<DepthDepth>(p->z * metersToInputUnitsScale);
+
+            DepthDepth& outputDepth = registeredDepth.at<DepthDepth>(projectedPixelLocation.y, projectedPixelLocation.x);
+
+            // Occlusion check
+            if (isEqualToNoDepthSentinelValue<DepthDepth>(outputDepth) || (outputDepth > cloudDepth))
+                outputDepth = cloudDepth;
+
+            // If desired, dilate this point to avoid holes in the final image
+            if (depthDilation)
+            {
+                // Choosing to dilate in a 2x2 region, where the original projected location is in the bottom right of this
+                // region. This is what's done on PrimeSense devices, but a more accurate scheme could be used.
+                const Point2i dilatedProjectedLocations[3] = { Point2i(projectedPixelLocation.x - 1, projectedPixelLocation.y),
+                                                               Point2i(projectedPixelLocation.x    , projectedPixelLocation.y - 1),
+                                                               Point2i(projectedPixelLocation.x - 1, projectedPixelLocation.y - 1) };
+
+                for (int i = 0; i < 3; i++)
+                {
+                    const Point2i& dilatedCoordinates = dilatedProjectedLocations[i];
+
+                    if (!registeredDepthBounds.contains(dilatedCoordinates))
+                        continue;
+
+                    DepthDepth& outputDilatedDepth = registeredDepth.at<DepthDepth>(dilatedCoordinates.y, dilatedCoordinates.x);
+
+                    // Occlusion check
+                    if (isEqualToNoDepthSentinelValue(outputDilatedDepth) || (outputDilatedDepth > cloudDepth))
+                        outputDilatedDepth = cloudDepth;
+                }
+
+            } // depthDilation
+
+        } // iterate cols
+    } // iterate rows
+}
+
+
+
+void
+registerDepth(InputArray unregisteredCameraMatrix, InputArray registeredCameraMatrix, InputArray registeredDistCoeffs,
+              InputArray Rt, InputArray unregisteredDepth, const Size& outputImagePlaneSize,
+              OutputArray registeredDepth, bool depthDilation)
+{
+    CV_Assert(unregisteredCameraMatrix.depth() == CV_64F || unregisteredCameraMatrix.depth() == CV_32F);
+    CV_Assert(registeredCameraMatrix.depth() == CV_64F   || registeredCameraMatrix.depth() == CV_32F);
+    CV_Assert(registeredDistCoeffs.empty() || registeredDistCoeffs.depth() == CV_64F || registeredDistCoeffs.depth() == CV_32F);
+    CV_Assert(Rt.depth() == CV_64F || Rt.depth() == CV_32F);
+
+    CV_Assert(unregisteredDepth.cols() > 0 && unregisteredDepth.rows() > 0 &&
+              (unregisteredDepth.depth() == CV_32F || unregisteredDepth.depth() == CV_64F || unregisteredDepth.depth() == CV_16U));
+    CV_Assert(outputImagePlaneSize.height > 0 && outputImagePlaneSize.width > 0);
+
+    // Implicitly checking dimensions of the InputArrays
+    Matx33f _unregisteredCameraMatrix = unregisteredCameraMatrix.getMat();
+    Matx33f _registeredCameraMatrix = registeredCameraMatrix.getMat();
+    Mat_<float> _registeredDistCoeffs = registeredDistCoeffs.getMat();
+    Matx44f _rbtRgb2Depth = Rt.getMat();
+
+    Mat& registeredDepthMat = registeredDepth.getMatRef();
+
+    switch (unregisteredDepth.depth())
+    {
+    case CV_16U:
+    {
+        performRegistration<unsigned short>(unregisteredDepth.getMat(), _unregisteredCameraMatrix,
+            _registeredCameraMatrix, _registeredDistCoeffs,
+            _rbtRgb2Depth, outputImagePlaneSize, depthDilation,
+            .001f, registeredDepthMat);
+        break;
+    }
+    case CV_32F:
+    {
+        performRegistration<float>(unregisteredDepth.getMat(), _unregisteredCameraMatrix,
+                                   _registeredCameraMatrix, _registeredDistCoeffs,
+                                   _rbtRgb2Depth, outputImagePlaneSize, depthDilation,
+                                   1.0f, registeredDepthMat);
+        break;
+    }
+    case CV_64F:
+    {
+        performRegistration<double>(unregisteredDepth.getMat(), _unregisteredCameraMatrix,
+                                    _registeredCameraMatrix, _registeredDistCoeffs,
+                                    _rbtRgb2Depth, outputImagePlaneSize, depthDilation,
+                                    1.0f, registeredDepthMat);
+        break;
+    }
+    default:
+    {
+        CV_Error(Error::StsUnsupportedFormat, "Input depth must be unsigned short, float, or double.");
+    }
+    }
+}
+
+} /* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp b/upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp
new file mode 100644
index 0000000..f6f13a0
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/depth_to_3d.cpp
@@ -0,0 +1,254 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "depth_to_3d.hpp"
+
+namespace cv
+{
+
+/** If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
+ * by 1000 to get a depth in meters, and the values 0 are converted to std::numeric_limits<float>::quiet_NaN()
+ * Otherwise, the image is simply converted to floats
+ * @param in_in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
+ *              (as done with the Microsoft Kinect), it is assumed in meters)
+ * @param depth the desired output depth (floats or double)
+ * @param out_out The rescaled float depth image
+ */
+void rescaleDepth(InputArray in_in, int type, OutputArray out_out, double depth_factor)
+{
+    cv::Mat in = in_in.getMat();
+    CV_Assert(in.type() == CV_64FC1 || in.type() == CV_32FC1 || in.type() == CV_16UC1 || in.type() == CV_16SC1);
+    CV_Assert(type == CV_64FC1 || type == CV_32FC1);
+
+    int in_depth = in.depth();
+
+    out_out.create(in.size(), type);
+    cv::Mat out = out_out.getMat();
+    if (in_depth == CV_16U)
+    {
+      in.convertTo(out, type, 1 / depth_factor); //convert to float so that it is in meters
+      cv::Mat valid_mask = in == std::numeric_limits<ushort>::min(); // Should we do std::numeric_limits<ushort>::max() too ?
+      out.setTo(std::numeric_limits<float>::quiet_NaN(), valid_mask); //set a$
+    }
+    if (in_depth == CV_16S)
+    {
+      in.convertTo(out, type, 1 / depth_factor); //convert to float so tha$
+      cv::Mat valid_mask = (in == std::numeric_limits<short>::min()) | (in == std::numeric_limits<short>::max()); // Should we do std::numeric_limits<ushort>::max() too ?
+      out.setTo(std::numeric_limits<float>::quiet_NaN(), valid_mask); //set a$
+    }
+    if ((in_depth == CV_32F) || (in_depth == CV_64F))
+      in.convertTo(out, type);
+}
+
+
+/**
+ * @param K
+ * @param depth the depth image
+ * @param mask the mask of the points to consider (can be empty)
+ * @param points3d the resulting 3d points, a 3-channel matrix
+ */
+static void depthTo3d_from_uvz(const cv::Mat& in_K, const cv::Mat& u_mat, const cv::Mat& v_mat, const cv::Mat& z_mat,
+                               cv::Mat& points3d)
+{
+    CV_Assert((u_mat.size() == z_mat.size()) && (v_mat.size() == z_mat.size()));
+    if (u_mat.empty())
+        return;
+    CV_Assert((u_mat.type() == z_mat.type()) && (v_mat.type() == z_mat.type()));
+
+    //grab camera params
+    cv::Mat_<float> K;
+
+    if (in_K.depth() == CV_32F)
+        K = in_K;
+    else
+        in_K.convertTo(K, CV_32F);
+
+    float fx = K(0, 0);
+    float fy = K(1, 1);
+    float s = K(0, 1);
+    float cx = K(0, 2);
+    float cy = K(1, 2);
+
+    std::vector<cv::Mat> coordinates(4);
+
+    coordinates[0] = (u_mat - cx) / fx;
+
+    if (s != 0)
+        coordinates[0] = coordinates[0] + (-(s / fy) * v_mat + cy * s / fy) / fx;
+
+    coordinates[0] = coordinates[0].mul(z_mat);
+    coordinates[1] = (v_mat - cy).mul(z_mat) * (1. / fy);
+    coordinates[2] = z_mat;
+    coordinates[3] = Mat(u_mat.size(), CV_32F, Scalar(0));
+    cv::merge(coordinates, points3d);
+}
+
+/**
+ * @param K
+ * @param depth the depth image
+ * @param mask the mask of the points to consider (can be empty)
+ * @param points3d the resulting 3d points
+ */
+static void depthTo3dMask(const cv::Mat& depth, const cv::Mat& K, const cv::Mat& mask, cv::Mat& points3d)
+{
+    // Create 3D points in one go.
+    cv::Mat_<float> u_mat, v_mat, z_mat;
+
+    cv::Mat_<uchar> uchar_mask = mask;
+
+    if (mask.depth() != (CV_8U))
+        mask.convertTo(uchar_mask, CV_8U);
+
+    // Figure out the interesting indices
+    size_t n_points;
+
+    if (depth.depth() == CV_16U)
+        n_points = convertDepthToFloat<ushort>(depth, mask, 1.0f / 1000.0f, u_mat, v_mat, z_mat);
+    else if (depth.depth() == CV_16S)
+        n_points = convertDepthToFloat<short>(depth, mask, 1.0f / 1000.0f, u_mat, v_mat, z_mat);
+    else
+    {
+        CV_Assert(depth.type() == CV_32F);
+        n_points = convertDepthToFloat<float>(depth, mask, 1.0f, u_mat, v_mat, z_mat);
+    }
+
+    if (n_points == 0)
+        return;
+
+    u_mat.resize(n_points);
+    v_mat.resize(n_points);
+    z_mat.resize(n_points);
+
+    depthTo3d_from_uvz(K, u_mat, v_mat, z_mat, points3d);
+    points3d = points3d.reshape(4, 1);
+}
+
+/**
+ * @param K
+ * @param depth the depth image
+ * @param points3d the resulting 3d points
+ */
+template<typename T>
+void depthTo3dNoMask(const cv::Mat& in_depth, const cv::Mat_<T>& K, cv::Mat& points3d)
+{
+    const T inv_fx = T(1) / K(0, 0);
+    const T inv_fy = T(1) / K(1, 1);
+    const T ox = K(0, 2);
+    const T oy = K(1, 2);
+
+    // Build z
+    cv::Mat_<T> z_mat;
+    if (z_mat.depth() == in_depth.depth())
+        z_mat = in_depth;
+    else
+        rescaleDepthTemplated<T>(in_depth, z_mat);
+
+    // Pre-compute some constants
+    cv::Mat_<T> x_cache(1, in_depth.cols), y_cache(in_depth.rows, 1);
+    T* x_cache_ptr = x_cache[0], * y_cache_ptr = y_cache[0];
+    for (int x = 0; x < in_depth.cols; ++x, ++x_cache_ptr)
+        *x_cache_ptr = (x - ox) * inv_fx;
+    for (int y = 0; y < in_depth.rows; ++y, ++y_cache_ptr)
+        *y_cache_ptr = (y - oy) * inv_fy;
+
+    y_cache_ptr = y_cache[0];
+    for (int y = 0; y < in_depth.rows; ++y, ++y_cache_ptr)
+    {
+        cv::Vec<T, 4>* point = points3d.ptr<cv::Vec<T, 4> >(y);
+        const T* x_cache_ptr_end = x_cache[0] + in_depth.cols;
+        const T* depth = z_mat[y];
+        for (x_cache_ptr = x_cache[0]; x_cache_ptr != x_cache_ptr_end; ++x_cache_ptr, ++point, ++depth)
+        {
+            T z = *depth;
+            (*point)[0] = (*x_cache_ptr) * z;
+            (*point)[1] = (*y_cache_ptr) * z;
+            (*point)[2] = z;
+            (*point)[3] = 0;
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @param K
+ * @param depth the depth image
+ * @param u_mat the list of x coordinates
+ * @param v_mat the list of matching y coordinates
+ * @param points3d the resulting 3d points
+ */
+void depthTo3dSparse(InputArray depth_in, InputArray K_in, InputArray points_in, OutputArray points3d_out)
+{
+    // Make sure we use foat types
+    cv::Mat points = points_in.getMat();
+    cv::Mat depth = depth_in.getMat();
+
+    cv::Mat points_float;
+    if (points.depth() != CV_32F)
+        points.convertTo(points_float, CV_32FC2);
+    else
+        points_float = points;
+
+    // Fill the depth matrix
+    cv::Mat_<float> z_mat;
+
+    if (depth.depth() == CV_16U)
+        convertDepthToFloat<ushort>(depth, 1.0f / 1000.0f, points_float, z_mat);
+    else if (depth.depth() == CV_16U)
+        convertDepthToFloat<short>(depth, 1.0f / 1000.0f, points_float, z_mat);
+    else
+    {
+        CV_Assert(depth.type() == CV_32F);
+        convertDepthToFloat<float>(depth, 1.0f, points_float, z_mat);
+    }
+
+    std::vector<cv::Mat> channels(2);
+    cv::split(points_float, channels);
+
+    points3d_out.create(channels[0].rows, channels[0].cols, CV_32FC4);
+    cv::Mat points3d = points3d_out.getMat();
+    depthTo3d_from_uvz(K_in.getMat(), channels[0], channels[1], z_mat, points3d);
+}
+
+/**
+ * @param depth the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
+ *              (as done with the Microsoft Kinect), otherwise, if given as CV_32F, it is assumed in meters)
+ * @param K The calibration matrix
+ * @param points3d the resulting 3d points. They are of depth the same as `depth` if it is CV_32F or CV_64F, and the
+ *        depth of `K` if `depth` is of depth CV_U
+ * @param mask the mask of the points to consider (can be empty)
+ */
+void depthTo3d(InputArray depth_in, InputArray K_in, OutputArray points3d_out, InputArray mask_in)
+{
+    cv::Mat depth = depth_in.getMat();
+    cv::Mat K = K_in.getMat();
+    cv::Mat mask = mask_in.getMat();
+    CV_Assert(K.cols == 3 && K.rows == 3 && (K.depth() == CV_64F || K.depth() == CV_32F));
+    CV_Assert(depth.type() == CV_64FC1 || depth.type() == CV_32FC1 || depth.type() == CV_16UC1 || depth.type() == CV_16SC1);
+    CV_Assert(mask.empty() || mask.channels() == 1);
+
+    cv::Mat K_new;
+    K.convertTo(K_new, depth.depth() == CV_64F ? CV_64F : CV_32F); // issue #1021
+
+    // Create 3D points in one go.
+    if (!mask.empty())
+    {
+        cv::Mat points3d;
+        depthTo3dMask(depth, K_new, mask, points3d);
+        points3d_out.create(points3d.size(), CV_MAKETYPE(K_new.depth(), 4));
+        points3d.copyTo(points3d_out.getMat());
+    }
+    else
+    {
+        points3d_out.create(depth.size(), CV_MAKETYPE(K_new.depth(), 4));
+        cv::Mat points3d = points3d_out.getMat();
+        if (K_new.depth() == CV_64F)
+            depthTo3dNoMask<double>(depth, K_new, points3d);
+        else
+            depthTo3dNoMask<float>(depth, K_new, points3d);
+    }
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/depth_to_3d.hpp b/upstream/opencv/modules/ptcloud/src/depth_to_3d.hpp
new file mode 100644
index 0000000..2692cd8
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/depth_to_3d.hpp
@@ -0,0 +1,115 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_DEPTH_TO_3D_HPP
+#define OPENCV_3D_DEPTH_TO_3D_HPP
+
+#include "precomp.hpp"
+#include "utils.hpp"
+
+namespace cv
+{
+
+/** If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
+ * by 1000 to get a depth in meters, and the values 0 are converted to std::numeric_limits<float>::quiet_NaN()
+ * Otherwise, the image is simply converted to floats
+ * @param in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters
+ *              (as done with the Microsoft Kinect), it is assumed in meters)
+ * @param the desired output depth (floats or double)
+ * @param out The rescaled float depth image
+ */
+/* void rescaleDepth(InputArray in_in, int depth, OutputArray out_out); */
+
+template<typename T>
+void
+rescaleDepthTemplated(const Mat& in, Mat& out);
+
+template<>
+inline void
+rescaleDepthTemplated<float>(const Mat& in, Mat& out)
+{
+  rescaleDepth(in, CV_32F, out);
+}
+
+template<>
+inline void
+rescaleDepthTemplated<double>(const Mat& in, Mat& out)
+{
+  rescaleDepth(in, CV_64F, out);
+}
+
+/**
+ * @param depth the depth image, containing depth with the value T
+ * @param the mask, containing CV_8UC1
+ */
+template <typename T>
+size_t convertDepthToFloat(const cv::Mat& depth, const cv::Mat& mask, float scale, cv::Mat_<float> &u_mat, cv::Mat_<float> &v_mat, cv::Mat_<float> &z_mat)
+{
+    CV_Assert(depth.size == mask.size);
+
+    cv::Size depth_size = depth.size();
+
+    cv::Mat_<uchar> uchar_mask = mask;
+
+    if ((mask.depth() != CV_8S) && (mask.depth() != CV_8U) && (mask.depth() != CV_Bool))
+        mask.convertTo(uchar_mask, CV_8U);
+
+    u_mat = cv::Mat_<float>(depth_size.area(), 1);
+    v_mat = cv::Mat_<float>(depth_size.area(), 1);
+    z_mat = cv::Mat_<float>(depth_size.area(), 1);
+
+    // Raw data from the Kinect has int
+    size_t n_points = 0;
+
+    for (int v = 0; v < depth_size.height; v++)
+    {
+        uchar* r = uchar_mask.ptr<uchar>(v, 0);
+
+        for (int u = 0; u < depth_size.width; u++, ++r)
+            if (*r)
+            {
+                u_mat((int)n_points, 0) = (float)u;
+                v_mat((int)n_points, 0) = (float)v;
+                T depth_i = depth.at<T>(v, u);
+
+                if (cvIsNaN((float)depth_i) || (depth_i == std::numeric_limits<T>::min()) || (depth_i == std::numeric_limits<T>::max()))
+                    z_mat((int)n_points, 0) = std::numeric_limits<float>::quiet_NaN();
+                else
+                    z_mat((int)n_points, 0) = depth_i * scale;
+
+                ++n_points;
+            }
+    }
+
+    return n_points;
+}
+
+/**
+ * @param depth the depth image, containing depth with the value T
+ * @param the mask, containing CV_8UC1
+ */
+template <typename T>
+void convertDepthToFloat(const cv::Mat& depth, float scale, const cv::Mat &uv_mat, cv::Mat_<float> &z_mat)
+{
+    z_mat = cv::Mat_<float>(uv_mat.size());
+
+    // Raw data from the Kinect has int
+    float* z_mat_iter = reinterpret_cast<float*>(z_mat.data);
+
+    for (cv::Mat_<cv::Vec2f>::const_iterator uv_iter = uv_mat.begin<cv::Vec2f>(), uv_end = uv_mat.end<cv::Vec2f>();
+        uv_iter != uv_end; ++uv_iter, ++z_mat_iter)
+    {
+        T depth_i = depth.at < T >((int)(*uv_iter)[1], (int)(*uv_iter)[0]);
+
+        if (cvIsNaN((float)depth_i) || (depth_i == std::numeric_limits < T > ::min())
+            || (depth_i == std::numeric_limits < T > ::max()))
+            *z_mat_iter = std::numeric_limits<float>::quiet_NaN();
+        else
+            *z_mat_iter = depth_i * scale;
+    }
+}
+
+}
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp b/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp
new file mode 100644
index 0000000..fe57723
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.cpp
@@ -0,0 +1,1542 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#include "precomp.hpp"
+#include "hash_tsdf_functions.hpp"
+#include "opencl_kernels_ptcloud.hpp"
+
+namespace cv {
+
+static Vec3i volumeToVolumeUnitIdx(const Point3f& point, const float volumeUnitSize)
+{
+    return cv::Vec3i(
+        cvFloor(point.x / volumeUnitSize),
+        cvFloor(point.y / volumeUnitSize),
+        cvFloor(point.z / volumeUnitSize));
+}
+
+static cv::Point3f volumeUnitIdxToVolume(const cv::Vec3i& volumeUnitIdx, const float volumeUnitSize)
+{
+    return cv::Point3f(
+        volumeUnitIdx[0] * volumeUnitSize,
+        volumeUnitIdx[1] * volumeUnitSize,
+        volumeUnitIdx[2] * volumeUnitSize);
+}
+
+static cv::Point3f voxelCoordToVolume(const cv::Vec3i& voxelIdx, const float voxelSize)
+{
+    return cv::Point3f(
+        voxelIdx[0] * voxelSize,
+        voxelIdx[1] * voxelSize,
+        voxelIdx[2] * voxelSize);
+}
+
+static cv::Vec3i volumeToVoxelCoord(const cv::Point3f& point, const float voxelSizeInv)
+{
+    return cv::Vec3i(
+        cvFloor(point.x * voxelSizeInv),
+        cvFloor(point.y * voxelSizeInv),
+        cvFloor(point.z * voxelSizeInv));
+}
+
+int calcVolumeUnitDegree(Point3i volumeResolution)
+{
+    if (!(volumeResolution.x & (volumeResolution.x - 1)))
+    {
+        // vuRes is a power of 2, let's get this power
+        return trailingZeros32(volumeResolution.x);
+    }
+    else
+    {
+        CV_Error(Error::StsBadArg, "Volume unit resolution should be a power of 2");
+    }
+}
+
+void allocateVolumeUnits(
+    const UMat& _depth, float depthFactor, const Affine3f volumePose, const Matx44f& cameraPose, const Intr& intrinsics,
+    CustomHashSet& hashTable, const int volumeUnitDegree, const float truncDist, const float maxDepth, const float volumeUnitSize);
+
+TsdfVoxel atVolumeUnit(
+    const Mat& volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const Vec3i& point, const Vec3i& volumeUnitIdx, VolumeUnitIndexes::const_iterator it,
+    const int volumeUnitDegree, const Vec4i volStrides);
+
+TsdfVoxel new_atVolumeUnit(
+    const Mat& volUnitsDataCopy,
+    const Vec3i& point, const Vec3i& volumeUnitIdx, const int indx,
+    const int volumeUnitDegree, const Vec4i volStrides);
+
+Point3f getNormalVoxel(
+    const Point3f& point, const float voxelSizeInv,
+    const int volumeUnitDegree, const Vec4i volStrides,
+    const Mat& volUnitsDataCopy, const VolumeUnitIndexes& volumeUnits);
+
+
+#ifdef HAVE_OPENCL
+void markActive(
+    const Matx44f& cameraPose, const Intr& intrinsics, const Size frameSz, const int frameId,
+    const Affine3f volumePose, CustomHashSet& hashTable, UMat& isActiveFlags, UMat& lastVisibleIndices,
+    const float maxDepth, const float volumeUnitSize);
+
+Point3f ocl_getNormalVoxel(
+    const Point3f& point, const float voxelSizeInv,
+    const int volumeUnitDegree, const Vec4i volStrides,
+    const Mat& volUnitsData, const CustomHashSet& hashTable);
+#endif
+
+void integrateHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int& lastVolIndex, const int frameId, const int volumeUnitDegree, bool enableGrowth,
+    InputArray _depth, InputArray _pixNorms, InputOutputArray _volUnitsData, VolumeUnitIndexes& volumeUnits)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(_depth.type() == DEPTH_TYPE);
+    Depth depth = _depth.getMat();
+    Mat& volUnitsData = _volUnitsData.getMatRef();
+    Mat pixNorms = _pixNorms.getMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    const Affine3f cam2vol(pose.inv() * Affine3f(cameraPose));
+
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    const Intr intrinsics(intr);
+    const Intr::Reprojector reproj(intrinsics.makeReprojector());
+
+    const float maxDepth = settings.getMaxDepth();
+    const float voxelSize = settings.getVoxelSize();
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const float volumeUnitSize = voxelSize * resolution[0];
+
+    if (enableGrowth)
+    {
+        //! Compute volumes to be allocated
+        const int depthStride = volumeUnitDegree;
+        const float invDepthFactor = 1.f / settings.getDepthFactor();
+        const float truncDist = settings.getTsdfTruncateDistance();
+
+        const Point3f truncPt(truncDist, truncDist, truncDist);
+        std::unordered_set<cv::Vec3i, tsdf_hash> newIndices;
+        Mutex mutex;
+        Range allocateRange(0, depth.rows);
+
+        auto AllocateVolumeUnitsInvoker = [&](const Range& range)
+        {
+            std::unordered_set<cv::Vec3i, tsdf_hash> localAccessVolUnits;
+            for (int y = range.start; y < range.end; y += depthStride)
+            {
+                const depthType* depthRow = depth[y];
+                for (int x = 0; x < depth.cols; x += depthStride)
+                {
+                    depthType z = depthRow[x] * invDepthFactor;
+
+                    if (z <= 0 || z > maxDepth)
+                        continue;
+
+                    Point3f camPoint = reproj(Point3f((float)x, (float)y, z));
+                    Point3f volPoint = cam2vol * camPoint;
+                    //! Find accessed TSDF volume unit for valid 3D vertex
+                    Vec3i lower_bound = volumeToVolumeUnitIdx(volPoint - truncPt, volumeUnitSize);
+                    Vec3i upper_bound = volumeToVolumeUnitIdx(volPoint + truncPt, volumeUnitSize);
+
+                    for (int i = lower_bound[0]; i <= upper_bound[0]; i++)
+                        for (int j = lower_bound[1]; j <= upper_bound[1]; j++)
+                            for (int k = lower_bound[2]; k <= upper_bound[2]; k++)
+                            {
+                                const Vec3i tsdf_idx = Vec3i(i, j, k);
+                                if (localAccessVolUnits.count(tsdf_idx) <= 0 && volumeUnits.count(tsdf_idx) <= 0)
+                                {
+                                    //! This volume unit will definitely be required for current integration
+                                    localAccessVolUnits.emplace(tsdf_idx);
+                                }
+                            }
+                }
+            }
+
+            mutex.lock();
+            for (const auto& tsdf_idx : localAccessVolUnits)
+            {
+                //! If the insert into the global set passes
+                if (!newIndices.count(tsdf_idx))
+                {
+                    // Volume allocation can be performed outside of the lock
+                    newIndices.emplace(tsdf_idx);
+                }
+            }
+            mutex.unlock();
+        };
+        parallel_for_(allocateRange, AllocateVolumeUnitsInvoker);
+
+        //! Perform the allocation
+        for (auto idx : newIndices)
+        {
+            VolumeUnit& vu = volumeUnits.emplace(idx, VolumeUnit()).first->second;
+
+            Matx44f subvolumePose = pose.translate(pose.rotation() * volumeUnitIdxToVolume(idx, volumeUnitSize)).matrix;
+
+            vu.pose = subvolumePose;
+            vu.index = lastVolIndex;
+            if (lastVolIndex >= int(volUnitsData.size().height))
+            {
+                volUnitsData.resize(lastVolIndex * 2);
+                CV_LOG_DEBUG(NULL, "HashTSDF storage extended from " << lastVolIndex << " to " << lastVolIndex * 2 << " volume units");
+            }
+            lastVolIndex++;
+            volUnitsData.row(vu.index).forEach<VecTsdfVoxel>([](VecTsdfVoxel &vv, const int * /* position */)
+            {
+                TsdfVoxel& v = reinterpret_cast<TsdfVoxel&>(vv);
+                v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+            });
+            //! This volume unit will definitely be required for current integration
+            vu.lastVisibleIndex = frameId;
+            vu.isActive = true;
+        }
+    }
+
+    //! Get keys for all the allocated volume Units
+    std::vector<Vec3i> totalVolUnits;
+    for (const auto& keyvalue : volumeUnits)
+    {
+        totalVolUnits.push_back(keyvalue.first);
+    }
+
+    //! Mark volumes in the camera frustum as active
+    Range inFrustumRange(0, (int)volumeUnits.size());
+    parallel_for_(inFrustumRange, [&](const Range& range)
+    {
+        const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+        const Intr::Projector proj(intrinsics.makeProjector());
+
+        for (int i = range.start; i < range.end; ++i)
+        {
+            Vec3i tsdf_idx = totalVolUnits[i];
+            VolumeUnitIndexes::iterator it = volumeUnits.find(tsdf_idx);
+            if (it == volumeUnits.end())
+                continue;
+
+            Point3f volumeUnitPos = volumeUnitIdxToVolume(it->first, volumeUnitSize);
+            Point3f volUnitInCamSpace = vol2cam * volumeUnitPos;
+            if (volUnitInCamSpace.z < 0 || volUnitInCamSpace.z > maxDepth)
+            {
+                it->second.isActive = false;
+                continue;
+            }
+            Point2f cameraPoint = proj(volUnitInCamSpace);
+            if (cameraPoint.x >= 0 && cameraPoint.y >= 0 && cameraPoint.x < depth.cols && cameraPoint.y < depth.rows)
+            {
+                assert(it != volumeUnits.end());
+                it->second.lastVisibleIndex = frameId;
+                it->second.isActive = true;
+            }
+        }
+    });
+
+
+    //! Integrate the correct volumeUnits
+    parallel_for_(Range(0, (int)totalVolUnits.size()), [&](const Range& range)
+    {
+        for (int i = range.start; i < range.end; i++)
+        {
+            Vec3i tsdf_idx = totalVolUnits[i];
+            VolumeUnitIndexes::iterator it = volumeUnits.find(tsdf_idx);
+            if (it == volumeUnits.end())
+                return;
+
+            VolumeUnit& volumeUnit = it->second;
+            if (volumeUnit.isActive)
+            {
+                //! The volume unit should already be added into the Volume from the allocator
+                integrateTsdfVolumeUnit(settings, volumeUnit.pose, cameraPose, depth, pixNorms, volUnitsData.row(volumeUnit.index));
+
+                //! Ensure all active volumeUnits are set to inactive for next integration
+                volumeUnit.isActive = false;
+            }
+        }
+    });
+}
+
+
+void allocateVolumeUnits(
+    const UMat& _depth, float depthFactor, const Affine3f volumePose, const Matx44f& cameraPose, const Intr& intrinsics,
+    CustomHashSet& hashTable, const int volumeUnitDegree, const float truncDist, const float maxDepth, const float volumeUnitSize)
+{
+    constexpr int pixCapacity = 16;
+    typedef std::array<Vec3i, pixCapacity> LocalVolUnits;
+
+    Depth depth = _depth.getMat(ACCESS_READ);
+
+    //! Compute volumes to be allocated
+    const int depthStride = volumeUnitDegree;
+    const float invDepthFactor = 1.f / depthFactor;
+    const Intr::Reprojector reproj(intrinsics.makeReprojector());
+    const Affine3f cam2vol(volumePose.inv() * Affine3f(cameraPose));
+    const Point3f truncPt(truncDist, truncDist, truncDist);
+    Mutex mutex;
+
+    // for new indices
+    CustomHashSet thm;
+
+    auto fillLocalAcessVolUnits = [&](const Range& xrange, const Range& yrange, CustomHashSet& ghm)
+    {
+        for (int y = yrange.start; y < yrange.end; y += depthStride)
+        {
+            const depthType* depthRow = depth[y];
+            for (int x = xrange.start; x < xrange.end; x += depthStride)
+            {
+                depthType z = depthRow[x] * invDepthFactor;
+                if (z <= 0 || z > maxDepth)
+                    continue;
+                Point3f camPoint = reproj(Point3f((float)x, (float)y, z));
+                Point3f volPoint = cam2vol * camPoint;
+                //! Find accessed TSDF volume unit for valid 3D vertex
+                Vec3i lower_bound = volumeToVolumeUnitIdx(volPoint - truncPt, volumeUnitSize);
+                Vec3i upper_bound = volumeToVolumeUnitIdx(volPoint + truncPt, volumeUnitSize);
+
+                int pixLocalCounter = 0;
+                LocalVolUnits pixLocalVolUnits;
+                for (int i = lower_bound[0]; i <= upper_bound[0]; i++)
+                    for (int j = lower_bound[1]; j <= upper_bound[1]; j++)
+                        for (int k = lower_bound[2]; k <= upper_bound[2]; k++)
+                        {
+                            const Vec3i tsdf_idx = Vec3i(i, j, k);
+
+                            if (hashTable.find(tsdf_idx) < 0)
+                            {
+                                bool found = false;
+                                for (int c = 0; c < pixLocalCounter; c++)
+                                {
+                                    if (pixLocalVolUnits[c] == tsdf_idx)
+                                    {
+                                        found = true; break;
+                                    }
+                                }
+                                if (!found)
+                                {
+                                    pixLocalVolUnits[pixLocalCounter++] = tsdf_idx;
+                                    if (pixLocalCounter >= pixCapacity)
+                                    {
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+
+                // lock localAccessVolUnits somehow
+                for (int i = 0; i < pixLocalCounter; i++)
+                {
+                    Vec3i idx = pixLocalVolUnits[i];
+                    if (!ghm.insert(idx))
+                    {
+                        //return;
+                    }
+                }
+                // unlock
+            }
+        }
+    };
+
+    Rect dim(0, 0, depth.cols, depth.rows);
+    Size gsz(32, 32);
+    Size gg(divUp(dim.width, gsz.width), divUp(dim.height, gsz.height));
+
+    bool needReallocation = false;
+    auto allocateLambda = [&](const Range& r)
+    {
+
+        for (int yg = r.start; yg < r.end; yg++)
+        {
+            for (int xg = 0; xg < gg.width; xg++)
+            {
+                Rect gr(xg * gsz.width, yg * gsz.height, (xg + 1) * gsz.width, (yg + 1) * gsz.height);
+                gr = gr & dim;
+                Range xr(gr.tl().x, gr.br().x), yr(gr.tl().y, gr.br().y);
+
+                CustomHashSet ghm;
+
+                fillLocalAcessVolUnits(xr, yr, ghm);
+
+                if (ghm.last)
+                {
+                    cv::AutoLock al(mutex);
+
+                    for (int i = 0; i < ghm.last; i++)
+                    {
+                        Vec4i node = ghm.data[i];
+                        Vec3i idx(node[0], node[1], node[2]);
+
+                        //TODO: 1. add to separate hash map instead, then merge on GPU side
+
+                        int result = thm.insert(idx);
+                        if (!result)
+                        {
+                            needReallocation = true;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+    };
+
+    do
+    {
+        if (needReallocation)
+        {
+            thm.capacity *= 2;
+            thm.data.resize(thm.capacity);
+
+            needReallocation = false;
+        }
+
+        parallel_for_(Range(0, gg.height), allocateLambda);
+    } while (needReallocation);
+
+
+    auto pushToGlobal = [](const CustomHashSet _thm, CustomHashSet& _globalHashMap,
+        bool& _needReallocation, Mutex& _mutex)
+    {
+        for (int i = 0; i < _thm.last; i++)
+        {
+            Vec4i node = _thm.data[i];
+            Vec3i idx(node[0], node[1], node[2]);
+
+            std::lock_guard<Mutex> al(_mutex);
+
+            int result = _globalHashMap.insert(idx);
+            if (result == 0)
+            {
+                _needReallocation = true;
+                return;
+            }
+        }
+    };
+
+    needReallocation = false;
+    do
+    {
+        if (needReallocation)
+        {
+            hashTable.capacity *= 2;
+            hashTable.data.resize(hashTable.capacity);
+
+            needReallocation = false;
+        }
+
+        pushToGlobal(thm, hashTable, needReallocation, mutex);
+    } while (needReallocation);
+}
+
+#ifdef HAVE_OPENCL
+
+void markActive(
+    const Matx44f& cameraPose, const Intr& intrinsics, const Size frameSz, const int frameId,
+    const Affine3f volumePose, CustomHashSet& hashTable, UMat& isActiveFlags, UMat& lastVisibleIndices,
+    const float maxDepth, const float volumeUnitSize)
+{
+    //! Mark volumes in the camera frustum as active
+    String errorStr;
+    String name = "markActive";
+    ocl::ProgramSource source = ocl::ptcloud::hash_tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * volumePose);
+    const Intr::Projector proj(intrinsics.makeProjector());
+    Vec2f fxy(proj.fx, proj.fy), cxy(proj.cx, proj.cy);
+
+    UMat hashDataGpu = Mat(hashTable.data, false).getUMat(ACCESS_READ);
+
+    k.args(
+        ocl::KernelArg::PtrReadOnly(hashDataGpu),
+        ocl::KernelArg::WriteOnly(isActiveFlags),
+        ocl::KernelArg::WriteOnly(lastVisibleIndices),
+        vol2cam.matrix,
+        fxy,
+        cxy,
+        frameSz,
+        volumeUnitSize,
+        hashTable.last,
+        maxDepth,
+        frameId
+    );
+
+    size_t globalSize[1] = { (size_t)hashTable.last };
+    if (!k.run(1, globalSize, nullptr, true))
+        throw std::runtime_error("Failed to run kernel");
+}
+
+
+void ocl_integrateHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int& lastVolIndex, const int frameId, int& bufferSizeDegree, const int volumeUnitDegree, bool enableGrowth,
+    InputArray _depth, InputArray _pixNorms, InputArray _lastVisibleIndices, InputOutputArray _volUnitsDataCopy,  InputOutputArray _volUnitsData, CustomHashSet& hashTable, InputArray _isActiveFlags)
+{
+    CV_TRACE_FUNCTION();
+    UMat depth = _depth.getUMat();
+    CV_Assert(!depth.empty());
+    CV_Assert(lastVolIndex >= 0);
+    UMat pixNorms = _pixNorms.getUMat();
+    UMat& volUnitsData = _volUnitsData.getUMatRef();
+    Mat& volUnitsDataCopy = _volUnitsDataCopy.getMatRef();
+    UMat isActiveFlags = _isActiveFlags.getUMat();
+    UMat lastVisibleIndices = _lastVisibleIndices.getUMat();
+
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    const Intr intrinsics(intr);
+
+    Vec4i volStrides;
+    settings.getVolumeStrides(volStrides);
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const int volumeUnitResolution = resolution[0];
+    const int maxWeight = settings.getMaxWeight();
+    const float truncDist = settings.getTsdfTruncateDistance();
+    const float maxDepth = settings.getMaxDepth();
+    const float voxelSize = settings.getVoxelSize();
+    const float depthFactor = settings.getDepthFactor();
+    const float dfac = 1.f / depthFactor;
+    const float volumeUnitSize = voxelSize * resolution[0];
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    Matx44f vol2camMatrix = (Affine3f(cameraPose).inv() * pose).matrix;
+
+    if (enableGrowth)
+    {
+        // Save length to fill new data in ranges
+        int sizeBefore = hashTable.last;
+        allocateVolumeUnits(depth, depthFactor, pose, cameraPose, intrinsics, hashTable, volumeUnitDegree, truncDist, maxDepth, volumeUnitSize);
+        int sizeAfter = hashTable.last;
+        //! Perform the allocation
+
+        // Grow buffers
+        int buff_lvl = (int)(1 << bufferSizeDegree);
+        if (sizeAfter >= buff_lvl)
+        {
+            bufferSizeDegree = (int)(log2(sizeAfter) + 1); // clz() would be better
+            int oldBuffSize = buff_lvl;
+            buff_lvl = (int)pow(2, bufferSizeDegree);
+
+            volUnitsDataCopy.resize(buff_lvl);
+
+            Range oldr(0, oldBuffSize);
+            int volCubed = volumeUnitResolution * volumeUnitResolution * volumeUnitResolution;
+            UMat newData(buff_lvl, volCubed, CV_8UC2);
+            volUnitsData.copyTo(newData.rowRange(oldr));
+            volUnitsData = newData;
+
+            UMat newLastVisibleIndices(buff_lvl, 1, CV_32S);
+            lastVisibleIndices.copyTo(newLastVisibleIndices.rowRange(oldr));
+            lastVisibleIndices = newLastVisibleIndices;
+
+            UMat newIsActiveFlags(buff_lvl, 1, CV_8U);
+            isActiveFlags.copyTo(newIsActiveFlags.rowRange(oldr));
+            isActiveFlags = newIsActiveFlags;
+        }
+
+        // Fill data for new volume units
+        Range r(sizeBefore, sizeAfter);
+        if (r.start < r.end)
+        {
+            lastVisibleIndices.rowRange(r) = frameId;
+            isActiveFlags.rowRange(r) = 1;
+
+            TsdfVoxel emptyVoxel(floatToTsdf(0.0f), 0);
+            volUnitsData.rowRange(r) = Vec2b((uchar)(emptyVoxel.tsdf), (uchar)(emptyVoxel.weight));
+        }
+    }
+
+    //! Mark volumes in the camera frustum as active
+    markActive(cameraPose, intrinsics, depth.size(), frameId, pose, hashTable, isActiveFlags, lastVisibleIndices, maxDepth, volumeUnitSize);
+
+    //! Integrate the correct volumeUnits
+    String errorStr;
+    String name = "integrateAllVolumeUnits";
+    ocl::ProgramSource source = ocl::ptcloud::hash_tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    Vec2f fxy(intrinsics.fx, intrinsics.fy), cxy(intrinsics.cx, intrinsics.cy);
+
+    UMat hashesGpu = Mat(hashTable.hashes, false).getUMat(ACCESS_READ);
+    UMat hashDataGpu = Mat(hashTable.data, false).getUMat(ACCESS_READ);
+
+    k.args(ocl::KernelArg::ReadOnly(depth),
+        ocl::KernelArg::PtrReadOnly(hashesGpu),
+        ocl::KernelArg::PtrReadOnly(hashDataGpu),
+        ocl::KernelArg::ReadWrite(volUnitsData),
+        ocl::KernelArg::ReadOnly(pixNorms),
+        ocl::KernelArg::ReadOnly(isActiveFlags),
+        vol2camMatrix,
+        voxelSize,
+        volumeUnitResolution,
+        volStrides.val,
+        fxy.val,
+        cxy.val,
+        dfac,
+        truncDist,
+        int(maxWeight)
+    );
+
+    int resol = volumeUnitResolution;
+    size_t globalSize[3];
+    globalSize[0] = (size_t)resol;
+    globalSize[1] = (size_t)resol;
+    globalSize[2] = (size_t)hashTable.last; // num of volume units
+
+    if (!k.run(3, globalSize, NULL, true))
+        throw std::runtime_error("Failed to run kernel");
+}
+#endif
+
+inline TsdfVoxel _at(Mat& volUnitsData, const cv::Vec3i& volumeIdx, int indx,
+    const int volumeUnitResolution, const Vec4i volStrides)
+{
+    //! Out of bounds
+    if ((volumeIdx[0] >= volumeUnitResolution || volumeIdx[0] < 0) ||
+        (volumeIdx[1] >= volumeUnitResolution || volumeIdx[1] < 0) ||
+        (volumeIdx[2] >= volumeUnitResolution || volumeIdx[2] < 0))
+    {
+        return TsdfVoxel(floatToTsdf(1.f), 0);
+    }
+
+    const TsdfVoxel* volData = volUnitsData.ptr<TsdfVoxel>(indx);
+    int coordBase =
+        volumeIdx[0] * volStrides[0] + volumeIdx[1] * volStrides[1] + volumeIdx[2] * volStrides[2];
+    return volData[coordBase];
+}
+
+#if USE_INTRINSICS
+inline float interpolate(float tx, float ty, float tz, float vx[8])
+{
+    v_float32x4 v0246, v1357;
+    v_load_deinterleave(vx, v0246, v1357);
+
+    v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+    v_float32x4 v00_10 = vxx;
+    v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+    v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+    float v0 = v_get0(v0_1);
+    v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+    float v1 = v_get0(v0_1);
+
+    return v0 + tx * (v1 - v0);
+}
+
+#else
+inline float interpolate(float tx, float ty, float tz, float vx[8])
+{
+    float v00 = vx[0] + tz * (vx[1] - vx[0]);
+    float v01 = vx[2] + tz * (vx[3] - vx[2]);
+    float v10 = vx[4] + tz * (vx[5] - vx[4]);
+    float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+    float v0 = v00 + ty * (v01 - v00);
+    float v1 = v10 + ty * (v11 - v10);
+
+    return v0 + tx * (v1 - v0);
+}
+#endif
+
+TsdfVoxel atVolumeUnit(
+    const Mat& volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const Vec3i& point, const Vec3i& volumeUnitIdx, VolumeUnitIndexes::const_iterator it,
+    const int volumeUnitDegree, const Vec4i volStrides)
+{
+    if (it == volumeUnits.end())
+    {
+        return TsdfVoxel(floatToTsdf(1.f), 0);
+    }
+    Vec3i volUnitLocalIdx = point - Vec3i(volumeUnitIdx[0] << volumeUnitDegree,
+        volumeUnitIdx[1] << volumeUnitDegree,
+        volumeUnitIdx[2] << volumeUnitDegree);
+
+    // expanding at(), removing bounds check
+    const TsdfVoxel* volData = volUnitsData.ptr<TsdfVoxel>(it->second.index);
+    int coordBase = volUnitLocalIdx[0] * volStrides[0] + volUnitLocalIdx[1] * volStrides[1] + volUnitLocalIdx[2] * volStrides[2];
+    return volData[coordBase];
+}
+
+
+TsdfVoxel new_atVolumeUnit(
+    const Mat& volUnitsDataCopy,
+    const Vec3i& point, const Vec3i& volumeUnitIdx, const int indx,
+    const int volumeUnitDegree, const Vec4i volStrides)
+{
+    if (indx < 0)
+    {
+        return TsdfVoxel(floatToTsdf(1.f), 0);
+    }
+    Vec3i volUnitLocalIdx = point - Vec3i(volumeUnitIdx[0] << volumeUnitDegree,
+        volumeUnitIdx[1] << volumeUnitDegree,
+        volumeUnitIdx[2] << volumeUnitDegree);
+
+    // expanding at(), removing bounds check
+    const TsdfVoxel* volData = volUnitsDataCopy.ptr<TsdfVoxel>(indx);
+    int coordBase = volUnitLocalIdx[0] * volStrides[0] +
+        volUnitLocalIdx[1] * volStrides[1] +
+        volUnitLocalIdx[2] * volStrides[2];
+    return volData[coordBase];
+}
+
+
+
+Point3f getNormalVoxel(
+    const Point3f& point, const float voxelSizeInv,
+    const int volumeUnitDegree,  const Vec4i volStrides,
+    const Mat& volUnitsDataCopy, const VolumeUnitIndexes& volumeUnits)
+{
+    Vec3f normal = Vec3f(0, 0, 0);
+
+    Point3f ptVox = point * voxelSizeInv;
+    Vec3i iptVox(cvFloor(ptVox.x), cvFloor(ptVox.y), cvFloor(ptVox.z));
+
+    // A small hash table to reduce a number of find() calls
+    bool queried[8];
+    VolumeUnitIndexes::const_iterator iterMap[8];
+    for (int i = 0; i < 8; i++)
+    {
+        iterMap[i] = volumeUnits.end();
+        queried[i] = false;
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    const Vec3i offsets[] = { { 1,  0,  0}, {-1,  0,  0}, { 0,  1,  0}, // 0-3
+                              { 0, -1,  0}, { 0,  0,  1}, { 0,  0, -1}  // 4-7
+    };
+    const int nVals = 6;
+
+#else
+    const Vec3i offsets[] = { { 0,  0,  0}, { 0,  0,  1}, { 0,  1,  0}, { 0,  1,  1}, //  0-3
+                              { 1,  0,  0}, { 1,  0,  1}, { 1,  1,  0}, { 1,  1,  1}, //  4-7
+                              {-1,  0,  0}, {-1,  0,  1}, {-1,  1,  0}, {-1,  1,  1}, //  8-11
+                              { 2,  0,  0}, { 2,  0,  1}, { 2,  1,  0}, { 2,  1,  1}, // 12-15
+                              { 0, -1,  0}, { 0, -1,  1}, { 1, -1,  0}, { 1, -1,  1}, // 16-19
+                              { 0,  2,  0}, { 0,  2,  1}, { 1,  2,  0}, { 1,  2,  1}, // 20-23
+                              { 0,  0, -1}, { 0,  1, -1}, { 1,  0, -1}, { 1,  1, -1}, // 24-27
+                              { 0,  0,  2}, { 0,  1,  2}, { 1,  0,  2}, { 1,  1,  2}, // 28-31
+    };
+    const int nVals = 32;
+#endif
+
+    float vals[nVals];
+    for (int i = 0; i < nVals; i++)
+    {
+        Vec3i pt = iptVox + offsets[i];
+
+        Vec3i volumeUnitIdx = Vec3i(pt[0] >> volumeUnitDegree, pt[1] >> volumeUnitDegree, pt[2] >> volumeUnitDegree);
+
+        int dictIdx = (volumeUnitIdx[0] & 1) + (volumeUnitIdx[1] & 1) * 2 + (volumeUnitIdx[2] & 1) * 4;
+        auto it = iterMap[dictIdx];
+        if (!queried[dictIdx])
+        {
+            it = volumeUnits.find(volumeUnitIdx);
+            iterMap[dictIdx] = it;
+            queried[dictIdx] = true;
+        }
+
+        vals[i] = tsdfToFloat(atVolumeUnit(volUnitsDataCopy, volumeUnits, pt, volumeUnitIdx, it, volumeUnitDegree, volStrides).tsdf);
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    for (int c = 0; c < 3; c++)
+    {
+        normal[c] = vals[c * 2] - vals[c * 2 + 1];
+    }
+#else
+
+    float cxv[8], cyv[8], czv[8];
+
+    // How these numbers were obtained:
+    // 1. Take the basic interpolation sequence:
+    // 000, 001, 010, 011, 100, 101, 110, 111
+    // where each digit corresponds to shift by x, y, z axis respectively.
+    // 2. Add +1 for next or -1 for prev to each coordinate to corresponding axis
+    // 3. Search corresponding values in offsets
+    const int idxxp[8] = { 8,  9, 10, 11,  0,  1,  2,  3 };
+    const int idxxn[8] = { 4,  5,  6,  7, 12, 13, 14, 15 };
+    const int idxyp[8] = { 16, 17,  0,  1, 18, 19,  4,  5 };
+    const int idxyn[8] = { 2,  3, 20, 21,  6,  7, 22, 23 };
+    const int idxzp[8] = { 24,  0, 25,  2, 26,  4, 27,  6 };
+    const int idxzn[8] = { 1, 28,  3, 29,  5, 30,  7, 31 };
+
+#if !USE_INTRINSICS
+    for (int i = 0; i < 8; i++)
+    {
+        cxv[i] = vals[idxxn[i]] - vals[idxxp[i]];
+        cyv[i] = vals[idxyn[i]] - vals[idxyp[i]];
+        czv[i] = vals[idxzn[i]] - vals[idxzp[i]];
+    }
+#else
+
+# if CV_SIMD_WIDTH >= 32
+    v_float32x8 cxp = v_lut(vals, v256_load(idxxp));
+    v_float32x8 cxn = v_lut(vals, v256_load(idxxn));
+
+    v_float32x8 cyp = v_lut(vals, v256_load(idxyp));
+    v_float32x8 cyn = v_lut(vals, v256_load(idxyn));
+
+    v_float32x8 czp = v_lut(vals, v256_load(idxzp));
+    v_float32x8 czn = v_lut(vals, v256_load(idxzn));
+
+    v_float32x8 vcxv = v_sub(cxn, cxp);
+    v_float32x8 vcyv = v_sub(cyn, cyp);
+    v_float32x8 vczv = v_sub(czn, czp);
+
+    v_store(cxv, vcxv);
+    v_store(cyv, vcyv);
+    v_store(czv, vczv);
+# else
+    v_float32x4 cxp0 = v_lut(vals, idxxp + 0); v_float32x4 cxp1 = v_lut(vals, idxxp + 4);
+    v_float32x4 cxn0 = v_lut(vals, idxxn + 0); v_float32x4 cxn1 = v_lut(vals, idxxn + 4);
+
+    v_float32x4 cyp0 = v_lut(vals, idxyp + 0); v_float32x4 cyp1 = v_lut(vals, idxyp + 4);
+    v_float32x4 cyn0 = v_lut(vals, idxyn + 0); v_float32x4 cyn1 = v_lut(vals, idxyn + 4);
+
+    v_float32x4 czp0 = v_lut(vals, idxzp + 0); v_float32x4 czp1 = v_lut(vals, idxzp + 4);
+    v_float32x4 czn0 = v_lut(vals, idxzn + 0); v_float32x4 czn1 = v_lut(vals, idxzn + 4);
+
+    v_float32x4 cxv0 = v_sub(cxn0, cxp0); v_float32x4 cxv1 = v_sub(cxn1, cxp1);
+    v_float32x4 cyv0 = v_sub(cyn0, cyp0); v_float32x4 cyv1 = v_sub(cyn1, cyp1);
+    v_float32x4 czv0 = v_sub(czn0, czp0); v_float32x4 czv1 = v_sub(czn1, czp1);
+
+    v_store(cxv + 0, cxv0); v_store(cxv + 4, cxv1);
+    v_store(cyv + 0, cyv0); v_store(cyv + 4, cyv1);
+    v_store(czv + 0, czv0); v_store(czv + 4, czv1);
+#endif
+
+#endif
+
+    float tx = ptVox.x - iptVox[0];
+    float ty = ptVox.y - iptVox[1];
+    float tz = ptVox.z - iptVox[2];
+
+    normal[0] = interpolate(tx, ty, tz, cxv);
+    normal[1] = interpolate(tx, ty, tz, cyv);
+    normal[2] = interpolate(tx, ty, tz, czv);
+#endif
+
+    float nv = sqrt(normal[0] * normal[0] +
+        normal[1] * normal[1] +
+        normal[2] * normal[2]);
+    return nv < 0.0001f ? nan3 : normal / nv;
+}
+
+#ifdef HAVE_OPENCL
+
+Point3f ocl_getNormalVoxel(
+    const Point3f& point, const float voxelSizeInv,
+    const int volumeUnitDegree, const Vec4i volStrides,
+    const Mat& volUnitsData, const CustomHashSet& hashTable)
+{
+    Vec3f normal = Vec3f(0, 0, 0);
+
+    Point3f ptVox = point * voxelSizeInv;
+    Vec3i iptVox(cvFloor(ptVox.x), cvFloor(ptVox.y), cvFloor(ptVox.z));
+
+    // A small hash table to reduce a number of find() calls
+    // -2 and lower means not queried yet
+    // -1 means not found
+    // 0+ means found
+    int iterMap[8];
+    for (int i = 0; i < 8; i++)
+    {
+        iterMap[i] = -2;
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    const Vec3i offsets[] = { { 1,  0,  0}, {-1,  0,  0}, { 0,  1,  0}, // 0-3
+                              { 0, -1,  0}, { 0,  0,  1}, { 0,  0, -1}  // 4-7
+    };
+    const int nVals = 6;
+
+#else
+    const Vec3i offsets[] = { { 0,  0,  0}, { 0,  0,  1}, { 0,  1,  0}, { 0,  1,  1}, //  0-3
+                              { 1,  0,  0}, { 1,  0,  1}, { 1,  1,  0}, { 1,  1,  1}, //  4-7
+                              {-1,  0,  0}, {-1,  0,  1}, {-1,  1,  0}, {-1,  1,  1}, //  8-11
+                              { 2,  0,  0}, { 2,  0,  1}, { 2,  1,  0}, { 2,  1,  1}, // 12-15
+                              { 0, -1,  0}, { 0, -1,  1}, { 1, -1,  0}, { 1, -1,  1}, // 16-19
+                              { 0,  2,  0}, { 0,  2,  1}, { 1,  2,  0}, { 1,  2,  1}, // 20-23
+                              { 0,  0, -1}, { 0,  1, -1}, { 1,  0, -1}, { 1,  1, -1}, // 24-27
+                              { 0,  0,  2}, { 0,  1,  2}, { 1,  0,  2}, { 1,  1,  2}, // 28-31
+    };
+    const int nVals = 32;
+#endif
+
+    float vals[nVals];
+    for (int i = 0; i < nVals; i++)
+    {
+        Vec3i pt = iptVox + offsets[i];
+
+        Vec3i volumeUnitIdx = Vec3i(pt[0] >> volumeUnitDegree, pt[1] >> volumeUnitDegree, pt[2] >> volumeUnitDegree);
+
+        int dictIdx = (volumeUnitIdx[0] & 1) + (volumeUnitIdx[1] & 1) * 2 + (volumeUnitIdx[2] & 1) * 4;
+        auto it = iterMap[dictIdx];
+        if (it < -1)
+        {
+            it = hashTable.find(volumeUnitIdx);
+            iterMap[dictIdx] = it;
+        }
+
+        vals[i] = tsdfToFloat(new_atVolumeUnit(volUnitsData, pt, volumeUnitIdx, it, volumeUnitDegree, volStrides).tsdf);
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    for (int c = 0; c < 3; c++)
+    {
+        normal[c] = vals[c * 2] - vals[c * 2 + 1];
+    }
+#else
+
+    float cxv[8], cyv[8], czv[8];
+
+    // How these numbers were obtained:
+    // 1. Take the basic interpolation sequence:
+    // 000, 001, 010, 011, 100, 101, 110, 111
+    // where each digit corresponds to shift by x, y, z axis respectively.
+    // 2. Add +1 for next or -1 for prev to each coordinate to corresponding axis
+    // 3. Search corresponding values in offsets
+    const int idxxp[8] = { 8,  9, 10, 11,  0,  1,  2,  3 };
+    const int idxxn[8] = { 4,  5,  6,  7, 12, 13, 14, 15 };
+    const int idxyp[8] = { 16, 17,  0,  1, 18, 19,  4,  5 };
+    const int idxyn[8] = { 2,  3, 20, 21,  6,  7, 22, 23 };
+    const int idxzp[8] = { 24,  0, 25,  2, 26,  4, 27,  6 };
+    const int idxzn[8] = { 1, 28,  3, 29,  5, 30,  7, 31 };
+
+#if !USE_INTRINSICS
+    for (int i = 0; i < 8; i++)
+    {
+        cxv[i] = vals[idxxn[i]] - vals[idxxp[i]];
+        cyv[i] = vals[idxyn[i]] - vals[idxyp[i]];
+        czv[i] = vals[idxzn[i]] - vals[idxzp[i]];
+    }
+#else
+
+# if CV_SIMD_WIDTH >= 32
+    v_float32x8 cxp = v_lut(vals, v256_load(idxxp));
+    v_float32x8 cxn = v_lut(vals, v256_load(idxxn));
+
+    v_float32x8 cyp = v_lut(vals, v256_load(idxyp));
+    v_float32x8 cyn = v_lut(vals, v256_load(idxyn));
+
+    v_float32x8 czp = v_lut(vals, v256_load(idxzp));
+    v_float32x8 czn = v_lut(vals, v256_load(idxzn));
+
+    v_float32x8 vcxv = v_sub(cxn, cxp);
+    v_float32x8 vcyv = v_sub(cyn, cyp);
+    v_float32x8 vczv = v_sub(czn, czp);
+
+    v_store(cxv, vcxv);
+    v_store(cyv, vcyv);
+    v_store(czv, vczv);
+# else
+    v_float32x4 cxp0 = v_lut(vals, idxxp + 0); v_float32x4 cxp1 = v_lut(vals, idxxp + 4);
+    v_float32x4 cxn0 = v_lut(vals, idxxn + 0); v_float32x4 cxn1 = v_lut(vals, idxxn + 4);
+
+    v_float32x4 cyp0 = v_lut(vals, idxyp + 0); v_float32x4 cyp1 = v_lut(vals, idxyp + 4);
+    v_float32x4 cyn0 = v_lut(vals, idxyn + 0); v_float32x4 cyn1 = v_lut(vals, idxyn + 4);
+
+    v_float32x4 czp0 = v_lut(vals, idxzp + 0); v_float32x4 czp1 = v_lut(vals, idxzp + 4);
+    v_float32x4 czn0 = v_lut(vals, idxzn + 0); v_float32x4 czn1 = v_lut(vals, idxzn + 4);
+
+    v_float32x4 cxv0 = v_sub(cxn0, cxp0); v_float32x4 cxv1 = v_sub(cxn1, cxp1);
+    v_float32x4 cyv0 = v_sub(cyn0, cyp0); v_float32x4 cyv1 = v_sub(cyn1, cyp1);
+    v_float32x4 czv0 = v_sub(czn0, czp0); v_float32x4 czv1 = v_sub(czn1, czp1);
+
+    v_store(cxv + 0, cxv0); v_store(cxv + 4, cxv1);
+    v_store(cyv + 0, cyv0); v_store(cyv + 4, cyv1);
+    v_store(czv + 0, czv0); v_store(czv + 4, czv1);
+#endif
+
+#endif
+
+    float tx = ptVox.x - iptVox[0];
+    float ty = ptVox.y - iptVox[1];
+    float tz = ptVox.z - iptVox[2];
+
+    normal[0] = interpolate(tx, ty, tz, cxv);
+    normal[1] = interpolate(tx, ty, tz, cyv);
+    normal[2] = interpolate(tx, ty, tz, czv);
+#endif
+
+    float nv = sqrt(normal[0] * normal[0] +
+        normal[1] * normal[1] +
+        normal[2] * normal[2]);
+    return nv < 0.0001f ? nan3 : normal / nv;
+}
+
+#endif
+
+void raycastHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr, const int volumeUnitDegree,
+    InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits, OutputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    Size frameSize(width, height);
+    CV_Assert(frameSize.area() > 0);
+
+    Matx33f mintr(intr.getMat());
+
+    Mat volUnitsData = _volUnitsData.getMat();
+
+    _points.create(frameSize, POINT_TYPE);
+    _normals.create(frameSize, POINT_TYPE);
+
+    Points points1 = _points.getMat();
+    Normals normals1 = _normals.getMat();
+
+    Points& points(points1);
+    Normals& normals(normals1);
+
+    const float truncDist = settings.getTsdfTruncateDistance();
+    const float raycastStepFactor = settings.getRaycastStepFactor();
+    const float tstep = truncDist * raycastStepFactor;
+    const float maxDepth = settings.getMaxDepth();
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const float volumeUnitSize = voxelSize * resolution[0];
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    const Affine3f cam2vol(pose.inv() * Affine3f(cameraPose));
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    const Intr intrinsics(mintr);
+    const Intr::Reprojector reproj(intrinsics.makeReprojector());
+
+    const int nstripes = -1;
+
+    auto _HashRaycastInvoker = [&](const Range& range)
+    {
+        const Point3f cam2volTrans = cam2vol.translation();
+        const Matx33f cam2volRot = cam2vol.rotation();
+        const Matx33f vol2camRot = vol2cam.rotation();
+
+        const float blockSize = volumeUnitSize;
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            ptype* ptsRow = points[y];
+            ptype* nrmRow = normals[y];
+
+            for (int x = 0; x < points.cols; x++)
+            {
+                //! Initialize default value
+                Point3f point = nan3, normal = nan3;
+
+                //! Ray origin and direction in the volume coordinate frame
+                Point3f orig = cam2volTrans;
+                Point3f rayDirV = normalize(Vec3f(cam2volRot * reproj(Point3f(float(x), float(y), 1.f))));
+
+                float tmin = 0;
+                float tmax = maxDepth;
+                float tcurr = tmin;
+
+                cv::Vec3i prevVolumeUnitIdx =
+                    cv::Vec3i(std::numeric_limits<int>::min(), std::numeric_limits<int>::min(),
+                        std::numeric_limits<int>::min());
+
+                float tprev = tcurr;
+                float prevTsdf = truncDist;
+                while (tcurr < tmax)
+                {
+
+                    Point3f currRayPos = orig + tcurr * rayDirV;
+                    cv::Vec3i currVolumeUnitIdx = volumeToVolumeUnitIdx(currRayPos, volumeUnitSize);
+
+                    VolumeUnitIndexes::const_iterator it = volumeUnits.find(currVolumeUnitIdx);
+
+                    float currTsdf = prevTsdf;
+                    int currWeight = 0;
+                    float stepSize = 0.5f * blockSize;
+                    cv::Vec3i volUnitLocalIdx;
+
+
+                    //! The subvolume exists in hashtable
+                    if (it != volumeUnits.end())
+                    {
+                        cv::Point3f currVolUnitPos = volumeUnitIdxToVolume(currVolumeUnitIdx, volumeUnitSize);
+                        volUnitLocalIdx = volumeToVoxelCoord(currRayPos - currVolUnitPos, voxelSizeInv);
+
+                        //! TODO: Figure out voxel interpolation
+                        TsdfVoxel currVoxel = _at(volUnitsData, volUnitLocalIdx, it->second.index, volResolution.x, volDims);
+                        currTsdf = tsdfToFloat(currVoxel.tsdf);
+                        currWeight = currVoxel.weight;
+                        stepSize = tstep;
+                    }
+
+                    //! Surface crossing
+                    if (prevTsdf > 0.f && currTsdf <= 0.f && currWeight > 0)
+                    {
+                        float tInterp = (tcurr * prevTsdf - tprev * currTsdf) / (prevTsdf - currTsdf);
+                        if (!cvIsNaN(tInterp) && !cvIsInf(tInterp))
+                        {
+                            Point3f pv = orig + tInterp * rayDirV;
+                            Point3f nv = getNormalVoxel(pv, voxelSizeInv, volumeUnitDegree, volDims, volUnitsData, volumeUnits);
+
+                            if (!isNaN(nv))
+                            {
+                                normal = vol2camRot * nv;
+                                point = vol2cam * pv;
+                            }
+                        }
+                        break;
+                    }
+                    prevVolumeUnitIdx = currVolumeUnitIdx;
+                    prevTsdf = currTsdf;
+                    tprev = tcurr;
+                    tcurr += stepSize;
+                }
+                ptsRow[x] = toPtype(point);
+                nrmRow[x] = toPtype(normal);
+            }
+        }
+    };
+
+    parallel_for_(Range(0, points.rows), _HashRaycastInvoker, nstripes);
+}
+
+#ifdef HAVE_OPENCL
+
+void ocl_raycastHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr, const int volumeUnitDegree,
+    const CustomHashSet& hashTable, InputArray _volUnitsData, OutputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    Size frameSize(width, height);
+    CV_Assert(frameSize.area() > 0);
+
+    Matx33f mintr(intr.getMat());
+
+    UMat volUnitsData = _volUnitsData.getUMat();
+
+    String errorStr;
+    String name = "raycast";
+    ocl::ProgramSource source = ocl::ptcloud::hash_tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    _points.create(frameSize, CV_32FC4);
+    _normals.create(frameSize, CV_32FC4);
+
+    UMat points = _points.getUMat();
+    UMat normals = _normals.getUMat();
+
+    Intr intrinsics(mintr);
+    Intr::Reprojector r = intrinsics.makeReprojector();
+    Vec2f finv(r.fxinv, r.fyinv), cxy(r.cx, r.cy);
+
+    const float truncDist = settings.getTsdfTruncateDistance();
+    const float raycastStepFactor = settings.getRaycastStepFactor();
+    const float tstep = truncDist * raycastStepFactor;
+    const float maxDepth = settings.getMaxDepth();
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    const Vec4i volStrides;
+    settings.getVolumeStrides(volStrides);
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const float volumeUnitSize = voxelSize * volResolution.x;
+
+    Vec4f boxMin, boxMax(volumeUnitSize - voxelSize,
+                         volumeUnitSize - voxelSize,
+                         volumeUnitSize - voxelSize);
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    const Affine3f cam2vol(pose.inv() * Affine3f(cameraPose));
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    Matx44f cam2volRotGPU = cam2vol.matrix;
+    Matx44f vol2camRotGPU = vol2cam.matrix;
+
+    UMat hashesGpu = Mat(hashTable.hashes, false).getUMat(ACCESS_READ);
+    UMat hashDataGpu = Mat(hashTable.data, false).getUMat(ACCESS_READ);
+
+    k.args(
+        ocl::KernelArg::PtrReadOnly(hashesGpu),
+        ocl::KernelArg::PtrReadOnly(hashDataGpu),
+        ocl::KernelArg::WriteOnlyNoSize(points),
+        ocl::KernelArg::WriteOnlyNoSize(normals),
+        frameSize,
+        ocl::KernelArg::ReadOnly(volUnitsData),
+        cam2volRotGPU,
+        vol2camRotGPU,
+        float(maxDepth),
+        finv.val, cxy.val,
+        boxMin.val, boxMax.val,
+        tstep,
+        voxelSize,
+        voxelSizeInv,
+        volumeUnitSize,
+        truncDist,
+        volumeUnitDegree,
+        volStrides
+    );
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)frameSize.width;
+    globalSize[1] = (size_t)frameSize.height;
+
+    if (!k.run(2, globalSize, NULL, true))
+        throw std::runtime_error("Failed to run kernel");
+
+}
+#endif
+
+
+void fetchNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const int volumeUnitDegree, InputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+
+    if (!_normals.needed())
+        return;
+
+    Points points = _points.getMat();
+    CV_Assert(points.type() == POINT_TYPE);
+
+    _normals.createSameSize(_points, _points.type());
+    Normals normals = _normals.getMat();
+    Mat volUnitsData = _volUnitsData.getMat();
+
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose(_pose);
+
+    auto HashPushNormals = [&](const ptype& point, const int* position) {
+        Affine3f invPose(pose.inv());
+        Point3f p = fromPtype(point);
+        Point3f n = nan3;
+        if (!isNaN(p))
+        {
+            Point3f voxelPoint = invPose * p;
+            n = pose.rotation() * getNormalVoxel(voxelPoint, voxelSizeInv, volumeUnitDegree, volDims, volUnitsData, volumeUnits);
+        }
+        normals(position[0], position[1]) = toPtype(n);
+    };
+    points.forEach(HashPushNormals);
+
+}
+
+#ifdef HAVE_OPENCL
+void ocl_fetchNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const int volumeUnitDegree, InputArray _volUnitsData, InputArray _volUnitsDataCopy,
+    const CustomHashSet& hashTable, InputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    UMat volUnitsData = _volUnitsData.getUMat();
+    Mat volUnitsDataCopy = _volUnitsDataCopy.getMat();
+    if (!_normals.needed())
+        return;
+
+    //TODO: remove it when it works w/o CPU code
+    volUnitsData.copyTo(volUnitsDataCopy);
+
+    Points points = _points.getMat();
+    CV_Assert(points.type() == POINT_TYPE);
+    _normals.createSameSize(_points, _points.type());
+    Normals normals = _normals.getMat();
+
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+
+    auto HashPushNormals = [&](const ptype& point, const int* position) {
+        Affine3f invPose(pose.inv());
+        Point3f p = fromPtype(point);
+        Point3f n = nan3;
+        if (!isNaN(p))
+        {
+            Point3f voxelPoint = invPose * p;
+            n = pose.rotation() * ocl_getNormalVoxel(voxelPoint, voxelSizeInv, volumeUnitDegree, volDims, volUnitsDataCopy, hashTable);
+        }
+        normals(position[0], position[1]) = toPtype(n);
+    };
+    points.forEach(HashPushNormals);
+
+}
+#endif
+
+
+void fetchPointsNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const int volumeUnitDegree, OutputArray _points, OutputArray _normals)
+{
+    //std::cout << "fetchNormalsFromHashTsdfVolumeUnit()" << std::endl;
+    CV_TRACE_FUNCTION();
+
+    if (!_points.needed())
+        return;
+
+    std::vector<std::vector<ptype>> pVecs, nVecs;
+    Mat volUnitsData = _volUnitsData.getMat();
+
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const int volumeUnitResolution = volResolution.x;
+    const float volumeUnitSize = voxelSize * resolution[0];
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+
+    Matx44f mpose;
+    settings.getVolumePose(mpose);
+    const Affine3f pose(mpose);
+
+    std::vector<Vec3i> totalVolUnits;
+    for (const auto& keyvalue : volumeUnits)
+    {
+        totalVolUnits.push_back(keyvalue.first);
+    }
+    Range fetchRange(0, (int)totalVolUnits.size());
+    const int nstripes = -1;
+
+    bool needNormals(_normals.needed());
+    Mutex mutex;
+
+    //TODO: this is incorrect; a 0-surface should be captured instead of all non-zero voxels
+    auto HashFetchPointsNormalsInvoker = [&](const Range& range)
+    {
+        std::vector<ptype> points, normals;
+        for (int i = range.start; i < range.end; i++)
+        {
+            cv::Vec3i tsdf_idx = totalVolUnits[i];
+
+            VolumeUnitIndexes::const_iterator it = volumeUnits.find(tsdf_idx);
+            Point3f base_point = volumeUnitIdxToVolume(tsdf_idx, volumeUnitSize);
+            if (it != volumeUnits.end())
+            {
+                std::vector<ptype> localPoints;
+                std::vector<ptype> localNormals;
+                for (int x = 0; x < volumeUnitResolution; x++)
+                    for (int y = 0; y < volumeUnitResolution; y++)
+                        for (int z = 0; z < volumeUnitResolution; z++)
+                        {
+                            cv::Vec3i voxelIdx(x, y, z);
+                            TsdfVoxel voxel = _at(volUnitsData, voxelIdx, it->second.index, volResolution.x, volDims);
+
+                            // floatToTsdf(1.0) == -128
+                            if (voxel.tsdf != -128 && voxel.weight != 0)
+                            {
+                                Point3f point = base_point + voxelCoordToVolume(voxelIdx, voxelSize);
+                                localPoints.push_back(toPtype(pose * point));
+                                if (needNormals)
+                                {
+                                    Point3f normal = getNormalVoxel(point, voxelSizeInv, volumeUnitDegree, volDims, volUnitsData, volumeUnits);
+                                    localNormals.push_back(toPtype(pose.rotation() * normal));
+                                }
+                            }
+                        }
+
+                AutoLock al(mutex);
+                pVecs.push_back(localPoints);
+                nVecs.push_back(localNormals);
+            }
+        }
+    };
+
+    parallel_for_(fetchRange, HashFetchPointsNormalsInvoker, nstripes);
+
+    std::vector<ptype> points, normals;
+    for (size_t i = 0; i < pVecs.size(); i++)
+    {
+        points.insert(points.end(), pVecs[i].begin(), pVecs[i].end());
+        normals.insert(normals.end(), nVecs[i].begin(), nVecs[i].end());
+    }
+
+    _points.create((int)points.size(), 1, POINT_TYPE);
+    if (!points.empty())
+        Mat((int)points.size(), 1, POINT_TYPE, &points[0]).copyTo(_points.getMat());
+
+    if (_normals.needed())
+    {
+        _normals.create((int)normals.size(), 1, POINT_TYPE);
+        if (!normals.empty())
+            Mat((int)normals.size(), 1, POINT_TYPE, &normals[0]).copyTo(_normals.getMat());
+    }
+}
+
+#ifdef HAVE_OPENCL
+
+inline TsdfVoxel new_at(
+    Mat& volUnitsDataCopy, const cv::Vec3i& volumeIdx, int indx,
+    const int volumeUnitResolution, const Vec4i volStrides)
+{
+    //! Out of bounds
+    if ((volumeIdx[0] >= volumeUnitResolution || volumeIdx[0] < 0) ||
+        (volumeIdx[1] >= volumeUnitResolution || volumeIdx[1] < 0) ||
+        (volumeIdx[2] >= volumeUnitResolution || volumeIdx[2] < 0))
+    {
+        return TsdfVoxel(floatToTsdf(1.0f), 0);
+    }
+
+    const TsdfVoxel* volData = volUnitsDataCopy.ptr<TsdfVoxel>(indx);
+    int coordBase =
+        volumeIdx[0] * volStrides[0] +
+        volumeIdx[1] * volStrides[1] +
+        volumeIdx[2] * volStrides[2];
+    return volData[coordBase];
+}
+
+
+void ocl_fetchPointsNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const int volumeUnitDegree, InputArray _volUnitsData, InputArray _volUnitsDataCopy,
+    const CustomHashSet& hashTable, OutputArray _points, OutputArray _normals)
+{
+
+    CV_TRACE_FUNCTION();
+
+    if (!_points.needed())
+        return;
+
+    UMat volUnitsData = _volUnitsData.getUMat();
+    Mat volUnitsDataCopy = _volUnitsDataCopy.getMat();
+    //TODO: remove it when it works w/o CPU code
+    volUnitsData.copyTo(volUnitsDataCopy);
+    //TODO: remove it when it works w/o CPU code
+    //TODO: enable it when it's on GPU
+    //UMat hashDataGpu(hashMap.capacity, 1, CV_32SC4);
+    //Mat(hashMap.data, false).copyTo(hashDataGpu);
+
+    std::vector<std::vector<ptype>> pVecs, nVecs;
+
+    const float voxelSize = settings.getVoxelSize();
+    const float voxelSizeInv = 1.f / voxelSize;
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const int volumeUnitResolution = volResolution.x;
+    const float volumeUnitSize = voxelSize * resolution[0];
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+
+    Matx44f mpose;
+    settings.getVolumePose(mpose);
+    const Affine3f pose(mpose);
+
+    Range _fetchRange(0, hashTable.last);
+
+    const int nstripes = -1;
+
+    bool needNormals(_normals.needed());
+    Mutex mutex;
+
+    //TODO: this is incorrect; a 0-surface should be captured instead of all non-zero voxels
+    auto _HashFetchPointsNormalsInvoker = [&](const Range& range)
+    {
+        std::vector<ptype> points, normals;
+        for (int row = range.start; row < range.end; row++)
+        {
+            cv::Vec4i idx4 = hashTable.data[row];
+            cv::Vec3i idx(idx4[0], idx4[1], idx4[2]);
+
+            Point3f base_point = volumeUnitIdxToVolume(idx, volumeUnitSize);
+
+            std::vector<ptype> localPoints;
+            std::vector<ptype> localNormals;
+            for (int x = 0; x < volumeUnitResolution; x++)
+                for (int y = 0; y < volumeUnitResolution; y++)
+                    for (int z = 0; z < volumeUnitResolution; z++)
+                    {
+                        cv::Vec3i voxelIdx(x, y, z);
+                        TsdfVoxel voxel = new_at(volUnitsDataCopy, voxelIdx, row, volumeUnitResolution, volDims);
+
+                        // floatToTsdf(1.0) == -128
+                        if (voxel.tsdf != -128 && voxel.weight != 0)
+                        {
+                            Point3f point = base_point + voxelCoordToVolume(voxelIdx, voxelSize);
+
+                            localPoints.push_back(toPtype(pose * point));
+                            if (needNormals)
+                            {
+                                Point3f normal = ocl_getNormalVoxel(point, voxelSizeInv, volumeUnitDegree, volDims, volUnitsDataCopy, hashTable);
+                                localNormals.push_back(toPtype(pose.rotation() * normal));
+                            }
+                        }
+                    }
+
+            AutoLock al(mutex);
+            pVecs.push_back(localPoints);
+            nVecs.push_back(localNormals);
+        }
+    };
+
+    parallel_for_(_fetchRange, _HashFetchPointsNormalsInvoker, nstripes);
+
+    std::vector<ptype> points, normals;
+    for (size_t i = 0; i < pVecs.size(); i++)
+    {
+        points.insert(points.end(), pVecs[i].begin(), pVecs[i].end());
+        normals.insert(normals.end(), nVecs[i].begin(), nVecs[i].end());
+    }
+
+    _points.create((int)points.size(), 1, POINT_TYPE);
+    if (!points.empty())
+        Mat((int)points.size(), 1, POINT_TYPE, &points[0]).copyTo(_points.getMat());
+
+    if (_normals.needed())
+    {
+        _normals.create((int)normals.size(), 1, POINT_TYPE);
+        if (!normals.empty())
+            Mat((int)normals.size(), 1, POINT_TYPE, &normals[0]).copyTo(_normals.getMat());
+    }
+
+}
+#endif
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.hpp b/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.hpp
new file mode 100644
index 0000000..52c4267
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/hash_tsdf_functions.hpp
@@ -0,0 +1,324 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#ifndef OPENCV_3D_HASH_TSDF_FUNCTIONS_HPP
+#define OPENCV_3D_HASH_TSDF_FUNCTIONS_HPP
+
+#include <unordered_set>
+
+#include "utils.hpp"
+#include "tsdf_functions.hpp"
+
+#define USE_INTERPOLATION_IN_GETNORMAL 1
+#define VOLUMES_SIZE 8192
+
+namespace cv
+{
+
+//! Spatial hashing
+struct tsdf_hash
+{
+    size_t operator()(const Vec3i& x) const noexcept
+    {
+        size_t seed = 0;
+        constexpr uint32_t GOLDEN_RATIO = 0x9e3779b9;
+        for (uint16_t i = 0; i < 3; i++)
+        {
+            seed ^= std::hash<int>()(x[i]) + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+        }
+        return seed;
+    }
+};
+
+struct VolumeUnit
+{
+    cv::Vec3i coord;
+    int index;
+    cv::Matx44f pose;
+    int lastVisibleIndex = 0;
+    bool isActive;
+};
+
+class CustomHashSet
+{
+public:
+    static const int hashDivisor = 32768;
+    static const int startCapacity = 2048;
+
+    std::vector<int> hashes;
+    // 0-3 for key, 4th for internal use
+    // don't keep keep value
+    std::vector<Vec4i> data;
+    int capacity;
+    int last;
+
+    CustomHashSet()
+    {
+        hashes.resize(hashDivisor);
+        for (int i = 0; i < hashDivisor; i++)
+            hashes[i] = -1;
+        capacity = startCapacity;
+
+        data.resize(capacity);
+        for (int i = 0; i < capacity; i++)
+            data[i] = { 0, 0, 0, -1 };
+
+        last = 0;
+    }
+
+    ~CustomHashSet() { }
+
+    inline size_t calc_hash(Vec3i x) const
+    {
+        uint32_t seed = 0;
+        constexpr uint32_t GOLDEN_RATIO = 0x9e3779b9;
+        for (int i = 0; i < 3; i++)
+        {
+            seed ^= x[i] + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+        }
+        return seed;
+    }
+
+    // should work on existing elements too
+    // 0 - need resize
+    // 1 - idx is inserted
+    // 2 - idx already exists
+    int insert(Vec3i idx)
+    {
+        if (last < capacity)
+        {
+            int hash = int(calc_hash(idx) % hashDivisor);
+            int place = hashes[hash];
+            if (place >= 0)
+            {
+                int oldPlace = place;
+                while (place >= 0)
+                {
+                    if (data[place][0] == idx[0] &&
+                        data[place][1] == idx[1] &&
+                        data[place][2] == idx[2])
+                        return 2;
+                    else
+                    {
+                        oldPlace = place;
+                        place = data[place][3];
+                        //std::cout << "place=" << place << std::endl;
+                    }
+                }
+
+                // found, create here
+                data[oldPlace][3] = last;
+            }
+            else
+            {
+                // insert at last
+                hashes[hash] = last;
+            }
+
+            data[last][0] = idx[0];
+            data[last][1] = idx[1];
+            data[last][2] = idx[2];
+            data[last][3] = -1;
+            last++;
+
+            return 1;
+        }
+        else
+            return 0;
+    }
+
+    int find(Vec3i idx) const
+    {
+        int hash = int(calc_hash(idx) % hashDivisor);
+        int place = hashes[hash];
+        // search a place
+        while (place >= 0)
+        {
+            if (data[place][0] == idx[0] &&
+                data[place][1] == idx[1] &&
+                data[place][2] == idx[2])
+                break;
+            else
+            {
+                place = data[place][3];
+            }
+        }
+
+        return place;
+    }
+};
+
+// TODO: remove this structure as soon as HashTSDFGPU data is completely on GPU;
+// until then CustomHashTable can be replaced by this one if needed
+
+const int NAN_ELEMENT = -2147483647;
+
+struct Volume_NODE
+{
+    Vec4i idx = Vec4i(NAN_ELEMENT);
+    int32_t row = -1;
+    int32_t nextVolumeRow = -1;
+    int32_t dummy = 0;
+    int32_t dummy2 = 0;
+};
+
+const int _hash_divisor = 32768;
+const int _list_size = 4;
+
+class VolumesTable
+{
+public:
+    const int hash_divisor = _hash_divisor;
+    const int list_size = _list_size;
+    const int32_t free_row = -1;
+    const int32_t free_isActive = 0;
+
+    const cv::Vec4i nan4 = cv::Vec4i(NAN_ELEMENT);
+
+    int bufferNums;
+    cv::Mat volumes;
+
+    VolumesTable() : bufferNums(1)
+    {
+        this->volumes = cv::Mat(hash_divisor * list_size, 1, rawType<Volume_NODE>());
+        for (int i = 0; i < volumes.size().height; i++)
+        {
+            Volume_NODE* v = volumes.ptr<Volume_NODE>(i);
+            v->idx = nan4;
+            v->row = -1;
+            v->nextVolumeRow = -1;
+        }
+    }
+    const VolumesTable& operator=(const VolumesTable& vt)
+    {
+        this->volumes = vt.volumes;
+        this->bufferNums = vt.bufferNums;
+        return *this;
+    }
+    ~VolumesTable() {};
+
+    bool insert(Vec3i idx, int row)
+    {
+        CV_Assert(row >= 0);
+
+        int bufferNum = 0;
+        int hash = int(calc_hash(idx) % hash_divisor);
+        int start = getPos(idx, bufferNum);
+        int i = start;
+
+        while (i >= 0)
+        {
+            Volume_NODE* v = volumes.ptr<Volume_NODE>(i);
+
+            if (v->idx[0] == NAN_ELEMENT)
+            {
+                Vec4i idx4(idx[0], idx[1], idx[2], 0);
+
+                bool extend = false;
+                if (i != start && i % list_size == 0)
+                {
+                    if (bufferNum >= bufferNums - 1)
+                    {
+                        extend = true;
+                        volumes.resize(hash_divisor * bufferNums);
+                        bufferNums++;
+                    }
+                    bufferNum++;
+                    v->nextVolumeRow = (bufferNum * hash_divisor + hash) * list_size;
+                }
+                else
+                {
+                    v->nextVolumeRow = i + 1;
+                }
+
+                v->idx = idx4;
+                v->row = row;
+
+                return extend;
+            }
+
+            i = v->nextVolumeRow;
+        }
+        return false;
+    }
+    int findRow(Vec3i idx) const
+    {
+        int bufferNum = 0;
+        int i = getPos(idx, bufferNum);
+
+        while (i >= 0)
+        {
+            const Volume_NODE* v = volumes.ptr<Volume_NODE>(i);
+
+            if (v->idx == Vec4i(idx[0], idx[1], idx[2], 0))
+                return v->row;
+            else
+                i = v->nextVolumeRow;
+        }
+
+        return -1;
+    }
+
+    inline int getPos(Vec3i idx, int bufferNum) const
+    {
+        int hash = int(calc_hash(idx) % hash_divisor);
+        return (bufferNum * hash_divisor + hash) * list_size;
+    }
+
+    inline size_t calc_hash(Vec3i x) const
+    {
+        uint32_t seed = 0;
+        constexpr uint32_t GOLDEN_RATIO = 0x9e3779b9;
+        for (int i = 0; i < 3; i++)
+        {
+            seed ^= x[i] + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+        }
+        return seed;
+    }
+};
+
+int calcVolumeUnitDegree(Point3i volumeResolution);
+
+typedef std::unordered_map<cv::Vec3i, VolumeUnit, tsdf_hash> VolumeUnitIndexes;
+
+void integrateHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int& lastVolIndex, const int frameId, const int volumeUnitDegree, bool enableGrowth,
+    InputArray _depth, InputArray _pixNorms, InputOutputArray _volUnitsData, VolumeUnitIndexes& volumeUnits);
+
+void raycastHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr, const int volumeUnitDegree,
+    InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits, OutputArray _points, OutputArray _normals);
+
+void fetchNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const int volumeUnitDegree, InputArray _points, OutputArray _normals);
+
+void fetchPointsNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volUnitsData, const VolumeUnitIndexes& volumeUnits,
+    const int volumeUnitDegree, OutputArray _points, OutputArray _normals);
+
+#ifdef HAVE_OPENCL
+void ocl_integrateHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int& lastVolIndex, const int frameId, int& bufferSizeDegree, const int volumeUnitDegree, bool enableGrowth,
+    InputArray _depth, InputArray _pixNorms, InputArray _lastVisibleIndices, InputOutputArray _volUnitsDataCopy, InputOutputArray _volUnitsData, CustomHashSet& hashTable, InputArray _isActiveFlags);
+
+void ocl_raycastHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr, const int volumeUnitDegree,
+    const CustomHashSet& hashTable, InputArray _volUnitsData, OutputArray _points, OutputArray _normals);
+
+void ocl_fetchNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const int volumeUnitDegree, InputArray _volUnitsData, InputArray _volUnitsDataCopy,
+    const CustomHashSet& hashTable, InputArray _points, OutputArray _normals);
+
+void ocl_fetchPointsNormalsFromHashTsdfVolumeUnit(
+    const VolumeSettings& settings, const int volumeUnitDegree, InputArray _volUnitsData, InputArray _volUnitsDataCopy,
+    const CustomHashSet& hashTable, OutputArray _points, OutputArray _normals);
+#endif
+
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/io_base.cpp b/upstream/opencv/modules/ptcloud/src/io_base.cpp
new file mode 100644
index 0000000..1791ad0
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_base.cpp
@@ -0,0 +1,35 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "io_base.hpp"
+
+namespace cv {
+
+void BasePointCloudDecoder::setSource(const std::string& filename) noexcept
+{
+    m_filename = filename;
+}
+
+void BasePointCloudDecoder::readData(std::vector<Point3f> &points, std::vector<Point3f> &normals, std::vector<Point3f> &rgb)
+{
+    std::vector<std::vector<int32_t>> indices;
+    std::vector<Point3f> texCoords;
+    int nTexCoords;
+    readData(points, normals, rgb, texCoords, nTexCoords, indices, READ_AS_IS_FLAG);
+}
+
+void BasePointCloudEncoder::setDestination(const std::string& filename) noexcept
+{
+    m_filename = filename;
+}
+
+void BasePointCloudEncoder::writeData(const std::vector<Point3f> &points, const std::vector<Point3f> &normals, const std::vector<Point3f> &rgb)
+{
+    std::vector<std::vector<int32_t>> indices;
+    std::vector<Point3f> texCoords;
+    writeData(points, normals, rgb, texCoords, 0, indices);
+}
+
+} /* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/io_base.hpp b/upstream/opencv/modules/ptcloud/src/io_base.hpp
new file mode 100644
index 0000000..30afd7d
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_base.hpp
@@ -0,0 +1,59 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _CODERS_BASE_H_
+#define _CODERS_BASE_H_
+
+#include <vector>
+#include <memory>
+#include <cstdint>
+
+#include <opencv2/core.hpp>
+
+namespace cv {
+
+class BasePointCloudDecoder;
+class BasePointCloudEncoder;
+using PointCloudDecoder = std::unique_ptr<BasePointCloudDecoder>;
+using PointCloudEncoder = std::unique_ptr<BasePointCloudEncoder>;
+
+// for OBJ files: to read vertices, normals and texture coords as they are given in the file
+// or duplicate them according to faces
+const int READ_AS_IS_FLAG = 1;
+
+///////////////////////////////// base class for decoders ////////////////////////
+class BasePointCloudDecoder
+{
+public:
+    virtual ~BasePointCloudDecoder() = default;
+
+    virtual void setSource(const std::string& filename) noexcept;
+    virtual void readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb);
+    virtual void readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                          std::vector<Point3f>& texCoords, int& nTexCoords,
+                          std::vector<std::vector<int32_t>>& indices, int flags) = 0;
+
+protected:
+    std::string m_filename;
+};
+
+///////////////////////////////// base class for encoders ////////////////////////
+class BasePointCloudEncoder
+{
+public:
+    virtual ~BasePointCloudEncoder() = default;
+
+    virtual void setDestination(const std::string& filename) noexcept;
+    virtual void writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb);
+    virtual void writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb,
+                           const std::vector<Point3f>& texCoords, int nTexCoords,
+                           const std::vector<std::vector<int32_t>>& indices) = 0;
+
+protected:
+    std::string m_filename;
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/io_obj.cpp b/upstream/opencv/modules/ptcloud/src/io_obj.cpp
new file mode 100644
index 0000000..f95d265
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_obj.cpp
@@ -0,0 +1,293 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "io_obj.hpp"
+#include <fstream>
+#include <opencv2/core/utils/logger.hpp>
+#include "utils.hpp"
+
+namespace cv {
+
+std::unordered_set<std::string> ObjDecoder::m_unsupportedKeys;
+
+void ObjDecoder::readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb)
+{
+    std::vector<Point3f> texCoords;
+    int nTexCoords;
+    std::vector<std::vector<int32_t>> indices;
+    this->readData(points, normals, rgb, texCoords, nTexCoords, indices, READ_AS_IS_FLAG);
+}
+
+void ObjDecoder::readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                          std::vector<Point3f>& texCoords, int& nTexCoords,
+                          std::vector<std::vector<int32_t>>& indices, int flags)
+{
+    std::vector<Point3f> ptsList, nrmList, texCoordList, rgbList;
+    std::vector<std::vector<int32_t>> idxList, texIdxList, normalIdxList;
+
+    nTexCoords = 0;
+
+    bool duplicateVertices = false;
+
+    std::ifstream file(m_filename, std::ios::binary);
+    if (!file)
+    {
+        CV_LOG_ERROR(NULL, "Impossible to open the file: " << m_filename);
+        return;
+    }
+    std::string s;
+
+    while (!file.eof())
+    {
+        std::getline(file, s);
+        // "\r" symbols are not trimmed by default
+        s = trimSpaces(s);
+        if (s.empty())
+            continue;
+        std::stringstream ss(s);
+        std::string key;
+        ss >> key;
+
+        if (key == "#")
+            continue;
+        else if (key == "v")
+        {
+            // (x, y, z, [w], [r, g, b])
+            auto splitArr = split(s, ' ');
+            if (splitArr.size() <= 3)
+            {
+                CV_LOG_ERROR(NULL, "Vertex should have at least 3 coordinate values.");
+                return;
+            }
+            Point3f vertex;
+            ss >> vertex.x >> vertex.y >> vertex.z;
+            ptsList.push_back(vertex);
+            if (splitArr.size() == 5 || splitArr.size() == 8)
+            {
+                float w;
+                ss >> w;
+                CV_UNUSED(w);
+            }
+            if (splitArr.size() >= 7)
+            {
+                Point3f color;
+                if (ss.rdbuf()->in_avail() != 0)
+                {
+                    ss >> color.x >> color.y >> color.z;
+                    rgbList.push_back(color);
+                }
+            }
+        }
+        else if (key == "vn")
+        {
+            Point3f normal;
+            ss >> normal.x >> normal.y >> normal.z;
+            nrmList.push_back(normal);
+        }
+        else if (key == "f")
+        {
+            // format: "f v0 / t0 / n0 v1 / t1 / n1 v2/t2/n2 ..."
+            std::vector<int> vertexInd, normInd, texInd;
+            vertexInd.reserve(3); normInd.reserve(3); texInd.reserve(3);
+            auto tokens = split(s, ' ');
+            for (size_t i = 1; i < tokens.size(); i++)
+            {
+                auto vertexinfo = split(tokens[i], '/');
+                std::array<int, 3> idx = { -1, -1, -1 };
+                for (int j = 0; j < (int)vertexinfo.size(); j++)
+                {
+                    std::string sj = vertexinfo[j];
+                    // trimming spaces; as a result s can become empty - this is not an error
+                    auto si = std::find_if(sj.begin(),  sj.end(),  [](char c) { return (c >= '0' && c <= '9'); });
+                    auto ei = std::find_if(sj.rbegin(), sj.rend(), [](char c) { return (c >= '0' && c <= '9'); });
+                    if (si != sj.end() && ei != sj.rend())
+                    {
+                        auto first = std::distance(si, sj.begin());
+                        auto last  = std::distance(ei, sj.rend());
+                        sj = sj.substr(first, last - first + 1);
+                        try
+                        {
+                            idx[j] = std::stoi(sj);
+                        }
+                        // std::invalid_exception, std::out_of_range
+                        catch(const std::exception&)
+                        {
+                            CV_LOG_ERROR(NULL, "Failed to parse face index: " + sj);
+                            return;
+                        }
+                    }
+                }
+                int vertexIndex   = idx[0];
+                int texCoordIndex = idx[1];
+                int normalIndex   = idx[2];
+
+                if (vertexIndex <= 0)
+                {
+                    CV_LOG_ERROR(NULL, "Vertex index is not present or incorrect");
+                    return;
+                }
+
+                if ((vertexIndex != texCoordIndex && texCoordIndex >= 0) ||
+                    (vertexIndex != normalIndex   && normalIndex   >= 0))
+                {
+                    duplicateVertices = !(flags & READ_AS_IS_FLAG);
+                }
+
+                vertexInd.push_back(vertexIndex - 1);
+                normInd.push_back(normalIndex - 1);
+                texInd.push_back(texCoordIndex - 1);
+            }
+            idxList.push_back(vertexInd);
+            texIdxList.push_back(texInd);
+            normalIdxList.push_back(normInd);
+        }
+        else if (key == "vt")
+        {
+            // (u, [v, [w]])
+            auto splitArr = split(s, ' ');
+            int ncoords = (int)splitArr.size() - 1;
+            if (!nTexCoords)
+            {
+                nTexCoords = ncoords;
+                if (nTexCoords < 1 || nTexCoords > 3)
+                {
+                    CV_LOG_ERROR(NULL, "The amount of texture coordinates should be between 1 and 3");
+                    return;
+                }
+            }
+
+            if (ncoords != nTexCoords)
+            {
+                CV_LOG_ERROR(NULL, "All points should have the same number of texture coordinates");
+                return;
+            }
+
+            Vec3f tc;
+            for (int i = 0; i < nTexCoords; i++)
+            {
+                ss >> tc[i];
+            }
+            texCoordList.push_back(tc);
+        }
+        else
+        {
+            if (m_unsupportedKeys.find(key) == m_unsupportedKeys.end()) {
+                m_unsupportedKeys.insert(key);
+                CV_LOG_WARNING(NULL, "Key " << key << " not supported");
+            }
+        }
+    }
+
+    if (duplicateVertices)
+    {
+        points.clear();
+        normals.clear();
+        rgb.clear();
+        texCoords.clear();
+        indices.clear();
+
+        for (int tri = 0; tri < (int)idxList.size(); tri++)
+        {
+            auto vi = idxList[tri];
+            auto ti = texIdxList[tri];
+            auto ni = normalIdxList[tri];
+
+            std::vector<int32_t> newvi;
+            newvi.reserve(3);
+            for (int i = 0; i < (int)vi.size(); i++)
+            {
+                newvi.push_back((int)points.size());
+                points.push_back(ptsList.at(vi[i]));
+                if (!rgbList.empty())
+                {
+                    rgb.push_back(rgbList.at(vi[i]));
+                }
+
+                texCoords.push_back(texCoordList.at(ti[i]));
+                normals.push_back(nrmList.at(ni[i]));
+            }
+
+            indices.push_back(newvi);
+        }
+    }
+    else
+    {
+        points    = std::move(ptsList);
+        normals   = std::move(nrmList);
+        rgb       = std::move(rgbList);
+        texCoords = std::move(texCoordList);
+        indices   = std::move(idxList);
+    }
+
+    file.close();
+}
+
+void ObjEncoder::writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb,
+                           const std::vector<Point3f>& texCoords, int nTexCoords,
+                           const std::vector<std::vector<int32_t>>& indices)
+{
+    std::ofstream file(m_filename, std::ios::binary);
+    if (!file) {
+        CV_LOG_ERROR(NULL, "Impossible to open the file: " << m_filename);
+        return;
+    }
+
+    if (!rgb.empty() && rgb.size() != points.size()) {
+        CV_LOG_ERROR(NULL, "Vertices and Colors have different size.");
+        return;
+    }
+
+    if (texCoords.empty() && nTexCoords > 0)
+    {
+        CV_LOG_ERROR(NULL, "No texture coordinates provided while having nTexCoord > 0");
+        return;
+    }
+
+    file << "# OBJ file writer" << std::endl;
+    file << "o Point_Cloud" << std::endl;
+
+    for (size_t i = 0; i < points.size(); ++i)
+    {
+        file << "v " << points[i].x << " " << points[i].y << " " << points[i].z;
+        if (!rgb.empty())
+        {
+            file << " " << rgb[i].x << " " << rgb[i].y  << " " << rgb[i].z;
+        }
+        file << std::endl;
+    }
+
+    for (const auto& normal : normals)
+    {
+        file << "vn " << normal.x << " " << normal.y << " " << normal.z << std::endl;
+    }
+
+    for (const auto& tc : texCoords)
+    {
+        file << "vt " << tc.x;
+        if (nTexCoords > 1)
+        {
+            file << " " << tc.y;
+        }
+        if (nTexCoords > 2)
+        {
+            file << " " << tc.z;
+        }
+        file << std::endl;
+    }
+
+    for (const auto& faceIndices : indices)
+    {
+        file << "f ";
+        for (const auto& index : faceIndices)
+        {
+            file << index + 1 << " ";
+        }
+        file << std::endl;
+    }
+
+    file.close();
+}
+
+} /* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/io_obj.hpp b/upstream/opencv/modules/ptcloud/src/io_obj.hpp
new file mode 100644
index 0000000..4f0572c
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_obj.hpp
@@ -0,0 +1,36 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _CODERS_OBJ_H_
+#define _CODERS_OBJ_H_
+
+#include "io_base.hpp"
+#include <unordered_set>
+
+namespace cv {
+
+class ObjDecoder CV_FINAL : public BasePointCloudDecoder
+{
+public:
+    void readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb) CV_OVERRIDE;
+    void readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                  std::vector<Point3f>& texCoords, int& nTexCoords,
+                  std::vector<std::vector<int32_t>>& indices, int flags) CV_OVERRIDE;
+
+protected:
+    static std::unordered_set<std::string> m_unsupportedKeys;
+};
+
+class ObjEncoder CV_FINAL : public BasePointCloudEncoder
+{
+public:
+    void writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb,
+                   const std::vector<Point3f>& texCoords, int nTexCoords,
+                   const std::vector<std::vector<int32_t>>& indices) CV_OVERRIDE;
+
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/io_ply.cpp b/upstream/opencv/modules/ptcloud/src/io_ply.cpp
new file mode 100644
index 0000000..9652bda
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_ply.cpp
@@ -0,0 +1,682 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+#include "io_ply.hpp"
+#include "utils.hpp"
+#include <opencv2/core/utils/logger.hpp>
+#include <fstream>
+#include <string>
+#include <iomanip>
+#include <cstddef>
+
+namespace cv {
+
+static const std::set<std::string> colorKeys = { "red", "diffuse_red", "green", "diffuse_green", "blue", "diffuse_blue" };
+
+void PlyDecoder::readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                          std::vector<Point3f>& texCoords, int& nTexCoords,
+                          std::vector<std::vector<int32_t>>& indices, int /*flags*/)
+{
+    points.clear();
+    normals.clear();
+    rgb.clear();
+    texCoords.clear();
+    indices.clear();
+    nTexCoords = 0;
+
+    std::ifstream file(m_filename, std::ios::binary);
+    if (parseHeader(file, nTexCoords))
+    {
+        parseBody(file, points, normals, rgb, texCoords, indices);
+    }
+}
+
+
+bool PlyDecoder::parseHeader(std::ifstream &file, int& nTexCoords)
+{
+    std::string s;
+    std::getline(file, s);
+    if (trimSpaces(s) != "ply")
+    {
+        CV_LOG_ERROR(NULL, "Provided file is not in PLY format");
+        return false;
+    }
+    std::getline(file, s);
+    auto splitArr = split(s, ' ');
+    // "\r" symbols are not trimmed by default
+    for (auto& e : splitArr)
+    {
+        e = trimSpaces(e);
+    }
+    if (splitArr[0] != "format")
+    {
+        CV_LOG_ERROR(NULL, "Provided file doesn't have format");
+        return false;
+    }
+    if (splitArr[1] == "ascii")
+    {
+        m_inputDataFormat = DataFormat::ASCII;
+    }
+    else if (splitArr[1] == "binary_little_endian")
+    {
+        m_inputDataFormat = DataFormat::BinaryLittleEndian;
+    }
+    else if (splitArr[1] == "binary_big_endian")
+    {
+        m_inputDataFormat = DataFormat::BinaryBigEndian;
+    }
+    else
+    {
+        CV_LOG_ERROR(NULL, "Provided PLY file format is not supported");
+        return false;
+    }
+
+    const std::map<std::string, int> dataTypes =
+    {
+        { "char",   CV_8S  }, { "int8",    CV_8S  },
+        { "uchar",  CV_8U  }, { "uint8",   CV_8U  },
+        { "short",  CV_16S }, { "int16",   CV_16S },
+        { "ushort", CV_16U }, { "uint16",  CV_16U },
+        { "int",    CV_32S }, { "int32",   CV_32S },
+        { "uint",   CV_32U }, { "uint32",  CV_32U },
+        { "float",  CV_32F }, { "float32", CV_32F },
+        { "double", CV_64F }, { "float64", CV_64F },
+    };
+
+    enum ReadElement
+    {
+        READ_OTHER  = 0,
+        READ_VERTEX = 1,
+        READ_FACE   = 2
+    };
+    ReadElement elemRead = READ_OTHER;
+    m_vertexDescription = ElementDescription();
+    m_faceDescription = ElementDescription();
+    while (std::getline(file, s))
+    {
+        if (startsWith(s, "element"))
+        {
+            std::vector<std::string> splitArrElem = split(s, ' ');
+            // "\r" symbols are not trimmed by default
+            for (auto& e : splitArrElem)
+            {
+                e = trimSpaces(e);
+            }
+            std::string elemName = splitArrElem.at(1);
+            if (elemName == "vertex")
+            {
+                elemRead = READ_VERTEX;
+                if(splitArrElem.size() != 3)
+                {
+                    CV_LOG_ERROR(NULL, "Vertex element description has " << splitArrElem.size()
+                                 << " words instead of 3");
+                    return false;
+                }
+                std::istringstream iss(splitArrElem[2]);
+                iss >> m_vertexDescription.amount;
+            }
+            else if (elemName == "face")
+            {
+                elemRead = READ_FACE;
+                if(splitArrElem.size() != 3)
+                {
+                    CV_LOG_ERROR(NULL, "Face element description has " << splitArrElem.size()
+                                 << " words instead of 3");
+                    return false;
+                }
+                std::istringstream iss(splitArrElem[2]);
+                iss >> m_faceDescription.amount;
+            }
+            else
+            {
+                elemRead = READ_OTHER;
+            }
+            continue;
+        }
+        if (startsWith(s, "property"))
+        {
+            Property property;
+            std::string elName = (elemRead == READ_VERTEX) ? "Vertex" : "Face";
+            std::vector<std::string> splitArrElem = split(s, ' ');
+            // "\r" symbols are not trimmed by default
+            for (auto& e : splitArrElem)
+            {
+                e = trimSpaces(e);
+            }
+            if (splitArrElem.size() < 3)
+            {
+                CV_LOG_ERROR(NULL, elName << " property has " << splitArrElem.size()
+                             << " words instead of at least 3");
+                return false;
+            }
+            std::string propType = splitArrElem[1];
+            if (propType == "list")
+            {
+                property.isList = true;
+                if (splitArrElem.size() < 5)
+                {
+                    CV_LOG_ERROR(NULL, elName << " property has " << splitArrElem.size()
+                                 << " words instead of at least 5");
+                    return false;
+                }
+                std::string amtTypeString = splitArrElem[2];
+                if (dataTypes.count(amtTypeString) == 0)
+                {
+                    CV_LOG_ERROR(NULL, "Property type " << amtTypeString
+                                 << " is not supported");
+                    return false;
+                }
+                else
+                {
+                    property.counterType = dataTypes.at(amtTypeString);
+                }
+                std::string idxTypeString = splitArrElem[3];
+                if (dataTypes.count(idxTypeString) == 0)
+                {
+                    CV_LOG_ERROR(NULL, "Property type " << idxTypeString
+                                 << " is not supported");
+                    return false;
+                }
+                else
+                {
+                    property.valType = dataTypes.at(idxTypeString);
+                }
+
+                property.name = splitArrElem[4];
+            }
+            else
+            {
+                property.isList = false;
+                if (dataTypes.count(propType) == 0)
+                {
+                    CV_LOG_ERROR(NULL, "Property type " << propType
+                                 << " is not supported");
+                    return false;
+                }
+                else
+                {
+                    property.valType = dataTypes.at(propType);
+                }
+                property.name = splitArrElem[2];
+            }
+
+            if (elemRead == READ_VERTEX)
+            {
+                m_vertexDescription.properties.push_back(property);
+            }
+            else if (elemRead == READ_FACE)
+            {
+                m_faceDescription.properties.push_back(property);
+            }
+
+            continue;
+        }
+        if (startsWith(s, "end_header"))
+            break;
+    }
+
+    static const std::set<std::string> texCoordKeys = { "texture_u", "s", "texture_v", "t", "texture_w" };
+
+    bool good = true;
+    m_vertexCount = m_vertexDescription.amount;
+    std::map<std::string, int> amtProps;
+    for (const auto& p : m_vertexDescription.properties)
+    {
+        bool known = false;
+        if (p.name ==  "x" || p.name ==  "y" || p.name ==  "z")
+        {
+            known = true;
+            if (p.valType != CV_32F)
+            {
+                CV_LOG_ERROR(NULL, "Vertex property " << p.name
+                                                      << " should be float");
+                good = false;
+            }
+        }
+        if (p.name == "nx" || p.name == "ny" || p.name == "nz")
+        {
+            known = true;
+            if (p.valType != CV_32F)
+            {
+                CV_LOG_ERROR(NULL, "Vertex property " << p.name
+                                                      << " should be float");
+                good = false;
+            }
+            m_hasNormal = true;
+        }
+        if (colorKeys.count(p.name) > 0)
+        {
+            known = true;
+            if (p.valType != CV_8U)
+            {
+                CV_LOG_ERROR(NULL, "Vertex property " << p.name
+                                                      << " should be uchar");
+                good = false;
+            }
+            m_hasColour = true;
+        }
+        if (texCoordKeys.count(p.name) > 0)
+        {
+            known = true;
+            if (p.valType != CV_32F)
+            {
+                CV_LOG_ERROR(NULL, "Vertex property " << p.name
+                                                      << " should be float");
+                good = false;
+            }
+            m_hasTexCoord = true;
+        }
+        if (p.isList)
+        {
+            CV_LOG_ERROR(NULL, "List properties for vertices are not supported");
+            good = false;
+        }
+        if (known)
+        {
+            amtProps[p.name]++;
+        }
+    }
+
+    // check if we have no duplicates
+    for (const auto& a : amtProps)
+    {
+        if (a.second > 1)
+        {
+            CV_LOG_ERROR(NULL, "Vertex property " << a.first << " is duplicated");
+            good = false;
+        }
+    }
+    const std::array<std::string, 3> vertKeys = {"x", "y", "z"};
+    for (const std::string& c : vertKeys)
+    {
+        if (amtProps.count(c) == 0)
+        {
+            CV_LOG_ERROR(NULL, "Vertex property " << c << " is not presented in the file");
+            good = false;
+        }
+    }
+
+    // check for synonyms
+    std::vector<std::pair<size_t, size_t>> propCounts;
+    std::vector<std::pair<std::string, std::string>> synonyms = {
+        {"red", "diffuse_red"},
+        {"green", "diffuse_green"},
+        {"blue", "diffuse_blue"},
+        {"texture_u", "s"},
+        {"texture_v", "t"},
+    };
+    for (const auto& p : synonyms)
+    {
+        std::string a, b;
+        a = p.first; b = p.second;
+        size_t ca = amtProps.count(a), cb = amtProps.count(b);
+        propCounts.push_back({ca, cb});
+        if (ca + cb > 1)
+        {
+            CV_LOG_ERROR(NULL, "Vertex property " << a << " should not go with its synonym " << b);
+            good = false;
+        }
+    }
+    // check for color conventions
+    bool shortColorConv   = propCounts[0].first  || propCounts[1].first  || propCounts[2].first;
+    bool diffuseColorConv = propCounts[0].second || propCounts[1].second || propCounts[2].second;
+    if (shortColorConv && diffuseColorConv)
+    {
+        CV_LOG_ERROR(NULL, "Vertex color properties should not be diffuse and not diffuse at the same time");
+        good = false;
+    }
+    // check for texture conventions
+    bool shortTexConv = propCounts[3].second || propCounts[4].second;
+    bool longTexConv  = propCounts[3].first  || propCounts[4].first;
+    if (shortTexConv && longTexConv)
+    {
+        CV_LOG_ERROR(NULL, "Vertex texture coordinates properties should not be in a short and in a long form at the same time");
+        good = false;
+    }
+
+    nTexCoords = 0;
+    for (const auto& k : texCoordKeys)
+    {
+        nTexCoords += (int)(amtProps.count(k));
+    }
+
+    m_faceCount = m_faceDescription.amount;
+    int amtLists = 0;
+    for (const auto& p : m_faceDescription.properties)
+    {
+        if (p.isList)
+        {
+            amtLists++;
+            if (!(p.counterType == CV_8U && (p.valType == CV_32S || p.valType == CV_32U)))
+            {
+                CV_LOG_ERROR(NULL, "List property " << p.name
+                             << " should have type uint8 for counter and uint32 for values");
+                good = false;
+            }
+            if (!(p.name == "vertex_index" || p.name == "vertex_indices"))
+            {
+                CV_LOG_ERROR(NULL, "List property should be vertex_index or vertex_indices, "
+                             << p.name << " is not supported");
+                good = false;
+            }
+        }
+    }
+    if (amtLists > 1)
+    {
+        CV_LOG_ERROR(NULL, "Only 1 list property is supported per face");
+        good = false;
+    }
+
+    return good;
+}
+
+template <typename T>
+T readNext(std::ifstream &file, DataFormat format)
+{
+    T val;
+    if (format == DataFormat::ASCII)
+    {
+        file >> val;
+        return val;
+    }
+    file.read((char *)&val, sizeof(T));
+#ifdef WORDS_BIGENDIAN
+    if (!(format == DataFormat::BinaryBigEndian) )
+    {
+        swapEndian<T>(val);
+    }
+#else
+    if (format == DataFormat::BinaryBigEndian)
+    {
+        swapEndian<T>(val);
+    }
+#endif
+    return val;
+}
+
+template <>
+uchar readNext<uchar>(std::ifstream &file, DataFormat format)
+{
+    if (format == DataFormat::ASCII)
+    {
+        int val;
+        file >> val;
+        return (uchar)val;
+    }
+    uchar val;
+    file.read((char *)&val, sizeof(uchar));
+    // 1 byte does not have to be endian-swapped
+    return val;
+}
+
+void PlyDecoder::parseBody(std::ifstream &file,
+                           std::vector<Point3f>& points, std::vector<Point3f>& normals,
+                           std::vector<Point3f>& rgb, std::vector<Point3f>& texCoords,
+                           std::vector<std::vector<int32_t>> &indices)
+{
+    points.reserve(m_vertexCount);
+    if (m_hasColour)
+    {
+        rgb.reserve(m_vertexCount);
+    }
+    if (m_hasNormal)
+    {
+        normals.reserve(m_vertexCount);
+    }
+
+    struct VertexFields
+    {
+        float vx, vy, vz;
+        float nx, ny, nz;
+        float u, v, w;
+        float r, g, b;
+    };
+
+    union VertexData
+    {
+        std::array<uchar, sizeof(VertexFields)> bytes;
+        VertexFields vf;
+    };
+
+    // to avoid string matching at file loading
+    std::vector<size_t> vertexOffsets(m_vertexDescription.properties.size(), (size_t)(-1));
+    for (size_t j = 0; j < m_vertexDescription.properties.size(); j++)
+    {
+        const auto& p = m_vertexDescription.properties[j];
+        size_t offset = (size_t)(-1);
+        if (p.name == "x")
+            offset = offsetof(VertexFields, vx);
+        if (p.name == "y")
+            offset = offsetof(VertexFields, vy);
+        if (p.name == "z")
+            offset = offsetof(VertexFields, vz);
+        if (p.name == "nx")
+            offset = offsetof(VertexFields, nx);
+        if (p.name == "ny")
+            offset = offsetof(VertexFields, ny);
+        if (p.name == "nz")
+            offset = offsetof(VertexFields, nz);
+        if (p.name == "texture_u" || p.name == "s")
+            offset = offsetof(VertexFields, u);
+        if (p.name == "texture_v" || p.name == "t")
+            offset = offsetof(VertexFields, v);
+        if (p.name == "texture_w")
+            offset = offsetof(VertexFields, w);
+        if (p.name == "red"   || p.name == "diffuse_red")
+            offset = offsetof(VertexFields, r);
+        if (p.name == "green" || p.name == "diffuse_green")
+            offset = offsetof(VertexFields, g);
+        if (p.name == "blue"  || p.name == "diffuse_blue")
+            offset = offsetof(VertexFields, b);
+        vertexOffsets[j] = offset;
+    }
+
+    for (size_t i = 0; i < m_vertexCount; i++)
+    {
+        VertexData vertexData{ };
+        for (size_t j = 0; j < m_vertexDescription.properties.size(); j++)
+        {
+            const auto& p = m_vertexDescription.properties[j];
+            uint ival = 0; float fval = 0;
+            // here signedness is not important
+            switch (p.valType)
+            {
+            case CV_8U: case CV_8S:
+                ival = readNext<uchar>(file, m_inputDataFormat);
+                break;
+            case CV_16U: case CV_16S:
+                ival = readNext<ushort>(file, m_inputDataFormat);
+                break;
+            case CV_32S: case CV_32U:
+                ival = readNext<uint>(file, m_inputDataFormat);
+                break;
+            case CV_32F:
+                fval = readNext<float>(file, m_inputDataFormat);
+                break;
+            case CV_64F:
+                fval = (float)readNext<double>(file, m_inputDataFormat);
+                break;
+            default:
+                break;
+            }
+            size_t offset = vertexOffsets[j];
+            if (offset != (size_t)(-1))
+            {
+                if (colorKeys.count(p.name) > 0 && p.valType == CV_8U)
+                {
+                    fval = ival / 255.f;
+                }
+
+                *(float*)(vertexData.bytes.data() + offset) = fval;
+            }
+        }
+
+        points.push_back({ vertexData.vf.vx, vertexData.vf.vy, vertexData.vf.vz });
+        if (m_hasColour)
+        {
+            rgb.push_back({ vertexData.vf.r, vertexData.vf.g, vertexData.vf.b });
+        }
+        if (m_hasNormal)
+        {
+            normals.push_back({ vertexData.vf.nx, vertexData.vf.ny, vertexData.vf.nz });
+        }
+        if (m_hasTexCoord)
+        {
+            texCoords.push_back({ vertexData.vf.u, vertexData.vf.v, vertexData.vf.w });
+        }
+    }
+
+    indices.reserve(m_faceCount);
+    for (size_t i = 0; i < m_faceCount; i++)
+    {
+        for (const auto& p : m_faceDescription.properties)
+        {
+            if (p.isList)
+            {
+                size_t nVerts = readNext<uchar>(file, m_inputDataFormat);
+                if (nVerts < 3)
+                {
+                    CV_LOG_ERROR(NULL, "Face should have at least 3 vertices but has " << nVerts);
+                    return;
+                }
+                // PLY can have faces with >3 vertices in TRIANGLE_FAN format
+                // in this case we load them as separate triangles
+                int vert1 = readNext<int>(file, m_inputDataFormat);
+                int vert2 = readNext<int>(file, m_inputDataFormat);
+                for (size_t j = 2; j < nVerts; j++)
+                {
+                    int vert3 = readNext<int>(file, m_inputDataFormat);
+                    indices.push_back({vert1, vert2, vert3});
+                    vert2 = vert3;
+                }
+            }
+            else
+            {
+                // read and discard
+                switch (p.valType)
+                {
+                case CV_8U: case CV_8S:
+                    readNext<uchar>(file, m_inputDataFormat);
+                    break;
+                case CV_16U: case CV_16S:
+                    readNext<ushort>(file, m_inputDataFormat);
+                    break;
+                case CV_32S: case CV_32U:
+                    readNext<uint>(file, m_inputDataFormat);
+                    break;
+                case CV_32F:
+                    readNext<float>(file, m_inputDataFormat);
+                    break;
+                case CV_64F:
+                    readNext<double>(file, m_inputDataFormat);
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void PlyEncoder::writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb,
+                           const std::vector<Point3f>& texCoords, int nTexCoords,
+                           const std::vector<std::vector<int32_t>>& indices)
+{
+    std::ofstream file(m_filename, std::ios::binary);
+    if (!file)
+    {
+        CV_LOG_ERROR(NULL, "Impossible to open the file: " << m_filename);
+        return;
+    }
+    bool hasNormals = !normals.empty(), hasColor = !rgb.empty();
+    if (texCoords.empty() && nTexCoords > 0)
+    {
+        CV_LOG_ERROR(NULL, "No texture coordinates provided while having nTexCoord > 0");
+        return;
+    }
+
+    file << "ply" << std::endl;
+    file << "format ascii 1.0" << std::endl;
+    file << "comment created by OpenCV" << std::endl;
+    file << "element vertex " << points.size() << std::endl;
+
+    file << "property float x" << std::endl;
+    file << "property float y" << std::endl;
+    file << "property float z" << std::endl;
+
+    if(hasColor)
+    {
+        file << "property uchar red" << std::endl;
+        file << "property uchar green" << std::endl;
+        file << "property uchar blue" << std::endl;
+    }
+
+    if (hasNormals)
+    {
+        file << "property float nx" << std::endl;
+        file << "property float ny" << std::endl;
+        file << "property float nz" << std::endl;
+    }
+
+    if (nTexCoords > 0)
+    {
+        file << "property float texture_u" << std::endl;
+    }
+    if (nTexCoords > 1)
+    {
+        file << "property float texture_v" << std::endl;
+    }
+    if (nTexCoords > 2)
+    {
+        file << "property float texture_w" << std::endl;
+    }
+
+    if (!indices.empty())
+    {
+        file << "element face " << indices.size() << std::endl;
+        file << "property list uchar int vertex_indices" << std::endl;
+    }
+
+    file << "end_header" << std::endl;
+
+    for (size_t i = 0; i < points.size(); i++)
+    {
+        file << std::setprecision(9) << points[i].x << " " << points[i].y << " " << points[i].z;
+        if (hasColor)
+        {
+            file << " " << static_cast<int>(rgb[i].x * 255.f) << " " << static_cast<int>(rgb[i].y * 255.f) << " " << static_cast<int>(rgb[i].z * 255.f);
+        }
+        if (hasNormals)
+        {
+            file << " " << std::setprecision(9) << normals[i].x << " " << normals[i].y << " " << normals[i].z;
+        }
+        if (nTexCoords > 0)
+        {
+            file << " " << std::setprecision(9) << texCoords[i].x;
+        }
+        if (nTexCoords > 1)
+        {
+            file << " " << std::setprecision(9) << texCoords[i].y;
+        }
+        if (nTexCoords > 2)
+        {
+            file << " " << std::setprecision(9) << texCoords[i].z;
+        }
+        file << std::endl;
+    }
+
+    for (const auto& faceIndices : indices)
+    {
+        file << faceIndices.size();
+        for (const auto& index : faceIndices)
+        {
+            file << " " << index;
+        }
+        file << std::endl;
+    }
+    file.close();
+}
+
+} /* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/io_ply.hpp b/upstream/opencv/modules/ptcloud/src/io_ply.hpp
new file mode 100644
index 0000000..9aa1d85
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/io_ply.hpp
@@ -0,0 +1,70 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _CODERS_PLY_H_
+#define _CODERS_PLY_H_
+
+#include "io_base.hpp"
+#include <istream>
+#include <vector>
+
+namespace cv {
+
+enum class DataFormat
+{
+    ASCII,
+    BinaryLittleEndian,
+    BinaryBigEndian
+};
+
+struct Property
+{
+    bool isList;
+    int counterType;
+    int valType;
+    std::string name;
+};
+
+struct ElementDescription
+{
+    size_t amount;
+    std::vector<Property> properties;
+};
+
+class PlyDecoder CV_FINAL : public BasePointCloudDecoder
+{
+public:
+    void readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                  std::vector<Point3f>& texCoords, int& nTexCoords,
+                  std::vector<std::vector<int32_t>>& indices, int flags) CV_OVERRIDE;
+
+protected:
+    bool parseHeader(std::ifstream &file, int& nTexCoords);
+    void parseBody(std::ifstream &file,
+                   std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb,
+                   std::vector<Point3f>& texCoords,
+                   std::vector<std::vector<int32_t>>& indices);
+
+    DataFormat m_inputDataFormat;
+    size_t m_vertexCount{0};
+    size_t m_faceCount{0};
+    bool m_hasColour{false};
+    bool m_hasNormal{false};
+    bool m_hasTexCoord{false};
+    ElementDescription m_vertexDescription;
+    ElementDescription m_faceDescription;
+};
+
+class PlyEncoder CV_FINAL : public BasePointCloudEncoder
+{
+public:
+    void writeData(const std::vector<Point3f>& points, const std::vector<Point3f>& normals, const std::vector<Point3f>& rgb,
+                   const std::vector<Point3f>& texCoords, int nTexCoords,
+                   const std::vector<std::vector<int32_t>>& indices) CV_OVERRIDE;
+
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp b/upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp
new file mode 100644
index 0000000..036247b
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/kinfu_frame.cpp
@@ -0,0 +1,783 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#include "precomp.hpp"
+#include "opencv2/ptcloud/detail/kinfu_frame.hpp"
+#include "utils.hpp"
+#include "opencl_kernels_ptcloud.hpp"
+
+namespace cv {
+
+static void computePointsNormals(const cv::Intr, float depthFactor, const Depth, Points, Normals );
+void computePointsNormalsColors(const Intr, const Intr, float, const Depth, const Colors, Points, Normals, Colors);
+static Depth pyrDownBilateral(const Depth depth, float sigma);
+static void pyrDownPointsNormals(const Points p, const Normals n, Points& pdown, Normals& ndown);
+
+template<int p>
+inline float specPow(float x)
+{
+    if(p % 2 == 0)
+    {
+        float v = specPow<p/2>(x);
+        return v*v;
+    }
+    else
+    {
+        float v = specPow<(p-1)/2>(x);
+        return v*v*x;
+    }
+}
+
+template<>
+inline float specPow<0>(float /*x*/)
+{
+    return 1.f;
+}
+
+template<>
+inline float specPow<1>(float x)
+{
+    return x;
+}
+
+
+struct RenderInvoker : ParallelLoopBody
+{
+    RenderInvoker(const Points& _points, const Normals& _normals, Mat_<Vec4b>& _img, Vec3f _lightPt, Size _sz) :
+        ParallelLoopBody(),
+        points(_points),
+        normals(_normals),
+        img(_img),
+        lightPt(_lightPt),
+        sz(_sz)
+    { }
+
+    virtual void operator ()(const Range& range) const override
+    {
+        for(int y = range.start; y < range.end; y++)
+        {
+            Vec4b* imgRow = img[y];
+            const ptype* ptsRow = points[y];
+            const ptype* nrmRow = normals[y];
+
+            for(int x = 0; x < sz.width; x++)
+            {
+                Point3f p = fromPtype(ptsRow[x]);
+                Point3f n = fromPtype(nrmRow[x]);
+
+                Vec4b color;
+
+                if(isNaN(p))
+                {
+                    color = Vec4b(0, 32, 0, 0);
+                }
+                else
+                {
+                    const float Ka = 0.3f;  //ambient coeff
+                    const float Kd = 0.5f;  //diffuse coeff
+                    const float Ks = 0.2f;  //specular coeff
+                    const int   sp = 20;  //specular power
+
+                    const float Ax = 1.f;   //ambient color,  can be RGB
+                    const float Dx = 1.f;   //diffuse color,  can be RGB
+                    const float Sx = 1.f;   //specular color, can be RGB
+                    const float Lx = 1.f;   //light color
+
+                    Point3f l = normalize(lightPt - Vec3f(p));
+                    Point3f v = normalize(-Vec3f(p));
+                    Point3f r = normalize(Vec3f(2.f*n*n.dot(l) - l));
+
+                    uchar ix = (uchar)((Ax*Ka*Dx + Lx*Kd*Dx*max(0.f, n.dot(l)) +
+                                        Lx*Ks*Sx*specPow<sp>(max(0.f, r.dot(v))))*255.f);
+                    color = Vec4b(ix, ix, ix, 0);
+                }
+
+                imgRow[x] = color;
+            }
+        }
+    }
+
+    const Points& points;
+    const Normals& normals;
+    Mat_<Vec4b>& img;
+    Vec3f lightPt;
+    Size sz;
+};
+
+struct RenderColorInvoker : ParallelLoopBody
+{
+    RenderColorInvoker(const Points& _points, const Colors& _colors, Mat_<Vec4b>& _img, Size _sz) :
+        ParallelLoopBody(),
+        points(_points),
+        colors(_colors),
+        img(_img),
+        sz(_sz)
+    { }
+
+    virtual void operator ()(const Range& range) const override
+    {
+        for(int y = range.start; y < range.end; y++)
+        {
+            Vec4b* imgRow = img[y];
+            const ptype* ptsRow = points[y];
+            const ptype* clrRow = colors[y];
+
+            for(int x = 0; x < sz.width; x++)
+            {
+                Point3f p = fromPtype(ptsRow[x]);
+                Point3f c = fromPtype(clrRow[x]);
+                Vec4b color;
+
+                if(isNaN(p) || isNaN(c))
+                {
+                    color = Vec4b(0, 32, 0, 0);
+                }
+                else
+                {
+                    color = Vec4b((uchar)c.x, (uchar)c.y, (uchar)c.z, (uchar)0);
+                }
+
+                imgRow[x] = color;
+            }
+        }
+    }
+
+    const Points& points;
+    const Colors& colors;
+    Mat_<Vec4b>& img;
+    Size sz;
+};
+
+
+void pyrDownPointsNormals(const Points p, const Normals n, Points &pdown, Normals &ndown)
+{
+    CV_TRACE_FUNCTION();
+
+    for(int y = 0; y < pdown.rows; y++)
+    {
+        ptype* ptsRow = pdown[y];
+        ptype* nrmRow = ndown[y];
+        const ptype* pUpRow0 = p[2*y];
+        const ptype* pUpRow1 = p[2*y+1];
+        const ptype* nUpRow0 = n[2*y];
+        const ptype* nUpRow1 = n[2*y+1];
+        for(int x = 0; x < pdown.cols; x++)
+        {
+            Point3f point = nan3, normal = nan3;
+
+            Point3f d00 = fromPtype(pUpRow0[2*x]);
+            Point3f d01 = fromPtype(pUpRow0[2*x+1]);
+            Point3f d10 = fromPtype(pUpRow1[2*x]);
+            Point3f d11 = fromPtype(pUpRow1[2*x+1]);
+
+            if(!(isNaN(d00) || isNaN(d01) || isNaN(d10) || isNaN(d11)))
+            {
+                point = (d00 + d01 + d10 + d11)*0.25f;
+
+                Point3f n00 = fromPtype(nUpRow0[2*x]);
+                Point3f n01 = fromPtype(nUpRow0[2*x+1]);
+                Point3f n10 = fromPtype(nUpRow1[2*x]);
+                Point3f n11 = fromPtype(nUpRow1[2*x+1]);
+
+                normal = (n00 + n01 + n10 + n11)*0.25f;
+            }
+
+            ptsRow[x] = toPtype(point);
+            nrmRow[x] = toPtype(normal);
+        }
+    }
+}
+
+struct PyrDownBilateralInvoker : ParallelLoopBody
+{
+    PyrDownBilateralInvoker(const Depth& _depth, Depth& _depthDown, float _sigma) :
+        ParallelLoopBody(),
+        depth(_depth),
+        depthDown(_depthDown),
+        sigma(_sigma)
+    { }
+
+    virtual void operator ()(const Range& range) const override
+    {
+        float sigma3 = sigma*3;
+        const int D = 5;
+
+        for(int y = range.start; y < range.end; y++)
+        {
+            depthType* downRow = depthDown[y];
+            const depthType* srcCenterRow = depth[2*y];
+
+            for(int x = 0; x < depthDown.cols; x++)
+            {
+                depthType center = srcCenterRow[2*x];
+
+                int sx = max(0, 2*x - D/2), ex = min(2*x - D/2 + D, depth.cols-1);
+                int sy = max(0, 2*y - D/2), ey = min(2*y - D/2 + D, depth.rows-1);
+
+                depthType sum = 0;
+                int count = 0;
+
+                for(int iy = sy; iy < ey; iy++)
+                {
+                    const depthType* srcRow = depth[iy];
+                    for(int ix = sx; ix < ex; ix++)
+                    {
+                        depthType val = srcRow[ix];
+                        if(abs(val - center) < sigma3)
+                        {
+                            sum += val; count ++;
+                        }
+                    }
+                }
+
+                downRow[x] = (count == 0) ? 0 : sum / count;
+            }
+        }
+    }
+
+    const Depth& depth;
+    Depth& depthDown;
+    float sigma;
+};
+
+
+Depth pyrDownBilateral(const Depth depth, float sigma)
+{
+    CV_TRACE_FUNCTION();
+
+    Depth depthDown(depth.rows/2, depth.cols/2);
+
+    PyrDownBilateralInvoker pdi(depth, depthDown, sigma);
+    Range range(0, depthDown.rows);
+    const int nstripes = -1;
+    parallel_for_(range, pdi, nstripes);
+
+    return depthDown;
+}
+
+struct ComputePointsNormalsInvoker : ParallelLoopBody
+{
+    ComputePointsNormalsInvoker(const Depth& _depth, Points& _points, Normals& _normals,
+                                const Intr::Reprojector& _reproj, float _dfac) :
+        ParallelLoopBody(),
+        depth(_depth),
+        points(_points),
+        normals(_normals),
+        reproj(_reproj),
+        dfac(_dfac)
+    { }
+
+    virtual void operator ()(const Range& range) const override
+    {
+        for(int y = range.start; y < range.end; y++)
+        {
+            const depthType* depthRow0 = depth[y];
+            const depthType* depthRow1 = (y < depth.rows - 1) ? depth[y + 1] : 0;
+            ptype    *ptsRow = points[y];
+            ptype   *normRow = normals[y];
+
+            for(int x = 0; x < depth.cols; x++)
+            {
+                depthType d00 = depthRow0[x];
+                depthType z00 = d00*dfac;
+                Point3f v00 = reproj(Point3f((float)x, (float)y, z00));
+
+                Point3f p = nan3, n = nan3;
+
+                if(x < depth.cols - 1 && y < depth.rows - 1)
+                {
+                    depthType d01 = depthRow0[x+1];
+                    depthType d10 = depthRow1[x];
+
+                    depthType z01 = d01*dfac;
+                    depthType z10 = d10*dfac;
+
+                    // before it was
+                    //if(z00*z01*z10 != 0)
+                    if(z00 != 0 && z01 != 0 && z10 != 0)
+                    {
+                        Point3f v01 = reproj(Point3f((float)(x+1), (float)(y+0), z01));
+                        Point3f v10 = reproj(Point3f((float)(x+0), (float)(y+1), z10));
+
+                        cv::Vec3f vec = (v01-v00).cross(v10-v00);
+                        n = -normalize(vec);
+                        p = v00;
+                    }
+                }
+
+                ptsRow[x] = toPtype(p);
+                normRow[x] = toPtype(n);
+            }
+        }
+    }
+
+    const Depth& depth;
+    Points& points;
+    Normals& normals;
+    const Intr::Reprojector& reproj;
+    float dfac;
+};
+
+
+void computePointsNormals(const Intr intr, float depthFactor, const Depth depth,
+                          Points points, Normals normals)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(!points.empty() && !normals.empty());
+    CV_Assert(depth.size() == points.size());
+    CV_Assert(depth.size() == normals.size());
+
+    // conversion to meters
+    // before it was:
+    //float dfac = 0.001f/depthFactor;
+    float dfac = 1.f/depthFactor;
+
+    Intr::Reprojector reproj = intr.makeReprojector();
+
+    ComputePointsNormalsInvoker ci(depth, points, normals, reproj, dfac);
+    Range range(0, depth.rows);
+    const int nstripes = -1;
+    parallel_for_(range, ci, nstripes);
+}
+
+
+///////// GPU implementation /////////
+
+#ifdef HAVE_OPENCL
+
+static bool ocl_renderPointsNormals(const UMat points, const UMat normals, UMat image, Vec3f lightLoc);
+static bool ocl_makeFrameFromDepth(const UMat depth, OutputArrayOfArrays points, OutputArrayOfArrays normals,
+                                   const Intr intr, int levels, float depthFactor,
+                                   float sigmaDepth, float sigmaSpatial, int kernelSize,
+                                   float truncateThreshold);
+static bool ocl_buildPyramidPointsNormals(const UMat points, const UMat normals,
+                                          OutputArrayOfArrays pyrPoints, OutputArrayOfArrays pyrNormals,
+                                          int levels);
+
+static bool computePointsNormalsGpu(const Intr intr, float depthFactor, const UMat& depth, UMat& points, UMat& normals);
+static bool pyrDownBilateralGpu(const UMat& depth, UMat& depthDown, float sigma);
+static bool customBilateralFilterGpu(const UMat src, UMat& dst, int kernelSize, float sigmaDepth, float sigmaSpatial);
+static bool pyrDownPointsNormalsGpu(const UMat p, const UMat n, UMat &pdown, UMat &ndown);
+
+
+bool computePointsNormalsGpu(const Intr intr, float depthFactor, const UMat& depth,
+                             UMat& points, UMat& normals)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(!points.empty() && !normals.empty());
+    CV_Assert(depth.size() == points.size());
+    CV_Assert(depth.size() == normals.size());
+    CV_Assert(depth.type() == DEPTH_TYPE);
+    CV_Assert(points.type()  == POINT_TYPE);
+    CV_Assert(normals.type() == POINT_TYPE);
+
+    // conversion to meters
+    float dfac = 1.f/depthFactor;
+
+    Intr::Reprojector reproj = intr.makeReprojector();
+
+    cv::String errorStr;
+    cv::String name = "computePointsNormals";
+    ocl::ProgramSource source = ocl::ptcloud::kinfu_frame_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if(k.empty())
+        return false;
+
+    Vec2f fxyinv(reproj.fxinv, reproj.fyinv), cxy(reproj.cx, reproj.cy);
+
+    k.args(ocl::KernelArg::WriteOnlyNoSize(points),
+           ocl::KernelArg::WriteOnlyNoSize(normals),
+           ocl::KernelArg::ReadOnly(depth),
+           fxyinv.val,
+           cxy.val,
+           dfac);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)depth.cols;
+    globalSize[1] = (size_t)depth.rows;
+
+    return k.run(2, globalSize, NULL, true);
+}
+
+
+bool pyrDownBilateralGpu(const UMat& depth, UMat& depthDown, float sigma)
+{
+    CV_TRACE_FUNCTION();
+
+    depthDown.create(depth.rows/2, depth.cols/2, DEPTH_TYPE);
+
+    cv::String errorStr;
+    cv::String name = "pyrDownBilateral";
+    ocl::ProgramSource source = ocl::ptcloud::kinfu_frame_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if(k.empty())
+        return false;
+
+    k.args(ocl::KernelArg::ReadOnly(depth),
+           ocl::KernelArg::WriteOnly(depthDown),
+           sigma);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)depthDown.cols;
+    globalSize[1] = (size_t)depthDown.rows;
+
+    return k.run(2, globalSize, NULL, true);
+}
+
+//TODO: remove it when OpenCV's bilateral processes 32f on GPU
+bool customBilateralFilterGpu(const UMat src /* udepth */, UMat& dst /* smooth */,
+                              int kernelSize, float sigmaDepth, float sigmaSpatial)
+{
+    CV_TRACE_FUNCTION();
+
+    Size frameSize = src.size();
+
+    CV_Assert(frameSize.area() > 0);
+    CV_Assert(src.type() == DEPTH_TYPE);
+
+    dst.create(frameSize, DEPTH_TYPE);
+
+    cv::String errorStr;
+    cv::String name = "customBilateral";
+    ocl::ProgramSource source = ocl::ptcloud::kinfu_frame_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if(k.empty())
+        return false;
+
+    k.args(ocl::KernelArg::ReadOnlyNoSize(src),
+           ocl::KernelArg::WriteOnlyNoSize(dst),
+           frameSize,
+           kernelSize,
+           0.5f / (sigmaSpatial * sigmaSpatial),
+           0.5f / (sigmaDepth * sigmaDepth));
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)src.cols;
+    globalSize[1] = (size_t)src.rows;
+
+    return k.run(2, globalSize, NULL, true);
+}
+
+
+bool pyrDownPointsNormalsGpu(const UMat p, const UMat n, UMat &pdown, UMat &ndown)
+{
+    CV_TRACE_FUNCTION();
+
+    cv::String errorStr;
+    cv::String name = "pyrDownPointsNormals";
+    ocl::ProgramSource source = ocl::ptcloud::kinfu_frame_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if(k.empty())
+        return false;
+
+    Size downSize = pdown.size();
+
+    k.args(ocl::KernelArg::ReadOnlyNoSize(p),
+           ocl::KernelArg::ReadOnlyNoSize(n),
+           ocl::KernelArg::WriteOnlyNoSize(pdown),
+           ocl::KernelArg::WriteOnlyNoSize(ndown),
+           downSize);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)pdown.cols;
+    globalSize[1] = (size_t)pdown.rows;
+
+    return k.run(2, globalSize, NULL, true);
+}
+
+
+static bool ocl_renderPointsNormals(const UMat points, const UMat normals,
+                                    UMat img, Vec3f lightLoc)
+{
+    CV_TRACE_FUNCTION();
+
+    cv::String errorStr;
+    cv::String name = "render";
+    ocl::ProgramSource source = ocl::ptcloud::kinfu_frame_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if(k.empty())
+        return false;
+
+    Vec4f lightPt(lightLoc[0], lightLoc[1], lightLoc[2]);
+    Size frameSize = points.size();
+
+    k.args(ocl::KernelArg::ReadOnlyNoSize(points),
+           ocl::KernelArg::ReadOnlyNoSize(normals),
+           ocl::KernelArg::WriteOnlyNoSize(img),
+           frameSize,
+           lightPt.val);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)points.cols;
+    globalSize[1] = (size_t)points.rows;
+
+    return k.run(2, globalSize, NULL, true);
+}
+
+
+static bool ocl_makeFrameFromDepth(const UMat depth, OutputArrayOfArrays points, OutputArrayOfArrays normals,
+                                   const Intr intr, int levels, float depthFactor,
+                                   float sigmaDepth, float sigmaSpatial, int kernelSize,
+                                   float truncateThreshold)
+{
+    CV_TRACE_FUNCTION();
+
+    // looks like OpenCV's bilateral filter works the same as KinFu's
+    UMat smooth;
+    //TODO: fix that
+    // until 32f isn't implemented in OpenCV in OpenCL, we should use our workarounds
+    //bilateralFilter(udepth, smooth, kernelSize, sigmaDepth*depthFactor, sigmaSpatial);
+    if(!customBilateralFilterGpu(depth, smooth, kernelSize, sigmaDepth*depthFactor, sigmaSpatial))
+        return false;
+
+    // depth truncation can be used in some scenes
+    UMat depthThreshold;
+    if(truncateThreshold > 0.f)
+        threshold(smooth, depthThreshold, truncateThreshold * depthFactor, 0.0, THRESH_TOZERO_INV);
+    else
+        depthThreshold = smooth;
+
+    UMat scaled = depthThreshold;
+    Size sz = smooth.size();
+    points.create(levels, 1, POINT_TYPE);
+    normals.create(levels, 1, POINT_TYPE);
+    for(int i = 0; i < levels; i++)
+    {
+        UMat& p = points.getUMatRef(i);
+        UMat& n = normals.getUMatRef(i);
+        p.create(sz, POINT_TYPE);
+        n.create(sz, POINT_TYPE);
+
+        if(!computePointsNormalsGpu(intr.scale(i), depthFactor, scaled, p, n))
+            return false;
+
+        if(i < levels - 1)
+        {
+            sz.width /= 2, sz.height /= 2;
+            UMat halfDepth(sz, DEPTH_TYPE);
+            pyrDownBilateralGpu(scaled, halfDepth, sigmaDepth*depthFactor);
+            scaled = halfDepth;
+        }
+    }
+
+    return true;
+}
+
+
+static bool ocl_buildPyramidPointsNormals(const UMat points, const UMat normals,
+                                          OutputArrayOfArrays pyrPoints, OutputArrayOfArrays pyrNormals,
+                                          int levels)
+{
+    CV_TRACE_FUNCTION();
+
+    pyrPoints .create(levels, 1, POINT_TYPE);
+    pyrNormals.create(levels, 1, POINT_TYPE);
+
+    pyrPoints .getUMatRef(0) = points;
+    pyrNormals.getUMatRef(0) = normals;
+
+    Size sz = points.size();
+    for(int i = 1; i < levels; i++)
+    {
+        UMat p1 = pyrPoints .getUMat(i-1);
+        UMat n1 = pyrNormals.getUMat(i-1);
+
+        sz.width /= 2; sz.height /= 2;
+        UMat& p0 = pyrPoints .getUMatRef(i);
+        UMat& n0 = pyrNormals.getUMatRef(i);
+        p0.create(sz, POINT_TYPE);
+        n0.create(sz, POINT_TYPE);
+
+        if(!pyrDownPointsNormalsGpu(p1, n1, p0, n0))
+            return false;
+    }
+
+    return true;
+}
+
+#endif
+
+namespace detail {
+
+void renderPointsNormals(InputArray _points, InputArray _normals, OutputArray image, cv::Vec3f lightLoc)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(_points.size().area() > 0);
+    CV_Assert(_points.size() == _normals.size());
+
+    Size sz = _points.size();
+    image.create(sz, CV_8UC4);
+
+    CV_OCL_RUN(_points.isUMat() && _normals.isUMat() && image.isUMat(),
+               ocl_renderPointsNormals(_points.getUMat(),
+                                       _normals.getUMat(),
+                                       image.getUMat(), lightLoc))
+
+    Points  points  = _points.getMat();
+    Normals normals = _normals.getMat();
+
+    Mat_<Vec4b> img = image.getMat();
+
+    RenderInvoker ri(points, normals, img, lightLoc, sz);
+    Range range(0, sz.height);
+    const int nstripes = -1;
+    parallel_for_(range, ri, nstripes);
+}
+
+void renderPointsNormalsColors(InputArray _points, InputArray _normals, InputArray _colors, OutputArray image)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(_points.size().area() > 0);
+    CV_Assert(_points.size() == _normals.size());
+
+    Size sz = _points.size();
+    image.create(sz, CV_8UC4);
+
+    Points  points  = _points.getMat();
+    Normals normals = _normals.getMat();
+    Colors colors = _colors.getMat();
+
+    Mat_<Vec4b> img = image.getMat();
+
+    RenderColorInvoker ri(points, colors, img, sz);
+    Range range(0, sz.height);
+    const int nstripes = -1;
+    parallel_for_(range, ri, nstripes);
+}
+
+} // namespace detail
+
+void makeFrameFromDepth(InputArray _depth,
+                        OutputArray pyrPoints, OutputArray pyrNormals,
+                        const Matx33f _intr, int levels, float depthFactor,
+                        float sigmaDepth, float sigmaSpatial, int kernelSize,
+                        float truncateThreshold)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(_depth.type() == DEPTH_TYPE);
+
+    Intr intr(_intr);
+    CV_OCL_RUN(_depth.isUMat() && pyrPoints.isUMatVector() && pyrNormals.isUMatVector(),
+               ocl_makeFrameFromDepth(_depth.getUMat(), pyrPoints, pyrNormals,
+                                      intr, levels, depthFactor,
+                                      sigmaDepth, sigmaSpatial, kernelSize,
+                                      truncateThreshold));
+
+    int kp = pyrPoints.kind(), kn = pyrNormals.kind();
+    // There can be UMats in the container (when OpenCL is off)
+    CV_Assert(kp == _InputArray::STD_ARRAY_MAT || kp == _InputArray::STD_VECTOR_MAT || kp == _InputArray::STD_VECTOR_UMAT);
+    CV_Assert(kn == _InputArray::STD_ARRAY_MAT || kn == _InputArray::STD_VECTOR_MAT || kp == _InputArray::STD_VECTOR_UMAT);
+
+    Depth depth = _depth.getMat();
+
+    // looks like OpenCV's bilateral filter works the same as KinFu's
+    Depth smooth;
+    Depth depthNoNans = depth.clone();
+    patchNaNs(depthNoNans);
+    bilateralFilter(depthNoNans, smooth, kernelSize, sigmaDepth * depthFactor, sigmaSpatial);
+
+    // depth truncation can be used in some scenes
+    Depth depthThreshold;
+    if(truncateThreshold > 0.f)
+        threshold(smooth, depthThreshold, truncateThreshold * depthFactor, 0.0, THRESH_TOZERO_INV);
+    else
+        depthThreshold = smooth;
+
+    // we don't need depth pyramid outside this method
+    // if we do, the code is to be refactored
+
+    Depth scaled = depthThreshold;
+    Size sz = smooth.size();
+    pyrPoints.create(levels, 1, POINT_TYPE);
+    pyrNormals.create(levels, 1, POINT_TYPE);
+    for(int i = 0; i < levels; i++)
+    {
+        pyrPoints .create(sz, POINT_TYPE, i);
+        pyrNormals.create(sz, POINT_TYPE, i);
+
+        // There can be UMats in the container (when OpenCL is off),
+        // getMatRef() is not applicable
+        Points  p = pyrPoints. getMat(i);
+        Normals n = pyrNormals.getMat(i);
+
+        computePointsNormals(intr.scale(i), depthFactor, scaled, p, n);
+
+        if(i < levels - 1)
+        {
+            sz.width /= 2; sz.height /= 2;
+            scaled = pyrDownBilateral(scaled, sigmaDepth*depthFactor);
+        }
+    }
+}
+
+
+void buildPyramidPointsNormals(InputArray _points, InputArray _normals,
+                               OutputArrayOfArrays pyrPoints, OutputArrayOfArrays pyrNormals,
+                               int levels)
+{
+    CV_TRACE_FUNCTION();
+
+    CV_Assert(_points.type() == POINT_TYPE);
+    CV_Assert(_points.type() == _normals.type());
+    CV_Assert(_points.size() == _normals.size());
+
+    CV_OCL_RUN(_points.isUMat() && _normals.isUMat() &&
+               pyrPoints.isUMatVector() && pyrNormals.isUMatVector(),
+               ocl_buildPyramidPointsNormals(_points.getUMat(), _normals.getUMat(),
+                                             pyrPoints, pyrNormals,
+                                             levels));
+
+    int kp = pyrPoints.kind(), kn = pyrNormals.kind();
+    CV_Assert(kp == _InputArray::STD_ARRAY_MAT || kp == _InputArray::STD_VECTOR_MAT);
+    CV_Assert(kn == _InputArray::STD_ARRAY_MAT || kn == _InputArray::STD_VECTOR_MAT);
+
+    Mat p0 = _points.getMat(), n0 = _normals.getMat();
+
+    pyrPoints .create(levels, 1, POINT_TYPE);
+    pyrNormals.create(levels, 1, POINT_TYPE);
+
+    pyrPoints .getMatRef(0) = p0;
+    pyrNormals.getMatRef(0) = n0;
+
+    Size sz = _points.size();
+    for(int i = 1; i < levels; i++)
+    {
+        Points  p1 = pyrPoints .getMat(i-1);
+        Normals n1 = pyrNormals.getMat(i-1);
+
+        sz.width /= 2; sz.height /= 2;
+
+        pyrPoints .create(sz, POINT_TYPE, i);
+        pyrNormals.create(sz, POINT_TYPE, i);
+        Points  pd = pyrPoints. getMatRef(i);
+        Normals nd = pyrNormals.getMatRef(i);
+
+        pyrDownPointsNormals(p1, n1, pd, nd);
+    }
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp b/upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp
new file mode 100644
index 0000000..11bc7b2
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/load_point_cloud.cpp
@@ -0,0 +1,341 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "precomp.hpp"
+
+#include "io_base.hpp"
+#include "io_obj.hpp"
+#include "io_ply.hpp"
+#include "utils.hpp"
+#include "opencv2/core/utils/filesystem.private.hpp"
+#include <opencv2/core/utils/logger.hpp>
+
+#include <memory>
+
+namespace cv {
+
+#if OPENCV_HAVE_FILESYSTEM_SUPPORT
+
+static PointCloudDecoder findDecoder(const String &filename)
+{
+    auto file_ext = getExtension(filename);
+    if (file_ext == "obj" || file_ext == "OBJ")
+    {
+        return std::unique_ptr<ObjDecoder>(new ObjDecoder());
+    }
+    if (file_ext == "ply" || file_ext == "PLY")
+    {
+        return std::unique_ptr<PlyDecoder>(new PlyDecoder());
+    }
+
+    return nullptr;
+}
+
+static PointCloudEncoder findEncoder(const String &filename)
+{
+    auto file_ext = getExtension(filename);
+    if (file_ext == "obj" || file_ext == "OBJ")
+    {
+        return std::unique_ptr<ObjEncoder>(new ObjEncoder());
+    }
+    if (file_ext == "ply" || file_ext == "PLY")
+    {
+        return std::unique_ptr<PlyEncoder>(new PlyEncoder());
+    }
+
+    return nullptr;
+}
+
+#endif
+
+void loadPointCloud(const String &filename, OutputArray vertices, OutputArray normals, OutputArray rgb)
+{
+#if OPENCV_HAVE_FILESYSTEM_SUPPORT
+    auto decoder = findDecoder(filename);
+    if (!decoder) {
+        String file_ext = getExtension(filename);
+        CV_LOG_ERROR(NULL, "File extension '" << file_ext << "' is not supported");
+        return;
+    }
+
+    decoder->setSource(filename);
+
+    std::vector<Point3f> vec_vertices, vec_normals, vec_rgb;
+
+    decoder->readData(vec_vertices, vec_normals, vec_rgb);
+
+    if (!vec_vertices.empty())
+        Mat(static_cast<int>(vec_vertices.size()), 1, CV_32FC3, vec_vertices.data()).copyTo(vertices);
+
+    if (!vec_normals.empty() && normals.needed())
+        Mat(static_cast<int>(vec_normals.size()), 1, CV_32FC3, vec_normals.data()).copyTo(normals);
+
+    if (!vec_rgb.empty() && rgb.needed())
+        Mat(static_cast<int>(vec_rgb.size()), 1, CV_32FC3, vec_rgb.data()).copyTo(rgb);
+
+#else // OPENCV_HAVE_FILESYSTEM_SUPPORT
+    CV_UNUSED(filename);
+    CV_UNUSED(vertices);
+    CV_UNUSED(normals);
+    CV_UNUSED(rgb);
+    CV_LOG_WARNING(NULL, "File system support is disabled in this OpenCV build!");
+#endif
+}
+
+void savePointCloud(const String &filename, InputArray vertices, InputArray normals, InputArray rgb)
+{
+#if OPENCV_HAVE_FILESYSTEM_SUPPORT
+    if (vertices.empty()) {
+        CV_LOG_WARNING(NULL, "Have no vertices to save");
+        return;
+    };
+
+    auto encoder = findEncoder(filename);
+    if (!encoder) {
+        String file_ext = getExtension(filename);
+        CV_LOG_ERROR(NULL, "File extension '" << file_ext << "' is not supported");
+        return;
+    }
+
+    encoder->setDestination(filename);
+
+    std::vector<Point3f> vec_vertices(vertices.getMat()), vec_normals, vec_rgb;
+
+    if (!normals.empty())
+    {
+        vec_normals = normals.getMat();
+    }
+
+    if (!rgb.empty())
+    {
+        vec_rgb = rgb.getMat();
+    }
+    encoder->writeData(vec_vertices, vec_normals, vec_rgb);
+
+#else // OPENCV_HAVE_FILESYSTEM_SUPPORT
+    CV_UNUSED(filename);
+    CV_UNUSED(vertices);
+    CV_UNUSED(normals);
+    CV_UNUSED(rgb);
+    CV_LOG_WARNING(NULL, "File system support is disabled in this OpenCV build!");
+#endif
+}
+
+void loadMesh(const String &filename, OutputArray vertices, OutputArrayOfArrays indices,
+              OutputArray normals, OutputArray colors, OutputArray texCoords)
+{
+#if OPENCV_HAVE_FILESYSTEM_SUPPORT
+    CV_Assert(vertices.needed());
+    CV_Assert(indices.needed());
+
+    PointCloudDecoder decoder = findDecoder(filename);
+    String file_ext = getExtension(filename);
+    if (!decoder) {
+        CV_LOG_ERROR(NULL, "File extension '" << file_ext << "' is not supported");
+        return;
+    }
+
+    decoder->setSource(filename);
+
+    std::vector<Point3f> vec_vertices, vec_normals, vec_rgb;
+    std::vector<std::vector<int32_t>> vec_indices;
+
+    std::vector<Point3f> vec_texCoords;
+    int nTexCoords = 0;
+
+    decoder->readData(vec_vertices, vec_normals, vec_rgb, vec_texCoords, nTexCoords, vec_indices, 0);
+
+    if (!vec_vertices.empty())
+    {
+        Mat(1, static_cast<int>(vec_vertices.size()), CV_32FC3, vec_vertices.data()).copyTo(vertices);
+    }
+
+    if (normals.needed() && !vec_normals.empty())
+    {
+        Mat(1, static_cast<int>(vec_normals.size()), CV_32FC3, vec_normals.data()).copyTo(normals);
+    }
+
+    if (colors.needed() && !vec_rgb.empty())
+    {
+        Mat(1, static_cast<int>(vec_rgb.size()), CV_32FC3, vec_rgb.data()).copyTo(colors);
+    }
+
+    if (!vec_indices.empty())
+    {
+        _InputArray::KindFlag kind = indices.kind();
+        int vecsz = (int)vec_indices.size();
+        if (kind == _InputArray::KindFlag::STD_VECTOR_VECTOR)
+        {
+            CV_Assert(indices.depth() == CV_32S);
+            std::vector<std::vector<int32_t>>& vec = *(std::vector<std::vector<int32_t>>*)indices.getObj();
+            vec.resize(vecsz);
+            for (int i = 0; i < vecsz; ++i)
+            {
+                Mat(1, static_cast<int>(vec_indices[i].size()), CV_32SC1, vec_indices[i].data()).copyTo(vec[i]);
+            }
+        }
+        // std::array<Mat> has fixed size, unsupported
+        else if (kind == _InputArray::KindFlag::STD_VECTOR_MAT)
+        {
+            indices.create(vecsz, 1, CV_32S);
+            for (int i = 0; i < vecsz; i++)
+            {
+                std::vector<int> vi = vec_indices[i];
+                indices.create(1, (int)vi.size(), CV_32S, i);
+                Mat(vi).copyTo(indices.getMat(i));
+            }
+        }
+        else
+        {
+            std::vector<Vec3i> vec(vec_indices.size());
+            for (int i = 0; i < vecsz; ++i)
+            {
+                Vec3i tri;
+                size_t sz = vec_indices[i].size();
+                if (sz != 3)
+                {
+                    CV_Error(Error::StsBadArg, "Face contains " + std::to_string(sz) + " vertices, can not put it into 3-channel indices array");
+                }
+                else
+                {
+                    for (int j = 0; j < 3; j++)
+                    {
+                        tri[j] = vec_indices[i][j];
+                    }
+                }
+                vec[i] = tri;
+            }
+            indices.create(1, (int)vec_indices.size(), CV_32SC3);
+            Mat(1, static_cast<int>(vec_indices.size()), CV_32SC3, vec.data()).copyTo(indices);
+        }
+    }
+
+    if (texCoords.needed())
+    {
+        if (nTexCoords)
+        {
+            CV_Assert(!texCoords.fixedType() || (texCoords.type() == CV_MAKE_TYPE(CV_32F, nTexCoords)));
+
+            Mat tex3(vec_texCoords);
+
+            if (nTexCoords == 3)
+            {
+                tex3.copyTo(texCoords);
+            }
+            else if (nTexCoords == 2)
+            {
+                // if texCoords is empty then channels() can be any number
+                bool has3ch = texCoords.channels() == 3;
+                int ch = has3ch ? 3 : 2;
+                std::vector<int> permut = has3ch ? std::vector<int>{ 0, 0, 1, 1, -1, 2 } : std::vector<int>{ 0, 0, 1, 1 };
+                texCoords.createSameSize(vec_texCoords, CV_MAKE_TYPE(CV_32F, ch));
+                Mat out = texCoords.getMat();
+                cv::mixChannels(tex3, out, permut);
+            }
+        }
+        else
+        {
+            texCoords.clear();
+        }
+    }
+
+#else // OPENCV_HAVE_FILESYSTEM_SUPPORT
+    CV_UNUSED(filename);
+    CV_UNUSED(vertices);
+    CV_UNUSED(normals);
+    CV_UNUSED(colors);
+    CV_UNUSED(indices);
+    CV_UNUSED(texCoords);
+    CV_LOG_WARNING(NULL, "File system support is disabled in this OpenCV build!");
+#endif
+}
+
+void saveMesh(const String &filename, InputArray vertices, InputArrayOfArrays indices,
+              InputArray normals, InputArray colors, InputArray texCoords)
+{
+#if OPENCV_HAVE_FILESYSTEM_SUPPORT
+    if (vertices.empty()) {
+        CV_LOG_WARNING(NULL, "Have no vertices to save");
+        return;
+    }
+
+    auto encoder = findEncoder(filename);
+    String file_ext = getExtension(filename);
+    if (!encoder) {
+        CV_LOG_ERROR(NULL, "File extension '" << file_ext << "' is not supported");
+        return;
+    }
+
+    encoder->setDestination(filename);
+
+    std::vector<Point3f> vec_vertices(vertices.getMat()), vec_normals, vec_rgb;
+    if (!normals.empty())
+    {
+        vec_normals = normals.getMat();
+    }
+
+    if (!colors.empty())
+    {
+        vec_rgb = colors.getMat();
+    }
+
+    std::vector<std::vector<int32_t>> vec_indices;
+    CV_Assert(indices.depth() == CV_32S);
+    if (indices.kind() == _InputArray::KindFlag::STD_VECTOR_VECTOR ||
+        indices.kind() == _InputArray::KindFlag::STD_VECTOR_MAT)
+    {
+        std::vector<Mat> mat_indices;
+        indices.getMatVector(mat_indices);
+        vec_indices.resize(mat_indices.size());
+        for (size_t i = 0; i < mat_indices.size(); ++i)
+        {
+            mat_indices[i].copyTo(vec_indices[i]);
+        }
+    }
+    else
+    {
+        CV_Assert(indices.channels() == 3);
+        std::vector<Vec3i>& vec = *(std::vector<Vec3i>*)indices.getObj();
+        vec_indices.resize(vec.size());
+        for (size_t i = 0; i < vec.size(); ++i)
+        {
+            for (int j = 0; j < 3; j++)
+            {
+                vec_indices[i].push_back(vec[i][j]);
+            }
+        }
+    }
+
+    std::vector<Point3f> vec_texCoords;
+    int nTexCoords = 0;
+    if (!texCoords.empty())
+    {
+        nTexCoords = texCoords.channels();
+    }
+    if (nTexCoords == 2)
+    {
+        // extend by 3rd zero channel
+        vec_texCoords.resize(texCoords.total());
+        cv::mixChannels(texCoords, vec_texCoords, {0, 0, 1, 1, -1, 2});
+    }
+    if (nTexCoords == 3)
+    {
+        texCoords.copyTo(vec_texCoords);
+    }
+
+    encoder->writeData(vec_vertices, vec_normals, vec_rgb, vec_texCoords, nTexCoords, vec_indices);
+
+#else // OPENCV_HAVE_FILESYSTEM_SUPPORT
+    CV_UNUSED(filename);
+    CV_UNUSED(vertices);
+    CV_UNUSED(colors);
+    CV_UNUSED(normals);
+    CV_UNUSED(indices);
+    CV_UNUSED(texCoords);
+    CV_LOG_WARNING(NULL, "File system support is disabled in this OpenCV build!");
+#endif
+
+}
+
+}/* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/normal.cpp b/upstream/opencv/modules/ptcloud/src/normal.cpp
new file mode 100644
index 0000000..0be55f3
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/normal.cpp
@@ -0,0 +1,921 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/** Just compute the norm of a vector
+ * @param vec a vector of size 3 and any type T
+ * @return
+ */
+template<typename T>
+T inline norm_vec(const Vec<T, 3>& vec)
+{
+    return std::sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
+}
+template<typename T>
+T inline norm_vec(const Vec<T, 4>& vec)
+{
+    return std::sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
+}
+
+/** Given 3d points, compute their distance to the origin
+ * @param points
+ * @return
+ */
+template<typename T>
+Mat_<T> computeRadius(const Mat& points)
+{
+    typedef Vec<T, 4> PointT;
+
+    // Compute the
+    Size size(points.cols, points.rows);
+    Mat_<T> r(size);
+    if (points.isContinuous())
+        size = Size(points.cols * points.rows, 1);
+    for (int y = 0; y < size.height; ++y)
+    {
+        const PointT* point = points.ptr < PointT >(y), * point_end = points.ptr < PointT >(y) + size.width;
+        T* row = r[y];
+        for (; point != point_end; ++point, ++row)
+            *row = norm_vec(*point);
+    }
+
+    return r;
+}
+
+// Compute theta and phi according to equation 3 of
+// ``Fast and Accurate Computation of Surface Normals from Range Images``
+// by H. Badino, D. Huber, Y. Park and T. Kanade
+template<typename T>
+void computeThetaPhi(int rows, int cols, const Matx<T, 3, 3>& K, Mat& cos_theta, Mat& sin_theta,
+                     Mat& cos_phi, Mat& sin_phi)
+{
+    // Create some bogus coordinates
+    Mat depth_image = K(0, 0) * Mat_<T> ::ones(rows, cols);
+    Mat points3d;
+    depthTo3d(depth_image, Mat(K), points3d);
+
+    //typedef Vec<T, 3> Vec3T;
+    typedef Vec<T, 4> Vec4T;
+
+    cos_theta = Mat_<T>(rows, cols);
+    sin_theta = Mat_<T>(rows, cols);
+    cos_phi = Mat_<T>(rows, cols);
+    sin_phi = Mat_<T>(rows, cols);
+    Mat r = computeRadius<T>(points3d);
+    for (int y = 0; y < rows; ++y)
+    {
+        T* row_cos_theta = cos_theta.ptr <T>(y), * row_sin_theta = sin_theta.ptr <T>(y);
+        T* row_cos_phi = cos_phi.ptr <T>(y), * row_sin_phi = sin_phi.ptr <T>(y);
+        const Vec4T* row_points = points3d.ptr <Vec4T>(y),
+               * row_points_end = points3d.ptr <Vec4T>(y) + points3d.cols;
+        const T* row_r = r.ptr < T >(y);
+        for (; row_points < row_points_end;
+            ++row_cos_theta, ++row_sin_theta, ++row_cos_phi, ++row_sin_phi, ++row_points, ++row_r)
+        {
+            // In the paper, z goes away from the camera, y goes down, x goes right
+            // OpenCV has the same conventions
+            // Theta goes from z to x (and actually goes from -pi/2 to pi/2, phi goes from z to y
+            float theta = (float)std::atan2(row_points->val[0], row_points->val[2]);
+            *row_cos_theta = std::cos(theta);
+            *row_sin_theta = std::sin(theta);
+            float phi = (float)std::asin(row_points->val[1] / (*row_r));
+            *row_cos_phi = std::cos(phi);
+            *row_sin_phi = std::sin(phi);
+        }
+    }
+}
+
+/** Modify normals to make sure they point towards the camera
+ * @param normals
+ */
+template<typename T>
+inline void signNormal(const Vec<T, 3>& normal_in, Vec<T, 3>& normal_out)
+{
+    Vec<T, 3> res;
+    if (normal_in[2] > 0)
+        res = -normal_in / norm_vec(normal_in);
+    else
+        res = normal_in / norm_vec(normal_in);
+
+    normal_out[0] = res[0];
+    normal_out[1] = res[1];
+    normal_out[2] = res[2];
+}
+template<typename T>
+inline void signNormal(const Vec<T, 3>& normal_in, Vec<T, 4>& normal_out)
+{
+    Vec<T, 3> res;
+    if (normal_in[2] > 0)
+        res = -normal_in / norm_vec(normal_in);
+    else
+        res = normal_in / norm_vec(normal_in);
+
+    normal_out[0] = res[0];
+    normal_out[1] = res[1];
+    normal_out[2] = res[2];
+    normal_out[3] = 0;
+}
+
+/** Modify normals to make sure they point towards the camera
+ * @param normals
+ */
+template<typename T>
+inline void signNormal(T a, T b, T c, Vec<T, 3>& normal)
+{
+    T norm = 1 / std::sqrt(a * a + b * b + c * c);
+    if (c > 0)
+    {
+        normal[0] = -a * norm;
+        normal[1] = -b * norm;
+        normal[2] = -c * norm;
+    }
+    else
+    {
+        normal[0] = a * norm;
+        normal[1] = b * norm;
+        normal[2] = c * norm;
+    }
+}
+template<typename T>
+inline void signNormal(T a, T b, T c, Vec<T, 4>& normal)
+{
+    T norm = 1 / std::sqrt(a * a + b * b + c * c);
+    if (c > 0)
+    {
+        normal[0] = -a * norm;
+        normal[1] = -b * norm;
+        normal[2] = -c * norm;
+        normal[3] = 0;
+    }
+    else
+    {
+        normal[0] = a * norm;
+        normal[1] = b * norm;
+        normal[2] = c * norm;
+        normal[3] = 0;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+class RgbdNormalsImpl : public RgbdNormals
+{
+public:
+    static const int dtype = cv::traits::Depth<T>::value;
+
+    RgbdNormalsImpl(int _rows, int _cols, int _windowSize, const Mat& _K, RgbdNormals::RgbdNormalsMethod _method) :
+        rows(_rows),
+        cols(_cols),
+        windowSize(_windowSize),
+        method(_method),
+        cacheIsDirty(true)
+    {
+        CV_Assert(_K.cols == 3 && _K.rows == 3);
+
+        _K.convertTo(K, dtype);
+        _K.copyTo(K_ori);
+    }
+
+    virtual ~RgbdNormalsImpl() CV_OVERRIDE
+    { }
+
+    virtual int getDepth() const CV_OVERRIDE
+    {
+        return dtype;
+    }
+    virtual int getRows() const CV_OVERRIDE
+    {
+        return rows;
+    }
+    virtual void setRows(int val) CV_OVERRIDE
+    {
+        rows = val; cacheIsDirty = true;
+    }
+    virtual int getCols() const CV_OVERRIDE
+    {
+        return cols;
+    }
+    virtual void setCols(int val) CV_OVERRIDE
+    {
+        cols = val; cacheIsDirty = true;
+    }
+    virtual int getWindowSize() const CV_OVERRIDE
+    {
+        return windowSize;
+    }
+    virtual void setWindowSize(int val) CV_OVERRIDE
+    {
+        windowSize = val; cacheIsDirty = true;
+    }
+    virtual void getK(OutputArray val) const CV_OVERRIDE
+    {
+        K.copyTo(val);
+    }
+    virtual void setK(InputArray val) CV_OVERRIDE
+    {
+        K = val.getMat(); cacheIsDirty = true;
+    }
+    virtual RgbdNormalsMethod getMethod() const CV_OVERRIDE
+    {
+        return method;
+    }
+
+    virtual void compute(const Mat& in, Mat& normals) const = 0;
+
+    /** Given a set of 3d points in a depth image, compute the normals at each point
+     * @param points3d_in depth a float depth image. Or it can be rows x cols x 3 is they are 3d points
+     * @param normals a rows x cols x 3 matrix
+     */
+    virtual void apply(InputArray points3d_in, OutputArray normals_out) const CV_OVERRIDE
+    {
+        Mat points3d_ori = points3d_in.getMat();
+
+        CV_Assert(points3d_ori.dims == 2);
+
+        // Either we have 3d points or a depth image
+
+        bool ptsAre4F = (points3d_ori.channels() == 4) && (points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F);
+        bool ptsAreDepth = (points3d_ori.channels() == 1) && (points3d_ori.depth() == CV_16U || points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F);
+        if (method == RGBD_NORMALS_METHOD_FALS || method == RGBD_NORMALS_METHOD_SRI || method == RGBD_NORMALS_METHOD_CROSS_PRODUCT)
+        {
+            if (!ptsAre4F)
+            {
+                CV_Error(Error::StsBadArg, "Input image should have 4 float-point channels");
+            }
+        }
+        else if (method == RGBD_NORMALS_METHOD_LINEMOD)
+        {
+            if (!ptsAre4F && !ptsAreDepth)
+            {
+                CV_Error(Error::StsBadArg, "Input image should have 4 float-point channels or have 1 ushort or float-point channel");
+            }
+        }
+        else
+        {
+            CV_Error(Error::StsInternal, "Unknown normal computer algorithm");
+        }
+
+        // Initialize the pimpl
+        cache();
+
+        // Precompute something for RGBD_NORMALS_METHOD_SRI and RGBD_NORMALS_METHOD_FALS
+        Mat points3d;
+        if (method != RGBD_NORMALS_METHOD_LINEMOD)
+        {
+            // Make the points have the right depth
+            if (points3d_ori.depth() == dtype)
+                points3d = points3d_ori;
+            else
+                points3d_ori.convertTo(points3d, dtype);
+        }
+
+        // Get the normals
+        normals_out.create(points3d_ori.size(), CV_MAKETYPE(dtype, 4));
+        if (points3d_ori.empty())
+            return;
+
+        Mat normals = normals_out.getMat();
+        if ((method == RGBD_NORMALS_METHOD_FALS) || (method == RGBD_NORMALS_METHOD_SRI))
+        {
+            // Compute the distance to the points
+            Mat radius = computeRadius<T>(points3d);
+            compute(radius, normals);
+        }
+        else if (method == RGBD_NORMALS_METHOD_LINEMOD)
+        {
+            compute(points3d_ori, normals);
+        }
+        else if (method == RGBD_NORMALS_METHOD_CROSS_PRODUCT)
+        {
+            compute(points3d, normals);
+        }
+        else
+        {
+            CV_Error(Error::StsInternal, "Unknown normal computer algorithm");
+        }
+    }
+
+    int rows, cols;
+    Mat K, K_ori;
+    int windowSize;
+    RgbdNormalsMethod method;
+    mutable bool cacheIsDirty;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Given a set of 3d points in a depth image, compute the normals at each point
+ * using the FALS method described in
+ * ``Fast and Accurate Computation of Surface Normals from Range Images``
+ * by H. Badino, D. Huber, Y. Park and T. Kanade
+ */
+template<typename T>
+class FALS : public RgbdNormalsImpl<T>
+{
+public:
+    typedef Matx<T, 3, 3> Mat33T;
+    typedef Vec<T, 9> Vec9T;
+    typedef Vec<T, 4> Vec4T;
+    typedef Vec<T, 3> Vec3T;
+
+    FALS(int _rows, int _cols, int _windowSize, const Mat& _K) :
+        RgbdNormalsImpl<T>(_rows, _cols, _windowSize, _K, RgbdNormals::RGBD_NORMALS_METHOD_FALS)
+    { }
+    virtual ~FALS() CV_OVERRIDE
+    { }
+
+    /** Compute cached data
+     */
+    virtual void cache() const CV_OVERRIDE
+    {
+        if (!this->cacheIsDirty)
+            return;
+
+        // Compute theta and phi according to equation 3
+        Mat cos_theta, sin_theta, cos_phi, sin_phi;
+        computeThetaPhi<T>(this->rows, this->cols, this->K, cos_theta, sin_theta, cos_phi, sin_phi);
+
+        // Compute all the v_i for every points
+        std::vector<Mat> channels(3);
+        channels[0] = sin_theta.mul(cos_phi);
+        channels[1] = sin_phi;
+        channels[2] = cos_theta.mul(cos_phi);
+        merge(channels, V_);
+
+        // Compute M
+        Mat_<Vec9T> M(this->rows, this->cols);
+        Mat33T VVt;
+        const Vec3T* vec = V_[0];
+        Vec9T* M_ptr = M[0], * M_ptr_end = M_ptr + this->rows * this->cols;
+        for (; M_ptr != M_ptr_end; ++vec, ++M_ptr)
+        {
+            VVt = (*vec) * vec->t();
+            *M_ptr = Vec9T(VVt.val);
+        }
+
+        boxFilter(M, M, M.depth(), Size(this->windowSize, this->windowSize), Point(-1, -1), false);
+
+        // Compute M's inverse
+        Mat33T M_inv;
+        M_inv_.create(this->rows, this->cols);
+        Vec9T* M_inv_ptr = M_inv_[0];
+        for (M_ptr = &M(0); M_ptr != M_ptr_end; ++M_inv_ptr, ++M_ptr)
+        {
+            // We have a semi-definite matrix
+            invert(Mat33T(M_ptr->val), M_inv, DECOMP_CHOLESKY);
+            *M_inv_ptr = Vec9T(M_inv.val);
+        }
+
+        this->cacheIsDirty = false;
+    }
+
+    /** Compute the normals
+     * @param r
+     * @return
+     */
+    virtual void compute(const Mat& r, Mat& normals) const CV_OVERRIDE
+    {
+        // Compute B
+        Mat_<Vec3T> B(this->rows, this->cols);
+
+        const T* row_r = r.ptr < T >(0), * row_r_end = row_r + this->rows * this->cols;
+        const Vec3T* row_V = V_[0];
+        Vec3T* row_B = B[0];
+        for (; row_r != row_r_end; ++row_r, ++row_B, ++row_V)
+        {
+            Vec3T val = (*row_V) / (*row_r);
+            if (cvIsInf(val[0]) || cvIsNaN(val[0]) ||
+                cvIsInf(val[1]) || cvIsNaN(val[1]) ||
+                cvIsInf(val[2]) || cvIsNaN(val[2]))
+                *row_B = Vec3T();
+            else
+                *row_B = val;
+        }
+
+        // Apply a box filter to B
+        boxFilter(B, B, B.depth(), Size(this->windowSize, this->windowSize), Point(-1, -1), false);
+
+        // compute the Minv*B products
+        row_r = r.ptr < T >(0);
+        const Vec3T* B_vec = B[0];
+        const Mat33T* M_inv = reinterpret_cast<const Mat33T*>(M_inv_.ptr(0));
+        //Vec3T* normal = normals.ptr<Vec3T>(0);
+        Vec4T* normal = normals.ptr<Vec4T>(0);
+        for (; row_r != row_r_end; ++row_r, ++B_vec, ++normal, ++M_inv)
+            if (cvIsNaN(*row_r))
+            {
+                (*normal)[0] = *row_r;
+                (*normal)[1] = *row_r;
+                (*normal)[2] = *row_r;
+                (*normal)[3] = 0;
+            }
+            else
+            {
+                Mat33T Mr = *M_inv;
+                Vec3T Br = *B_vec;
+                Vec3T MBr(Mr(0, 0) * Br[0] + Mr(0, 1) * Br[1] + Mr(0, 2) * Br[2],
+                          Mr(1, 0) * Br[0] + Mr(1, 1) * Br[1] + Mr(1, 2) * Br[2],
+                          Mr(2, 0) * Br[0] + Mr(2, 1) * Br[1] + Mr(2, 2) * Br[2]);
+                signNormal(MBr, *normal);
+            }
+    }
+
+    // Cached data
+    mutable Mat_<Vec3T> V_;
+    mutable Mat_<Vec9T> M_inv_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Function that multiplies K_inv by a vector. It is just meant to speed up the product as we know
+ * that K_inv is upper triangular and K_inv(2,2)=1
+ * @param K_inv
+ * @param a
+ * @param b
+ * @param c
+ * @param res
+ */
+template<typename T, typename U>
+void multiply_by_K_inv(const Matx<T, 3, 3>& K_inv, U a, U b, U c, Vec<T, 3>& res)
+{
+    res[0] = (T)(K_inv(0, 0) * a + K_inv(0, 1) * b + K_inv(0, 2) * c);
+    res[1] = (T)(K_inv(1, 1) * b + K_inv(1, 2) * c);
+    res[2] = (T)c;
+}
+
+/** Given a depth image, compute the normals as detailed in the LINEMOD paper
+ * ``Gradient Response Maps for Real-Time Detection of Texture-Less Objects``
+ * by S. Hinterstoisser, C. Cagniart, S. Ilic, P. Sturm, N. Navab, P. Fua, and V. Lepetit
+ */
+template<typename T>
+class LINEMOD : public RgbdNormalsImpl<T>
+{
+public:
+    typedef Vec<T, 4> Vec4T;
+    typedef Vec<T, 3> Vec3T;
+    typedef Matx<T, 3, 3> Mat33T;
+
+    LINEMOD(int _rows, int _cols, int _windowSize, const Mat& _K, double _diffThr = 50.0) :
+        RgbdNormalsImpl<T>(_rows, _cols, _windowSize, _K, RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD),
+        differenceThreshold(_diffThr)
+    { }
+
+    /** Compute cached data
+     */
+    virtual void cache() const CV_OVERRIDE
+    {
+        this->cacheIsDirty = false;
+    }
+
+    /** Compute the normals
+     * @param r
+     * @param normals the output normals
+     */
+    virtual void compute(const Mat& points3d, Mat& normals) const CV_OVERRIDE
+    {
+        // Only focus on the depth image for LINEMOD
+        Mat depth_in;
+        //if (points3d.channels() == 3)
+        if (points3d.channels() == 4)
+        {
+            std::vector<Mat> channels;
+            split(points3d, channels);
+            depth_in = channels[2];
+        }
+        else
+            depth_in = points3d;
+
+        switch (depth_in.depth())
+        {
+        case CV_16U:
+        {
+            const Mat_<unsigned short>& d(depth_in);
+            computeImpl<unsigned short, long>(d, normals);
+            break;
+        }
+        case CV_32F:
+        {
+            const Mat_<float>& d(depth_in);
+            computeImpl<float, float>(d, normals);
+            break;
+        }
+        case CV_64F:
+        {
+            const Mat_<double>& d(depth_in);
+            computeImpl<double, double>(d, normals);
+            break;
+        }
+        }
+    }
+
+    /** Compute the normals
+     * @param r
+     * @return
+     */
+    template<typename DepthDepth, typename ContainerDepth>
+    Mat computeImpl(const Mat_<DepthDepth>& depthIn, Mat& normals) const
+    {
+        const int r = 5; // used to be 7
+        const int sample_step = r;
+        const int square_size = ((2 * r / sample_step) + 1);
+        long offsets[square_size * square_size];
+        long offsets_x[square_size * square_size];
+        long offsets_y[square_size * square_size];
+        long offsets_x_x[square_size * square_size];
+        long offsets_x_y[square_size * square_size];
+        long offsets_y_y[square_size * square_size];
+        for (int j = -r, index = 0; j <= r; j += sample_step)
+            for (int i = -r; i <= r; i += sample_step, ++index)
+            {
+                offsets_x[index] = i;
+                offsets_y[index] = j;
+                offsets_x_x[index] = i * i;
+                offsets_x_y[index] = i * j;
+                offsets_y_y[index] = j * j;
+                offsets[index] = j * this->cols + i;
+            }
+
+        // Define K_inv by hand, just for higher accuracy
+        Mat33T K_inv = Matx<T, 3, 3>::eye(), kmat;
+        this->K.copyTo(kmat);
+        K_inv(0, 0) = 1.0f / kmat(0, 0);
+        K_inv(0, 1) = -kmat(0, 1) / (kmat(0, 0) * kmat(1, 1));
+        K_inv(0, 2) = (kmat(0, 1) * kmat(1, 2) - kmat(0, 2) * kmat(1, 1)) / (kmat(0, 0) * kmat(1, 1));
+        K_inv(1, 1) = 1 / kmat(1, 1);
+        K_inv(1, 2) = -kmat(1, 2) / kmat(1, 1);
+
+        Vec3T X1_minus_X, X2_minus_X;
+
+        ContainerDepth difference_threshold((ContainerDepth)differenceThreshold);
+        //TODO: fixit, difference threshold should not depend on input type
+        difference_threshold *= (ContainerDepth)(std::is_same<DepthDepth, ushort>::value ? 1000.0 : 1.0);
+        normals.setTo(std::numeric_limits<DepthDepth>::quiet_NaN());
+        for (int y = r; y < this->rows - r - 1; ++y)
+        {
+            const DepthDepth* p_line = reinterpret_cast<const DepthDepth*>(depthIn.ptr(y, r));
+            Vec4T* normal = normals.ptr<Vec4T>(y, r);
+
+            for (int x = r; x < this->cols - r - 1; ++x)
+            {
+                DepthDepth d = p_line[0];
+
+                // accum
+                long A[4];
+                A[0] = A[1] = A[2] = A[3] = 0;
+                ContainerDepth b[2];
+                b[0] = b[1] = 0;
+                for (unsigned int i = 0; i < square_size * square_size; ++i) {
+                    // We need to cast to ContainerDepth in case we have unsigned DepthDepth
+                    ContainerDepth delta = ContainerDepth(p_line[offsets[i]]) - ContainerDepth(d);
+                    if (std::abs(delta) > difference_threshold)
+                        continue;
+
+                    A[0] += offsets_x_x[i];
+                    A[1] += offsets_x_y[i];
+                    A[3] += offsets_y_y[i];
+                    b[0] += offsets_x[i] * delta;
+                    b[1] += offsets_y[i] * delta;
+                }
+
+                // solve for the optimal gradient D of equation (8)
+                long det = A[0] * A[3] - A[1] * A[1];
+                // We should divide the following two by det, but instead, we multiply
+                // X1_minus_X and X2_minus_X by det (which does not matter as we normalize the normals)
+                // Therefore, no division is done: this is only for speedup
+                ContainerDepth dx = (A[3] * b[0] - A[1] * b[1]);
+                ContainerDepth dy = (-A[1] * b[0] + A[0] * b[1]);
+
+                // Compute the dot product
+                //Vec3T X = K_inv * Vec3T(x, y, 1) * depth(y, x);
+                //Vec3T X1 = K_inv * Vec3T(x + 1, y, 1) * (depth(y, x) + dx);
+                //Vec3T X2 = K_inv * Vec3T(x, y + 1, 1) * (depth(y, x) + dy);
+                //Vec3T nor = (X1 - X).cross(X2 - X);
+                multiply_by_K_inv(K_inv, d * det + (x + 1) * dx, y * dx, dx, X1_minus_X);
+                multiply_by_K_inv(K_inv, x * dy, d * det + (y + 1) * dy, dy, X2_minus_X);
+                Vec3T nor = X1_minus_X.cross(X2_minus_X);
+                signNormal(nor, *normal);
+
+                ++p_line;
+                ++normal;
+            }
+        }
+
+        return normals;
+    }
+
+    double differenceThreshold;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Given a set of 3d points in a depth image, compute the normals at each point
+ * using the SRI method described in
+ * ``Fast and Accurate Computation of Surface Normals from Range Images``
+ * by H. Badino, D. Huber, Y. Park and T. Kanade
+ */
+template<typename T>
+class SRI : public RgbdNormalsImpl<T>
+{
+public:
+    typedef Matx<T, 3, 3> Mat33T;
+    typedef Vec<T, 9> Vec9T;
+    typedef Vec<T, 4> Vec4T;
+    typedef Vec<T, 3> Vec3T;
+
+    SRI(int _rows, int _cols, int _windowSize, const Mat& _K) :
+        RgbdNormalsImpl<T>(_rows, _cols, _windowSize, _K, RgbdNormals::RGBD_NORMALS_METHOD_SRI),
+        phi_step_(0),
+        theta_step_(0)
+    { }
+
+    /** Compute cached data
+     */
+    virtual void cache() const CV_OVERRIDE
+    {
+        if (!this->cacheIsDirty)
+            return;
+
+        Mat_<T> cos_theta, sin_theta, cos_phi, sin_phi;
+        computeThetaPhi<T>(this->rows, this->cols, this->K, cos_theta, sin_theta, cos_phi, sin_phi);
+
+        // Create the derivative kernels
+        getDerivKernels(kx_dx_, ky_dx_, 1, 0, this->windowSize, true, this->dtype);
+        getDerivKernels(kx_dy_, ky_dy_, 0, 1, this->windowSize, true, this->dtype);
+
+        // Get the mapping function for SRI
+        float min_theta = (float)std::asin(sin_theta(0, 0)), max_theta = (float)std::asin(sin_theta(0, this->cols - 1));
+        float min_phi = (float)std::asin(sin_phi(0, this->cols / 2 - 1)), max_phi = (float)std::asin(sin_phi(this->rows - 1, this->cols / 2 - 1));
+
+        std::vector<Point3f> points3d(this->cols * this->rows);
+        R_hat_.create(this->rows, this->cols);
+        phi_step_ = float(max_phi - min_phi) / (this->rows - 1);
+        theta_step_ = float(max_theta - min_theta) / (this->cols - 1);
+        for (int phi_int = 0, k = 0; phi_int < this->rows; ++phi_int)
+        {
+            float phi = min_phi + phi_int * phi_step_;
+            float phi_sin = std::sin(phi), phi_cos = std::cos(phi);
+            for (int theta_int = 0; theta_int < this->cols; ++theta_int, ++k)
+            {
+                float theta = min_theta + theta_int * theta_step_;
+                float theta_sin = std::sin(theta), theta_cos = std::cos(theta);
+                // Store the 3d point to project it later
+                Point3f pp(theta_sin * phi_cos, phi_sin, theta_cos * phi_cos);
+                points3d[k] = pp;
+
+                // Cache the rotation matrix and negate it
+                Matx<T, 3, 3> mat = Matx<T, 3, 3> (0, 1, 0,  0, 0, 1,  1, 0, 0) *
+                                    Matx<T, 3, 3> (theta_cos, -theta_sin, 0,  theta_sin, theta_cos, 0,  0, 0, 1) *
+                                    Matx<T, 3, 3> (phi_cos, 0, -phi_sin,  0, 1, 0,  phi_sin, 0, phi_cos);
+
+                for (unsigned char i = 0; i < 3; ++i)
+                    mat(i, 1) = mat(i, 1) / phi_cos;
+                // The second part of the matrix is never explained in the paper ... but look at the wikipedia normal article
+                mat(0, 0) = mat(0, 0) - 2 * pp.x;
+                mat(1, 0) = mat(1, 0) - 2 * pp.y;
+                mat(2, 0) = mat(2, 0) - 2 * pp.z;
+
+                R_hat_(phi_int, theta_int) = Vec9T(mat.val);
+            }
+        }
+
+        map_.create(this->rows, this->cols);
+        projectPoints(points3d, Mat(3, 1, CV_32FC1, Scalar::all(0.0f)), Mat(3, 1, CV_32FC1, Scalar::all(0.0f)), this->K, Mat(), map_);
+        map_ = map_.reshape(2, this->rows);
+        convertMaps(map_, Mat(), xy_, fxy_, CV_16SC2);
+
+        //map for converting from Spherical coordinate space to Euclidean space
+        euclideanMap_.create(this->rows, this->cols);
+        Matx<T, 3, 3> km(this->K);
+        float invFx = (float)(1.0f / km(0, 0)), cx = (float)(km(0, 2));
+        double invFy = 1.0f / (km(1, 1)), cy = km(1, 2);
+        for (int i = 0; i < this->rows; i++)
+        {
+            float y = (float)((i - cy) * invFy);
+            for (int j = 0; j < this->cols; j++)
+            {
+                float x = (j - cx) * invFx;
+                float theta = std::atan(x);
+                float phi = std::asin(y / std::sqrt(x * x + y * y + 1.0f));
+
+                euclideanMap_(i, j) = Vec2f((theta - min_theta) / theta_step_, (phi - min_phi) / phi_step_);
+            }
+        }
+        //convert map to 2 maps in short format for increasing speed in remap function
+        convertMaps(euclideanMap_, Mat(), invxy_, invfxy_, CV_16SC2);
+
+        // Update the kernels: the steps are due to the fact that derivatives will be computed on a grid where
+        // the step is not 1. Only need to do it on one dimension as it computes derivatives in only one direction
+        kx_dx_ /= theta_step_;
+        ky_dy_ /= phi_step_;
+
+        this->cacheIsDirty = false;
+    }
+
+    /** Compute the normals
+     * @param r
+     * @return
+     */
+    virtual void compute(const Mat& in, Mat& normals_out) const CV_OVERRIDE
+    {
+        const Mat_<T>& r_non_interp = in;
+
+        // Interpolate the radial image to make derivatives meaningful
+        Mat_<T> r;
+        // higher quality remapping does not help here
+        remap(r_non_interp, r, xy_, fxy_, INTER_LINEAR);
+
+        // Compute the derivatives with respect to theta and phi
+        // TODO add bilateral filtering (as done in kinfu)
+        Mat_<T> r_theta, r_phi;
+        sepFilter2D(r, r_theta, r.depth(), kx_dx_, ky_dx_);
+        //current OpenCV version sometimes corrupts r matrix after second call of sepFilter2D
+        //it depends on resolution, be careful
+        sepFilter2D(r, r_phi, r.depth(), kx_dy_, ky_dy_);
+
+        // Fill the result matrix
+        Mat_<Vec4T> normals(this->rows, this->cols);
+
+        const T* r_theta_ptr = r_theta[0], * r_theta_ptr_end = r_theta_ptr + this->rows * this->cols;
+        const T* r_phi_ptr = r_phi[0];
+        const Mat33T* R = reinterpret_cast<const Mat33T*>(R_hat_[0]);
+        const T* r_ptr = r[0];
+        Vec4T* normal = normals[0];
+        for (; r_theta_ptr != r_theta_ptr_end; ++r_theta_ptr, ++r_phi_ptr, ++R, ++r_ptr, ++normal)
+        {
+            if (cvIsNaN(*r_ptr))
+            {
+                (*normal)[0] = *r_ptr;
+                (*normal)[1] = *r_ptr;
+                (*normal)[2] = *r_ptr;
+                (*normal)[3] = 0;
+            }
+            else
+            {
+                T r_theta_over_r = (*r_theta_ptr) / (*r_ptr);
+                T r_phi_over_r = (*r_phi_ptr) / (*r_ptr);
+                // R(1,1) is 0
+                signNormal((*R)(0, 0) + (*R)(0, 1) * r_theta_over_r + (*R)(0, 2) * r_phi_over_r,
+                           (*R)(1, 0) + (*R)(1, 2) * r_phi_over_r,
+                           (*R)(2, 0) + (*R)(2, 1) * r_theta_over_r + (*R)(2, 2) * r_phi_over_r, *normal);
+            }
+        }
+
+        remap(normals, normals_out, invxy_, invfxy_, INTER_LINEAR);
+        normal = normals_out.ptr<Vec4T>(0);
+        Vec4T* normal_end = normal + this->rows * this->cols;
+        for (; normal != normal_end; ++normal)
+            signNormal((*normal)[0], (*normal)[1], (*normal)[2], *normal);
+    }
+
+    // Cached data
+    /** Stores R */
+    mutable Mat_<Vec9T> R_hat_;
+    mutable float phi_step_, theta_step_;
+
+    /** Derivative kernels */
+    mutable Mat kx_dx_, ky_dx_, kx_dy_, ky_dy_;
+    /** mapping function to get an SRI image */
+    mutable Mat_<Vec2f> map_;
+    mutable Mat xy_, fxy_;
+
+    mutable Mat_<Vec2f> euclideanMap_;
+    mutable Mat invxy_, invfxy_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/* Uses the simpliest possible method for normals calculation: calculates cross product between two vectors
+(pointAt(x+1, y) - pointAt(x, y)) and (pointAt(x, y+1) - pointAt(x, y)) */
+
+template<typename DataType>
+class CrossProduct : public RgbdNormalsImpl<DataType>
+{
+public:
+    typedef Vec<DataType, 3> Vec3T;
+    typedef Vec<DataType, 4> Vec4T;
+    typedef Point3_<DataType> Point3T;
+
+    CrossProduct(int _rows, int _cols, int _windowSize, const Mat& _K) :
+        RgbdNormalsImpl<DataType>(_rows, _cols, _windowSize, _K, RgbdNormals::RGBD_NORMALS_METHOD_CROSS_PRODUCT)
+    { }
+
+    /** Compute cached data
+     */
+    virtual void cache() const CV_OVERRIDE
+    {
+        this->cacheIsDirty = false;
+    }
+
+    static inline Point3T fromVec(Vec4T v)
+    {
+        return {v[0], v[1], v[2]};
+    }
+
+    static inline Vec4T toVec4(Point3T p)
+    {
+        return {p.x, p.y, p.z, 0};
+    }
+
+    static inline bool haveNaNs(Point3T p)
+    {
+        return cvIsNaN(p.x) || cvIsNaN(p.y) || cvIsNaN(p.z);
+    }
+
+    /** Compute the normals
+     * @param points reprojected depth points
+     * @param normals generated normals
+     * @return
+     */
+    virtual void compute(const Mat& points, Mat& normals) const CV_OVERRIDE
+    {
+        for(int y = 0; y < this->rows; y++)
+        {
+            const Vec4T* ptsRow0 = points.ptr<Vec4T>(y);
+            const Vec4T* ptsRow1 = (y < this->rows - 1) ? points.ptr<Vec4T>(y + 1) : nullptr;
+            Vec4T *normRow = normals.ptr<Vec4T>(y);
+
+            for (int x = 0; x < this->cols; x++)
+            {
+                Point3T v00 = fromVec(ptsRow0[x]);
+                const float qnan = std::numeric_limits<float>::quiet_NaN();
+                Point3T n(qnan, qnan, qnan);
+
+                if ((x < this->cols - 1) && (y < this->rows - 1) && !haveNaNs(v00))
+                {
+                    Point3T v01 = fromVec(ptsRow0[x + 1]);
+                    Point3T v10 = fromVec(ptsRow1[x]);
+
+                    if (!haveNaNs(v01) && !haveNaNs(v10))
+                    {
+                        Vec3T vec = (v10 - v00).cross(v01 - v00);
+                        n = normalize(vec);
+                    }
+                }
+
+                normRow[x] = toVec4(n);
+            }
+        }
+    }
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+Ptr<RgbdNormals> RgbdNormals::create(int rows, int cols, int depth, InputArray K, int windowSize, float diffThreshold, RgbdNormalsMethod method)
+{
+    CV_Assert(rows > 0 && cols > 0 && (depth == CV_32F || depth == CV_64F));
+    CV_Assert(windowSize == 1 || windowSize == 3 || windowSize == 5 || windowSize == 7);
+    CV_Assert(K.cols() == 3 && K.rows() == 3 && (K.depth() == CV_32F || K.depth() == CV_64F));
+
+    Mat mK = K.getMat();
+    Ptr<RgbdNormals> ptr;
+    switch (method)
+    {
+    case (RGBD_NORMALS_METHOD_FALS):
+    {
+        if (depth == CV_32F)
+            ptr = makePtr<FALS<float> >(rows, cols, windowSize, mK);
+        else
+            ptr = makePtr<FALS<double>>(rows, cols, windowSize, mK);
+        break;
+    }
+    case (RGBD_NORMALS_METHOD_LINEMOD):
+    {
+        CV_Assert(diffThreshold > 0);
+        if (depth == CV_32F)
+            ptr = makePtr<LINEMOD<float> >(rows, cols, windowSize, mK, diffThreshold);
+        else
+            ptr = makePtr<LINEMOD<double>>(rows, cols, windowSize, mK, diffThreshold);
+        break;
+    }
+    case RGBD_NORMALS_METHOD_SRI:
+    {
+        if (depth == CV_32F)
+            ptr = makePtr<SRI<float> >(rows, cols, windowSize, mK);
+        else
+            ptr = makePtr<SRI<double>>(rows, cols, windowSize, mK);
+        break;
+    }
+    case RGBD_NORMALS_METHOD_CROSS_PRODUCT:
+    {
+        if (depth == CV_32F)
+            ptr = makePtr<CrossProduct<float> >(rows, cols, windowSize, mK);
+        else
+            ptr = makePtr<CrossProduct<double>>(rows, cols, windowSize, mK);
+        break;
+    }
+    default:
+        CV_Error(Error::StsBadArg, "Unknown normals compute algorithm");
+    }
+
+    return ptr;
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/octree.cpp b/upstream/opencv/modules/ptcloud/src/octree.cpp
new file mode 100644
index 0000000..8ad57f7
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/octree.cpp
@@ -0,0 +1,695 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "octree.hpp"
+#include "opencv2/geometry/3d.hpp"
+
+namespace cv{
+
+OctreeNode::OctreeNode() :
+    children(),
+    depth(0),
+    size(0),
+    origin(0,0,0),
+    neigh(),
+    parentIndex(-1)
+{ }
+
+OctreeNode::OctreeNode(int _depth, double _size, const Point3f &_origin, int _parentIndex) :
+    children(),
+    depth(_depth),
+    size(_size),
+    origin(_origin),
+    neigh(),
+    parentIndex(_parentIndex)
+{ }
+
+bool OctreeNode::empty() const
+{
+    if(this->isLeaf)
+    {
+        if(this->pointList.empty())
+            return true;
+        else
+            return false;
+    }
+    else
+    {
+        for(size_t i = 0; i < 8; i++)
+        {
+            if(!this->children[i].empty())
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+
+bool OctreeNode::isPointInBound(const Point3f& _point) const
+{
+    Point3f eps;
+    eps.x = std::max(std::abs(_point.x), std::abs(this->origin.x));
+    eps.y = std::max(std::abs(_point.y), std::abs(this->origin.y));
+    eps.z = std::max(std::abs(_point.z), std::abs(this->origin.z));
+    eps *= std::numeric_limits<float>::epsilon();
+    Point3f ptEps = _point + eps;
+    Point3f upPt = this->origin + eps + Point3f {(float)this->size, (float)this->size, (float)this->size};
+
+    return (ptEps.x >= this->origin.x) &&
+           (ptEps.y >= this->origin.y) &&
+           (ptEps.z >= this->origin.z) &&
+           (_point.x <= upPt.x) &&
+           (_point.y <= upPt.y) &&
+           (_point.z <= upPt.z);
+}
+
+struct Octree::Impl
+{
+public:
+    Impl() : Impl(0, 0, {0, 0, 0}, 0, false) { }
+
+    Impl(int _maxDepth, double _size, const Point3f& _origin, double _resolution,
+         bool _hasColor) :
+        maxDepth(_maxDepth),
+        size(_size),
+        origin(_origin),
+        resolution(_resolution),
+        hasColor(_hasColor)
+    { }
+
+    ~Impl() { }
+
+    void fill(bool useResolution, InputArray pointCloud, InputArray colorAttribute);
+    bool insertPoint(const Point3f& point, const Point3f &color);
+
+    // The pointer to Octree root node
+    Ptr <OctreeNode> rootNode = nullptr;
+    //! Max depth of the Octree
+    int maxDepth;
+    //! The size of the cube
+    double size;
+    //! The origin coordinate of root node
+    Point3f origin;
+    //! The size of the leaf node
+    double resolution;
+    //! Whether the point cloud has a color attribute
+    bool hasColor;
+};
+
+Octree::Octree() :
+    p(makePtr<Impl>())
+{ }
+
+Ptr<Octree> Octree::createWithDepth(int maxDepth, double size, const Point3f& origin, bool withColors)
+{
+    CV_Assert(maxDepth > 0);
+    CV_Assert(size > 0);
+
+    Ptr<Octree> octree = makePtr<Octree>();
+    octree->p = makePtr<Impl>(maxDepth, size, origin, /*resolution*/ 0, withColors);
+    return octree;
+}
+
+Ptr<Octree> Octree::createWithDepth(int maxDepth, InputArray pointCloud, InputArray colors)
+{
+    CV_Assert(maxDepth > 0);
+
+    Ptr<Octree> octree = makePtr<Octree>();
+    octree->p->maxDepth = maxDepth;
+    octree->p->fill(/* useResolution */ false, pointCloud, colors);
+    return octree;
+}
+
+Ptr<Octree> Octree::createWithResolution(double resolution, double size, const Point3f& origin, bool withColors)
+{
+    CV_Assert(resolution > 0);
+    CV_Assert(size > 0);
+
+    Ptr<Octree> octree = makePtr<Octree>();
+    octree->p = makePtr<Impl>(/*maxDepth*/ 0, size, origin, resolution, withColors);
+    return octree;
+}
+
+Ptr<Octree> Octree::createWithResolution(double resolution, InputArray pointCloud, InputArray colors)
+{
+    CV_Assert(resolution > 0);
+
+    Ptr<Octree> octree = makePtr<Octree>();
+    octree->p->resolution = resolution;
+    octree->p->fill(/* useResolution */ true, pointCloud, colors);
+    return octree;
+}
+
+Octree::~Octree() { }
+
+bool Octree::insertPoint(const Point3f& point, const Point3f &color)
+{
+    return p->insertPoint(point, color);
+}
+
+bool Octree::Impl::insertPoint(const Point3f& point, const Point3f &color)
+{
+    size_t depthMask = (size_t)(1ULL << (this->maxDepth - 1));
+
+    if(this->rootNode.empty())
+    {
+        this->rootNode = new OctreeNode( 0, this->size, this->origin, -1);
+    }
+
+    bool pointInBoundFlag = this->rootNode->isPointInBound(point);
+    if(this->rootNode->depth == 0 && !pointInBoundFlag)
+    {
+        return false;
+    }
+
+    OctreeKey key((size_t)floor((point.x - this->origin.x) / this->resolution),
+                  (size_t)floor((point.y - this->origin.y) / this->resolution),
+                  (size_t)floor((point.z - this->origin.z) / this->resolution));
+
+    Ptr<OctreeNode> node = this->rootNode;
+    while (node->depth != maxDepth)
+    {
+        double childSize = node->size * 0.5;
+
+        // calculate the index and the origin of child.
+        size_t childIndex = key.findChildIdxByMask(depthMask);
+        size_t xIndex = (childIndex & 1) ? 1 : 0;
+        size_t yIndex = (childIndex & 2) ? 1 : 0;
+        size_t zIndex = (childIndex & 4) ? 1 : 0;
+
+        Point3f childOrigin = node->origin + Point3f(float(xIndex), float(yIndex), float(zIndex)) * float(childSize);
+
+        Ptr<OctreeNode> &childPtr = node->children[childIndex];
+        if (!childPtr)
+        {
+            childPtr = new OctreeNode(node->depth + 1, childSize, childOrigin, int(childIndex));
+            childPtr->parent = node;
+        }
+
+        node = childPtr;
+        depthMask = depthMask >> 1;
+    }
+
+    node->isLeaf = true;
+    node->pointList.push_back(point);
+    node->colorList.push_back(color);
+
+    return true;
+}
+
+
+static Vec6f getBoundingBox(const Mat& points)
+{
+    const float mval = std::numeric_limits<float>::max();
+    Vec6f bb(mval, mval, mval, -mval, -mval, -mval);
+
+    for (int i = 0; i < (int)points.total(); i++)
+    {
+        Point3f pt = points.at<Point3f>(i);
+        bb[0] = min(bb[0], pt.x);
+        bb[1] = min(bb[1], pt.y);
+        bb[2] = min(bb[2], pt.z);
+        bb[3] = max(bb[3], pt.x);
+        bb[4] = max(bb[4], pt.y);
+        bb[5] = max(bb[5], pt.z);
+    }
+
+    return bb;
+}
+
+void Octree::Impl::fill(bool useResolution, InputArray _points, InputArray _colors)
+{
+    CV_CheckFalse(_points.empty(), "No points provided");
+
+    Mat points, colors;
+    int nPoints = 0, nColors = 0;
+
+    int pointType = _points.type();
+    CV_Assert(pointType == CV_32FC1 || pointType == CV_32FC3);
+    points = _points.getMat();
+    // transform 3xN matrix to Nx3, except 3x3
+    if ((_points.channels() == 1) && (_points.rows() == 3) && (_points.cols() != 3))
+    {
+        points = points.t();
+    }
+    // This transposition is performed on 1xN matrix so it's almost free in terms of performance
+    points = points.reshape(3, 1).t();
+    nPoints = (int)points.total();
+
+    if (!_colors.empty())
+    {
+        int colorType = _colors.type();
+        CV_Assert(colorType == CV_32FC1 || colorType == CV_32FC3);
+        colors = _colors.getMat();
+        // transform 3xN matrix to Nx3, except 3x3
+        if ((_colors.channels() == 1) && (_colors.rows() == 3) && (_colors.cols() != 3))
+        {
+            colors = colors.t();
+        }
+        colors = colors.reshape(3, 1).t();
+        nColors = (int)colors.total();
+
+        CV_Assert(nColors == nPoints);
+        this->hasColor = true;
+    }
+
+    Vec6f bbox = getBoundingBox(points);
+    Point3f minBound(bbox[0], bbox[1], bbox[2]);
+    Point3f maxBound(bbox[3], bbox[4], bbox[5]);
+
+    double maxSize = max(max(maxBound.x - minBound.x, maxBound.y - minBound.y), maxBound.z - minBound.z);
+
+    // Extend maxSize to the closest power of 2 that exceeds it for bit operations
+    maxSize = double(1 << int(ceil(log2(maxSize))));
+
+    // to calculate maxDepth from resolution or vice versa
+    if (useResolution)
+    {
+        this->maxDepth = (int)ceil(log2(maxSize / this->resolution));
+    }
+    else
+    {
+        this->resolution = (maxSize / (1 << (this->maxDepth + 1)));
+    }
+
+    this->size = (1 << this->maxDepth) * this->resolution;
+    this->origin = Point3f(float(floor(minBound.x / this->resolution) * this->resolution),
+                           float(floor(minBound.y / this->resolution) * this->resolution),
+                           float(floor(minBound.z / this->resolution) * this->resolution));
+
+    // Insert every point in PointCloud data.
+    for (int idx = 0; idx < nPoints; idx++)
+    {
+        Point3f pt = points.at<Point3f>(idx);
+        Point3f insertColor = this->hasColor ? colors.at<Point3f>(idx) : Point3f { };
+        if (!this->insertPoint(pt, insertColor))
+        {
+            CV_Error(Error::StsBadArg, "The point is out of boundary!");
+        }
+    }
+}
+
+
+void Octree::clear()
+{
+    p = makePtr<Impl>();
+}
+
+bool Octree::empty() const
+{
+    return p->rootNode.empty();
+}
+
+
+bool Octree::isPointInBound(const Point3f& _point) const
+{
+    return p->rootNode->isPointInBound(_point);
+}
+
+bool Octree::deletePoint(const Point3f& point)
+{
+    OctreeKey key = OctreeKey((size_t)floor((point.x - this->p->origin.x) / p->resolution),
+                              (size_t)floor((point.y - this->p->origin.y) / p->resolution),
+                              (size_t)floor((point.z - this->p->origin.z) / p->resolution));
+    size_t depthMask = (size_t)1 << (p->maxDepth - 1);
+
+    Ptr<OctreeNode> node = p->rootNode;
+    while(node)
+    {
+        if (node->empty())
+        {
+            node = nullptr;
+        }
+        else if (node->isLeaf)
+        {
+            const float eps = 1e-9f;
+            bool found = std::any_of(node->pointList.begin(), node->pointList.end(),
+                [point, eps](const Point3f& pt) -> bool
+                {
+                    return abs(point.x - pt.x) < eps &&
+                           abs(point.y - pt.y) < eps &&
+                           abs(point.z - pt.z) < eps;
+                });
+            if (!found)
+                node = nullptr;
+            break;
+        }
+        else
+        {
+            node = node->children[key.findChildIdxByMask(depthMask)];
+            depthMask = depthMask >> 1;
+        }
+    }
+
+    if(!node)
+        return false;
+
+    const float eps = 1e-9f;
+
+    // we've found a leaf node and delete all verts equal to given one
+    size_t ctr = 0;
+    while (!node->pointList.empty() && ctr < node->pointList.size())
+    {
+        if (abs(point.x - node->pointList[ctr].x) < eps &&
+            abs(point.y - node->pointList[ctr].y) < eps &&
+            abs(point.z - node->pointList[ctr].z) < eps)
+        {
+            node->pointList.erase(node->pointList.begin() + ctr);
+        }
+        else
+        {
+            ctr++;
+        }
+    }
+
+    if (node->pointList.empty())
+    {
+        // empty node and its empty parents should be removed
+        OctreeNode *parentPtr = node->parent;
+        int parentdIdx = node->parentIndex;
+
+        while (parentPtr)
+        {
+            parentPtr->children[parentdIdx].release();
+
+            // check if all children were deleted
+            bool deleteFlag = true;
+            for (size_t i = 0; i < 8; i++)
+            {
+                if (!parentPtr->children[i].empty())
+                {
+                    deleteFlag = false;
+                    break;
+                }
+            }
+
+            if (deleteFlag)
+            {
+                // we're at empty node, going up
+                parentdIdx = parentPtr->parentIndex;
+                parentPtr = parentPtr->parent;
+            }
+            else
+            {
+                // reached first non-empty node, stopping
+                parentPtr = nullptr;
+            }
+        }
+    }
+    return true;
+}
+
+
+void Octree::getPointCloudByOctree(OutputArray restorePointCloud, OutputArray restoreColor)
+{
+    Ptr<OctreeNode> root = p->rootNode;
+    double resolution = p->resolution;
+    std::vector<Point3f> outPts, outColors;
+
+    typedef std::tuple<Ptr<OctreeNode>, size_t, size_t, size_t> stack_element;
+    std::stack<stack_element> toCheck;
+    toCheck.push(stack_element(root, 0, 0, 0));
+    while (!toCheck.empty())
+    {
+        auto top = toCheck.top();
+        toCheck.pop();
+        Ptr<OctreeNode> node = std::get<0>(top);
+        size_t x_key = std::get<1>(top);
+        size_t y_key = std::get<2>(top);
+        size_t z_key = std::get<3>(top);
+
+        if (node->isLeaf)
+        {
+            outPts.emplace_back(
+                    (float) (resolution * x_key) + (float) (resolution * 0.5) + p->origin.x,
+                    (float) (resolution * y_key) + (float) (resolution * 0.5) + p->origin.y,
+                    (float) (resolution * z_key) + (float) (resolution * 0.5) + p->origin.z);
+            if (p->hasColor)
+            {
+                Point3f avgColor { };
+                for (const auto& c : node->colorList)
+                {
+                    avgColor += c;
+                }
+                avgColor *= (1.f/(float)node->colorList.size());
+                outColors.emplace_back(avgColor);
+            }
+        }
+        else
+        {
+            unsigned char x_mask = 1;
+            unsigned char y_mask = 2;
+            unsigned char z_mask = 4;
+            for (unsigned char i = 0; i < 8; i++)
+            {
+                size_t x_copy = x_key;
+                size_t y_copy = y_key;
+                size_t z_copy = z_key;
+                if (!node->children[i].empty())
+                {
+                    size_t x_offSet = !!(x_mask & i);
+                    size_t y_offSet = !!(y_mask & i);
+                    size_t z_offSet = !!(z_mask & i);
+                    x_copy = (x_copy << 1) | x_offSet;
+                    y_copy = (y_copy << 1) | y_offSet;
+                    z_copy = (z_copy << 1) | z_offSet;
+                    toCheck.push(stack_element(node->children[i], x_copy, y_copy, z_copy));
+                }
+            }
+        }
+    }
+
+    if (restorePointCloud.needed())
+    {
+        Mat(outPts).copyTo(restorePointCloud);
+    }
+    if (restoreColor.needed())
+    {
+        Mat(outColors).copyTo(restoreColor);
+    }
+}
+
+
+static float SquaredDistance(const Point3f& query, const Point3f& origin)
+{
+    Point3f diff = query - origin;
+    return diff.dot(diff);
+}
+
+bool OctreeNode::overlap(const Point3f& query, float squareRadius) const
+{
+    float halfSize = float(this->size * 0.5);
+    Point3f center = this->origin + Point3f( halfSize, halfSize, halfSize );
+
+    float dist = SquaredDistance(center, query);
+    float temp = float(this->size) * float(this->size) * 3.0f;
+
+    return ( dist + dist * std::numeric_limits<float>::epsilon() ) <= float(temp * 0.25f + squareRadius + sqrt(temp * squareRadius)) ;
+}
+
+
+int Octree::radiusNNSearch(const Point3f& query, float radius, OutputArray pointSet, OutputArray squareDistSet) const
+{
+    return this->radiusNNSearch(query, radius, pointSet, noArray(), squareDistSet);
+}
+
+int Octree::radiusNNSearch(const Point3f& query, float radius, OutputArray points, OutputArray colors, OutputArray squareDists) const
+{
+    std::vector<Point3f> outPoints, outColors;
+    std::vector<float> outSqDists;
+
+    if (!p->rootNode.empty())
+    {
+        float squareRadius = radius * radius;
+
+        std::vector<std::tuple<float, Point3f, Point3f>> candidatePoints;
+
+        std::stack<Ptr<OctreeNode>> toCheck;
+        toCheck.push(p->rootNode);
+
+        while (!toCheck.empty())
+        {
+            Ptr<OctreeNode> node = toCheck.top();
+            toCheck.pop();
+            for(size_t i = 0; i < 8; i++)
+            {
+                Ptr<OctreeNode> child = node->children[i];
+                if( child && child->overlap(query, squareRadius))
+                {
+                    if(child->isLeaf)
+                    {
+                        for(size_t j = 0; j < child->pointList.size(); j++)
+                        {
+                            Point3f pt = child->pointList[j];
+                            Point3f col;
+                            if (!child->colorList.empty())
+                            {
+                                col = child->colorList[j];
+                            }
+                            float dist = SquaredDistance(pt, query);
+                            if(dist + dist * std::numeric_limits<float>::epsilon() <= squareRadius)
+                            {
+                                candidatePoints.emplace_back(dist, pt, col);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        toCheck.push(child);
+                    }
+                }
+            }
+        }
+
+        for (size_t i = 0; i < candidatePoints.size(); i++)
+        {
+            auto cp = candidatePoints[i];
+            outSqDists.push_back(std::get<0>(cp));
+            outPoints.push_back(std::get<1>(cp));
+            outColors.push_back(std::get<2>(cp));
+        }
+    }
+
+    if (points.needed())
+    {
+        Mat(outPoints).copyTo(points);
+    }
+    if (colors.needed())
+    {
+        CV_Assert(this->p->hasColor);
+        Mat(outColors).copyTo(colors);
+    }
+    if (squareDists.needed())
+    {
+        Mat(outSqDists).copyTo(squareDists);
+    }
+
+    return int(outPoints.size());
+}
+
+
+void OctreeNode::KNNSearchRecurse(const Point3f& query, const int K,
+                                  float& smallestDist, std::vector<std::tuple<float, Point3f, Point3f>>& candidatePoint) const
+{
+    std::vector<std::pair<float, int>> priorityQue;
+
+    // Add the non-empty OctreeNode to priorityQue
+    for(size_t i = 0; i < 8; i++)
+    {
+        Ptr<OctreeNode> child = this->children[i];
+        if(child)
+        {
+            float halfSize = float(child->size * 0.5);
+
+            Point3f center = child->origin + Point3f(halfSize, halfSize, halfSize);
+
+            float dist = SquaredDistance(query, center);
+            priorityQue.emplace_back(dist, int(i));
+        }
+    }
+
+    std::sort(priorityQue.rbegin(), priorityQue.rend(),
+        [](const std::pair<float, int>& a, const std::pair<float, int>& b) -> bool
+        {
+            return std::get<0>(a) < std::get<0>(b);
+        });
+    Ptr<OctreeNode> child = this->children[std::get<1>(priorityQue.back())];
+
+    while (!priorityQue.empty() && child->overlap(query, smallestDist))
+    {
+        if (!child->isLeaf)
+        {
+            child->KNNSearchRecurse(query, K, smallestDist, candidatePoint);
+        }
+        else
+        {
+            for (size_t i = 0; i < child->pointList.size(); i++)
+            {
+                float dist = SquaredDistance(child->pointList[i], query);
+
+                if ( dist + dist * std::numeric_limits<float>::epsilon() <= smallestDist )
+                {
+                    Point3f pt = child->pointList[i];
+                    Point3f col { };
+                    if (child->colorList.empty())
+                    {
+                        col = child->colorList[i];
+                    }
+                    candidatePoint.emplace_back(dist, pt, col);
+                }
+            }
+
+            std::sort(candidatePoint.begin(), candidatePoint.end(),
+                [](const std::tuple<float, Point3f, Point3f>& a, const std::tuple<float, Point3f, Point3f>& b) -> bool
+                {
+                    return std::get<0>(a) < std::get<0>(b);
+                }
+            );
+
+            if (int(candidatePoint.size()) > K)
+            {
+                candidatePoint.resize(K);
+            }
+
+            if (int(candidatePoint.size()) == K)
+            {
+                smallestDist = std::get<0>(candidatePoint.back());
+            }
+        }
+
+        priorityQue.pop_back();
+
+        // To next child
+        if(!priorityQue.empty())
+        {
+            child = this->children[std::get<1>(priorityQue.back())];
+        }
+    }
+}
+
+
+void Octree::KNNSearch(const Point3f &query, const int K, OutputArray pointSet, OutputArray squareDistSet) const
+{
+    this->KNNSearch(query, K, pointSet, noArray(), squareDistSet);
+}
+
+void Octree::KNNSearch(const Point3f &query, const int K, OutputArray points, OutputArray colors, OutputArray squareDists) const
+{
+    std::vector<Point3f> outPoints, outColors;
+    std::vector<float> outSqDists;
+
+    if (!p->rootNode.empty())
+    {
+        std::vector<std::tuple<float, Point3f, Point3f>> candidatePoints;
+        float smallestDist = std::numeric_limits<float>::max();
+
+        p->rootNode->KNNSearchRecurse(query, K, smallestDist, candidatePoints);
+
+        for(size_t i = 0; i < candidatePoints.size(); i++)
+        {
+            auto cp = candidatePoints[i];
+            outSqDists.push_back(std::get<0>(cp));
+            outPoints.push_back(std::get<1>(cp));
+            outColors.push_back(std::get<2>(cp));
+        }
+    }
+
+    if (points.needed())
+    {
+        Mat(outPoints).copyTo(points);
+    }
+    if (colors.needed())
+    {
+        CV_Assert(this->p->hasColor);
+        Mat(outColors).copyTo(colors);
+    }
+    if (squareDists.needed())
+    {
+        Mat(outSqDists).copyTo(squareDists);
+    }
+}
+}
diff --git a/upstream/opencv/modules/ptcloud/src/octree.hpp b/upstream/opencv/modules/ptcloud/src/octree.hpp
new file mode 100644
index 0000000..481682c
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/octree.hpp
@@ -0,0 +1,181 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2021, Huawei Technologies Co., Ltd. All rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Author: Zihao Mu <zihaomu6@gmail.com>
+//         Liangqian Kong <chargerKong@126.com>
+//         Longbu Wang <riskiest@gmail.com>
+
+#ifndef OPENCV_3D_SRC_OCTREE_HPP
+#define OPENCV_3D_SRC_OCTREE_HPP
+
+#include <vector>
+#include <array>
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+// Forward declaration
+class OctreeKey;
+
+/** @brief OctreeNode for Octree.
+
+The class OctreeNode represents the node of the octree. Each node contains 8 children, which are used to divide the
+space cube into eight parts. Each octree node represents a cube.
+And these eight children will have a fixed order, the order is described as follows:
+
+For illustration, assume,
+    rootNode: origin == (0, 0, 0), size == 2
+ Then,
+    children[0]: origin == (0, 0, 0), size == 1
+    children[1]: origin == (1, 0, 0), size == 1, along X-axis next to child 0
+    children[2]: origin == (0, 1, 0), size == 1, along Y-axis next to child 0
+    children[3]: origin == (1, 1, 0), size == 1, in X-Y plane
+    children[4]: origin == (0, 0, 1), size == 1, along Z-axis next to child 0
+    children[5]: origin == (1, 0, 1), size == 1, in X-Z plane
+    children[6]: origin == (0, 1, 1), size == 1, in Y-Z plane
+    children[7]: origin == (1, 1, 1), size == 1, furthest from child 0
+
+There are two kinds of nodes in an octree, intermediate nodes and leaf nodes, which are distinguished by isLeaf.
+Intermediate nodes are used to contain leaf nodes, and leaf nodes will contain pointers to all pointcloud data
+within the node, which will be used for octree indexing and mapping from point clouds to octree. Note that,
+in an octree, each leaf node contains at least one point cloud data. Similarly, every intermediate OctreeNode
+contains at least one non-empty child pointer, except for the root node.
+*/
+class OctreeNode
+{
+public:
+
+    /**
+    * There are multiple constructors to create OctreeNode.
+    * */
+    OctreeNode();
+
+    /** @overload
+    *
+    * @param _depth The depth of the current node. The depth of the root node is 0, and the leaf node is equal
+    * to the depth of Octree.
+    * @param _size The length of the OctreeNode. In space, every OctreeNode represents a cube.
+    * @param _origin The absolute coordinates of the center of the cube.
+    * @param _parentIndex The serial number of the child of the current node in the parent node,
+    * the range is (-1~7). Among them, only the root node's _parentIndex is -1.
+    */
+    OctreeNode(int _depth, double _size, const Point3f& _origin, int _parentIndex);
+
+    //! returns true if the rootNode is NULL.
+    bool empty() const;
+
+    bool isPointInBound(const Point3f& _point) const;
+
+    bool overlap(const Point3f& query, float squareRadius) const;
+
+    void KNNSearchRecurse(const Point3f& query, const int K, float& smallestDist, std::vector<std::tuple<float, Point3f, Point3f>>& candidatePoint) const;
+
+    //! Contains 8 pointers to its 8 children.
+    std::array<Ptr<OctreeNode>, 8> children;
+
+    //! Point to the parent node of the current node. The root node has no parent node and the value is NULL.
+    OctreeNode* parent;
+
+    //! The depth of the current node. The depth of the root node is 0, and the leaf node is equal to the depth of Octree.
+    int depth;
+
+    //! The length of the OctreeNode. In space, every OctreeNode represents a cube.
+    double size;
+
+    //! Absolute coordinates of the smallest point of the cube.
+    //! And the center of cube is `center = origin + Point3f(size/2, size/2, size/2)`.
+    Point3f origin;
+
+    //! RAHTCoefficient of octree node, used for color attribute compression.
+    Point3f RAHTCoefficient = { };
+
+    /**  The list of 6 adjacent neighbor node.
+        *    index mapping:
+        *     +z                        [101]
+        *      |                          |    [110]
+        *      |                          |  /
+        *      O-------- +x    [001]----{000} ----[011]
+        *     /                       /   |
+        *    /                   [010]    |
+        *  +y                           [100]
+        *  index 000, 111 are reserved
+        */
+    std::array<Ptr<OctreeNode>, 8> neigh;
+
+    /**  The serial number of the child of the current node in the parent node,
+    * the range is (-1~7). Among them, only the root node's _parentIndex is -1.
+    */
+    int parentIndex;
+
+    //! If the OctreeNode is LeafNode.
+    bool isLeaf = false;
+
+    //! Contains pointers to all point cloud data in this node.
+    std::vector<Point3f> pointList;
+
+    //! color attribute of octree node.
+    std::vector<Point3f> colorList;
+};
+
+/** @brief Key for pointCloud, used to compute the child node index through bit operations.
+
+When building the octree, the point cloud data is firstly voxelized/discretized: by inserting
+all the points into a voxel coordinate system. For example, when resolution is set to 0.01, a point
+with coordinate Point3f(0.251,0.502,0.753) would be transformed to:(0.251/0.01,0.502/0.01,0.753/0.01)
+=(25,50,75). And the OctreeKey will be (x_key:1_1001,y_key:11_0010,z_key:100_1011). Assume the Octree->depth
+is 100_0000, It can quickly calculate the index of the child nodes at each layer.
+layer    Depth Mask   x&Depth Mask    y&Depth Mask    z&Depth Mask    Child Index(0-7)
+1        100_0000     0               0               1               4
+2        10_0000      0               1               0               2
+3        1_0000       1               1               0               3
+4        1000         1               0               1               5
+5        100          0               0               0               0
+6        10           0               1               1               6
+7        1            1               0               1               5
+*/
+
+class OctreeKey
+{
+public:
+    size_t x_key;
+    size_t y_key;
+    size_t z_key;
+
+public:
+    OctreeKey() : x_key(0), y_key(0), z_key(0) { }
+    OctreeKey(size_t x, size_t y, size_t z) : x_key(x), y_key(y), z_key(z) { }
+
+    /** @brief compute the child node index through bit operations.
+    *
+    * @param mask The mask of specify layer.
+    * @return the index of child(0-7)
+    */
+    inline unsigned char findChildIdxByMask(size_t mask) const
+    {
+        return static_cast<unsigned char>((!!(z_key & mask))<<2) | ((!!(y_key & mask))<<1) | (!!(x_key & mask));
+    }
+
+    /** @brief get occupancy code from node.
+    *
+    * The occupancy code type is unsigned char that represents whether the eight child nodes of the octree node exist
+    * If a octree node has 3 child which indexes are 0,1,7, then the occupancy code of this node is 1000_0011
+    * @param node The octree node.
+    * @return the occupancy code(0000_0000-1111_1111)
+    */
+    static inline unsigned char getBitPattern(OctreeNode &node)
+    {
+        unsigned char res = 0;
+        for (unsigned char i = 0; i < node.children.size(); i++)
+        {
+            res |= static_cast<unsigned char>((!node.children[i].empty()) << i);
+        }
+        return res;
+    }
+};
+
+}
+#endif //OPENCV_3D_SRC_OCTREE_HPP
\ No newline at end of file
diff --git a/upstream/opencv/modules/ptcloud/src/odometry.cpp b/upstream/opencv/modules/ptcloud/src/odometry.cpp
new file mode 100644
index 0000000..8355667
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/odometry.cpp
@@ -0,0 +1,529 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "utils.hpp"
+#include "opencv2/ptcloud/odometry.hpp"
+#include "odometry_functions.hpp"
+
+namespace cv
+{
+
+class Odometry::Impl
+{
+public:
+    Impl() {};
+    virtual ~Impl() {};
+    virtual void prepareFrame(OdometryFrame& frame) const = 0;
+    virtual void prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const = 0;
+    virtual bool compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const = 0;
+    virtual bool compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const = 0;
+    virtual bool compute(InputArray srcDepth, InputArray srcRGB,
+                         InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const = 0;
+    virtual Ptr<RgbdNormals> getNormalsComputer() const = 0;
+};
+
+
+class OdometryICP : public Odometry::Impl
+{
+private:
+    OdometrySettings settings;
+    OdometryAlgoType algtype;
+    mutable Ptr<RgbdNormals> normalsComputer;
+
+public:
+    OdometryICP(OdometrySettings _settings, OdometryAlgoType _algtype) :
+        settings(_settings), algtype(_algtype), normalsComputer()
+    { }
+    ~OdometryICP() { }
+
+    virtual void prepareFrame(OdometryFrame& frame) const override;
+    virtual void prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const override;
+    virtual bool compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray srcRGB,
+                         InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const override;
+    virtual Ptr<RgbdNormals> getNormalsComputer() const override;
+};
+
+Ptr<RgbdNormals> OdometryICP::getNormalsComputer() const
+{
+    return this->normalsComputer;
+}
+
+void OdometryICP::prepareFrame(OdometryFrame& frame) const
+{
+    prepareICPFrame(frame, frame, this->normalsComputer, this->settings, this->algtype);
+}
+
+void OdometryICP::prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const
+{
+    prepareICPFrame(srcFrame, dstFrame, this->normalsComputer, this->settings, this->algtype);
+}
+
+bool OdometryICP::compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const
+{
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+    bool isCorrect = RGBDICPOdometryImpl(Rt, Mat(), srcFrame, dstFrame, cameraMatrix,
+                                         this->settings.getMaxDepthDiff(), this->settings.getAngleThreshold(),
+                                         iterCounts, this->settings.getMaxTranslation(),
+                                         this->settings.getMaxRotation(), settings.getSobelScale(),
+                                         OdometryType::DEPTH, OdometryTransformType::RIGID_TRANSFORMATION, this->algtype);
+    return isCorrect;
+}
+
+bool OdometryICP::compute(InputArray _srcDepth, InputArray _dstDepth, OutputArray Rt) const
+{
+    OdometryFrame srcFrame(_srcDepth);
+    OdometryFrame dstFrame(_dstDepth);
+
+    prepareICPFrame(srcFrame, dstFrame, this->normalsComputer, this->settings, this->algtype);
+
+    bool isCorrect = compute(srcFrame, dstFrame, Rt);
+    return isCorrect;
+}
+
+bool OdometryICP::compute(InputArray srcDepth, InputArray srcRGB,
+                          InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const
+{
+    CV_UNUSED(srcDepth);
+    CV_UNUSED(srcRGB);
+    CV_UNUSED(dstDepth);
+    CV_UNUSED(dstRGB);
+    CV_UNUSED(Rt);
+    CV_Error(cv::Error::StsBadFunc, "This odometry does not work with rgb data");
+}
+
+class OdometryRGB : public Odometry::Impl
+{
+private:
+    OdometrySettings settings;
+    OdometryAlgoType algtype;
+
+public:
+    OdometryRGB(OdometrySettings _settings, OdometryAlgoType _algtype) : settings(_settings), algtype(_algtype) { }
+    ~OdometryRGB() { }
+
+    virtual void prepareFrame(OdometryFrame& frame) const override;
+    virtual void prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const override;
+    virtual bool compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray srcRGB,
+                         InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const override;
+    virtual Ptr<RgbdNormals> getNormalsComputer() const override { return Ptr<RgbdNormals>(); }
+};
+
+
+void OdometryRGB::prepareFrame(OdometryFrame& frame) const
+{
+    prepareRGBFrame(frame, frame, this->settings);
+}
+
+void OdometryRGB::prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const
+{
+    prepareRGBFrame(srcFrame, dstFrame, this->settings);
+}
+
+bool OdometryRGB::compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const
+{
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+    bool isCorrect = RGBDICPOdometryImpl(Rt, Mat(), srcFrame, dstFrame, cameraMatrix,
+                                         this->settings.getMaxDepthDiff(), this->settings.getAngleThreshold(),
+                                         iterCounts, this->settings.getMaxTranslation(),
+                                         this->settings.getMaxRotation(), settings.getSobelScale(),
+                                         OdometryType::RGB, OdometryTransformType::RIGID_TRANSFORMATION, this->algtype);
+    return isCorrect;
+}
+
+bool OdometryRGB::compute(InputArray _srcDepth, InputArray _dstDepth, OutputArray Rt) const
+{
+    CV_UNUSED(_srcDepth);
+    CV_UNUSED(_dstDepth);
+    CV_UNUSED(Rt);
+    CV_Error(cv::Error::StsBadFunc, "This odometry algorithm requires depth and rgb data simultaneously");
+}
+
+bool OdometryRGB::compute(InputArray srcDepth, InputArray srcRGB, InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const
+{
+    OdometryFrame srcFrame(srcDepth, srcRGB);
+    OdometryFrame dstFrame(dstDepth, dstRGB);
+
+    prepareRGBFrame(srcFrame, dstFrame, this->settings);
+
+    return compute(srcFrame, dstFrame, Rt);
+}
+
+class OdometryRGBD : public Odometry::Impl
+{
+private:
+    OdometrySettings settings;
+    OdometryAlgoType algtype;
+    mutable Ptr<RgbdNormals> normalsComputer;
+
+public:
+    OdometryRGBD(OdometrySettings _settings, OdometryAlgoType _algtype) : settings(_settings), algtype(_algtype), normalsComputer() { }
+    ~OdometryRGBD() { }
+
+    virtual void prepareFrame(OdometryFrame& frame) const override;
+    virtual void prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const override;
+    virtual bool compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const override;
+    virtual bool compute(InputArray srcDepth, InputArray srcRGB,
+                         InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const override;
+    virtual Ptr<RgbdNormals> getNormalsComputer() const override;
+};
+
+Ptr<RgbdNormals> OdometryRGBD::getNormalsComputer() const
+{
+    return normalsComputer;
+}
+
+void OdometryRGBD::prepareFrame(OdometryFrame& frame) const
+{
+    prepareRGBDFrame(frame, frame, this->normalsComputer, this->settings, this->algtype);
+}
+
+void OdometryRGBD::prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const
+{
+    prepareRGBDFrame(srcFrame, dstFrame, this->normalsComputer, this->settings, this->algtype);
+}
+
+bool OdometryRGBD::compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const
+{
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+    bool isCorrect = RGBDICPOdometryImpl(Rt, Mat(), srcFrame, dstFrame, cameraMatrix,
+                                         this->settings.getMaxDepthDiff(), this->settings.getAngleThreshold(),
+                                         iterCounts, this->settings.getMaxTranslation(),
+                                         this->settings.getMaxRotation(), settings.getSobelScale(),
+                                         OdometryType::RGB_DEPTH, OdometryTransformType::RIGID_TRANSFORMATION, this->algtype);
+    return isCorrect;
+}
+
+bool OdometryRGBD::compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const
+{
+    CV_UNUSED(srcDepth);
+    CV_UNUSED(dstDepth);
+    CV_UNUSED(Rt);
+    CV_Error(cv::Error::StsBadFunc, "This odometry algorithm needs depth and rgb data simultaneously");
+}
+
+bool OdometryRGBD::compute(InputArray _srcDepth, InputArray _srcRGB,
+                           InputArray _dstDepth, InputArray _dstRGB, OutputArray Rt) const
+{
+    OdometryFrame srcFrame(_srcDepth, _srcRGB);
+    OdometryFrame dstFrame(_dstDepth, _dstRGB);
+
+    prepareRGBDFrame(srcFrame, dstFrame, this->normalsComputer, this->settings, this->algtype);
+    bool isCorrect = compute(srcFrame, dstFrame, Rt);
+    return isCorrect;
+}
+
+
+Odometry::Odometry()
+{
+    OdometrySettings settings;
+    this->impl = makePtr<OdometryICP>(settings, OdometryAlgoType::COMMON);
+}
+
+Odometry::Odometry(OdometryType otype)
+{
+    OdometrySettings settings;
+    switch (otype)
+    {
+    case OdometryType::DEPTH:
+        this->impl = makePtr<OdometryICP>(settings, OdometryAlgoType::FAST);
+        break;
+    case OdometryType::RGB:
+        this->impl = makePtr<OdometryRGB>(settings, OdometryAlgoType::COMMON);
+        break;
+    case OdometryType::RGB_DEPTH:
+        this->impl = makePtr<OdometryRGBD>(settings, OdometryAlgoType::COMMON);
+        break;
+    default:
+        CV_Error(Error::StsInternal,
+            "Incorrect OdometryType, you are able to use only { DEPTH = 0, RGB = 1, RGB_DEPTH = 2 }");
+        break;
+    }
+}
+
+Odometry::Odometry(OdometryType otype, const OdometrySettings& settings, OdometryAlgoType algtype)
+{
+    switch (otype)
+    {
+    case OdometryType::DEPTH:
+        this->impl = makePtr<OdometryICP>(settings, algtype);
+        break;
+    case OdometryType::RGB:
+        this->impl = makePtr<OdometryRGB>(settings, algtype);
+        break;
+    case OdometryType::RGB_DEPTH:
+        this->impl = makePtr<OdometryRGBD>(settings, algtype);
+        break;
+    default:
+        CV_Error(Error::StsInternal,
+                 "Incorrect OdometryType, you are able to use only { ICP, RGB, RGBD }");
+        break;
+    }
+}
+
+Odometry::~Odometry()
+{
+}
+
+void Odometry::prepareFrame(OdometryFrame& frame) const
+{
+    this->impl->prepareFrame(frame);
+}
+
+void Odometry::prepareFrames(OdometryFrame& srcFrame, OdometryFrame& dstFrame) const
+{
+    this->impl->prepareFrames(srcFrame, dstFrame);
+}
+
+bool Odometry::compute(const OdometryFrame& srcFrame, const OdometryFrame& dstFrame, OutputArray Rt) const
+{
+    return this->impl->compute(srcFrame, dstFrame, Rt);
+}
+
+bool Odometry::compute(InputArray srcDepth, InputArray dstDepth, OutputArray Rt) const
+{
+    return this->impl->compute(srcDepth, dstDepth, Rt);
+}
+
+bool Odometry::compute(InputArray srcDepth, InputArray srcRGB,
+                       InputArray dstDepth, InputArray dstRGB, OutputArray Rt) const
+{
+    return this->impl->compute(srcDepth, srcRGB, dstDepth, dstRGB, Rt);
+}
+
+Ptr<RgbdNormals> Odometry::getNormalsComputer() const
+{
+    return this->impl->getNormalsComputer();
+}
+
+
+void warpFrame(InputArray depth, InputArray image, InputArray mask,
+               InputArray Rt, InputArray cameraMatrix,
+               OutputArray warpedDepth, OutputArray warpedImage, OutputArray warpedMask)
+{
+    CV_Assert(cameraMatrix.size() == Size(3, 3));
+    CV_Assert(cameraMatrix.depth() == CV_32F || cameraMatrix.depth() == CV_64F);
+    Matx33d K, Kinv;
+    cameraMatrix.getMat().convertTo(K, CV_64F);
+    std::vector<bool> camPlaces { /* fx */ true, false, /* cx */ true, false, /* fy */ true, /* cy */ true,  false, false, /* 1 */ true};
+    for (int i = 0; i < 9; i++)
+    {
+        CV_Assert(camPlaces[i] == (K.val[i] > DBL_EPSILON));
+    }
+    Kinv = K.inv();
+
+    CV_Assert((Rt.cols() == 4) && (Rt.rows() == 3 || Rt.rows() == 4));
+    CV_Assert(Rt.depth() == CV_32F || Rt.depth() == CV_64F);
+    Mat rtmat;
+    Rt.getMat().convertTo(rtmat, CV_64F);
+    Affine3d rt(rtmat);
+
+    CV_Assert(!depth.empty());
+    CV_Assert(depth.channels() == 1);
+    double maxDepth = 0;
+    int depthDepth = depth.depth();
+    switch (depthDepth)
+    {
+    case CV_16U:
+        maxDepth = std::numeric_limits<unsigned short>::max();
+        break;
+    case CV_32F:
+        maxDepth = std::numeric_limits<float>::max();
+        break;
+    case CV_64F:
+        maxDepth = std::numeric_limits<double>::max();
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "Unsupported depth data type");
+    }
+    Mat_<double> depthDbl;
+    depth.getMat().convertTo(depthDbl, CV_64F);
+    Size sz = depth.size();
+
+    Mat_<uchar> maskMat;
+    if (!mask.empty())
+    {
+        CV_Assert(mask.type() == CV_8UC1 || mask.type() == CV_8SC1 || mask.type() == CV_BoolC1);
+        CV_Assert(mask.size() == sz);
+        maskMat = mask.getMat();
+    }
+
+    int imageType = -1;
+    Mat imageMat;
+    if (!image.empty())
+    {
+        imageType = image.type();
+        CV_Assert(imageType == CV_8UC1 || imageType == CV_8UC3 || imageType == CV_8UC4);
+        CV_Assert(image.size() == sz);
+        CV_Assert(warpedImage.needed());
+        imageMat = image.getMat();
+    }
+
+    CV_Assert(warpedDepth.needed() || warpedImage.needed() || warpedMask.needed());
+
+    // Getting new coords for depth point
+
+    // see the explanation in the loop below
+    Matx33d krki = K * rt.rotation() * Kinv;
+    Matx32d krki_cols01 = krki.get_minor<3, 2>(0, 0);
+    Vec3d krki_col2(krki.col(2).val);
+
+    Vec3d ktmat = K * rt.translation();
+    Mat_<Vec3d> reprojBack(depth.size());
+    for (int y = 0; y < sz.height; y++)
+    {
+        const uchar* maskRow = maskMat.empty() ? nullptr : maskMat[y];
+        const double* depthRow = depthDbl[y];
+        Vec3d* reprojRow = reprojBack[y];
+        for (int x = 0; x < sz.width; x++)
+        {
+            double z = depthRow[x];
+            bool badz = cvIsNaN(z) || cvIsInf(z) || z <= 0 || z >= maxDepth || (maskRow && !maskRow[x]);
+            Vec3d v;
+            if (!badz)
+            {
+                // Reproject pixel (x, y) using known z, rotate+translate and project back
+                // getting new pixel in projective coordinates:
+                // v = K * Rt * K^-1 * ([x, y, 1] * z) = [new_x*new_z, new_y*new_z, new_z]
+                // v = K * (R * K^-1 * ([x, y, 1] * z) + t) =
+                // v = krki * [x, y, 1] * z + ktmat =
+                // v = (krki_cols01 * [x, y] + krki_col2) * z + K * t
+                v = (krki_cols01 * Vec2d(x, y) + krki_col2) * z + ktmat;
+            }
+            else
+            {
+                v = Vec3d();
+            }
+            reprojRow[x] = v;
+        }
+    }
+
+    // Draw new depth in z-buffer manner
+
+    Mat warpedImageMat;
+    if (warpedImage.needed())
+    {
+        warpedImage.create(sz, imageType);
+        warpedImage.setZero();
+        warpedImageMat = warpedImage.getMat();
+    }
+
+    const double infinity = std::numeric_limits<double>::max();
+
+    Mat zBuffer(sz, CV_32FC1, infinity);
+
+    const Rect rect = Rect(Point(), sz);
+
+    for (int y = 0; y < sz.height; y++)
+    {
+        uchar* imageRow1ch = nullptr;
+        Vec3b* imageRow3ch = nullptr;
+        Vec4b* imageRow4ch = nullptr;
+        switch (imageType)
+        {
+        case -1:
+            break;
+        case CV_8UC1:
+            imageRow1ch = imageMat.ptr<uchar>(y);
+            break;
+        case CV_8UC3:
+            imageRow3ch = imageMat.ptr<Vec3b>(y);
+            break;
+        case CV_8UC4:
+            imageRow4ch = imageMat.ptr<Vec4b>(y);
+            break;
+        default:
+            break;
+        }
+
+        const Vec3d* reprojRow = reprojBack[y];
+        for (int x = 0; x < sz.width; x++)
+        {
+            Vec3d v = reprojRow[x];
+            double z = v[2];
+
+            if (z > 0)
+            {
+                Point uv(cvFloor(v[0] / z), cvFloor(v[1] / z));
+                if (rect.contains(uv))
+                {
+                    float oldz = zBuffer.at<float>(uv);
+
+                    if (z < oldz)
+                    {
+                        zBuffer.at<float>(uv) = (float)z;
+
+                        switch (imageType)
+                        {
+                        case -1:
+                            break;
+                        case CV_8UC1:
+                            warpedImageMat.at<uchar>(uv) = imageRow1ch[x];
+                            break;
+                        case CV_8UC3:
+                            warpedImageMat.at<Vec3b>(uv) = imageRow3ch[x];
+                            break;
+                        case CV_8UC4:
+                            warpedImageMat.at<Vec4b>(uv) = imageRow4ch[x];
+                            break;
+                        default:
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (warpedDepth.needed() || warpedMask.needed())
+    {
+        Mat goodMask = (zBuffer < infinity);
+
+        if (warpedDepth.needed())
+        {
+            warpedDepth.create(sz, depthDepth);
+
+            double badVal;
+            switch (depthDepth)
+            {
+            case CV_16U:
+                badVal = 0;
+                break;
+            case CV_32F:
+                badVal = std::numeric_limits<float>::quiet_NaN();
+                break;
+            case CV_64F:
+                badVal = std::numeric_limits<double>::quiet_NaN();
+                break;
+            default:
+                break;
+            }
+
+            zBuffer.convertTo(warpedDepth, depthDepth);
+            warpedDepth.setTo(badVal, ~goodMask);
+        }
+
+        if (warpedMask.needed())
+        {
+            warpedMask.create(sz, CV_8UC1);
+            goodMask.copyTo(warpedMask);
+        }
+    }
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp b/upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp
new file mode 100644
index 0000000..4538bff
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/odometry_frame_impl.cpp
@@ -0,0 +1,100 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+#include <opencv2/core/ocl.hpp>
+
+#include "utils.hpp"
+
+namespace cv
+{
+
+OdometryFrame::OdometryFrame(InputArray depth, InputArray image, InputArray mask, InputArray normals)
+{
+    this->impl = makePtr<OdometryFrame::Impl>();
+    if (!image.empty())
+    {
+        image.copyTo(this->impl->image);
+    }
+    if (!depth.empty())
+    {
+        depth.copyTo(this->impl->depth);
+    }
+    if (!mask.empty())
+    {
+        mask.copyTo(this->impl->mask);
+    }
+    if (!normals.empty())
+    {
+        normals.copyTo(this->impl->normals);
+    }
+}
+
+void OdometryFrame::getImage(OutputArray image) const { this->impl->getImage(image); }
+void OdometryFrame::getGrayImage(OutputArray image) const { this->impl->getGrayImage(image); }
+void OdometryFrame::getDepth(OutputArray depth) const { this->impl->getDepth(depth); }
+void OdometryFrame::getProcessedDepth(OutputArray depth) const { this->impl->getProcessedDepth(depth); }
+void OdometryFrame::getMask(OutputArray mask) const { this->impl->getMask(mask); }
+void OdometryFrame::getNormals(OutputArray normals) const { this->impl->getNormals(normals); }
+
+int OdometryFrame::getPyramidLevels() const { return this->impl->getPyramidLevels(); }
+
+void OdometryFrame::getPyramidAt(OutputArray img, OdometryFramePyramidType pyrType, size_t level) const
+{
+    this->impl->getPyramidAt(img, pyrType, level);
+}
+
+void OdometryFrame::Impl::getImage(OutputArray _image) const
+{
+    _image.assign(this->image);
+}
+
+void OdometryFrame::Impl::getGrayImage(OutputArray _image) const
+{
+    _image.assign(this->imageGray);
+}
+
+void OdometryFrame::Impl::getDepth(OutputArray _depth) const
+{
+    _depth.assign(this->depth);
+}
+
+void OdometryFrame::Impl::getProcessedDepth(OutputArray _depth) const
+{
+    _depth.assign(this->scaledDepth);
+}
+
+void OdometryFrame::Impl::getMask(OutputArray _mask) const
+{
+    _mask.assign(this->mask);
+}
+
+void OdometryFrame::Impl::getNormals(OutputArray _normals) const
+{
+    _normals.assign(this->normals);
+}
+
+int OdometryFrame::Impl::getPyramidLevels() const
+{
+    // all pyramids should have the same size
+    for (const auto& p : this->pyramids)
+    {
+        if (!p.empty())
+            return (int)(p.size());
+    }
+    return 0;
+}
+
+
+void OdometryFrame::Impl::getPyramidAt(OutputArray _img, OdometryFramePyramidType pyrType, size_t level) const
+{
+    CV_Assert(pyrType < OdometryFramePyramidType::N_PYRAMIDS);
+    if (level < pyramids[pyrType].size())
+        _img.assign(pyramids[pyrType][level]);
+    else
+        _img.clear();
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/odometry_functions.cpp b/upstream/opencv/modules/ptcloud/src/odometry_functions.cpp
new file mode 100644
index 0000000..4e91f7a
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/odometry_functions.cpp
@@ -0,0 +1,1500 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "odometry_functions.hpp"
+#include "precomp.hpp"
+#include "utils.hpp"
+#include "opencl_kernels_ptcloud.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include <opencv2/core/hal/intrin.hpp>
+#include <opencv2/core/dualquaternion.hpp>
+
+namespace cv
+{
+
+static void randomSubsetOfMask(InputOutputArray _mask, float part)
+{
+    const int minPointsCount = 1000; // minimum point count (we can process them fast)
+    const int nonzeros = countNonZero(_mask);
+    const int needCount = std::max(minPointsCount, int(_mask.total() * part));
+    if (needCount < nonzeros)
+    {
+        RNG rng;
+        Mat mask = _mask.getMat();
+        Mat subset(mask.size(), CV_8UC1, Scalar(0));
+
+        int subsetSize = 0;
+        while (subsetSize < needCount)
+        {
+            int y = rng(mask.rows);
+            int x = rng(mask.cols);
+            if (mask.at<uchar>(y, x))
+            {
+                subset.at<uchar>(y, x) = 255;
+                mask.at<uchar>(y, x) = 0;
+                subsetSize++;
+            }
+        }
+        _mask.assign(subset);
+    }
+}
+
+
+static UMat prepareScaledDepth(OdometryFrame& frame)
+{
+    UMat depth;
+    frame.getDepth(depth);
+    CV_Assert(!depth.empty());
+    bool isFloat = (depth.type() == CV_32FC1 || depth.type() == CV_64FC1);
+
+    // Odometry works well with depth values in range [0, 10)
+    // If it's bigger, let's scale it down by 5000, a typical depth factor
+    UMat depthFlt;
+    if (isFloat)
+    {
+        depth.convertTo(depthFlt, CV_32FC1);
+        patchNaNs(depthFlt, 0);
+    }
+
+    double maxv;
+    cv::minMaxLoc(isFloat ? depthFlt : depth, nullptr, &maxv);
+
+    if (!isFloat || maxv > 10)
+    {
+        depth.convertTo(depthFlt, CV_32FC1, maxv > 10 ? (1.f / 5000.f) : 1.f);
+        patchNaNs(depthFlt, 0);
+    }
+
+    frame.impl->scaledDepth = depthFlt;
+
+    return depthFlt;
+}
+
+
+//TODO: this with bilateral, maybe masks
+static void preparePyramidDepth(UMat depth, std::vector<UMat>& dpyramids, int maxLevel)
+{
+    //TODO: make resize down instead
+    buildPyramid(depth, dpyramids, maxLevel);
+    //resize(depth, resized, dsize, fx, fy, INTER_NEAREST);
+}
+
+
+static void preparePyramidMask(UMat mask, const std::vector<UMat> pyramidDepth, int nLevels, float minDepth, float maxDepth,
+                               std::vector<UMat>& pyramidMask)
+{
+    minDepth = std::max(0.f, minDepth);
+
+    buildPyramid(mask, pyramidMask, nLevels - 1);
+
+    for (int i = 0; i < nLevels; i++)
+    {
+        UMat maski = pyramidMask[i];
+        threshold(maski, maski, 254, 255, THRESH_TOZERO);
+        const UMat depthi = pyramidDepth[i];
+
+        UMat gtmin, ltmax, tmpMask;
+        cv::compare(depthi, Scalar(minDepth), gtmin, CMP_GT);
+        cv::compare(depthi, Scalar(maxDepth), ltmax, CMP_LT);
+        cv::bitwise_and(gtmin, ltmax, tmpMask);
+        cv::bitwise_and(maski, tmpMask, maski);
+    }
+}
+
+static void extendPyrMaskByPyrNormals(const std::vector<UMat>& pyramidNormals,  std::vector<UMat>& pyramidMask)
+{
+    if (!pyramidNormals.empty())
+    {
+        int nLevels = (int)pyramidNormals.size();
+
+        for (int i = 0; i < nLevels; i++)
+        {
+            UMat maski = pyramidMask[i];
+            UMat normali = pyramidNormals[i];
+            UMat validNormalMask;
+            finiteMask(normali, validNormalMask);
+            cv::bitwise_and(maski, validNormalMask, maski);
+        }
+    }
+}
+
+static void buildPyramidCameraMatrix(const Matx33f& cameraMatrix, int levels, std::vector<Matx33f>& pyramidCameraMatrix)
+{
+    pyramidCameraMatrix.resize(levels);
+
+    for (int i = 0; i < levels; i++)
+    {
+        Matx33f levelCameraMatrix = (i == 0) ? cameraMatrix : 0.5f * pyramidCameraMatrix[i - 1];
+        levelCameraMatrix(2, 2) = 1.0;
+        pyramidCameraMatrix[i] = levelCameraMatrix;
+    }
+}
+
+static void preparePyramidCloud(const std::vector<UMat>& pyramidDepth, const Matx33f& cameraMatrix, std::vector<UMat>& pyramidCloud)
+{
+    int nLevels = (int)pyramidDepth.size();
+
+    std::vector<Matx33f> pyramidCameraMatrix;
+    buildPyramidCameraMatrix(cameraMatrix, nLevels, pyramidCameraMatrix);
+
+    pyramidCloud.resize(nLevels, UMat());
+
+    for (int i = 0; i < nLevels; i++)
+    {
+        UMat cloud;
+        depthTo3d(pyramidDepth[i], pyramidCameraMatrix[i], cloud, noArray());
+        pyramidCloud[i] = cloud;
+    }
+}
+
+
+static void preparePyramidTexturedMask(const std::vector<UMat>& pyramid_dI_dx, const std::vector<UMat>& pyramid_dI_dy,
+                                       std::vector<float> minGradMagnitudes, const std::vector<UMat>& pyramidMask, double maxPointsPart,
+                                       std::vector<UMat>& pyramidTexturedMask, double sobelScale)
+{
+    int nLevels = (int)pyramid_dI_dx.size();
+
+    const float sobelScale2_inv = (float)(1. / (sobelScale * sobelScale));
+    pyramidTexturedMask.resize(nLevels, UMat());
+    for (int i = 0; i < nLevels; i++)
+    {
+        const float minScaledGradMagnitude2 = minGradMagnitudes[i] * minGradMagnitudes[i] * sobelScale2_inv;
+        const Mat dIdx = pyramid_dI_dx[i].getMat(ACCESS_READ);
+        const Mat dIdy = pyramid_dI_dy[i].getMat(ACCESS_READ);
+
+        Mat texturedMask(dIdx.size(), CV_8UC1, Scalar(0));
+
+        for (int y = 0; y < dIdx.rows; y++)
+        {
+            const short *dIdx_row = dIdx.ptr<short>(y);
+            const short *dIdy_row = dIdy.ptr<short>(y);
+            uchar *texturedMask_row = texturedMask.ptr<uchar>(y);
+            for (int x = 0; x < dIdx.cols; x++)
+            {
+                float magnitude2 = static_cast<float>(dIdx_row[x] * dIdx_row[x] + dIdy_row[x] * dIdy_row[x]);
+                if (magnitude2 >= minScaledGradMagnitude2)
+                    texturedMask_row[x] = 255;
+            }
+        }
+        Mat texMask = texturedMask & pyramidMask[i].getMat(ACCESS_READ);
+        randomSubsetOfMask(texMask, (float)maxPointsPart);
+        texMask.copyTo(pyramidTexturedMask[i]);
+    }
+}
+
+
+static void preparePyramidNormals(const UMat &normals, const std::vector<UMat> &pyramidDepth, std::vector<UMat> &pyramidNormals)
+{
+    int nLevels = (int)pyramidDepth.size();
+
+    buildPyramid(normals, pyramidNormals, nLevels - 1);
+    // renormalize normals
+    for (int i = 1; i < nLevels; i++)
+    {
+        Mat currNormals = pyramidNormals[i].getMat(ACCESS_RW);
+        CV_Assert(currNormals.type() == CV_32FC4);
+        for (int y = 0; y < currNormals.rows; y++)
+        {
+            Vec4f *normals_row = currNormals.ptr<Vec4f>(y);
+            for (int x = 0; x < currNormals.cols; x++)
+            {
+                Vec4f n4 = normals_row[x];
+                Point3f n(n4[0], n4[1], n4[2]);
+                double nrm = norm(n);
+                n *= 1.f / nrm;
+                normals_row[x] = Vec4f(n.x, n.y, n.z, 0);
+            }
+        }
+    }
+}
+
+
+static void preparePyramidNormalsMask(const std::vector<UMat> &pyramidNormals, const std::vector<UMat> &pyramidMask, double maxPointsPart,
+                                      std::vector<UMat> &pyramidNormalsMask)
+{
+    int nLevels = (int)pyramidNormals.size();
+    pyramidNormalsMask.resize(nLevels, UMat());
+    for (int i = 0; i < nLevels; i++)
+    {
+        Mat pyrMask = pyramidMask[i].getMat(ACCESS_READ);
+
+        const Mat normals = pyramidNormals[i].getMat(ACCESS_READ);
+        Mat_<uchar> normalsMask(pyrMask.size(), (uchar)255);
+        for (int y = 0; y < normalsMask.rows; y++)
+        {
+            const Vec4f *normals_row = normals.ptr<Vec4f>(y);
+            uchar *normalsMask_row = normalsMask.ptr<uchar>(y);
+            for (int x = 0; x < normalsMask.cols; x++)
+            {
+                Vec4f n = normals_row[x];
+                if (!(std::isfinite(n[0]) && std::isfinite(n[1]) && std::isfinite(n[2])))
+                {
+                    normalsMask_row[x] = 0;
+                }
+            }
+        }
+        cv::bitwise_and(pyrMask, normalsMask, normalsMask);
+
+        randomSubsetOfMask(normalsMask, (float)maxPointsPart);
+        normalsMask.copyTo(pyramidNormalsMask[i]);
+    }
+}
+
+
+static void prepareRGBFrameBase(OdometryFrame& frame, OdometrySettings settings)
+{
+    UMat grayImage;
+    frame.getGrayImage(grayImage);
+    if (grayImage.empty())
+    {
+        UMat image;
+        frame.getImage(image);
+        CV_Assert(!image.empty() && image.depth() == CV_8U);
+
+        int ch = image.channels();
+        if (ch == 3 || ch == 4)
+            cvtColor(image, grayImage, ch == 3 ? COLOR_BGR2GRAY : COLOR_BGRA2GRAY, 1);
+        else if (ch == 1)
+                grayImage = image;
+        else
+            CV_Error(Error::StsBadArg, "Image should have 3 or 4 channels (RGB) or 1 channel (grayscale)");
+        grayImage.convertTo(grayImage, CV_8U);
+        frame.impl->imageGray = grayImage;
+    }
+
+    //TODO: don't use scaled when scale bug is fixed
+    UMat scaledDepth;
+    frame.getProcessedDepth(scaledDepth);
+    if (scaledDepth.empty())
+    {
+        scaledDepth = prepareScaledDepth(frame);
+        CV_Assert(scaledDepth.size() == grayImage.size());
+    }
+
+    UMat depthMask;
+    // ignore small, negative, Inf, NaN values
+    cv::compare(scaledDepth, Scalar(FLT_EPSILON), depthMask, CMP_GT);
+
+    UMat mask;
+    frame.getMask(mask);
+    if (mask.empty())
+    {
+        frame.impl->mask = depthMask;
+    }
+    else
+    {
+        CV_Assert(mask.type() == CV_8UC1 || mask.type() == CV_8SC1 || mask.type() == CV_BoolC1);
+        CV_Assert(mask.size() == grayImage.size());
+        cv::bitwise_and(mask, depthMask, frame.impl->mask);
+    }
+    frame.getMask(mask);
+
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+
+    int maxLevel = (int)iterCounts.size() - 1;
+    std::vector<UMat>& ipyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_IMAGE];
+    if (ipyramids.empty())
+        buildPyramid(grayImage, ipyramids, maxLevel);
+
+    std::vector<UMat>& dpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DEPTH];
+    if (dpyramids.empty())
+        preparePyramidDepth(scaledDepth, dpyramids, maxLevel);
+
+    std::vector<UMat>& mpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_MASK];
+    if (mpyramids.empty())
+        preparePyramidMask(mask, dpyramids, maxLevel + 1, settings.getMinDepth(), settings.getMaxDepth(), mpyramids);
+}
+
+
+static void prepareRGBFrameSrc(OdometryFrame& frame, OdometrySettings settings)
+{
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+
+    std::vector<UMat>&       cpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_CLOUD];
+    const std::vector<UMat>& dpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DEPTH];
+
+    preparePyramidCloud(dpyramids, cameraMatrix, cpyramids);
+}
+
+
+static void prepareRGBFrameDst(OdometryFrame& frame, OdometrySettings settings)
+{
+    const std::vector<UMat>& ipyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_IMAGE];
+    const std::vector<UMat>& mpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_MASK];
+
+    std::vector<UMat>& dxpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DIX];
+    std::vector<UMat>& dypyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DIY];
+
+    std::vector<float> minGradientMagnitudes;
+    settings.getMinGradientMagnitudes(minGradientMagnitudes);
+
+    int nLevels = (int)ipyramids.size();
+    dxpyramids.resize(nLevels, UMat());
+    dypyramids.resize(nLevels, UMat());
+    int sobelSize = settings.getSobelSize();
+    for (int i = 0; i < nLevels; i++)
+    {
+        Sobel(ipyramids[i], dxpyramids[i], CV_16S, 1, 0, sobelSize);
+        Sobel(ipyramids[i], dypyramids[i], CV_16S, 0, 1, sobelSize);
+    }
+
+    std::vector<UMat>& tmpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_TEXMASK];
+    preparePyramidTexturedMask(dxpyramids, dypyramids, minGradientMagnitudes,
+                               mpyramids, settings.getMaxPointsPart(), tmpyramids, settings.getSobelScale());
+}
+
+
+static void prepareICPFrameBase(OdometryFrame& frame, OdometrySettings settings)
+{
+    //TODO: don't use scaled when scale bug is fixed
+    UMat scaledDepth;
+    frame.getProcessedDepth(scaledDepth);
+    if (scaledDepth.empty())
+    {
+        scaledDepth = prepareScaledDepth(frame);
+    }
+
+    UMat depthMask;
+    // ignore small, negative, Inf, NaN values
+    cv::compare(scaledDepth, Scalar(FLT_EPSILON), depthMask, CMP_GT);
+
+    UMat mask;
+    frame.getMask(mask);
+    if (mask.empty())
+    {
+        frame.impl->mask = depthMask;
+    }
+    else
+    {
+        CV_Assert(mask.type() == CV_8UC1 || mask.type() == CV_8SC1 || mask.type() == CV_BoolC1);
+        CV_Assert(mask.size() == scaledDepth.size());
+        cv::bitwise_and(mask, depthMask, frame.impl->mask);
+    }
+    frame.getMask(mask);
+
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+
+    int maxLevel = (int)iterCounts.size() - 1;
+    std::vector<UMat>& dpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DEPTH];
+    if (dpyramids.empty())
+        preparePyramidDepth(scaledDepth, dpyramids, maxLevel);
+
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+
+    std::vector<UMat>& cpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_CLOUD];
+    if (cpyramids.empty())
+        preparePyramidCloud(dpyramids, cameraMatrix, cpyramids);
+}
+
+
+static void prepareICPFrameSrc(OdometryFrame& frame, OdometrySettings settings)
+{
+    UMat mask;
+    frame.getMask(mask);
+
+    const std::vector<UMat>& dpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DEPTH];
+
+    std::vector<int> iterCounts;
+    settings.getIterCounts(iterCounts);
+    std::vector<UMat>& mpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_MASK];
+    if (mpyramids.empty())
+        preparePyramidMask(mask, dpyramids, (int)iterCounts.size(), settings.getMinDepth(), settings.getMaxDepth(), mpyramids);
+}
+
+
+static void prepareICPFrameDst(OdometryFrame& frame, OdometrySettings settings, Ptr<RgbdNormals>& normalsComputer)
+{
+    Matx33f cameraMatrix;
+    settings.getCameraMatrix(cameraMatrix);
+
+    UMat scaledDepth, mask, normals;
+    frame.getProcessedDepth(scaledDepth);
+    frame.getMask(mask);
+    frame.getNormals(normals);
+
+    if (normals.empty())
+    {
+        Matx33f K;
+        if (!normalsComputer.empty())
+            normalsComputer->getK(K);
+        if (normalsComputer.empty() ||
+            normalsComputer->getRows() != scaledDepth.rows ||
+            normalsComputer->getCols() != scaledDepth.cols ||
+            norm(K, cameraMatrix) > FLT_EPSILON)
+        {
+            int normalWinSize = settings.getNormalWinSize();
+            float diffThreshold = settings.getNormalDiffThreshold();
+            RgbdNormals::RgbdNormalsMethod normalMethod = settings.getNormalMethod();
+            normalsComputer = RgbdNormals::create(scaledDepth.rows,
+                                                  scaledDepth.cols,
+                                                  scaledDepth.depth(),
+                                                  cameraMatrix,
+                                                  normalWinSize,
+                                                  diffThreshold,
+                                                  normalMethod);
+        }
+        const UMat& c0 = frame.impl->pyramids[OdometryFramePyramidType::PYR_CLOUD][0];
+        normalsComputer->apply(c0, normals);
+        frame.impl->normals = normals;
+    }
+    CV_Assert(normals.type() == CV_32FC4);
+
+    const std::vector<UMat>& dpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_DEPTH];
+
+    std::vector<UMat>& npyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_NORM];
+    if (npyramids.empty())
+        preparePyramidNormals(normals, dpyramids, npyramids);
+
+    std::vector<UMat>& mpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_MASK];
+    if (mpyramids.empty())
+    {
+        std::vector<int> iterCounts;
+        settings.getIterCounts(iterCounts);
+        preparePyramidMask(mask, dpyramids, (int)iterCounts.size(), settings.getMinDepth(), settings.getMaxDepth(), mpyramids);
+        extendPyrMaskByPyrNormals(npyramids, mpyramids);
+    }
+
+    std::vector<UMat>& nmpyramids = frame.impl->pyramids[OdometryFramePyramidType::PYR_NORMMASK];
+    if (nmpyramids.empty())
+        preparePyramidNormalsMask(npyramids, mpyramids, settings.getMaxPointsPart(), nmpyramids);
+}
+
+
+void prepareRGBFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, OdometrySettings settings)
+{
+    prepareRGBFrameBase(srcFrame, settings);
+    prepareRGBFrameBase(dstFrame, settings);
+
+    prepareRGBFrameSrc(srcFrame, settings);
+    prepareRGBFrameDst(dstFrame, settings);
+}
+
+void prepareICPFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, Ptr<RgbdNormals>& normalsComputer, OdometrySettings settings, OdometryAlgoType algtype)
+{
+    prepareICPFrameBase(srcFrame, settings);
+    prepareICPFrameBase(dstFrame, settings);
+
+    prepareICPFrameSrc(srcFrame, settings);
+    if (algtype == OdometryAlgoType::FAST)
+        prepareICPFrameDst(srcFrame, settings, normalsComputer);
+    prepareICPFrameDst(dstFrame, settings, normalsComputer);
+}
+
+void prepareRGBDFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, Ptr<RgbdNormals>& normalsComputer, OdometrySettings settings, OdometryAlgoType algtype)
+{
+    prepareRGBFrame(srcFrame, dstFrame, settings);
+    prepareICPFrame(srcFrame, dstFrame, normalsComputer, settings, algtype);
+}
+
+bool RGBDICPOdometryImpl(OutputArray _Rt, const Mat& initRt,
+                         const OdometryFrame& srcFrame,
+                         const OdometryFrame& dstFrame,
+                         const Matx33f& cameraMatrix,
+                         float maxDepthDiff, float angleThreshold, const std::vector<int>& iterCounts,
+                         double maxTranslation, double maxRotation, double sobelScale,
+                         OdometryType method, OdometryTransformType transformType, OdometryAlgoType algtype)
+{
+    if (srcFrame.getPyramidLevels() != (int)(iterCounts.size()))
+        CV_Error(Error::StsBadArg, "srcFrame has incorrect number of pyramid levels. Did you forget to call prepareFrame()?");
+    if (dstFrame.getPyramidLevels() != (int)(iterCounts.size()))
+        CV_Error(Error::StsBadArg, "dstFrame has incorrect number of pyramid levels. Did you forget to call prepareFrame()?");
+
+    int transformDim = getTransformDim(transformType);
+
+    const int minOverdetermScale = 20;
+    const int minCorrespsCount = minOverdetermScale * transformDim;
+
+    std::vector<Matx33f> pyramidCameraMatrix;
+    buildPyramidCameraMatrix(cameraMatrix, (int)iterCounts.size(), pyramidCameraMatrix);
+
+    Mat resultRt = initRt.empty() ? Mat::eye(4,4,CV_64FC1) : initRt.clone();
+    Mat currRt, ksi;
+    Affine3f transform = Affine3f::Identity();
+
+    bool isOk = false;
+    for(int level = (int)iterCounts.size() - 1; level >= 0; level--)
+    {
+        const Matx33f& levelCameraMatrix = pyramidCameraMatrix[level];
+        const Mat srcLevelDepth, dstLevelDepth;
+        const Mat srcLevelImage, dstLevelImage;
+        srcFrame.getPyramidAt(srcLevelDepth, OdometryFramePyramidType::PYR_DEPTH, level);
+        dstFrame.getPyramidAt(dstLevelDepth, OdometryFramePyramidType::PYR_DEPTH, level);
+
+        if (method != OdometryType::DEPTH) // RGB(D)
+        {
+            srcFrame.getPyramidAt(srcLevelImage, OdometryFramePyramidType::PYR_IMAGE, level);
+            dstFrame.getPyramidAt(dstLevelImage, OdometryFramePyramidType::PYR_IMAGE, level);
+        }
+
+        const double fx = levelCameraMatrix(0, 0);
+        const double fy = levelCameraMatrix(1, 1);
+        const double determinantThreshold = 1e-6;
+
+        Mat AtA_rgbd, AtB_rgbd, AtA_icp, AtB_icp;
+
+        // Run transformation search on current level iteratively.
+        for(int iter = 0; iter < iterCounts[level]; iter ++)
+        {
+            Mat resultRt_inv = resultRt.inv(DECOMP_SVD);
+            Mat corresps_rgbd, corresps_icp, diffs_rgbd;
+            Mat dummy;
+            double sigma_rgbd = 0, dummyFloat = 0;
+
+            const Mat pyramidMask;
+            srcFrame.getPyramidAt(pyramidMask, OdometryFramePyramidType::PYR_MASK, level);
+
+            if(method != OdometryType::DEPTH) // RGB(D)
+            {
+                const Mat pyramidTexturedMask;
+                dstFrame.getPyramidAt(pyramidTexturedMask, OdometryFramePyramidType::PYR_TEXMASK, level);
+                computeCorresps(levelCameraMatrix, resultRt,
+                                srcLevelImage, srcLevelDepth, pyramidMask,
+                                dstLevelImage, dstLevelDepth, pyramidTexturedMask, maxDepthDiff,
+                                corresps_rgbd, diffs_rgbd, sigma_rgbd, OdometryType::RGB);
+            }
+
+            if(method != OdometryType::RGB) // ICP, RGBD
+            {
+                if (algtype == OdometryAlgoType::COMMON)
+                {
+                    const Mat pyramidNormalsMask;
+                    dstFrame.getPyramidAt(pyramidNormalsMask, OdometryFramePyramidType::PYR_NORMMASK, level);
+                    computeCorresps(levelCameraMatrix, resultRt,
+                                    Mat(), srcLevelDepth, pyramidMask,
+                                    Mat(), dstLevelDepth, pyramidNormalsMask, maxDepthDiff,
+                                    corresps_icp, dummy, dummyFloat, OdometryType::DEPTH);
+                }
+            }
+
+            if(corresps_rgbd.rows < minCorrespsCount && corresps_icp.rows < minCorrespsCount && algtype != OdometryAlgoType::FAST)
+                break;
+
+            const UMat srcPyrCloud;
+            srcFrame.getPyramidAt(srcPyrCloud, OdometryFramePyramidType::PYR_CLOUD, level);
+
+
+            Mat AtA(transformDim, transformDim, CV_64FC1, Scalar(0)), AtB(transformDim, 1, CV_64FC1, Scalar(0));
+            if(corresps_rgbd.rows >= minCorrespsCount)
+            {
+                const Mat srcPyrImage, dstPyrImage, dstPyrIdx, dstPyrIdy;
+                srcFrame.getPyramidAt(srcPyrImage, OdometryFramePyramidType::PYR_IMAGE, level);
+                dstFrame.getPyramidAt(dstPyrImage, OdometryFramePyramidType::PYR_IMAGE, level);
+                dstFrame.getPyramidAt(dstPyrIdx, OdometryFramePyramidType::PYR_DIX, level);
+                dstFrame.getPyramidAt(dstPyrIdy, OdometryFramePyramidType::PYR_DIY, level);
+                calcRgbdLsmMatrices(srcPyrCloud.getMat(ACCESS_READ), resultRt, dstPyrIdx, dstPyrIdy,
+                                    corresps_rgbd, diffs_rgbd, sigma_rgbd, fx, fy, sobelScale,
+                                    AtA_rgbd, AtB_rgbd, transformType);
+                AtA += AtA_rgbd;
+                AtB += AtB_rgbd;
+            }
+            if(corresps_icp.rows >= minCorrespsCount || algtype == OdometryAlgoType::FAST)
+            {
+                if (algtype == OdometryAlgoType::COMMON)
+                {
+                    const Mat dstPyrCloud, dstPyrNormals;
+                    dstFrame.getPyramidAt(dstPyrCloud, OdometryFramePyramidType::PYR_CLOUD, level);
+                    dstFrame.getPyramidAt(dstPyrNormals, OdometryFramePyramidType::PYR_NORM, level);
+                    calcICPLsmMatrices(srcPyrCloud.getMat(ACCESS_READ), resultRt, dstPyrCloud, dstPyrNormals,
+                                       corresps_icp, AtA_icp, AtB_icp, transformType);
+                }
+                else
+                {
+                    const UMat dstPyrCloud, dstPyrNormals, srcPyrNormals;
+                    dstFrame.getPyramidAt(dstPyrCloud, OdometryFramePyramidType::PYR_CLOUD, level);
+                    dstFrame.getPyramidAt(dstPyrNormals, OdometryFramePyramidType::PYR_NORM, level);
+                    srcFrame.getPyramidAt(srcPyrNormals, OdometryFramePyramidType::PYR_NORM, level);
+                    cv::Matx66f A;
+                    cv::Vec6f b;
+                    calcICPLsmMatricesFast(cameraMatrix, dstPyrCloud, dstPyrNormals, srcPyrCloud, srcPyrNormals, transform, level, maxDepthDiff, angleThreshold, A, b);
+                    AtA_icp = Mat(A);
+                    AtB_icp = Mat(b);
+                }
+
+                AtA += AtA_icp;
+                AtB += AtB_icp;
+            }
+
+            bool solutionExist = solveSystem(AtA, AtB, determinantThreshold, ksi);
+
+            if (!solutionExist)
+            {
+                break;
+            }
+
+            Mat tmp61(6, 1, CV_64FC1, Scalar(0));
+            if(transformType == OdometryTransformType::ROTATION)
+            {
+                ksi.copyTo(tmp61.rowRange(0,3));
+                ksi = tmp61;
+            }
+            else if(transformType == OdometryTransformType::TRANSLATION)
+            {
+                ksi.copyTo(tmp61.rowRange(3,6));
+                ksi = tmp61;
+            }
+
+            computeProjectiveMatrix(ksi, currRt);
+            resultRt = currRt * resultRt;
+
+            //TODO: fixit, transform is used for Fast ICP only
+            Vec6f x(ksi);
+            Affine3f tinc(Vec3f(x.val), Vec3f(x.val + 3));
+            transform = tinc * transform;
+
+            isOk = true;
+        }
+
+    }
+
+    _Rt.create(resultRt.size(), resultRt.type());
+    Mat Rt = _Rt.getMat();
+    resultRt.copyTo(Rt);
+    if(isOk)
+    {
+        Mat deltaRt;
+        if(initRt.empty())
+            deltaRt = resultRt;
+        else
+            deltaRt = resultRt * initRt.inv(DECOMP_SVD);
+
+        isOk = testDeltaTransformation(deltaRt, maxTranslation, maxRotation);
+    }
+
+    return isOk;
+}
+
+// Rotate dst by RtInv to get corresponding src pixels
+// In RGB case compute sigma and diffs too
+void computeCorresps(const Matx33f& _K, const Mat& rt,
+                     const Mat& imageSrc, const Mat& depthSrc, const Mat& validMaskSrc,
+                     const Mat& imageDst, const Mat& depthDst, const Mat& selectMaskDst, float maxDepthDiff,
+                     Mat& _corresps, Mat& _diffs, double& _sigma, OdometryType method)
+{
+    Mat mrtInv = rt.inv(DECOMP_SVD);
+    Matx44d rtInv = mrtInv;
+
+    Mat corresps(depthDst.size(), CV_16SC2, Scalar::all(-1));
+    Mat diffs;
+    if (method == OdometryType::RGB)
+        diffs = Mat(depthDst.size(), CV_32F, Scalar::all(-1));
+
+    // src_2d = K * src_3d, src_3d = K_inv * [src_2d | z]
+    //
+
+    Matx33d K(_K);
+    Matx33d K_inv = K.inv(DECOMP_SVD);
+    Rect r(0, 0, depthDst.cols, depthDst.rows);
+    Matx31d tinv = rtInv.get_minor<3, 1>(0, 3);
+    Matx31d ktinvm = K * tinv;
+    //const double* Kt_ptr = Kt.ptr<const double>();
+    Point3d ktinv(ktinvm(0, 0), ktinvm(1, 0), ktinvm(2, 0));
+
+    AutoBuffer<float> buf(3 * (depthDst.cols + depthDst.rows));
+    float* KRK_inv0_u1 = buf.data();
+    float* KRK_inv1_v1_plus_KRK_inv2 = buf.data() + depthDst.cols;
+    float* KRK_inv3_u1               = buf.data() + depthDst.cols     + depthDst.rows;
+    float* KRK_inv4_v1_plus_KRK_inv5 = buf.data() + depthDst.cols * 2 + depthDst.rows;
+    float* KRK_inv6_u1               = buf.data() + depthDst.cols * 2 + depthDst.rows * 2;
+    float* KRK_inv7_v1_plus_KRK_inv8 = buf.data() + depthDst.cols * 3 + depthDst.rows * 2;
+    {
+        Matx33d rinv = rtInv.get_minor<3, 3>(0, 0);
+
+        Matx33d kriki = K * rinv * K_inv;
+        for (int udst = 0; udst < depthDst.cols; udst++)
+        {
+            KRK_inv0_u1[udst] = (float)(kriki(0, 0) * udst);
+            KRK_inv3_u1[udst] = (float)(kriki(1, 0) * udst);
+            KRK_inv6_u1[udst] = (float)(kriki(2, 0) * udst);
+        }
+
+        for (int vdst = 0; vdst < depthDst.rows; vdst++)
+        {
+            KRK_inv1_v1_plus_KRK_inv2[vdst] = (float)(kriki(0, 1) * vdst + kriki(0, 2));
+            KRK_inv4_v1_plus_KRK_inv5[vdst] = (float)(kriki(1, 1) * vdst + kriki(1, 2));
+            KRK_inv7_v1_plus_KRK_inv8[vdst] = (float)(kriki(2, 1) * vdst + kriki(2, 2));
+        }
+    }
+
+    double sigma = 0;
+    int correspCount = 0;
+    for (int vdst = 0; vdst < depthDst.rows; vdst++)
+    {
+        const float* depthDst_row = depthDst.ptr<float>(vdst);
+        const uchar* maskDst_row = selectMaskDst.ptr<uchar>(vdst);
+        for (int udst = 0; udst < depthDst.cols; udst++)
+        {
+            float ddst = depthDst_row[udst];
+
+            if (maskDst_row[udst])
+            {
+                float transformed_ddst = static_cast<float>(ddst * (KRK_inv6_u1[udst] + KRK_inv7_v1_plus_KRK_inv8[vdst]) + ktinv.z);
+
+                if (transformed_ddst > 0)
+                {
+                    float transformed_ddst_inv = 1.f / transformed_ddst;
+                    int usrc = cvRound(transformed_ddst_inv * (ddst * (KRK_inv0_u1[udst] + KRK_inv1_v1_plus_KRK_inv2[vdst]) + ktinv.x));
+                    int vsrc = cvRound(transformed_ddst_inv * (ddst * (KRK_inv3_u1[udst] + KRK_inv4_v1_plus_KRK_inv5[vdst]) + ktinv.y));
+                    if (r.contains(Point(usrc, vsrc)))
+                    {
+                        float dsrc = depthSrc.at<float>(vsrc, usrc);
+                        if (validMaskSrc.at<uchar>(vsrc, usrc) && std::abs(transformed_ddst - dsrc) <= maxDepthDiff)
+                        {
+                            CV_DbgAssert(!cvIsNaN(dsrc));
+                            Vec2s& c = corresps.at<Vec2s>(vsrc, usrc);
+                            float diff = 0;
+                            if (c[0] != -1)
+                            {
+                                diff = 0;
+                                int exist_u1 = c[0], exist_v1 = c[1];
+
+                                float exist_d1 = (float)(depthDst.at<float>(exist_v1, exist_u1) *
+                                                 (KRK_inv6_u1[exist_u1] + KRK_inv7_v1_plus_KRK_inv8[exist_v1]) + ktinv.z);
+
+                                if (transformed_ddst > exist_d1)
+                                    continue;
+                                if (method == OdometryType::RGB)
+                                    diff = static_cast<float>(static_cast<int>(imageSrc.at<uchar>(vsrc, usrc)) -
+                                                              static_cast<int>(imageDst.at<uchar>(vdst, udst)));
+                            }
+                            else
+                            {
+                                if (method == OdometryType::RGB)
+                                    diff = static_cast<float>(static_cast<int>(imageSrc.at<uchar>(vsrc, usrc)) -
+                                                              static_cast<int>(imageDst.at<uchar>(vdst, udst)));
+                                correspCount++;
+                            }
+                            c = Vec2s((short)udst, (short)vdst);
+                            if (method == OdometryType::RGB)
+                            {
+                                diffs.at<float>(vsrc, usrc) = diff;
+                                sigma += diff * diff;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    _sigma = std::sqrt(sigma / double(correspCount));
+
+    _corresps.create(correspCount, 1, CV_32SC4);
+    Vec4i* corresps_ptr = _corresps.ptr<Vec4i>();
+    float* diffs_ptr = nullptr;
+    if (method == OdometryType::RGB)
+    {
+        _diffs.create(correspCount, 1, CV_32F);
+        diffs_ptr = _diffs.ptr<float>();
+    }
+    for (int vsrc = 0, i = 0; vsrc < corresps.rows; vsrc++)
+    {
+        const Vec2s* corresps_row = corresps.ptr<Vec2s>(vsrc);
+        const float* diffs_row = nullptr;
+        if (method == OdometryType::RGB)
+            diffs_row = diffs.ptr<float>(vsrc);
+        for (int usrc = 0; usrc < corresps.cols; usrc++)
+        {
+            const Vec2s& c = corresps_row[usrc];
+            const float& d = diffs_row[usrc];
+            if (c[0] != -1)
+            {
+                corresps_ptr[i] = Vec4i(usrc, vsrc, c[0], c[1]);
+                if (method == OdometryType::RGB)
+                    diffs_ptr[i] = d;
+                i++;
+            }
+        }
+    }
+}
+
+void calcRgbdLsmMatrices(const Mat& cloud0, const Mat& Rt,
+                         const Mat& dI_dx1, const Mat& dI_dy1,
+                         const Mat& corresps, const Mat& _diffs, const double _sigma,
+                         double fx, double fy, double sobelScaleIn,
+                         Mat& AtA, Mat& AtB, OdometryTransformType transformType)
+{
+    int transformDim = getTransformDim(transformType);
+    AtA = Mat(transformDim, transformDim, CV_64FC1, Scalar(0));
+    AtB = Mat(transformDim, 1, CV_64FC1, Scalar(0));
+    double* AtB_ptr = AtB.ptr<double>();
+
+    CV_Assert(Rt.type() == CV_64FC1);
+    Affine3d rtmat(Rt);
+
+    const float* diffs_ptr = _diffs.ptr<float>();
+    const Vec4i* corresps_ptr = corresps.ptr<Vec4i>();
+    double sigma = _sigma;
+
+    std::vector<double> A_buf(transformDim);
+    double* A_ptr = &A_buf[0];
+
+    for (int correspIndex = 0; correspIndex < corresps.rows; correspIndex++)
+    {
+        const Vec4i& c = corresps_ptr[correspIndex];
+        int u0 = c[0], v0 = c[1];
+        int u1 = c[2], v1 = c[3];
+
+        double w = sigma + std::abs(diffs_ptr[correspIndex]);
+        w = w > DBL_EPSILON ? 1. / w : 1.;
+
+        double w_sobelScale = w * sobelScaleIn;
+
+        const Vec4f& p0 = cloud0.at<Vec4f>(v0, u0);
+        Point3d tp0 = rtmat * Point3d(p0[0], p0[1], p0[2]);
+
+        rgbdCoeffsFunc(transformType,
+                       A_ptr,
+                       w_sobelScale * dI_dx1.at<short int>(v1, u1),
+                       w_sobelScale * dI_dy1.at<short int>(v1, u1),
+                       tp0, fx, fy);
+
+        for (int y = 0; y < transformDim; y++)
+        {
+            double* AtA_ptr = AtA.ptr<double>(y);
+            for (int x = y; x < transformDim; x++)
+            {
+                AtA_ptr[x] += A_ptr[y] * A_ptr[x];
+            }
+            AtB_ptr[y] += A_ptr[y] * w * diffs_ptr[correspIndex];
+        }
+    }
+
+    for (int y = 0; y < transformDim; y++)
+        for (int x = y + 1; x < transformDim; x++)
+            AtA.at<double>(x, y) = AtA.at<double>(y, x);
+}
+
+
+void calcICPLsmMatrices(const Mat& cloud0, const Mat& Rt,
+                        const Mat& cloud1, const Mat& normals1,
+                        const Mat& corresps,
+                        Mat& AtA, Mat& AtB, OdometryTransformType transformType)
+{
+    int transformDim = getTransformDim(transformType);
+    AtA = Mat(transformDim, transformDim, CV_64FC1, Scalar(0));
+    AtB = Mat(transformDim, 1, CV_64FC1, Scalar(0));
+    double* AtB_ptr = AtB.ptr<double>();
+
+    const int correspsCount = corresps.rows;
+
+    CV_Assert(Rt.type() == CV_64FC1);
+    const double* Rt_ptr = Rt.ptr<const double>();
+
+    AutoBuffer<float> diffs(correspsCount);
+    float* diffs_ptr = diffs.data();
+
+    AutoBuffer<Point3f> transformedPoints0(correspsCount);
+    Point3f* tps0_ptr = transformedPoints0.data();
+
+    const Vec4i* corresps_ptr = corresps.ptr<Vec4i>();
+
+    double sigma = 0;
+    for (int correspIndex = 0; correspIndex < corresps.rows; correspIndex++)
+    {
+        const Vec4i& c = corresps_ptr[correspIndex];
+        int u0 = c[0], v0 = c[1];
+        int u1 = c[2], v1 = c[3];
+
+        const Vec4f& p0 = cloud0.at<Vec4f>(v0, u0);
+        Point3f tp0;
+        tp0.x = (float)(p0[0] * Rt_ptr[0] + p0[1] * Rt_ptr[1] + p0[2] * Rt_ptr[2] + Rt_ptr[3]);
+        tp0.y = (float)(p0[0] * Rt_ptr[4] + p0[1] * Rt_ptr[5] + p0[2] * Rt_ptr[6] + Rt_ptr[7]);
+        tp0.z = (float)(p0[0] * Rt_ptr[8] + p0[1] * Rt_ptr[9] + p0[2] * Rt_ptr[10] + Rt_ptr[11]);
+
+        Vec4f n1 = normals1.at<Vec4f>(v1, u1);
+        Vec4f _v = cloud1.at<Vec4f>(v1, u1);
+        Point3f v = Point3f(_v[0], _v[1], _v[2]) - tp0;
+
+        tps0_ptr[correspIndex] = tp0;
+        diffs_ptr[correspIndex] = n1[0] * v.x + n1[1] * v.y + n1[2] * v.z;
+        sigma += diffs_ptr[correspIndex] * diffs_ptr[correspIndex];
+    }
+
+    sigma = std::sqrt(sigma / correspsCount);
+
+    std::vector<double> A_buf(transformDim);
+    double* A_ptr = &A_buf[0];
+    for (int correspIndex = 0; correspIndex < corresps.rows; correspIndex++)
+    {
+        const Vec4i& c = corresps_ptr[correspIndex];
+        int u1 = c[2], v1 = c[3];
+
+        double w = sigma +std::abs(diffs_ptr[correspIndex]);
+        w = w > DBL_EPSILON ? 1. / w : 1.;
+
+        Vec4f n4 = normals1.at<Vec4f>(v1, u1);
+        Vec4f p1 = cloud1.at<Vec4f>(v1, u1);
+
+        icpCoeffsFunc(transformType,
+                      A_ptr, tps0_ptr[correspIndex], Point3d(p1[0], p1[1], p1[2]), Vec3d(n4[0], n4[1], n4[2]) * w);
+        for (int y = 0; y < transformDim; y++)
+        {
+            double* AtA_ptr = AtA.ptr<double>(y);
+            for (int x = y; x < transformDim; x++)
+            {
+                AtA_ptr[x] += A_ptr[y] * A_ptr[x];
+            }
+            AtB_ptr[y] += A_ptr[y] * w * diffs_ptr[correspIndex];
+        }
+    }
+
+    for (int y = 0; y < transformDim; y++)
+        for (int x = y + 1; x < transformDim; x++)
+            AtA.at<double>(x, y) = AtA.at<double>(y, x);
+}
+
+void computeProjectiveMatrix(const Mat& ksi, Mat& Rt)
+{
+    CV_Assert(ksi.size() == Size(1, 6) && ksi.type() == CV_64FC1);
+
+    const double* ksi_ptr = ksi.ptr<const double>();
+    // 0.5 multiplication is here because (dual) quaternions keep half an angle/twist inside
+    Matx44d matdq = (DualQuatd(0, ksi_ptr[0], ksi_ptr[1], ksi_ptr[2],
+                               0, ksi_ptr[3], ksi_ptr[4], ksi_ptr[5]) * 0.5).exp().toMat(QUAT_ASSUME_UNIT);
+    Mat(matdq).copyTo(Rt);
+}
+
+bool solveSystem(const Mat& AtA, const Mat& AtB, double detThreshold, Mat& x)
+{
+    double det = determinant(AtA);
+    if (fabs(det) < detThreshold || cvIsNaN(det) || cvIsInf(det))
+        return false;
+
+    solve(AtA, AtB, x, DECOMP_CHOLESKY);
+
+    return true;
+}
+
+bool testDeltaTransformation(const Mat& deltaRt, double maxTranslation, double maxRotation)
+{
+    double translation = norm(deltaRt(Rect(3, 0, 1, 3)));
+
+    Mat rvec;
+    Rodrigues(deltaRt(Rect(0, 0, 3, 3)), rvec);
+
+    double rotation = norm(rvec) * 180. / CV_PI;
+
+    return translation <= maxTranslation && rotation <= maxRotation;
+}
+
+// Upper triangle buffer size (for symmetric matrix build)
+const size_t UTSIZE = 27;
+
+#if USE_INTRINSICS
+static inline bool fastCheck(const v_float32x4& p0, const v_float32x4& p1)
+{
+    float check = v_reduce_sum(p0) + v_reduce_sum(p1);
+    return !cvIsNaN(check);
+}
+
+static inline void getCrossPerm(const v_float32x4& a, v_float32x4& yzx, v_float32x4& zxy)
+{
+    v_uint32x4 aa = v_reinterpret_as_u32(a);
+    v_uint32x4 yz00 = v_extract<1>(aa, v_setzero_u32());
+    v_uint32x4 x0y0, tmp;
+    v_zip(aa, v_setzero_u32(), x0y0, tmp);
+    v_uint32x4 yzx0 = v_combine_low(yz00, x0y0);
+    v_uint32x4 y000 = v_extract<2>(x0y0, v_setzero_u32());
+    v_uint32x4 zx00 = v_extract<1>(yzx0, v_setzero_u32());
+    zxy = v_reinterpret_as_f32(v_combine_low(zx00, y000));
+    yzx = v_reinterpret_as_f32(yzx0);
+}
+
+static inline v_float32x4 crossProduct(const v_float32x4& a, const v_float32x4& b)
+{
+    v_float32x4 ayzx, azxy, byzx, bzxy;
+    getCrossPerm(a, ayzx, azxy);
+    getCrossPerm(b, byzx, bzxy);
+    return v_sub(v_mul(ayzx, bzxy), v_mul(azxy, byzx));
+}
+#else
+static inline bool fastCheck(const Point3f& p)
+{
+    return !cvIsNaN(p.x);
+}
+
+#endif
+
+typedef Matx<float, 6, 7> ABtype;
+
+struct GetAbInvoker : ParallelLoopBody
+{
+    GetAbInvoker(ABtype& _globalAb, Mutex& _mtx,
+        const Points& _oldPts, const Normals& _oldNrm, const Points& _newPts, const Normals& _newNrm,
+        Affine3f _pose, Intr::Projector _proj, float _sqDistanceThresh, float _minCos) :
+        ParallelLoopBody(),
+        globalSumAb(_globalAb), mtx(_mtx),
+        oldPts(_oldPts), oldNrm(_oldNrm), newPts(_newPts), newNrm(_newNrm), pose(_pose),
+        proj(_proj), sqDistanceThresh(_sqDistanceThresh), minCos(_minCos)
+    { }
+
+    virtual void operator ()(const Range& range) const override
+    {
+#if USE_INTRINSICS
+        CV_Assert(ptype::channels == 4);
+
+        const size_t utBufferSize = 9;
+        float CV_DECL_ALIGNED(16) upperTriangle[utBufferSize * 4];
+        for (size_t i = 0; i < utBufferSize * 4; i++)
+            upperTriangle[i] = 0;
+        // how values are kept in upperTriangle
+        const int NA = 0;
+        const size_t utPos[] =
+        {
+           0,  1,  2,  4,  5,  6,  3,
+          NA,  9, 10, 12, 13, 14, 11,
+          NA, NA, 18, 20, 21, 22, 19,
+          NA, NA, NA, 24, 28, 30, 32,
+          NA, NA, NA, NA, 25, 29, 33,
+          NA, NA, NA, NA, NA, 26, 34
+        };
+
+        const float(&pm)[16] = pose.matrix.val;
+        v_float32x4 poseRot0(pm[0], pm[4], pm[8], 0);
+        v_float32x4 poseRot1(pm[1], pm[5], pm[9], 0);
+        v_float32x4 poseRot2(pm[2], pm[6], pm[10], 0);
+        v_float32x4 poseTrans(pm[3], pm[7], pm[11], 0);
+
+        v_float32x4 vfxy(proj.fx, proj.fy, 0, 0), vcxy(proj.cx, proj.cy, 0, 0);
+        v_float32x4 vframe((float)(oldPts.cols - 1), (float)(oldPts.rows - 1), 1.f, 1.f);
+
+        float sqThresh = sqDistanceThresh;
+        float cosThresh = minCos;
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            const CV_DECL_ALIGNED(16) float* newPtsRow = (const float*)newPts[y];
+            const CV_DECL_ALIGNED(16) float* newNrmRow = (const float*)newNrm[y];
+
+            for (int x = 0; x < newPts.cols; x++)
+            {
+                v_float32x4 newP = v_load_aligned(newPtsRow + x * 4);
+                v_float32x4 newN = v_load_aligned(newNrmRow + x * 4);
+
+                if (!fastCheck(newP, newN))
+                    continue;
+
+                //transform to old coord system
+                newP = v_matmuladd(newP, poseRot0, poseRot1, poseRot2, poseTrans);
+                newN = v_matmuladd(newN, poseRot0, poseRot1, poseRot2, v_setzero_f32());
+
+                //find correspondence by projecting the point
+                v_float32x4 oldCoords;
+                float pz = v_get0(v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(newP))));
+                // x, y, 0, 0
+                oldCoords = v_muladd(v_div(newP, v_setall_f32(pz)), vfxy, vcxy);
+
+                if (!v_check_all(v_and(v_ge(oldCoords, v_setzero_f32()), v_lt(oldCoords, vframe))))
+                    continue;
+
+                // bilinearly interpolate oldPts and oldNrm under oldCoords point
+                v_float32x4 oldP;
+                v_float32x4 oldN;
+                {
+                    v_int32x4 ixy = v_floor(oldCoords);
+                    v_float32x4 txy = v_sub(oldCoords, v_cvt_f32(ixy));
+                    int xi = v_get0(ixy);
+                    int yi = v_get0(v_rotate_right<1>(ixy));
+                    v_float32x4 tx = v_setall_f32(v_get0(txy));
+                    txy = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(txy)));
+                    v_float32x4 ty = v_setall_f32(v_get0(txy));
+
+                    const float* prow0 = (const float*)oldPts[yi + 0];
+                    const float* prow1 = (const float*)oldPts[yi + 1];
+
+                    v_float32x4 p00 = v_load(prow0 + (xi + 0) * 4);
+                    v_float32x4 p01 = v_load(prow0 + (xi + 1) * 4);
+                    v_float32x4 p10 = v_load(prow1 + (xi + 0) * 4);
+                    v_float32x4 p11 = v_load(prow1 + (xi + 1) * 4);
+
+                    // do not fix missing data
+                    // NaN check is done later
+
+                    const float* nrow0 = (const float*)oldNrm[yi + 0];
+                    const float* nrow1 = (const float*)oldNrm[yi + 1];
+
+                    v_float32x4 n00 = v_load(nrow0 + (xi + 0) * 4);
+                    v_float32x4 n01 = v_load(nrow0 + (xi + 1) * 4);
+                    v_float32x4 n10 = v_load(nrow1 + (xi + 0) * 4);
+                    v_float32x4 n11 = v_load(nrow1 + (xi + 1) * 4);
+
+                    // NaN check is done later
+
+                    v_float32x4 p0 = v_add(p00, v_mul(tx, v_sub(p01, p00)));
+                    v_float32x4 p1 = v_add(p10, v_mul(tx, v_sub(p11, p10)));
+                    oldP = v_add(p0, v_mul(ty, v_sub(p1, p0)));
+
+                    v_float32x4 n0 = v_add(n00, v_mul(tx, v_sub(n01, n00)));
+                    v_float32x4 n1 = v_add(n10, v_mul(tx, v_sub(n11, n10)));
+                    oldN = v_add(n0, v_mul(ty, v_sub(n1, n0)));
+                }
+
+                bool oldPNcheck = fastCheck(oldP, oldN);
+
+                //filter by distance
+                v_float32x4 diff = v_sub(newP, oldP);
+                bool distCheck = !(v_reduce_sum(v_mul(diff, diff)) > sqThresh);
+
+                //filter by angle
+                bool angleCheck = !(abs(v_reduce_sum(v_mul(newN, oldN))) < cosThresh);
+
+                if (!(oldPNcheck && distCheck && angleCheck))
+                    continue;
+
+                // build point-wise vector ab = [ A | b ]
+                v_float32x4 VxNv = crossProduct(newP, oldN);
+                Point3f VxN;
+                VxN.x = v_get0(VxNv);
+                VxN.y = v_get0(v_reinterpret_as_f32(v_extract<1>(v_reinterpret_as_u32(VxNv), v_setzero_u32())));
+                VxN.z = v_get0(v_reinterpret_as_f32(v_extract<2>(v_reinterpret_as_u32(VxNv), v_setzero_u32())));
+
+                float dotp = -v_reduce_sum(v_mul(oldN, diff));
+
+                // build point-wise upper-triangle matrix [ab^T * ab] w/o last row
+                // which is [A^T*A | A^T*b]
+                // and gather sum
+
+                v_float32x4 vd = v_or(VxNv, v_float32x4(0, 0, 0, dotp));
+                v_float32x4 n = oldN;
+                v_float32x4 nyzx;
+                {
+                    v_uint32x4 aa = v_reinterpret_as_u32(n);
+                    v_uint32x4 yz00 = v_extract<1>(aa, v_setzero_u32());
+                    v_uint32x4 x0y0, tmp;
+                    v_zip(aa, v_setzero_u32(), x0y0, tmp);
+                    nyzx = v_reinterpret_as_f32(v_combine_low(yz00, x0y0));
+                }
+
+                v_float32x4 vutg[utBufferSize];
+                for (size_t i = 0; i < utBufferSize; i++)
+                    vutg[i] = v_load_aligned(upperTriangle + i * 4);
+
+                int p = 0;
+                v_float32x4 v;
+                // vx * vd, vx * n
+                v = v_setall_f32(VxN.x);
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, vd, vutg[p])); p++;
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, n, vutg[p])); p++;
+                // vy * vd, vy * n
+                v = v_setall_f32(VxN.y);
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, vd, vutg[p])); p++;
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, n, vutg[p])); p++;
+                // vz * vd, vz * n
+                v = v_setall_f32(VxN.z);
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, vd, vutg[p])); p++;
+                v_store_aligned(upperTriangle + p * 4, v_muladd(v, n, vutg[p])); p++;
+                // nx^2, ny^2, nz^2
+                v_store_aligned(upperTriangle + p * 4, v_muladd(n, n, vutg[p])); p++;
+                // nx*ny, ny*nz, nx*nz
+                v_store_aligned(upperTriangle + p * 4, v_muladd(n, nyzx, vutg[p])); p++;
+                // nx*d, ny*d, nz*d
+                v = v_setall_f32(dotp);
+                v_store_aligned(upperTriangle + p * 4, v_muladd(n, v, vutg[p])); p++;
+            }
+        }
+
+        ABtype sumAB = ABtype::zeros();
+        for (int i = 0; i < 6; i++)
+        {
+            for (int j = i; j < 7; j++)
+            {
+                size_t p = utPos[i * 7 + j];
+                sumAB(i, j) = upperTriangle[p];
+            }
+        }
+
+        CV_UNUSED(UTSIZE);
+
+#else
+        float upperTriangle[UTSIZE];
+        for (size_t i = 0; i < UTSIZE; i++)
+            upperTriangle[i] = 0;
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            const ptype* newPtsRow = newPts[y];
+            const ptype* newNrmRow = newNrm[y];
+
+            for (int x = 0; x < newPts.cols; x++)
+            {
+                Point3f newP = fromPtype(newPtsRow[x]);
+                Point3f newN = fromPtype(newNrmRow[x]);
+
+                Point3f oldP(nan3), oldN(nan3);
+
+                if (!(fastCheck(newP) && fastCheck(newN)))
+                    continue;
+                //transform to old coord system
+                newP = pose * newP;
+                newN = pose.rotation() * newN;
+
+                //find correspondence by projecting the point
+                Point2f oldCoords = proj(newP);
+                if (!(oldCoords.x >= 0 && oldCoords.x < oldPts.cols - 1 &&
+                    oldCoords.y >= 0 && oldCoords.y < oldPts.rows - 1))
+                    continue;
+
+                // bilinearly interpolate oldPts and oldNrm under oldCoords point
+                int xi = cvFloor(oldCoords.x), yi = cvFloor(oldCoords.y);
+                float tx = oldCoords.x - xi, ty = oldCoords.y - yi;
+
+                const ptype* prow0 = oldPts[yi + 0];
+                const ptype* prow1 = oldPts[yi + 1];
+
+                Point3f p00 = fromPtype(prow0[xi + 0]);
+                Point3f p01 = fromPtype(prow0[xi + 1]);
+                Point3f p10 = fromPtype(prow1[xi + 0]);
+                Point3f p11 = fromPtype(prow1[xi + 1]);
+
+                //do not fix missing data
+                if (!(fastCheck(p00) && fastCheck(p01) &&
+                    fastCheck(p10) && fastCheck(p11)))
+                    continue;
+
+                const ptype* nrow0 = oldNrm[yi + 0];
+                const ptype* nrow1 = oldNrm[yi + 1];
+
+                Point3f n00 = fromPtype(nrow0[xi + 0]);
+                Point3f n01 = fromPtype(nrow0[xi + 1]);
+                Point3f n10 = fromPtype(nrow1[xi + 0]);
+                Point3f n11 = fromPtype(nrow1[xi + 1]);
+
+                if (!(fastCheck(n00) && fastCheck(n01) &&
+                    fastCheck(n10) && fastCheck(n11)))
+                    continue;
+
+                Point3f p0 = p00 + tx * (p01 - p00);
+                Point3f p1 = p10 + tx * (p11 - p10);
+                oldP = p0 + ty * (p1 - p0);
+
+                Point3f n0 = n00 + tx * (n01 - n00);
+                Point3f n1 = n10 + tx * (n11 - n10);
+                oldN = n0 + ty * (n1 - n0);
+
+                if (!(fastCheck(oldP) && fastCheck(oldN)))
+                    continue;
+
+                //filter by distance
+                Point3f diff = newP - oldP;
+                if (diff.dot(diff) > sqDistanceThresh)
+                {
+                    continue;
+                }
+
+                //filter by angle
+                if (abs(newN.dot(oldN)) < minCos)
+                {
+                    continue;
+                }
+                // build point-wise vector ab = [ A | b ]
+
+                //try to optimize
+                Point3f VxN = newP.cross(oldN);
+                float ab[7] = { VxN.x, VxN.y, VxN.z, oldN.x, oldN.y, oldN.z, oldN.dot(-diff) };
+                // build point-wise upper-triangle matrix [ab^T * ab] w/o last row
+                // which is [A^T*A | A^T*b]
+                // and gather sum
+                int pos = 0;
+                for (int i = 0; i < 6; i++)
+                {
+                    for (int j = i; j < 7; j++)
+                    {
+                        upperTriangle[pos++] += ab[i] * ab[j];
+                    }
+                }
+            }
+        }
+
+        ABtype sumAB = ABtype::zeros();
+        int pos = 0;
+        for (int i = 0; i < 6; i++)
+        {
+            for (int j = i; j < 7; j++)
+            {
+                sumAB(i, j) = upperTriangle[pos++];
+            }
+        }
+#endif
+        AutoLock al(mtx);
+        globalSumAb += sumAB;
+    }
+
+    ABtype& globalSumAb;
+    Mutex& mtx;
+    const Points& oldPts;
+    const Normals& oldNrm;
+    const Points& newPts;
+    const Normals& newNrm;
+    Affine3f pose;
+    const Intr::Projector proj;
+    float sqDistanceThresh;
+    float minCos;
+};
+
+void calcICPLsmMatricesFast(Matx33f cameraMatrix, const UMat& oldPts, const UMat& oldNrm, const UMat& newPts, const UMat& newNrm,
+                            cv::Affine3f pose, int level, float maxDepthDiff, float angleThreshold, cv::Matx66f& A, cv::Vec6f& b)
+{
+    CV_Assert(oldPts.size() == oldNrm.size());
+    CV_Assert(newPts.size() == newNrm.size());
+
+    CV_OCL_RUN(ocl::isOpenCLActivated(),
+        ocl_calcICPLsmMatricesFast(cameraMatrix,
+            oldPts, oldNrm, newPts, newNrm,
+            pose, level, maxDepthDiff, angleThreshold,
+            A, b)
+        );
+
+    ABtype sumAB = ABtype::zeros();
+    Mutex mutex;
+    const Points  op(oldPts.getMat(AccessFlag::ACCESS_READ)), np(newPts.getMat(AccessFlag::ACCESS_READ));
+    const Normals on(oldNrm.getMat(AccessFlag::ACCESS_READ)), nn(newNrm.getMat(AccessFlag::ACCESS_READ));
+
+    Intr intrinsics(cameraMatrix);
+    GetAbInvoker invoker(sumAB, mutex, op, on, np, nn, pose,
+        intrinsics.scale(level).makeProjector(),
+        maxDepthDiff * maxDepthDiff, std::cos(angleThreshold));
+    Range range(0, newPts.rows);
+    const int nstripes = -1;
+    parallel_for_(range, invoker, nstripes);
+
+    // splitting AB matrix to A and b
+    for (int i = 0; i < 6; i++)
+    {
+        // augment lower triangle of A by symmetry
+        for (int j = i; j < 6; j++)
+        {
+            A(i, j) = A(j, i) = sumAB(i, j);
+        }
+
+        b(i) = sumAB(i, 6);
+    }
+}
+
+#ifdef HAVE_OPENCL
+
+bool ocl_calcICPLsmMatricesFast(Matx33f cameraMatrix, const UMat& oldPts, const UMat& oldNrm, const UMat& newPts, const UMat& newNrm,
+                                cv::Affine3f pose, int level, float maxDepthDiff, float angleThreshold, cv::Matx66f& A, cv::Vec6f& b)
+{
+    CV_TRACE_FUNCTION();
+
+    Size oldSize = oldPts.size(), newSize = newPts.size();
+    CV_Assert(oldSize == oldNrm.size());
+    CV_Assert(newSize == newNrm.size());
+
+    // calculate 1x7 vector ab to produce b and upper triangle of A:
+    // [A|b] = ab*(ab^t)
+    // and then reduce it across work groups
+
+    UMat groupedSumBuffer;
+    cv::String errorStr;
+    String name = "getAb";
+    ocl::ProgramSource source = ocl::ptcloud::icp_oclsrc;
+    cv::String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)newPts.cols;
+    globalSize[1] = (size_t)newPts.rows;
+
+    const ocl::Device& device = ocl::Device::getDefault();
+    size_t wgsLimit = device.maxWorkGroupSize();
+    size_t memSize = device.localMemSize();
+    // local memory should keep upperTriangles for all threads in group for reduce
+    const size_t ltsz = UTSIZE * sizeof(float);
+    const size_t lcols = 32;
+    size_t lrows = min(memSize / ltsz, wgsLimit) / lcols;
+    // round lrows down to 2^n
+    lrows = roundDownPow2(lrows);
+    size_t localSize[2] = { lcols, lrows };
+    Size ngroups((int)divUp(globalSize[0], (unsigned int)localSize[0]),
+                 (int)divUp(globalSize[1], (unsigned int)localSize[1]));
+
+    // size of local buffer for group-wide reduce
+    size_t lsz = localSize[0] * localSize[1] * ltsz;
+
+    Intr intrinsics(cameraMatrix);
+    Intr::Projector proj = intrinsics.scale(level).makeProjector();
+    Vec2f fxy(proj.fx, proj.fy), cxy(proj.cx, proj.cy);
+
+    UMat& groupedSumGpu = groupedSumBuffer;
+    groupedSumGpu.create(Size(ngroups.width * UTSIZE, ngroups.height),
+        CV_32F);
+    groupedSumGpu.setTo(0);
+
+    // TODO: optimization possible:
+    // samplers instead of oldPts/oldNrm (mask needed)
+    k.args(ocl::KernelArg::ReadOnlyNoSize(oldPts),
+        ocl::KernelArg::ReadOnlyNoSize(oldNrm),
+        oldSize,
+        ocl::KernelArg::ReadOnlyNoSize(newPts),
+        ocl::KernelArg::ReadOnlyNoSize(newNrm),
+        newSize,
+        ocl::KernelArg::Constant(pose.matrix.val,
+            sizeof(pose.matrix.val)),
+        fxy.val, cxy.val,
+        maxDepthDiff * maxDepthDiff,
+        std::cos(angleThreshold),
+        ocl::KernelArg::Local(lsz),
+        ocl::KernelArg::WriteOnlyNoSize(groupedSumGpu)
+    );
+
+    if (!k.run(2, globalSize, localSize, true))
+        throw std::runtime_error("Failed to run kernel");
+
+    float upperTriangle[UTSIZE];
+    for (size_t i = 0; i < UTSIZE; i++)
+        upperTriangle[i] = 0;
+
+    Mat groupedSumCpu = groupedSumGpu.getMat(ACCESS_READ);
+
+    for (int y = 0; y < ngroups.height; y++)
+    {
+        const float* rowr = groupedSumCpu.ptr<float>(y);
+        for (size_t x = 0; x < size_t(ngroups.width); x++)
+        {
+            const float* p = rowr + x * UTSIZE;
+            for (size_t j = 0; j < UTSIZE; j++)
+            {
+                upperTriangle[j] += p[j];
+            }
+        }
+    }
+    groupedSumCpu.release();
+
+    ABtype sumAB = ABtype::zeros();
+    int pos = 0;
+    for (int i = 0; i < 6; i++)
+    {
+        for (int j = i; j < 7; j++)
+        {
+            sumAB(i, j) = upperTriangle[pos++];
+        }
+    }
+
+    // splitting AB matrix to A and b
+    for (int i = 0; i < 6; i++)
+    {
+        // augment lower triangle of A by symmetry
+        for (int j = i; j < 6; j++)
+        {
+            A(i, j) = A(j, i) = sumAB(i, j);
+        }
+
+        b(i) = sumAB(i, 6);
+    }
+    return true;
+}
+
+#endif
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/odometry_functions.hpp b/upstream/opencv/modules/ptcloud/src/odometry_functions.hpp
new file mode 100644
index 0000000..7aa35d7
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/odometry_functions.hpp
@@ -0,0 +1,200 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_ODOMETRY_FUNCTIONS_HPP
+#define OPENCV_3D_ODOMETRY_FUNCTIONS_HPP
+
+#include "utils.hpp"
+#include <opencv2/imgproc.hpp>
+
+namespace cv
+{
+enum class OdometryTransformType
+{
+    // rotation, translation, rotation+translation
+    ROTATION = 1, TRANSLATION = 2, RIGID_TRANSFORMATION = 4
+};
+
+static inline int getTransformDim(OdometryTransformType transformType)
+{
+    switch(transformType)
+    {
+    case OdometryTransformType::RIGID_TRANSFORMATION:
+        return 6;
+    case OdometryTransformType::ROTATION:
+    case OdometryTransformType::TRANSLATION:
+        return 3;
+    default:
+        CV_Error(Error::StsBadArg, "Incorrect transformation type");
+    }
+}
+
+
+static inline
+Vec6d calcRgbdEquationCoeffs(double dIdx, double dIdy, const Point3d& p3d, double fx, double fy)
+{
+    double invz = 1. / p3d.z,
+           v0 = dIdx * fx * invz,
+           v1 = dIdy * fy * invz,
+           v2 = -(v0 * p3d.x + v1 * p3d.y) * invz;
+    Point3d v(v0, v1, v2);
+    Point3d pxv = p3d.cross(v);
+
+    return Vec6d(pxv.x, pxv.y, pxv.z, v0, v1, v2);
+}
+
+static inline
+Vec3d calcRgbdEquationCoeffsRotation(double dIdx, double dIdy, const Point3d& p3d, double fx, double fy)
+{
+    double invz = 1. / p3d.z,
+           v0 = dIdx * fx * invz,
+           v1 = dIdy * fy * invz,
+           v2 = -(v0 * p3d.x + v1 * p3d.y) * invz;
+
+    Point3d v(v0, v1, v2);
+    Point3d pxv = p3d.cross(v);
+
+    return Vec3d(pxv);
+}
+
+static inline
+Vec3d calcRgbdEquationCoeffsTranslation(double dIdx, double dIdy, const Point3d& p3d, double fx, double fy)
+{
+    double invz = 1. / p3d.z,
+           v0 = dIdx * fx * invz,
+           v1 = dIdy * fy * invz,
+           v2 = -(v0 * p3d.x + v1 * p3d.y) * invz;
+
+    return Vec3d(v0, v1, v2);
+}
+
+static inline void rgbdCoeffsFunc(OdometryTransformType transformType,
+                                  double* C, double dIdx, double dIdy, const Point3d& p3d, double fx, double fy)
+{
+    int dim = getTransformDim(transformType);
+    Vec6d ret;
+    switch(transformType)
+    {
+    case OdometryTransformType::RIGID_TRANSFORMATION:
+    {
+        ret = calcRgbdEquationCoeffs(dIdx, dIdy, p3d, fx, fy);
+        break;
+    }
+    case OdometryTransformType::ROTATION:
+    {
+        Vec3d r = calcRgbdEquationCoeffsRotation(dIdx, dIdy, p3d, fx, fy);
+        ret = Vec6d(r[0], r[1], r[2], 0, 0, 0);
+        break;
+    }
+    case OdometryTransformType::TRANSLATION:
+    {
+        Vec3d r = calcRgbdEquationCoeffsTranslation(dIdx, dIdy, p3d, fx, fy);
+        ret = Vec6d(r[0], r[1], r[2], 0, 0, 0);
+        break;
+    }
+    default:
+        CV_Error(Error::StsBadArg, "Incorrect transformation type");
+    }
+    for (int i = 0; i < dim; i++)
+        C[i] = ret[i];
+}
+
+
+static inline
+Vec6d calcICPEquationCoeffs(const Point3d& psrc, const Vec3d& ndst)
+{
+    Point3d pxv = psrc.cross(Point3d(ndst));
+
+    return Vec6d(pxv.x, pxv.y, pxv.z, ndst[0], ndst[1], ndst[2]);
+}
+
+static inline
+Vec3d calcICPEquationCoeffsRotation(const Point3d& psrc, const Vec3d& ndst)
+{
+    Point3d pxv = psrc.cross(Point3d(ndst));
+
+    return Vec3d(pxv);
+}
+
+static inline
+Vec3d calcICPEquationCoeffsTranslation( const Point3d& /*p0*/, const Vec3d& ndst)
+{
+    return Vec3d(ndst);
+}
+
+static inline
+void icpCoeffsFunc(OdometryTransformType transformType, double* C, const Point3d& p0, const Point3d& /*p1*/, const Vec3d& n1)
+{
+    int dim = getTransformDim(transformType);
+    Vec6d ret;
+    switch(transformType)
+    {
+    case OdometryTransformType::RIGID_TRANSFORMATION:
+    {
+        ret = calcICPEquationCoeffs(p0, n1);
+        break;
+    }
+    case OdometryTransformType::ROTATION:
+    {
+        Vec3d r = calcICPEquationCoeffsRotation(p0, n1);
+        ret = Vec6d(r[0], r[1], r[2], 0, 0, 0);
+        break;
+    }
+    case OdometryTransformType::TRANSLATION:
+    {
+        Vec3d r = calcICPEquationCoeffsTranslation(p0, n1);
+        ret = Vec6d(r[0], r[1], r[2], 0, 0, 0);
+        break;
+    }
+    default:
+        CV_Error(Error::StsBadArg, "Incorrect transformation type");
+    }
+    for (int i = 0; i < dim; i++)
+        C[i] = ret[i];
+}
+
+void prepareRGBDFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, Ptr<RgbdNormals>& normalsComputer, const OdometrySettings settings, OdometryAlgoType algtype);
+void prepareRGBFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, OdometrySettings settings);
+void prepareICPFrame(OdometryFrame& srcFrame, OdometryFrame& dstFrame, Ptr<RgbdNormals>& normalsComputer, const OdometrySettings settings, OdometryAlgoType algtype);
+
+bool RGBDICPOdometryImpl(OutputArray _Rt, const Mat& initRt,
+                         const OdometryFrame& srcFrame,
+                         const OdometryFrame& dstFrame,
+                         const Matx33f& cameraMatrix,
+                         float maxDepthDiff, float angleThreshold, const std::vector<int>& iterCounts,
+                         double maxTranslation, double maxRotation, double sobelScale,
+                         OdometryType method, OdometryTransformType transfromType, OdometryAlgoType algtype);
+
+void computeCorresps(const Matx33f& _K, const Mat& Rt,
+                     const Mat& image0, const Mat& depth0, const Mat& validMask0,
+                     const Mat& image1, const Mat& depth1, const Mat& selectMask1, float maxDepthDiff,
+                     Mat& _corresps, Mat& _diffs, double& _sigma, OdometryType method);
+
+void calcRgbdLsmMatrices(const Mat& cloud0, const Mat& Rt,
+                         const Mat& dI_dx1, const Mat& dI_dy1,
+                         const Mat& corresps, const Mat& diffs, const double sigma,
+                         double fx, double fy, double sobelScaleIn,
+                         Mat& AtA, Mat& AtB, OdometryTransformType transformType);
+
+void calcICPLsmMatrices(const Mat& cloud0, const Mat& Rt,
+                        const Mat& cloud1, const Mat& normals1,
+                        const Mat& corresps,
+                        Mat& AtA, Mat& AtB, OdometryTransformType transformType);
+
+void calcICPLsmMatricesFast(Matx33f cameraMatrix, const UMat& oldPts, const UMat& oldNrm, const UMat& newPts, const UMat& newNrm,
+                            cv::Affine3f pose, int level, float maxDepthDiff, float angleThreshold, cv::Matx66f& A, cv::Vec6f& b);
+
+#ifdef HAVE_OPENCL
+bool ocl_calcICPLsmMatricesFast(Matx33f cameraMatrix, const UMat& oldPts, const UMat& oldNrm, const UMat& newPts, const UMat& newNrm,
+                                cv::Affine3f pose, int level, float maxDepthDiff, float angleThreshold, cv::Matx66f& A, cv::Vec6f& b);
+#endif
+
+void computeProjectiveMatrix(const Mat& ksi, Mat& Rt);
+
+bool solveSystem(const Mat& AtA, const Mat& AtB, double detThreshold, Mat& x);
+
+bool testDeltaTransformation(const Mat& deltaRt, double maxTranslation, double maxRotation);
+
+}
+#endif //OPENCV_3D_ODOMETRY_FUNCTIONS_HPP
diff --git a/upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp b/upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp
new file mode 100644
index 0000000..a5716d1
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/odometry_settings_impl.cpp
@@ -0,0 +1,407 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "utils.hpp"
+
+namespace cv
+{
+
+class OdometrySettings::Impl
+{
+public:
+    Impl() {};
+    virtual ~Impl() {};
+    virtual void setCameraMatrix(InputArray val) = 0;
+    virtual void getCameraMatrix(OutputArray val) const = 0;
+    virtual void setIterCounts(InputArray val) = 0;
+    virtual void getIterCounts(OutputArray val) const = 0;
+
+    virtual void  setMinDepth(float val) = 0;
+    virtual float getMinDepth() const = 0;
+    virtual void  setMaxDepth(float val) = 0;
+    virtual float getMaxDepth() const = 0;
+    virtual void  setMaxDepthDiff(float val) = 0;
+    virtual float getMaxDepthDiff() const = 0;
+    virtual void  setMaxPointsPart(float val) = 0;
+    virtual float getMaxPointsPart() const = 0;
+
+    virtual void setSobelSize(int val) = 0;
+    virtual int  getSobelSize() const = 0;
+    virtual void   setSobelScale(double val) = 0;
+    virtual double getSobelScale() const = 0;
+
+    virtual void setNormalWinSize(int val) = 0;
+    virtual int  getNormalWinSize() const = 0;
+    virtual void setNormalDiffThreshold(float val) = 0;
+    virtual float getNormalDiffThreshold() const = 0;
+    virtual void setNormalMethod(RgbdNormals::RgbdNormalsMethod nm) = 0;
+    virtual RgbdNormals::RgbdNormalsMethod getNormalMethod() const = 0;
+
+    virtual void  setAngleThreshold(float val) = 0;
+    virtual float getAngleThreshold() const = 0;
+    virtual void  setMaxTranslation(float val) = 0;
+    virtual float getMaxTranslation() const = 0;
+    virtual void  setMaxRotation(float val) = 0;
+    virtual float getMaxRotation() const = 0;
+
+    virtual void  setMinGradientMagnitude(float val) = 0;
+    virtual float getMinGradientMagnitude() const = 0;
+    virtual void setMinGradientMagnitudes(InputArray val) = 0;
+    virtual void getMinGradientMagnitudes(OutputArray val) const = 0;
+};
+
+class OdometrySettingsImplCommon : public OdometrySettings::Impl
+{
+public:
+    OdometrySettingsImplCommon();
+    ~OdometrySettingsImplCommon() {};
+    virtual void setCameraMatrix(InputArray val) override;
+    virtual void getCameraMatrix(OutputArray val) const override;
+    virtual void setIterCounts(InputArray val) override;
+    virtual void getIterCounts(OutputArray val) const override;
+
+    virtual void  setMinDepth(float val) override;
+    virtual float getMinDepth() const override;
+    virtual void  setMaxDepth(float val) override;
+    virtual float getMaxDepth() const override;
+    virtual void  setMaxDepthDiff(float val) override;
+    virtual float getMaxDepthDiff() const override;
+    virtual void  setMaxPointsPart(float val) override;
+    virtual float getMaxPointsPart() const override;
+
+    virtual void setSobelSize(int val) override;
+    virtual int  getSobelSize() const override;
+    virtual void   setSobelScale(double val) override;
+    virtual double getSobelScale() const override;
+
+    virtual void setNormalWinSize(int val) override;
+    virtual int  getNormalWinSize() const override;
+    virtual void setNormalDiffThreshold(float val) override;
+    virtual float getNormalDiffThreshold() const override;
+    virtual void setNormalMethod(RgbdNormals::RgbdNormalsMethod nm) override;
+    virtual RgbdNormals::RgbdNormalsMethod getNormalMethod() const override;
+
+    virtual void  setAngleThreshold(float val) override;
+    virtual float getAngleThreshold() const override;
+    virtual void  setMaxTranslation(float val) override;
+    virtual float getMaxTranslation() const override;
+    virtual void  setMaxRotation(float val) override;
+    virtual float getMaxRotation() const override;
+
+    virtual void  setMinGradientMagnitude(float val) override;
+    virtual float getMinGradientMagnitude() const override;
+    virtual void setMinGradientMagnitudes(InputArray val) override;
+    virtual void getMinGradientMagnitudes(OutputArray val) const override;
+
+private:
+    Matx33f cameraMatrix;
+    std::vector<int> iterCounts;
+
+    float minDepth;
+    float maxDepth;
+    float maxDepthDiff;
+    float maxPointsPart;
+
+    int sobelSize;
+    double sobelScale;
+
+    int normalWinSize;
+    float normalDiffThreshold;
+    RgbdNormals::RgbdNormalsMethod normalMethod;
+
+    float angleThreshold;
+    float maxTranslation;
+    float maxRotation;
+
+    float minGradientMagnitude;
+    std::vector<float> minGradientMagnitudes;
+
+public:
+    class DefaultSets {
+    public:
+        static const int width  = 640;
+        static const int height = 480;
+        static constexpr float fx = 525.f;
+        static constexpr float fy = 525.f;
+        static constexpr float cx = float(width) / 2.f - 0.5f;
+        static constexpr float cy = float(height) / 2.f - 0.5f;
+        const cv::Matx33f defaultCameraMatrix = { fx, 0, cx, 0, fy, cy, 0, 0, 1 };
+        const std::vector<int> defaultIterCounts = { 7, 7, 7, 10 };
+
+        static constexpr float defaultMinDepth = 0.f;
+        static constexpr float defaultMaxDepth = 4.f;
+        static constexpr float defaultMaxDepthDiff = 0.07f;
+        static constexpr float defaultMaxPointsPart = 0.07f;
+
+        static const int defaultSobelSize = 3;
+        static constexpr double defaultSobelScale = 1. / 8.;
+
+        static const int defaultNormalWinSize = 5;
+        static const RgbdNormals::RgbdNormalsMethod defaultNormalMethod = RgbdNormals::RGBD_NORMALS_METHOD_FALS;
+        static constexpr float defaultNormalDiffThreshold = 50.f;
+
+        static constexpr float defaultAngleThreshold = (float)(30. * CV_PI / 180.);
+        static constexpr float defaultMaxTranslation = 0.15f;
+        static constexpr float defaultMaxRotation = 15.f;
+
+        static constexpr float defaultMinGradientMagnitude = 10.f;
+        const std::vector<float> defaultMinGradientMagnitudes = std::vector<float>(defaultIterCounts.size(), 10.f /*defaultMinGradientMagnitude*/);
+    };
+};
+
+
+OdometrySettings::OdometrySettings()
+{
+    this->impl = makePtr<OdometrySettingsImplCommon>();
+}
+
+OdometrySettings::OdometrySettings(const OdometrySettings& s)
+{
+    this->impl = makePtr<OdometrySettingsImplCommon>(*s.impl.dynamicCast<OdometrySettingsImplCommon>());
+}
+
+OdometrySettings& OdometrySettings::operator=(const OdometrySettings& s)
+{
+    this->impl = makePtr<OdometrySettingsImplCommon>(*s.impl.dynamicCast<OdometrySettingsImplCommon>());
+    return *this;
+}
+
+void OdometrySettings::setCameraMatrix(InputArray val) { this->impl->setCameraMatrix(val); }
+void OdometrySettings::getCameraMatrix(OutputArray val) const { this->impl->getCameraMatrix(val); }
+void OdometrySettings::setIterCounts(InputArray val) { this->impl->setIterCounts(val); }
+void OdometrySettings::getIterCounts(OutputArray val) const { this->impl->getIterCounts(val); }
+
+void  OdometrySettings::setMinDepth(float val) { this->impl->setMinDepth(val); }
+float OdometrySettings::getMinDepth() const { return this->impl->getMinDepth(); }
+void  OdometrySettings::setMaxDepth(float val) { this->impl->setMaxDepth(val); }
+float OdometrySettings::getMaxDepth() const { return this->impl->getMaxDepth(); }
+void  OdometrySettings::setMaxDepthDiff(float val) { this->impl->setMaxDepthDiff(val); }
+float OdometrySettings::getMaxDepthDiff() const { return this->impl->getMaxDepthDiff(); }
+void  OdometrySettings::setMaxPointsPart(float val) { this->impl->setMaxPointsPart(val); }
+float OdometrySettings::getMaxPointsPart() const { return this->impl->getMaxPointsPart(); }
+
+void OdometrySettings::setSobelSize(int val) { this->impl->setSobelSize(val); }
+int  OdometrySettings::getSobelSize() const { return this->impl->getSobelSize(); }
+void   OdometrySettings::setSobelScale(double val) { this->impl->setSobelScale(val); }
+double OdometrySettings::getSobelScale() const { return this->impl->getSobelScale(); }
+
+void  OdometrySettings::setNormalWinSize(int val) { this->impl->setNormalWinSize(val); }
+int   OdometrySettings::getNormalWinSize() const { return this->impl->getNormalWinSize(); }
+void  OdometrySettings::setNormalDiffThreshold(float val) { this->impl->setNormalDiffThreshold(val); }
+float OdometrySettings::getNormalDiffThreshold() const { return this->impl->getNormalDiffThreshold(); }
+void  OdometrySettings::setNormalMethod(RgbdNormals::RgbdNormalsMethod nm) { this->impl->setNormalMethod(nm); }
+RgbdNormals::RgbdNormalsMethod OdometrySettings::getNormalMethod() const { return this->impl->getNormalMethod(); }
+
+void  OdometrySettings::setAngleThreshold(float val) { this->impl->setAngleThreshold(val); }
+float OdometrySettings::getAngleThreshold() const { return this->impl->getAngleThreshold(); }
+void  OdometrySettings::setMaxTranslation(float val) { this->impl->setMaxTranslation(val); }
+float OdometrySettings::getMaxTranslation() const { return this->impl->getMaxTranslation(); }
+void  OdometrySettings::setMaxRotation(float val) { this->impl->setMaxRotation(val); }
+float OdometrySettings::getMaxRotation() const { return this->impl->getMaxRotation(); }
+
+void  OdometrySettings::setMinGradientMagnitude(float val) { this->impl->setMinGradientMagnitude(val); }
+float OdometrySettings::getMinGradientMagnitude() const { return this->impl->getMinGradientMagnitude(); }
+void OdometrySettings::setMinGradientMagnitudes(InputArray val) { this->impl->setMinGradientMagnitudes(val); }
+void OdometrySettings::getMinGradientMagnitudes(OutputArray val) const { this->impl->getMinGradientMagnitudes(val); }
+
+
+OdometrySettingsImplCommon::OdometrySettingsImplCommon()
+{
+    DefaultSets ds;
+    this->cameraMatrix = ds.defaultCameraMatrix;
+    this->iterCounts = ds.defaultIterCounts;
+
+    this->minDepth = ds.defaultMinDepth;
+    this->maxDepth = ds.defaultMaxDepth;
+    this->maxDepthDiff = ds.defaultMaxDepthDiff;
+    this->maxPointsPart = ds.defaultMaxPointsPart;
+
+    this->sobelSize = ds.defaultSobelSize;
+    this->sobelScale = ds.defaultSobelScale;
+
+    this->normalWinSize = ds.defaultNormalWinSize;
+    this->normalDiffThreshold = ds.defaultNormalDiffThreshold;
+    this->normalMethod = ds.defaultNormalMethod;
+
+    this->angleThreshold = ds.defaultAngleThreshold;
+    this->maxTranslation = ds.defaultMaxTranslation;
+    this->maxRotation = ds.defaultMaxRotation;
+
+    this->minGradientMagnitude = ds.defaultMinGradientMagnitude;
+    this->minGradientMagnitudes = ds.defaultMinGradientMagnitudes;
+}
+
+void OdometrySettingsImplCommon::setCameraMatrix(InputArray val)
+{
+    if (!val.empty())
+    {
+        CV_Assert(val.rows() == 3 && val.cols() == 3 && val.channels() == 1);
+        CV_Assert(val.type() == CV_32F);
+        val.copyTo(cameraMatrix);
+    }
+    else
+    {
+        DefaultSets ds;
+        this->cameraMatrix = ds.defaultCameraMatrix;
+    }
+}
+
+void OdometrySettingsImplCommon::getCameraMatrix(OutputArray val) const
+{
+    Mat(this->cameraMatrix).copyTo(val);
+}
+
+void OdometrySettingsImplCommon::setIterCounts(InputArray val)
+{
+    if (!val.empty())
+    {
+        size_t nLevels = val.size(-1).width;
+        std::vector<Mat> pyramids;
+        val.getMatVector(pyramids);
+        this->iterCounts.clear();
+        for (size_t i = 0; i < nLevels; i++)
+            this->iterCounts.push_back(pyramids[i].at<int>(0));
+    }
+    else
+    {
+        DefaultSets ds;
+        this->iterCounts = ds.defaultIterCounts;
+    }
+}
+
+void OdometrySettingsImplCommon::getIterCounts(OutputArray val) const
+{
+    Mat(this->iterCounts).copyTo(val);
+}
+
+void OdometrySettingsImplCommon::setMinDepth(float val)
+{
+    this->minDepth = val;
+}
+float OdometrySettingsImplCommon::getMinDepth() const
+{
+    return this->minDepth;
+}
+void  OdometrySettingsImplCommon::setMaxDepth(float val)
+{
+    this->maxDepth = val;
+}
+float OdometrySettingsImplCommon::getMaxDepth() const
+{
+    return this->maxDepth;
+}
+void  OdometrySettingsImplCommon::setMaxDepthDiff(float val)
+{
+    this->maxDepthDiff = val;
+}
+float OdometrySettingsImplCommon::getMaxDepthDiff() const
+{
+    return this->maxDepthDiff;
+}
+void  OdometrySettingsImplCommon::setMaxPointsPart(float val)
+{
+    this->maxPointsPart = val;
+}
+float OdometrySettingsImplCommon::getMaxPointsPart() const
+{
+    return this->maxPointsPart;
+}
+
+void OdometrySettingsImplCommon::setSobelSize(int val)
+{
+    this->sobelSize = val;
+}
+int  OdometrySettingsImplCommon::getSobelSize() const
+{
+    return this->sobelSize;
+}
+void   OdometrySettingsImplCommon::setSobelScale(double val)
+{
+    this->sobelScale = val;
+}
+double OdometrySettingsImplCommon::getSobelScale() const
+{
+    return this->sobelScale;
+}
+void OdometrySettingsImplCommon::setNormalWinSize(int val)
+{
+    this->normalWinSize = val;
+}
+int  OdometrySettingsImplCommon::getNormalWinSize() const
+{
+    return this->normalWinSize;
+}
+void OdometrySettingsImplCommon::setNormalDiffThreshold(float val)
+{
+    this->normalDiffThreshold = val;
+}
+float OdometrySettingsImplCommon::getNormalDiffThreshold() const
+{
+    return this->normalDiffThreshold;
+}
+void OdometrySettingsImplCommon::setNormalMethod(RgbdNormals::RgbdNormalsMethod nm)
+{
+    this->normalMethod = nm;
+}
+RgbdNormals::RgbdNormalsMethod OdometrySettingsImplCommon::getNormalMethod() const
+{
+    return this->normalMethod;
+}
+void  OdometrySettingsImplCommon::setAngleThreshold(float val)
+{
+    this->angleThreshold = val;
+}
+float OdometrySettingsImplCommon::getAngleThreshold() const
+{
+    return this->angleThreshold;
+}
+void  OdometrySettingsImplCommon::setMaxTranslation(float val)
+{
+    this->maxTranslation = val;
+}
+float OdometrySettingsImplCommon::getMaxTranslation() const
+{
+    return this->maxTranslation;
+}
+void  OdometrySettingsImplCommon::setMaxRotation(float val)
+{
+    this->maxRotation = val;
+}
+float OdometrySettingsImplCommon::getMaxRotation() const
+{
+    return this->maxRotation;
+}
+
+void  OdometrySettingsImplCommon::setMinGradientMagnitude(float val)
+{
+    this->minGradientMagnitude = val;
+}
+float OdometrySettingsImplCommon::getMinGradientMagnitude() const
+{
+    return this->minGradientMagnitude;
+}
+void OdometrySettingsImplCommon::setMinGradientMagnitudes(InputArray val)
+{
+    if (!val.empty())
+    {
+        size_t nLevels = val.size(-1).width;
+        std::vector<Mat> pyramids;
+        val.getMatVector(pyramids);
+        this->minGradientMagnitudes.clear();
+        for (size_t i = 0; i < nLevels; i++)
+            this->minGradientMagnitudes.push_back(pyramids[i].at<float>(0));
+    }
+    else
+    {
+        DefaultSets ds;
+        this->minGradientMagnitudes = ds.defaultMinGradientMagnitudes;
+    }
+}
+void OdometrySettingsImplCommon::getMinGradientMagnitudes(OutputArray val) const
+{
+    Mat(this->minGradientMagnitudes).copyTo(val);
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/opencl/hash_tsdf.cl b/upstream/opencv/modules/ptcloud/src/opencl/hash_tsdf.cl
new file mode 100644
index 0000000..a4e0f79
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/opencl/hash_tsdf.cl
@@ -0,0 +1,653 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// This code is also subject to the license terms in the LICENSE_KinectFusion.md file found in this module's directory
+
+#define USE_INTERPOLATION_IN_GETNORMAL 1
+#define HASH_DIVISOR 32768
+
+typedef char int8_t;
+typedef uint int32_t;
+
+typedef int8_t TsdfType;
+typedef uchar WeightType;
+
+struct TsdfVoxel
+{
+    TsdfType tsdf;
+    WeightType weight;
+};
+
+
+static inline TsdfType floatToTsdf(float num)
+{
+    int8_t res = (int8_t) ( (num * (-128)) );
+    res = res ? res : (num < 0 ? 1 : -1);
+    return res;
+}
+
+static inline float tsdfToFloat(TsdfType num)
+{
+    return ( (float) num ) / (-128);
+}
+
+static uint calc_hash(int3 x)
+{
+    unsigned int seed = 0;
+    unsigned int GOLDEN_RATIO = 0x9e3779b9;
+    seed ^= x.s0 + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+    seed ^= x.s1 + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+    seed ^= x.s2 + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+    return seed;
+}
+
+
+//TODO: make hashDivisor a power of 2
+//TODO: put it to this .cl file as a constant
+static int custom_find(int3 idx, const int hashDivisor, __global const int* hashes,
+                    __global const int4* data)
+{
+    int hash = calc_hash(idx) % hashDivisor;
+    int place = hashes[hash];
+    // search a place
+    while (place >= 0)
+    {
+        if (all(data[place].s012 == idx))
+            break;
+        else
+            place = data[place].s3;
+    }
+
+    return place;
+}
+
+
+
+static void integrateVolumeUnit(
+                        int x, int y,
+                        __global const char * depthptr,
+                        int depth_step, int depth_offset,
+                        int depth_rows, int depth_cols,
+                        __global struct TsdfVoxel * volumeptr,
+                        const __global char * pixNormsPtr,
+                        int pixNormsStep, int pixNormsOffset,
+                        int pixNormsRows, int pixNormsCols,
+                        const float16 vol2camMatrix,
+                        const float voxelSize,
+                        const int4 volResolution4,
+                        const int4 volStrides4,
+                        const float2 fxy,
+                        const float2 cxy,
+                        const float dfac,
+                        const float truncDist,
+                        const int maxWeight
+                        )
+{
+    const int3 volResolution = volResolution4.xyz;
+
+    if(x >= volResolution.x || y >= volResolution.y)
+        return;
+
+    // coord-independent constants
+    const int3 volStrides = volStrides4.xyz;
+    const float2 limits = (float2)(depth_cols-1, depth_rows-1);
+
+    const float4 vol2cam0 = vol2camMatrix.s0123;
+    const float4 vol2cam1 = vol2camMatrix.s4567;
+    const float4 vol2cam2 = vol2camMatrix.s89ab;
+
+    const float truncDistInv = 1.f/truncDist;
+
+    // optimization of camSpace transformation (vector addition instead of matmul at each z)
+    float4 inPt = (float4)(x*voxelSize, y*voxelSize, 0, 1);
+    float3 basePt = (float3)(dot(vol2cam0, inPt),
+                             dot(vol2cam1, inPt),
+                             dot(vol2cam2, inPt));
+
+    float3 camSpacePt = basePt;
+
+    // zStep == vol2cam*(float3(x, y, 1)*voxelSize) - basePt;
+    float3 zStep = ((float3)(vol2cam0.z, vol2cam1.z, vol2cam2.z))*voxelSize;
+
+    int volYidx = x*volStrides.x + y*volStrides.y;
+
+    int startZ, endZ;
+    if(fabs(zStep.z) > 1e-5f)
+    {
+        int baseZ = convert_int(-basePt.z / zStep.z);
+        if(zStep.z > 0)
+        {
+            startZ = baseZ;
+            endZ = volResolution.z;
+        }
+        else
+        {
+            startZ = 0;
+            endZ = baseZ;
+        }
+    }
+    else
+    {
+        if(basePt.z > 0)
+        {
+            startZ = 0; endZ = volResolution.z;
+        }
+        else
+        {
+            // z loop shouldn't be performed
+            startZ = endZ = 0;
+        }
+    }
+
+    startZ = max(0, startZ);
+    endZ = min(volResolution.z, endZ);
+
+    for(int z = startZ; z < endZ; z++)
+    {
+        // optimization of the following:
+        //float3 camSpacePt = vol2cam * ((float3)(x, y, z)*voxelSize);
+        camSpacePt += zStep;
+
+        if(camSpacePt.z <= 0)
+            continue;
+
+        float3 camPixVec = camSpacePt / camSpacePt.z;
+        float2 projected = mad(camPixVec.xy, fxy, cxy); // mad(a,b,c) = a * b + c
+
+        float v;
+        // bilinearly interpolate depth at projected
+        if(all(projected >= 0) && all(projected < limits))
+        {
+            float2 ip = floor(projected);
+            int xi = ip.x, yi = ip.y;
+
+            __global const float* row0 = (__global const float*)(depthptr + depth_offset +
+                                                                 (yi+0)*depth_step);
+            __global const float* row1 = (__global const float*)(depthptr + depth_offset +
+                                                                 (yi+1)*depth_step);
+
+            float v00 = row0[xi+0];
+            float v01 = row0[xi+1];
+            float v10 = row1[xi+0];
+            float v11 = row1[xi+1];
+            float4 vv = (float4)(v00, v01, v10, v11);
+
+            // assume correct depth is positive
+            if(all(vv > 0))
+            {
+                float2 t = projected - ip;
+                float2 vf = mix(vv.xz, vv.yw, t.x);
+                v = mix(vf.s0, vf.s1, t.y);
+            }
+            else
+                continue;
+        }
+        else
+            continue;
+
+        if(v == 0)
+            continue;
+
+        int2 projInt = convert_int2(projected);
+        float pixNorm = *(__global const float*)(pixNormsPtr + pixNormsOffset + projInt.y*pixNormsStep + projInt.x*sizeof(float));
+        //float pixNorm = length(camPixVec);
+
+        // difference between distances of point and of surface to camera
+        float sdf = pixNorm*(v*dfac - camSpacePt.z);
+        // possible alternative is:
+        // float sdf = length(camSpacePt)*(v*dfac/camSpacePt.z - 1.0);
+        if(sdf >= -truncDist)
+        {
+            float tsdf = fmin(1.0f, sdf * truncDistInv);
+            int volIdx = volYidx + z*volStrides.z;
+
+            struct TsdfVoxel voxel = volumeptr[volIdx];
+            float value  = tsdfToFloat(voxel.tsdf);
+            int weight = voxel.weight;
+            // update TSDF
+            value = (value*weight + tsdf) / (weight + 1);
+            weight = min(weight + 1, maxWeight);
+
+            voxel.tsdf = floatToTsdf(value);
+            voxel.weight = weight;
+            volumeptr[volIdx] = voxel;
+        }
+    }
+
+}
+
+
+__kernel void integrateAllVolumeUnits(
+                        // depth
+                        __global const char * depthptr,
+                        int depth_step, int depth_offset,
+                        int depth_rows, int depth_cols,
+                        // hashMap
+                        __global const int* hashes,
+                        __global const int4* data,
+                        // volUnitsData
+                        __global struct TsdfVoxel * allVolumePtr,
+                        int table_step, int table_offset,
+                        int table_rows, int table_cols,
+                        // pixNorms
+                        const __global char * pixNormsPtr,
+                        int pixNormsStep, int pixNormsOffset,
+                        int pixNormsRows, int pixNormsCols,
+                        // isActiveFlags
+                        __global const uchar* isActiveFlagsPtr,
+                        int isActiveFlagsStep, int isActiveFlagsOffset,
+                        int isActiveFlagsRows, int isActiveFlagsCols,
+                        // cam matrix:
+                        const float16 vol2cam,
+                        // scalars:
+                        const float voxelSize,
+                        const int volUnitResolution,
+                        const int4 volStrides4,
+                        const float2 fxy,
+                        const float2 cxy,
+                        const float dfac,
+                        const float truncDist,
+                        const int maxWeight
+                        )
+{
+    const int hash_divisor = HASH_DIVISOR;
+    int i = get_global_id(0);
+    int j = get_global_id(1);
+    int row = get_global_id(2);
+    int3 idx = data[row].xyz;
+
+    const int4 volResolution4 = (int4)(volUnitResolution,
+                                       volUnitResolution,
+                                       volUnitResolution,
+                                       volUnitResolution);
+
+    int isActive = *(__global const uchar*)(isActiveFlagsPtr + isActiveFlagsOffset + row);
+
+    if (isActive)
+    {
+        int volCubed = volUnitResolution * volUnitResolution * volUnitResolution;
+        __global struct TsdfVoxel * volumeptr = (__global struct TsdfVoxel*)
+                                                (allVolumePtr + table_offset + row * volCubed);
+
+        // volUnit2cam = world2cam * volUnit2world =
+        // camPoseInv * volUnitPose = camPoseInv * (volPose + volPoseRot*(idx * volUnitSize)) =
+        // camPoseInv * (volPose + volPoseRot*(idx * volUnitResolution * voxelSize)) =
+        // camPoseInv * (volPose + volPoseRot*mulIdx) = camPoseInv * volPose + camPoseInv * volPoseRot * mulIdx =
+        // vol2cam + camPoseInv * volPoseRot * mulIdx
+        float3 mulIdx = convert_float3(idx * volUnitResolution) * voxelSize;
+        float16 volUnit2cam = vol2cam;
+
+        volUnit2cam.s37b += (float3)(dot(mulIdx, vol2cam.s012),
+                                     dot(mulIdx, vol2cam.s456),
+                                     dot(mulIdx, vol2cam.s89a));
+
+        integrateVolumeUnit(
+            i, j,
+            depthptr,
+            depth_step, depth_offset,
+            depth_rows, depth_cols,
+            volumeptr,
+            pixNormsPtr,
+            pixNormsStep, pixNormsOffset,
+            pixNormsRows, pixNormsCols,
+            volUnit2cam,
+            voxelSize,
+            volResolution4,
+            volStrides4,
+            fxy,
+            cxy,
+            dfac,
+            truncDist,
+            maxWeight
+            );
+    }
+}
+
+
+static struct TsdfVoxel at(int3 volumeIdx, int row, int volumeUnitDegree,
+                           int3 volStrides, __global const struct TsdfVoxel * allVolumePtr, int table_offset)
+
+{
+    //! Out of bounds
+    if (any(volumeIdx >= (1 << volumeUnitDegree)) ||
+        any(volumeIdx < 0))
+    {
+        struct TsdfVoxel dummy;
+        dummy.tsdf = floatToTsdf(1.0f);
+        dummy.weight = 0;
+        return dummy;
+    }
+
+    int volCubed = 1 << (volumeUnitDegree*3);
+    __global struct TsdfVoxel * volData = (__global struct TsdfVoxel*)
+                                          (allVolumePtr + table_offset + row * volCubed);
+    int3 ismul = volumeIdx * volStrides;
+    int coordBase = ismul.x + ismul.y + ismul.z;
+    return volData[coordBase];
+}
+
+
+static struct TsdfVoxel atVolumeUnit(int3 volumeIdx, int3 volumeUnitIdx, int row,
+                                     int volumeUnitDegree, int3 volStrides,
+                                     __global const struct TsdfVoxel * allVolumePtr, int table_offset)
+
+{
+    //! Out of bounds
+    if (row < 0)
+    {
+        struct TsdfVoxel dummy;
+        dummy.tsdf = floatToTsdf(1.0f);
+        dummy.weight = 0;
+        return dummy;
+    }
+
+    int3 volUnitLocalIdx = volumeIdx - (volumeUnitIdx << volumeUnitDegree);
+    int volCubed = 1 << (volumeUnitDegree*3);
+    __global struct TsdfVoxel * volData = (__global struct TsdfVoxel*)
+                                          (allVolumePtr + table_offset + row * volCubed);
+    int3 ismul = volUnitLocalIdx * volStrides;
+    int coordBase = ismul.x + ismul.y + ismul.z;
+    return volData[coordBase];
+}
+
+inline float interpolate(float3 t, float8 vz)
+{
+    float4 vy = mix(vz.s0246, vz.s1357, t.z);
+    float2 vx = mix(vy.s02, vy.s13, t.y);
+    return mix(vx.s0, vx.s1, t.x);
+}
+
+inline float3 getNormalVoxel(float3 ptVox, __global const struct TsdfVoxel* allVolumePtr,
+                             int volumeUnitDegree,
+                             const int hash_divisor,
+                             __global const int* hashes,
+                             __global const int4* data,
+
+                             int3 volStrides, int table_offset)
+{
+    float3 normal = (float3) (0.0f, 0.0f, 0.0f);
+    float3 fip = floor(ptVox);
+    int3 iptVox = convert_int3(fip);
+
+    // A small hash table to reduce a number of findRow() calls
+    // -2 and lower means not queried yet
+    // -1 means not found
+    // 0+ means found
+    int iterMap[8];
+    for (int i = 0; i < 8; i++)
+    {
+        iterMap[i] = -2;
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    int4 offsets[] = { (int4)( 1,  0,  0, 0), (int4)(-1,  0,  0, 0), (int4)( 0,  1,  0, 0), // 0-3
+                       (int4)( 0, -1,  0, 0), (int4)( 0,  0,  1, 0), (int4)( 0,  0, -1, 0)  // 4-7
+    };
+
+    const int nVals = 6;
+    float vals[6];
+#else
+    int4 offsets[]={(int4)( 0,  0,  0, 0), (int4)( 0,  0,  1, 0), (int4)( 0,  1,  0, 0), (int4)( 0,  1,  1, 0), //  0-3
+                    (int4)( 1,  0,  0, 0), (int4)( 1,  0,  1, 0), (int4)( 1,  1,  0, 0), (int4)( 1,  1,  1, 0), //  4-7
+                    (int4)(-1,  0,  0, 0), (int4)(-1,  0,  1, 0), (int4)(-1,  1,  0, 0), (int4)(-1,  1,  1, 0), //  8-11
+                    (int4)( 2,  0,  0, 0), (int4)( 2,  0,  1, 0), (int4)( 2,  1,  0, 0), (int4)( 2,  1,  1, 0), // 12-15
+                    (int4)( 0, -1,  0, 0), (int4)( 0, -1,  1, 0), (int4)( 1, -1,  0, 0), (int4)( 1, -1,  1, 0), // 16-19
+                    (int4)( 0,  2,  0, 0), (int4)( 0,  2,  1, 0), (int4)( 1,  2,  0, 0), (int4)( 1,  2,  1, 0), // 20-23
+                    (int4)( 0,  0, -1, 0), (int4)( 0,  1, -1, 0), (int4)( 1,  0, -1, 0), (int4)( 1,  1, -1, 0), // 24-27
+                    (int4)( 0,  0,  2, 0), (int4)( 0,  1,  2, 0), (int4)( 1,  0,  2, 0), (int4)( 1,  1,  2, 0), // 28-31
+    };
+    const int nVals = 32;
+    float vals[32];
+#endif
+
+    for (int i = 0; i < nVals; i++)
+    {
+        int3 pt = iptVox + offsets[i].s012;
+
+        // VoxelToVolumeUnitIdx()
+        int3 volumeUnitIdx = pt >> volumeUnitDegree;
+
+        int3 vand = (volumeUnitIdx & 1);
+        int dictIdx = vand.s0 + vand.s1 * 2 + vand.s2 * 4;
+
+        int it = iterMap[dictIdx];
+        if (it < -1)
+        {
+            it = custom_find(volumeUnitIdx, hash_divisor, hashes, data);
+            iterMap[dictIdx] = it;
+        }
+
+        struct TsdfVoxel tmp = atVolumeUnit(pt, volumeUnitIdx, it, volumeUnitDegree, volStrides, allVolumePtr, table_offset);
+        vals[i] = tsdfToFloat( tmp.tsdf );
+    }
+
+#if !USE_INTERPOLATION_IN_GETNORMAL
+    float3 pv, nv;
+
+    pv = (float3)(vals[0*2  ], vals[1*2  ], vals[2*2  ]);
+    nv = (float3)(vals[0*2+1], vals[1*2+1], vals[2*2+1]);
+    normal = pv - nv;
+#else
+
+    float cxv[8], cyv[8], czv[8];
+
+    // How these numbers were obtained:
+    // 1. Take the basic interpolation sequence:
+    // 000, 001, 010, 011, 100, 101, 110, 111
+    // where each digit corresponds to shift by x, y, z axis respectively.
+    // 2. Add +1 for next or -1 for prev to each coordinate to corresponding axis
+    // 3. Search corresponding values in offsets
+    const int idxxn[8] = {  8,  9, 10, 11,  0,  1,  2,  3 };
+    const int idxxp[8] = {  4,  5,  6,  7, 12, 13, 14, 15 };
+    const int idxyn[8] = { 16, 17,  0,  1, 18, 19,  4,  5 };
+    const int idxyp[8] = {  2,  3, 20, 21,  6,  7, 22, 23 };
+    const int idxzn[8] = { 24,  0, 25,  2, 26,  4, 27,  6 };
+    const int idxzp[8] = {  1, 28,  3, 29,  5, 30,  7, 31 };
+
+    float vcxp[8], vcxn[8];
+    float vcyp[8], vcyn[8];
+    float vczp[8], vczn[8];
+
+    for (int i = 0; i < 8; i++)
+    {
+        vcxp[i] = vals[idxxp[i]]; vcxn[i] = vals[idxxn[i]];
+        vcyp[i] = vals[idxyp[i]]; vcyn[i] = vals[idxyn[i]];
+        vczp[i] = vals[idxzp[i]]; vczn[i] = vals[idxzn[i]];
+    }
+
+    float8 cxp = vload8(0, vcxp), cxn = vload8(0, vcxn);
+    float8 cyp = vload8(0, vcyp), cyn = vload8(0, vcyn);
+    float8 czp = vload8(0, vczp), czn = vload8(0, vczn);
+    float8 cx = cxp - cxn;
+    float8 cy = cyp - cyn;
+    float8 cz = czp - czn;
+
+    float3 tv = ptVox - fip;
+    normal.x = interpolate(tv, cx);
+    normal.y = interpolate(tv, cy);
+    normal.z = interpolate(tv, cz);
+#endif
+
+    float norm = sqrt(dot(normal, normal));
+    return norm < 0.0001f ? nan((uint)0) : normal / norm;
+}
+
+typedef float4 ptype;
+
+__kernel void raycast(
+                    __global const int* hashes,
+                    __global const int4* data,
+                    __global char * pointsptr,
+                      int points_step, int points_offset,
+                    __global char * normalsptr,
+                      int normals_step, int normals_offset,
+                    const int2 frameSize,
+                    __global const struct TsdfVoxel * allVolumePtr,
+                        int table_step, int table_offset,
+                        int table_rows, int table_cols,
+                    float16 cam2volRotGPU,
+                    float16 vol2camRotGPU,
+                    float truncateThreshold,
+                    const float2 fixy, const float2 cxy,
+                    const float4 boxDown4, const float4 boxUp4,
+                    const float tstep,
+                    const float voxelSize,
+                    const float voxelSizeInv,
+                    float volumeUnitSize,
+                    float truncDist,
+                    int volumeUnitDegree,
+                    int4 volStrides4
+                    )
+{
+    const int hash_divisor = HASH_DIVISOR;
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= frameSize.x || y >= frameSize.y)
+        return;
+
+    float3 point  = nan((uint)0);
+    float3 normal = nan((uint)0);
+
+    const float3 camRot0  = cam2volRotGPU.s012;
+    const float3 camRot1  = cam2volRotGPU.s456;
+    const float3 camRot2  = cam2volRotGPU.s89a;
+    const float3 camTrans = cam2volRotGPU.s37b;
+
+    const float3 volRot0  = vol2camRotGPU.s012;
+    const float3 volRot1  = vol2camRotGPU.s456;
+    const float3 volRot2  = vol2camRotGPU.s89a;
+    const float3 volTrans = vol2camRotGPU.s37b;
+
+    float3 planed = (float3)(((float2)(x, y) - cxy)*fixy, 1.f);
+    planed = (float3)(dot(planed, camRot0),
+                      dot(planed, camRot1),
+                      dot(planed, camRot2));
+
+    float3 orig = (float3) (camTrans.s0, camTrans.s1, camTrans.s2);
+    float3 dir = fast_normalize(planed);
+    float3 origScaled = orig * voxelSizeInv;
+    float3 dirScaled = dir * voxelSizeInv;
+
+    float tmin = 0;
+    float tmax = truncateThreshold;
+    float tcurr = tmin;
+    float tprev = tcurr;
+    float prevTsdf = truncDist;
+
+    int3 volStrides = volStrides4.xyz;
+
+    while (tcurr < tmax)
+    {
+        float3 currRayPosVox = origScaled + tcurr * dirScaled;
+
+        // VolumeToVolumeUnitIdx()
+        int3 currVoxel = convert_int3(floor(currRayPosVox));
+        int3 currVolumeUnitIdx = currVoxel >> volumeUnitDegree;
+
+        int row = custom_find(currVolumeUnitIdx, hash_divisor, hashes, data);
+
+        float currTsdf = prevTsdf;
+        int currWeight = 0;
+        float stepSize = 0.5 * volumeUnitSize;
+        int3 volUnitLocalIdx;
+
+        if (row >= 0)
+        {
+            volUnitLocalIdx = currVoxel - (currVolumeUnitIdx << volumeUnitDegree);
+            struct TsdfVoxel currVoxel = at(volUnitLocalIdx, row, volumeUnitDegree, volStrides, allVolumePtr, table_offset);
+
+            currTsdf = tsdfToFloat(currVoxel.tsdf);
+            currWeight = currVoxel.weight;
+            stepSize = tstep;
+        }
+
+        if (prevTsdf > 0.f && currTsdf <= 0.f && currWeight > 0)
+        {
+            float tInterp = (tcurr * prevTsdf - tprev * currTsdf) / (prevTsdf - currTsdf);
+            if ( !isnan(tInterp) && !isinf(tInterp) )
+            {
+                float3 pvox = origScaled + tInterp * dirScaled;
+                float3 nv = getNormalVoxel( pvox, allVolumePtr, volumeUnitDegree,
+                                            hash_divisor, hashes, data,
+                                            volStrides, table_offset);
+
+                if(!any(isnan(nv)))
+                {
+                    //convert pv and nv to camera space
+                    normal = (float3)(dot(nv, volRot0),
+                                      dot(nv, volRot1),
+                                      dot(nv, volRot2));
+                    // interpolation optimized a little
+                    float3 pv = pvox * voxelSize;
+                    point = (float3)(dot(pv, volRot0),
+                                     dot(pv, volRot1),
+                                     dot(pv, volRot2)) + volTrans;
+                }
+            }
+            break;
+        }
+        prevTsdf = currTsdf;
+        tprev = tcurr;
+        tcurr += stepSize;
+    }
+
+    __global float* pts = (__global float*)(pointsptr  +  points_offset + y*points_step   + x*sizeof(ptype));
+    __global float* nrm = (__global float*)(normalsptr + normals_offset + y*normals_step  + x*sizeof(ptype));
+    vstore4((float4)(point,  0), 0, pts);
+    vstore4((float4)(normal, 0), 0, nrm);
+}
+
+
+__kernel void markActive (
+        __global const int4* hashSetData,
+
+        __global char* isActiveFlagsPtr,
+        int isActiveFlagsStep, int isActiveFlagsOffset,
+        int isActiveFlagsRows, int isActiveFlagsCols,
+
+        __global char* lastVisibleIndicesPtr,
+        int lastVisibleIndicesStep, int lastVisibleIndicesOffset,
+        int lastVisibleIndicesRows, int lastVisibleIndicesCols,
+
+        const float16 vol2cam,
+        const float2 fxy,
+        const float2 cxy,
+        const int2 frameSz,
+        const float volumeUnitSize,
+        const int lastVolIndex,
+        const float truncateThreshold,
+        const int frameId
+        )
+{
+    const int hash_divisor = HASH_DIVISOR;
+    int row = get_global_id(0);
+
+    if (row < lastVolIndex)
+    {
+        int3 idx = hashSetData[row].xyz;
+
+        float3 volumeUnitPos = convert_float3(idx) * volumeUnitSize;
+
+        float3 volUnitInCamSpace = (float3) (dot(volumeUnitPos, vol2cam.s012),
+                                             dot(volumeUnitPos, vol2cam.s456),
+                                             dot(volumeUnitPos, vol2cam.s89a)) + vol2cam.s37b;
+
+        if (volUnitInCamSpace.z < 0 || volUnitInCamSpace.z > truncateThreshold)
+        {
+            *(isActiveFlagsPtr + isActiveFlagsOffset + row * isActiveFlagsStep) = 0;
+            return;
+        }
+
+        float2 cameraPoint;
+        float invz = 1.f / volUnitInCamSpace.z;
+        cameraPoint = fxy * volUnitInCamSpace.xy * invz + cxy;
+
+        if (all(cameraPoint >= 0) && all(cameraPoint < convert_float2(frameSz)))
+        {
+            *(__global int*)(lastVisibleIndicesPtr + lastVisibleIndicesOffset + row * lastVisibleIndicesStep) = frameId;
+            *(isActiveFlagsPtr + isActiveFlagsOffset + row * isActiveFlagsStep) = 1;
+        }
+    }
+}
diff --git a/upstream/opencv/modules/ptcloud/src/opencl/icp.cl b/upstream/opencv/modules/ptcloud/src/opencl/icp.cl
new file mode 100644
index 0000000..93b859a
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/opencl/icp.cl
@@ -0,0 +1,239 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#define UTSIZE 27
+
+typedef float4 ptype;
+
+/*
+    Calculate an upper triangle of Ab matrix then reduce it across workgroup
+*/
+
+inline void calcAb7(__global const char * oldPointsptr,
+                    int oldPoints_step, int oldPoints_offset,
+                    __global const char * oldNormalsptr,
+                    int oldNormals_step, int oldNormals_offset,
+                    const int2 oldSize,
+                    __global const char * newPointsptr,
+                    int newPoints_step, int newPoints_offset,
+                    __global const char * newNormalsptr,
+                    int newNormals_step, int newNormals_offset,
+                    const int2 newSize,
+                    const float16 poseMatrix,
+                    const float2 fxy,
+                    const float2 cxy,
+                    const float sqDistanceThresh,
+                    const float minCos,
+                    float* ab7
+                    )
+{
+    const int x = get_global_id(0);
+    const int y = get_global_id(1);
+
+    if(x >= newSize.x || y >= newSize.y)
+        return;
+
+    // coord-independent constants
+
+    const float3 poseRot0 = poseMatrix.s012;
+    const float3 poseRot1 = poseMatrix.s456;
+    const float3 poseRot2 = poseMatrix.s89a;
+    const float3 poseTrans = poseMatrix.s37b;
+
+    const float2 oldEdge = (float2)(oldSize.x - 1, oldSize.y - 1);
+
+    __global const ptype* newPtsRow = (__global const ptype*)(newPointsptr +
+                                                              newPoints_offset +
+                                                              y*newPoints_step);
+
+    __global const ptype* newNrmRow = (__global const ptype*)(newNormalsptr +
+                                                              newNormals_offset +
+                                                              y*newNormals_step);
+
+    float3 newP = newPtsRow[x].xyz;
+    float3 newN = newNrmRow[x].xyz;
+
+    if( any(isnan(newP)) || any(isnan(newN)) ||
+        any(isinf(newP)) || any(isinf(newN)) )
+        return;
+
+    //transform to old coord system
+    newP = (float3)(dot(newP, poseRot0),
+                    dot(newP, poseRot1),
+                    dot(newP, poseRot2)) + poseTrans;
+    newN = (float3)(dot(newN, poseRot0),
+                    dot(newN, poseRot1),
+                    dot(newN, poseRot2));
+
+    //find correspondence by projecting the point
+    float2 oldCoords = (newP.xy/newP.z)*fxy+cxy;
+
+    if(!(all(oldCoords >= 0.f) && all(oldCoords < oldEdge)))
+        return;
+
+    // bilinearly interpolate oldPts and oldNrm under oldCoords point
+    float3 oldP, oldN;
+    float2 ip = floor(oldCoords);
+    float2 t = oldCoords - ip;
+    int xi = ip.x, yi = ip.y;
+
+    __global const ptype* prow0 = (__global const ptype*)(oldPointsptr +
+                                                          oldPoints_offset +
+                                                          (yi+0)*oldPoints_step);
+    __global const ptype* prow1 = (__global const ptype*)(oldPointsptr +
+                                                          oldPoints_offset +
+                                                          (yi+1)*oldPoints_step);
+    float3 p00 = prow0[xi+0].xyz;
+    float3 p01 = prow0[xi+1].xyz;
+    float3 p10 = prow1[xi+0].xyz;
+    float3 p11 = prow1[xi+1].xyz;
+
+    // NaN check is done later
+
+    __global const ptype* nrow0 = (__global const ptype*)(oldNormalsptr +
+                                                          oldNormals_offset +
+                                                          (yi+0)*oldNormals_step);
+    __global const ptype* nrow1 = (__global const ptype*)(oldNormalsptr +
+                                                          oldNormals_offset +
+                                                          (yi+1)*oldNormals_step);
+
+    float3 n00 = nrow0[xi+0].xyz;
+    float3 n01 = nrow0[xi+1].xyz;
+    float3 n10 = nrow1[xi+0].xyz;
+    float3 n11 = nrow1[xi+1].xyz;
+
+    // NaN check is done later
+
+    float3 p0 = mix(p00, p01, t.x);
+    float3 p1 = mix(p10, p11, t.x);
+    oldP = mix(p0, p1, t.y);
+
+    float3 n0 = mix(n00, n01, t.x);
+    float3 n1 = mix(n10, n11, t.x);
+    oldN = mix(n0, n1, t.y);
+
+    if( any(isnan(oldP)) || any(isnan(oldN)) ||
+        any(isinf(oldP)) || any(isinf(oldN)) )
+        return;
+
+    //filter by distance
+    float3 diff = newP - oldP;
+    if(dot(diff, diff) > sqDistanceThresh)
+        return;
+
+    //filter by angle
+    if(fabs(dot(newN, oldN)) < minCos)
+        return;
+
+    // build point-wise vector ab = [ A | b ]
+
+    float3 VxN = cross(newP, oldN);
+    float ab[7] = {VxN.x, VxN.y, VxN.z, oldN.x, oldN.y, oldN.z, -dot(oldN, diff)};
+
+    for(int i = 0; i < 7; i++)
+        ab7[i] = ab[i];
+}
+
+
+__kernel void getAb(__global const char * oldPointsptr,
+                    int oldPoints_step, int oldPoints_offset,
+                    __global const char * oldNormalsptr,
+                    int oldNormals_step, int oldNormals_offset,
+                    const int2 oldSize,
+                    __global const char * newPointsptr,
+                    int newPoints_step, int newPoints_offset,
+                    __global const char * newNormalsptr,
+                    int newNormals_step, int newNormals_offset,
+                    const int2 newSize,
+                    const float16 poseMatrix,
+                    const float2 fxy,
+                    const float2 cxy,
+                    const float sqDistanceThresh,
+                    const float minCos,
+                    __local float * reducebuf,
+                    __global char* groupedSumptr,
+                    int groupedSum_step, int groupedSum_offset
+)
+{
+    const int x = get_global_id(0);
+    const int y = get_global_id(1);
+
+    const int gx = get_group_id(0);
+    const int gy = get_group_id(1);
+    const int gw = get_num_groups(0);
+    const int gh = get_num_groups(1);
+
+    const int lx = get_local_id(0);
+    const int ly = get_local_id(1);
+    const int lw = get_local_size(0);
+    const int lh = get_local_size(1);
+    const int lsz = lw*lh;
+    const int lid = lx + ly*lw;
+
+    float ab[7];
+    for(int i = 0; i < 7; i++)
+        ab[i] = 0;
+
+    calcAb7(oldPointsptr,
+            oldPoints_step, oldPoints_offset,
+            oldNormalsptr,
+            oldNormals_step, oldNormals_offset,
+            oldSize,
+            newPointsptr,
+            newPoints_step, newPoints_offset,
+            newNormalsptr,
+            newNormals_step, newNormals_offset,
+            newSize,
+            poseMatrix,
+            fxy, cxy,
+            sqDistanceThresh,
+            minCos,
+            ab);
+
+    // build point-wise upper-triangle matrix [ab^T * ab] w/o last row
+    // which is [A^T*A | A^T*b]
+    // and gather sum
+
+    __local float* upperTriangle = reducebuf + lid*UTSIZE;
+
+    int pos = 0;
+    for(int i = 0; i < 6; i++)
+    {
+        for(int j = i; j < 7; j++)
+        {
+            upperTriangle[pos++] = ab[i]*ab[j];
+        }
+    }
+
+    // reduce upperTriangle to local mem
+
+    // maxStep = ctz(lsz), ctz isn't supported on CUDA devices
+    const int c = clz(lsz & -lsz);
+    const int maxStep = c ? 31 - c : c;
+    for(int nstep = 1; nstep <= maxStep; nstep++)
+    {
+        if(lid % (1 << nstep) == 0)
+        {
+            __local float* rto   = reducebuf + UTSIZE*lid;
+            __local float* rfrom = reducebuf + UTSIZE*(lid+(1 << (nstep-1)));
+            for(int i = 0; i < UTSIZE; i++)
+                rto[i] += rfrom[i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // here group sum should be in reducebuf[0...UTSIZE]
+    if(lid == 0)
+    {
+        __global float* groupedRow = (__global float*)(groupedSumptr +
+                                                       groupedSum_offset +
+                                                       gy*groupedSum_step);
+
+        for(int i = 0; i < UTSIZE; i++)
+            groupedRow[gx*UTSIZE + i] = reducebuf[i];
+    }
+}
diff --git a/upstream/opencv/modules/ptcloud/src/opencl/kinfu_frame.cl b/upstream/opencv/modules/ptcloud/src/opencl/kinfu_frame.cl
new file mode 100644
index 0000000..9ed66b7
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/opencl/kinfu_frame.cl
@@ -0,0 +1,288 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+inline float3 reproject(float3 p, float2 fxyinv, float2 cxy)
+{
+    float2 pp = p.z*(p.xy - cxy)*fxyinv;
+    return (float3)(pp, p.z);
+}
+
+typedef float4 ptype;
+
+__kernel void computePointsNormals(__global char * pointsptr,
+                                   int points_step, int points_offset,
+                                   __global char * normalsptr,
+                                   int normals_step, int normals_offset,
+                                   __global const char * depthptr,
+                                   int depth_step, int depth_offset,
+                                   int depth_rows, int depth_cols,
+                                   const float2 fxyinv,
+                                   const float2 cxy,
+                                   const float dfac
+                                    )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= depth_cols || y >= depth_rows)
+        return;
+
+    __global const float* row0 = (__global const float*)(depthptr + depth_offset +
+                                                         (y+0)*depth_step);
+    __global const float* row1 = (__global const float*)(depthptr + depth_offset +
+                                                         (y+1)*depth_step);
+
+    float d00 = row0[x];
+    float z00 = d00*dfac;
+    float3 p00 = (float3)(convert_float2((int2)(x, y)), z00);
+    float3 v00 = reproject(p00, fxyinv, cxy);
+
+    float3 p = nan((uint)0), n = nan((uint)0);
+
+    if(x < depth_cols - 1 && y < depth_rows - 1)
+    {
+        float d01 = row0[x+1];
+        float d10 = row1[x];
+
+        float z01 = d01*dfac;
+        float z10 = d10*dfac;
+
+        if(z00 != 0 && z01 != 0 && z10 != 0)
+        {
+            float3 p01 = (float3)(convert_float2((int2)(x+1, y+0)), z01);
+            float3 p10 = (float3)(convert_float2((int2)(x+0, y+1)), z10);
+            float3 v01 = reproject(p01, fxyinv, cxy);
+            float3 v10 = reproject(p10, fxyinv, cxy);
+
+            float3 vec = cross(v01 - v00, v10 - v00);
+            n = - normalize(vec);
+            p = v00;
+        }
+    }
+
+    __global float* pts = (__global float*)(pointsptr  +  points_offset + y*points_step  + x*sizeof(ptype));
+    __global float* nrm = (__global float*)(normalsptr + normals_offset + y*normals_step + x*sizeof(ptype));
+    vstore4((ptype)(p, 0), 0, pts);
+    vstore4((ptype)(n, 0), 0, nrm);
+}
+
+__kernel void pyrDownBilateral(__global const char * depthptr,
+                               int depth_step, int depth_offset,
+                               int depth_rows, int depth_cols,
+                               __global char * depthDownptr,
+                               int depthDown_step, int depthDown_offset,
+                               int depthDown_rows, int depthDown_cols,
+                               const float sigma
+                               )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= depthDown_cols || y >= depthDown_rows)
+        return;
+
+    const float sigma3 = sigma*3;
+    const int D = 5;
+
+    __global const float* srcCenterRow = (__global const float*)(depthptr + depth_offset +
+                                                                 (2*y)*depth_step);
+
+    float center = srcCenterRow[2*x];
+
+    int sx = max(0, 2*x - D/2), ex = min(2*x - D/2 + D, depth_cols-1);
+    int sy = max(0, 2*y - D/2), ey = min(2*y - D/2 + D, depth_rows-1);
+
+    float sum = 0;
+    int count = 0;
+
+    for(int iy = sy; iy < ey; iy++)
+    {
+        __global const float* srcRow = (__global const float*)(depthptr + depth_offset +
+                                                               (iy)*depth_step);
+        for(int ix = sx; ix < ex; ix++)
+        {
+            float val = srcRow[ix];
+            if(fabs(val - center) < sigma3)
+            {
+                sum += val; count++;
+            }
+        }
+    }
+
+    __global float* downRow = (__global float*)(depthDownptr + depthDown_offset +
+                                                y*depthDown_step + x*sizeof(float));
+
+    *downRow = (count == 0) ? 0 : sum/convert_float(count);
+}
+
+//TODO: remove bilateral when OpenCV performs 32f bilat with OpenCL
+
+__kernel void customBilateral(__global const char * srcptr,
+                              int src_step, int src_offset,
+                              __global char * dstptr,
+                              int dst_step, int dst_offset,
+                              const int2 frameSize,
+                              const int kernelSize,
+                              const float sigma_spatial2_inv_half,
+                              const float sigma_depth2_inv_half
+)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= frameSize.x || y >= frameSize.y)
+        return;
+
+    __global const float* srcCenterRow = (__global const float*)(srcptr + src_offset +
+                                                                 y*src_step);
+    float value = srcCenterRow[x];
+
+    int tx = min (x - kernelSize / 2 + kernelSize, frameSize.x - 1);
+    int ty = min (y - kernelSize / 2 + kernelSize, frameSize.y - 1);
+
+    float sum1 = 0;
+    float sum2 = 0;
+
+    for (int cy = max (y - kernelSize / 2, 0); cy < ty; ++cy)
+    {
+        __global const float* srcRow = (__global const float*)(srcptr + src_offset +
+                                                               cy*src_step);
+        for (int cx = max (x - kernelSize / 2, 0); cx < tx; ++cx)
+        {
+            float depth = srcRow[cx];
+
+            float space2 = convert_float((x - cx) * (x - cx) + (y - cy) * (y - cy));
+            float color2 = (value - depth) * (value - depth);
+
+            float weight = native_exp (-(space2 * sigma_spatial2_inv_half +
+                                         color2 * sigma_depth2_inv_half));
+
+            sum1 += depth * weight;
+            sum2 += weight;
+        }
+    }
+
+    __global float* dst = (__global float*)(dstptr + dst_offset +
+                                            y*dst_step + x*sizeof(float));
+    *dst = sum1/sum2;
+}
+
+__kernel void pyrDownPointsNormals(__global const char * pptr,
+                                   int p_step, int p_offset,
+                                   __global const char * nptr,
+                                   int n_step, int n_offset,
+                                   __global char * pdownptr,
+                                   int pdown_step, int pdown_offset,
+                                   __global char * ndownptr,
+                                   int ndown_step, int ndown_offset,
+                                   const int2 downSize
+                                   )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= downSize.x || y >= downSize.y)
+        return;
+
+    float3 point = nan((uint)0), normal = nan((uint)0);
+
+    __global const ptype* pUpRow0 = (__global const ptype*)(pptr + p_offset + (2*y  )*p_step);
+    __global const ptype* pUpRow1 = (__global const ptype*)(pptr + p_offset + (2*y+1)*p_step);
+
+    float3 d00 = pUpRow0[2*x  ].xyz;
+    float3 d01 = pUpRow0[2*x+1].xyz;
+    float3 d10 = pUpRow1[2*x  ].xyz;
+    float3 d11 = pUpRow1[2*x+1].xyz;
+
+    if(!(any(isnan(d00)) || any(isnan(d01)) ||
+         any(isnan(d10)) || any(isnan(d11))))
+    {
+        point = (d00 + d01 + d10 + d11)*0.25f;
+
+        __global const ptype* nUpRow0 = (__global const ptype*)(nptr + n_offset + (2*y  )*n_step);
+        __global const ptype* nUpRow1 = (__global const ptype*)(nptr + n_offset + (2*y+1)*n_step);
+
+        float3 n00 = nUpRow0[2*x  ].xyz;
+        float3 n01 = nUpRow0[2*x+1].xyz;
+        float3 n10 = nUpRow1[2*x  ].xyz;
+        float3 n11 = nUpRow1[2*x+1].xyz;
+
+        normal = (n00 + n01 + n10 + n11)*0.25f;
+    }
+
+    __global ptype* pts = (__global ptype*)(pdownptr + pdown_offset + y*pdown_step);
+    __global ptype* nrm = (__global ptype*)(ndownptr + ndown_offset + y*ndown_step);
+    pts[x] = (ptype)(point,  0);
+    nrm[x] = (ptype)(normal, 0);
+}
+
+typedef char4 pixelType;
+
+// 20 is fixed power
+float specPow20(float x)
+{
+    float x2 = x*x;
+    float x5 = x2*x2*x;
+    float x10 = x5*x5;
+    float x20 = x10*x10;
+    return x20;
+}
+
+__kernel void render(__global const char * pointsptr,
+                     int points_step, int points_offset,
+                     __global const char * normalsptr,
+                     int normals_step, int normals_offset,
+                     __global char * imgptr,
+                     int img_step, int img_offset,
+                     const int2 frameSize,
+                     const float4 lightPt
+                    )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= frameSize.x || y >= frameSize.y)
+        return;
+
+    __global const ptype* ptsRow = (__global const ptype*)(pointsptr  + points_offset  + y*points_step  + x*sizeof(ptype));
+    __global const ptype* nrmRow = (__global const ptype*)(normalsptr + normals_offset + y*normals_step + x*sizeof(ptype));
+
+    float3 p = (*ptsRow).xyz;
+    float3 n = (*nrmRow).xyz;
+
+    pixelType color;
+
+    if(any(isnan(p)))
+    {
+        color = (pixelType)(0, 32, 0, 0);
+    }
+    else
+    {
+        const float Ka = 0.3f;  //ambient coeff
+        const float Kd = 0.5f;  //diffuse coeff
+        const float Ks = 0.2f;  //specular coeff
+        //const int   sp = 20;  //specular power, fixed in specPow20()
+
+        const float Ax = 1.f;   //ambient color,  can be RGB
+        const float Dx = 1.f;   //diffuse color,  can be RGB
+        const float Sx = 1.f;   //specular color, can be RGB
+        const float Lx = 1.f;   //light color
+
+        float3 l = normalize(lightPt.xyz - p);
+        float3 v = normalize(-p);
+        float3 r = normalize(2.f*n*dot(n, l) - l);
+
+        float val = (Ax*Ka*Dx + Lx*Kd*Dx*max(0.f, dot(n, l)) +
+                     Lx*Ks*Sx*specPow20(max(0.f, dot(r, v))));
+
+        uchar ix = convert_uchar(val*255.f);
+        color = (pixelType)(ix, ix, ix, 0);
+    }
+
+    __global char* imgRow = (__global char*)(imgptr + img_offset + y*img_step + x*sizeof(pixelType));
+    vstore4(color, 0, imgRow);
+}
diff --git a/upstream/opencv/modules/ptcloud/src/opencl/tsdf.cl b/upstream/opencv/modules/ptcloud/src/opencl/tsdf.cl
new file mode 100644
index 0000000..fe7bb34
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/opencl/tsdf.cl
@@ -0,0 +1,856 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+typedef char int8_t;
+typedef int8_t TsdfType;
+typedef uchar WeightType;
+
+struct TsdfVoxel
+{
+    TsdfType tsdf;
+    WeightType weight;
+};
+
+static inline TsdfType floatToTsdf(float num)
+{
+    int8_t res = (int8_t) ( (num * (-128)) );
+    res = res ? res : (num < 0 ? 1 : -1);
+    return res;
+}
+
+static inline float tsdfToFloat(TsdfType num)
+{
+    return ( (float) num ) / (-128);
+}
+
+__kernel void integrate(__global const char * depthptr,
+                        int depth_step, int depth_offset,
+                        int depth_rows, int depth_cols,
+                        __global struct TsdfVoxel * volumeptr,
+                        __global const float * vol2camptr,
+                        const float voxelSize,
+                        const int4 volResolution4,
+                        const int4 volDims4,
+                        const float2 fxy,
+                        const float2 cxy,
+                        const float dfac,
+                        const float truncDist,
+                        const int maxWeight,
+                        const __global float * pixNorms)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    const int3 volResolution = volResolution4.xyz;
+
+    if(x >= volResolution.x || y >= volResolution.y)
+        return;
+
+    // coord-independent constants
+    const int3 volDims = volDims4.xyz;
+    const float2 limits = (float2)(depth_cols-1, depth_rows-1);
+
+    __global const float* vm = vol2camptr;
+    const float4 vol2cam0 = vload4(0, vm);
+    const float4 vol2cam1 = vload4(1, vm);
+    const float4 vol2cam2 = vload4(2, vm);
+
+    const float truncDistInv = 1.f/truncDist;
+
+    // optimization of camSpace transformation (vector addition instead of matmul at each z)
+    float4 inPt = (float4)(x*voxelSize, y*voxelSize, 0, 1);
+    float3 basePt = (float3)(dot(vol2cam0, inPt),
+                             dot(vol2cam1, inPt),
+                             dot(vol2cam2, inPt));
+
+    float3 camSpacePt = basePt;
+
+    // zStep == vol2cam*(float3(x, y, 1)*voxelSize) - basePt;
+    float3 zStep = ((float3)(vol2cam0.z, vol2cam1.z, vol2cam2.z))*voxelSize;
+
+    int volYidx = x*volDims.x + y*volDims.y;
+
+    int startZ, endZ;
+    if(fabs(zStep.z) > 1e-5f)
+    {
+        int baseZ = convert_int(-basePt.z / zStep.z);
+        if(zStep.z > 0)
+        {
+            startZ = baseZ;
+            endZ = volResolution.z;
+        }
+        else
+        {
+            startZ = 0;
+            endZ = baseZ;
+        }
+    }
+    else
+    {
+        if(basePt.z > 0)
+        {
+            startZ = 0; endZ = volResolution.z;
+        }
+        else
+        {
+            // z loop shouldn't be performed
+            //startZ = endZ = 0;
+            return;
+        }
+    }
+
+    startZ = max(0, startZ);
+    endZ = min(volResolution.z, endZ);
+
+    for(int z = startZ; z < endZ; z++)
+    {
+        // optimization of the following:
+        //float3 camSpacePt = vol2cam * ((float3)(x, y, z)*voxelSize);
+        camSpacePt += zStep;
+
+        if(camSpacePt.z <= 0)
+            continue;
+
+        float3 camPixVec = camSpacePt / camSpacePt.z;
+        float2 projected = mad(camPixVec.xy, fxy, cxy);
+
+        float v;
+        // bilinearly interpolate depth at projected
+        if(all(projected >= 0) && all(projected < limits))
+        {
+            float2 ip = floor(projected);
+            int xi = ip.x, yi = ip.y;
+
+            __global const float* row0 = (__global const float*)(depthptr + depth_offset +
+                                                                 (yi+0)*depth_step);
+            __global const float* row1 = (__global const float*)(depthptr + depth_offset +
+                                                                 (yi+1)*depth_step);
+
+            float v00 = row0[xi+0];
+            float v01 = row0[xi+1];
+            float v10 = row1[xi+0];
+            float v11 = row1[xi+1];
+            float4 vv = (float4)(v00, v01, v10, v11);
+
+            // assume correct depth is positive
+            if(all(vv > 0))
+            {
+                float2 t = projected - ip;
+                float2 vf = mix(vv.xz, vv.yw, t.x);
+                v = mix(vf.s0, vf.s1, t.y);
+            }
+            else
+                continue;
+        }
+        else
+            continue;
+
+        if(v == 0)
+            continue;
+
+        int idx = projected.y * depth_cols + projected.x;
+        float pixNorm = pixNorms[idx];
+        //float pixNorm = length(camPixVec);
+
+        // difference between distances of point and of surface to camera
+        float sdf = pixNorm*(v*dfac - camSpacePt.z);
+        // possible alternative is:
+        // float sdf = length(camSpacePt)*(v*dfac/camSpacePt.z - 1.0);
+
+        if(sdf >= -truncDist)
+        {
+            float tsdf = fmin(1.0f, sdf * truncDistInv);
+            int volIdx = volYidx + z*volDims.z;
+
+            struct TsdfVoxel voxel = volumeptr[volIdx];
+            float value  = tsdfToFloat(voxel.tsdf);
+            int weight = voxel.weight;
+
+            // update TSDF
+            value = (value*weight + tsdf) / (weight + 1);
+            weight = min(weight + 1, maxWeight);
+
+            voxel.tsdf = floatToTsdf(value);
+            voxel.weight = weight;
+            volumeptr[volIdx] = voxel;
+        }
+    }
+}
+
+
+inline float interpolateVoxel(float3 p, __global const struct TsdfVoxel* volumePtr,
+                              int3 volDims, int8 neighbourCoords)
+{
+    float3 fip = floor(p);
+    int3 ip = convert_int3(fip);
+    float3 t = p - fip;
+
+    int3 cmul = volDims*ip;
+    int coordBase = cmul.x + cmul.y + cmul.z;
+    int nco[8];
+    vstore8(neighbourCoords + coordBase, 0, nco);
+
+    float vaz[8];
+    for(int i = 0; i < 8; i++)
+        vaz[i] = tsdfToFloat(volumePtr[nco[i]].tsdf);
+
+    float8 vz = vload8(0, vaz);
+
+    float4 vy = mix(vz.s0246, vz.s1357, t.z);
+    float2 vx = mix(vy.s02, vy.s13, t.y);
+    return mix(vx.s0, vx.s1, t.x);
+}
+
+inline float3 getNormalVoxel(float3 p, __global const struct TsdfVoxel* volumePtr,
+                             int3 volResolution, int3 volDims, int8 neighbourCoords)
+{
+    if(any(p < 1) || any(p >= convert_float3(volResolution - 2)))
+        return nan((uint)0);
+
+    float3 fip = floor(p);
+    int3 ip = convert_int3(fip);
+    float3 t = p - fip;
+
+    int3 cmul = volDims*ip;
+    int coordBase = cmul.x + cmul.y + cmul.z;
+    int nco[8];
+    vstore8(neighbourCoords + coordBase, 0, nco);
+
+    int arDims[3];
+    vstore3(volDims, 0, arDims);
+    float an[3];
+    for(int c = 0; c < 3; c++)
+    {
+        int dim = arDims[c];
+
+        float vaz[8];
+        for(int i = 0; i < 8; i++)
+            vaz[i] = tsdfToFloat(volumePtr[nco[i] + dim].tsdf) -
+                     tsdfToFloat(volumePtr[nco[i] - dim].tsdf);
+
+        float8 vz = vload8(0, vaz);
+
+        float4 vy = mix(vz.s0246, vz.s1357, t.z);
+        float2 vx = mix(vy.s02, vy.s13, t.y);
+
+        an[c] = mix(vx.s0, vx.s1, t.x);
+    }
+
+    //gradientDeltaFactor is fixed at 1.0 of voxel size
+    float3 n = vload3(0, an);
+    float Norm = sqrt(n.x*n.x + n.y*n.y + n.z*n.z);
+    return Norm < 0.0001f ? nan((uint)0) : n / Norm;
+    //return fast_normalize(vload3(0, an));
+}
+
+typedef float4 ptype;
+
+__kernel void raycast(__global char * pointsptr,
+                      int points_step, int points_offset,
+                      __global char * normalsptr,
+                      int normals_step, int normals_offset,
+                      const int2 frameSize,
+                      __global const struct TsdfVoxel * volumeptr,
+                      __global const float * vol2camptr,
+                      __global const float * cam2volptr,
+                      const float2 fixy,
+                      const float2 cxy,
+                      const float4 boxDown4,
+                      const float4 boxUp4,
+                      const float tstep,
+                      const float voxelSize,
+                      const int4 volResolution4,
+                      const int4 volDims4,
+                      const int8 neighbourCoords
+                      )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= frameSize.x || y >= frameSize.y)
+        return;
+
+    // coordinate-independent constants
+
+    __global const float* cm = cam2volptr;
+    const float3 camRot0  = vload4(0, cm).xyz;
+    const float3 camRot1  = vload4(1, cm).xyz;
+    const float3 camRot2  = vload4(2, cm).xyz;
+    const float3 camTrans = (float3)(cm[3], cm[7], cm[11]);
+
+    __global const float* vm = vol2camptr;
+    const float3 volRot0  = vload4(0, vm).xyz;
+    const float3 volRot1  = vload4(1, vm).xyz;
+    const float3 volRot2  = vload4(2, vm).xyz;
+    const float3 volTrans = (float3)(vm[3], vm[7], vm[11]);
+
+    const float3 boxDown = boxDown4.xyz;
+    const float3 boxUp   = boxUp4.xyz;
+    const int3   volDims = volDims4.xyz;
+
+    const int3 volResolution = volResolution4.xyz;
+
+    const float invVoxelSize = native_recip(voxelSize);
+
+    // kernel itself
+
+    float3 point  = nan((uint)0);
+    float3 normal = nan((uint)0);
+
+    float3 orig = camTrans;
+
+    // get direction through pixel in volume space:
+    // 1. reproject (x, y) on projecting plane where z = 1.f
+    float3 planed = (float3)(((float2)(x, y) - cxy)*fixy, 1.f);
+
+    // 2. rotate to volume space
+    planed = (float3)(dot(planed, camRot0),
+                      dot(planed, camRot1),
+                      dot(planed, camRot2));
+
+    // 3. normalize
+    float3 dir = fast_normalize(planed);
+
+    // compute intersection of ray with all six bbox planes
+    float3 rayinv = native_recip(dir);
+    float3 tbottom = rayinv*(boxDown - orig);
+    float3 ttop    = rayinv*(boxUp   - orig);
+
+    // re-order intersections to find smallest and largest on each axis
+    float3 minAx = min(ttop, tbottom);
+    float3 maxAx = max(ttop, tbottom);
+
+    // near clipping plane
+    const float clip = 0.f;
+    float tmin = max(max(max(minAx.x, minAx.y), max(minAx.x, minAx.z)), clip);
+    float tmax =     min(min(maxAx.x, maxAx.y), min(maxAx.x, maxAx.z));
+
+    // precautions against getting coordinates out of bounds
+    tmin = tmin + tstep;
+    tmax = tmax - tstep;
+
+    if(tmin < tmax)
+    {
+        // interpolation optimized a little
+        orig *= invVoxelSize;
+        dir  *= invVoxelSize;
+
+        float3 rayStep = dir*tstep;
+        float3 next = (orig + dir*tmin);
+        float f = interpolateVoxel(next, volumeptr, volDims, neighbourCoords);
+        float fnext = f;
+
+        // raymarch
+        int steps = 0;
+        int nSteps = floor(native_divide(tmax - tmin, tstep));
+        bool stop = false;
+        for(int i = 0; i < nSteps; i++)
+        {
+            // fix for wrong steps counting
+            if(!stop)
+            {
+                next += rayStep;
+
+                // fetch voxel
+                int3 ip = convert_int3(round(next));
+                int3 cmul = ip*volDims;
+                int idx = cmul.x + cmul.y + cmul.z;
+                fnext = tsdfToFloat(volumeptr[idx].tsdf);
+
+                if(fnext != f)
+                {
+                    fnext = interpolateVoxel(next, volumeptr, volDims, neighbourCoords);
+
+                    // when ray crosses a surface
+                    if(signbit(f) != signbit(fnext))
+                    {
+                        stop = true; continue;
+                    }
+
+                    f = fnext;
+                }
+                steps++;
+            }
+        }
+
+        // if ray penetrates a surface from outside
+        // linearly interpolate t between two f values
+        if(f > 0 && fnext < 0)
+        {
+            float3 tp = next - rayStep;
+            float ft   = interpolateVoxel(tp,   volumeptr, volDims, neighbourCoords);
+            float ftdt = interpolateVoxel(next, volumeptr, volDims, neighbourCoords);
+            // float t = tmin + steps*tstep;
+            // float ts = t - tstep*ft/(ftdt - ft);
+            float ts = tmin + tstep*(steps - native_divide(ft, ftdt - ft));
+
+            // avoid division by zero
+            if(!isnan(ts) && !isinf(ts))
+            {
+                float3 pv = orig + dir*ts;
+                float3 nv = getNormalVoxel(pv, volumeptr, volResolution, volDims, neighbourCoords);
+
+                if(!any(isnan(nv)))
+                {
+                    //convert pv and nv to camera space
+                    normal = (float3)(dot(nv, volRot0),
+                                      dot(nv, volRot1),
+                                      dot(nv, volRot2));
+                    // interpolation optimized a little
+                    pv *= voxelSize;
+                    point = (float3)(dot(pv, volRot0),
+                                     dot(pv, volRot1),
+                                     dot(pv, volRot2)) + volTrans;
+                }
+            }
+        }
+    }
+
+    __global float* pts = (__global float*)(pointsptr  +  points_offset + y*points_step  + x*sizeof(ptype));
+    __global float* nrm = (__global float*)(normalsptr + normals_offset + y*normals_step + x*sizeof(ptype));
+    vstore4((float4)(point,  0), 0, pts);
+    vstore4((float4)(normal, 0), 0, nrm);
+}
+
+
+__kernel void getNormals(__global const char * pointsptr,
+                         int points_step, int points_offset,
+                         __global char * normalsptr,
+                         int normals_step, int normals_offset,
+                         const int2 frameSize,
+                         __global const struct TsdfVoxel* volumeptr,
+                         __global const float * volPoseptr,
+                         __global const float * invPoseptr,
+                         const float voxelSizeInv,
+                         const int4 volResolution4,
+                         const int4 volDims4,
+                         const int8 neighbourCoords
+                         )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x >= frameSize.x || y >= frameSize.y)
+        return;
+
+    // coordinate-independent constants
+
+    __global const float* vp = volPoseptr;
+    const float3 volRot0  = vload4(0, vp).xyz;
+    const float3 volRot1  = vload4(1, vp).xyz;
+    const float3 volRot2  = vload4(2, vp).xyz;
+    const float3 volTrans = (float3)(vp[3], vp[7], vp[11]);
+
+    __global const float* iv = invPoseptr;
+    const float3 invRot0 = vload4(0, iv).xyz;
+    const float3 invRot1 = vload4(1, iv).xyz;
+    const float3 invRot2 = vload4(2, iv).xyz;
+    const float3 invTrans = (float3)(iv[3], iv[7], iv[11]);
+
+    const int3 volResolution = volResolution4.xyz;
+    const int3 volDims = volDims4.xyz;
+
+    // kernel itself
+
+    __global const ptype* ptsRow = (__global const ptype*)(pointsptr +
+                                                           points_offset +
+                                                           y*points_step);
+    float3 p = ptsRow[x].xyz;
+    float3 n = nan((uint)0);
+    if(!any(isnan(p)))
+    {
+        float3 voxPt = (float3)(dot(p, invRot0),
+                                dot(p, invRot1),
+                                dot(p, invRot2)) + invTrans;
+        voxPt = voxPt * voxelSizeInv;
+        n = getNormalVoxel(voxPt, volumeptr, volResolution, volDims, neighbourCoords);
+        n = (float3)(dot(n, volRot0),
+                     dot(n, volRot1),
+                     dot(n, volRot2));
+    }
+
+    __global float* nrm = (__global float*)(normalsptr +
+                                            normals_offset +
+                                            y*normals_step +
+                                            x*sizeof(ptype));
+
+    vstore4((float4)(n, 0), 0, nrm);
+}
+
+#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics:enable
+
+struct CoordReturn
+{
+    bool result;
+    float3 point;
+    float3 normal;
+};
+
+inline struct CoordReturn coord(int x, int y, int z, float3 V, float v0, int axis,
+                                __global const struct TsdfVoxel* volumeptr,
+                                int3 volResolution, int3 volDims,
+                                int8 neighbourCoords,
+                                float voxelSize, float voxelSizeInv,
+                                const float3 volRot0,
+                                const float3 volRot1,
+                                const float3 volRot2,
+                                const float3 volTrans,
+                                bool needNormals,
+                                bool scan
+                                )
+{
+    struct CoordReturn cr;
+
+    // 0 for x, 1 for y, 2 for z
+    bool limits = false;
+    int3 shift;
+    float Vc = 0.f;
+    if(axis == 0)
+    {
+        shift = (int3)(1, 0, 0);
+        limits = (x + 1 < volResolution.x);
+        Vc = V.x;
+    }
+    if(axis == 1)
+    {
+        shift = (int3)(0, 1, 0);
+        limits = (y + 1 < volResolution.y);
+        Vc = V.y;
+    }
+    if(axis == 2)
+    {
+        shift = (int3)(0, 0, 1);
+        limits = (z + 1 < volResolution.z);
+        Vc = V.z;
+    }
+
+    if(limits)
+    {
+        int3 ip = ((int3)(x, y, z)) + shift;
+        int3 cmul = ip*volDims;
+        int idx = cmul.x + cmul.y + cmul.z;
+
+        struct TsdfVoxel voxel = volumeptr[idx];
+        float vd  = tsdfToFloat(voxel.tsdf);
+        int weight = voxel.weight;
+
+        if(weight != 0 && vd != 1.f)
+        {
+            if((v0 > 0 && vd < 0) || (v0 < 0 && vd > 0))
+            {
+                // calc actual values or estimate amount of space
+                if(!scan)
+                {
+                    // linearly interpolate coordinate
+                    float Vn = Vc + voxelSize;
+                    float dinv = 1.f/(fabs(v0)+fabs(vd));
+                    float inter = (Vc*fabs(vd) + Vn*fabs(v0))*dinv;
+
+                    float3 p = (float3)(shift.x ? inter : V.x,
+                                        shift.y ? inter : V.y,
+                                        shift.z ? inter : V.z);
+
+                    cr.point = (float3)(dot(p, volRot0),
+                                        dot(p, volRot1),
+                                        dot(p, volRot2)) + volTrans;
+
+                    if(needNormals)
+                    {
+                        float3 nv = getNormalVoxel(p * voxelSizeInv,
+                                                   volumeptr, volResolution, volDims, neighbourCoords);
+
+                        cr.normal = (float3)(dot(nv, volRot0),
+                                             dot(nv, volRot1),
+                                             dot(nv, volRot2));
+                    }
+                }
+
+                cr.result = true;
+                return cr;
+            }
+        }
+    }
+
+    cr.result = false;
+    return cr;
+}
+
+
+__kernel void scanSize(__global const struct TsdfVoxel* volumeptr,
+                       const int4 volResolution4,
+                       const int4 volDims4,
+                       const int8 neighbourCoords,
+                       __global const float * volPoseptr,
+                       const float voxelSize,
+                       const float voxelSizeInv,
+                       __local int* reducebuf,
+                       __global char* groupedSumptr,
+                       int groupedSum_slicestep,
+                       int groupedSum_step, int groupedSum_offset
+                       )
+{
+    const int3 volDims = volDims4.xyz;
+    const int3 volResolution = volResolution4.xyz;
+
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    int z = get_global_id(2);
+
+    bool validVoxel = true;
+    if(x >= volResolution.x || y >= volResolution.y || z >= volResolution.z)
+        validVoxel = false;
+
+    const int gx = get_group_id(0);
+    const int gy = get_group_id(1);
+    const int gz = get_group_id(2);
+
+    const int lx = get_local_id(0);
+    const int ly = get_local_id(1);
+    const int lz = get_local_id(2);
+    const int lw = get_local_size(0);
+    const int lh = get_local_size(1);
+    const int ld = get_local_size(2);
+    const int lsz = lw*lh*ld;
+    const int lid = lx + ly*lw + lz*lw*lh;
+
+    // coordinate-independent constants
+
+    __global const float* vp = volPoseptr;
+    const float3 volRot0  = vload4(0, vp).xyz;
+    const float3 volRot1  = vload4(1, vp).xyz;
+    const float3 volRot2  = vload4(2, vp).xyz;
+    const float3 volTrans = (float3)(vp[3], vp[7], vp[11]);
+
+    // kernel itself
+    int npts = 0;
+    if(validVoxel)
+    {
+        int3 ip = (int3)(x, y, z);
+        int3 cmul = ip*volDims;
+        int idx = cmul.x + cmul.y + cmul.z;
+        struct TsdfVoxel voxel = volumeptr[idx];
+        float value  = tsdfToFloat(voxel.tsdf);
+        int weight = voxel.weight;
+
+        // if voxel is not empty
+        if(weight != 0 && value != 1.f)
+        {
+            float3 V = (((float3)(x, y, z)) + 0.5f)*voxelSize;
+
+            #pragma unroll
+            for(int i = 0; i < 3; i++)
+            {
+                struct CoordReturn cr;
+                cr = coord(x, y, z, V, value, i,
+                           volumeptr, volResolution, volDims,
+                           neighbourCoords,
+                           voxelSize, voxelSizeInv,
+                           volRot0, volRot1, volRot2, volTrans,
+                           false, true);
+                if(cr.result)
+                {
+                    npts++;
+                }
+            }
+        }
+    }
+
+    // reducebuf keeps counters for each thread
+    reducebuf[lid] = npts;
+
+    // reduce counter to local mem
+
+    // maxStep = ctz(lsz), ctz isn't supported on CUDA devices
+    const int c = clz(lsz & -lsz);
+    const int maxStep = c ? 31 - c : c;
+    for(int nstep = 1; nstep <= maxStep; nstep++)
+    {
+        if(lid % (1 << nstep) == 0)
+        {
+            int rto   = lid;
+            int rfrom = lid + (1 << (nstep-1));
+            reducebuf[rto] += reducebuf[rfrom];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    if(lid == 0)
+    {
+        __global int* groupedRow = (__global int*)(groupedSumptr +
+                                                   groupedSum_offset +
+                                                   gy*groupedSum_step +
+                                                   gz*groupedSum_slicestep);
+
+        groupedRow[gx] = reducebuf[0];
+    }
+}
+
+
+__kernel void fillPtsNrm(__global const struct TsdfVoxel* volumeptr,
+                         const int4 volResolution4,
+                         const int4 volDims4,
+                         const int8 neighbourCoords,
+                         __global const float * volPoseptr,
+                         const float voxelSize,
+                         const float voxelSizeInv,
+                         const int needNormals,
+                         __local float* localbuf,
+                         volatile __global int* atomicCtr,
+                         __global const char* groupedSumptr,
+                         int groupedSum_slicestep,
+                         int groupedSum_step, int groupedSum_offset,
+                         __global char * pointsptr,
+                         int points_step, int points_offset,
+                         __global char * normalsptr,
+                         int normals_step, int normals_offset
+                         )
+{
+    const int3 volDims = volDims4.xyz;
+    const int3 volResolution = volResolution4.xyz;
+
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    int z = get_global_id(2);
+
+    bool validVoxel = true;
+    if(x >= volResolution.x || y >= volResolution.y || z >= volResolution.z)
+        validVoxel = false;
+
+    const int gx = get_group_id(0);
+    const int gy = get_group_id(1);
+    const int gz = get_group_id(2);
+
+    __global int* groupedRow = (__global int*)(groupedSumptr +
+                                               groupedSum_offset +
+                                               gy*groupedSum_step +
+                                               gz*groupedSum_slicestep);
+
+    // this group contains 0 pts, skip it
+    int nptsGroup = groupedRow[gx];
+    if(nptsGroup == 0)
+        return;
+
+    const int lx = get_local_id(0);
+    const int ly = get_local_id(1);
+    const int lz = get_local_id(2);
+    const int lw = get_local_size(0);
+    const int lh = get_local_size(1);
+    const int ld = get_local_size(2);
+    const int lsz = lw*lh*ld;
+    const int lid = lx + ly*lw + lz*lw*lh;
+
+    // coordinate-independent constants
+
+    __global const float* vp = volPoseptr;
+    const float3 volRot0  = vload4(0, vp).xyz;
+    const float3 volRot1  = vload4(1, vp).xyz;
+    const float3 volRot2  = vload4(2, vp).xyz;
+    const float3 volTrans = (float3)(vp[3], vp[7], vp[11]);
+
+    // kernel itself
+    int npts = 0;
+    float3 parr[3], narr[3];
+    if(validVoxel)
+    {
+        int3 ip = (int3)(x, y, z);
+        int3 cmul = ip*volDims;
+        int idx = cmul.x + cmul.y + cmul.z;
+        struct TsdfVoxel voxel = volumeptr[idx];
+        float value  = tsdfToFloat(voxel.tsdf);
+        int weight = voxel.weight;
+
+        // if voxel is not empty
+        if(weight != 0 && value != 1.f)
+        {
+            float3 V = (((float3)(x, y, z)) + 0.5f)*voxelSize;
+
+            #pragma unroll
+            for(int i = 0; i < 3; i++)
+            {
+                struct CoordReturn cr;
+                cr = coord(x, y, z, V, value, i,
+                           volumeptr, volResolution, volDims,
+                           neighbourCoords,
+                           voxelSize, voxelSizeInv,
+                           volRot0, volRot1, volRot2, volTrans,
+                           needNormals, false);
+
+                if(cr.result)
+                {
+                    parr[npts] = cr.point;
+                    narr[npts] = cr.normal;
+                    npts++;
+                }
+            }
+        }
+    }
+
+    // 4 floats per point or normal
+    const int elemStep = 4;
+
+    __local float* normAddr;
+    __local int localCtr;
+    if(lid == 0)
+        localCtr = 0;
+
+    // push all pts (and nrm) from private array to local mem
+    int privateCtr = 0;
+    barrier(CLK_LOCAL_MEM_FENCE);
+    privateCtr = atomic_add(&localCtr, npts);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for(int i = 0; i < npts; i++)
+    {
+        __local float* addr = localbuf + (privateCtr+i)*elemStep;
+        vstore4((float4)(parr[i], 0), 0, addr);
+    }
+
+    if(needNormals)
+    {
+        normAddr = localbuf + localCtr*elemStep;
+
+        for(int i = 0; i < npts; i++)
+        {
+            __local float* addr = normAddr + (privateCtr+i)*elemStep;
+            vstore4((float4)(narr[i], 0), 0, addr);
+        }
+    }
+
+    // debugging purposes
+    if(lid == 0)
+    {
+        if(localCtr != nptsGroup)
+        {
+            printf("!!! fetchPointsNormals result may be incorrect, npts != localCtr at %3d %3d %3d: %3d vs %3d\n",
+                   gx, gy, gz, localCtr, nptsGroup);
+        }
+    }
+
+    // copy local buffer to global mem
+    __local int whereToWrite;
+    if(lid == 0)
+        whereToWrite = atomic_add(atomicCtr, localCtr);
+    barrier(CLK_GLOBAL_MEM_FENCE);
+
+    event_t ev[2];
+    int evn = 0;
+    // points and normals are 1-column matrices
+    __global float* pts = (__global float*)(pointsptr +
+                                            points_offset +
+                                            whereToWrite*points_step);
+    ev[evn++] = async_work_group_copy(pts, localbuf, localCtr*elemStep, 0);
+
+    if(needNormals)
+    {
+        __global float* nrm = (__global float*)(normalsptr +
+                                                normals_offset +
+                                                whereToWrite*normals_step);
+        ev[evn++] = async_work_group_copy(nrm, normAddr, localCtr*elemStep, 0);
+    }
+
+    wait_group_events(evn, ev);
+}
diff --git a/upstream/opencv/modules/ptcloud/src/plane.cpp b/upstream/opencv/modules/ptcloud/src/plane.cpp
new file mode 100644
index 0000000..70d449d
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/plane.cpp
@@ -0,0 +1,586 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+/** This is an implementation of a fast plane detection loosely inspired by
+ * Fast Plane Detection and Polygonalization in noisy 3D Range Images
+ * Jann Poppinga, Narunas Vaskevicius, Andreas Birk, and Kaustubh Pathak
+ * and the follow-up
+ * Fast Plane Detection for SLAM from Noisy Range Images in
+ * Both Structured and Unstructured Environments
+ * Junhao Xiao, Jianhua Zhang and Jianwei Zhang
+ * Houxiang Zhang and Hans Petter Hildre
+ */
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/** Structure defining a plane. The notations are from the second paper */
+class PlaneBase
+{
+public:
+    PlaneBase(const Vec3f& m, const Vec3f& n_in, int index) :
+        index_(index),
+        n_(n_in),
+        m_sum_(Vec3f(0, 0, 0)),
+        m_(m),
+        Q_(Matx33f::zeros()),
+        mse_(0),
+        K_(0)
+    {
+        UpdateD();
+    }
+
+    virtual
+        ~PlaneBase()
+    {  }
+
+    /** Compute the distance to the plane. This will be implemented by the children to take into account different
+     * sensor models
+     * @param p_j
+     * @return
+     */
+    virtual float distance(const Vec3f& p_j) const = 0;
+
+    /** The d coefficient in the plane equation ax+by+cz+d = 0
+     * @return
+     */
+    inline float d() const
+    {
+        return d_;
+    }
+
+    /** The normal to the plane
+     * @return the normal to the plane
+     */
+    const Vec3f& n() const
+    {
+        return n_;
+    }
+
+    /** Update the different coefficients of the plane, based on the new statistics
+     */
+    void UpdateParameters()
+    {
+        if (empty())
+            return;
+        m_ = m_sum_ / K_;
+        // Compute C
+        Matx33f C = Q_ - m_sum_ * m_.t();
+
+        // Compute n
+        SVD svd(C);
+        n_ = Vec3f(svd.vt.at<float>(2, 0), svd.vt.at<float>(2, 1), svd.vt.at<float>(2, 2));
+        mse_ = svd.w.at<float>(2) / K_;
+
+        UpdateD();
+    }
+
+    /** Update the different sum of point and sum of point*point.t()
+     */
+    void  UpdateStatistics(const Vec3f& point, const Matx33f& Q_local)
+    {
+        m_sum_ += point;
+        Q_ += Q_local;
+        ++K_;
+    }
+
+    inline size_t empty() const
+    {
+        return K_ == 0;
+    }
+
+    inline int
+        K() const
+    {
+        return K_;
+    }
+    /** The index of the plane */
+    int index_;
+protected:
+    /** The 4th coefficient in the plane equation ax+by+cz+d = 0 */
+    float d_;
+    /** Normal of the plane */
+    Vec3f n_;
+private:
+    inline void UpdateD()
+    {
+        d_ = -m_.dot(n_);
+    }
+    /** The sum of the points */
+    Vec3f m_sum_;
+    /** The mean of the points */
+    Vec3f m_;
+    /** The sum of pi * pi^\top */
+    Matx33f Q_;
+    /** The different matrices we need to update */
+    Matx33f C_;
+    float mse_;
+    /** the number of points that form the plane */
+    int K_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Basic planar child, with no sensor error model
+ */
+class Plane : public PlaneBase
+{
+public:
+    Plane(const Vec3f& m, const Vec3f& n_in, int index) :
+        PlaneBase(m, n_in, index)
+    { }
+
+    /** The computed distance is perfect in that case
+     * @param p_j the point to compute its distance to
+     * @return
+     */
+    float distance(const Vec3f& p_j) const CV_OVERRIDE
+    {
+        return std::abs(float(p_j.dot(n_) + d_));
+    }
+};
+
+/** Planar child with a quadratic error model
+ */
+class PlaneABC : public PlaneBase
+{
+public:
+    PlaneABC(const Vec3f& m, const Vec3f& n_in, int index, float sensor_error_a, float sensor_error_b, float sensor_error_c) :
+        PlaneBase(m, n_in, index),
+        sensor_error_a_(sensor_error_a),
+        sensor_error_b_(sensor_error_b),
+        sensor_error_c_(sensor_error_c)
+    {
+    }
+
+    /** The distance is now computed by taking the sensor error into account */
+    inline float distance(const Vec3f& p_j) const CV_OVERRIDE
+    {
+        float cst = p_j.dot(n_) + d_;
+        float err = sensor_error_a_ * p_j[2] * p_j[2] + sensor_error_b_ * p_j[2] + sensor_error_c_;
+        if (((cst - n_[2] * err <= 0) && (cst + n_[2] * err >= 0)) || ((cst + n_[2] * err <= 0) && (cst - n_[2] * err >= 0)))
+            return 0;
+        return std::min(std::abs(cst - err), std::abs(cst + err));
+    }
+private:
+    float sensor_error_a_;
+    float sensor_error_b_;
+    float sensor_error_c_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** The PlaneGrid contains statistic about the individual tiles
+ */
+class PlaneGrid
+{
+public:
+    PlaneGrid(const Mat_<Vec4f>& points3d, int block_size) :
+        block_size_(block_size)
+    {
+        // Figure out some dimensions
+        int mini_rows = points3d.rows / block_size;
+        if (points3d.rows % block_size != 0)
+            ++mini_rows;
+
+        int mini_cols = points3d.cols / block_size;
+        if (points3d.cols % block_size != 0)
+            ++mini_cols;
+
+        // Compute all the interesting quantities
+        m_.create(mini_rows, mini_cols);
+        n_.create(mini_rows, mini_cols);
+        Q_.create(points3d.rows, points3d.cols);
+        mse_.create(mini_rows, mini_cols);
+        for (int y = 0; y < mini_rows; ++y)
+            for (int x = 0; x < mini_cols; ++x)
+            {
+                // Update the tiles
+                Matx33f Q = Matx33f::zeros();
+                Vec3f m = Vec3f(0, 0, 0);
+                int K = 0;
+                for (int j = y * block_size; j < std::min((y + 1) * block_size, points3d.rows); ++j)
+                {
+                    const Vec4f* vec = points3d.ptr < Vec4f >(j, x * block_size), * vec_end;
+                    float* pointpointt = reinterpret_cast<float*>(Q_.ptr < Vec<float, 9> >(j, x * block_size));
+                    if (x == mini_cols - 1)
+                        vec_end = points3d.ptr < Vec4f >(j, points3d.cols - 1) + 1;
+                    else
+                        vec_end = vec + block_size;
+                    for (; vec != vec_end; ++vec, pointpointt += 9)
+                    {
+                        if (cvIsNaN(vec->val[0]))
+                            continue;
+                        // Fill point*point.t()
+                        *pointpointt = vec->val[0] * vec->val[0];
+                        *(pointpointt + 1) = vec->val[0] * vec->val[1];
+                        *(pointpointt + 2) = vec->val[0] * vec->val[2];
+                        *(pointpointt + 3) = *(pointpointt + 1);
+                        *(pointpointt + 4) = vec->val[1] * vec->val[1];
+                        *(pointpointt + 5) = vec->val[1] * vec->val[2];
+                        *(pointpointt + 6) = *(pointpointt + 2);
+                        *(pointpointt + 7) = *(pointpointt + 5);
+                        *(pointpointt + 8) = vec->val[2] * vec->val[2];
+
+                        Q += *reinterpret_cast<Matx33f*>(pointpointt);
+                        m += Vec3f((*vec)[0], (*vec)[1], (*vec)[2]);
+                        ++K;
+                    }
+                }
+                if (K == 0)
+                {
+                    mse_(y, x) = std::numeric_limits<float>::max();
+                    continue;
+                }
+
+                m /= K;
+                m_(y, x) = m;
+
+                // Compute C
+                Matx33f C = Q - K * m * m.t();
+
+                // Compute n
+                SVD svd(C);
+                n_(y, x) = Vec3f(svd.vt.at<float>(2, 0), svd.vt.at<float>(2, 1), svd.vt.at<float>(2, 2));
+                mse_(y, x) = svd.w.at<float>(2) / K;
+            }
+    }
+
+    /** The size of the block */
+    int block_size_;
+    Mat_<Vec3f> m_;
+    Mat_<Vec3f> n_;
+    Mat_<Vec<float, 9> > Q_;
+    Mat_<float> mse_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class TileQueue
+{
+public:
+    struct PlaneTile
+    {
+        PlaneTile(int x, int y, float mse) :
+            x_(x),
+            y_(y),
+            mse_(mse)
+        { }
+
+        bool operator<(const PlaneTile& tile2) const
+        {
+            return mse_ < tile2.mse_;
+        }
+
+        int x_;
+        int y_;
+        float mse_;
+    };
+
+    TileQueue(const PlaneGrid& plane_grid)
+    {
+        done_tiles_ = Mat_<unsigned char>::zeros(plane_grid.mse_.rows, plane_grid.mse_.cols);
+        tiles_.clear();
+        for (int y = 0; y < plane_grid.mse_.rows; ++y)
+            for (int x = 0; x < plane_grid.mse_.cols; ++x)
+                if (plane_grid.mse_(y, x) != std::numeric_limits<float>::max())
+                    // Update the tiles
+                    tiles_.push_back(PlaneTile(x, y, plane_grid.mse_(y, x)));
+        // Sort tiles by MSE
+        tiles_.sort();
+    }
+
+    bool empty()
+    {
+        while (!tiles_.empty())
+        {
+            const PlaneTile& tile = tiles_.front();
+            if (done_tiles_(tile.y_, tile.x_))
+                tiles_.pop_front();
+            else
+                break;
+        }
+        return tiles_.empty();
+    }
+
+    const PlaneTile& front() const
+    {
+        return tiles_.front();
+    }
+
+    void remove(int y, int x)
+    {
+        done_tiles_(y, x) = 1;
+    }
+private:
+    /** The list of tiles ordered from most planar to least */
+    std::list<PlaneTile> tiles_;
+    /** contains 1 when the tiles has been studied, 0 otherwise */
+    Mat_<unsigned char> done_tiles_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class InlierFinder
+{
+public:
+    InlierFinder(float err, const Mat_<Vec4f>& points3d, const Mat_<Vec4f>& normals,
+                 unsigned char plane_index, int block_size) :
+        err_(err),
+        points3d_(points3d),
+        normals_(normals),
+        plane_index_(plane_index),
+        block_size_(block_size)
+    {
+    }
+
+    void Find(const PlaneGrid& plane_grid, Ptr<PlaneBase>& plane, TileQueue& tile_queue,
+              std::set<TileQueue::PlaneTile>& neighboring_tiles, Mat_<unsigned char>& overall_mask,
+              Mat_<unsigned char>& plane_mask)
+    {
+        // Do not use reference as we pop the from later on
+        TileQueue::PlaneTile tile = *(neighboring_tiles.begin());
+
+        // Figure the part of the image to look at
+        Range range_x, range_y;
+        int x = tile.x_ * block_size_, y = tile.y_ * block_size_;
+
+        if (tile.x_ == plane_mask.cols - 1)
+            range_x = Range(x, overall_mask.cols);
+        else
+            range_x = Range(x, x + block_size_);
+
+        if (tile.y_ == plane_mask.rows - 1)
+            range_y = Range(y, overall_mask.rows);
+        else
+            range_y = Range(y, y + block_size_);
+
+        int n_valid_points = 0;
+        for (int yy = range_y.start; yy != range_y.end; ++yy)
+        {
+            uchar* data = overall_mask.ptr(yy, range_x.start), * data_end = data + range_x.size();
+            const Vec4f* point = points3d_.ptr < Vec4f >(yy, range_x.start);
+            const Matx33f* Q_local = reinterpret_cast<const Matx33f*>(plane_grid.Q_.ptr < Vec<float, 9>
+            >(yy, range_x.start));
+
+            // Depending on whether you have a normal, check it
+            if (!normals_.empty())
+            {
+                const Vec4f* normal = normals_.ptr < Vec4f >(yy, range_x.start);
+                for (; data != data_end; ++data, ++point, ++normal, ++Q_local)
+                {
+                    // Don't do anything if the point already belongs to another plane
+                    if (cvIsNaN(point->val[0]) || ((*data) != 255))
+                        continue;
+
+                    // If the point is close enough to the plane
+                    Vec3f _p = Vec3f((*point)[0], (*point)[1], (*point)[2]);
+                    if (plane->distance(_p) < err_)
+                    {
+                        // make sure the normals are similar to the plane
+                        Vec3f _n = Vec3f((*normal)[0], (*normal)[1], (*normal)[2]);
+                        if (std::abs(plane->n().dot(_n)) > 0.3)
+                        {
+                            // The point now belongs to the plane
+                            plane->UpdateStatistics(_p, *Q_local);
+                            *data = plane_index_;
+                            ++n_valid_points;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (; data != data_end; ++data, ++point, ++Q_local)
+                {
+                    // Don't do anything if the point already belongs to another plane
+                    if (cvIsNaN(point->val[0]) || ((*data) != 255))
+                        continue;
+
+                    // If the point is close enough to the plane
+                    Vec3f _p = Vec3f((*point)[0], (*point)[1], (*point)[2]);
+                    if (plane->distance(_p) < err_)
+                    {
+                        // The point now belongs to the plane
+                        plane->UpdateStatistics(_p, *Q_local);
+                        *data = plane_index_;
+                        ++n_valid_points;
+                    }
+                }
+            }
+        }
+
+        plane->UpdateParameters();
+
+        // Mark the front as being done and pop it
+        if (n_valid_points > (range_x.size() * range_y.size()) / 2)
+            tile_queue.remove(tile.y_, tile.x_);
+        plane_mask(tile.y_, tile.x_) = 1;
+        neighboring_tiles.erase(neighboring_tiles.begin());
+
+        // Add potential neighbors of the tile
+        std::vector<std::pair<int, int> > pairs;
+        if (tile.x_ > 0)
+            for (unsigned char* val = overall_mask.ptr<unsigned char>(range_y.start, range_x.start), *val_end = val
+                + range_y.size() * overall_mask.step; val != val_end; val += overall_mask.step)
+                if (*val == plane_index_)
+                {
+                    pairs.push_back(std::pair<int, int>(tile.x_ - 1, tile.y_));
+                    break;
+                }
+        if (tile.x_ < plane_mask.cols - 1)
+            for (unsigned char* val = overall_mask.ptr<unsigned char>(range_y.start, range_x.end - 1), *val_end = val
+                + range_y.size() * overall_mask.step; val != val_end; val += overall_mask.step)
+                if (*val == plane_index_)
+                {
+                    pairs.push_back(std::pair<int, int>(tile.x_ + 1, tile.y_));
+                    break;
+                }
+        if (tile.y_ > 0)
+            for (unsigned char* val = overall_mask.ptr<unsigned char>(range_y.start, range_x.start), *val_end = val
+                + range_x.size(); val != val_end; ++val)
+                if (*val == plane_index_)
+                {
+                    pairs.push_back(std::pair<int, int>(tile.x_, tile.y_ - 1));
+                    break;
+                }
+        if (tile.y_ < plane_mask.rows - 1)
+            for (unsigned char* val = overall_mask.ptr<unsigned char>(range_y.end - 1, range_x.start), *val_end = val
+                + range_x.size(); val != val_end; ++val)
+                if (*val == plane_index_)
+                {
+                    pairs.push_back(std::pair<int, int>(tile.x_, tile.y_ + 1));
+                    break;
+                }
+
+        for (unsigned char i = 0; i < pairs.size(); ++i)
+            if (!plane_mask(pairs[i].second, pairs[i].first))
+                neighboring_tiles.insert(
+                    TileQueue::PlaneTile(pairs[i].first, pairs[i].second, plane_grid.mse_(pairs[i].second, pairs[i].first)));
+    }
+
+private:
+    float err_;
+    const Mat_<Vec4f>& points3d_;
+    const Mat_<Vec4f>& normals_;
+    unsigned char plane_index_;
+    /** THe block size as defined in the main algorithm */
+    int block_size_;
+
+    const InlierFinder& operator = (const InlierFinder&);
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void findPlanes(InputArray points3d_in, InputArray normals_in, OutputArray mask_out, OutputArray plane_coefficients_out,
+                int block_size, int min_size, double threshold, double sensor_error_a, double sensor_error_b, double sensor_error_c,
+                RgbdPlaneMethod method)
+{
+    CV_Assert(method == RGBD_PLANE_METHOD_DEFAULT);
+
+    Mat_<Vec4f> points3d, normals;
+    if (points3d_in.depth() == CV_32F)
+        points3d = points3d_in.getMat();
+    else
+        points3d_in.getMat().convertTo(points3d, CV_32F);
+    if (!normals_in.empty())
+    {
+        if (normals_in.depth() == CV_32F)
+            normals = normals_in.getMat();
+        else
+            normals_in.getMat().convertTo(normals, CV_32F);
+    }
+
+    // Pre-computations
+    mask_out.create(points3d.size(), CV_8U);
+    Mat mask_out_mat = mask_out.getMat();
+    Mat_<unsigned char> mask_out_uc = (Mat_<unsigned char>&) mask_out_mat;
+    mask_out_uc.setTo(255);
+    PlaneGrid plane_grid(points3d, block_size);
+    TileQueue plane_queue(plane_grid);
+    size_t index_plane = 0;
+
+    std::vector<Vec4f> plane_coefficients;
+    float mse_min = (float)(threshold * threshold);
+
+    while (!plane_queue.empty())
+    {
+        // Get the first tile if it's good enough
+        const TileQueue::PlaneTile front_tile = plane_queue.front();
+        if (front_tile.mse_ > mse_min)
+            break;
+
+        InlierFinder inlier_finder((float)threshold, points3d, normals, (unsigned char)index_plane, block_size);
+
+        // Construct the plane for the first tile
+        int x = front_tile.x_, y = front_tile.y_;
+        const Vec3f& n = plane_grid.n_(y, x);
+        Ptr<PlaneBase> plane;
+        if ((sensor_error_a == 0) && (sensor_error_b == 0) && (sensor_error_c == 0))
+            plane = Ptr<PlaneBase>(new Plane(plane_grid.m_(y, x), n, (int)index_plane));
+        else
+            plane = Ptr<PlaneBase>(new PlaneABC(plane_grid.m_(y, x), n, (int)index_plane,
+                                   (float)sensor_error_a, (float)sensor_error_b, (float)sensor_error_c));
+
+        Mat_<unsigned char> plane_mask = Mat_<unsigned char>::zeros(divUp(points3d.rows, block_size),
+                                                                    divUp(points3d.cols, block_size));
+        std::set<TileQueue::PlaneTile> neighboring_tiles;
+        neighboring_tiles.insert(front_tile);
+        plane_queue.remove(front_tile.y_, front_tile.x_);
+
+        // Process all the neighboring tiles
+        while (!neighboring_tiles.empty())
+            inlier_finder.Find(plane_grid, plane, plane_queue, neighboring_tiles, mask_out_uc, plane_mask);
+
+        // Don't record the plane if it's empty
+        if (plane->empty())
+            continue;
+        // Don't record the plane if it's smaller than asked
+        if (plane->K() < min_size)
+        {
+            // Reset the plane index in the mask
+            for (y = 0; y < plane_mask.rows; ++y)
+                for (x = 0; x < plane_mask.cols; ++x)
+                {
+                    if (!plane_mask(y, x))
+                        continue;
+                    // Go over the tile
+                    for (int yy = y * block_size;
+                        yy < std::min((y + 1) * block_size, mask_out_uc.rows); ++yy)
+                    {
+                        uchar* data = mask_out_uc.ptr(yy, x * block_size);
+                        uchar* data_end = data + std::min(block_size, mask_out_uc.cols - x * block_size);
+                        for (; data != data_end; ++data)
+                        {
+                            if (*data == index_plane)
+                                *data = 255;
+                        }
+                    }
+                }
+            continue;
+        }
+
+        ++index_plane;
+        if (index_plane >= 255)
+            break;
+        Vec4f coeffs(plane->n()[0], plane->n()[1], plane->n()[2], plane->d());
+        if (coeffs(2) > 0)
+            coeffs = -coeffs;
+        plane_coefficients.push_back(coeffs);
+    };
+
+    // Fill the plane coefficients
+    if (plane_coefficients.empty())
+        return;
+    plane_coefficients_out.create((int)plane_coefficients.size(), 1, CV_32FC4);
+    Mat plane_coefficients_mat = plane_coefficients_out.getMat();
+    float* data = plane_coefficients_mat.ptr<float>(0);
+    for (size_t i = 0; i < plane_coefficients.size(); ++i)
+        for (uchar j = 0; j < 4; ++j, ++data)
+            *data = plane_coefficients[i][j];
+}
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/pose_graph.cpp b/upstream/opencv/modules/ptcloud/src/pose_graph.cpp
new file mode 100644
index 0000000..0d4d1e8
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/pose_graph.cpp
@@ -0,0 +1,1061 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+#include "opencv2/geometry/detail/optimizer.hpp"
+#include "opencv2/ptcloud/detail/pose_graph.hpp"
+#include <opencv2/geometry/mst.hpp>
+#include "sparse_block_matrix.hpp"
+
+namespace cv
+{
+namespace detail
+{
+
+#if defined(HAVE_EIGEN)
+
+// matrix form of conjugation
+static const cv::Matx44d M_Conj{ 1,  0,  0,  0,
+                                 0, -1,  0,  0,
+                                 0,  0, -1,  0,
+                                 0,  0,  0, -1 };
+
+// matrix form of quaternion multiplication from left side
+static inline cv::Matx44d m_left(cv::Quatd q)
+{
+    // M_left(a)* V(b) =
+    //    = (I_4 * a0 + [ 0 | -av    [    0 | 0_1x3
+    //                   av | 0_3] +  0_3x1 | skew(av)]) * V(b)
+
+    double w = q.w, x = q.x, y = q.y, z = q.z;
+    return { w, -x, -y, -z,
+             x,  w, -z,  y,
+             y,  z,  w, -x,
+             z, -y,  x,  w };
+}
+
+// matrix form of quaternion multiplication from right side
+static inline cv::Matx44d m_right(cv::Quatd q)
+{
+    // M_right(b)* V(a) =
+    //    = (I_4 * b0 + [ 0 | -bv    [    0 | 0_1x3
+    //                   bv | 0_3] +  0_3x1 | skew(-bv)]) * V(a)
+
+    double w = q.w, x = q.x, y = q.y, z = q.z;
+    return { w, -x, -y, -z,
+             x,  w,  z, -y,
+             y, -z,  w,  x,
+             z,  y, -x,  w };
+}
+
+// jacobian of quaternionic (exp(x)*q) : R_3 -> H near x == 0
+static inline cv::Matx43d expQuatJacobian(cv::Quatd q)
+{
+    double w = q.w, x = q.x, y = q.y, z = q.z;
+    return cv::Matx43d(-x, -y, -z,
+                        w,  z, -y,
+                       -z,  w,  x,
+                        y, -x,  w);
+}
+
+// concatenate matrices vertically
+template<typename _Tp, int m, int n, int k> static inline
+cv::Matx<_Tp, m + k, n> concatVert(const cv::Matx<_Tp, m, n>& a, const cv::Matx<_Tp, k, n>& b)
+{
+    cv::Matx<_Tp, m + k, n> res;
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            res(i, j) = a(i, j);
+        }
+    }
+    for (int i = 0; i < k; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            res(m + i, j) = b(i, j);
+        }
+    }
+    return res;
+}
+
+// concatenate matrices horizontally
+template<typename _Tp, int m, int n, int k> static inline
+cv::Matx<_Tp, m, n + k> concatHor(const cv::Matx<_Tp, m, n>& a, const cv::Matx<_Tp, m, k>& b)
+{
+    cv::Matx<_Tp, m, n + k> res;
+
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            res(i, j) = a(i, j);
+        }
+    }
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < k; j++)
+        {
+            res(i, n + j) = b(i, j);
+        }
+    }
+    return res;
+}
+
+class PoseGraphImpl;
+class PoseGraphLevMarqBackend;
+
+class PoseGraphLevMarq : public LevMarqBase
+{
+public:
+    PoseGraphLevMarq(PoseGraphImpl* pg, const LevMarq::Settings& settings_ = LevMarq::Settings()) :
+        LevMarqBase(makePtr<PoseGraphLevMarqBackend>(pg), settings_)
+    { }
+};
+
+
+class PoseGraphImpl : public cv::detail::PoseGraph
+{
+public:
+    struct Pose3d
+    {
+        Vec3d t;
+        Quatd q;
+
+        Pose3d() : t(), q(1, 0, 0, 0) { }
+
+        Pose3d(const Matx33d& rotation, const Vec3d& translation)
+            : t(translation), q(Quatd::createFromRotMat(rotation).normalize())
+        { }
+
+        explicit Pose3d(const Matx44d& pose) :
+            Pose3d(pose.get_minor<3, 3>(0, 0), Vec3d(pose(0, 3), pose(1, 3), pose(2, 3)))
+        { }
+
+        inline Pose3d operator*(const Pose3d& otherPose) const
+        {
+            Pose3d out(*this);
+            out.t += q.toRotMat3x3(QUAT_ASSUME_UNIT) * otherPose.t;
+            out.q = out.q * otherPose.q;
+            return out;
+        }
+
+        Affine3d getAffine() const
+        {
+            return Affine3d(q.toRotMat3x3(QUAT_ASSUME_UNIT), t);
+        }
+
+        inline Pose3d inverse() const
+        {
+            Pose3d out;
+            out.q = q.conjugate();
+            out.t = -(out.q.toRotMat3x3(QUAT_ASSUME_UNIT) * t);
+            return out;
+        }
+
+        inline void normalizeRotation()
+        {
+            q = q.normalize();
+        }
+
+        // jacobian of exponential (exp(x)* q) : R_6->SE(3) near x == 0
+        inline Matx<double, 7, 6> expJacobian()
+        {
+            Matx43d qj = expQuatJacobian(q);
+            // x node layout is (rot_x, rot_y, rot_z, trans_x, trans_y, trans_z)
+            // pose layout is (q_w, q_x, q_y, q_z, trans_x, trans_y, trans_z)
+            return concatVert(concatHor(qj, Matx43d()),
+                              concatHor(Matx33d(), Matx33d::eye()));
+        }
+
+        inline Pose3d oplus(const Vec6d dx)
+        {
+            Vec3d deltaRot(dx[0], dx[1], dx[2]), deltaTrans(dx[3], dx[4], dx[5]);
+            Pose3d p;
+            p.q = Quatd(0, deltaRot[0], deltaRot[1], deltaRot[2]).exp() * this->q;
+            p.t = this->t + deltaTrans;
+            return p;
+        }
+    };
+
+    /*! \class GraphNode
+     *  \brief Defines a node/variable that is optimizable in a posegraph
+     *
+     *  Detailed description
+     */
+    struct Node
+    {
+    public:
+        explicit Node(size_t _nodeId, const Affine3d& _pose)
+            : id(_nodeId), isFixed(false), pose(_pose.rotation(), _pose.translation())
+        { }
+
+        Affine3d getPose() const
+        {
+            return pose.getAffine();
+        }
+        void setPose(const Affine3d& _pose)
+        {
+            pose = Pose3d(_pose.rotation(), _pose.translation());
+        }
+
+    public:
+        size_t id;
+        bool isFixed;
+        Pose3d pose;
+    };
+
+    /*! \class PoseGraphEdge
+     *  \brief Defines the constraints between two PoseGraphNodes
+     *
+     *  Detailed description
+     */
+    struct Edge
+    {
+    public:
+        explicit Edge(size_t _sourceNodeId, size_t _targetNodeId, const Affine3f& _transformation,
+                      const Matx66f& _information = Matx66f::eye());
+
+        bool operator==(const Edge& edge)
+        {
+            if ((edge.sourceNodeId == sourceNodeId && edge.targetNodeId == targetNodeId) ||
+                (edge.sourceNodeId == targetNodeId && edge.targetNodeId == sourceNodeId))
+                return true;
+            return false;
+        }
+
+    public:
+        size_t sourceNodeId;
+        size_t targetNodeId;
+        Pose3d pose;
+        Matx66f sqrtInfo;
+    };
+
+    PoseGraphImpl() : nodes(), edges(), lm()
+    { }
+
+    virtual ~PoseGraphImpl() CV_OVERRIDE
+    { }
+
+    // Node may have any id >= 0
+    virtual void addNode(size_t _nodeId, const Affine3d& _pose, bool fixed) CV_OVERRIDE;
+    virtual bool isNodeExist(size_t nodeId) const CV_OVERRIDE
+    {
+        return (nodes.find(nodeId) != nodes.end());
+    }
+
+    virtual bool setNodeFixed(size_t nodeId, bool fixed) CV_OVERRIDE
+    {
+        auto it = nodes.find(nodeId);
+        if (it != nodes.end())
+        {
+            it->second.isFixed = fixed;
+            return true;
+        }
+        else
+            return false;
+    }
+
+    virtual bool isNodeFixed(size_t nodeId) const CV_OVERRIDE
+    {
+        auto it = nodes.find(nodeId);
+        if (it != nodes.end())
+            return it->second.isFixed;
+        else
+            return false;
+    }
+
+    virtual Affine3d getNodePose(size_t nodeId) const CV_OVERRIDE
+    {
+        auto it = nodes.find(nodeId);
+        if (it != nodes.end())
+            return it->second.getPose();
+        else
+            return Affine3d();
+    }
+
+    virtual std::vector<size_t> getNodesIds() const CV_OVERRIDE
+    {
+        std::vector<size_t> ids;
+        for (const auto& it : nodes)
+        {
+            ids.push_back(it.first);
+        }
+        return ids;
+    }
+
+    virtual size_t getNumNodes() const CV_OVERRIDE
+    {
+        return nodes.size();
+    }
+
+    // Edges have consequent indices starting from 0
+    virtual void addEdge(size_t _sourceNodeId, size_t _targetNodeId, const Affine3f& _transformation,
+                         const Matx66f& _information = Matx66f::eye()) CV_OVERRIDE
+    {
+        Edge e(_sourceNodeId, _targetNodeId, _transformation, _information);
+        edges.push_back(e);
+    }
+
+    virtual size_t getEdgeStart(size_t i) const CV_OVERRIDE
+    {
+        return edges[i].sourceNodeId;
+    }
+
+    virtual size_t getEdgeEnd(size_t i) const CV_OVERRIDE
+    {
+        return edges[i].targetNodeId;
+    }
+
+    virtual Affine3d getEdgePose(size_t i) const CV_OVERRIDE
+    {
+        return edges[i].pose.getAffine();
+    }
+    virtual Matx66f getEdgeInfo(size_t i) const CV_OVERRIDE
+    {
+        Matx66f s = edges[i].sqrtInfo;
+        return s * s;
+    }
+
+    virtual size_t getNumEdges() const CV_OVERRIDE
+    {
+        return edges.size();
+    }
+
+    // checks if graph is connected and each edge connects exactly 2 nodes
+    virtual bool isValid() const CV_OVERRIDE;
+
+    // calculate cost function based on current nodes parameters
+    virtual double calcEnergy() const CV_OVERRIDE;
+
+    // calculate cost function based on provided nodes parameters
+    double calcEnergyNodes(const std::map<size_t, Node>& newNodes) const;
+
+    void initializePosesWithMST(double lambda) CV_OVERRIDE;
+
+    // creates an optimizer
+    virtual Ptr<LevMarqBase> createOptimizer(const LevMarq::Settings& settings) CV_OVERRIDE
+    {
+        lm = makePtr<PoseGraphLevMarq>(this, settings);
+
+        return lm;
+    }
+
+    // creates an optimizer
+    virtual Ptr<LevMarqBase> createOptimizer() CV_OVERRIDE
+    {
+        lm = makePtr<PoseGraphLevMarq>(this, LevMarq::Settings()
+                                             .setMaxIterations(100)
+                                             .setCheckRelEnergyChange(true)
+                                             .setRelEnergyDeltaTolerance(1e-6)
+                                             .setGeodesic(true));
+
+        return lm;
+    }
+
+    // Returns number of iterations elapsed or -1 if max number of iterations was reached or failed to optimize
+    virtual LevMarq::Report optimize() CV_OVERRIDE;
+
+    std::map<size_t, Node> nodes;
+    std::vector<Edge> edges;
+
+    Ptr<PoseGraphLevMarq> lm;
+
+private:
+    double calculateWeight(const PoseGraphImpl::Edge& e, double lambda) const;
+    void applyMST(const std::vector<cv::MSTEdge>& resultingEdges, const PoseGraphImpl::Node& rootNode);
+};
+
+
+void PoseGraphImpl::addNode(size_t _nodeId, const Affine3d& _pose, bool fixed)
+{
+    Node node(_nodeId, _pose);
+    node.isFixed = fixed;
+
+    size_t id = node.id;
+    const auto& it = nodes.find(id);
+    if (it != nodes.end())
+    {
+        std::cout << "duplicated node, id=" << id << std::endl;
+        nodes.insert(it, { id, node });
+    }
+    else
+    {
+        nodes.insert({ id, node });
+    }
+}
+
+
+// Cholesky decomposition of symmetrical 6x6 matrix
+static inline cv::Matx66d llt6(Matx66d m)
+{
+    Matx66d L;
+    for (int i = 0; i < 6; i++)
+    {
+        for (int j = 0; j < (i + 1); j++)
+        {
+            double sum = 0;
+            for (int k = 0; k < j; k++)
+                sum += L(i, k) * L(j, k);
+
+            if (i == j)
+                L(i, i) = sqrt(m(i, i) - sum);
+            else
+                L(i, j) = (1.0 / L(j, j) * (m(i, j) - sum));
+        }
+    }
+    return L;
+}
+
+PoseGraphImpl::Edge::Edge(size_t _sourceNodeId, size_t _targetNodeId, const Affine3f& _transformation,
+                          const Matx66f& _information) :
+                          sourceNodeId(_sourceNodeId),
+                          targetNodeId(_targetNodeId),
+                          pose(_transformation.rotation(), _transformation.translation()),
+                          sqrtInfo(llt6(_information))
+{ }
+
+
+bool PoseGraphImpl::isValid() const
+{
+    size_t numNodes = getNumNodes();
+    size_t numEdges = getNumEdges();
+
+    if (!numNodes || !numEdges)
+        return false;
+
+    std::unordered_set<size_t> nodesVisited;
+    std::vector<size_t> nodesToVisit;
+
+    nodesToVisit.push_back(nodes.begin()->first);
+
+    bool isGraphConnected = false;
+    while (!nodesToVisit.empty())
+    {
+        size_t currNodeId = nodesToVisit.back();
+        nodesToVisit.pop_back();
+        nodesVisited.insert(currNodeId);
+        // Since each node does not maintain its neighbor list
+        for (size_t i = 0; i < numEdges; i++)
+        {
+            const Edge& potentialEdge = edges.at(i);
+            size_t nextNodeId = (size_t)(-1);
+
+            if (potentialEdge.sourceNodeId == currNodeId)
+            {
+                nextNodeId = potentialEdge.targetNodeId;
+            }
+            else if (potentialEdge.targetNodeId == currNodeId)
+            {
+                nextNodeId = potentialEdge.sourceNodeId;
+            }
+            if (nextNodeId != (size_t)(-1))
+            {
+                if (nodesVisited.count(nextNodeId) == 0)
+                {
+                    nodesToVisit.push_back(nextNodeId);
+                }
+            }
+        }
+    }
+
+    isGraphConnected = (nodesVisited.size() == numNodes);
+
+    CV_LOG_INFO(NULL, "nodesVisited: " << nodesVisited.size() << " IsGraphConnected: " << isGraphConnected);
+
+    bool invalidEdgeNode = false;
+    for (size_t i = 0; i < numEdges; i++)
+    {
+        const Edge& edge = edges.at(i);
+        // edges have spurious source/target nodes
+        if ((nodesVisited.count(edge.sourceNodeId) != 1) ||
+            (nodesVisited.count(edge.targetNodeId) != 1))
+        {
+            invalidEdgeNode = true;
+            break;
+        }
+    }
+    return isGraphConnected && !invalidEdgeNode;
+}
+
+double PoseGraphImpl::calculateWeight(const PoseGraphImpl::Edge& e, double lambda) const
+{
+    double translationNorm = cv::norm(e.pose.t);
+
+    cv::Matx33d R = e.pose.q.toRotMat3x3(cv::QUAT_ASSUME_UNIT);
+    cv::Vec3d rvec;
+    cv::Rodrigues(R, rvec);
+    double rotationAngle = cv::norm(rvec);
+
+    double weight = translationNorm + lambda * rotationAngle;
+
+    return weight;
+}
+
+void PoseGraphImpl::applyMST(const std::vector<cv::MSTEdge>& resultingEdges, const PoseGraphImpl::Node& rootNode)
+{
+    std::unordered_map<size_t, std::vector<std::pair<size_t, PoseGraphImpl::Pose3d>>> adj;
+    for (const auto& e: resultingEdges)
+    {
+        auto it = std::find_if(edges.begin(), edges.end(), [&](const PoseGraphImpl::Edge& edge)
+        {
+            return (edge.sourceNodeId == static_cast<size_t>(e.source) && edge.targetNodeId == static_cast<size_t>(e.target)) ||
+                   (edge.sourceNodeId == static_cast<size_t>(e.target) && edge.targetNodeId == static_cast<size_t>(e.source));
+        });
+        if (it != edges.end())
+        {
+            size_t src = it->sourceNodeId;
+            size_t tgt = it->targetNodeId;
+            const PoseGraphImpl::Pose3d& relPose = it->pose;
+
+            adj[src].emplace_back(tgt, relPose);
+            adj[tgt].emplace_back(src, relPose.inverse());
+        }
+    }
+
+    std::unordered_map<size_t, PoseGraphImpl::Pose3d> newPoses;
+    std::stack<size_t> toVisit;
+    std::unordered_set<size_t> visited;
+
+    newPoses[rootNode.id] = rootNode.pose;
+    toVisit.push(rootNode.id);
+
+    while (!toVisit.empty())
+    {
+        size_t current = toVisit.top();
+        toVisit.pop();
+        visited.insert(current);
+
+        const auto& currentPose = newPoses[current];
+
+        auto it = adj.find(current);
+        if (it == adj.end())
+            continue;
+
+        for (const auto& pr : it->second)
+        {
+            auto neighbor = pr.first;
+            auto relativePose = pr.second;
+
+            if (visited.count(neighbor))
+                continue;
+            newPoses[neighbor] = currentPose * relativePose;
+            toVisit.push(neighbor);
+        }
+    }
+
+    // Apply the new poses
+    for (const auto& np : newPoses)
+    {
+        auto nodeId = np.first;
+        auto pose = np.second;
+
+        if (!nodes.at(nodeId).isFixed)
+            nodes.at(nodeId).setPose(pose.getAffine());
+    }
+}
+
+void PoseGraphImpl::initializePosesWithMST(double lambda)
+{
+    size_t numNodes = getNumNodes();
+
+    std::vector<MSTEdge> MSTedges;
+    for (const auto& e: edges)
+    {
+        double weight = calculateWeight(e, lambda);
+        MSTedges.push_back({static_cast<int>(e.sourceNodeId), static_cast<int>(e.targetNodeId), weight});
+    }
+
+    size_t rootId = 0;
+    PoseGraphImpl::Node rootNode = nodes.begin()->second;
+
+    for (const auto& n: nodes)
+    {
+        if (isNodeFixed(n.second.id))
+        {
+            rootNode = n.second;
+            rootId = n.second.id;
+            break;
+        }
+    }
+
+    std::vector<MSTEdge> resultingEdges;
+    if (!cv::buildMST(numNodes, MSTedges, resultingEdges, MST_PRIM, static_cast<int>(rootId)))
+    {
+        CV_LOG_INFO(NULL, "Failed to build MST: graph may be disconnected.");
+        return;
+    }
+
+    applyMST(resultingEdges, rootNode);
+}
+
+//////////////////////////
+// Optimization itself //
+////////////////////////
+
+static inline double poseError(Quatd sourceQuat, Vec3d sourceTrans, Quatd targetQuat, Vec3d targetTrans,
+                               Quatd rotMeasured, Vec3d transMeasured, Matx66d sqrtInfoMatrix, bool needJacobians,
+                               Matx<double, 6, 4>& sqj, Matx<double, 6, 3>& stj,
+                               Matx<double, 6, 4>& tqj, Matx<double, 6, 3>& ttj,
+                               Vec6d& res)
+{
+    // err_r = 2*Im(conj(rel_r) * measure_r) = 2*Im(conj(target_r) * source_r * measure_r)
+    // err_t = conj(source_r) * (target_t - source_t) * source_r - measure_t
+
+    Quatd sourceQuatInv = sourceQuat.conjugate();
+    Vec3d deltaTrans = targetTrans - sourceTrans;
+
+    Quatd relativeQuat = sourceQuatInv * targetQuat;
+    Vec3d relativeTrans = sourceQuatInv.toRotMat3x3(cv::QUAT_ASSUME_UNIT) * deltaTrans;
+
+    //! Definition should actually be relativeQuat * rotMeasured.conjugate()
+    Quatd deltaRot = relativeQuat.conjugate() * rotMeasured;
+
+    Vec3d terr = relativeTrans - transMeasured;
+    Vec3d rerr = 2.0 * Vec3d(deltaRot.x, deltaRot.y, deltaRot.z);
+    Vec6d rterr(terr[0], terr[1], terr[2], rerr[0], rerr[1], rerr[2]);
+
+    res = sqrtInfoMatrix * rterr;
+
+    if (needJacobians)
+    {
+        // d(err_r) = 2*Im(d(conj(target_r) * source_r * measure_r)) = < measure_r is constant > =
+        // 2*Im((conj(d(target_r)) * source_r + conj(target_r) * d(source_r)) * measure_r)
+        // d(target_r) == 0:
+        //  # d(err_r) = 2*Im(conj(target_r) * d(source_r) * measure_r)
+        //  # V(d(err_r)) = 2 * M_Im * M_right(measure_r) * M_left(conj(target_r)) * V(d(source_r))
+        //  # d(err_r) / d(source_r) = 2 * M_Im * M_right(measure_r) * M_left(conj(target_r))
+        Matx34d drdsq = 2.0 * (m_right(rotMeasured) * m_left(targetQuat.conjugate())).get_minor<3, 4>(1, 0);
+
+        // d(source_r) == 0:
+        //  # d(err_r) = 2*Im(conj(d(target_r)) * source_r * measure_r)
+        //  # V(d(err_r)) = 2 * M_Im * M_right(source_r * measure_r) * M_Conj * V(d(target_r))
+        //  # d(err_r) / d(target_r) = 2 * M_Im * M_right(source_r * measure_r) * M_Conj
+        Matx34d drdtq = 2.0 * (m_right(sourceQuat * rotMeasured) * M_Conj).get_minor<3, 4>(1, 0);
+
+        // d(err_t) = d(conj(source_r) * (target_t - source_t) * source_r) =
+        // conj(source_r) * (d(target_t) - d(source_t)) * source_r +
+        // conj(d(source_r)) * (target_t - source_t) * source_r +
+        // conj(source_r) * (target_t - source_t) * d(source_r) =
+        // <conj(a*b) == conj(b)*conj(a), conj(target_t - source_t) = - (target_t - source_t), 2 * Im(x) = (x - conj(x))>
+        // conj(source_r) * (d(target_t) - d(source_t)) * source_r +
+        // 2 * Im(conj(source_r) * (target_t - source_t) * d(source_r))
+        // d(*_t) == 0:
+        //  # d(err_t) = 2 * Im(conj(source_r) * (target_t - source_t) * d(source_r))
+        //  # V(d(err_t)) = 2 * M_Im * M_left(conj(source_r) * (target_t - source_t)) * V(d(source_r))
+        //  # d(err_t) / d(source_r) = 2 * M_Im * M_left(conj(source_r) * (target_t - source_t))
+        Matx34d dtdsq = 2 * m_left(sourceQuatInv * Quatd(0, deltaTrans[0], deltaTrans[1], deltaTrans[2])).get_minor<3, 4>(1, 0);
+        // deltaTrans is rotated by sourceQuatInv, so the jacobian is rot matrix of sourceQuatInv by +1 or -1
+        Matx33d dtdtt = sourceQuatInv.toRotMat3x3(QUAT_ASSUME_UNIT);
+        Matx33d dtdst = -dtdtt;
+
+        Matx33d z;
+        sqj = concatVert(dtdsq, drdsq);
+        tqj = concatVert(Matx34d(), drdtq);
+        stj = concatVert(dtdst, z);
+        ttj = concatVert(dtdtt, z);
+
+        stj = sqrtInfoMatrix * stj;
+        ttj = sqrtInfoMatrix * ttj;
+        sqj = sqrtInfoMatrix * sqj;
+        tqj = sqrtInfoMatrix * tqj;
+    }
+
+    return res.ddot(res);
+}
+
+
+double PoseGraphImpl::calcEnergy() const
+{
+    return calcEnergyNodes(nodes);
+}
+
+
+// estimate current energy
+double PoseGraphImpl::calcEnergyNodes(const std::map<size_t, Node>& newNodes) const
+{
+    double totalErr = 0;
+    for (const auto& e : edges)
+    {
+        Pose3d srcP = newNodes.at(e.sourceNodeId).pose;
+        Pose3d tgtP = newNodes.at(e.targetNodeId).pose;
+
+        Vec6d res;
+        Matx<double, 6, 3> stj, ttj;
+        Matx<double, 6, 4> sqj, tqj;
+        double err = poseError(srcP.q, srcP.t, tgtP.q, tgtP.t, e.pose.q, e.pose.t, e.sqrtInfo,
+                               /* needJacobians = */ false, sqj, stj, tqj, ttj, res);
+
+        totalErr += err;
+    }
+    return totalErr * 0.5;
+}
+
+
+// J := J * d_inv, d_inv = make_diag(di)
+// J^T*J := (J * d_inv)^T * J * d_inv = diag(di) * (J^T * J) * diag(di) = eltwise_mul(J^T*J, di*di^T)
+// J^T*b := (J * d_inv)^T * b = d_inv^T * J^T*b = eltwise_mul(J^T*b, di)
+static void doJacobiScalingSparse(BlockSparseMat<double, 6, 6>& jtj, Mat_<double>& jtb, const Mat_<double>& di)
+{
+    // scaling J^T*J
+    for (auto& ijv : jtj.ijValue)
+    {
+        Point2i bpt = ijv.first;
+        Matx66d& m = ijv.second;
+        for (int i = 0; i < 6; i++)
+        {
+            for (int j = 0; j < 6; j++)
+            {
+                Point2i pt(bpt.x * 6 + i, bpt.y * 6 + j);
+                m(i, j) *= di(pt.x) * di(pt.y);
+            }
+        }
+    }
+
+    // scaling J^T*b
+    jtb = jtb.mul(di);
+}
+
+//TODO: robustness
+class PoseGraphLevMarqBackend : public detail::LevMarqBackend
+{
+public:
+    PoseGraphLevMarqBackend(PoseGraphImpl* pg_) :
+        LevMarqBackend(),
+        pg(pg_),
+        jtj(0),
+        jtb(),
+        tempNodes(),
+        useGeo(),
+        geoNodes(),
+        jtrvv(),
+        jtCached(),
+        decomposition(),
+        numNodes(),
+        numEdges(),
+        placesIds(),
+        idToPlace(),
+        nVarNodes()
+    {
+        if (!pg->isValid())
+        {
+            CV_Error(cv::Error::Code::StsBadArg, "Invalid PoseGraph that is either not connected or has invalid nodes");
+        }
+
+        this->numNodes = pg->getNumNodes();
+        this->numEdges = pg->getNumEdges();
+
+        // Allocate indices for nodes
+        for (const auto& ni : pg->nodes)
+        {
+            if (!ni.second.isFixed)
+            {
+                this->idToPlace[ni.first] = this->placesIds.size();
+                this->placesIds.push_back(ni.first);
+            }
+        }
+
+        this->nVarNodes = this->placesIds.size();
+        if (!this->nVarNodes)
+        {
+            CV_Error(cv::Error::Code::StsBadArg, "PoseGraph contains no non-constant nodes, skipping optimization");
+        }
+
+        if (!this->numEdges)
+        {
+            CV_Error(cv::Error::Code::StsBadArg, "PoseGraph has no edges, no optimization to be done");
+        }
+
+        CV_LOG_INFO(NULL, "Optimizing PoseGraph with " << this->numNodes << " nodes and " << this->numEdges << " edges");
+
+        this->nVars = this->nVarNodes * 6;
+    }
+
+
+    virtual bool calcFunc(double& energy, bool calcEnergy = true, bool calcJacobian = false) CV_OVERRIDE
+    {
+        std::map<size_t, PoseGraphImpl::Node>& nodes = tempNodes;
+
+        std::vector<cv::Matx<double, 7, 6>> cachedJac;
+        if (calcJacobian)
+        {
+            jtj.clear();
+            std::fill(jtb.begin(), jtb.end(), 0.0);
+
+            // caching nodes jacobians
+            for (auto id : placesIds)
+            {
+                cachedJac.push_back(nodes.at(id).pose.expJacobian());
+            }
+
+            if (useGeo)
+                jtCached.clear();
+        }
+
+        double totalErr = 0.0;
+        for (const auto& e : pg->edges)
+        {
+            size_t srcId = e.sourceNodeId, dstId = e.targetNodeId;
+            const PoseGraphImpl::Node& srcNode = nodes.at(srcId);
+            const PoseGraphImpl::Node& dstNode = nodes.at(dstId);
+
+            const PoseGraphImpl::Pose3d& srcP = srcNode.pose;
+            const PoseGraphImpl::Pose3d& tgtP = dstNode.pose;
+            bool srcFixed = srcNode.isFixed;
+            bool dstFixed = dstNode.isFixed;
+
+            Vec6d res;
+            Matx<double, 6, 3> stj, ttj;
+            Matx<double, 6, 4> sqj, tqj;
+
+            double err = poseError(srcP.q, srcP.t, tgtP.q, tgtP.t, e.pose.q, e.pose.t, e.sqrtInfo,
+             /* needJacobians = */ calcJacobian, sqj, stj, tqj, ttj, res);
+            totalErr += err;
+
+            if (calcJacobian)
+            {
+                size_t srcPlace = (size_t)(-1), dstPlace = (size_t)(-1);
+                Matx66d sj, tj;
+                if (!srcFixed)
+                {
+                    srcPlace = idToPlace.at(srcId);
+                    sj = concatHor(sqj, stj) * cachedJac[srcPlace];
+
+                    jtj.refBlock(srcPlace, srcPlace) += sj.t() * sj;
+
+                    Vec6d jtbSrc = sj.t() * res;
+                    for (int i = 0; i < 6; i++)
+                    {
+                        jtb(6 * (int)srcPlace + i) += jtbSrc[i];
+                    }
+                }
+
+                if (!dstFixed)
+                {
+                    dstPlace = idToPlace.at(dstId);
+                    tj = concatHor(tqj, ttj) * cachedJac[dstPlace];
+
+                    jtj.refBlock(dstPlace, dstPlace) += tj.t() * tj;
+
+                    Vec6d jtbDst = tj.t() * res;
+                    for (int i = 0; i < 6; i++)
+                    {
+                        jtb(6 * (int)dstPlace + i) += jtbDst[i];
+                    }
+                }
+
+                if (!(srcFixed || dstFixed))
+                {
+                    Matx66d sjttj = sj.t() * tj;
+                    jtj.refBlock(srcPlace, dstPlace) += sjttj;
+                    jtj.refBlock(dstPlace, srcPlace) += sjttj.t();
+                }
+
+                if (useGeo)
+                {
+                    jtCached.push_back({ sj, tj });
+                }
+            }
+        }
+
+        if (calcEnergy)
+        {
+            energy = totalErr * 0.5;
+        }
+
+        return true;
+    }
+
+    virtual bool enableGeo() CV_OVERRIDE
+    {
+        useGeo = true;
+        return true;
+    }
+
+    // adds d to current variables and writes result to probe vars or geo vars
+    virtual void currentOplusX(const Mat_<double>& d, bool geo = false) CV_OVERRIDE
+    {
+        if (geo && !useGeo)
+        {
+            CV_Error(cv::Error::StsBadArg, "Geodesic acceleration is disabled");
+        }
+
+        std::map<size_t, PoseGraphImpl::Node>& nodes = geo ? geoNodes : tempNodes;
+
+        nodes = pg->nodes;
+
+        for (size_t i = 0; i < nVarNodes; i++)
+        {
+            Vec6d dx(d[0] + (i * 6));
+            PoseGraphImpl::Pose3d& p = nodes.at(placesIds[i]).pose;
+
+            p = p.oplus(dx);
+        }
+    }
+
+    virtual void prepareVars() CV_OVERRIDE
+    {
+        jtj = BlockSparseMat<double, 6, 6>(nVarNodes);
+        jtb = Mat_<double>((int)nVars, 1);
+        tempNodes = pg->nodes;
+        if (useGeo)
+            geoNodes = pg->nodes;
+    }
+
+    // decomposes LevMarq matrix before solution
+    virtual bool decompose() CV_OVERRIDE
+    {
+        return jtj.decompose(decomposition, false);
+    }
+
+    // solves LevMarq equation (J^T*J + lmdiag) * x = -right for current iteration using existing decomposition
+    // right can be equal to J^T*b for LevMarq equation or J^T*rvv for geodesic acceleration equation
+    virtual bool solveDecomposed(const Mat_<double>& right, Mat_<double>& x) CV_OVERRIDE
+    {
+        return jtj.solveDecomposed(decomposition, -right, x);
+    }
+
+    // calculates J^T*f(geo)
+    virtual bool calcJtbv(Mat_<double>& jtbv) CV_OVERRIDE
+    {
+        jtbv.setZero();
+
+        int ei = 0;
+        for (const auto& e : pg->edges)
+        {
+            size_t srcId = e.sourceNodeId, dstId = e.targetNodeId;
+            const PoseGraphImpl::Node& srcNode = geoNodes.at(srcId);
+            const PoseGraphImpl::Node& dstNode = geoNodes.at(dstId);
+
+            const PoseGraphImpl::Pose3d& srcP = srcNode.pose;
+            const PoseGraphImpl::Pose3d& tgtP = dstNode.pose;
+            bool srcFixed = srcNode.isFixed;
+            bool dstFixed = dstNode.isFixed;
+
+            Vec6d res;
+            // dummy vars
+            Matx<double, 6, 3> stj, ttj;
+            Matx<double, 6, 4> sqj, tqj;
+
+            poseError(srcP.q, srcP.t, tgtP.q, tgtP.t, e.pose.q, e.pose.t, e.sqrtInfo,
+            /* needJacobians = */ false, sqj, stj, tqj, ttj, res);
+
+            size_t srcPlace = (size_t)(-1), dstPlace = (size_t)(-1);
+            Matx66d sj = jtCached[ei].first, tj = jtCached[ei].second;
+
+            if (!srcFixed)
+            {
+                srcPlace = idToPlace.at(srcId);
+
+                Vec6d jtbSrc = sj.t() * res;
+                for (int i = 0; i < 6; i++)
+                {
+                    jtbv(6 * (int)srcPlace + i) += jtbSrc[i];
+                }
+            }
+
+            if (!dstFixed)
+            {
+                dstPlace = idToPlace.at(dstId);
+
+                Vec6d jtbDst = tj.t() * res;
+                for (int i = 0; i < 6; i++)
+                {
+                    jtbv(6 * (int)dstPlace + i) += jtbDst[i];
+                }
+            }
+
+            ei++;
+        }
+
+        return true;
+    }
+
+    virtual const Mat_<double> getDiag() CV_OVERRIDE
+    {
+        return jtj.diagonal();
+    }
+
+    virtual const Mat_<double> getJtb() CV_OVERRIDE
+    {
+        return jtb;
+    }
+
+    virtual void setDiag(const Mat_<double>& d) CV_OVERRIDE
+    {
+        for (size_t i = 0; i < nVars; i++)
+        {
+            jtj.refElem(i, i) = d((int)i);
+        }
+    }
+
+    virtual void doJacobiScaling(const Mat_<double>& di) CV_OVERRIDE
+    {
+        doJacobiScalingSparse(jtj, jtb, di);
+    }
+
+
+    virtual void acceptProbe() CV_OVERRIDE
+    {
+        pg->nodes = tempNodes;
+    }
+
+    PoseGraphImpl* pg;
+
+    // J^T*J matrix
+    BlockSparseMat<double, 6, 6> jtj;
+    // J^T*b vector
+    Mat_<double> jtb;
+
+    // Probe variable for different lambda tryout
+    std::map<size_t, PoseGraphImpl::Node> tempNodes;
+
+    // For geodesic acceleration
+    bool useGeo;
+    std::map<size_t, PoseGraphImpl::Node> geoNodes;
+    Mat_<double> jtrvv;
+    std::vector<std::pair<Matx66d, Matx66d>> jtCached;
+
+    // Used for keeping intermediate matrix decomposition for further linear solve operations
+    BlockSparseMat<double, 6, 6>::Decomposition decomposition;
+
+    // The rest members are generated from pg
+    size_t nVars;
+    size_t numNodes;
+    size_t numEdges;
+
+    // Structures to convert node id to place in variables vector and back
+    std::vector<size_t> placesIds;
+    std::map<size_t, size_t> idToPlace;
+
+    size_t nVarNodes;
+};
+
+
+LevMarq::Report PoseGraphImpl::optimize()
+{
+    if (!lm)
+        createOptimizer();
+    return lm->optimize();
+}
+
+Ptr<detail::PoseGraph> detail::PoseGraph::create()
+{
+    return makePtr<PoseGraphImpl>();
+}
+
+#else
+
+Ptr<detail::PoseGraph> detail::PoseGraph::create()
+{
+    CV_Error(Error::StsNotImplemented, "Eigen library required for sparse matrix solve during pose graph optimization, dense solver is not implemented");
+}
+
+#endif
+
+PoseGraph::~PoseGraph() { }
+
+}  // namespace detail
+}  // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/precomp.hpp b/upstream/opencv/modules/ptcloud/src/precomp.hpp
new file mode 100644
index 0000000..24cc396
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/precomp.hpp
@@ -0,0 +1,28 @@
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#ifdef _MSC_VER
+#  define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
+#  define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
+#endif
+
+#include <vector>
+#include <set>
+#include <map>
+#include <list>
+#include <unordered_set>
+#include <unordered_map>
+#include <stack>
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/types.hpp"
+#include "opencv2/core/base.hpp"
+#include "opencv2/core/utils/logger.hpp"
+#include "opencv2/core/utils/trace.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/ptcloud.hpp"
+#include "opencv2/geometry.hpp"
+#include "opencv2/imgproc.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/rendering.cpp b/upstream/opencv/modules/ptcloud/src/rendering.cpp
new file mode 100644
index 0000000..ca0b9bb
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/rendering.cpp
@@ -0,0 +1,412 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv {
+
+TriangleRasterizeSettings::TriangleRasterizeSettings()
+{
+    shadingType = RASTERIZE_SHADING_SHADED;
+    cullingMode = RASTERIZE_CULLING_CW;
+    glCompatibleMode = RASTERIZE_COMPAT_DISABLED;
+}
+
+static void drawTriangle(Vec4f verts[3], Vec3f colors[3], Mat& depthBuf, Mat& colorBuf,
+                         TriangleRasterizeSettings settings)
+{
+    // this will be useful during refactoring
+    // if there's gonna be more supported data types
+    CV_DbgAssert(depthBuf.empty() || depthBuf.type() == CV_32FC1);
+    CV_DbgAssert(colorBuf.empty() || colorBuf.type() == CV_32FC3);
+
+    // any of buffers can be empty
+    int width  = std::max(colorBuf.cols, depthBuf.cols);
+    int height = std::max(colorBuf.rows, depthBuf.rows);
+
+    Point minPt(width, height), maxPt(0, 0);
+    for (int i = 0; i < 3; i++)
+    {
+        // round down to cover the whole pixel
+        int x = (int)(verts[i][0]), y = (int)(verts[i][1]);
+        minPt.x = std::min(    x, minPt.x);
+        minPt.y = std::min(    y, minPt.y);
+        maxPt.x = std::max(x + 1, maxPt.x);
+        maxPt.y = std::max(y + 1, maxPt.y);
+    }
+
+    minPt.x = std::max(minPt.x, 0); maxPt.x = std::min(maxPt.x, width);
+    minPt.y = std::max(minPt.y, 0); maxPt.y = std::min(maxPt.y, height);
+
+    Point2f a(verts[0][0], verts[0][1]), b(verts[1][0], verts[1][1]), c(verts[2][0], verts[2][1]);
+    Point2f bc = b - c, ac = a - c;
+    float d = ac.x*bc.y - ac.y*bc.x;
+
+    // culling and degenerated triangle removal
+    if ((settings.cullingMode == RASTERIZE_CULLING_CW  && d <= 0) ||
+        (settings.cullingMode == RASTERIZE_CULLING_CCW && d >= 0) ||
+        (abs(d) < 1e-6))
+    {
+        return;
+    }
+
+    float invd = 1.f / d;
+    Vec3f zinv { verts[0][2], verts[1][2], verts[2][2] };
+    Vec3f w { verts[0][3], verts[1][3], verts[2][3] };
+
+    for (int y = minPt.y; y < maxPt.y; y++)
+    {
+        for (int x = minPt.x; x < maxPt.x; x++)
+        {
+            Point2f p(x + 0.5f, y + 0.5f), pc = p - c;
+            // barycentric coordinates
+            Vec3f f;
+            f[0] = ( pc.x * bc.y - pc.y * bc.x) * invd;
+            f[1] = ( pc.y * ac.x - pc.x * ac.y) * invd;
+            f[2] = 1.f - f[0] - f[1];
+            // if inside the triangle
+            if ((f[0] >= 0) && (f[1] >= 0) && (f[2] >= 0))
+            {
+                bool update = false;
+                if (!depthBuf.empty())
+                {
+                    float zCurrent = depthBuf.at<float>(height - 1 - y, x);
+                    float zNew = f[0] * zinv[0] + f[1] * zinv[1] + f[2] * zinv[2];
+                    if (zNew < zCurrent)
+                    {
+                        update = true;
+                        depthBuf.at<float>(height - 1 - y, x) = zNew;
+                    }
+                }
+                else // RASTERIZE_SHADING_WHITE
+                {
+                    update = true;
+                }
+
+                if (!colorBuf.empty() && update)
+                {
+                    Vec3f color;
+                    if (settings.shadingType == RASTERIZE_SHADING_WHITE)
+                    {
+                        color = { 1.f, 1.f, 1.f };
+                    }
+                    else if (settings.shadingType == RASTERIZE_SHADING_FLAT)
+                    {
+                        color = colors[0];
+                    }
+                    else // TriangleShadingType::Shaded
+                    {
+                        float zInter = 1.0f / (f[0] * w[0] + f[1] * w[1] + f[2] * w[2]);
+                        color = { 0, 0, 0 };
+                        for (int j = 0; j < 3; j++)
+                        {
+                            color += (f[j] * w[j]) * colors[j];
+                        }
+                        color *= zInter;
+                    }
+                    colorBuf.at<Vec3f>(height - 1 - y, x) = color;
+                }
+            }
+        }
+    }
+}
+
+
+// values outside of [zNear, zFar] have to be restored
+// [0, 1] -> [zNear, zFar]
+static void linearizeDepth(const Mat& inbuf, const Mat& validMask, Mat outbuf, double zFar, double zNear)
+{
+    CV_Assert(inbuf.type() == CV_32FC1);
+    CV_Assert(validMask.type() == CV_8UC1 || validMask.type() == CV_8SC1 || validMask.type() == CV_BoolC1);
+    CV_Assert(outbuf.type() == CV_32FC1);
+    CV_Assert(outbuf.size() == inbuf.size());
+
+    float scaleNear = (float)(1.0 / zNear);
+    float scaleFar  = (float)(1.0 / zFar);
+    for (int y = 0; y < inbuf.rows; y++)
+    {
+        const float* inp = inbuf.ptr<float>(y);
+        const uchar * validPtr = validMask.ptr<uchar>(y);
+        float * outp = outbuf.ptr<float>(y);
+        for (int x = 0; x < inbuf.cols; x++)
+        {
+            if (validPtr[x])
+            {
+                float d = inp[x];
+                // precision-optimized version of this:
+                //float z = - zFar * zNear / (d * (zFar - zNear) - zFar);
+                float z =  1.f / ((1.f - d) * scaleNear + d * scaleFar );
+                outp[x] = z;
+            }
+        }
+    }
+}
+
+// [zNear, zFar] -> [0, 1]
+static void invertDepth(const Mat& inbuf, Mat& outbuf, Mat& validMask, double zNear, double zFar)
+{
+    CV_Assert(inbuf.type() == CV_32FC1);
+    outbuf.create(inbuf.size(), CV_32FC1);
+    validMask.create(inbuf.size(), CV_8UC1);
+
+    float fNear = (float)zNear, fFar = (float)zFar;
+    float zadd = (float)(zFar / (zFar - zNear));
+    float zmul = (float)(-zNear * zFar / (zFar - zNear));
+    for (int y = 0; y < inbuf.rows; y++)
+    {
+        const float * inp = inbuf.ptr<float>(y);
+        float * outp = outbuf.ptr<float>(y);
+        uchar * validPtr = validMask.ptr<uchar>(y);
+        for (int x = 0; x < inbuf.cols; x++)
+        {
+            float z = inp[x];
+            uchar m = (z >= fNear) && (z <= fFar);
+            z = std::max(std::min(z, fFar), fNear);
+            // precision-optimized version of this:
+            // outp[x] = (z - zNear) / z * zFar / (zFar - zNear);
+            outp[x] = zadd + zmul / z;
+            validPtr[x] = m;
+        }
+    }
+}
+
+
+static void triangleRasterizeInternal(InputArray _vertices, InputArray _indices, InputArray _colors,
+                                      Mat& colorBuf, Mat& depthBuf,
+                                      InputArray world2cam, double fovyRadians, double zNear, double zFar,
+                                      const TriangleRasterizeSettings& settings)
+{
+    CV_Assert(world2cam.type() == CV_32FC1 || world2cam.type() == CV_64FC1);
+    CV_Assert((world2cam.size() == Size {4, 3}) || (world2cam.size() == Size {4, 4}));
+
+    CV_Assert((fovyRadians > 0) && (fovyRadians < CV_PI));
+    CV_Assert(zNear > 0);
+    CV_Assert(zFar > zNear);
+
+    Mat cpMat;
+    world2cam.getMat().convertTo(cpMat, CV_64FC1);
+    Matx44d camPoseMat = Matx44d::eye();
+    for (int i = 0; i < 3; i++)
+    {
+        for (int j = 0; j < 4; j++)
+        {
+            camPoseMat(i, j) = cpMat.at<double>(i, j);
+        }
+    }
+
+    if(_indices.empty())
+    {
+        return;
+    }
+
+    CV_CheckFalse(_vertices.empty(), "No vertices provided along with indices array");
+
+    Mat vertices, colors, triangles;
+    int nVerts = 0, nColors = 0, nTriangles = 0;
+
+    int vertexType = _vertices.type();
+    CV_Assert(vertexType == CV_32FC1 || vertexType == CV_32FC3);
+    vertices = _vertices.getMat();
+    // transform 3xN matrix to Nx3, except 3x3
+    if ((_vertices.channels() == 1) && (_vertices.rows() == 3) && (_vertices.cols() != 3))
+    {
+        vertices = vertices.t();
+    }
+    // This transposition is performed on 1xN matrix so it's almost free in terms of performance
+    vertices = vertices.reshape(3, 1).t();
+    nVerts = (int)vertices.total();
+
+    int indexType = _indices.type();
+    CV_Assert(indexType == CV_32SC1 || indexType == CV_32SC3);
+    triangles = _indices.getMat();
+    // transform 3xN matrix to Nx3, except 3x3
+    if ((_indices.channels() == 1) && (_indices.rows() == 3) && (_indices.cols() != 3))
+    {
+        triangles = triangles.t();
+    }
+    // This transposition is performed on 1xN matrix so it's almost free in terms of performance
+    triangles = triangles.reshape(3, 1).t();
+    nTriangles = (int)triangles.total();
+
+    if (!_colors.empty())
+    {
+        int colorType = _colors.type();
+        CV_Assert(colorType == CV_32FC1 || colorType == CV_32FC3);
+        colors = _colors.getMat();
+        // transform 3xN matrix to Nx3, except 3x3
+        if ((_colors.channels() == 1) && (_colors.rows() == 3) && (_colors.cols() != 3))
+        {
+            colors = colors.t();
+        }
+        colors = colors.reshape(3, 1).t();
+        nColors = (int)colors.total();
+
+        CV_Assert(nColors == nVerts);
+    }
+
+    // any of buffers can be empty
+    Size imgSize {std::max(colorBuf.cols, depthBuf.cols), std::max(colorBuf.rows, depthBuf.rows)};
+
+    // world-to-camera coord system
+    Matx44d lookAtMatrix = camPoseMat;
+
+    double ys = 1.0 / std::tan(fovyRadians / 2);
+    double xs = ys / (double)imgSize.width * (double)imgSize.height;
+    double zz = (zNear + zFar) / (zNear - zFar);
+    double zw = 2.0 * zFar * zNear / (zNear - zFar);
+
+    // camera to NDC: [-1, 1]^3
+    Matx44d perspectMatrix (xs,  0,  0,  0,
+                             0, ys,  0,  0,
+                             0,  0, zz, zw,
+                             0,  0,  -1, 0);
+
+    Matx44f mvpMatrix = perspectMatrix * lookAtMatrix;
+
+    // vertex transform stage
+
+    Mat screenVertices(vertices.size(), CV_32FC4);
+    for (int i = 0; i < nVerts; i++)
+    {
+        Vec3f vglobal = vertices.at<Vec3f>(i);
+
+        float x_num = std::fma(mvpMatrix(0,0), vglobal[0],
+                      std::fma(mvpMatrix(0,1), vglobal[1],
+                      std::fma(mvpMatrix(0,2), vglobal[2], mvpMatrix(0,3))));
+        float y_num = std::fma(mvpMatrix(1,0), vglobal[0],
+                      std::fma(mvpMatrix(1,1), vglobal[1],
+                      std::fma(mvpMatrix(1,2), vglobal[2], mvpMatrix(1,3))));
+        float z_num = std::fma(mvpMatrix(2,0), vglobal[0],
+                      std::fma(mvpMatrix(2,1), vglobal[1],
+                      std::fma(mvpMatrix(2,2), vglobal[2], mvpMatrix(2,3))));
+        float w_num = std::fma(mvpMatrix(3,0), vglobal[0],
+                      std::fma(mvpMatrix(3,1), vglobal[1],
+                      std::fma(mvpMatrix(3,2), vglobal[2], mvpMatrix(3,3))));
+
+        float invw = 1.f / w_num;
+
+        // [-1, 1]^3 => [0, width] x [0, height] x [0, 1]
+        Vec4f vscreen = {
+            std::fma(x_num * invw, 0.5f * (float)imgSize.width,  0.5f * (float)imgSize.width),
+            std::fma(y_num * invw, 0.5f * (float)imgSize.height, 0.5f * (float)imgSize.height),
+            std::fma(z_num * invw, 0.5f, 0.5f),
+            invw
+        };
+
+        screenVertices.at<Vec4f>(i) = vscreen;
+    }
+
+    // draw stage
+
+    for (int t = 0; t < nTriangles; t++)
+    {
+        Vec3i tri = triangles.at<Vec3i>(t);
+
+        Vec3f col[3];
+        Vec4f ver[3];
+        for (int i = 0; i < 3; i++)
+        {
+            int idx = tri[i];
+            CV_DbgAssert(idx >= 0 && idx < nVerts);
+
+            col[i] = colors.empty() ? Vec3f::all(0) : colors.at<Vec3f>(idx);
+            ver[i] = screenVertices.at<Vec4f>(idx);
+        }
+
+        drawTriangle(ver, col, depthBuf, colorBuf, settings);
+    }
+}
+
+
+void triangleRasterizeDepth(InputArray _vertices, InputArray _indices, InputOutputArray _depthBuf,
+                            InputArray world2cam, double fovY, double zNear, double zFar,
+                            const TriangleRasterizeSettings& settings)
+{
+    CV_Assert(!_depthBuf.empty());
+    CV_Assert(_depthBuf.type() == CV_32FC1);
+
+    Mat emptyColorBuf;
+    // out-of-range values from user-provided depthBuf should not be altered, let's mark them
+    Mat_<uchar> validMask;
+    Mat depthBuf;
+    if (settings.glCompatibleMode == RASTERIZE_COMPAT_INVDEPTH)
+    {
+        depthBuf = _depthBuf.getMat();
+    }
+    else // RASTERIZE_COMPAT_DISABLED
+    {
+        invertDepth(_depthBuf.getMat(), depthBuf, validMask, zNear, zFar);
+    }
+
+    triangleRasterizeInternal(_vertices, _indices, noArray(), emptyColorBuf, depthBuf, world2cam, fovY, zNear, zFar, settings);
+
+    if (settings.glCompatibleMode == RASTERIZE_COMPAT_DISABLED)
+    {
+        linearizeDepth(depthBuf, validMask, _depthBuf.getMat(), zFar, zNear);
+    }
+}
+
+void triangleRasterizeColor(InputArray _vertices, InputArray _indices, InputArray _colors, InputOutputArray _colorBuf,
+                            InputArray world2cam, double fovY, double zNear, double zFar,
+                            const TriangleRasterizeSettings& settings)
+{
+    CV_Assert(!_colorBuf.empty());
+    CV_Assert(_colorBuf.type() == CV_32FC3);
+    Mat colorBuf = _colorBuf.getMat();
+
+    Mat depthBuf;
+    if (_colors.empty())
+    {
+        // full white shading does not require depth test
+        CV_Assert(settings.shadingType == RASTERIZE_SHADING_WHITE);
+    }
+    else
+    {
+        // internal depth buffer is not exposed outside
+        depthBuf.create(_colorBuf.size(), CV_32FC1);
+        depthBuf.setTo(1.0);
+    }
+
+    triangleRasterizeInternal(_vertices, _indices, _colors, colorBuf, depthBuf, world2cam, fovY, zNear, zFar, settings);
+}
+
+void triangleRasterize(InputArray _vertices, InputArray _indices, InputArray _colors,
+                       InputOutputArray _colorBuffer, InputOutputArray _depthBuffer,
+                       InputArray world2cam, double fovyRadians, double zNear, double zFar,
+                       const TriangleRasterizeSettings& settings)
+{
+    if (_colors.empty())
+    {
+        CV_Assert(settings.shadingType == RASTERIZE_SHADING_WHITE);
+    }
+
+    CV_Assert(!_colorBuffer.empty());
+    CV_Assert(_colorBuffer.type() == CV_32FC3);
+    CV_Assert(!_depthBuffer.empty());
+    CV_Assert(_depthBuffer.type() == CV_32FC1);
+
+    CV_Assert(_depthBuffer.size() == _colorBuffer.size());
+
+    Mat colorBuf = _colorBuffer.getMat();
+
+    // out-of-range values from user-provided depthBuf should not be altered, let's mark them
+    Mat_<uchar> validMask;
+    Mat depthBuf;
+    if (settings.glCompatibleMode == RASTERIZE_COMPAT_INVDEPTH)
+    {
+        depthBuf = _depthBuffer.getMat();
+    }
+    else // RASTERIZE_COMPAT_DISABLED
+    {
+        invertDepth(_depthBuffer.getMat(), depthBuf, validMask, zNear, zFar);
+    }
+
+    triangleRasterizeInternal(_vertices, _indices, _colors, colorBuf, depthBuf, world2cam, fovyRadians, zNear, zFar, settings);
+
+    if (settings.glCompatibleMode == RASTERIZE_COMPAT_DISABLED)
+    {
+        linearizeDepth(depthBuf, validMask, _depthBuffer.getMat(), zFar, zNear);
+    }
+}
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/sparse_block_matrix.hpp b/upstream/opencv/modules/ptcloud/src/sparse_block_matrix.hpp
new file mode 100644
index 0000000..bc30e38
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/sparse_block_matrix.hpp
@@ -0,0 +1,223 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_SPARSE_BLOCK_MATRIX_HPP
+#define OPENCV_3D_SPARSE_BLOCK_MATRIX_HPP
+
+#include "precomp.hpp"
+
+#if defined(HAVE_EIGEN)
+#include <Eigen/Core>
+#include <Eigen/Sparse>
+#include <Eigen/SparseCholesky>
+
+#include "opencv2/core/eigen.hpp"
+#endif
+
+namespace cv
+{
+/*!
+ * \class BlockSparseMat
+ * Naive implementation of Sparse Block Matrix
+ */
+template<typename _Tp, size_t blockM, size_t blockN>
+struct BlockSparseMat
+{
+    struct Point2iHash
+    {
+        size_t operator()(const cv::Point2i& point) const noexcept
+        {
+            size_t seed                     = 0;
+            constexpr uint32_t GOLDEN_RATIO = 0x9e3779b9;
+            seed ^= std::hash<int>()(point.x) + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+            seed ^= std::hash<int>()(point.y) + GOLDEN_RATIO + (seed << 6) + (seed >> 2);
+            return seed;
+        }
+    };
+    typedef Matx<_Tp, blockM, blockN> MatType;
+    typedef std::unordered_map<Point2i, MatType, Point2iHash> IDtoBlockValueMap;
+
+    BlockSparseMat(size_t _nBlocks) : nBlocks(_nBlocks), ijValue() {}
+
+    void clear()
+    {
+        ijValue.clear();
+    }
+
+    inline MatType& refBlock(size_t i, size_t j)
+    {
+        Point2i p((int)i, (int)j);
+        auto it = ijValue.find(p);
+        if (it == ijValue.end())
+        {
+            it = ijValue.insert({ p, MatType::zeros() }).first;
+        }
+        return it->second;
+    }
+
+    inline _Tp& refElem(size_t i, size_t j)
+    {
+        Point2i ib((int)(i / blockM), (int)(j / blockN));
+        Point2i iv((int)(i % blockM), (int)(j % blockN));
+        return refBlock(ib.x, ib.y)(iv.x, iv.y);
+    }
+
+    inline MatType valBlock(size_t i, size_t j) const
+    {
+        Point2i p((int)i, (int)j);
+        auto it = ijValue.find(p);
+        if (it == ijValue.end())
+            return MatType::zeros();
+        else
+            return it->second;
+    }
+
+    inline _Tp valElem(size_t i, size_t j) const
+    {
+        Point2i ib((int)(i / blockM), (int)(j / blockN));
+        Point2i iv((int)(i % blockM), (int)(j % blockN));
+        return valBlock(ib.x, ib.y)(iv.x, iv.y);
+    }
+
+    Mat diagonal() const
+    {
+        // Diagonal max length is the number of columns in the sparse matrix
+        int diagLength =int( blockN * nBlocks );
+        cv::Mat diag   = cv::Mat::zeros(diagLength, 1, cv::DataType<_Tp>::type);
+
+        for (int i = 0; i < diagLength; i++)
+        {
+            diag.at<_Tp>(i, 0) = valElem(i, i);
+        }
+        return diag;
+    }
+
+#if defined(HAVE_EIGEN)
+    Eigen::SparseMatrix<_Tp> toEigen() const
+    {
+        std::vector<Eigen::Triplet<_Tp>> tripletList;
+        tripletList.reserve(ijValue.size() * blockM * blockN);
+        for (const auto& ijv : ijValue)
+        {
+            int xb = ijv.first.x, yb = ijv.first.y;
+            MatType vblock = ijv.second;
+            for (size_t i = 0; i < blockM; i++)
+            {
+                for (size_t j = 0; j < blockN; j++)
+                {
+                    _Tp val = vblock((int)i, (int)j);
+                    if (abs(val) >= NON_ZERO_VAL_THRESHOLD)
+                    {
+                        tripletList.push_back(Eigen::Triplet<_Tp>((int)(blockM * xb + i), (int)(blockN * yb + j), val));
+                    }
+                }
+            }
+        }
+        Eigen::SparseMatrix<_Tp> EigenMat(blockM * nBlocks, blockN * nBlocks);
+        EigenMat.setFromTriplets(tripletList.begin(), tripletList.end());
+        EigenMat.makeCompressed();
+
+        return EigenMat;
+    }
+#endif
+    inline size_t nonZeroBlocks() const { return ijValue.size(); }
+
+    BlockSparseMat<_Tp, blockM, blockN>& operator+=(const BlockSparseMat<_Tp, blockM, blockN>& other)
+    {
+        for (const auto& oijv : other.ijValue)
+        {
+            Point2i p = oijv.first;
+            MatType vblock = oijv.second;
+            this->refBlock(p.x, p.y) += vblock;
+        }
+
+        return *this;
+    }
+
+#if defined(HAVE_EIGEN)
+
+    // Decomposes matrix for further solution
+    // Sometimes it's required to consequently solve A*x = b then A*x = c then A*x = d...
+    // Splitting the solution procedure into two parts let us reuse the matrix' decomposition
+    struct Decomposition
+    {
+        Eigen::SparseMatrix<_Tp> bigA;
+        Eigen::SimplicialLDLT<Eigen::SparseMatrix<_Tp>> solver;
+    };
+
+    bool decompose(Decomposition& d, bool checkSymmetry = true) const
+    {
+        d.bigA = this->toEigen();
+
+        Eigen::SparseMatrix<_Tp> bigAtranspose = d.bigA.transpose();
+        if (checkSymmetry && !d.bigA.isApprox(bigAtranspose))
+        {
+            CV_Error(Error::StsBadArg, "H matrix is not symmetrical");
+            return false;
+        }
+
+        d.solver.compute(d.bigA);
+        bool r = (d.solver.info() == Eigen::Success);
+        if (!r)
+        {
+            CV_LOG_INFO(NULL, "Failed to eigen-decompose");
+        }
+
+        return r;
+    }
+
+    static bool solveDecomposed(const Decomposition& d, InputArray B, OutputArray X, OutputArray predB = cv::noArray())
+    {
+        Mat mb = B.getMat();
+        mb = mb.cols == 1 ? mb : mb.t();
+        Eigen::Matrix<_Tp, -1, 1> bigB;
+        cv2eigen(mb, bigB);
+
+        Eigen::Matrix<_Tp, -1, 1> solutionX = d.solver.solve(bigB);
+        if (d.solver.info() != Eigen::Success)
+        {
+            CV_LOG_INFO(NULL, "Failed to eigen-solve");
+            return false;
+        }
+        else
+        {
+            eigen2cv(solutionX, X);
+            if (predB.needed())
+            {
+                Eigen::Matrix<_Tp, -1, 1> predBEigen = d.bigA * solutionX;
+                eigen2cv(predBEigen, predB);
+            }
+            return true;
+        }
+    }
+
+#else
+    struct Decomposition { };
+
+    bool decompose(Decomposition& /*_d*/, bool /*checkSymmetry*/ = true) const
+    {
+        CV_Error(Error::StsNotImplemented, "Eigen library required for matrix solve, dense solver is not implemented");
+    }
+
+    bool solveDecomposed(const Decomposition& /*d*/, InputArray /*B*/, OutputArray /*X*/, OutputArray /*predB*/ = cv::noArray()) const
+    {
+        CV_Error(Error::StsNotImplemented, "Eigen library required for matrix solve, dense solver is not implemented");
+    }
+#endif
+
+    //! Function to solve a sparse linear system of equations HX = B
+    bool sparseSolve(InputArray B, OutputArray X, bool checkSymmetry = true, OutputArray predB = cv::noArray()) const
+    {
+        Decomposition d;
+        return decompose(d, checkSymmetry) && solveDecomposed(d, B, X, predB);
+    }
+
+    static constexpr _Tp NON_ZERO_VAL_THRESHOLD = _Tp(0.0001);
+    size_t nBlocks;
+    IDtoBlockValueMap ijValue;
+};
+
+}  // namespace cv
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp b/upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp
new file mode 100644
index 0000000..b038de4
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/tsdf_functions.cpp
@@ -0,0 +1,1448 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#include "precomp.hpp"
+#include "tsdf_functions.hpp"
+#include "opencl_kernels_ptcloud.hpp"
+
+namespace cv {
+
+void preCalculationPixNorm(Size size, const Intr& intrinsics, Mat& pixNorm)
+{
+    CV_TRACE_FUNCTION();
+
+    Point2f fl(intrinsics.fx, intrinsics.fy);
+    Point2f pp(intrinsics.cx, intrinsics.cy);
+    pixNorm = Mat(size.height, size.width, CV_32F);
+    std::vector<float> x(size.width);
+    std::vector<float> y(size.height);
+    for (int i = 0; i < size.width; i++)
+        x[i] = (i - pp.x) / fl.x;
+    for (int i = 0; i < size.height; i++)
+        y[i] = (i - pp.y) / fl.y;
+
+    for (int i = 0; i < size.height; i++)
+    {
+        for (int j = 0; j < size.width; j++)
+        {
+            pixNorm.at<float>(i, j) = sqrtf(x[j] * x[j] + y[i] * y[i] + 1.0f);
+        }
+    }
+
+}
+
+#ifdef HAVE_OPENCL
+void ocl_preCalculationPixNorm(Size size, const Intr& intrinsics, UMat& pixNorm)
+{
+    // calculating this on CPU then uploading to GPU is faster than calculating this on GPU
+    Mat cpuPixNorm;
+    preCalculationPixNorm(size, intrinsics, cpuPixNorm);
+    cpuPixNorm.copyTo(pixNorm);
+
+}
+#endif
+
+// Integrate
+
+void integrateTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose,
+                             InputArray _depth, InputArray _pixNorms, InputArray _volume)
+{
+    Matx44f volumePose;
+    settings.getVolumePose(volumePose);
+    integrateTsdfVolumeUnit(settings, volumePose, cameraPose, _depth, _pixNorms, _volume);
+}
+
+
+void integrateTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& volumePose, const Matx44f& cameraPose,
+                             InputArray _depth, InputArray _pixNorms, InputArray _volume)
+{
+    Depth depth = _depth.getMat();
+    Mat volume = _volume.getMat();
+    Mat pixNorms = _pixNorms.getMat();
+
+    TsdfVoxel* volDataStart = volume.ptr<TsdfVoxel>();
+
+    Vec4i volStrides;
+    settings.getVolumeStrides(volStrides);
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    float voxelSize = settings.getVoxelSize();
+
+    const Affine3f pose = Affine3f(volumePose);
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    const Intr::Projector proj = Intr(intr).makeProjector();
+    const float dfac(1.f / settings.getDepthFactor());
+    const float truncDist = settings.getTsdfTruncateDistance();
+    const float truncDistInv = 1.f / truncDist;
+    const int maxWeight = settings.getMaxWeight();
+
+    Range integrateRange(0, volResolution.x);
+
+#if USE_INTRINSICS
+    auto IntegrateInvoker = [&](const Range& range)
+    {
+        // zStep == vol2cam*(Point3f(x, y, 1)*voxelSize) - basePt;
+        Point3f zStepPt = Point3f(vol2cam.matrix(0, 2),
+            vol2cam.matrix(1, 2),
+            vol2cam.matrix(2, 2)) * voxelSize;
+
+        v_float32x4 zStep(zStepPt.x, zStepPt.y, zStepPt.z, 0);
+        v_float32x4 vfxy(proj.fx, proj.fy, 0.f, 0.f), vcxy(proj.cx, proj.cy, 0.f, 0.f);
+        const v_float32x4 upLimits = v_cvt_f32(v_int32x4(depth.cols - 1, depth.rows - 1, 0, 0));
+
+        for (int x = range.start; x < range.end; x++)
+        {
+            TsdfVoxel* volDataX = volDataStart + x * volStrides[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                TsdfVoxel* volDataY = volDataX + y * volStrides[1];
+                // optimization of camSpace transformation (vector addition instead of matmul at each z)
+                Point3f basePt = vol2cam * (Point3f((float)x, (float)y, 0) * voxelSize);
+                v_float32x4 camSpacePt(basePt.x, basePt.y, basePt.z, 0);
+
+                int startZ, endZ;
+                if (abs(zStepPt.z) > 1e-5)
+                {
+                    int baseZ = (int)(-basePt.z / zStepPt.z);
+                    if (zStepPt.z > 0)
+                    {
+                        startZ = baseZ;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        startZ = 0;
+                        endZ = baseZ;
+                    }
+                }
+                else
+                {
+                    if (basePt.z > 0)
+                    {
+                        startZ = 0;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        // z loop shouldn't be performed
+                        startZ = endZ = 0;
+                    }
+                }
+                startZ = max(0, startZ);
+                endZ = min(int(volResolution.z), endZ);
+                for (int z = startZ; z < endZ; z++)
+                {
+                    // optimization of the following:
+                    //Point3f volPt = Point3f(x, y, z)*voxelSize;
+                    //Point3f camSpacePt = vol2cam * volPt;
+                    camSpacePt = v_add(camSpacePt, zStep);
+
+                    float zCamSpace = v_get0(v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(camSpacePt))));
+                    if (zCamSpace <= 0.f)
+                        continue;
+
+                    v_float32x4 camPixVec = v_div(camSpacePt, v_setall_f32(zCamSpace));
+                    v_float32x4 projected = v_muladd(camPixVec, vfxy, vcxy);
+                    // leave only first 2 lanes
+                    projected = v_reinterpret_as_f32(v_and(v_reinterpret_as_u32(projected),
+                        v_uint32x4(0xFFFFFFFF, 0xFFFFFFFF, 0, 0)));
+
+                    depthType v;
+                    // bilinearly interpolate depth at projected
+                    {
+                        const v_float32x4& pt = projected;
+                        // check coords >= 0 and < imgSize
+                        v_uint32x4 limits = v_or(v_reinterpret_as_u32(v_lt(pt, v_setzero_f32())),
+                            v_reinterpret_as_u32(v_ge(pt, upLimits)));
+                        limits = v_or(limits, v_rotate_right<1>(limits));
+                        if (v_get0(limits))
+                            continue;
+
+                        // xi, yi = floor(pt)
+                        v_int32x4 ip = v_floor(pt);
+                        v_int32x4 ipshift = ip;
+                        int xi = v_get0(ipshift);
+                        ipshift = v_rotate_right<1>(ipshift);
+                        int yi = v_get0(ipshift);
+
+                        const depthType* row0 = depth[yi + 0];
+                        const depthType* row1 = depth[yi + 1];
+
+                        // v001 = [v(xi + 0, yi + 0), v(xi + 1, yi + 0)]
+                        v_float32x4 v001 = v_load_low(row0 + xi);
+                        // v101 = [v(xi + 0, yi + 1), v(xi + 1, yi + 1)]
+                        v_float32x4 v101 = v_load_low(row1 + xi);
+
+                        v_float32x4 vall = v_combine_low(v001, v101);
+
+                        // assume correct depth is positive
+                        // don't fix missing data
+                        if (v_check_all(v_gt(vall, v_setzero_f32())))
+                        {
+                            v_float32x4 t = v_sub(pt, v_cvt_f32(ip));
+                            float tx = v_get0(t);
+                            t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+                            v_float32x4 ty = v_setall_f32(v_get0(t));
+                            // vx is y-interpolated between rows 0 and 1
+                            v_float32x4 vx = v_add(v001, v_mul(ty, v_sub(v101, v001)));
+                            float v0 = v_get0(vx);
+                            vx = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vx)));
+                            float v1 = v_get0(vx);
+                            v = v0 + tx * (v1 - v0);
+                        }
+                        else
+                            continue;
+                    }
+
+                    // norm(camPixVec) produces double which is too slow
+                    int _u = (int)v_get0(projected);
+                    int _v = (int)v_get0(v_rotate_right<1>(projected));
+                    if (!(_u >= 0 && _u < depth.cols && _v >= 0 && _v < depth.rows))
+                        continue;
+                    float pixNorm = pixNorms.at<float>(_v, _u);
+                    // float pixNorm = sqrt(v_reduce_sum(camPixVec*camPixVec));
+                    // difference between distances of point and of surface to camera
+                    float sdf = pixNorm * (v * dfac - zCamSpace);
+                    // possible alternative is:
+                    // kftype sdf = norm(camSpacePt)*(v*dfac/camSpacePt.z - 1);
+
+                    if (sdf >= -truncDist)
+                    {
+                        TsdfType tsdf = floatToTsdf(fmin(1.f, sdf * truncDistInv));
+
+                        TsdfVoxel& voxel = volDataY[z * volStrides[2]];
+                        WeightType& weight = voxel.weight;
+                        TsdfType& value = voxel.tsdf;
+
+                        // update TSDF
+                        value = floatToTsdf((tsdfToFloat(value) * weight + tsdfToFloat(tsdf)) / (weight + 1));
+                        weight = (weight + 1) < maxWeight ? (weight + 1) : (WeightType)maxWeight;
+                    }
+                }
+            }
+        }
+    };
+#else
+    auto IntegrateInvoker = [&](const Range& range)
+    {
+        for (int x = range.start; x < range.end; x++)
+        {
+            TsdfVoxel* volDataX = volDataStart + x * volStrides[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                TsdfVoxel* volDataY = volDataX + y * volStrides[1];
+                // optimization of camSpace transformation (vector addition instead of matmul at each z)
+                Point3f basePt = vol2cam * (Point3f(float(x), float(y), 0.0f) * voxelSize);
+                Point3f camSpacePt = basePt;
+                // zStep == vol2cam*(Point3f(x, y, 1)*voxelSize) - basePt;
+                // zStep == vol2cam*[Point3f(x, y, 1) - Point3f(x, y, 0)]*voxelSize
+                Point3f zStep = Point3f(vol2cam.matrix(0, 2),
+                    vol2cam.matrix(1, 2),
+                    vol2cam.matrix(2, 2)) * voxelSize;
+                int startZ, endZ;
+                if (abs(zStep.z) > 1e-5)
+                {
+                    int baseZ = int(-basePt.z / zStep.z);
+                    if (zStep.z > 0)
+                    {
+                        startZ = baseZ;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        startZ = 0;
+                        endZ = baseZ;
+                    }
+                }
+                else
+                {
+                    if (basePt.z > 0)
+                    {
+                        startZ = 0;
+                        endZ = volResolution.z;
+                    }
+                    else
+                    {
+                        // z loop shouldn't be performed
+                        startZ = endZ = 0;
+                    }
+                }
+                startZ = max(0, startZ);
+                endZ = min(int(volResolution.z), endZ);
+
+                for (int z = startZ; z < endZ; z++)
+                {
+                    // optimization of the following:
+                    //Point3f volPt = Point3f(x, y, z)*volume.voxelSize;
+                    //Point3f camSpacePt = vol2cam * volPt;
+
+                    camSpacePt += zStep;
+                    if (camSpacePt.z <= 0)
+                        continue;
+
+                    Point3f camPixVec;
+                    Point2f projected = proj(camSpacePt, camPixVec);
+
+                    depthType v = bilinearDepth(depth, projected);
+                    if (v == 0) {
+                        continue;
+                    }
+                    int _u = (int)projected.x;
+                    int _v = (int)projected.y;
+                    if (!(_u >= 0 && _u < depth.cols && _v >= 0 && _v < depth.rows))
+                        continue;
+
+                    float pixNorm = pixNorms.at<float>(_v, _u);
+
+                    // difference between distances of point and of surface to camera
+                    float sdf = pixNorm * (v * dfac - camSpacePt.z);
+                    // possible alternative is:
+                    // kftype sdf = norm(camSpacePt)*(v*dfac/camSpacePt.z - 1);
+                    if (sdf >= -truncDist)
+                    {
+                        TsdfType tsdf = floatToTsdf(fmin(1.f, sdf * truncDistInv));
+
+                        TsdfVoxel& voxel = volDataY[z * volStrides[2]];
+                        WeightType& weight = voxel.weight;
+                        TsdfType& value = voxel.tsdf;
+
+                        // update TSDF
+                        value = floatToTsdf((tsdfToFloat(value) * weight + tsdfToFloat(tsdf)) / (weight + 1));
+                        weight = (WeightType)min(weight + 1, maxWeight);
+                    }
+                }
+            }
+        }
+    };
+#endif
+    parallel_for_(integrateRange, IntegrateInvoker);
+    //IntegrateInvoker(integrateRange);
+}
+
+#ifdef HAVE_OPENCL
+void ocl_integrateTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose,
+                                 InputArray _depth, InputArray _pixNorms, InputArray _volume)
+{
+    CV_TRACE_FUNCTION();
+    CV_Assert(!_depth.empty());
+
+    UMat depth = _depth.getUMat();
+    UMat volume = _volume.getUMat();
+    UMat pixNorms = _pixNorms.getUMat();
+
+    String errorStr;
+    String name = "integrate";
+    ocl::ProgramSource source = ocl::ptcloud::tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    UMat vol2camGpu;
+    Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+    Mat(vol2cam.matrix).copyTo(vol2camGpu);
+
+    float dfac = 1.f / settings.getDepthFactor();
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    Vec4i volResGpu(volResolution.x, volResolution.y, volResolution.z);
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    Intr intrinsics(intr);
+    Vec2f fxy(intrinsics.fx, intrinsics.fy), cxy(intrinsics.cx, intrinsics.cy);
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+
+    const float voxelSize = settings.getVoxelSize();
+    const float truncatedDistance = settings.getTsdfTruncateDistance();
+    const int maxWeight = settings.getMaxWeight();
+
+    // TODO: optimization possible
+    // Use sampler for depth (mask needed)
+    k.args(ocl::KernelArg::ReadOnly(depth),
+        ocl::KernelArg::PtrReadWrite(volume),
+        ocl::KernelArg::PtrReadOnly(vol2camGpu),
+        voxelSize,
+        volResGpu.val,
+        volDims.val,
+        fxy.val,
+        cxy.val,
+        dfac,
+        truncatedDistance,
+        maxWeight,
+        ocl::KernelArg::PtrReadOnly(pixNorms));
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)volResolution.x;
+    globalSize[1] = (size_t)volResolution.y;
+
+    if (!k.run(2, globalSize, NULL, true))
+        throw std::runtime_error("Failed to run kernel");
+
+}
+#endif
+
+
+// Raycast
+
+#if USE_INTRINSICS
+// all coordinate checks should be done in inclosing cycle
+inline float interpolateTsdfVoxel(const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords,
+    const v_float32x4& p)
+{
+    // tx, ty, tz = floor(p)
+    v_int32x4 ip = v_floor(p);
+    v_float32x4 t = v_sub(p, v_cvt_f32(ip));
+    float tx = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float ty = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float tz = v_get0(t);
+
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const TsdfVoxel* volData = volume.ptr<TsdfVoxel>();
+
+    int ix = v_get0(ip);
+    ip = v_rotate_right<1>(ip);
+    int iy = v_get0(ip);
+    ip = v_rotate_right<1>(ip);
+    int iz = v_get0(ip);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    TsdfType vx[8];
+    for (int i = 0; i < 8; i++)
+        vx[i] = volData[neighbourCoords[i] + coordBase].tsdf;
+
+    v_float32x4 v0246 = tsdfToFloat_INTR(v_int32x4(vx[0], vx[2], vx[4], vx[6]));
+    v_float32x4 v1357 = tsdfToFloat_INTR(v_int32x4(vx[1], vx[3], vx[5], vx[7]));
+    v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+    v_float32x4 v00_10 = vxx;
+    v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+    v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+    float v0 = v_get0(v0_1);
+    v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+    float v1 = v_get0(v0_1);
+
+    return v0 + tx * (v1 - v0);
+}
+
+inline float interpolateTsdfVoxel( const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords,
+    const Point3f& _p)
+{
+    v_float32x4 p(_p.x, _p.y, _p.z, 0);
+    return interpolateTsdfVoxel(volume, volDims, neighbourCoords, p);
+}
+
+#else
+inline float interpolateTsdfVoxel( const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords,
+    const Point3f& p)
+{
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+
+    int ix = cvFloor(p.x);
+    int iy = cvFloor(p.y);
+    int iz = cvFloor(p.z);
+
+    float tx = p.x - ix;
+    float ty = p.y - iy;
+    float tz = p.z - iz;
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+    const TsdfVoxel* volData = volume.ptr<TsdfVoxel>();
+
+    float vx[8];
+    for (int i = 0; i < 8; i++)
+        vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase].tsdf);
+
+    float v00 = vx[0] + tz * (vx[1] - vx[0]);
+    float v01 = vx[2] + tz * (vx[3] - vx[2]);
+    float v10 = vx[4] + tz * (vx[5] - vx[4]);
+    float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+    float v0 = v00 + ty * (v01 - v00);
+    float v1 = v10 + ty * (v11 - v10);
+
+    return v0 + tx * (v1 - v0);
+
+}
+#endif
+
+
+#if USE_INTRINSICS
+//gradientDeltaFactor is fixed at 1.0 of voxel size
+inline v_float32x4 getNormalVoxel( const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const v_float32x4& p)
+{
+    if (v_check_any(v_lt(p, v_float32x4(1.f, 1.f, 1.f, 0.f))) ||
+        v_check_any(v_ge(p, v_float32x4((float)(volResolution.x - 2),
+            (float)(volResolution.y - 2),
+            (float)(volResolution.z - 2), 1.f)))
+        )
+        return nanv;
+
+    v_int32x4 ip = v_floor(p);
+    v_float32x4 t = v_sub(p, v_cvt_f32(ip));
+    float tx = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float ty = v_get0(t);
+    t = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(t)));
+    float tz = v_get0(t);
+
+    const int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const TsdfVoxel* volData = volume.ptr<TsdfVoxel>();
+
+    int ix = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iy = v_get0(ip); ip = v_rotate_right<1>(ip);
+    int iz = v_get0(ip);
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    float CV_DECL_ALIGNED(16) an[4];
+    an[0] = an[1] = an[2] = an[3] = 0.f;
+    for (int c = 0; c < 3; c++)
+    {
+        const int dim = volDims[c];
+        float& nv = an[c];
+
+        float vx[8];
+        for (int i = 0; i < 8; i++)
+            vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase + 1 * dim].tsdf) -
+            tsdfToFloat(volData[neighbourCoords[i] + coordBase - 1 * dim].tsdf);
+
+        v_float32x4 v0246(vx[0], vx[2], vx[4], vx[6]);
+        v_float32x4 v1357(vx[1], vx[3], vx[5], vx[7]);
+        v_float32x4 vxx = v_add(v0246, v_mul(v_setall_f32(tz), v_sub(v1357, v0246)));
+
+        v_float32x4 v00_10 = vxx;
+        v_float32x4 v01_11 = v_reinterpret_as_f32(v_rotate_right<1>(v_reinterpret_as_u32(vxx)));
+
+        v_float32x4 v0_1 = v_add(v00_10, v_mul(v_setall_f32(ty), v_sub(v01_11, v00_10)));
+        float v0 = v_get0(v0_1);
+        v0_1 = v_reinterpret_as_f32(v_rotate_right<2>(v_reinterpret_as_u32(v0_1)));
+        float v1 = v_get0(v0_1);
+
+        nv = v0 + tx * (v1 - v0);
+    }
+
+    v_float32x4 n = v_load_aligned(an);
+    v_float32x4 Norm = v_sqrt(v_setall_f32(v_reduce_sum(v_mul(n, n))));
+
+    return v_get0(Norm) < 0.0001f ? nanv : v_div(n, Norm);
+}
+
+inline Point3f getNormalVoxel( const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const Point3f& _p)
+{
+    v_float32x4 p(_p.x, _p.y, _p.z, 0.f);
+    v_float32x4 result = getNormalVoxel(volume, volDims, neighbourCoords, volResolution, p);
+    float CV_DECL_ALIGNED(16) ares[4];
+    v_store_aligned(ares, result);
+    return Point3f(ares[0], ares[1], ares[2]);
+}
+#else
+inline Point3f getNormalVoxel( const Mat& volume,
+    const Vec4i& volDims, const Vec8i& neighbourCoords, const Point3i volResolution,
+    const Point3f& p)
+{
+    int xdim = volDims[0], ydim = volDims[1], zdim = volDims[2];
+    const TsdfVoxel* volData = volume.ptr<TsdfVoxel>();
+
+    if (p.x < 1 || p.x >= volResolution.x - 2 ||
+        p.y < 1 || p.y >= volResolution.y - 2 ||
+        p.z < 1 || p.z >= volResolution.z - 2)
+        return nan3;
+
+    int ix = cvFloor(p.x);
+    int iy = cvFloor(p.y);
+    int iz = cvFloor(p.z);
+
+    float tx = p.x - ix;
+    float ty = p.y - iy;
+    float tz = p.z - iz;
+
+    int coordBase = ix * xdim + iy * ydim + iz * zdim;
+
+    Vec3f an;
+    for (int c = 0; c < 3; c++)
+    {
+        const int dim = volDims[c];
+        float& nv = an[c];
+
+        float vx[8];
+        for (int i = 0; i < 8; i++)
+            vx[i] = tsdfToFloat(volData[neighbourCoords[i] + coordBase + 1 * dim].tsdf) -
+            tsdfToFloat(volData[neighbourCoords[i] + coordBase - 1 * dim].tsdf);
+
+        float v00 = vx[0] + tz * (vx[1] - vx[0]);
+        float v01 = vx[2] + tz * (vx[3] - vx[2]);
+        float v10 = vx[4] + tz * (vx[5] - vx[4]);
+        float v11 = vx[6] + tz * (vx[7] - vx[6]);
+
+        float v0 = v00 + ty * (v01 - v00);
+        float v1 = v10 + ty * (v11 - v10);
+
+        nv = v0 + tx * (v1 - v0);
+    }
+
+    float nv = sqrt(an[0] * an[0] +
+        an[1] * an[1] +
+        an[2] * an[2]);
+    return nv < 0.0001f ? nan3 : an / nv;
+}
+#endif
+
+void raycastTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose,
+                           int height, int width, InputArray intr,
+                           InputArray _volume, OutputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+
+    const Size frameSize(width, height);
+    CV_Assert(frameSize.area() > 0);
+
+    Matx33f mintr(intr.getMat());
+
+    _points.create(frameSize, POINT_TYPE);
+    _normals.create(frameSize, POINT_TYPE);
+
+    Points points = _points.getMat();
+    Normals normals = _normals.getMat();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const Point3f volSize = Point3f(volResolution) * settings.getVoxelSize();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+
+    const Point3f boxMax(volSize - Point3f(settings.getVoxelSize(), settings.getVoxelSize(), settings.getVoxelSize()));
+    const Point3f boxMin = Point3f(0, 0, 0);
+    const Affine3f cam2vol(pose.inv() * Affine3f(cameraPose));
+    const Affine3f vol2cam(Affine3f(cameraPose.inv()) * pose);
+
+    const Mat volume = _volume.getMat();
+    float voxelSize = settings.getVoxelSize();
+    float voxelSizeInv = 1.0f / voxelSize;
+    const Intr::Reprojector reproj = Intr(mintr).makeReprojector();
+    float tstep = settings.getTsdfTruncateDistance() * settings.getRaycastStepFactor();
+
+    Range raycastRange = Range(0, points.rows);
+    //TODO::  swap realization, they are missplaced :)
+#if USE_INTRINSICS
+    auto RaycastInvoker = [&](const Range& range)
+    {
+        const v_float32x4 vfxy(reproj.fxinv, reproj.fyinv, 0, 0);
+        const v_float32x4 vcxy(reproj.cx, reproj.cy, 0, 0);
+
+        const float(&cm)[16] = cam2vol.matrix.val;
+        const v_float32x4 camRot0(cm[0], cm[4], cm[8], 0);
+        const v_float32x4 camRot1(cm[1], cm[5], cm[9], 0);
+        const v_float32x4 camRot2(cm[2], cm[6], cm[10], 0);
+        const v_float32x4 camTrans(cm[3], cm[7], cm[11], 0);
+
+        const v_float32x4 boxDown(boxMin.x, boxMin.y, boxMin.z, 0.f);
+        const v_float32x4 boxUp(boxMax.x, boxMax.y, boxMax.z, 0.f);
+
+        const v_float32x4 invVoxelSize = v_float32x4(voxelSizeInv, voxelSizeInv, voxelSizeInv, 1.f);
+
+        const float(&vm)[16] = vol2cam.matrix.val;
+        const v_float32x4 volRot0(vm[0], vm[4], vm[8], 0);
+        const v_float32x4 volRot1(vm[1], vm[5], vm[9], 0);
+        const v_float32x4 volRot2(vm[2], vm[6], vm[10], 0);
+        const v_float32x4 volTrans(vm[3], vm[7], vm[11], 0);
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            ptype* ptsRow = points[y];
+            ptype* nrmRow = normals[y];
+
+            for (int x = 0; x < points.cols; x++)
+            {
+                v_float32x4 point = nanv, normal = nanv;
+
+                v_float32x4 orig = camTrans;
+
+                // get direction through pixel in volume space:
+
+                // 1. reproject (x, y) on projecting plane where z = 1.f
+                v_float32x4 planed = v_mul(v_sub(v_float32x4((float)x, (float)y, 0.f, 0.f), vcxy), vfxy);
+                planed = v_combine_low(planed, v_float32x4(1.f, 0.f, 0.f, 0.f));
+
+                // 2. rotate to volume space
+                planed = v_matmuladd(planed, camRot0, camRot1, camRot2, v_setzero_f32());
+
+                // 3. normalize
+                v_float32x4 invNorm = v_invsqrt(v_setall_f32(v_reduce_sum(v_mul(planed, planed))));
+                v_float32x4 dir = v_mul(planed, invNorm);
+
+                // compute intersection of ray with all six bbox planes
+                v_float32x4 rayinv = v_div(v_setall_f32(1.f), dir);
+                // div by zero should be eliminated by these products
+                v_float32x4 tbottom = v_mul(rayinv, v_sub(boxDown, orig));
+                v_float32x4 ttop = v_mul(rayinv, v_sub(boxUp, orig));
+
+                // re-order intersections to find smallest and largest on each axis
+                v_float32x4 minAx = v_min(ttop, tbottom);
+                v_float32x4 maxAx = v_max(ttop, tbottom);
+
+                // near clipping plane
+                const float clip = 0.f;
+                float _minAx[4], _maxAx[4];
+                v_store(_minAx, minAx);
+                v_store(_maxAx, maxAx);
+                float tmin = max({ _minAx[0], _minAx[1], _minAx[2], clip });
+                float tmax = min({ _maxAx[0], _maxAx[1], _maxAx[2] });
+
+                // precautions against getting coordinates out of bounds
+                tmin = tmin + tstep;
+                tmax = tmax - tstep;
+
+                if (tmin < tmax)
+                {
+                    // interpolation optimized a little
+                    orig = v_mul(orig, invVoxelSize);
+                    dir = v_mul(dir, invVoxelSize);
+
+                    int xdim = volDims[0];
+                    int ydim = volDims[1];
+                    int zdim = volDims[2];
+                    v_float32x4 rayStep = v_mul(dir, v_setall_f32(tstep));
+                    v_float32x4 next = v_add(orig, v_mul(dir, v_setall_f32(tmin)));
+                    float f = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+                    float fnext = f;
+
+                    //raymarch
+                    int steps = 0;
+                    int nSteps = cvFloor((tmax - tmin) / tstep);
+                    for (; steps < nSteps; steps++)
+                    {
+                        next = v_add(next, rayStep);
+                        v_int32x4 ip = v_round(next);
+                        int ix = v_get0(ip); ip = v_rotate_right<1>(ip);
+                        int iy = v_get0(ip); ip = v_rotate_right<1>(ip);
+                        int iz = v_get0(ip);
+                        int coord = ix * xdim + iy * ydim + iz * zdim;
+
+                        fnext = tsdfToFloat(volume.at<TsdfVoxel>(coord).tsdf);
+                        if (fnext != f)
+                        {
+                            fnext = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+
+                            // when ray crosses a surface
+                            if (std::signbit(f) != std::signbit(fnext))
+                                break;
+
+                            f = fnext;
+                        }
+                    }
+
+                    // if ray penetrates a surface from outside
+                    // linearly interpolate t between two f values
+                    if (f > 0.f && fnext < 0.f)
+                    {
+                        v_float32x4 tp = v_sub(next, rayStep);
+                        float ft = interpolateTsdfVoxel(volume, volDims, neighbourCoords, tp);
+                        float ftdt = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+                        float ts = tmin + tstep * (steps - ft / (ftdt - ft));
+
+                        // avoid division by zero
+                        if (!cvIsNaN(ts) && !cvIsInf(ts))
+                        {
+                            v_float32x4 pv = v_add(orig, v_mul(dir, v_setall_f32(ts)));
+                            v_float32x4 nv = getNormalVoxel(volume, volDims, neighbourCoords, volResolution, pv);
+
+                            if (!isNaN(nv))
+                            {
+                                //convert pv and nv to camera space
+                                normal = v_matmuladd(nv, volRot0, volRot1, volRot2, v_setzero_f32());
+                                // interpolation optimized a little
+                                point = v_matmuladd(v_mul(pv, v_float32x4(voxelSize, voxelSize, voxelSize, 1.f)),
+                                    volRot0, volRot1, volRot2, volTrans);
+                            }
+                        }
+                    }
+                }
+
+                v_store((float*)(&ptsRow[x]), point);
+                v_store((float*)(&nrmRow[x]), normal);
+            }
+        }
+    };
+#else
+    auto RaycastInvoker = [&](const Range& range)
+    {
+        const Point3f camTrans = cam2vol.translation();
+        const Matx33f  camRot = cam2vol.rotation();
+        const Matx33f  volRot = vol2cam.rotation();
+
+        for (int y = range.start; y < range.end; y++)
+        {
+            ptype* ptsRow = points[y];
+            ptype* nrmRow = normals[y];
+
+            for (int x = 0; x < points.cols; x++)
+            {
+                Point3f point = nan3, normal = nan3;
+
+                Point3f orig = camTrans;
+                // direction through pixel in volume space
+                Point3f dir = normalize(Vec3f(camRot * reproj(Point3f(float(x), float(y), 1.f))));
+
+                // compute intersection of ray with all six bbox planes
+                Vec3f rayinv(1.f / dir.x, 1.f / dir.y, 1.f / dir.z);
+                Point3f tbottom = rayinv.mul(boxMin - orig);
+                Point3f ttop = rayinv.mul(boxMax - orig);
+
+                // re-order intersections to find smallest and largest on each axis
+                Point3f minAx(min(ttop.x, tbottom.x), min(ttop.y, tbottom.y), min(ttop.z, tbottom.z));
+                Point3f maxAx(max(ttop.x, tbottom.x), max(ttop.y, tbottom.y), max(ttop.z, tbottom.z));
+
+                // near clipping plane
+                const float clip = 0.f;
+                //float tmin = max(max(max(minAx.x, minAx.y), max(minAx.x, minAx.z)), clip);
+                //float tmax =     min(min(maxAx.x, maxAx.y), min(maxAx.x, maxAx.z));
+                float tmin = max({ minAx.x, minAx.y, minAx.z, clip });
+                float tmax = min({ maxAx.x, maxAx.y, maxAx.z });
+
+                // precautions against getting coordinates out of bounds
+                tmin = tmin + tstep;
+                tmax = tmax - tstep;
+
+                if (tmin < tmax)
+                {
+                    // interpolation optimized a little
+                    orig = orig * voxelSizeInv;
+                    dir = dir * voxelSizeInv;
+
+                    Point3f rayStep = dir * tstep;
+                    Point3f next = (orig + dir * tmin);
+                    float f = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+                    float fnext = f;
+
+                    //raymarch
+                    int steps = 0;
+                    int nSteps = int(floor((tmax - tmin) / tstep));
+                    for (; steps < nSteps; steps++)
+                    {
+                        next += rayStep;
+                        int xdim = volDims[0];
+                        int ydim = volDims[1];
+                        int zdim = volDims[2];
+                        int ix = cvRound(next.x);
+                        int iy = cvRound(next.y);
+                        int iz = cvRound(next.z);
+                        fnext = tsdfToFloat(volume.at<TsdfVoxel>(ix * xdim + iy * ydim + iz * zdim).tsdf);
+                        if (fnext != f)
+                        {
+                            fnext = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+                            // when ray crosses a surface
+                            if (std::signbit(f) != std::signbit(fnext))
+                                break;
+
+                            f = fnext;
+                        }
+                    }
+                    // if ray penetrates a surface from outside
+                    // linearly interpolate t between two f values
+                    if (f > 0.f && fnext < 0.f)
+                    {
+                        Point3f tp = next - rayStep;
+                        float ft = interpolateTsdfVoxel(volume, volDims, neighbourCoords, tp);
+                        float ftdt = interpolateTsdfVoxel(volume, volDims, neighbourCoords, next);
+                        // float t = tmin + steps*tstep;
+                        // float ts = t - tstep*ft/(ftdt - ft);
+                        float ts = tmin + tstep * (steps - ft / (ftdt - ft));
+
+                        // avoid division by zero
+                        if (!cvIsNaN(ts) && !cvIsInf(ts))
+                        {
+                            Point3f pv = (orig + dir * ts);
+                            Point3f nv = getNormalVoxel(volume, volDims, neighbourCoords, volResolution, pv);
+
+                            if (!isNaN(nv))
+                            {
+                                //convert pv and nv to camera space
+                                normal = volRot * nv;
+                                // interpolation optimized a little
+                                point = vol2cam * (pv * voxelSize);
+                            }
+                        }
+                    }
+                }
+                ptsRow[x] = toPtype(point);
+                nrmRow[x] = toPtype(normal);
+            }
+        }
+    };
+
+#endif
+    parallel_for_(raycastRange, RaycastInvoker);
+}
+
+
+#ifdef HAVE_OPENCL
+void ocl_raycastTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose,
+                               int height, int width, InputArray intr,
+                               InputArray _volume, OutputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+
+    const Size frameSize(width, height);
+    CV_Assert(frameSize.area() > 0);
+
+    Matx33f mintr(intr.getMat());
+
+    String errorStr;
+    String name = "raycast";
+    ocl::ProgramSource source = ocl::ptcloud::tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    _points.create(frameSize, CV_32FC4);
+    _normals.create(frameSize, CV_32FC4);
+
+    UMat points = _points.getUMat();
+    UMat normals = _normals.getUMat();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    const Point3f volSize = Point3f(volResolution) * settings.getVoxelSize();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+
+    UMat vol2camGpu, cam2volGpu;
+    Affine3f vol2cam = Affine3f(cameraPose.inv()) * pose;
+    Affine3f cam2vol = pose.inv() * Affine3f(cameraPose);
+    Mat(cam2vol.matrix).copyTo(cam2volGpu);
+    Mat(vol2cam.matrix).copyTo(vol2camGpu);
+
+    Intr intrinsics(mintr);
+    Intr::Reprojector r = intrinsics.makeReprojector();
+
+    const UMat volume = _volume.getUMat();
+    float voxelSize = settings.getVoxelSize();
+    float raycastStepFactor = settings.getRaycastStepFactor();
+    float truncatedDistance = settings.getTsdfTruncateDistance();
+
+    // We do subtract voxel size to minimize checks after
+    // Note: origin of volume coordinate is placed
+    // in the center of voxel (0,0,0), not in the corner of the voxel!
+    Vec4f boxMin, boxMax(volSize.x - voxelSize,
+        volSize.y - voxelSize,
+        volSize.z - voxelSize);
+    Vec2f finv(r.fxinv, r.fyinv), cxy(r.cx, r.cy);
+    float tstep = truncatedDistance * raycastStepFactor;
+
+    Vec4i volResGpu(volResolution.x, volResolution.y, volResolution.z);
+
+    k.args(ocl::KernelArg::WriteOnlyNoSize(points),
+        ocl::KernelArg::WriteOnlyNoSize(normals),
+        frameSize,
+        ocl::KernelArg::PtrReadOnly(volume),
+        ocl::KernelArg::PtrReadOnly(vol2camGpu),
+        ocl::KernelArg::PtrReadOnly(cam2volGpu),
+        finv.val, cxy.val,
+        boxMin.val, boxMax.val,
+        tstep,
+        voxelSize,
+        volResGpu.val,
+        volDims.val,
+        neighbourCoords.val);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)frameSize.width;
+    globalSize[1] = (size_t)frameSize.height;
+
+    if (!k.run(2, globalSize, NULL, true))
+        throw std::runtime_error("Failed to run kernel");
+}
+#endif
+
+// Fetch
+
+void fetchNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume, InputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    CV_Assert(!_points.empty());
+    if (!_normals.needed())
+        return;
+
+    Points points = _points.getMat();
+    CV_Assert(points.type() == POINT_TYPE);
+
+    _normals.createSameSize(_points, _points.type());
+    Normals normals = _normals.getMat();
+
+    const Mat volume = _volume.getMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    Affine3f invPose(pose.inv());
+    Matx33f r = pose.rotation();
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+    auto PushNormals = [&](const ptype& pp, const int* position)
+    {
+        Point3f p = fromPtype(pp);
+        Point3f n = nan3;
+        if (!isNaN(p))
+        {
+            Point3f voxPt = (invPose * p);
+            voxPt = voxPt * voxelSizeInv;
+            n = r * getNormalVoxel(volume, volDims, neighbourCoords, volResolution, voxPt);
+        }
+        normals(position[0], position[1]) = toPtype(n);
+    };
+    points.forEach(PushNormals);
+}
+
+#ifdef HAVE_OPENCL
+void ocl_fetchNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume, InputArray _points, OutputArray _normals)
+{
+    CV_TRACE_FUNCTION();
+    CV_Assert(!_points.empty());
+    if (!_normals.needed())
+        return;
+
+    UMat points = _points.getUMat();
+    CV_Assert(points.type() == POINT_TYPE);
+
+    _normals.createSameSize(_points, POINT_TYPE);
+    UMat normals = _normals.getUMat();
+
+    const UMat volume = _volume.getUMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+    String errorStr;
+    String name = "getNormals";
+    ocl::ProgramSource source = ocl::ptcloud::tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+    ocl::Kernel k;
+    k.create(name.c_str(), source, options, &errorStr);
+
+    if (k.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    UMat volPoseGpu, invPoseGpu;
+    Mat(pose.matrix).copyTo(volPoseGpu);
+    Mat(pose.inv().matrix).copyTo(invPoseGpu);
+    Vec4i volResGpu(volResolution.x, volResolution.y, volResolution.z);
+    Size frameSize = points.size();
+
+    k.args(ocl::KernelArg::ReadOnlyNoSize(points),
+           ocl::KernelArg::WriteOnlyNoSize(normals),
+           frameSize,
+           ocl::KernelArg::PtrReadOnly(volume),
+           ocl::KernelArg::PtrReadOnly(volPoseGpu),
+           ocl::KernelArg::PtrReadOnly(invPoseGpu),
+           voxelSizeInv,
+           volResGpu.val,
+           volDims.val,
+           neighbourCoords.val);
+
+    size_t globalSize[2];
+    globalSize[0] = (size_t)points.cols;
+    globalSize[1] = (size_t)points.rows;
+
+    if (!k.run(2, globalSize, NULL, true))
+        throw std::runtime_error("Failed to run kernel");
+
+}
+#endif
+
+inline void coord(const Mat& volume, const TsdfVoxel* volDataStart, std::vector<ptype>& points, std::vector<ptype>& normals,
+                  const Point3i volResolution, const Vec4i volDims, const Vec8i neighbourCoords, const Affine3f pose,
+                  const float voxelSize, const float voxelSizeInv, bool needNormals, int x, int y, int z, Point3f V, float v0, int axis)
+{
+    // 0 for x, 1 for y, 2 for z
+    bool limits = false;
+    Point3i shift;
+    float Vc = 0.f;
+    if (axis == 0)
+    {
+        shift = Point3i(1, 0, 0);
+        limits = (x + 1 < volResolution.x);
+        Vc = V.x;
+    }
+    if (axis == 1)
+    {
+        shift = Point3i(0, 1, 0);
+        limits = (y + 1 < volResolution.y);
+        Vc = V.y;
+    }
+    if (axis == 2)
+    {
+        shift = Point3i(0, 0, 1);
+        limits = (z + 1 < volResolution.z);
+        Vc = V.z;
+    }
+
+    if (limits)
+    {
+        const TsdfVoxel &voxeld = volDataStart[(x + shift.x) * volDims[0] +
+                                               (y + shift.y) * volDims[1] +
+                                               (z + shift.z) * volDims[2]];
+        float vd = tsdfToFloat(voxeld.tsdf);
+        if (voxeld.weight != 0 && vd != 1.f)
+        {
+            if ((v0 > 0 && vd < 0) || (v0 < 0 && vd > 0))
+            {
+                //linearly interpolate coordinate
+                float Vn = Vc + voxelSize;
+                float dinv = 1.f / (abs(v0) + abs(vd));
+                float inter = (Vc * abs(vd) + Vn * abs(v0)) * dinv;
+
+                Point3f p(shift.x ? inter : V.x,
+                          shift.y ? inter : V.y,
+                          shift.z ? inter : V.z);
+                {
+                    points.push_back(toPtype(pose * p));
+                    if (needNormals)
+                        normals.push_back(toPtype(pose.rotation() *
+                                          getNormalVoxel(volume, volDims, neighbourCoords, volResolution, p * voxelSizeInv)));
+                }
+            }
+        }
+    }
+}
+
+
+void fetchPointsNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume, OutputArray _points, OutputArray _normals)
+{
+    if (!_points.needed())
+        return;
+    const Mat volume = _volume.getMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+    float voxelSize = settings.getVoxelSize();
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+    bool needNormals = _normals.needed();
+
+    std::vector<std::vector<ptype>> pVecs, nVecs;
+    Range fetchRange(0, volResolution.x);
+    const int nstripes = -1;
+    const TsdfVoxel* volDataStart = volume.ptr<TsdfVoxel>();
+    Mutex mutex;
+
+    auto FetchPointsNormalsInvoker = [&](const Range& range) {
+        std::vector<ptype> points, normals;
+        for (int x = range.start; x < range.end; x++)
+        {
+            const TsdfVoxel* volDataX = volDataStart + x * volDims[0];
+            for (int y = 0; y < volResolution.y; y++)
+            {
+                const TsdfVoxel* volDataY = volDataX + y * volDims[1];
+                for (int z = 0; z < volResolution.z; z++)
+                {
+                    const TsdfVoxel& voxel0 = volDataY[z * volDims[2]];
+                    float v0 = tsdfToFloat(voxel0.tsdf);
+                    if (voxel0.weight != 0 && v0 != 1.f)
+                    {
+                        Point3f V(Point3f((float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f) * voxelSize);
+
+                        coord(volume, volDataStart, points, normals, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, x, y, z, V, v0, 0);
+                        coord(volume, volDataStart, points, normals, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, x, y, z, V, v0, 1);
+                        coord(volume, volDataStart, points, normals, volResolution, volDims, neighbourCoords, pose, voxelSize, voxelSizeInv, needNormals, x, y, z, V, v0, 2);
+
+                    } // if voxel is not empty
+                }
+            }
+        }
+
+        AutoLock al(mutex);
+        pVecs.push_back(points);
+        nVecs.push_back(normals);
+    };
+
+    parallel_for_(fetchRange, FetchPointsNormalsInvoker, nstripes);
+
+    std::vector<ptype> points, normals;
+    for (size_t i = 0; i < pVecs.size(); i++)
+    {
+        points.insert(points.end(), pVecs[i].begin(), pVecs[i].end());
+        normals.insert(normals.end(), nVecs[i].begin(), nVecs[i].end());
+    }
+
+    _points.create((int)points.size(), 1, POINT_TYPE);
+    if (!points.empty())
+        Mat((int)points.size(), 1, POINT_TYPE, &points[0]).copyTo(_points.getMat());
+
+    if (_normals.needed())
+    {
+        _normals.create((int)normals.size(), 1, POINT_TYPE);
+        if (!normals.empty())
+            Mat((int)normals.size(), 1, POINT_TYPE, &normals[0]).copyTo(_normals.getMat());
+    }
+
+}
+
+
+#ifdef HAVE_OPENCL
+void ocl_fetchPointsNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume, OutputArray points, OutputArray normals)
+{
+    CV_TRACE_FUNCTION();
+
+    if (!points.needed())
+        return;
+
+
+    const UMat volume = _volume.getUMat();
+
+    Matx44f _pose;
+    settings.getVolumePose(_pose);
+    const Affine3f pose = Affine3f(_pose);
+
+    float voxelSize = settings.getVoxelSize();
+    float voxelSizeInv = 1.f / settings.getVoxelSize();
+
+    const Vec4i volDims;
+    settings.getVolumeStrides(volDims);
+    const Vec8i neighbourCoords = Vec8i(
+        volDims.dot(Vec4i(0, 0, 0)),
+        volDims.dot(Vec4i(0, 0, 1)),
+        volDims.dot(Vec4i(0, 1, 0)),
+        volDims.dot(Vec4i(0, 1, 1)),
+        volDims.dot(Vec4i(1, 0, 0)),
+        volDims.dot(Vec4i(1, 0, 1)),
+        volDims.dot(Vec4i(1, 1, 0)),
+        volDims.dot(Vec4i(1, 1, 1))
+    );
+
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+
+
+    bool needNormals = normals.needed();
+
+    // 1. scan to count points in each group and allocate output arrays
+
+    ocl::Kernel kscan;
+
+    String errorStr;
+    ocl::ProgramSource source = ocl::ptcloud::tsdf_oclsrc;
+    String options = "-cl-mad-enable";
+
+    kscan.create("scanSize", source, options, &errorStr);
+
+    if (kscan.empty())
+        throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+    size_t globalSize[3];
+    globalSize[0] = (size_t)volResolution.x;
+    globalSize[1] = (size_t)volResolution.y;
+    globalSize[2] = (size_t)volResolution.z;
+
+    const ocl::Device& device = ocl::Device::getDefault();
+    size_t wgsLimit = device.maxWorkGroupSize();
+    size_t memSize = device.localMemSize();
+    // local mem should keep a point (and a normal) for each thread in a group
+    // use 4 float per each point and normal
+    size_t elemSize = (sizeof(float) * 4) * (needNormals ? 2 : 1);
+    const size_t lcols = 8;
+    const size_t lrows = 8;
+    size_t lplanes = min(memSize / elemSize, wgsLimit) / lcols / lrows;
+    lplanes = roundDownPow2(lplanes);
+    size_t localSize[3] = { lcols, lrows, lplanes };
+    Vec3i ngroups((int)divUp(globalSize[0], (unsigned int)localSize[0]),
+        (int)divUp(globalSize[1], (unsigned int)localSize[1]),
+        (int)divUp(globalSize[2], (unsigned int)localSize[2]));
+
+    const size_t counterSize = sizeof(int);
+    size_t lszscan = localSize[0] * localSize[1] * localSize[2] * counterSize;
+
+    const int gsz[3] = { ngroups[2], ngroups[1], ngroups[0] };
+    UMat groupedSum(3, gsz, CV_32S, Scalar(0));
+
+    UMat volPoseGpu;
+    Mat(pose.matrix).copyTo(volPoseGpu);
+    Vec4i volResGpu(volResolution.x, volResolution.y, volResolution.z);
+
+    kscan.args(ocl::KernelArg::PtrReadOnly(volume),
+        volResGpu.val,
+        volDims.val,
+        neighbourCoords.val,
+        ocl::KernelArg::PtrReadOnly(volPoseGpu),
+        voxelSize,
+        voxelSizeInv,
+        ocl::KernelArg::Local(lszscan),
+        ocl::KernelArg::WriteOnlyNoSize(groupedSum));
+
+    if (!kscan.run(3, globalSize, localSize, true))
+        throw std::runtime_error("Failed to run kernel");
+
+    Mat groupedSumCpu = groupedSum.getMat(ACCESS_READ);
+    int gpuSum = (int)sum(groupedSumCpu)[0];
+    // should be no CPU copies when new kernel is executing
+    groupedSumCpu.release();
+
+    // 2. fill output arrays according to per-group points count
+
+    points.create(gpuSum, 1, POINT_TYPE);
+    UMat pts = points.getUMat();
+    UMat nrm;
+    if (needNormals)
+    {
+        normals.create(gpuSum, 1, POINT_TYPE);
+        nrm = normals.getUMat();
+    }
+    else
+    {
+        // it won't be accessed but empty args are forbidden
+        nrm = UMat(1, 1, POINT_TYPE);
+    }
+
+    if (gpuSum)
+    {
+        ocl::Kernel kfill;
+        kfill.create("fillPtsNrm", source, options, &errorStr);
+
+        if (kfill.empty())
+            throw std::runtime_error("Failed to create kernel: " + errorStr);
+
+        UMat atomicCtr(1, 1, CV_32S, Scalar(0));
+
+        // mem size to keep pts (and normals optionally) for all work-items in a group
+        size_t lszfill = localSize[0] * localSize[1] * localSize[2] * elemSize;
+
+        kfill.args(ocl::KernelArg::PtrReadOnly(volume),
+            volResGpu.val,
+            volDims.val,
+            neighbourCoords.val,
+            ocl::KernelArg::PtrReadOnly(volPoseGpu),
+            voxelSize,
+            voxelSizeInv,
+            ((int)needNormals),
+            ocl::KernelArg::Local(lszfill),
+            ocl::KernelArg::PtrReadWrite(atomicCtr),
+            ocl::KernelArg::ReadOnlyNoSize(groupedSum),
+            ocl::KernelArg::WriteOnlyNoSize(pts),
+            ocl::KernelArg::WriteOnlyNoSize(nrm)
+        );
+
+        if (!kfill.run(3, globalSize, localSize, true))
+            throw std::runtime_error("Failed to run kernel");
+    }
+}
+#endif
+
+
+
+} // namespace cv
diff --git a/upstream/opencv/modules/ptcloud/src/tsdf_functions.hpp b/upstream/opencv/modules/ptcloud/src/tsdf_functions.hpp
new file mode 100644
index 0000000..8f138c2
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/tsdf_functions.hpp
@@ -0,0 +1,211 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+// Partially rewritten from https://github.com/Nerei/kinfu_remake
+// Copyright(c) 2012, Anatoly Baksheev. All rights reserved.
+
+#ifndef OPENCV_3D_TSDF_FUNCTIONS_HPP
+#define OPENCV_3D_TSDF_FUNCTIONS_HPP
+
+#include "precomp.hpp"
+#include "utils.hpp"
+
+namespace cv
+{
+
+typedef int8_t TsdfType;
+typedef uchar WeightType;
+
+struct TsdfVoxel
+{
+    TsdfVoxel(TsdfType _tsdf, WeightType _weight) :
+        tsdf(_tsdf), weight(_weight)
+    { }
+    TsdfType tsdf;
+    WeightType weight;
+};
+
+typedef Vec<uchar, sizeof(TsdfVoxel)> VecTsdfVoxel;
+
+typedef short int ColorType;
+struct RGBTsdfVoxel
+{
+    RGBTsdfVoxel(TsdfType _tsdf, WeightType _weight, ColorType _r, ColorType _g, ColorType _b) :
+        tsdf(_tsdf), weight(_weight), r(_r), g(_g), b(_b)
+    { }
+    TsdfType tsdf;
+    WeightType weight;
+    ColorType r, g, b;
+};
+
+typedef Vec<uchar, sizeof(RGBTsdfVoxel)> VecRGBTsdfVoxel;
+
+#if CV_SIMD128
+inline v_float32x4 tsdfToFloat_INTR(const v_int32x4& num)
+{
+    v_float32x4 num128 = v_setall_f32(-1.f / 128.f);
+    return v_mul(v_cvt_f32(num), num128);
+}
+#endif
+
+inline TsdfType floatToTsdf(float num)
+{
+    //CV_Assert(-1 < num <= 1);
+    int8_t res = int8_t(num * (-128.f));
+    res = res ? res : (num < 0 ? 1 : -1);
+    return res;
+}
+
+inline float tsdfToFloat(TsdfType num)
+{
+    return float(num) * (-1.f / 128.f);
+}
+
+inline void colorFix(ColorType& r, ColorType& g, ColorType&b)
+{
+    if (r > 255) r = 255;
+    if (g > 255) g = 255;
+    if (b > 255) b = 255;
+}
+
+inline void colorFix(Point3f& c)
+{
+    if (c.x > 255) c.x = 255;
+    if (c.y > 255) c.y = 255;
+    if (c.z > 255) c.z = 255;
+}
+
+void preCalculationPixNorm(Size size, const Intr& intrinsics, Mat& pixNorm);
+#ifdef HAVE_OPENCL
+void ocl_preCalculationPixNorm(Size size, const Intr& intrinsics, UMat& pixNorm);
+#endif
+
+inline depthType bilinearDepth(const Depth& m, cv::Point2f pt)
+{
+    const bool fixMissingData = false;
+    const depthType defaultValue = qnan;
+    if (pt.x < 0 || pt.x >= m.cols - 1 ||
+        pt.y < 0 || pt.y >= m.rows - 1)
+        return defaultValue;
+
+    int xi = cvFloor(pt.x), yi = cvFloor(pt.y);
+
+    const depthType* row0 = m[yi + 0];
+    const depthType* row1 = m[yi + 1];
+
+    depthType v00 = row0[xi + 0];
+    depthType v01 = row0[xi + 1];
+    depthType v10 = row1[xi + 0];
+    depthType v11 = row1[xi + 1];
+
+    // assume correct depth is positive
+    bool b00 = v00 > 0;
+    bool b01 = v01 > 0;
+    bool b10 = v10 > 0;
+    bool b11 = v11 > 0;
+
+    if (!fixMissingData)
+    {
+        if (!(b00 && b01 && b10 && b11))
+            return defaultValue;
+        else
+        {
+            float tx = pt.x - xi, ty = pt.y - yi;
+            depthType v0 = v00 + tx * (v01 - v00);
+            depthType v1 = v10 + tx * (v11 - v10);
+            return v0 + ty * (v1 - v0);
+        }
+    }
+    else
+    {
+        int nz = b00 + b01 + b10 + b11;
+        if (nz == 0)
+        {
+            return defaultValue;
+        }
+        if (nz == 1)
+        {
+            if (b00) return v00;
+            if (b01) return v01;
+            if (b10) return v10;
+            if (b11) return v11;
+        }
+        if (nz == 2)
+        {
+            if (b00 && b10) v01 = v00, v11 = v10;
+            if (b01 && b11) v00 = v01, v10 = v11;
+            if (b00 && b01) v10 = v00, v11 = v01;
+            if (b10 && b11) v00 = v10, v01 = v11;
+            if (b00 && b11) v01 = v10 = (v00 + v11) * 0.5f;
+            if (b01 && b10) v00 = v11 = (v01 + v10) * 0.5f;
+        }
+        if (nz == 3)
+        {
+            if (!b00) v00 = v10 + v01 - v11;
+            if (!b01) v01 = v00 + v11 - v10;
+            if (!b10) v10 = v00 + v11 - v01;
+            if (!b11) v11 = v01 + v10 - v00;
+        }
+
+        float tx = pt.x - xi, ty = pt.y - yi;
+        depthType v0 = v00 + tx * (v01 - v00);
+        depthType v1 = v10 + tx * (v11 - v10);
+        return v0 + ty * (v1 - v0);
+    }
+}
+
+void _integrateVolumeUnit(
+    float truncDist, float voxelSize, int maxWeight,
+    cv::Matx44f _pose, Point3i volResolution, Vec4i volStrides,
+    InputArray _depth, float depthFactor, const cv::Matx44f& cameraPose,
+    const cv::Intr& intrinsics, InputArray _pixNorms, InputArray _volume);
+
+void _integrateRGBVolumeUnit(
+    float truncDist, float voxelSize, int maxWeight,
+    cv::Matx44f _pose, Point3i volResolution, Vec4i volStrides,
+    InputArray _depth, InputArray _rgb, float depthFactor, const cv::Matx44f& cameraPose,
+    const cv::Intr& depth_intrinsics, const cv::Intr& rgb_intrinsics, InputArray _pixNorms, InputArray _volume);
+
+
+void integrateTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose,
+    InputArray _depth, InputArray _pixNorms, InputArray _volume);
+
+void integrateTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& volumePose, const Matx44f& cameraPose,
+    InputArray _depth, InputArray _pixNorms, InputArray _volume);
+
+
+void raycastTsdfVolumeUnit(const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr,
+                       InputArray _volume, OutputArray _points, OutputArray _normals);
+
+void fetchNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume,
+                                    InputArray _points, OutputArray _normals);
+
+void fetchPointsNormalsFromTsdfVolumeUnit(const VolumeSettings& settings, InputArray _volume,
+                                          OutputArray points, OutputArray normals);
+
+
+#ifdef HAVE_OPENCL
+void ocl_integrateTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose,
+    InputArray _depth, InputArray _pixNorms, InputArray _volume);
+
+void ocl_raycastTsdfVolumeUnit(
+    const VolumeSettings& settings, const Matx44f& cameraPose, int height, int width, InputArray intr,
+    InputArray _volume, OutputArray _points, OutputArray _normals);
+
+void ocl_fetchNormalsFromTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volume,
+    InputArray _points, OutputArray _normals);
+
+void ocl_fetchPointsNormalsFromTsdfVolumeUnit(
+    const VolumeSettings& settings, InputArray _volume,
+    OutputArray _points, OutputArray _normals);
+#endif
+
+
+}  // namespace cv
+
+#endif // include guard
diff --git a/upstream/opencv/modules/ptcloud/src/utils.cpp b/upstream/opencv/modules/ptcloud/src/utils.cpp
new file mode 100644
index 0000000..ed15531
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/utils.cpp
@@ -0,0 +1,21 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "utils.hpp"
+
+namespace cv {
+
+std::vector<std::string> split(const std::string &s, char delimiter)
+{
+    std::vector<std::string> tokens;
+    std::string token;
+    std::istringstream tokenStream(s);
+    while (std::getline(tokenStream, token, delimiter))
+    {
+        tokens.push_back(token);
+    }
+    return tokens;
+}
+
+} /* namespace cv */
diff --git a/upstream/opencv/modules/ptcloud/src/utils.hpp b/upstream/opencv/modules/ptcloud/src/utils.hpp
new file mode 100644
index 0000000..74332e6
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/utils.hpp
@@ -0,0 +1,319 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef _CODERS_UTILS_H_
+#define _CODERS_UTILS_H_
+
+#include "precomp.hpp"
+
+#include <string>
+#include <vector>
+#include <sstream>
+#include <array>
+#include <algorithm>
+#include <cstdint>
+
+namespace cv {
+
+std::vector<std::string> split(const std::string &s, char delimiter);
+
+inline bool startsWith(const std::string &s1, const std::string &s2)
+{
+    return s1.compare(0, s2.length(), s2) == 0;
+}
+
+inline std::string trimSpaces(const std::string &input)
+{
+    size_t start = 0;
+    while (start < input.size() && input[start] == ' ')
+    {
+        start++;
+    }
+    size_t end = input.size();
+    while (end > start && (input[end - 1] == ' ' || input[end - 1] == '\n' || input[end - 1] == '\r'))
+    {
+        end--;
+    }
+    return input.substr(start, end - start);
+}
+
+inline std::string getExtension(const std::string& filename)
+{
+    auto pos = filename.find_last_of('.');
+    if (pos == std::string::npos)
+    {
+        return "";
+    }
+    return filename.substr( pos + 1);
+}
+
+template <typename T>
+void swapEndian(T &val)
+{
+    union U
+    {
+        T val;
+        std::array<std::uint8_t, sizeof(T)> raw;
+    } src, dst;
+
+    src.val = val;
+    std::reverse_copy(src.raw.begin(), src.raw.end(), dst.raw.begin());
+    val = dst.val;
+}
+
+ /** Checks if the value is a valid depth. For CV_16U or CV_16S, the convention is to be invalid if it is
+  * a limit. For a float/double, we just check if it is a NaN
+  * @param depth the depth to check for validity
+  */
+inline bool isValidDepth(const float& depth)
+{
+    return !cvIsNaN(depth);
+}
+
+inline bool isValidDepth(const double& depth)
+{
+    return !cvIsNaN(depth);
+}
+
+inline bool isValidDepth(const short int& depth)
+{
+    return (depth != std::numeric_limits<short int>::min()) &&
+           (depth != std::numeric_limits<short int>::max());
+}
+
+inline bool isValidDepth(const unsigned short int& depth)
+{
+    return (depth != std::numeric_limits<unsigned short int>::min()) &&
+           (depth != std::numeric_limits<unsigned short int>::max());
+}
+
+inline bool isValidDepth(const int& depth)
+{
+    return (depth != std::numeric_limits<int>::min()) &&
+           (depth != std::numeric_limits<int>::max());
+}
+
+inline bool isValidDepth(const unsigned int& depth)
+{
+    return (depth != std::numeric_limits<unsigned int>::min()) &&
+           (depth != std::numeric_limits<unsigned int>::max());
+}
+
+
+// One place to turn intrinsics on and off
+#define USE_INTRINSICS CV_SIMD128
+
+typedef float depthType;
+
+const float qnan = std::numeric_limits<float>::quiet_NaN();
+const cv::Vec3f nan3(qnan, qnan, qnan);
+#if USE_INTRINSICS
+const cv::v_float32x4 nanv(qnan, qnan, qnan, qnan);
+#endif
+
+inline bool isNaN(cv::Point3f p)
+{
+    return (cvIsNaN(p.x) || cvIsNaN(p.y) || cvIsNaN(p.z));
+}
+
+#if USE_INTRINSICS
+static inline bool isNaN(const cv::v_float32x4& p)
+{
+    return cv::v_check_any(v_ne(p, p));
+}
+#endif
+
+inline size_t roundDownPow2(size_t x)
+{
+    size_t shift = 0;
+    while(x != 0)
+    {
+        shift++; x >>= 1;
+    }
+    return (size_t)(1ULL << (shift-1));
+}
+
+template<> class DataType<cv::Point3f>
+{
+public:
+    typedef float       value_type;
+    typedef value_type  work_type;
+    typedef value_type  channel_type;
+    typedef value_type  vec_type;
+    enum { generic_type = 0,
+           depth        = CV_32F,
+           channels     = 3,
+           fmt          = (int)'f',
+           type         = CV_MAKETYPE(depth, channels)
+         };
+};
+
+template<> class DataType<cv::Vec3f>
+{
+public:
+    typedef float       value_type;
+    typedef value_type  work_type;
+    typedef value_type  channel_type;
+    typedef value_type  vec_type;
+    enum { generic_type = 0,
+           depth        = CV_32F,
+           channels     = 3,
+           fmt          = (int)'f',
+           type         = CV_MAKETYPE(depth, channels)
+         };
+};
+
+template<> class DataType<cv::Vec4f>
+{
+public:
+    typedef float       value_type;
+    typedef value_type  work_type;
+    typedef value_type  channel_type;
+    typedef value_type  vec_type;
+    enum { generic_type = 0,
+           depth        = CV_32F,
+           channels     = 4,
+           fmt          = (int)'f',
+           type         = CV_MAKETYPE(depth, channels)
+         };
+};
+
+
+typedef cv::Vec4f ptype;
+inline cv::Vec3f fromPtype(const ptype& x)
+{
+    return cv::Vec3f(x[0], x[1], x[2]);
+}
+
+inline ptype toPtype(const cv::Vec3f& x)
+{
+    return ptype(x[0], x[1], x[2], 0);
+}
+
+enum
+{
+    DEPTH_TYPE = DataType<depthType>::type,
+    POINT_TYPE = DataType<ptype    >::type,
+    COLOR_TYPE = DataType<ptype    >::type
+};
+
+typedef cv::Mat_< ptype > Points;
+typedef Points Normals;
+typedef Points Colors;
+
+typedef cv::Point3f _ptype;
+typedef cv::Mat_< _ptype > _Points;
+typedef _Points _Normals;
+typedef _Points _Colors;
+
+enum
+{
+    _DEPTH_TYPE = DataType<depthType>::type,
+    _POINT_TYPE = DataType<_ptype   >::type,
+    _COLOR_TYPE = DataType<_ptype   >::type
+};
+
+typedef cv::Mat_< depthType > Depth;
+
+void makeFrameFromDepth(InputArray depth, OutputArray pyrPoints, OutputArray pyrNormals,
+                        const Matx33f intr, int levels, float depthFactor,
+                        float sigmaDepth, float sigmaSpatial, int kernelSize,
+                        float truncateThreshold);
+void buildPyramidPointsNormals(InputArray _points, InputArray _normals,
+                               OutputArrayOfArrays pyrPoints, OutputArrayOfArrays pyrNormals,
+                               int levels);
+
+struct Intr
+{
+    /** @brief Camera intrinsics */
+    /** Reprojects screen point to camera space given z coord. */
+    struct Reprojector
+    {
+        Reprojector() {}
+        inline Reprojector(Intr intr)
+        {
+            fxinv = 1.f/intr.fx, fyinv = 1.f/intr.fy;
+            cx = intr.cx, cy = intr.cy;
+        }
+        template<typename T>
+        inline cv::Point3_<T> operator()(cv::Point3_<T> p) const
+        {
+            T x = p.z * (p.x - cx) * fxinv;
+            T y = p.z * (p.y - cy) * fyinv;
+            return cv::Point3_<T>(x, y, p.z);
+        }
+
+        float fxinv, fyinv, cx, cy;
+    };
+
+    /** Projects camera space vector onto screen */
+    struct Projector
+    {
+        inline Projector(Intr intr) : fx(intr.fx), fy(intr.fy), cx(intr.cx), cy(intr.cy) { }
+        template<typename T>
+        inline cv::Point_<T> operator()(cv::Point3_<T> p) const
+        {
+            T invz = T(1)/p.z;
+            T x = fx*(p.x*invz) + cx;
+            T y = fy*(p.y*invz) + cy;
+            return cv::Point_<T>(x, y);
+        }
+        template<typename T>
+        inline cv::Point_<T> operator()(cv::Point3_<T> p, cv::Point3_<T>& pixVec) const
+        {
+            T invz = T(1)/p.z;
+            pixVec = cv::Point3_<T>(p.x*invz, p.y*invz, 1);
+            T x = fx*pixVec.x + cx;
+            T y = fy*pixVec.y + cy;
+            return cv::Point_<T>(x, y);
+        }
+        float fx, fy, cx, cy;
+    };
+    Intr() : fx(), fy(), cx(), cy() { }
+    Intr(float _fx, float _fy, float _cx, float _cy) : fx(_fx), fy(_fy), cx(_cx), cy(_cy) { }
+    Intr(cv::Matx33f m) : fx(m(0, 0)), fy(m(1, 1)), cx(m(0, 2)), cy(m(1, 2)) { }
+    // scale intrinsics to pyramid level
+    inline Intr scale(int pyr) const
+    {
+        float factor = (1.f /(1 << pyr));
+        return Intr(fx*factor, fy*factor, cx*factor, cy*factor);
+    }
+    inline Reprojector makeReprojector() const { return Reprojector(*this); }
+    inline Projector   makeProjector()   const { return Projector(*this);   }
+
+    inline cv::Matx33f getMat() const { return Matx33f(fx, 0, cx, 0, fy, cy, 0, 0, 1); }
+
+    float fx, fy, cx, cy;
+};
+
+class OdometryFrame::Impl
+{
+public:
+    Impl() : pyramids(OdometryFramePyramidType::N_PYRAMIDS) { }
+    virtual ~Impl() {}
+
+    virtual void getImage(OutputArray image) const ;
+    virtual void getGrayImage(OutputArray image) const ;
+    virtual void getDepth(OutputArray depth) const ;
+    virtual void getProcessedDepth(OutputArray depth) const ;
+    virtual void getMask(OutputArray mask) const ;
+    virtual void getNormals(OutputArray normals) const ;
+
+    virtual int getPyramidLevels() const ;
+
+    virtual void getPyramidAt(OutputArray img,
+                              OdometryFramePyramidType pyrType, size_t level) const ;
+
+    UMat imageGray;
+    UMat image;
+    UMat depth;
+    UMat scaledDepth;
+    UMat mask;
+    UMat normals;
+    std::vector< std::vector<UMat> > pyramids;
+};
+
+} /* namespace cv */
+
+#endif
diff --git a/upstream/opencv/modules/ptcloud/src/volume_impl.cpp b/upstream/opencv/modules/ptcloud/src/volume_impl.cpp
new file mode 100644
index 0000000..0df8def
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/volume_impl.cpp
@@ -0,0 +1,596 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+
+#include <iostream>
+#include "volume_impl.hpp"
+#include "tsdf_functions.hpp"
+#include "hash_tsdf_functions.hpp"
+#include "color_tsdf_functions.hpp"
+#include "opencv2/imgproc.hpp"
+
+namespace cv
+{
+
+Volume::Impl::Impl(const VolumeSettings& _settings) :
+    settings(_settings)
+#ifdef HAVE_OPENCL
+    , useGPU(ocl::useOpenCL())
+#endif
+{}
+
+// TSDF
+
+TsdfVolume::TsdfVolume(const VolumeSettings& _settings) :
+    Volume::Impl(_settings)
+{
+    Vec3i volResolution;
+    settings.getVolumeResolution(volResolution);
+#ifndef HAVE_OPENCL
+    volume = Mat(1, volResolution[0] * volResolution[1] * volResolution[2], rawType<TsdfVoxel>());
+#else
+    if (useGPU)
+        gpu_volume = UMat(1, volResolution[0] * volResolution[1] * volResolution[2], rawType<TsdfVoxel>());
+    else
+        cpu_volume = Mat(1, volResolution[0] * volResolution[1] * volResolution[2], rawType<TsdfVoxel>());
+#endif
+
+    reset();
+}
+TsdfVolume::~TsdfVolume() {}
+
+void TsdfVolume::integrate(const OdometryFrame& frame, InputArray _cameraPose)
+{
+    CV_TRACE_FUNCTION();
+#ifndef HAVE_OPENCL
+    Mat depth;
+#else
+    UMat depth;
+#endif
+    frame.getDepth(depth);
+    integrate(depth, _cameraPose);
+}
+
+void TsdfVolume::integrate(InputArray _depth, InputArray _cameraPose)
+{
+    CV_TRACE_FUNCTION();
+#ifndef HAVE_OPENCL
+    Mat depth = _depth.getMat();
+#else
+    UMat depth = _depth.getUMat();
+#endif
+    CV_Assert(!depth.empty());
+
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    Intr intrinsics(intr);
+    Vec6f newParams((float)depth.rows, (float)depth.cols,
+                    intrinsics.fx, intrinsics.fy,
+                    intrinsics.cx, intrinsics.cy);
+    if (!(frameParams == newParams))
+    {
+        frameParams = newParams;
+#ifndef HAVE_OPENCL
+        preCalculationPixNorm(depth.size(), intrinsics, pixNorms);
+#else
+        if (useGPU)
+            ocl_preCalculationPixNorm(depth.size(), intrinsics, gpu_pixNorms);
+        else
+            preCalculationPixNorm(depth.size(), intrinsics, cpu_pixNorms);
+#endif
+    }
+    const Matx44f cameraPose = _cameraPose.getMat();
+
+#ifndef HAVE_OPENCL
+    integrateTsdfVolumeUnit(settings, cameraPose, depth, pixNorms, volume);
+#else
+    if (useGPU)
+        ocl_integrateTsdfVolumeUnit(settings, cameraPose, depth, gpu_pixNorms, gpu_volume);
+    else
+        integrateTsdfVolumeUnit(settings, cameraPose, depth, cpu_pixNorms, cpu_volume);
+#endif
+}
+void TsdfVolume::integrate(InputArray, InputArray, InputArray)
+{
+    CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+}
+
+
+void TsdfVolume::raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors)  const
+{
+    Matx33f intr;
+    settings.getCameraRaycastIntrinsics(intr);
+    raycast(cameraPose, settings.getRaycastHeight(), settings.getRaycastWidth(), intr, points, normals, colors);
+}
+
+
+void TsdfVolume::raycast(InputArray _cameraPose, int height, int width, InputArray intr, OutputArray _points, OutputArray _normals, OutputArray _colors) const
+{
+    if (_colors.needed())
+        CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+
+    CV_Assert(height > 0);
+    CV_Assert(width > 0);
+
+    const Matx44f cameraPose = _cameraPose.getMat();
+#ifndef HAVE_OPENCL
+    raycastTsdfVolumeUnit(settings, cameraPose, height, width, intr, volume, _points, _normals);
+#else
+    if (useGPU)
+        ocl_raycastTsdfVolumeUnit(settings, cameraPose, height, width, intr, gpu_volume, _points, _normals);
+    else
+        raycastTsdfVolumeUnit(settings, cameraPose, height, width, intr, cpu_volume, _points, _normals);
+#endif
+}
+
+void TsdfVolume::fetchNormals(InputArray points, OutputArray normals) const
+{
+#ifndef HAVE_OPENCL
+    fetchNormalsFromTsdfVolumeUnit(settings, volume, points, normals);
+#else
+    if (useGPU)
+        ocl_fetchNormalsFromTsdfVolumeUnit(settings, gpu_volume, points, normals);
+    else
+        fetchNormalsFromTsdfVolumeUnit(settings, cpu_volume, points, normals);
+#endif
+}
+
+void TsdfVolume::fetchPointsNormals(OutputArray points, OutputArray normals) const
+{
+#ifndef HAVE_OPENCL
+    fetchPointsNormalsFromTsdfVolumeUnit(settings, volume, points, normals);
+#else
+    if (useGPU)
+        ocl_fetchPointsNormalsFromTsdfVolumeUnit(settings, gpu_volume, points, normals);
+    else
+        fetchPointsNormalsFromTsdfVolumeUnit(settings, cpu_volume, points, normals);
+#endif
+}
+
+void TsdfVolume::fetchPointsNormalsColors(OutputArray, OutputArray, OutputArray) const
+{
+    CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+}
+
+void TsdfVolume::reset()
+{
+    CV_TRACE_FUNCTION();
+#ifndef HAVE_OPENCL
+    //TODO: use setTo(Scalar(0, 0))
+    volume.forEach<VecTsdfVoxel>([](VecTsdfVoxel& vv, const int* /* position */)
+        {
+            TsdfVoxel& v = reinterpret_cast<TsdfVoxel&>(vv);
+            v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+        });
+#else
+    if (useGPU)
+        gpu_volume.setTo(Scalar(floatToTsdf(0.0f), 0));
+    else
+        //TODO: use setTo(Scalar(0, 0))
+        cpu_volume.forEach<VecTsdfVoxel>([](VecTsdfVoxel& vv, const int* /* position */)
+            {
+                TsdfVoxel& v = reinterpret_cast<TsdfVoxel&>(vv);
+                v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+            });
+#endif
+}
+int TsdfVolume::getVisibleBlocks() const { return 1; }
+size_t TsdfVolume::getTotalVolumeUnits() const { return 1; }
+
+
+void TsdfVolume::getBoundingBox(OutputArray bb, int precision) const
+{
+    if (precision == Volume::BoundingBoxPrecision::VOXEL)
+    {
+        CV_Error(Error::StsNotImplemented, "Voxel mode is not implemented yet");
+    }
+    else
+    {
+        float sz = this->settings.getVoxelSize();
+        Vec3f res;
+        this->settings.getVolumeResolution(res);
+        Vec3f volSize = res * sz;
+        Vec6f(0, 0, 0, volSize[0], volSize[1], volSize[2]).copyTo(bb);
+    }
+}
+
+void TsdfVolume::setEnableGrowth(bool /*v*/) { }
+
+bool TsdfVolume::getEnableGrowth() const
+{
+    return false;
+}
+
+
+// HASH_TSDF
+
+HashTsdfVolume::HashTsdfVolume(const VolumeSettings& _settings) :
+    Volume::Impl(_settings)
+{
+    Vec3i resolution;
+    settings.getVolumeResolution(resolution);
+    const Point3i volResolution = Point3i(resolution);
+    volumeUnitDegree = calcVolumeUnitDegree(volResolution);
+
+#ifndef HAVE_OPENCL
+    volUnitsData = cv::Mat(VOLUMES_SIZE, resolution[0] * resolution[1] * resolution[2], rawType<TsdfVoxel>());
+    reset();
+#else
+    if (useGPU)
+    {
+        reset();
+    }
+    else
+    {
+        cpu_volUnitsData = cv::Mat(VOLUMES_SIZE, resolution[0] * resolution[1] * resolution[2], rawType<TsdfVoxel>());
+        reset();
+    }
+#endif
+}
+
+HashTsdfVolume::~HashTsdfVolume() {}
+
+void HashTsdfVolume::integrate(const OdometryFrame& frame, InputArray _cameraPose)
+{
+    CV_TRACE_FUNCTION();
+#ifndef HAVE_OPENCL
+    Mat depth;
+#else
+    UMat depth;
+#endif
+    frame.getDepth(depth);
+    integrate(depth, _cameraPose);
+}
+
+void HashTsdfVolume::integrate(InputArray _depth, InputArray _cameraPose)
+{
+#ifndef HAVE_OPENCL
+    Mat depth = _depth.getMat();
+#else
+    UMat depth = _depth.getUMat();
+#endif
+    const Matx44f cameraPose = _cameraPose.getMat();
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    Intr intrinsics(intr);
+    Vec6f newParams((float)depth.rows, (float)depth.cols,
+        intrinsics.fx, intrinsics.fy,
+        intrinsics.cx, intrinsics.cy);
+    if (!(frameParams == newParams))
+    {
+        frameParams = newParams;
+#ifndef HAVE_OPENCL
+        preCalculationPixNorm(depth.size(), intrinsics, pixNorms);
+#else
+        if (useGPU)
+            ocl_preCalculationPixNorm(depth.size(), intrinsics, gpu_pixNorms);
+        else
+            preCalculationPixNorm(depth.size(), intrinsics, cpu_pixNorms);
+#endif
+    }
+#ifndef HAVE_OPENCL
+    integrateHashTsdfVolumeUnit(settings, cameraPose, lastVolIndex, lastFrameId, volumeUnitDegree, enableGrowth, depth, pixNorms, volUnitsData, volumeUnits);
+    lastFrameId++;
+#else
+    if (useGPU)
+    {
+        ocl_integrateHashTsdfVolumeUnit(settings, cameraPose, lastVolIndex, lastFrameId, bufferSizeDegree, volumeUnitDegree, enableGrowth, depth, gpu_pixNorms,
+                                        lastVisibleIndices, volUnitsDataCopy, gpu_volUnitsData, hashTable, isActiveFlags);
+    }
+    else
+    {
+        integrateHashTsdfVolumeUnit(settings, cameraPose, lastVolIndex, lastFrameId, volumeUnitDegree, enableGrowth, depth,
+                                    cpu_pixNorms, cpu_volUnitsData, cpu_volumeUnits);
+        lastFrameId++;
+    }
+#endif
+}
+
+void HashTsdfVolume::integrate(InputArray, InputArray, InputArray)
+{
+    CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+}
+
+
+void HashTsdfVolume::raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors)  const
+{
+    Matx33f intr;
+    settings.getCameraRaycastIntrinsics(intr);
+    raycast(cameraPose, settings.getRaycastHeight(), settings.getRaycastWidth(), intr, points, normals, colors);
+}
+
+
+void HashTsdfVolume::raycast(InputArray _cameraPose, int height, int width, InputArray intr, OutputArray _points, OutputArray _normals, OutputArray _colors) const
+{
+    if (_colors.needed())
+        CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+
+    const Matx44f cameraPose = _cameraPose.getMat();
+
+#ifndef HAVE_OPENCL
+    raycastHashTsdfVolumeUnit(settings, cameraPose, height, width, intr, volumeUnitDegree, volUnitsData, volumeUnits, _points, _normals);
+#else
+    if (useGPU)
+        ocl_raycastHashTsdfVolumeUnit(settings, cameraPose, height, width, intr, volumeUnitDegree, hashTable, gpu_volUnitsData, _points, _normals);
+    else
+        raycastHashTsdfVolumeUnit(settings, cameraPose, height, width, intr, volumeUnitDegree, cpu_volUnitsData, cpu_volumeUnits, _points, _normals);
+#endif
+}
+
+void HashTsdfVolume::fetchNormals(InputArray points, OutputArray normals) const
+{
+#ifndef HAVE_OPENCL
+    fetchNormalsFromHashTsdfVolumeUnit(settings, volUnitsData, volumeUnits, volumeUnitDegree, points, normals);
+#else
+    if (useGPU)
+        ocl_fetchNormalsFromHashTsdfVolumeUnit(settings, volumeUnitDegree, gpu_volUnitsData, volUnitsDataCopy, hashTable, points, normals);
+    else
+        fetchNormalsFromHashTsdfVolumeUnit(settings, cpu_volUnitsData, cpu_volumeUnits, volumeUnitDegree, points, normals);
+
+#endif
+}
+void HashTsdfVolume::fetchPointsNormals(OutputArray points, OutputArray normals) const
+{
+#ifndef HAVE_OPENCL
+    fetchPointsNormalsFromHashTsdfVolumeUnit(settings, volUnitsData, volumeUnits, volumeUnitDegree, points, normals);
+#else
+    if (useGPU)
+        ocl_fetchPointsNormalsFromHashTsdfVolumeUnit(settings, volumeUnitDegree, gpu_volUnitsData, volUnitsDataCopy, hashTable, points, normals);
+    else
+        fetchPointsNormalsFromHashTsdfVolumeUnit(settings, cpu_volUnitsData, cpu_volumeUnits, volumeUnitDegree, points, normals);
+#endif
+}
+
+void HashTsdfVolume::fetchPointsNormalsColors(OutputArray, OutputArray, OutputArray) const
+{
+    CV_Error(cv::Error::StsBadFunc, "This volume doesn't support vertex colors");
+};
+
+void HashTsdfVolume::reset()
+{
+    CV_TRACE_FUNCTION();
+    lastVolIndex = 0;
+    lastFrameId = 0;
+    enableGrowth = true;
+#ifndef HAVE_OPENCL
+    volUnitsData.forEach<VecTsdfVoxel>([](VecTsdfVoxel& vv, const int* /* position */)
+        {
+            TsdfVoxel& v = reinterpret_cast<TsdfVoxel&>(vv);
+            v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+        });
+    volumeUnits = VolumeUnitIndexes();
+#else
+    if (useGPU)
+    {
+        Vec3i resolution;
+        settings.getVolumeResolution(resolution);
+
+        bufferSizeDegree = 15;
+        int buff_lvl = (int)(1 << bufferSizeDegree);
+        int volCubed = resolution[0] * resolution[1] * resolution[2];
+
+        volUnitsDataCopy = cv::Mat(buff_lvl, volCubed, rawType<TsdfVoxel>());
+        gpu_volUnitsData = cv::UMat(buff_lvl, volCubed, CV_8UC2);
+        lastVisibleIndices = cv::UMat(buff_lvl, 1, CV_32S);
+        isActiveFlags = cv::UMat(buff_lvl, 1, CV_8U);
+        hashTable = CustomHashSet();
+        frameParams = Vec6f();
+        gpu_pixNorms = UMat();
+    }
+    else
+    {
+        cpu_volUnitsData.forEach<VecTsdfVoxel>([](VecTsdfVoxel& vv, const int* /* position */)
+            {
+                TsdfVoxel& v = reinterpret_cast<TsdfVoxel&>(vv);
+                v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+            });
+        cpu_volumeUnits = VolumeUnitIndexes();
+    }
+#endif
+}
+
+int HashTsdfVolume::getVisibleBlocks() const { return 1; }
+size_t HashTsdfVolume::getTotalVolumeUnits() const { return 1; }
+
+void HashTsdfVolume::setEnableGrowth(bool v)
+{
+    enableGrowth = v;
+}
+
+bool HashTsdfVolume::getEnableGrowth() const
+{
+    return enableGrowth;
+}
+
+void HashTsdfVolume::getBoundingBox(OutputArray boundingBox, int precision) const
+{
+    if (precision == Volume::BoundingBoxPrecision::VOXEL)
+    {
+        CV_Error(Error::StsNotImplemented, "Voxel mode is not implemented yet");
+    }
+    else
+    {
+        Vec3i res;
+        this->settings.getVolumeResolution(res);
+        float voxelSize = this->settings.getVoxelSize();
+        float side = res[0] * voxelSize;
+
+        std::vector<Vec3i> vi;
+#ifndef HAVE_OPENCL
+        for (const auto& keyvalue : volumeUnits)
+        {
+            vi.push_back(keyvalue.first);
+        }
+#else
+        if (useGPU)
+        {
+            for (int row = 0; row < hashTable.last; row++)
+            {
+                Vec4i idx4 = hashTable.data[row];
+                vi.push_back(Vec3i(idx4[0], idx4[1], idx4[2]));
+            }
+        }
+        else
+        {
+            for (const auto& keyvalue : cpu_volumeUnits)
+            {
+                vi.push_back(keyvalue.first);
+            }
+        }
+#endif
+
+        if (vi.empty())
+        {
+            boundingBox.setZero();
+        }
+        else
+        {
+            std::vector<Point3f> pts;
+            for (Vec3i idx : vi)
+            {
+                Point3f base = Point3f((float)idx[0], (float)idx[1], (float)idx[2]) * side;
+                pts.push_back(base);
+                pts.push_back(base + Point3f(side, 0, 0));
+                pts.push_back(base + Point3f(0, side, 0));
+                pts.push_back(base + Point3f(0, 0, side));
+                pts.push_back(base + Point3f(side, side, 0));
+                pts.push_back(base + Point3f(side, 0, side));
+                pts.push_back(base + Point3f(0, side, side));
+                pts.push_back(base + Point3f(side, side, side));
+            }
+
+            const float mval = std::numeric_limits<float>::max();
+            Vec6f bb(mval, mval, mval, -mval, -mval, -mval);
+            for (auto p : pts)
+            {
+                // pt in local coords
+                Point3f pg = p;
+                bb[0] = min(bb[0], pg.x);
+                bb[1] = min(bb[1], pg.y);
+                bb[2] = min(bb[2], pg.z);
+                bb[3] = max(bb[3], pg.x);
+                bb[4] = max(bb[4], pg.y);
+                bb[5] = max(bb[5], pg.z);
+            }
+
+            bb.copyTo(boundingBox);
+        }
+    }
+}
+
+// COLOR_TSDF
+
+ColorTsdfVolume::ColorTsdfVolume(const VolumeSettings& _settings) :
+    Volume::Impl(_settings)
+{
+    Vec3i volResolution;
+    settings.getVolumeResolution(volResolution);
+    volume = Mat(1, volResolution[0] * volResolution[1] * volResolution[2], rawType<RGBTsdfVoxel>());
+    reset();
+}
+
+ColorTsdfVolume::~ColorTsdfVolume() {}
+
+void ColorTsdfVolume::integrate(const OdometryFrame& frame, InputArray cameraPose)
+{
+    CV_TRACE_FUNCTION();
+    Mat depth;
+    frame.getDepth(depth);
+    Mat rgb;
+    frame.getImage(rgb);
+
+    integrate(depth, rgb, cameraPose);
+}
+
+void ColorTsdfVolume::integrate(InputArray, InputArray)
+{
+    CV_Error(cv::Error::StsBadFunc, "Color data should be passed for this volume type");
+}
+
+void ColorTsdfVolume::integrate(InputArray _depth, InputArray _image, InputArray _cameraPose)
+{
+    Mat depth = _depth.getMat();
+    Colors image = _image.getMat();
+    const Matx44f cameraPose = _cameraPose.getMat();
+    Matx33f intr;
+    settings.getCameraIntegrateIntrinsics(intr);
+    Intr intrinsics(intr);
+    Vec6f newParams((float)depth.rows, (float)depth.cols,
+        intrinsics.fx, intrinsics.fy,
+        intrinsics.cx, intrinsics.cy);
+    if (!(frameParams == newParams))
+    {
+        frameParams = newParams;
+        preCalculationPixNorm(depth.size(), intrinsics, pixNorms);
+    }
+    integrateColorTsdfVolumeUnit(settings, cameraPose, depth, image, pixNorms, volume);
+}
+
+void ColorTsdfVolume::raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors)  const
+{
+    Matx33f intr;
+    settings.getCameraRaycastIntrinsics(intr);
+    raycast(cameraPose, settings.getRaycastHeight(), settings.getRaycastWidth(), intr, points, normals, colors);
+}
+
+void ColorTsdfVolume::raycast(InputArray _cameraPose, int height, int width, InputArray intr, OutputArray _points, OutputArray _normals, OutputArray _colors) const
+{
+    const Matx44f cameraPose = _cameraPose.getMat();
+    raycastColorTsdfVolumeUnit(settings, cameraPose, height, width, intr, volume, _points, _normals, _colors);
+}
+
+void ColorTsdfVolume::fetchNormals(InputArray points, OutputArray normals) const
+{
+    fetchNormalsFromColorTsdfVolumeUnit(settings, volume, points, normals);
+}
+
+void ColorTsdfVolume::fetchPointsNormals(OutputArray points, OutputArray normals) const
+{
+    fetchPointsNormalsFromColorTsdfVolumeUnit(settings, volume, points, normals);
+}
+
+void ColorTsdfVolume::fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const
+{
+    fetchPointsNormalsColorsFromColorTsdfVolumeUnit(settings, volume, points, normals, colors);
+}
+
+void ColorTsdfVolume::reset()
+{
+    CV_TRACE_FUNCTION();
+
+    volume.forEach<VecRGBTsdfVoxel>([](VecRGBTsdfVoxel& vv, const int* /* position */)
+        {
+            RGBTsdfVoxel& v = reinterpret_cast<RGBTsdfVoxel&>(vv);
+            v.tsdf = floatToTsdf(0.0f); v.weight = 0;
+            v.r = v.g = v.b = 0;
+        });
+}
+
+int ColorTsdfVolume::getVisibleBlocks() const { return 1; }
+size_t ColorTsdfVolume::getTotalVolumeUnits() const { return 1; }
+
+void ColorTsdfVolume::getBoundingBox(OutputArray bb, int precision) const
+{
+    if (precision == Volume::BoundingBoxPrecision::VOXEL)
+    {
+        CV_Error(Error::StsNotImplemented, "Voxel mode is not implemented yet");
+    }
+    else
+    {
+        float sz = this->settings.getVoxelSize();
+        Vec3f res;
+        this->settings.getVolumeResolution(res);
+        Vec3f volSize = res * sz;
+        Vec6f(0, 0, 0, volSize[0], volSize[1], volSize[2]).copyTo(bb);
+    }
+}
+
+void ColorTsdfVolume::setEnableGrowth(bool /*v*/) { }
+
+bool ColorTsdfVolume::getEnableGrowth() const
+{
+    return false;
+}
+
+}
diff --git a/upstream/opencv/modules/ptcloud/src/volume_impl.hpp b/upstream/opencv/modules/ptcloud/src/volume_impl.hpp
new file mode 100644
index 0000000..98941b3
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/volume_impl.hpp
@@ -0,0 +1,257 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_3D_VOLUME_IMPL_HPP
+#define OPENCV_3D_VOLUME_IMPL_HPP
+
+#include <iostream>
+
+#include "precomp.hpp"
+#include "hash_tsdf_functions.hpp"
+
+namespace cv
+{
+
+class Volume::Impl
+{
+private:
+    // TODO: make debug function, which show histogram of volume points values
+    // make this function run with debug lvl == 10
+public:
+    Impl(const VolumeSettings& settings);
+    virtual ~Impl() {};
+
+    virtual void integrate(const OdometryFrame& frame, InputArray pose) = 0;
+    virtual void integrate(InputArray depth, InputArray pose) = 0;
+    virtual void integrate(InputArray depth, InputArray image, InputArray pose) = 0;
+
+    virtual void raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors) const = 0;
+    virtual void raycast(InputArray cameraPose, int height, int width, InputArray intr, OutputArray points, OutputArray normals, OutputArray colors) const = 0;
+
+    virtual void fetchNormals(InputArray points, OutputArray normals) const = 0;
+    virtual void fetchPointsNormals(OutputArray points, OutputArray normals) const = 0;
+    virtual void fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const = 0;
+
+    virtual void reset() = 0;
+    virtual int getVisibleBlocks() const = 0;
+    virtual size_t getTotalVolumeUnits() const = 0;
+
+    virtual void getBoundingBox(OutputArray bb, int precision) const = 0;
+    virtual void setEnableGrowth(bool v) = 0;
+    virtual bool getEnableGrowth() const = 0;
+
+public:
+    VolumeSettings settings;
+#ifdef HAVE_OPENCL
+    const bool useGPU;
+#endif
+};
+
+
+class TsdfVolume : public Volume::Impl
+{
+public:
+    TsdfVolume(const VolumeSettings& settings);
+    ~TsdfVolume();
+
+    virtual void integrate(const OdometryFrame& frame, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray image, InputArray pose) override;
+    virtual void raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors) const override;
+    virtual void raycast(InputArray cameraPose, int height, int width, InputArray intr, OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void fetchNormals(InputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormals(OutputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void reset() override;
+    virtual int getVisibleBlocks() const override;
+    virtual size_t getTotalVolumeUnits() const override;
+
+    // Gets bounding box in volume coordinates with given precision:
+    // VOLUME_UNIT - up to volume unit
+    // VOXEL - up to voxel
+    // returns (min_x, min_y, min_z, max_x, max_y, max_z) in volume coordinates
+    virtual void getBoundingBox(OutputArray bb, int precision) const override;
+
+    // Enabels or disables new volume unit allocation during integration
+    // Applicable for HashTSDF only
+    virtual void setEnableGrowth(bool v) override;
+    // Returns if new volume units are allocated during integration or not
+    // Applicable for HashTSDF only
+    virtual bool getEnableGrowth() const override;
+
+public:
+    Vec6f frameParams;
+#ifndef HAVE_OPENCL
+    Mat pixNorms;
+    // See zFirstMemOrder arg of parent class constructor
+    // for the array layout info
+    // Consist of Voxel elements
+    Mat volume;
+#else
+    //temporary solution
+    Mat cpu_pixNorms;
+    Mat cpu_volume;
+    UMat gpu_pixNorms;
+    UMat gpu_volume;
+#endif
+};
+
+
+typedef std::unordered_set<cv::Vec3i, tsdf_hash> VolumeUnitIndexSet;
+typedef std::unordered_map<cv::Vec3i, VolumeUnit, tsdf_hash> VolumeUnitIndexes;
+
+class HashTsdfVolume : public Volume::Impl
+{
+public:
+    HashTsdfVolume(const VolumeSettings& settings);
+    ~HashTsdfVolume();
+
+    virtual void integrate(const OdometryFrame& frame, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray image, InputArray pose) override;
+    virtual void raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors) const override;
+    virtual void raycast(InputArray cameraPose, int height, int width, InputArray intr, OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void fetchNormals(InputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormals(OutputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void reset() override;
+    virtual int getVisibleBlocks() const override;
+    virtual size_t getTotalVolumeUnits() const override;
+
+    // Enabels or disables new volume unit allocation during integration
+    // Applicable for HashTSDF only
+    virtual void setEnableGrowth(bool v) override;
+    // Returns if new volume units are allocated during integration or not
+    // Applicable for HashTSDF only
+    virtual bool getEnableGrowth() const override;
+
+    // Gets bounding box in volume coordinates with given precision:
+    // VOLUME_UNIT - up to volume unit
+    // VOXEL - up to voxel
+    // returns (min_x, min_y, min_z, max_x, max_y, max_z) in volume coordinates
+    virtual void getBoundingBox(OutputArray bb, int precision) const override;
+
+public:
+    int lastVolIndex;
+    int lastFrameId;
+    Vec6f frameParams;
+    int volumeUnitDegree;
+    bool enableGrowth;
+
+#ifndef HAVE_OPENCL
+    Mat volUnitsData;
+    Mat pixNorms;
+    VolumeUnitIndexes volumeUnits;
+#else
+    VolumeUnitIndexes cpu_volumeUnits;
+
+    Mat cpu_volUnitsData;
+    Mat cpu_pixNorms;
+    UMat gpu_volUnitsData;
+    UMat gpu_pixNorms;
+
+    int bufferSizeDegree;
+    // per-volume-unit data
+    UMat lastVisibleIndices;
+    UMat isActiveFlags;
+    //TODO: remove it when there's no CPU parts
+    Mat volUnitsDataCopy;
+    //TODO: move indexes.volumes to GPU
+    CustomHashSet hashTable;
+#endif
+};
+
+
+class ColorTsdfVolume : public Volume::Impl
+{
+public:
+    ColorTsdfVolume(const VolumeSettings& settings);
+    ~ColorTsdfVolume();
+
+    virtual void integrate(const OdometryFrame& frame, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray pose) override;
+    virtual void integrate(InputArray depth, InputArray image, InputArray pose) override;
+    virtual void raycast(InputArray cameraPose, OutputArray points, OutputArray normals, OutputArray colors) const override;
+    virtual void raycast(InputArray cameraPose, int height, int width, InputArray intr, OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void fetchNormals(InputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormals(OutputArray points, OutputArray normals) const override;
+    virtual void fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const override;
+
+    virtual void reset() override;
+    virtual int getVisibleBlocks() const override;
+    virtual size_t getTotalVolumeUnits() const override;
+
+    // Gets bounding box in volume coordinates with given precision:
+    // VOLUME_UNIT - up to volume unit
+    // VOXEL - up to voxel
+    // returns (min_x, min_y, min_z, max_x, max_y, max_z) in volume coordinates
+    virtual void getBoundingBox(OutputArray bb, int precision) const override;
+
+    // Enabels or disables new volume unit allocation during integration
+    // Applicable for HashTSDF only
+    virtual void setEnableGrowth(bool v) override;
+    // Returns if new volume units are allocated during integration or not
+    // Applicable for HashTSDF only
+    virtual bool getEnableGrowth() const override;
+
+private:
+    Vec4i volStrides;
+    Vec6f frameParams;
+    Mat pixNorms;
+    // See zFirstMemOrder arg of parent class constructor
+    // for the array layout info
+    // Consist of Voxel elements
+    Mat volume;
+};
+
+
+Volume::Volume(VolumeType vtype, const VolumeSettings& settings)
+{
+    switch (vtype)
+    {
+    case VolumeType::TSDF:
+        this->impl = makePtr<TsdfVolume>(settings);
+        break;
+    case VolumeType::HashTSDF:
+        this->impl = makePtr<HashTsdfVolume>(settings);
+        break;
+    case VolumeType::ColorTSDF:
+        this->impl = makePtr<ColorTsdfVolume>(settings);
+        break;
+    default:
+        CV_Error(Error::StsInternal, "Incorrect OdometryType, you are able to use only { ICP, RGB, RGBD }");
+        break;
+    }
+}
+Volume::~Volume() {}
+
+void Volume::integrate(const OdometryFrame& frame, InputArray pose) { this->impl->integrate(frame, pose); }
+void Volume::integrate(InputArray depth, InputArray pose) { this->impl->integrate(depth, pose); }
+void Volume::integrate(InputArray depth, InputArray image, InputArray pose) { this->impl->integrate(depth, image, pose); }
+void Volume::raycast(InputArray cameraPose, OutputArray _points, OutputArray _normals) const { this->impl->raycast(cameraPose, _points, _normals, noArray()); }
+void Volume::raycast(InputArray cameraPose, OutputArray _points, OutputArray _normals, OutputArray _colors) const { this->impl->raycast(cameraPose, _points, _normals, _colors); }
+void Volume::raycast(InputArray cameraPose, int height, int width, InputArray _intr, OutputArray _points, OutputArray _normals) const { this->impl->raycast(cameraPose, height, width, _intr, _points, _normals, noArray()); }
+void Volume::raycast(InputArray cameraPose, int height, int width, InputArray _intr, OutputArray _points, OutputArray _normals, OutputArray _colors) const { this->impl->raycast(cameraPose, height, width, _intr, _points, _normals, _colors); }
+
+void Volume::fetchNormals(InputArray points, OutputArray normals) const { this->impl->fetchNormals(points, normals); }
+void Volume::fetchPointsNormals(OutputArray points, OutputArray normals) const { this->impl->fetchPointsNormals(points, normals); }
+void Volume::fetchPointsNormalsColors(OutputArray points, OutputArray normals, OutputArray colors) const { this->impl->fetchPointsNormalsColors(points, normals, colors); };
+
+void Volume::reset() { this->impl->reset(); }
+int Volume::getVisibleBlocks() const { return this->impl->getVisibleBlocks(); }
+size_t Volume::getTotalVolumeUnits() const { return this->impl->getTotalVolumeUnits(); }
+
+void Volume::getBoundingBox(OutputArray bb, int precision) const { this->impl->getBoundingBox(bb, precision); }
+void Volume::setEnableGrowth(bool v) { this->impl->setEnableGrowth(v); }
+bool Volume::getEnableGrowth() const { return this->impl->getEnableGrowth(); }
+
+
+}
+
+#endif // !OPENCV_3D_VOLUME_IMPL_HPP
diff --git a/upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp b/upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp
new file mode 100644
index 0000000..a7783ae
--- /dev/null
+++ b/upstream/opencv/modules/ptcloud/src/volume_settings_impl.cpp
@@ -0,0 +1,535 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+static Vec4i calcVolumeStrides(Point3i volumeResolution, bool ZFirstMemOrder)
+{
+    // (xRes*yRes*zRes) array
+    // Depending on zFirstMemOrder arg:
+    // &elem(x, y, z) = data + x*zRes*yRes + y*zRes + z;
+    // &elem(x, y, z) = data + x + y*xRes + z*xRes*yRes;
+    int xdim, ydim, zdim;
+    if (ZFirstMemOrder)
+    {
+        xdim = volumeResolution.z * volumeResolution.y;
+        ydim = volumeResolution.z;
+        zdim = 1;
+    }
+    else
+    {
+        xdim = 1;
+        ydim = volumeResolution.x;
+        zdim = volumeResolution.x * volumeResolution.y;
+    }
+    return Vec4i(xdim, ydim, zdim);
+}
+
+class VolumeSettings::Impl
+{
+public:
+    Impl() {};
+    virtual ~Impl() {};
+
+    virtual void  setIntegrateWidth(int  val) = 0;
+    virtual int   getIntegrateWidth() const = 0;
+    virtual void  setIntegrateHeight(int  val) = 0;
+    virtual int   getIntegrateHeight() const = 0;
+    virtual void  setRaycastWidth(int  val) = 0;
+    virtual int   getRaycastWidth() const = 0;
+    virtual void  setRaycastHeight(int  val) = 0;
+    virtual int   getRaycastHeight() const = 0;
+    virtual void  setDepthFactor(float val) = 0;
+    virtual float getDepthFactor() const = 0;
+    virtual void  setVoxelSize(float  val) = 0;
+    virtual float getVoxelSize() const = 0;
+    virtual void  setTsdfTruncateDistance(float val) = 0;
+    virtual float getTsdfTruncateDistance() const = 0;
+    virtual void  setMaxDepth(float val) = 0;
+    virtual float getMaxDepth() const = 0;
+    virtual void  setMaxWeight(int val) = 0;
+    virtual int   getMaxWeight() const = 0;
+    virtual void  setRaycastStepFactor(float val) = 0;
+    virtual float getRaycastStepFactor() const = 0;
+
+    virtual void setVolumePose(InputArray val) = 0;
+    virtual void getVolumePose(OutputArray val) const = 0;
+    virtual void setVolumeResolution(InputArray val) = 0;
+    virtual void getVolumeResolution(OutputArray val) const = 0;
+    virtual void getVolumeStrides(OutputArray val) const = 0;
+    virtual void setCameraIntegrateIntrinsics(InputArray val) = 0;
+    virtual void getCameraIntegrateIntrinsics(OutputArray val) const = 0;
+    virtual void setCameraRaycastIntrinsics(InputArray val) = 0;
+    virtual void getCameraRaycastIntrinsics(OutputArray val) const = 0;
+};
+
+class VolumeSettingsImpl : public VolumeSettings::Impl
+{
+public:
+    VolumeSettingsImpl();
+    VolumeSettingsImpl(VolumeType volumeType);
+    ~VolumeSettingsImpl();
+
+    virtual void  setIntegrateWidth(int  val) override;
+    virtual int   getIntegrateWidth() const override;
+    virtual void  setIntegrateHeight(int  val) override;
+    virtual int   getIntegrateHeight() const override;
+    virtual void  setRaycastWidth(int  val) override;
+    virtual int   getRaycastWidth() const override;
+    virtual void  setRaycastHeight(int  val) override;
+    virtual int   getRaycastHeight() const override;
+    virtual void  setDepthFactor(float val) override;
+    virtual float getDepthFactor() const override;
+    virtual void  setVoxelSize(float  val) override;
+    virtual float getVoxelSize() const override;
+    virtual void  setTsdfTruncateDistance(float val) override;
+    virtual float getTsdfTruncateDistance() const override;
+    virtual void  setMaxDepth(float val) override;
+    virtual float getMaxDepth() const override;
+    virtual void  setMaxWeight(int val) override;
+    virtual int   getMaxWeight() const override;
+    virtual void  setRaycastStepFactor(float val) override;
+    virtual float getRaycastStepFactor() const override;
+
+    virtual void setVolumePose(InputArray val) override;
+    virtual void getVolumePose(OutputArray val) const override;
+    virtual void setVolumeResolution(InputArray val) override;
+    virtual void getVolumeResolution(OutputArray val) const override;
+    virtual void getVolumeStrides(OutputArray val) const override;
+    virtual void setCameraIntegrateIntrinsics(InputArray val) override;
+    virtual void getCameraIntegrateIntrinsics(OutputArray val) const override;
+    virtual void setCameraRaycastIntrinsics(InputArray val) override;
+    virtual void getCameraRaycastIntrinsics(OutputArray val) const override;
+
+private:
+    VolumeType volumeType;
+
+    int   integrateWidth;
+    int   integrateHeight;
+    int   raycastWidth;
+    int   raycastHeight;
+    float depthFactor;
+    float voxelSize;
+    float tsdfTruncateDistance;
+    float maxDepth;
+    int   maxWeight;
+    float raycastStepFactor;
+    bool  zFirstMemOrder;
+
+    Matx44f volumePose;
+    Point3i volumeResolution;
+    Vec4i volumeStrides;
+    Matx33f cameraIntegrateIntrinsics;
+    Matx33f cameraRaycastIntrinsics;
+
+public:
+    // duplicate classes for all volumes
+
+    class DefaultTsdfSets {
+    public:
+        static const int integrateWidth  = 640;
+        static const int integrateHeight = 480;
+        float ifx = 525.f; // focus point x axis
+        float ify = 525.f; // focus point y axis
+        float icx = float(integrateWidth) / 2.f - 0.5f;  // central point x axis
+        float icy = float(integrateHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraIntegrateIntrinsics = Matx33f(ifx, 0, icx, 0, ify, icy, 0, 0, 1); // camera settings
+
+        static const int raycastWidth = 640;
+        static const int raycastHeight = 480;
+        float rfx = 525.f; // focus point x axis
+        float rfy = 525.f; // focus point y axis
+        float rcx = float(raycastWidth) / 2.f - 0.5f;  // central point x axis
+        float rcy = float(raycastHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraRaycastIntrinsics = Matx33f(rfx, 0, rcx, 0, rfy, rcy, 0, 0, 1); // camera settings
+
+        static constexpr float depthFactor = 5000.f; // 5000 for the 16-bit PNG files, 1 for the 32-bit float images in the ROS bag files
+        static constexpr float volumeSize = 3.f; // meters
+        static constexpr float voxelSize = volumeSize / 128.f; //meters
+        static constexpr float tsdfTruncateDistance = 2 * voxelSize;
+        static constexpr float maxDepth = 0.f;
+        static const int maxWeight = 64; // number of frames
+        static constexpr float raycastStepFactor = 0.75f;
+        static const bool zFirstMemOrder = true; // order of voxels in volume
+
+        const Affine3f volumePose = Affine3f().translate(Vec3f(-volumeSize / 2.f, -volumeSize / 2.f, 0.5f));
+        const Matx44f  volumePoseMatrix = volumePose.matrix;
+        // Unlike original code, this should work with any volume size
+        // Not only when (x,y,z % 32) == 0
+        const Point3i  volumeResolution = Vec3i::all(128); //number of voxels
+    };
+
+    class DefaultHashTsdfSets {
+    public:
+        static const int integrateWidth = 640;
+        static const int integrateHeight = 480;
+        float ifx = 525.f; // focus point x axis
+        float ify = 525.f; // focus point y axis
+        float icx = float(integrateWidth) / 2.f - 0.5f;  // central point x axis
+        float icy = float(integrateHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraIntegrateIntrinsics = Matx33f(ifx, 0, icx, 0, ify, icy, 0, 0, 1); // camera settings
+
+        static const int raycastWidth = 640;
+        static const int raycastHeight = 480;
+        float rfx = 525.f; // focus point x axis
+        float rfy = 525.f; // focus point y axis
+        float rcx = float(raycastWidth) / 2.f - 0.5f;  // central point x axis
+        float rcy = float(raycastHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraRaycastIntrinsics = Matx33f(rfx, 0, rcx, 0, rfy, rcy, 0, 0, 1); // camera settings
+
+        static constexpr float depthFactor = 5000.f; // 5000 for the 16-bit PNG files, 1 for the 32-bit float images in the ROS bag files
+        static constexpr float volumeSize = 3.f; // meters
+        static constexpr float voxelSize = volumeSize / 512.f; //meters
+        static constexpr float tsdfTruncateDistance = 7 * voxelSize;
+        static constexpr float maxDepth = 4.f;
+        static const int maxWeight = 64; // number of frames
+        static constexpr float raycastStepFactor = 0.25f;
+        static const bool zFirstMemOrder = true; // order of voxels in volume
+
+        const Affine3f volumePose = Affine3f().translate(Vec3f(-volumeSize / 2.f, -volumeSize / 2.f, 0.5f));
+        const Matx44f  volumePoseMatrix = volumePose.matrix;
+        // Unlike original code, this should work with any volume size
+        // Not only when (x,y,z % 32) == 0
+        const Point3i  volumeResolution = Vec3i::all(16); //number of voxels
+    };
+
+    class DefaultColorTsdfSets {
+    public:
+        static const int integrateWidth = 640;
+        static const int integrateHeight = 480;
+        float ifx = 525.f; // focus point x axis
+        float ify = 525.f; // focus point y axis
+        float icx = float(integrateWidth) / 2.f - 0.5f;  // central point x axis
+        float icy = float(integrateHeight) / 2.f - 0.5f; // central point y axis
+        float rgb_ifx = 525.f; // focus point x axis
+        float rgb_ify = 525.f; // focus point y axis
+        float rgb_icx = float(integrateWidth) / 2.f - 0.5f;  // central point x axis
+        float rgb_icy = float(integrateHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraIntegrateIntrinsics = Matx33f(ifx, 0, icx, 0, ify, icy, 0, 0, 1); // camera settings
+
+        static const int raycastWidth = 640;
+        static const int raycastHeight = 480;
+        float rfx = 525.f; // focus point x axis
+        float rfy = 525.f; // focus point y axis
+        float rcx = float(raycastWidth) / 2.f - 0.5f;  // central point x axis
+        float rcy = float(raycastHeight) / 2.f - 0.5f; // central point y axis
+        float rgb_rfx = 525.f; // focus point x axis
+        float rgb_rfy = 525.f; // focus point y axis
+        float rgb_rcx = float(raycastWidth) / 2.f - 0.5f;  // central point x axis
+        float rgb_rcy = float(raycastHeight) / 2.f - 0.5f; // central point y axis
+        const Matx33f  cameraRaycastIntrinsics = Matx33f(rfx, 0, rcx, 0, rfy, rcy, 0, 0, 1); // camera settings
+
+        static constexpr float depthFactor = 5000.f; // 5000 for the 16-bit PNG files, 1 for the 32-bit float images in the ROS bag files
+        static constexpr float volumeSize = 3.f; // meters
+        static constexpr float voxelSize = volumeSize / 128.f; //meters
+        static constexpr float tsdfTruncateDistance = 2 * voxelSize;
+        static constexpr float maxDepth = 0.f;
+        static const int maxWeight = 64; // number of frames
+        static constexpr float raycastStepFactor = 0.75f;
+        static const bool zFirstMemOrder = true; // order of voxels in volume
+
+        const Affine3f volumePose = Affine3f().translate(Vec3f(-volumeSize / 2.f, -volumeSize / 2.f, 0.5f));
+        const Matx44f  volumePoseMatrix = volumePose.matrix;
+        // Unlike original code, this should work with any volume size
+        // Not only when (x,y,z % 32) == 0
+        const Point3i  volumeResolution = Vec3i::all(128); //number of voxels
+    };
+
+};
+
+
+VolumeSettings::VolumeSettings(VolumeType volumeType)
+{
+    this->impl = makePtr<VolumeSettingsImpl>(volumeType);
+}
+
+VolumeSettings::VolumeSettings(const VolumeSettings& vs)
+{
+    this->impl = makePtr<VolumeSettingsImpl>(*vs.impl.dynamicCast<VolumeSettingsImpl>());
+}
+
+VolumeSettings& VolumeSettings::operator=(const VolumeSettings& vs)
+{
+    this->impl = makePtr<VolumeSettingsImpl>(*vs.impl.dynamicCast<VolumeSettingsImpl>());
+    return *this;
+}
+
+VolumeSettings::~VolumeSettings() {}
+
+void  VolumeSettings::setIntegrateWidth(int val) { this->impl->setIntegrateWidth(val); };
+int   VolumeSettings::getIntegrateWidth() const { return this->impl->getIntegrateWidth(); };
+void  VolumeSettings::setIntegrateHeight(int val) { this->impl->setIntegrateHeight(val); };
+int   VolumeSettings::getIntegrateHeight() const { return this->impl->getIntegrateHeight(); };
+void  VolumeSettings::setRaycastWidth(int val) { this->impl->setRaycastWidth(val); };
+int   VolumeSettings::getRaycastWidth() const { return this->impl->getRaycastWidth(); };
+void  VolumeSettings::setRaycastHeight(int val) { this->impl->setRaycastHeight(val); };
+int   VolumeSettings::getRaycastHeight() const { return this->impl->getRaycastHeight(); };
+void  VolumeSettings::setVoxelSize(float val) { this->impl->setVoxelSize(val); };
+float VolumeSettings::getVoxelSize() const { return this->impl->getVoxelSize(); };
+void  VolumeSettings::setRaycastStepFactor(float val) { this->impl->setRaycastStepFactor(val); };
+float VolumeSettings::getRaycastStepFactor() const { return this->impl->getRaycastStepFactor(); };
+void  VolumeSettings::setTsdfTruncateDistance(float val) { this->impl->setTsdfTruncateDistance(val); };
+float VolumeSettings::getTsdfTruncateDistance() const { return this->impl->getTsdfTruncateDistance(); };
+void  VolumeSettings::setMaxDepth(float val) { this->impl->setMaxDepth(val); };
+float VolumeSettings::getMaxDepth() const { return this->impl->getMaxDepth(); };
+void  VolumeSettings::setDepthFactor(float val) { this->impl->setDepthFactor(val); };
+float VolumeSettings::getDepthFactor() const { return this->impl->getDepthFactor(); };
+void  VolumeSettings::setMaxWeight(int val) { this->impl->setMaxWeight(val); };
+int   VolumeSettings::getMaxWeight() const { return this->impl->getMaxWeight(); };
+
+void VolumeSettings::setVolumePose(InputArray val) { this->impl->setVolumePose(val); };
+void VolumeSettings::getVolumePose(OutputArray val) const { this->impl->getVolumePose(val); };
+void VolumeSettings::setVolumeResolution(InputArray val) { this->impl->setVolumeResolution(val); };
+void VolumeSettings::getVolumeResolution(OutputArray val) const { this->impl->getVolumeResolution(val); };
+void VolumeSettings::getVolumeStrides(OutputArray val) const { this->impl->getVolumeStrides(val); };
+void VolumeSettings::setCameraIntegrateIntrinsics(InputArray val) { this->impl->setCameraIntegrateIntrinsics(val); };
+void VolumeSettings::getCameraIntegrateIntrinsics(OutputArray val) const { this->impl->getCameraIntegrateIntrinsics(val); };
+void VolumeSettings::setCameraRaycastIntrinsics(InputArray val) { this->impl->setCameraRaycastIntrinsics(val); };
+void VolumeSettings::getCameraRaycastIntrinsics(OutputArray val) const { this->impl->getCameraRaycastIntrinsics(val); };
+
+
+VolumeSettingsImpl::VolumeSettingsImpl()
+    : VolumeSettingsImpl(VolumeType::TSDF)
+{
+}
+
+VolumeSettingsImpl::VolumeSettingsImpl(VolumeType _volumeType)
+{
+    volumeType = _volumeType;
+    if (volumeType == VolumeType::TSDF)
+    {
+        DefaultTsdfSets ds = DefaultTsdfSets();
+
+        this->integrateWidth = ds.integrateWidth;
+        this->integrateHeight = ds.integrateHeight;
+        this->raycastWidth = ds.raycastWidth;
+        this->raycastHeight = ds.raycastHeight;
+        this->depthFactor = ds.depthFactor;
+        this->voxelSize = ds.voxelSize;
+        this->tsdfTruncateDistance = ds.tsdfTruncateDistance;
+        this->maxDepth = ds.maxDepth;
+        this->maxWeight = ds.maxWeight;
+        this->raycastStepFactor = ds.raycastStepFactor;
+        this->zFirstMemOrder = ds.zFirstMemOrder;
+
+        this->volumePose = ds.volumePoseMatrix;
+        this->volumeResolution = ds.volumeResolution;
+        this->volumeStrides = calcVolumeStrides(ds.volumeResolution, ds.zFirstMemOrder);
+        this->cameraIntegrateIntrinsics = ds.cameraIntegrateIntrinsics;
+        this->cameraRaycastIntrinsics = ds.cameraRaycastIntrinsics;
+    }
+    else if (volumeType == VolumeType::HashTSDF)
+    {
+        DefaultHashTsdfSets ds = DefaultHashTsdfSets();
+
+        this->integrateWidth = ds.integrateWidth;
+        this->integrateHeight = ds.integrateHeight;
+        this->raycastWidth = ds.raycastWidth;
+        this->raycastHeight = ds.raycastHeight;
+        this->depthFactor = ds.depthFactor;
+        this->voxelSize = ds.voxelSize;
+        this->tsdfTruncateDistance = ds.tsdfTruncateDistance;
+        this->maxDepth = ds.maxDepth;
+        this->maxWeight = ds.maxWeight;
+        this->raycastStepFactor = ds.raycastStepFactor;
+        this->zFirstMemOrder = ds.zFirstMemOrder;
+
+        this->volumePose = ds.volumePoseMatrix;
+        this->volumeResolution = ds.volumeResolution;
+        this->volumeStrides = calcVolumeStrides(ds.volumeResolution, ds.zFirstMemOrder);
+        this->cameraIntegrateIntrinsics = ds.cameraIntegrateIntrinsics;
+        this->cameraRaycastIntrinsics = ds.cameraRaycastIntrinsics;
+    }
+    else if (volumeType == VolumeType::ColorTSDF)
+    {
+        DefaultColorTsdfSets ds = DefaultColorTsdfSets();
+
+        this->integrateWidth = ds.integrateWidth;
+        this->integrateHeight = ds.integrateHeight;
+        this->raycastWidth = ds.raycastWidth;
+        this->raycastHeight = ds.raycastHeight;
+        this->depthFactor = ds.depthFactor;
+        this->voxelSize = ds.voxelSize;
+        this->tsdfTruncateDistance = ds.tsdfTruncateDistance;
+        this->maxDepth = ds.maxDepth;
+        this->maxWeight = ds.maxWeight;
+        this->raycastStepFactor = ds.raycastStepFactor;
+        this->zFirstMemOrder = ds.zFirstMemOrder;
+
+        this->volumePose = ds.volumePoseMatrix;
+        this->volumeResolution = ds.volumeResolution;
+        this->volumeStrides = calcVolumeStrides(ds.volumeResolution, ds.zFirstMemOrder);
+        this->cameraIntegrateIntrinsics = ds.cameraIntegrateIntrinsics;
+        this->cameraRaycastIntrinsics = ds.cameraRaycastIntrinsics;
+    }
+}
+
+
+VolumeSettingsImpl::~VolumeSettingsImpl() {}
+
+
+void VolumeSettingsImpl::setIntegrateWidth(int val)
+{
+    this->integrateWidth = val;
+}
+
+int VolumeSettingsImpl::getIntegrateWidth() const
+{
+    return this->integrateWidth;
+}
+
+void VolumeSettingsImpl::setIntegrateHeight(int val)
+{
+    this->integrateHeight = val;
+}
+
+int VolumeSettingsImpl::getIntegrateHeight() const
+{
+    return this->integrateHeight;
+}
+
+void VolumeSettingsImpl::setRaycastWidth(int val)
+{
+    this->raycastWidth = val;
+}
+
+int VolumeSettingsImpl::getRaycastWidth() const
+{
+    return this->raycastWidth;
+}
+
+void VolumeSettingsImpl::setRaycastHeight(int val)
+{
+    this->raycastHeight = val;
+}
+
+int VolumeSettingsImpl::getRaycastHeight() const
+{
+    return this->raycastHeight;
+}
+
+void VolumeSettingsImpl::setDepthFactor(float val)
+{
+    this->depthFactor = val;
+}
+
+float VolumeSettingsImpl::getDepthFactor() const
+{
+    return this->depthFactor;
+}
+
+void VolumeSettingsImpl::setVoxelSize(float  val)
+{
+    this->voxelSize = val;
+}
+
+float VolumeSettingsImpl::getVoxelSize() const
+{
+    return this->voxelSize;
+}
+
+void VolumeSettingsImpl::setTsdfTruncateDistance(float val)
+{
+    this->tsdfTruncateDistance = val;
+}
+
+float VolumeSettingsImpl::getTsdfTruncateDistance() const
+{
+    return this->tsdfTruncateDistance;
+}
+
+void VolumeSettingsImpl::setMaxDepth(float val)
+{
+    this->maxDepth = val;
+}
+
+float VolumeSettingsImpl::getMaxDepth() const
+{
+    return this->maxDepth;
+}
+
+void VolumeSettingsImpl::setMaxWeight(int val)
+{
+    this->maxWeight = val;
+}
+
+int VolumeSettingsImpl::getMaxWeight() const
+{
+    return this->maxWeight;
+}
+
+void VolumeSettingsImpl::setRaycastStepFactor(float val)
+{
+    this->raycastStepFactor = val;
+}
+
+float VolumeSettingsImpl::getRaycastStepFactor() const
+{
+    return this->raycastStepFactor;
+}
+
+void VolumeSettingsImpl::setVolumePose(InputArray val)
+{
+    if (!val.empty())
+    {
+        val.copyTo(this->volumePose);
+    }
+}
+
+void VolumeSettingsImpl::getVolumePose(OutputArray val) const
+{
+    Mat(this->volumePose).copyTo(val);
+}
+
+void VolumeSettingsImpl::setVolumeResolution(InputArray val)
+{
+    if (!val.empty())
+    {
+        this->volumeResolution = Point3i(val.getMat());
+        this->volumeStrides = calcVolumeStrides(this->volumeResolution, this->zFirstMemOrder);
+    }
+}
+
+void VolumeSettingsImpl::getVolumeResolution(OutputArray val) const
+{
+    Mat(this->volumeResolution).copyTo(val);
+}
+
+void VolumeSettingsImpl::getVolumeStrides(OutputArray val) const
+{
+    Mat(this->volumeStrides).copyTo(val);
+}
+
+void VolumeSettingsImpl::setCameraIntegrateIntrinsics(InputArray val)
+{
+    if (!val.empty())
+    {
+        this->cameraIntegrateIntrinsics = Matx33f(val.getMat());
+    }
+}
+
+void VolumeSettingsImpl::getCameraIntegrateIntrinsics(OutputArray val) const
+{
+    Mat(this->cameraIntegrateIntrinsics).copyTo(val);
+}
+
+
+void VolumeSettingsImpl::setCameraRaycastIntrinsics(InputArray val)
+{
+    if (!val.empty())
+    {
+        this->cameraRaycastIntrinsics = Matx33f(val.getMat());
+    }
+}
+
+void VolumeSettingsImpl::getCameraRaycastIntrinsics(OutputArray val) const
+{
+    Mat(this->cameraRaycastIntrinsics).copyTo(val);
+}
+
+}
diff --git a/third_party/opencv-5.0.0/modules/python/src2/copy_typings_stubs_on_success.py b/upstream/opencv/modules/python/src2/copy_typings_stubs_on_success.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/copy_typings_stubs_on_success.py
rename to upstream/opencv/modules/python/src2/copy_typings_stubs_on_success.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2.cpp b/upstream/opencv/modules/python/src2/cv2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2.cpp
rename to upstream/opencv/modules/python/src2/cv2.cpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2.hpp b/upstream/opencv/modules/python/src2/cv2.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2.hpp
rename to upstream/opencv/modules/python/src2/cv2.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_convert.cpp b/upstream/opencv/modules/python/src2/cv2_convert.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_convert.cpp
rename to upstream/opencv/modules/python/src2/cv2_convert.cpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_convert.hpp b/upstream/opencv/modules/python/src2/cv2_convert.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_convert.hpp
rename to upstream/opencv/modules/python/src2/cv2_convert.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_highgui.cpp b/upstream/opencv/modules/python/src2/cv2_highgui.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_highgui.cpp
rename to upstream/opencv/modules/python/src2/cv2_highgui.cpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_highgui.hpp b/upstream/opencv/modules/python/src2/cv2_highgui.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_highgui.hpp
rename to upstream/opencv/modules/python/src2/cv2_highgui.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_numpy.cpp b/upstream/opencv/modules/python/src2/cv2_numpy.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_numpy.cpp
rename to upstream/opencv/modules/python/src2/cv2_numpy.cpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_numpy.hpp b/upstream/opencv/modules/python/src2/cv2_numpy.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_numpy.hpp
rename to upstream/opencv/modules/python/src2/cv2_numpy.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_util.cpp b/upstream/opencv/modules/python/src2/cv2_util.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_util.cpp
rename to upstream/opencv/modules/python/src2/cv2_util.cpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/cv2_util.hpp b/upstream/opencv/modules/python/src2/cv2_util.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/cv2_util.hpp
rename to upstream/opencv/modules/python/src2/cv2_util.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/gen2.py b/upstream/opencv/modules/python/src2/gen2.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/gen2.py
rename to upstream/opencv/modules/python/src2/gen2.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/hdr_parser.py b/upstream/opencv/modules/python/src2/hdr_parser.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/hdr_parser.py
rename to upstream/opencv/modules/python/src2/hdr_parser.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/pycompat.hpp b/upstream/opencv/modules/python/src2/pycompat.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/pycompat.hpp
rename to upstream/opencv/modules/python/src2/pycompat.hpp
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/__init__.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/__init__.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/__init__.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/__init__.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/api_refinement.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/api_refinement.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/api_refinement.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/api_refinement.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/ast_utils.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/ast_utils.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/ast_utils.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/ast_utils.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/generation.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/generation.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/generation.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/generation.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/__init__.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/__init__.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/__init__.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/__init__.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/class_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/class_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/class_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/class_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/constant_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/constant_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/constant_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/constant_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/enumeration_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/enumeration_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/enumeration_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/enumeration_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/function_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/function_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/function_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/function_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/namespace_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/namespace_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/namespace_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/namespace_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/type_node.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/type_node.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/nodes/type_node.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/nodes/type_node.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/predefined_types.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/predefined_types.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/predefined_types.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/predefined_types.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/types_conversion.py b/upstream/opencv/modules/python/src2/typing_stubs_generation/types_conversion.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generation/types_conversion.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generation/types_conversion.py
diff --git a/third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generator.py b/upstream/opencv/modules/python/src2/typing_stubs_generator.py
similarity index 100%
rename from third_party/opencv-5.0.0/modules/python/src2/typing_stubs_generator.py
rename to upstream/opencv/modules/python/src2/typing_stubs_generator.py
diff --git a/upstream/opencv/modules/stereo/CMakeLists.txt b/upstream/opencv/modules/stereo/CMakeLists.txt
new file mode 100644
index 0000000..5f9fb43
--- /dev/null
+++ b/upstream/opencv/modules/stereo/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(the_description "Depth from Stereo")
+
+set(debug_modules "")
+if(DEBUG_opencv_stereo)
+  list(APPEND debug_modules opencv_highgui)
+endif()
+ocv_define_module(stereo opencv_imgproc opencv_geometry ${debug_modules}
+    WRAP java objc python js
+)
diff --git a/upstream/opencv/modules/stereo/include/opencv2/stereo.hpp b/upstream/opencv/modules/stereo/include/opencv2/stereo.hpp
new file mode 100644
index 0000000..850230a
--- /dev/null
+++ b/upstream/opencv/modules/stereo/include/opencv2/stereo.hpp
@@ -0,0 +1,489 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#ifndef OPENCV_STEREO_HPP
+#define OPENCV_STEREO_HPP
+
+#include "opencv2/core.hpp"
+
+/**
+  @defgroup stereo Stereo Correspondence
+
+ */
+
+namespace cv {
+
+enum
+{
+    STEREO_ZERO_DISPARITY=0x00400
+};
+
+//! @addtogroup stereo
+//! @{
+
+/** @brief Computes rectification transforms for each head of a calibrated stereo camera.
+
+@param cameraMatrix1 First camera intrinsic matrix.
+@param distCoeffs1 First camera distortion parameters.
+@param cameraMatrix2 Second camera intrinsic matrix.
+@param distCoeffs2 Second camera distortion parameters.
+@param imageSize Size of the image used for stereo calibration.
+@param R Rotation matrix from the coordinate system of the first camera to the second camera,
+see @ref stereoCalibrate.
+@param T Translation vector from the coordinate system of the first camera to the second camera,
+see @ref stereoCalibrate.
+@param R1 Output 3x3 rectification transform (rotation matrix) for the first camera. This matrix
+brings points given in the unrectified first camera's coordinate system to points in the rectified
+first camera's coordinate system. In more technical terms, it performs a change of basis from the
+unrectified first camera's coordinate system to the rectified first camera's coordinate system.
+@param R2 Output 3x3 rectification transform (rotation matrix) for the second camera. This matrix
+brings points given in the unrectified second camera's coordinate system to points in the rectified
+second camera's coordinate system. In more technical terms, it performs a change of basis from the
+unrectified second camera's coordinate system to the rectified second camera's coordinate system.
+@param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
+camera, i.e. it projects points given in the rectified first camera coordinate system into the
+rectified first camera's image.
+@param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
+camera, i.e. it projects points given in the rectified first camera coordinate system into the
+rectified second camera's image.
+@param Q Output \f$4 \times 4\f$ disparity-to-depth mapping matrix (see @ref reprojectImageTo3D).
+@param flags Operation flags that may be zero or @ref STEREO_ZERO_DISPARITY . If the flag is set,
+the function makes the principal points of each camera have the same pixel coordinates in the
+rectified views. And if the flag is not set, the function may still shift the images in the
+horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
+useful image area.
+@param alpha Free scaling parameter. If it is -1 or absent, the function performs the default
+scaling. Otherwise, the parameter should be between 0 and 1. alpha=0 means that the rectified
+images are zoomed and shifted so that only valid pixels are visible (no black areas after
+rectification). alpha=1 means that the rectified image is decimated and shifted so that all the
+pixels from the original images from the cameras are retained in the rectified images (no source
+image pixels are lost). Any intermediate value yields an intermediate result between
+those two extreme cases.
+@param newImageSize New image resolution after rectification. The same size should be passed to
+#initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
+is passed (default), it is set to the original imageSize . Setting it to a larger value can help you
+preserve details in the original image, especially when there is a big radial distortion.
+@param validPixROI1 Optional output rectangles inside the rectified images where all the pixels
+are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
+(see the picture below).
+@param validPixROI2 Optional output rectangles inside the rectified images where all the pixels
+are valid. If alpha=0 , the ROIs cover the whole images. Otherwise, they are likely to be smaller
+(see the picture below).
+
+The function computes the rotation matrices for each camera that (virtually) make both camera image
+planes the same plane. Consequently, this makes all the epipolar lines parallel and thus simplifies
+the dense stereo correspondence problem. The function takes the matrices computed by #stereoCalibrate
+as input. As output, it provides two rotation matrices and also two projection matrices in the new
+coordinates. The function distinguishes the following two cases:
+
+-   **Horizontal stereo**: the first and the second camera views are shifted relative to each other
+    mainly along the x-axis (with possible small vertical shift). In the rectified images, the
+    corresponding epipolar lines in the left and right cameras are horizontal and have the same
+    y-coordinate. P1 and P2 look like:
+
+    \f[\texttt{P1} = \begin{bmatrix}
+                        f & 0 & cx_1 & 0 \\
+                        0 & f & cy & 0 \\
+                        0 & 0 & 1 & 0
+                     \end{bmatrix}\f]
+
+    \f[\texttt{P2} = \begin{bmatrix}
+                        f & 0 & cx_2 & T_x \cdot f \\
+                        0 & f & cy & 0 \\
+                        0 & 0 & 1 & 0
+                     \end{bmatrix} ,\f]
+
+    \f[\texttt{Q} = \begin{bmatrix}
+                        1 & 0 & 0 & -cx_1 \\
+                        0 & 1 & 0 & -cy \\
+                        0 & 0 & 0 & f \\
+                        0 & 0 & -\frac{1}{T_x} & \frac{cx_1 - cx_2}{T_x}
+                    \end{bmatrix} \f]
+
+    where \f$T_x\f$ is a horizontal shift between the cameras and \f$cx_1=cx_2\f$ if
+    @ref STEREO_ZERO_DISPARITY is set.
+
+-   **Vertical stereo**: the first and the second camera views are shifted relative to each other
+    mainly in the vertical direction (and probably a bit in the horizontal direction too). The epipolar
+    lines in the rectified images are vertical and have the same x-coordinate. P1 and P2 look like:
+
+    \f[\texttt{P1} = \begin{bmatrix}
+                        f & 0 & cx & 0 \\
+                        0 & f & cy_1 & 0 \\
+                        0 & 0 & 1 & 0
+                     \end{bmatrix}\f]
+
+    \f[\texttt{P2} = \begin{bmatrix}
+                        f & 0 & cx & 0 \\
+                        0 & f & cy_2 & T_y \cdot f \\
+                        0 & 0 & 1 & 0
+                     \end{bmatrix},\f]
+
+    \f[\texttt{Q} = \begin{bmatrix}
+                        1 & 0 & 0 & -cx \\
+                        0 & 1 & 0 & -cy_1 \\
+                        0 & 0 & 0 & f \\
+                        0 & 0 & -\frac{1}{T_y} & \frac{cy_1 - cy_2}{T_y}
+                    \end{bmatrix} \f]
+
+    where \f$T_y\f$ is a vertical shift between the cameras and \f$cy_1=cy_2\f$ if
+    @ref STEREO_ZERO_DISPARITY is set.
+
+As you can see, the first three columns of P1 and P2 will effectively be the new "rectified" camera
+matrices. The matrices, together with R1 and R2 , can then be passed to #initUndistortRectifyMap to
+initialize the rectification map for each camera.
+
+See below the screenshot from the stereo_calib.cpp sample. Some red horizontal lines pass through
+the corresponding image regions. This means that the images are well rectified, which is what most
+stereo correspondence algorithms rely on. The green rectangles are roi1 and roi2 . You see that
+their interiors are all valid pixels.
+
+![image](pics/stereo_undistort.jpg)
+ */
+CV_EXPORTS_W void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1,
+                                 InputArray cameraMatrix2, InputArray distCoeffs2,
+                                 Size imageSize, InputArray R, InputArray T,
+                                 OutputArray R1, OutputArray R2,
+                                 OutputArray P1, OutputArray P2,
+                                 OutputArray Q, int flags = STEREO_ZERO_DISPARITY,
+                                 double alpha = -1, Size newImageSize = Size(),
+                                 CV_OUT Rect* validPixROI1 = 0, CV_OUT Rect* validPixROI2 = 0 );
+
+/** @brief Computes a rectification transform for an uncalibrated stereo camera.
+
+@param points1 Array of feature points in the first image.
+@param points2 The corresponding points in the second image. The same formats as in
+#findFundamentalMat are supported.
+@param F Input fundamental matrix. It can be computed from the same set of point pairs using
+#findFundamentalMat .
+@param imgSize Size of the image.
+@param H1 Output rectification homography matrix for the first image.
+@param H2 Output rectification homography matrix for the second image.
+@param threshold Optional threshold used to filter out the outliers. If the parameter is greater
+than zero, all the point pairs that do not comply with the epipolar geometry (that is, the points
+for which \f$|\texttt{points2[i]}^T \cdot \texttt{F} \cdot \texttt{points1[i]}|>\texttt{threshold}\f$ )
+are rejected prior to computing the homographies. Otherwise, all the points are considered inliers.
+
+The function computes the rectification transformations without knowing intrinsic parameters of the
+cameras and their relative position in the space, which explains the suffix "uncalibrated". Another
+related difference from #stereoRectify is that the function outputs not the rectification
+transformations in the object (3D) space, but the planar perspective transformations encoded by the
+homography matrices H1 and H2 . The function implements the algorithm @cite Hartley99 .
+
+@note
+   While the algorithm does not need to know the intrinsic parameters of the cameras, it heavily
+    depends on the epipolar geometry. Therefore, if the camera lenses have a significant distortion,
+    it would be better to correct it before computing the fundamental matrix and calling this
+    function. For example, distortion coefficients can be estimated for each head of stereo camera
+    separately by using #calibrateCamera . Then, the images can be corrected using #undistort , or
+    just the point coordinates can be corrected with #undistortPoints .
+ */
+CV_EXPORTS_W bool stereoRectifyUncalibrated( InputArray points1, InputArray points2,
+                                             InputArray F, Size imgSize,
+                                             OutputArray H1, OutputArray H2,
+                                             double threshold = 5 );
+
+
+CV_EXPORTS float rectify3Collinear( InputArray _cameraMatrix1, InputArray _distCoeffs1,
+                   InputArray _cameraMatrix2, InputArray _distCoeffs2,
+                   InputArray _cameraMatrix3, InputArray _distCoeffs3,
+                   InputArrayOfArrays _imgpt1,
+                   InputArrayOfArrays _imgpt3,
+                   Size imageSize, InputArray _Rmat12, InputArray _Tmat12,
+                   InputArray _Rmat13, InputArray _Tmat13,
+                   OutputArray _Rmat1, OutputArray _Rmat2, OutputArray _Rmat3,
+                   OutputArray _Pmat1, OutputArray _Pmat2, OutputArray _Pmat3,
+                   OutputArray _Qmat,
+                   double alpha, Size newImgSize,
+                   Rect* roi1, Rect* roi2, int flags );
+
+namespace fisheye {
+
+/** @brief Stereo rectification for fisheye camera model
+
+@param K1 First camera intrinsic matrix.
+@param D1 First camera distortion parameters.
+@param K2 Second camera intrinsic matrix.
+@param D2 Second camera distortion parameters.
+@param imageSize Size of the image used for stereo calibration.
+@param R Rotation matrix between the coordinate systems of the first and the second
+cameras.
+@param tvec Translation vector between coordinate systems of the cameras.
+@param R1 Output 3x3 rectification transform (rotation matrix) for the first camera.
+@param R2 Output 3x3 rectification transform (rotation matrix) for the second camera.
+@param P1 Output 3x4 projection matrix in the new (rectified) coordinate systems for the first
+camera.
+@param P2 Output 3x4 projection matrix in the new (rectified) coordinate systems for the second
+camera.
+@param Q Output \f$4 \times 4\f$ disparity-to-depth mapping matrix (see reprojectImageTo3D ).
+@param flags Operation flags that may be zero or @ref cv::CALIB_ZERO_DISPARITY . If the flag is set,
+the function makes the principal points of each camera have the same pixel coordinates in the
+rectified views. And if the flag is not set, the function may still shift the images in the
+horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the
+useful image area.
+@param newImageSize New image resolution after rectification. The same size should be passed to
+#initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0)
+is passed (default), it is set to the original imageSize . Setting it to larger value can help you
+preserve details in the original image, especially when there is a big radial distortion.
+@param balance Sets the new focal length in range between the min focal length and the max focal
+length. Balance is in range of [0, 1].
+@param fov_scale Divisor for new focal length.
+ */
+CV_EXPORTS_W void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,
+    OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),
+    double balance = 0.0, double fov_scale = 1.0);
+
+} // namespace fisheye
+
+/** @brief The base class for stereo correspondence algorithms.
+ */
+class CV_EXPORTS_W StereoMatcher : public Algorithm
+{
+public:
+    enum { DISP_SHIFT = 4,
+           DISP_SCALE = (1 << DISP_SHIFT)
+         };
+
+    /** @brief Computes disparity map for the specified stereo pair
+
+    @param left Left 8-bit single-channel image.
+    @param right Right image of the same size and the same type as the left one.
+    @param disparity Output disparity map. It has the same size as the input images. Some algorithms,
+    like StereoBM or StereoSGBM compute 16-bit fixed-point disparity map (where each disparity value
+    has 4 fractional bits), whereas other algorithms output 32-bit floating-point disparity map.
+     */
+    CV_WRAP virtual void compute( InputArray left, InputArray right,
+                                  OutputArray disparity ) = 0;
+
+    CV_WRAP virtual int getMinDisparity() const = 0;
+    CV_WRAP virtual void setMinDisparity(int minDisparity) = 0;
+
+    CV_WRAP virtual int getNumDisparities() const = 0;
+    CV_WRAP virtual void setNumDisparities(int numDisparities) = 0;
+
+    CV_WRAP virtual int getBlockSize() const = 0;
+    CV_WRAP virtual void setBlockSize(int blockSize) = 0;
+
+    CV_WRAP virtual int getSpeckleWindowSize() const = 0;
+    CV_WRAP virtual void setSpeckleWindowSize(int speckleWindowSize) = 0;
+
+    CV_WRAP virtual int getSpeckleRange() const = 0;
+    CV_WRAP virtual void setSpeckleRange(int speckleRange) = 0;
+
+    CV_WRAP virtual int getDisp12MaxDiff() const = 0;
+    CV_WRAP virtual void setDisp12MaxDiff(int disp12MaxDiff) = 0;
+};
+
+
+/** @brief Class for computing stereo correspondence using the block matching algorithm, introduced and
+contributed to OpenCV by K. Konolige.
+ */
+class CV_EXPORTS_W StereoBM : public StereoMatcher
+{
+public:
+    enum { PREFILTER_NORMALIZED_RESPONSE = 0,
+           PREFILTER_XSOBEL              = 1
+         };
+
+    CV_WRAP virtual int getPreFilterType() const = 0;
+    CV_WRAP virtual void setPreFilterType(int preFilterType) = 0;
+
+    CV_WRAP virtual int getPreFilterSize() const = 0;
+    CV_WRAP virtual void setPreFilterSize(int preFilterSize) = 0;
+
+    CV_WRAP virtual int getPreFilterCap() const = 0;
+    CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
+
+    CV_WRAP virtual int getTextureThreshold() const = 0;
+    CV_WRAP virtual void setTextureThreshold(int textureThreshold) = 0;
+
+    CV_WRAP virtual int getUniquenessRatio() const = 0;
+    CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
+
+    CV_WRAP virtual int getSmallerBlockSize() const = 0;
+    CV_WRAP virtual void setSmallerBlockSize(int blockSize) = 0;
+
+    CV_WRAP virtual Rect getROI1() const = 0;
+    CV_WRAP virtual void setROI1(Rect roi1) = 0;
+
+    CV_WRAP virtual Rect getROI2() const = 0;
+    CV_WRAP virtual void setROI2(Rect roi2) = 0;
+
+    /** @brief Creates StereoBM object
+
+    @param numDisparities the disparity search range. For each pixel algorithm will find the best
+    disparity from 0 (default minimum disparity) to numDisparities. The search range can then be
+    shifted by changing the minimum disparity.
+    @param blockSize the linear size of the blocks compared by the algorithm. The size should be odd
+    (as the block is centered at the current pixel). Larger block size implies smoother, though less
+    accurate disparity map. Smaller block size gives more detailed disparity map, but there is higher
+    chance for algorithm to find a wrong correspondence.
+
+    The function create StereoBM object. You can then call StereoBM::compute() to compute disparity for
+    a specific stereo pair.
+     */
+    CV_WRAP static Ptr<StereoBM> create(int numDisparities = 0, int blockSize = 21);
+};
+
+/** @brief The class implements the modified H. Hirschmuller algorithm @cite HH08 that differs from the original
+one as follows:
+
+-   By default, the algorithm is single-pass, which means that you consider only 5 directions
+instead of 8. Set mode=StereoSGBM::MODE_HH in createStereoSGBM to run the full variant of the
+algorithm but beware that it may consume a lot of memory.
+-   The algorithm matches blocks, not individual pixels. Though, setting blockSize=1 reduces the
+blocks to single pixels.
+-   Mutual information cost function is not implemented. Instead, a simpler Birchfield-Tomasi
+sub-pixel metric from @cite BT98 is used. Though, the color images are supported as well.
+-   Some pre- and post- processing steps from K. Konolige algorithm StereoBM are included, for
+example: pre-filtering (StereoBM::PREFILTER_XSOBEL type) and post-filtering (uniqueness
+check, quadratic interpolation and speckle filtering).
+
+@note
+   -   (Python) An example illustrating the use of the StereoSGBM matching algorithm can be found
+        at opencv_source_code/samples/python/stereo_match.py
+ */
+class CV_EXPORTS_W StereoSGBM : public StereoMatcher
+{
+public:
+    enum
+    {
+        MODE_SGBM = 0,
+        MODE_HH   = 1,
+        MODE_SGBM_3WAY = 2,
+        MODE_HH4  = 3
+    };
+
+    CV_WRAP virtual int getPreFilterCap() const = 0;
+    CV_WRAP virtual void setPreFilterCap(int preFilterCap) = 0;
+
+    CV_WRAP virtual int getUniquenessRatio() const = 0;
+    CV_WRAP virtual void setUniquenessRatio(int uniquenessRatio) = 0;
+
+    CV_WRAP virtual int getP1() const = 0;
+    CV_WRAP virtual void setP1(int P1) = 0;
+
+    CV_WRAP virtual int getP2() const = 0;
+    CV_WRAP virtual void setP2(int P2) = 0;
+
+    CV_WRAP virtual int getMode() const = 0;
+    CV_WRAP virtual void setMode(int mode) = 0;
+
+    /** @brief Creates StereoSGBM object
+
+    @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
+    rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
+    @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
+    zero. In the current implementation, this parameter must be divisible by 16.
+    @param blockSize Matched block size. It must be an odd number \>=1 . Normally, it should be
+    somewhere in the 3..11 range.
+    @param P1 The first parameter controlling the disparity smoothness. See below.
+    @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
+    the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
+    between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
+    pixels. The algorithm requires P2 \> P1 . See stereo_match.cpp sample where some reasonably good
+    P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
+    32\*number_of_image_channels\*blockSize\*blockSize , respectively).
+    @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
+    disparity check. Set it to a non-positive value to disable the check.
+    @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
+    computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
+    The result values are passed to the Birchfield-Tomasi pixel cost function.
+    @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function
+    value should "win" the second best value to consider the found match correct. Normally, a value
+    within the 5-15 range is good enough.
+    @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles
+    and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
+    50-200 range.
+    @param speckleRange Maximum disparity variation within each connected component. If you do speckle
+    filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
+    Normally, 1 or 2 is good enough.
+    @param mode Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming
+    algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
+    huge for HD-size pictures. By default, it is set to false .
+
+    The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
+    set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
+    to a custom value.
+     */
+    CV_WRAP static Ptr<StereoSGBM> create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3,
+                                          int P1 = 0, int P2 = 0, int disp12MaxDiff = 0,
+                                          int preFilterCap = 0, int uniquenessRatio = 0,
+                                          int speckleWindowSize = 0, int speckleRange = 0,
+                                          int mode = StereoSGBM::MODE_SGBM);
+};
+
+/** @brief Filters off small noise blobs (speckles) in the disparity map
+
+@param img The input 16-bit signed disparity image
+@param newVal The disparity value used to paint-off the speckles
+@param maxSpeckleSize The maximum speckle size to consider it a speckle. Larger blobs are not
+affected by the algorithm
+@param maxDiff Maximum difference between neighbor disparity pixels to put them into the same
+blob. Note that since StereoBM, StereoSGBM and may be other algorithms return a fixed-point
+disparity map, where disparity values are multiplied by 16, this scale factor should be taken into
+account when specifying this parameter value.
+@param buf The optional temporary buffer to avoid memory allocation within the function.
+ */
+CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal,
+                                  int maxSpeckleSize, double maxDiff,
+                                  InputOutputArray buf = noArray() );
+
+//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by #stereoRectify)
+CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2,
+                                        int minDisparity, int numberOfDisparities,
+                                        int blockSize );
+
+//! validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
+CV_EXPORTS_W void validateDisparity( InputOutputArray disparity, InputArray cost,
+                                     int minDisparity, int numberOfDisparities,
+                                     int disp12MaxDisp = 1 );
+
+/** @brief Reprojects a disparity image to 3D space.
+
+@param disparity Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit
+floating-point disparity image. The values of 8-bit / 16-bit signed formats are assumed to have no
+fractional bits. If the disparity is 16-bit signed format, as computed by @ref StereoBM or
+@ref StereoSGBM and maybe other algorithms, it should be divided by 16 (and scaled to float) before
+being used here.
+@param _3dImage Output 3-channel floating-point image of the same size as disparity. Each element of
+_3dImage(x,y) contains 3D coordinates of the point (x,y) computed from the disparity map. If one
+uses Q obtained by @ref stereoRectify, then the returned points are represented in the first
+camera's rectified coordinate system.
+@param Q \f$4 \times 4\f$ perspective transformation matrix that can be obtained with
+@ref stereoRectify.
+@param handleMissingValues Indicates, whether the function should handle missing values (i.e.
+points where the disparity was not computed). If handleMissingValues=true, then pixels with the
+minimal disparity that corresponds to the outliers (see StereoMatcher::compute ) are transformed
+to 3D points with a very large Z value (currently set to 10000).
+@param ddepth The optional output array depth. If it is -1, the output image will have CV_32F
+depth. ddepth can also be set to CV_16S, CV_32S or CV_32F.
+
+The function transforms a single-channel disparity map to a 3-channel image representing a 3D
+surface. That is, for each pixel (x,y) and the corresponding disparity d=disparity(x,y) , it
+computes:
+
+\f[\begin{bmatrix}
+X \\
+Y \\
+Z \\
+W
+\end{bmatrix} = Q \begin{bmatrix}
+x \\
+y \\
+\texttt{disparity} (x,y) \\
+1
+\end{bmatrix}.\f]
+
+@sa
+   To reproject a sparse set of points {(x,y,d),...} to 3D space, use perspectiveTransform.
+ */
+CV_EXPORTS_W void reprojectImageTo3D( InputArray disparity,
+                                      OutputArray _3dImage, InputArray Q,
+                                      bool handleMissingValues = false,
+                                      int ddepth = -1 );
+
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/stereo/src/main.cpp b/upstream/opencv/modules/stereo/src/main.cpp
new file mode 100644
index 0000000..127f86b
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/main.cpp
@@ -0,0 +1,52 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2015, Itseez Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//
+// Library initialization file
+//
+
+#include "precomp.hpp"
+
+IPP_INITIALIZER_AUTO
+
+/* End of file. */
diff --git a/upstream/opencv/modules/stereo/src/opencl/stereobm.cl b/upstream/opencv/modules/stereo/src/opencl/stereobm.cl
new file mode 100644
index 0000000..16386a6
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/opencl/stereobm.cl
@@ -0,0 +1,334 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////// stereoBM //////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define MAX_VAL 32767
+
+#ifndef WSZ
+#define WSZ     2
+#endif
+
+#define WSZ2    (WSZ / 2)
+
+#ifdef DEFINE_KERNEL_STEREOBM
+
+#define DISPARITY_SHIFT     4
+#define FILTERED            ((MIN_DISP - 1) << DISPARITY_SHIFT)
+
+void calcDisp(__local short * cost, __global short * disp, int uniquenessRatio,
+              __local int * bestDisp, __local int * bestCost, int d, int x, int y, int cols, int rows)
+{
+    int best_disp = *bestDisp, best_cost = *bestCost;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    short c = cost[0];
+    int thresh = best_cost + (best_cost * uniquenessRatio / 100);
+    bool notUniq = ( (c <= thresh) && (d < (best_disp - 1) || d > (best_disp + 1) ) );
+
+    if (notUniq)
+        *bestCost = FILTERED;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if( *bestCost != FILTERED && x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2 && d == best_disp)
+    {
+        int d_aprox = 0;
+        int yp =0, yn = 0;
+        if ((0 < best_disp) && (best_disp < NUM_DISP - 1))
+        {
+            yp = cost[-2 * BLOCK_SIZE_Y];
+            yn = cost[2 * BLOCK_SIZE_Y];
+            d_aprox = yp + yn - 2 * c + abs(yp - yn);
+        }
+        disp[0] = (short)(((best_disp + MIN_DISP)*256 + (d_aprox != 0 ? (yp - yn) * 256 / d_aprox : 0) + 15) >> 4);
+    }
+}
+
+short calcCostBorder(__global const uchar * leftptr, __global const uchar * rightptr, int x, int y, int nthread,
+                     short * costbuf, int *h, int cols, int d, short cost)
+{
+    int head = (*h) % WSZ;
+    __global const uchar * left, * right;
+    int idx = mad24(y + WSZ2 * (2 * nthread - 1), cols, x + WSZ2 * (1 - 2 * nthread));
+    left = leftptr + idx;
+    right = rightptr + (idx - d);
+
+    short costdiff = 0;
+    if (0 == nthread)
+    {
+        #pragma unroll
+        for (int i = 0; i < WSZ; i++)
+        {
+            costdiff += abs( left[0] - right[0] );
+            left += cols;
+            right += cols;
+        }
+    }
+    else // (1 == nthread)
+    {
+        #pragma unroll
+        for (int i = 0; i < WSZ; i++)
+        {
+            costdiff += abs(left[i] - right[i]);
+        }
+    }
+    cost += costdiff - costbuf[head];
+    costbuf[head] = costdiff;
+    *h = head + 1;
+    return cost;
+}
+
+short calcCostInside(__global const uchar * leftptr, __global const uchar * rightptr, int x, int y,
+                     int cols, int d, short cost_up_left, short cost_up, short cost_left)
+{
+    __global const uchar * left, * right;
+    int idx = mad24(y - WSZ2 - 1, cols, x - WSZ2 - 1);
+    left = leftptr + idx;
+    right = rightptr + (idx - d);
+    int idx2 = WSZ*cols;
+
+    uchar corrner1 = abs(left[0] - right[0]),
+          corrner2 = abs(left[WSZ] - right[WSZ]),
+          corrner3 = abs(left[idx2] - right[idx2]),
+          corrner4 = abs(left[idx2 + WSZ] - right[idx2 + WSZ]);
+
+    return cost_up + cost_left - cost_up_left + corrner1 -
+        corrner2 - corrner3 + corrner4;
+}
+
+__kernel void stereoBM(__global const uchar * leftptr,
+                       __global const uchar * rightptr,
+                       __global uchar * dispptr, int disp_step, int disp_offset,
+                       int rows, int cols,                                              // rows, cols of left and right images, not disp
+                       int textureThreshold, int uniquenessRatio)
+{
+    int lz = get_local_id(0);
+    int gx = get_global_id(1) * BLOCK_SIZE_X;
+    int gy = get_global_id(2) * BLOCK_SIZE_Y;
+
+    int nthread = lz / NUM_DISP;
+    int disp_idx = lz % NUM_DISP;
+
+    __global short * disp;
+    __global const uchar * left, * right;
+
+    __local short costFunc[2 * BLOCK_SIZE_Y * NUM_DISP];
+
+    __local short * cost;
+    __local int best_disp[2];
+    __local int best_cost[2];
+    best_cost[nthread] = MAX_VAL;
+    best_disp[nthread] = -1;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    short costbuf[WSZ];
+    int head = 0;
+
+    int shiftX = WSZ2 + NUM_DISP + MIN_DISP - 1;
+    int shiftY = WSZ2;
+
+    int x = gx + shiftX, y = gy + shiftY, lx = 0, ly = 0;
+
+    int costIdx = disp_idx * 2 * BLOCK_SIZE_Y + (BLOCK_SIZE_Y - 1);
+    cost = costFunc + costIdx;
+
+    int tempcost = 0;
+    if (x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2)
+    {
+        if (0 == nthread)
+        {
+            #pragma unroll
+            for (int i = 0; i < WSZ; i++)
+            {
+                int idx = mad24(y - WSZ2, cols, x - WSZ2 + i);
+                left = leftptr + idx;
+                right = rightptr + (idx - disp_idx);
+                short costdiff = 0;
+                for(int j = 0; j < WSZ; j++)
+                {
+                    costdiff += abs( left[0] - right[0] );
+                    left += cols;
+                    right += cols;
+                }
+                costbuf[i] = costdiff;
+            }
+        }
+        else // (1 == nthread)
+        {
+            #pragma unroll
+            for (int i = 0; i < WSZ; i++)
+            {
+                int idx = mad24(y - WSZ2 + i, cols, x - WSZ2);
+                left = leftptr + idx;
+                right = rightptr + (idx - disp_idx);
+                short costdiff = 0;
+                for (int j = 0; j < WSZ; j++)
+                {
+                    costdiff += abs( left[j] - right[j]);
+                }
+                tempcost += costdiff;
+                costbuf[i] = costdiff;
+            }
+        }
+    }
+    if (nthread == 1)
+    {
+        cost[0] = tempcost;
+        atomic_min(best_cost + 1, tempcost);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (best_cost[1] == tempcost)
+         atomic_max(best_disp + 1, disp_idx);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    int dispIdx = mad24(gy, disp_step, mad24((int)sizeof(short), gx, disp_offset));
+    disp = (__global short *)(dispptr + dispIdx);
+    calcDisp(cost, disp, uniquenessRatio, best_disp + 1, best_cost + 1, disp_idx, x, y, cols, rows);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    lx = 1 - nthread;
+    ly = nthread;
+
+    for (int i = 0; i < BLOCK_SIZE_Y * BLOCK_SIZE_X / 2; i++)
+    {
+        x = (lx < BLOCK_SIZE_X) ? gx + shiftX + lx : cols;
+        y = (ly < BLOCK_SIZE_Y) ? gy + shiftY + ly : rows;
+
+        best_cost[nthread] = MAX_VAL;
+        best_disp[nthread] = -1;
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        costIdx = mad24(2 * BLOCK_SIZE_Y, disp_idx, (BLOCK_SIZE_Y - 1 - ly + lx));
+        if (0 > costIdx)
+            costIdx = BLOCK_SIZE_Y - 1;
+        cost = costFunc + costIdx;
+        if (x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2)
+        {
+            tempcost = (ly * (1 - nthread) + lx * nthread == 0) ?
+                calcCostBorder(leftptr, rightptr, x, y, nthread, costbuf, &head, cols, disp_idx, cost[2*nthread-1]) :
+                calcCostInside(leftptr, rightptr, x, y, cols, disp_idx, cost[0], cost[1], cost[-1]);
+        }
+        cost[0] = tempcost;
+        atomic_min(best_cost + nthread, tempcost);
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        if (best_cost[nthread] == tempcost)
+            atomic_max(best_disp + nthread, disp_idx);
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        dispIdx = mad24(gy + ly, disp_step, mad24((int)sizeof(short), (gx + lx), disp_offset));
+        disp = (__global short *)(dispptr + dispIdx);
+        calcDisp(cost, disp, uniquenessRatio, best_disp + nthread, best_cost + nthread, disp_idx, x, y, cols, rows);
+
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        if (lx + nthread - 1 == ly)
+        {
+            lx = (lx + nthread + 1) * (1 - nthread);
+            ly = (ly + 1) * nthread;
+        }
+        else
+        {
+            lx += nthread;
+            ly = ly - nthread + 1;
+        }
+    }
+}
+#endif //DEFINE_KERNEL_STEREOBM
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////// Norm Prefiler ////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+__kernel void prefilter_norm(__global unsigned char *input, __global unsigned char *output,
+                               int rows, int cols, int prefilterCap, int scale_g, int scale_s)
+{
+    // prefilterCap in range 1..63, checked in StereoBMImpl::compute
+
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x < cols && y < rows)
+    {
+        int cov1 =                                   input[   max(y-1, 0)   * cols + x] * 1 +
+                  input[y * cols + max(x-1,0)] * 1 + input[      y          * cols + x] * 4 + input[y * cols + min(x+1, cols-1)] * 1 +
+                                                     input[min(y+1, rows-1) * cols + x] * 1;
+        int cov2 = 0;
+        for(int i = -WSZ2; i < WSZ2+1; i++)
+            for(int j = -WSZ2; j < WSZ2+1; j++)
+                cov2 += input[clamp(y+i, 0, rows-1) * cols + clamp(x+j, 0, cols-1)];
+
+        int res = (cov1*scale_g - cov2*scale_s)>>10;
+        res = clamp(res, -prefilterCap, prefilterCap) + prefilterCap;
+        output[y * cols + x] = res;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////// Sobel Prefiler ////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+__kernel void prefilter_xsobel(__global unsigned char *input, __global unsigned char *output,
+                               int rows, int cols, int prefilterCap)
+{
+    // prefilterCap in range 1..63, checked in StereoBMImpl::compute
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    if(x < cols && y < rows)
+    {
+        if (0 < x && !((y == rows-1) & (rows%2==1) ) )
+        {
+            int cov = input[ ((y > 0) ? y-1 : y+1)  * cols + (x-1)] * (-1) + input[ ((y > 0) ? y-1 : y+1)  * cols + ((x<cols-1) ? x+1 : x-1)] * (1) +
+                      input[              (y)       * cols + (x-1)] * (-2) + input[        (y)             * cols + ((x<cols-1) ? x+1 : x-1)] * (2) +
+                      input[((y<rows-1)?(y+1):(y-1))* cols + (x-1)] * (-1) + input[((y<rows-1)?(y+1):(y-1))* cols + ((x<cols-1) ? x+1 : x-1)] * (1);
+
+            cov = clamp(cov, -prefilterCap, prefilterCap) + prefilterCap;
+            output[y * cols + x] = cov;
+        }
+        else
+            output[y * cols + x] = prefilterCap;
+    }
+}
\ No newline at end of file
diff --git a/upstream/opencv/modules/stereo/src/precomp.hpp b/upstream/opencv/modules/stereo/src/precomp.hpp
new file mode 100644
index 0000000..deff149
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/precomp.hpp
@@ -0,0 +1,138 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+
+#include "opencv2/stereo.hpp"
+#include "opencv2/geometry.hpp"
+#include "opencv2/imgproc.hpp"
+
+#include "opencv2/core/ocl.hpp"
+
+#define GET_OPTIMIZED(func) (func)
+
+
+namespace cv
+{
+
+/**
+ * Compute the number of iterations given the confidence, outlier ratio, number
+ * of model points and the maximum iteration number.
+ *
+ * @param p confidence value
+ * @param ep outlier ratio
+ * @param modelPoints number of model points required for estimation
+ * @param maxIters maximum number of iterations
+ * @return The number of iterations according to the formula
+ * \f[
+ * \frac{\ln(1-p)}{\ln\left(1-(1-ep)^\mathrm{modelPoints}\right)}
+ * \f]
+ *
+ * If the computed number of iterations is larger than maxIters, then maxIters is returned.
+ */
+int RANSACUpdateNumIters( double p, double ep, int modelPoints, int maxIters );
+
+class CV_EXPORTS PointSetRegistrator : public Algorithm
+{
+public:
+    class CV_EXPORTS Callback
+    {
+    public:
+        virtual ~Callback() {}
+        virtual int runKernel(InputArray m1, InputArray m2, OutputArray model) const = 0;
+        virtual void computeError(InputArray m1, InputArray m2, InputArray model, OutputArray err) const = 0;
+        virtual bool checkSubset(InputArray, InputArray, int) const { return true; }
+    };
+
+    virtual void setCallback(const Ptr<PointSetRegistrator::Callback>& cb) = 0;
+    virtual bool run(InputArray m1, InputArray m2, OutputArray model, OutputArray mask) const = 0;
+};
+
+CV_EXPORTS Ptr<PointSetRegistrator> createRANSACPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                    int modelPoints, double threshold,
+                                                                    double confidence=0.99, int maxIters=1000 );
+
+CV_EXPORTS Ptr<PointSetRegistrator> createLMeDSPointSetRegistrator(const Ptr<PointSetRegistrator::Callback>& cb,
+                                                                   int modelPoints, double confidence=0.99, int maxIters=1000 );
+
+template<typename T> inline int compressElems( T* ptr, const uchar* mask, int mstep, int count )
+{
+    int i, j;
+    for( i = j = 0; i < count; i++ )
+        if( mask[i*mstep] )
+        {
+            if( i > j )
+                ptr[j] = ptr[i];
+            j++;
+        }
+    return j;
+}
+
+static inline bool haveCollinearPoints( const Mat& m, int count )
+{
+    int j, k, i = count-1;
+    const Point2f* ptr = m.ptr<Point2f>();
+
+    // check that the i-th selected point does not belong
+    // to a line connecting some previously selected points
+    // also checks that points are not too close to each other
+    for( j = 0; j < i; j++ )
+    {
+        double dx1 = ptr[j].x - ptr[i].x;
+        double dy1 = ptr[j].y - ptr[i].y;
+        for( k = 0; k < j; k++ )
+        {
+            double dx2 = ptr[k].x - ptr[i].x;
+            double dy2 = ptr[k].y - ptr[i].y;
+            if( fabs(dx2*dy1 - dy2*dx1) <= FLT_EPSILON*(fabs(dx1) + fabs(dy1) + fabs(dx2) + fabs(dy2)))
+                return true;
+        }
+    }
+    return false;
+}
+
+} // namespace cv
+
+#endif
diff --git a/upstream/opencv/modules/stereo/src/stereo_geom.cpp b/upstream/opencv/modules/stereo/src/stereo_geom.cpp
new file mode 100644
index 0000000..c230180
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/stereo_geom.cpp
@@ -0,0 +1,712 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+namespace cv {
+
+void reprojectImageTo3D( InputArray _disparity, OutputArray __3dImage,
+                         InputArray _Qmat, bool handleMissingValues, int dtype )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat disparity = _disparity.getMat(), Q = _Qmat.getMat();
+    int stype = disparity.type();
+
+    CV_Assert( stype == CV_8UC1 || stype == CV_16SC1 ||
+               stype == CV_32SC1 || stype == CV_32FC1 );
+    CV_Assert( Q.size() == Size(4,4) );
+
+    if( dtype >= 0 )
+        dtype = CV_MAKETYPE(CV_MAT_DEPTH(dtype), 3);
+
+    if( __3dImage.fixedType() )
+    {
+        int dtype_ = __3dImage.type();
+        CV_Assert( dtype == -1 || dtype == dtype_ );
+        dtype = dtype_;
+    }
+
+    if( dtype < 0 )
+        dtype = CV_32FC3;
+    else
+        CV_Assert( dtype == CV_16SC3 || dtype == CV_32SC3 || dtype == CV_32FC3 );
+
+    __3dImage.create(disparity.size(), dtype);
+    Mat _3dImage = __3dImage.getMat();
+
+    const float bigZ = 10000.f;
+    Matx44d _Q;
+    Q.convertTo(_Q, CV_64F);
+
+    int x, cols = disparity.cols;
+    CV_Assert( cols >= 0 );
+
+    std::vector<float> _sbuf(cols);
+    std::vector<Vec3f> _dbuf(cols);
+    float* sbuf = &_sbuf[0];
+    Vec3f* dbuf = &_dbuf[0];
+    double minDisparity = FLT_MAX;
+
+    // NOTE: here we quietly assume that at least one pixel in the disparity map is not defined.
+    // and we set the corresponding Z's to some fixed big value.
+    if( handleMissingValues )
+        cv::minMaxIdx( disparity, &minDisparity, 0, 0, 0 );
+
+    for( int y = 0; y < disparity.rows; y++ )
+    {
+        float* sptr = sbuf;
+        Vec3f* dptr = dbuf;
+
+        if( stype == CV_8UC1 )
+        {
+            const uchar* sptr0 = disparity.ptr<uchar>(y);
+            for( x = 0; x < cols; x++ )
+                sptr[x] = (float)sptr0[x];
+        }
+        else if( stype == CV_16SC1 )
+        {
+            const short* sptr0 = disparity.ptr<short>(y);
+            for( x = 0; x < cols; x++ )
+                sptr[x] = (float)sptr0[x];
+        }
+        else if( stype == CV_32SC1 )
+        {
+            const int* sptr0 = disparity.ptr<int>(y);
+            for( x = 0; x < cols; x++ )
+                sptr[x] = (float)sptr0[x];
+        }
+        else
+            sptr = disparity.ptr<float>(y);
+
+        if( dtype == CV_32FC3 )
+            dptr = _3dImage.ptr<Vec3f>(y);
+
+        for( x = 0; x < cols; x++)
+        {
+            double d = sptr[x];
+            Vec4d homg_pt = _Q*Vec4d(x, y, d, 1.0);
+            dptr[x] = Vec3d(homg_pt.val);
+            dptr[x] /= homg_pt[3];
+
+            if( fabs(d-minDisparity) <= FLT_EPSILON )
+                dptr[x][2] = bigZ;
+        }
+
+        if( dtype == CV_16SC3 )
+        {
+            Vec3s* dptr0 = _3dImage.ptr<Vec3s>(y);
+            for( x = 0; x < cols; x++ )
+            {
+                dptr0[x] = dptr[x];
+            }
+        }
+        else if( dtype == CV_32SC3 )
+        {
+            Vec3i* dptr0 = _3dImage.ptr<Vec3i>(y);
+            for( x = 0; x < cols; x++ )
+            {
+                dptr0[x] = dptr[x];
+            }
+        }
+    }
+}
+
+void stereoRectify( InputArray _cameraMatrix1, InputArray _distCoeffs1,
+                    InputArray _cameraMatrix2, InputArray _distCoeffs2,
+                    Size imageSize, InputArray R, InputArray T,
+                    OutputArray _R1, OutputArray _R2,
+                    OutputArray _P1, OutputArray _P2,
+                    OutputArray _Qmat, int flags,
+                    double alpha, Size newImgSize,
+                    Rect* roi1, Rect* roi2 )
+{
+    Mat matR = Mat_<double>(R.getMat()), matT = Mat_<double>(T.getMat());
+
+    Mat om, r_r;
+    Mat Z = Mat::zeros(3, 1, CV_64F);
+    double nx = imageSize.width, ny = imageSize.height;
+
+    if( matR.rows == 3 && matR.cols == 3 )
+        Rodrigues(matR, om);          // get vector rotation
+    else
+        matR.copyTo(om);
+    om *= -0.5; // get average rotation
+    Rodrigues(om, r_r);
+    Mat t = r_r * matT; // rotate cameras to same orientation by averaging
+
+    int idx = fabs(t.at<double>(0)) > fabs(t.at<double>(1)) ? 0 : 1;
+    double c = t.at<double>(idx), nt = norm(t, NORM_L2);
+    double _uu[3]={0, 0, 0};
+    _uu[idx] = c > 0 ? 1 : -1;
+
+    CV_Assert(nt > 0.0);
+
+    // calculate global Z rotation
+    Mat ww = t.cross(Mat(3, 1, CV_64F, _uu)), wR;
+    double nw = norm(ww, NORM_L2);
+    if (nw > 0.0)
+        ww *= std::acos(fabs(c)/nt)/nw;
+    Rodrigues(ww, wR);
+
+    Mat Ri;
+    // apply to both views
+    gemm(wR, r_r, 1, Mat(), 0, Ri, GEMM_2_T);
+    Ri.copyTo(_R1);
+    gemm(wR, r_r, 1, Mat(), 0, Ri, 0);
+    Ri.copyTo(_R2);
+    t = Ri * matT;
+
+    // calculate projection/camera matrices
+    // these contain the relevant rectified image internal params (fx, fy=fx, cx, cy)
+    Point2d cc_new[2]={};
+
+    newImgSize = newImgSize.width * newImgSize.height != 0 ? newImgSize : imageSize;
+    const double ratio_x = (double)newImgSize.width / imageSize.width / 2;
+    const double ratio_y = (double)newImgSize.height / imageSize.height / 2;
+    const double ratio = idx == 1 ? ratio_x : ratio_y;
+
+    Mat cameraMatrix1 = Mat_<double>(_cameraMatrix1.getMat());
+    Mat cameraMatrix2 = Mat_<double>(_cameraMatrix2.getMat());
+    Mat distCoeffs1, distCoeffs2;
+    if (!_distCoeffs1.empty())
+        distCoeffs1 = Mat_<double>(_distCoeffs1.getMat());
+    if (!_distCoeffs2.empty())
+        distCoeffs2 = Mat_<double>(_distCoeffs2.getMat());
+
+    double fc_new = (cameraMatrix1.at<double>(idx ^ 1, idx ^ 1) + cameraMatrix2.at<double>(idx ^ 1, idx ^ 1)) * ratio;
+
+    for( int k = 0; k < 2; k++ )
+    {
+        const Mat& A = k == 0 ? cameraMatrix1 : cameraMatrix2;
+        const Mat& Dk = k == 0 ? distCoeffs1 : distCoeffs2;
+        Point2f _pts[4] = {};
+        Point3f _pts_3[4] = {};
+        Mat pts(1, 4, CV_32FC2, _pts);
+        Mat pts_3(1, 4, CV_32FC3, _pts_3);
+
+        for( int i = 0; i < 4; i++ )
+        {
+            int j = (i<2) ? 0 : 1;
+            _pts[i].x = (float)((i % 2)*(nx-1));
+            _pts[i].y = (float)(j*(ny-1));
+        }
+        undistortPoints(pts, pts, A, Dk, Mat(), Mat());
+        convertPointsToHomogeneous(pts, pts_3);
+
+        // Change the camera matrix to have cc=[0,0] and fc = fc_new
+        double _a_tmp[3][3] = {{fc_new, 0, 0}, {0, fc_new, 0}, {0, 0, 1}};
+        Mat A_tmp(3, 3, CV_64F, _a_tmp);
+        projectPoints(pts_3, (k == 0 ? _R1 : _R2), Z, A_tmp, Mat(), pts);
+        Scalar avg = mean(pts);
+        cc_new[k].x = (nx-1)/2 - avg.val[0];
+        cc_new[k].y = (ny-1)/2 - avg.val[1];
+    }
+
+    // vertical focal length must be the same for both images to keep the epipolar constraint
+    // (for horizontal epipolar lines -- TBD: check for vertical epipolar lines)
+    // use fy for fx also, for simplicity
+
+    // For simplicity, set the principal points for both cameras to be the average
+    // of the two principal points (either one of or both x- and y- coordinates)
+    if( flags & STEREO_ZERO_DISPARITY )
+    {
+        cc_new[0].x = cc_new[1].x = (cc_new[0].x + cc_new[1].x)*0.5;
+        cc_new[0].y = cc_new[1].y = (cc_new[0].y + cc_new[1].y)*0.5;
+    }
+    else if( idx == 0 ) // horizontal stereo
+        cc_new[0].y = cc_new[1].y = (cc_new[0].y + cc_new[1].y)*0.5;
+    else // vertical stereo
+        cc_new[0].x = cc_new[1].x = (cc_new[0].x + cc_new[1].x)*0.5;
+
+    double t_idx = t.at<double>(idx);
+
+    Mat pp = Mat::zeros(3, 4, CV_64F);
+    pp.at<double>(0, 0) = pp.at<double>(1, 1) = fc_new;
+    pp.at<double>(0, 2) = cc_new[0].x;
+    pp.at<double>(1, 2) = cc_new[0].y;
+    pp.at<double>(2, 2) = 1.;
+    pp.copyTo(_P1);
+
+    pp.at<double>(0, 2) = cc_new[1].x;
+    pp.at<double>(1, 2) = cc_new[1].y;
+    pp.at<double>(idx, 3) = t_idx*fc_new; // baseline * focal length
+    pp.copyTo(_P2);
+
+    alpha = MIN(alpha, 1.);
+
+    cv::Rect_<double> inner1, inner2, outer1, outer2;
+    getUndistortRectangles(cameraMatrix1, distCoeffs1, _R1, _P1, imageSize, inner1, outer1);
+    getUndistortRectangles(cameraMatrix2, distCoeffs2, _R2, _P2, imageSize, inner2, outer2);
+
+    {
+    newImgSize = newImgSize.width*newImgSize.height != 0 ? newImgSize : imageSize;
+    double cx1_0 = cc_new[0].x;
+    double cy1_0 = cc_new[0].y;
+    double cx2_0 = cc_new[1].x;
+    double cy2_0 = cc_new[1].y;
+    double cx1 = newImgSize.width*cx1_0/imageSize.width;
+    double cy1 = newImgSize.height*cy1_0/imageSize.height;
+    double cx2 = newImgSize.width*cx2_0/imageSize.width;
+    double cy2 = newImgSize.height*cy2_0/imageSize.height;
+    double s = 1.;
+
+    if( alpha >= 0 )
+    {
+        double s0 = std::max(std::max(std::max((double)cx1/(cx1_0 - inner1.x), (double)cy1/(cy1_0 - inner1.y)),
+                            (double)(newImgSize.width - 1 - cx1)/(inner1.x + inner1.width - cx1_0)),
+                        (double)(newImgSize.height - 1 - cy1)/(inner1.y + inner1.height - cy1_0));
+        s0 = std::max(std::max(std::max(std::max((double)cx2/(cx2_0 - inner2.x), (double)cy2/(cy2_0 - inner2.y)),
+                         (double)(newImgSize.width - 1 - cx2)/(inner2.x + inner2.width - cx2_0)),
+                     (double)(newImgSize.height - 1 - cy2)/(inner2.y + inner2.height - cy2_0)),
+                 s0);
+
+        double s1 = std::min(std::min(std::min((double)cx1/(cx1_0 - outer1.x), (double)cy1/(cy1_0 - outer1.y)),
+                            (double)(newImgSize.width - 1 - cx1)/(outer1.x + outer1.width - cx1_0)),
+                        (double)(newImgSize.height - 1 - cy1)/(outer1.y + outer1.height - cy1_0));
+        s1 = std::min(std::min(std::min(std::min((double)cx2/(cx2_0 - outer2.x), (double)cy2/(cy2_0 - outer2.y)),
+                         (double)(newImgSize.width - 1 - cx2)/(outer2.x + outer2.width - cx2_0)),
+                     (double)(newImgSize.height - 1 - cy2)/(outer2.y + outer2.height - cy2_0)),
+                 s1);
+
+        s = s0*(1 - alpha) + s1*alpha;
+    }
+
+    fc_new *= s;
+    cc_new[0] = Point2d(cx1, cy1);
+    cc_new[1] = Point2d(cx2, cy2);
+
+    pp.at<double>(0, 0) = pp.at<double>(1, 1) = fc_new;
+    pp.at<double>(0, 2) = cx2;
+    pp.at<double>(1, 2) = cy2;
+    pp.at<double>(idx, 3) *= s;
+    pp.copyTo(_P2);
+
+    pp.at<double>(0, 2) = cx1;
+    pp.at<double>(1, 2) = cy1;
+    pp.at<double>(idx, 3) = 0.;
+    pp.copyTo(_P1);
+
+    if(roi1)
+    {
+        *roi1 =
+            cv::Rect(cvCeil((inner1.x - cx1_0)*s + cx1),
+                     cvCeil((inner1.y - cy1_0)*s + cy1),
+                     cvFloor(inner1.width*s), cvFloor(inner1.height*s))
+            & cv::Rect(0, 0, newImgSize.width, newImgSize.height)
+        ;
+    }
+
+    if(roi2)
+    {
+        *roi2 =
+            cv::Rect(cvCeil((inner2.x - cx2_0)*s + cx2),
+                     cvCeil((inner2.y - cy2_0)*s + cy2),
+                     cvFloor(inner2.width*s), cvFloor(inner2.height*s))
+            & cv::Rect(0, 0, newImgSize.width, newImgSize.height)
+        ;
+    }
+    }
+
+    if( _Qmat.needed() )
+    {
+        double q[] =
+        {
+            1, 0, 0, -cc_new[0].x,
+            0, 1, 0, -cc_new[0].y,
+            0, 0, 0, fc_new,
+            0, 0, -1./t_idx,
+            (idx == 0 ? cc_new[0].x - cc_new[1].x : cc_new[0].y - cc_new[1].y)/t_idx
+        };
+        Mat Q(4, 4, CV_64F, q);
+        Q.copyTo(_Qmat);
+    }
+}
+
+/*
+CV_IMPL int cvStereoRectifyUncalibrated(
+    const CvMat* _points1, const CvMat* _points2,
+    const CvMat* F0, CvSize imgSize,
+    CvMat* _H1, CvMat* _H2, double threshold )
+*/
+bool stereoRectifyUncalibrated( InputArray _points1, InputArray _points2,
+                                InputArray _Fmat, Size imgSize,
+                                OutputArray _Hmat1, OutputArray _Hmat2, double threshold )
+{
+    Mat points1 = _points1.getMat(), points2 = _points2.getMat();
+    CV_Assert( points1.size() == points2.size() );
+
+    int npoints = points1.checkVector(2);
+    CV_Assert(npoints > 0);
+
+    Mat _m1, _m2;
+
+    points1.convertTo(_m1, CV_64F);
+    points2.convertTo(_m2, CV_64F);
+    _m1 = _m1.reshape(2, 1);
+    _m2 = _m2.reshape(2, 1);
+
+    Mat F0 = _Fmat.getMat(), F, Wdiag, U, Vt;
+    F0.convertTo(F, CV_64F);
+
+    SVDecomp(F, Wdiag, U, Vt, 0);
+    Wdiag.at<double>(2) = 0.;
+    Mat W = Mat::diag(Wdiag), UW;
+    gemm(U, W, 1, Mat(), 0, UW);
+    gemm(UW, Vt, 1, Mat(), 0, F);
+
+    double cx = cvRound( (imgSize.width-1)*0.5 );
+    double cy = cvRound( (imgSize.height-1)*0.5 );
+
+    if( threshold > 0 )
+    {
+        Mat _lines1, _lines2;
+        computeCorrespondEpilines(_m1, 1, F, _lines1);
+        computeCorrespondEpilines(_m2, 2, F, _lines2);
+        CV_Assert(_m1.isContinuous() && _m2.isContinuous() &&
+                  _lines1.isContinuous() && _lines2.isContinuous());
+        Point2d* m1 = (Point2d*)_m1.data;
+        Point2d* m2 = (Point2d*)_m2.data;
+        Point3d* lines1 = (Point3d*)_lines1.data;
+        Point3d* lines2 = (Point3d*)_lines2.data;
+
+        // measure distance from points to the corresponding epilines, mark outliers
+        int i, j;
+        for( i = j = 0; i < npoints; i++ )
+        {
+            if( fabs(m1[i].x*lines2[i].x +
+                     m1[i].y*lines2[i].y +
+                     lines2[i].z) <= threshold &&
+                fabs(m2[i].x*lines1[i].x +
+                     m2[i].y*lines1[i].y +
+                     lines1[i].z) <= threshold )
+            {
+                if( j < i )
+                {
+                    m1[j] = m1[i];
+                    m2[j] = m2[i];
+                }
+                j++;
+            }
+        }
+
+        npoints = j;
+        if( npoints == 0 )
+            return false;
+        _m1.cols = _m2.cols = npoints;
+    }
+
+    Mat E2 = U.col(2).clone();
+    if (E2.at<double>(2) < 0)
+        E2 *= -1.0;
+
+    double t[] =
+    {
+        1, 0, -cx,
+        0, 1, -cy,
+        0, 0, 1
+    };
+    Mat T(3, 3, CV_64F, t);
+    E2 = T*E2;
+
+    double* e2 = (double*)E2.data;
+    int mirror = e2[0] < 0;
+    double d = std::sqrt(e2[0]*e2[0] + e2[1]*e2[1]);
+    d = MAX(d, DBL_EPSILON);
+    double alpha = e2[0]/d;
+    double beta = e2[1]/d;
+    double r[] =
+    {
+        alpha, beta, 0,
+        -beta, alpha, 0,
+        0, 0, 1
+    };
+    Mat R(3, 3, CV_64F, r);
+    T = R*T;
+    E2 = R*E2;
+    double invf = fabs(e2[2]) < 1e-6*fabs(e2[0]) ? 0 : -e2[2]/e2[0];
+    double k[] =
+    {
+        1, 0, 0,
+        0, 1, 0,
+        invf, 0, 1
+    };
+    Mat K(3, 3, CV_64F, k);
+    Mat H2 = K*T;
+    E2 = K*E2;
+
+    double it[] =
+    {
+        1, 0, cx,
+        0, 1, cy,
+        0, 0, 1
+    };
+    Mat iT( 3, 3, CV_64F, it );
+    H2 = iT*H2;
+
+    U.col(2).copyTo(E2);
+    if (E2.at<double>(2) < 0)
+        E2 *= -1.0;
+
+    double e2_x[] =
+    {
+        0, -e2[2], e2[1],
+       e2[2], 0, -e2[0],
+       -e2[1], e2[0], 0
+    };
+    double e2_111[] =
+    {
+        e2[0], e2[0], e2[0],
+        e2[1], e2[1], e2[1],
+        e2[2], e2[2], e2[2],
+    };
+    Mat E2_x(3, 3, CV_64F, e2_x);
+    Mat E2_111(3, 3, CV_64F, e2_111);
+    Mat H0 = E2_x*F + E2_111;
+    H0 = H2*H0;
+    Mat E1(3, 1, CV_64F, (double*)Vt.data+6);
+    E1 = H0*E1;
+
+    perspectiveTransform( _m1, _m1, H0 );
+    perspectiveTransform( _m2, _m2, H2 );
+    Mat A, X;
+    convertPointsToHomogeneous(_m1, A, CV_64F);
+    A = A.reshape(1, npoints);
+    Mat BxBy = _m2.reshape(1, npoints);
+    Mat B = BxBy.col(0);
+    solve(A, B, X, DECOMP_SVD);
+    CV_Assert(X.isContinuous());
+    double* x = X.ptr<double>();
+
+    double ha[] =
+    {
+        x[0], x[1], x[2],
+        0, 1, 0,
+        0, 0, 1
+    };
+    Mat Ha(3, 3, CV_64F, ha);
+    Mat H1 = Ha*H0;
+    perspectiveTransform( _m1, _m1, Ha );
+
+    if( mirror )
+    {
+        double mm[] = { -1, 0, cx*2, 0, -1, cy*2, 0, 0, 1 };
+        Mat MM(3, 3, CV_64F, mm);
+        H1 = MM*H1;
+        H2 = MM*H2;
+    }
+
+    H1.copyTo(_Hmat1);
+    H2.copyTo(_Hmat2);
+    return true;
+}
+
+
+static void adjust3rdMatrix(InputArrayOfArrays _imgpt1_0,
+                            InputArrayOfArrays _imgpt3_0,
+                            const Mat& cameraMatrix1, const Mat& distCoeffs1,
+                            const Mat& cameraMatrix3, const Mat& distCoeffs3,
+                            const Mat& R1, const Mat& R3, const Mat& P1, Mat& P3 )
+{
+    size_t n1 = _imgpt1_0.total(), n3 = _imgpt3_0.total();
+    std::vector<Point2f> imgpt1, imgpt3;
+
+    for( int i = 0; i < (int)std::min(n1, n3); i++ )
+    {
+        Mat pt1 = _imgpt1_0.getMat(i), pt3 = _imgpt3_0.getMat(i);
+        int ni1 = pt1.checkVector(2, CV_32F), ni3 = pt3.checkVector(2, CV_32F);
+        CV_Assert( ni1 > 0 && ni1 == ni3 );
+        const Point2f* pt1data = pt1.ptr<Point2f>();
+        const Point2f* pt3data = pt3.ptr<Point2f>();
+        std::copy(pt1data, pt1data + ni1, std::back_inserter(imgpt1));
+        std::copy(pt3data, pt3data + ni3, std::back_inserter(imgpt3));
+    }
+
+    undistortPoints(imgpt1, imgpt1, cameraMatrix1, distCoeffs1, R1, P1);
+    undistortPoints(imgpt3, imgpt3, cameraMatrix3, distCoeffs3, R3, P3);
+
+    double y1_ = 0, y2_ = 0, y1y1_ = 0, y1y2_ = 0;
+    size_t n = imgpt1.size();
+    CV_DbgAssert(n > 0);
+
+    for( size_t i = 0; i < n; i++ )
+    {
+        double y1 = imgpt3[i].y, y2 = imgpt1[i].y;
+
+        y1_ += y1; y2_ += y2;
+        y1y1_ += y1*y1; y1y2_ += y1*y2;
+    }
+
+    y1_ /= n;
+    y2_ /= n;
+    y1y1_ /= n;
+    y1y2_ /= n;
+
+    double a = (y1y2_ - y1_*y2_)/(y1y1_ - y1_*y1_);
+    double b = y2_ - a*y1_;
+
+    P3.at<double>(0,0) *= a;
+    P3.at<double>(1,1) *= a;
+    P3.at<double>(0,2) = P3.at<double>(0,2)*a;
+    P3.at<double>(1,2) = P3.at<double>(1,2)*a + b;
+    P3.at<double>(0,3) *= a;
+    P3.at<double>(1,3) *= a;
+}
+
+float rectify3Collinear( InputArray _cameraMatrix1, InputArray _distCoeffs1,
+                   InputArray _cameraMatrix2, InputArray _distCoeffs2,
+                   InputArray _cameraMatrix3, InputArray _distCoeffs3,
+                   InputArrayOfArrays _imgpt1,
+                   InputArrayOfArrays _imgpt3,
+                   Size imageSize, InputArray _Rmat12, InputArray _Tmat12,
+                   InputArray _Rmat13, InputArray _Tmat13,
+                   OutputArray _Rmat1, OutputArray _Rmat2, OutputArray _Rmat3,
+                   OutputArray _Pmat1, OutputArray _Pmat2, OutputArray _Pmat3,
+                   OutputArray _Qmat,
+                   double alpha, Size newImgSize,
+                   Rect* roi1, Rect* roi2, int flags )
+{
+    // first, rectify the 1-2 stereo pair
+    stereoRectify( _cameraMatrix1, _distCoeffs1, _cameraMatrix2, _distCoeffs2,
+                   imageSize, _Rmat12, _Tmat12, _Rmat1, _Rmat2, _Pmat1, _Pmat2, _Qmat,
+                   flags, alpha, newImgSize, roi1, roi2 );
+
+    Mat R12 = _Rmat12.getMat(), R13 = _Rmat13.getMat(), T12 = _Tmat12.getMat(), T13 = _Tmat13.getMat();
+
+    _Rmat3.create(3, 3, CV_64F);
+    _Pmat3.create(3, 4, CV_64F);
+
+    Mat P1 = _Pmat1.getMat(), P2 = _Pmat2.getMat();
+    Mat R3 = _Rmat3.getMat(), P3 = _Pmat3.getMat();
+
+    // recompute rectification transforms for cameras 1 & 2.
+    Mat om, r_r, r_r13;
+
+    if( R13.size() != Size(3,3) )
+        Rodrigues(R13, r_r13);
+    else
+        R13.copyTo(r_r13);
+
+    if( R12.size() == Size(3,3) )
+        Rodrigues(R12, om);
+    else
+        R12.copyTo(om);
+
+    om *= -0.5;
+    Rodrigues(om, r_r); // rotate cameras to same orientation by averaging
+    Mat_<double> t12 = r_r * T12;
+
+    int idx = fabs(t12(0,0)) > fabs(t12(1,0)) ? 0 : 1;
+    double c = t12(idx,0), nt = norm(t12, NORM_L2);
+    CV_Assert(fabs(nt) > 0);
+    Mat_<double> uu = Mat_<double>::zeros(3,1);
+    uu(idx, 0) = c > 0 ? 1 : -1;
+
+    // calculate global Z rotation
+    Mat_<double> ww = t12.cross(uu), wR;
+    double nw = norm(ww, NORM_L2);
+    CV_Assert(fabs(nw) > 0);
+    ww *= std::acos(fabs(c)/nt)/nw;
+    Rodrigues(ww, wR);
+
+    // now rotate camera 3 to make its optical axis parallel to cameras 1 and 2.
+    R3 = wR*r_r.t()*r_r13.t();
+    Mat_<double> t13 = R3 * T13;
+
+    P2.copyTo(P3);
+    Mat t = P3.col(3);
+    t13.copyTo(t);
+    P3.at<double>(0,3) *= P3.at<double>(0,0);
+    P3.at<double>(1,3) *= P3.at<double>(1,1);
+
+    if( !_imgpt1.empty() && !_imgpt3.empty() )
+        adjust3rdMatrix(_imgpt1, _imgpt3, _cameraMatrix1.getMat(), _distCoeffs1.getMat(),
+                        _cameraMatrix3.getMat(), _distCoeffs3.getMat(), _Rmat1.getMat(), R3, P1, P3);
+
+    return (float)((P3.at<double>(idx,3)/P3.at<double>(idx,idx))/
+                   (P2.at<double>(idx,3)/P2.at<double>(idx,idx)));
+}
+
+void cv::fisheye::stereoRectify( InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size& imageSize,
+        InputArray _R, InputArray _tvec, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2,
+        OutputArray Q, int flags, const Size& newImageSize, double balance, double fov_scale)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert((_R.size() == Size(3, 3) || _R.total() * _R.channels() == 3) && (_R.depth() == CV_32F || _R.depth() == CV_64F));
+    CV_Assert(_tvec.total() * _tvec.channels() == 3 && (_tvec.depth() == CV_32F || _tvec.depth() == CV_64F));
+
+
+    Mat aaa = _tvec.getMat().reshape(3, 1);
+
+    Vec3d rvec; // Rodrigues vector
+    if (_R.size() == Size(3, 3))
+    {
+        Matx33d rmat;
+        _R.getMat().convertTo(rmat, CV_64F);
+        rvec = Affine3d(rmat).rvec();
+    }
+    else if (_R.total() * _R.channels() == 3)
+        _R.getMat().convertTo(rvec, CV_64F);
+
+    Vec3d tvec;
+    _tvec.getMat().convertTo(tvec, CV_64F);
+
+    // rectification algorithm
+    rvec *= -0.5;              // get average rotation
+
+    Matx33d r_r;
+    Rodrigues(rvec, r_r);  // rotate cameras to same orientation by averaging
+
+    Vec3d t = r_r * tvec;
+    Vec3d uu(t[0] > 0 ? 1 : -1, 0, 0);
+
+    // calculate global Z rotation
+    Vec3d ww = t.cross(uu);
+    double nw = norm(ww);
+    if (nw > 0.0)
+        ww *= std::acos(fabs(t[0])/cv::norm(t))/nw;
+
+    Matx33d wr;
+    Rodrigues(ww, wr);
+
+    // apply to both views
+    Matx33d ri1 = wr * r_r.t();
+    Mat(ri1, false).convertTo(R1, R1.empty() ? CV_64F : R1.type());
+    Matx33d ri2 = wr * r_r;
+    Mat(ri2, false).convertTo(R2, R2.empty() ? CV_64F : R2.type());
+    Vec3d tnew = ri2 * tvec;
+
+    // calculate projection/camera matrices. these contain the relevant rectified image internal params (fx, fy=fx, cx, cy)
+    Matx33d newK1, newK2;
+    fisheye::estimateNewCameraMatrixForUndistortRectify(K1, D1, imageSize, R1, newK1, balance, newImageSize, fov_scale);
+    fisheye::estimateNewCameraMatrixForUndistortRectify(K2, D2, imageSize, R2, newK2, balance, newImageSize, fov_scale);
+
+    double fc_new = std::min(newK1(1,1), newK2(1,1));
+    Point2d cc_new[2] = { Vec2d(newK1(0, 2), newK1(1, 2)), Vec2d(newK2(0, 2), newK2(1, 2)) };
+
+    // Vertical focal length must be the same for both images to keep the epipolar constraint use fy for fx also.
+    // For simplicity, set the principal points for both cameras to be the average
+    // of the two principal points (either one of or both x- and y- coordinates)
+    if( flags & STEREO_ZERO_DISPARITY )
+        cc_new[0] = cc_new[1] = (cc_new[0] + cc_new[1]) * 0.5;
+    else
+        cc_new[0].y = cc_new[1].y = (cc_new[0].y + cc_new[1].y)*0.5;
+
+    Mat(Matx34d(fc_new, 0, cc_new[0].x, 0,
+                0, fc_new, cc_new[0].y, 0,
+                0,      0,           1, 0), false).convertTo(P1, P1.empty() ? CV_64F : P1.type());
+
+    Mat(Matx34d(fc_new, 0, cc_new[1].x, tnew[0]*fc_new, // baseline * focal length;,
+                0, fc_new, cc_new[1].y,              0,
+                0,      0,           1,              0), false).convertTo(P2, P2.empty() ? CV_64F : P2.type());
+
+    if (Q.needed())
+        Mat(Matx44d(1, 0, 0,           -cc_new[0].x,
+                    0, 1, 0,           -cc_new[0].y,
+                    0, 0, 0,            fc_new,
+                    0, 0, -1./tnew[0], (cc_new[0].x - cc_new[1].x)/tnew[0]), false).convertTo(Q, Q.empty() ? CV_64F : Q.depth());
+}
+
+}
diff --git a/upstream/opencv/modules/stereo/src/stereobm.cpp b/upstream/opencv/modules/stereo/src/stereobm.cpp
new file mode 100644
index 0000000..2b3aeab
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/stereobm.cpp
@@ -0,0 +1,1393 @@
+//M*//////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/****************************************************************************************\
+*    Very fast SAD-based (Sum-of-Absolute-Diffrences) stereo correspondence algorithm.   *
+*    Contributed by Kurt Konolige                                                        *
+\****************************************************************************************/
+
+#include "precomp.hpp"
+#include <stdio.h>
+#include <limits>
+#include <vector>
+#include "opencl_kernels_stereo.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/core/utils/buffer_area.private.hpp"
+
+namespace cv {
+
+struct StereoBMParams
+{
+    StereoBMParams(int _numDisparities=64, int _SADWindowSize=21)
+    {
+        preFilterType = StereoBM::PREFILTER_XSOBEL;
+        preFilterSize = 9;
+        preFilterCap = 31;
+        SADWindowSize = _SADWindowSize;
+        minDisparity = 0;
+        numDisparities = _numDisparities > 0 ? _numDisparities : 64;
+        textureThreshold = 10;
+        uniquenessRatio = 15;
+        speckleRange = speckleWindowSize = 0;
+        roi1 = roi2 = Rect(0,0,0,0);
+        disp12MaxDiff = -1;
+        dispType = CV_16S;
+    }
+
+    int preFilterType;
+    int preFilterSize;
+    int preFilterCap;
+    int SADWindowSize;
+    int minDisparity;
+    int numDisparities;
+    int textureThreshold;
+    int uniquenessRatio;
+    int speckleRange;
+    int speckleWindowSize;
+    Rect roi1, roi2;
+    int disp12MaxDiff;
+    int dispType;
+
+    inline bool useShorts() const
+    {
+        return preFilterCap <= 31 && SADWindowSize <= 21;
+    }
+    inline bool useFilterSpeckles() const
+    {
+        return speckleRange >= 0 && speckleWindowSize > 0;
+    }
+    inline bool useNormPrefilter() const
+    {
+        return preFilterType == StereoBM::PREFILTER_NORMALIZED_RESPONSE;
+    }
+};
+
+#ifdef HAVE_OPENCL
+static bool ocl_prefilter_norm(InputArray _input, OutputArray _output, int winsize, int prefilterCap)
+{
+    ocl::Kernel k("prefilter_norm", ocl::stereo::stereobm_oclsrc, format("-D WSZ=%d", winsize));
+    if(k.empty())
+        return false;
+
+    int scale_g = winsize*winsize/8, scale_s = (1024 + scale_g)/(scale_g*2);
+    scale_g *= scale_s;
+
+    UMat input = _input.getUMat(), output;
+    _output.create(input.size(), input.type());
+    output = _output.getUMat();
+
+    size_t globalThreads[3] = { (size_t)input.cols, (size_t)input.rows, 1 };
+
+    k.args(ocl::KernelArg::PtrReadOnly(input), ocl::KernelArg::PtrWriteOnly(output), input.rows, input.cols,
+        prefilterCap, scale_g, scale_s);
+
+    return k.run(2, globalThreads, NULL, false);
+}
+#endif
+
+static void prefilterNorm( const Mat& src, Mat& dst, int winsize, int ftzero, int *buf )
+{
+    int x, y, wsz2 = winsize/2;
+    int* vsum = buf + (wsz2 + 1);
+    int scale_g = winsize*winsize/8, scale_s = (1024 + scale_g)/(scale_g*2);
+    const int OFS = 256*5, TABSZ = OFS*2 + 256;
+    uchar tab[TABSZ];
+    const uchar* sptr = src.ptr();
+    int srcstep = (int)src.step;
+    Size size = src.size();
+
+    scale_g *= scale_s;
+
+    for( x = 0; x < TABSZ; x++ )
+        tab[x] = (uchar)(x - OFS < -ftzero ? 0 : x - OFS > ftzero ? ftzero*2 : x - OFS + ftzero);
+
+    for( x = 0; x < size.width; x++ )
+        vsum[x] = (ushort)(sptr[x]*(wsz2 + 2));
+
+    for( y = 1; y < wsz2; y++ )
+    {
+        for( x = 0; x < size.width; x++ )
+            vsum[x] = (ushort)(vsum[x] + sptr[srcstep*y + x]);
+    }
+
+    for( y = 0; y < size.height; y++ )
+    {
+        const uchar* top = sptr + srcstep*MAX(y-wsz2-1,0);
+        const uchar* bottom = sptr + srcstep*MIN(y+wsz2,size.height-1);
+        const uchar* prev = sptr + srcstep*MAX(y-1,0);
+        const uchar* curr = sptr + srcstep*y;
+        const uchar* next = sptr + srcstep*MIN(y+1,size.height-1);
+        uchar* dptr = dst.ptr<uchar>(y);
+
+        for( x = 0; x < size.width; x++ )
+            vsum[x] = (ushort)(vsum[x] + bottom[x] - top[x]);
+
+        for( x = 0; x <= wsz2; x++ )
+        {
+            vsum[-x-1] = vsum[0];
+            vsum[size.width+x] = vsum[size.width-1];
+        }
+
+        int sum = vsum[0]*(wsz2 + 1);
+        for( x = 1; x <= wsz2; x++ )
+            sum += vsum[x];
+
+        int val = ((curr[0]*5 + curr[1] + prev[0] + next[0])*scale_g - sum*scale_s) >> 10;
+        dptr[0] = tab[val + OFS];
+
+        for( x = 1; x < size.width-1; x++ )
+        {
+            sum += vsum[x+wsz2] - vsum[x-wsz2-1];
+            val = ((curr[x]*4 + curr[x-1] + curr[x+1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10;
+            dptr[x] = tab[val + OFS];
+        }
+
+        sum += vsum[x+wsz2] - vsum[x-wsz2-1];
+        val = ((curr[x]*5 + curr[x-1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10;
+        dptr[x] = tab[val + OFS];
+    }
+}
+
+#ifdef HAVE_OPENCL
+static bool ocl_prefilter_xsobel(InputArray _input, OutputArray _output, int prefilterCap)
+{
+    ocl::Kernel k("prefilter_xsobel", ocl::stereo::stereobm_oclsrc);
+    if(k.empty())
+        return false;
+
+    UMat input = _input.getUMat(), output;
+    _output.create(input.size(), input.type());
+    output = _output.getUMat();
+
+    size_t globalThreads[3] = { (size_t)input.cols, (size_t)input.rows, 1 };
+
+    k.args(ocl::KernelArg::PtrReadOnly(input), ocl::KernelArg::PtrWriteOnly(output), input.rows, input.cols, prefilterCap);
+
+    return k.run(2, globalThreads, NULL, false);
+}
+#endif
+
+static void
+prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
+{
+    int x, y;
+    const int OFS = 256*4, TABSZ = OFS*2 + 256;
+    uchar tab[TABSZ] = { 0 };
+    Size size = src.size();
+
+    for( x = 0; x < TABSZ; x++ )
+        tab[x] = (uchar)(x - OFS < -ftzero ? 0 : x - OFS > ftzero ? ftzero*2 : x - OFS + ftzero);
+    uchar val0 = tab[0 + OFS];
+
+    for( y = 0; y < size.height-1; y += 2 )
+    {
+        const uchar* srow1 = src.ptr<uchar>(y);
+        const uchar* srow0 = y > 0 ? srow1 - src.step : size.height > 1 ? srow1 + src.step : srow1;
+        const uchar* srow2 = y < size.height-1 ? srow1 + src.step : size.height > 1 ? srow1 - src.step : srow1;
+        const uchar* srow3 = y < size.height-2 ? srow1 + src.step*2 : srow1;
+        uchar* dptr0 = dst.ptr<uchar>(y);
+        uchar* dptr1 = dptr0 + dst.step;
+
+        dptr0[0] = dptr0[size.width-1] = dptr1[0] = dptr1[size.width-1] = val0;
+        x = 1;
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+        {
+            v_int16 ftz = vx_setall_s16((short) ftzero);
+            v_int16 ftz2 = vx_setall_s16((short)(ftzero*2));
+            v_int16 z = vx_setzero_s16();
+
+            for(; x <= (size.width - 1) - VTraits<v_int16>::vlanes(); x += VTraits<v_int16>::vlanes())
+            {
+                v_int16 s00 = v_reinterpret_as_s16(vx_load_expand(srow0 + x + 1));
+                v_int16 s01 = v_reinterpret_as_s16(vx_load_expand(srow0 + x - 1));
+                v_int16 s10 = v_reinterpret_as_s16(vx_load_expand(srow1 + x + 1));
+                v_int16 s11 = v_reinterpret_as_s16(vx_load_expand(srow1 + x - 1));
+                v_int16 s20 = v_reinterpret_as_s16(vx_load_expand(srow2 + x + 1));
+                v_int16 s21 = v_reinterpret_as_s16(vx_load_expand(srow2 + x - 1));
+                v_int16 s30 = v_reinterpret_as_s16(vx_load_expand(srow3 + x + 1));
+                v_int16 s31 = v_reinterpret_as_s16(vx_load_expand(srow3 + x - 1));
+
+                v_int16 d0 = v_sub(s00, s01);
+                v_int16 d1 = v_sub(s10, s11);
+                v_int16 d2 = v_sub(s20, s21);
+                v_int16 d3 = v_sub(s30, s31);
+
+                v_uint16 v0 = v_reinterpret_as_u16(v_max(v_min(v_add(v_add(v_add(v_add(d0, d1), d1), d2), ftz), ftz2), z));
+                v_uint16 v1 = v_reinterpret_as_u16(v_max(v_min(v_add(v_add(v_add(v_add(d1, d2), d2), d3), ftz), ftz2), z));
+
+                v_pack_store(dptr0 + x, v0);
+                v_pack_store(dptr1 + x, v1);
+            }
+        }
+#endif
+
+        for( ; x < size.width-1; x++ )
+        {
+            int d0 = srow0[x+1] - srow0[x-1], d1 = srow1[x+1] - srow1[x-1],
+            d2 = srow2[x+1] - srow2[x-1], d3 = srow3[x+1] - srow3[x-1];
+            int v0 = tab[d0 + d1*2 + d2 + OFS];
+            int v1 = tab[d1 + d2*2 + d3 + OFS];
+            dptr0[x] = (uchar)v0;
+            dptr1[x] = (uchar)v1;
+        }
+    }
+
+    for( ; y < size.height; y++ )
+    {
+        uchar* dptr = dst.ptr<uchar>(y);
+        x = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+        {
+            v_uint8 val0_16 = vx_setall_u8(val0);
+            for(; x <= size.width-VTraits<v_uint8>::vlanes(); x+=VTraits<v_uint8>::vlanes())
+                v_store(dptr + x, val0_16);
+        }
+#endif
+        for(; x < size.width; x++ )
+            dptr[x] = val0;
+    }
+}
+
+
+static const int DISPARITY_SHIFT_16S = 4;
+static const int DISPARITY_SHIFT_32S = 8;
+
+template <typename T>
+struct dispShiftTemplate
+{ };
+
+template<>
+struct dispShiftTemplate<short>
+{
+    enum { value = DISPARITY_SHIFT_16S };
+};
+
+template<>
+struct dispShiftTemplate<int>
+{
+    enum { value = DISPARITY_SHIFT_32S };
+};
+
+template <typename T>
+inline T dispDescale(int /*v1*/, int /*v2*/, int /*d*/);
+
+template<>
+inline short dispDescale(int v1, int v2, int d)
+{
+    return (short)((v1*256 + (d != 0 ? v2*256/d : 0) + 15) >> 4);
+}
+
+template <>
+inline int dispDescale(int v1, int v2, int d)
+{
+    return (int)(v1*256 + (d != 0 ? v2*256/d : 0)); // no need to add 127, this will be converted to float
+}
+
+
+class BufferBM
+{
+    static const int TABSZ = 256;
+public:
+    std::vector<int*> sad;
+    std::vector<int*> hsad;
+    std::vector<int*> htext;
+    std::vector<uchar*> cbuf0;
+    std::vector<ushort*> sad_short;
+    std::vector<ushort*> hsad_short;
+    int *prefilter[2];
+    uchar tab[TABSZ];
+private:
+    utils::BufferArea area;
+
+public:
+    BufferBM(size_t nstripes, size_t width, size_t height, const StereoBMParams& params)
+        : sad(nstripes, NULL),
+        hsad(nstripes, NULL),
+        htext(nstripes, NULL),
+        cbuf0(nstripes, NULL),
+        sad_short(nstripes, NULL),
+        hsad_short(nstripes, NULL),
+        prefilter()
+    {
+        const int wsz = params.SADWindowSize;
+        const int ndisp = params.numDisparities;
+        const int ftzero = params.preFilterCap;
+        for (size_t i = 0; i < nstripes; ++i)
+        {
+            // 1D: [1][  ndisp  ][1]
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            if (params.useShorts())
+                area.allocate(sad_short[i], ndisp + 2);
+            else
+#endif
+                area.allocate(sad[i], ndisp + 2);
+
+            // 2D: [ wsz/2 + 1 ][   height   ][ wsz/2 + 1 ] * [ ndisp ]
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            if (params.useShorts())
+                area.allocate(hsad_short[i], (height + wsz + 2) * ndisp);
+            else
+#endif
+                area.allocate(hsad[i], (height + wsz + 2) * ndisp);
+
+            // 1D: [ wsz/2 + 1 ][   height   ][ wsz/2 + 1 ]
+            area.allocate(htext[i], (height + wsz + 2));
+
+            // 3D: [ wsz/2 + 1 ][   height   ][ wsz/2 + 1 ] * [ ndisp ] * [ wsz/2 + 1 ][ wsz/2 + 1 ]
+            area.allocate(cbuf0[i], ((height + wsz + 2) * ndisp * (wsz + 2) + 256));
+        }
+        if (params.useNormPrefilter())
+        {
+            for (size_t i = 0; i < 2; ++i)
+                area.allocate(prefilter[i], width + params.preFilterSize + 2);
+        }
+        area.commit();
+
+        // static table
+        for (int x = 0; x < TABSZ; x++)
+            tab[x] = (uchar)std::abs(x - ftzero);
+    }
+};
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+template <typename dType>
+static void findStereoCorrespondenceBM_SIMD( const Mat& left, const Mat& right,
+                                            Mat& disp, Mat& cost, const StereoBMParams& state,
+                                            int _dy0, int _dy1, const BufferBM & bufX, size_t bufNum )
+{
+    int x, y, d;
+    int wsz = state.SADWindowSize, wsz2 = wsz/2;
+    int dy0 = MIN(_dy0, wsz2+1), dy1 = MIN(_dy1, wsz2+1);
+    int ndisp = state.numDisparities;
+    int mindisp = state.minDisparity;
+    int lofs = MAX(ndisp - 1 + mindisp, 0);
+    int rofs = -MIN(ndisp - 1 + mindisp, 0);
+    int width = left.cols, height = left.rows;
+    int width1 = width - rofs - ndisp + 1;
+    int textureThreshold = state.textureThreshold;
+    int uniquenessRatio = state.uniquenessRatio;
+    const int disp_shift = dispShiftTemplate<dType>::value;
+    dType FILTERED = (dType)((mindisp - 1) << disp_shift);
+
+    ushort *hsad, *hsad_sub;
+    uchar *cbuf;
+    const uchar* lptr0 = left.ptr() + lofs;
+    const uchar* rptr0 = right.ptr() + rofs;
+    const uchar *lptr, *lptr_sub, *rptr;
+    dType* dptr = disp.ptr<dType>();
+    int sstep = (int)left.step;
+    int dstep = (int)(disp.step/sizeof(dptr[0]));
+    int cstep = (height + dy0 + dy1)*ndisp;
+    short costbuf = 0;
+    int coststep = cost.data ? (int)(cost.step/sizeof(costbuf)) : 0;
+    const uchar * tab = bufX.tab;
+    short v_seq[VTraits<v_int16>::max_nlanes];
+    for (short i = 0; i < VTraits<v_int16>::vlanes(); ++i)
+        v_seq[i] = i;
+
+    ushort *sad = bufX.sad_short[bufNum] + 1;
+    ushort *hsad0 = bufX.hsad_short[bufNum] + (wsz2 + 1) * ndisp;
+    int *htext = bufX.htext[bufNum] + (wsz2 + 1);
+    uchar *cbuf0 = bufX.cbuf0[bufNum] + (wsz2 + 1) * ndisp;
+
+    // initialize buffers
+    memset(sad - 1, 0, (ndisp + 2) * sizeof(sad[0]));
+    memset(hsad0 - dy0 * ndisp, 0, (height + wsz + 2) * ndisp * sizeof(hsad[0]));
+    memset(htext - dy0, 0, (height + wsz + 2) * sizeof(htext[0]));
+
+    for( x = -wsz2-1; x < wsz2; x++ )
+    {
+        hsad = hsad0 - dy0*ndisp; cbuf = cbuf0 + (x + wsz2 + 1)*cstep - dy0*ndisp;
+        lptr = lptr0 + MIN(MAX(x, -lofs), width-lofs-1) - dy0*sstep;
+        rptr = rptr0 + MIN(MAX(x, -rofs), width-rofs-ndisp) - dy0*sstep;
+
+        for( y = -dy0; y < height + dy1; y++, hsad += ndisp, cbuf += ndisp, lptr += sstep, rptr += sstep )
+        {
+            int lval = lptr[0];
+            v_uint8 lv = vx_setall_u8((uchar)lval);
+            for( d = 0; d <= ndisp - VTraits<v_uint8>::vlanes(); d += VTraits<v_uint8>::vlanes() )
+            {
+                v_uint8 diff = v_absdiff(lv, vx_load(rptr + d));
+                v_store(cbuf + d, diff);
+                v_store(hsad + d, v_add(vx_load(hsad + d), v_expand_low(diff)));
+                v_store(hsad + d + VTraits<v_uint16>::vlanes(), v_add(vx_load(hsad + d + VTraits<v_uint16>::vlanes()), v_expand_high(diff)));
+            }
+            if( d <= ndisp - VTraits<v_uint16>::vlanes() )
+            {
+                v_uint8 diff = v_absdiff(lv, vx_load_low(rptr + d));
+                v_store_low(cbuf + d, diff);
+                v_store(hsad + d, v_add(vx_load(hsad + d), v_expand_low(diff)));
+                d += VTraits<v_uint16>::vlanes();
+            }
+            for( ; d < ndisp; d++ )
+            {
+                int diff = abs(lval - rptr[d]);
+                cbuf[d] = (uchar)diff;
+                hsad[d] += (ushort)diff;
+            }
+            htext[y] += tab[lval];
+        }
+    }
+
+    // initialize the left and right borders of the disparity map
+    for( y = 0; y < height; y++ )
+    {
+        for( x = 0; x < lofs; x++ )
+            dptr[y*dstep + x] = FILTERED;
+        for( x = lofs + width1; x < width; x++ )
+            dptr[y*dstep + x] = FILTERED;
+    }
+    dptr += lofs;
+
+    for( x = 0; x < width1; x++, dptr++ )
+    {
+        short* costptr = cost.data ? cost.ptr<short>() + lofs + x : &costbuf;
+        int x0 = x - wsz2 - 1, x1 = x + wsz2;
+        const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        hsad = hsad0 - dy0*ndisp;
+        lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
+        lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
+        rptr = rptr0 + MIN(MAX(x1, -rofs), width-ndisp-rofs) - dy0*sstep;
+
+        for( y = -dy0; y < height + dy1; y++, cbuf += ndisp, cbuf_sub += ndisp,
+            hsad += ndisp, lptr += sstep, lptr_sub += sstep, rptr += sstep )
+        {
+            int lval = lptr[0];
+            v_uint8 lv = vx_setall_u8((uchar)lval);
+            for( d = 0; d <= ndisp - VTraits<v_uint8>::vlanes(); d += VTraits<v_uint8>::vlanes() )
+            {
+                v_uint8 diff = v_absdiff(lv, vx_load(rptr + d));
+                v_int8 cbs = v_reinterpret_as_s8(vx_load(cbuf_sub + d));
+                v_store(cbuf + d, diff);
+                v_store(hsad + d, v_reinterpret_as_u16(v_sub(v_reinterpret_as_s16(v_add(vx_load(hsad + d), v_expand_low(diff))), v_expand_low(cbs))));
+                v_store(hsad + d + VTraits<v_uint16>::vlanes(), v_reinterpret_as_u16(v_sub(v_reinterpret_as_s16(v_add(vx_load(hsad + d + VTraits<v_uint16>::vlanes()), v_expand_high(diff))), v_expand_high(cbs))));
+            }
+            if( d <= ndisp - VTraits<v_uint16>::vlanes())
+            {
+                v_uint8 diff = v_absdiff(lv, vx_load_low(rptr + d));
+                v_store_low(cbuf + d, diff);
+                v_store(hsad + d, v_reinterpret_as_u16(v_sub(v_reinterpret_as_s16(v_add(vx_load(hsad + d), v_expand_low(diff))), vx_load_expand((schar *)cbuf_sub + d))));
+                d += VTraits<v_uint16>::vlanes();
+            }
+            for( ; d < ndisp; d++ )
+            {
+                int diff = abs(lval - rptr[d]);
+                cbuf[d] = (uchar)diff;
+                hsad[d] = hsad[d] + (ushort)diff - cbuf_sub[d];
+            }
+            htext[y] += tab[lval] - tab[lptr_sub[0]];
+        }
+
+        // fill borders
+        for( y = dy1; y <= wsz2; y++ )
+            htext[height+y] = htext[height+dy1-1];
+        for( y = -wsz2-1; y < -dy0; y++ )
+            htext[y] = htext[-dy0];
+
+        // initialize sums
+        for( d = 0; d < ndisp; d++ )
+            sad[d] = (ushort)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0));
+
+        hsad = hsad0 + (1 - dy0)*ndisp;
+        for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp )
+        {
+            for( d = 0; d <= ndisp-2*VTraits<v_uint16>::vlanes(); d += 2*VTraits<v_uint16>::vlanes() )
+            {
+                v_store(sad + d, v_add(vx_load(sad + d), vx_load(hsad + d)));
+                v_store(sad + d + VTraits<v_uint16>::vlanes(), v_add(vx_load(sad + d + VTraits<v_uint16>::vlanes()), vx_load(hsad + d + VTraits<v_uint16>::vlanes())));
+            }
+            if( d <= ndisp-VTraits<v_uint16>::vlanes() )
+            {
+                v_store(sad + d, v_add(vx_load(sad + d), vx_load(hsad + d)));
+                d += VTraits<v_uint16>::vlanes();
+            }
+            if( d <= ndisp-VTraits<v_uint16>::vlanes()/2 )
+            {
+                v_store_low(sad + d, v_add(vx_load_low(sad + d), vx_load_low(hsad + d)));
+                d += VTraits<v_uint16>::vlanes()/2;
+            }
+            for( ; d < ndisp; d++ )
+                sad[d] = sad[d] + hsad[d];
+        }
+        int tsum = 0;
+        for( y = -wsz2-1; y < wsz2; y++ )
+            tsum += htext[y];
+
+        // finally, start the real processing
+        for( y = 0; y < height; y++ )
+        {
+            int minsad = INT_MAX, mind = -1;
+            hsad = hsad0 + MIN(y + wsz2, height+dy1-1)*ndisp;
+            hsad_sub = hsad0 + MAX(y - wsz2 - 1, -dy0)*ndisp;
+            v_int16 minsad8 = vx_setall_s16(SHRT_MAX);
+            v_int16 mind8 = vx_setall_s16(0);
+
+            for( d = 0; d <= ndisp - 2*VTraits<v_int16>::vlanes(); d += 2*VTraits<v_int16>::vlanes() )
+            {
+                v_int16 sad8 = v_add(v_sub(v_reinterpret_as_s16(vx_load(hsad + d)), v_reinterpret_as_s16(vx_load(hsad_sub + d))), v_reinterpret_as_s16(vx_load(sad + d)));
+                v_store(sad + d, v_reinterpret_as_u16(sad8));
+                mind8 = v_max(mind8, v_and(v_gt(minsad8, sad8), vx_setall_s16((short)d)));
+                minsad8 = v_min(minsad8, sad8);
+
+                sad8 = v_add(v_sub(v_reinterpret_as_s16(vx_load(hsad + d + VTraits<v_int16>::vlanes())), v_reinterpret_as_s16(vx_load(hsad_sub + d + VTraits<v_int16>::vlanes()))), v_reinterpret_as_s16(vx_load(sad + d + VTraits<v_int16>::vlanes())));
+                v_store(sad + d + VTraits<v_int16>::vlanes(), v_reinterpret_as_u16(sad8));
+                mind8 = v_max(mind8, v_and(v_gt(minsad8, sad8), vx_setall_s16((short)(d + VTraits<v_int16>::vlanes()))));
+                minsad8 = v_min(minsad8, sad8);
+            }
+            if( d <= ndisp - VTraits<v_int16>::vlanes() )
+            {
+                v_int16 sad8 = v_add(v_sub(v_reinterpret_as_s16(vx_load(hsad + d)), v_reinterpret_as_s16(vx_load(hsad_sub + d))), v_reinterpret_as_s16(vx_load(sad + d)));
+                v_store(sad + d, v_reinterpret_as_u16(sad8));
+                mind8 = v_max(mind8, v_and(v_gt(minsad8, sad8), vx_setall_s16((short)d)));
+                minsad8 = v_min(minsad8, sad8);
+                d += VTraits<v_int16>::vlanes();
+            }
+            minsad = v_reduce_min(minsad8);
+            v_int16 v_mask = (v_eq(vx_setall_s16((short)minsad), minsad8));
+            mind = v_reduce_min(v_or(v_and(v_add(mind8, vx_load(v_seq)), v_mask), v_and(vx_setall_s16(32767), v_not(v_mask))));
+            for( ; d < ndisp; d++ )
+            {
+                int sad8 = (int)(hsad[d]) - hsad_sub[d] + sad[d];
+                sad[d] = (ushort)sad8;
+                if(minsad > sad8)
+                {
+                    mind = d;
+                    minsad = sad8;
+                }
+            }
+
+            tsum += htext[y + wsz2] - htext[y - wsz2 - 1];
+            if( tsum < textureThreshold )
+            {
+                dptr[y*dstep] = FILTERED;
+                continue;
+            }
+
+            if( uniquenessRatio > 0 )
+            {
+                int thresh = minsad + (minsad * uniquenessRatio/100);
+                v_int32 thresh4 = vx_setall_s32(thresh + 1);
+                v_int32 d1 = vx_setall_s32(mind-1), d2 = vx_setall_s32(mind+1);
+                v_int32 dd_4 = vx_setall_s32(VTraits<v_int32>::vlanes());
+                v_int32 d4 = vx_load_expand(v_seq);
+
+                for( d = 0; d <= ndisp - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes() )
+                {
+                    v_int32 sad4_l, sad4_h;
+                    v_expand(v_reinterpret_as_s16(vx_load(sad + d)), sad4_l, sad4_h);
+                    if( v_check_any(v_and(v_gt(thresh4, sad4_l), v_or(v_gt(d1, d4), v_gt(d4, d2)))) )
+                        break;
+                    d4 = v_add(d4, dd_4);
+                    if( v_check_any(v_and(v_gt(thresh4, sad4_h), v_or(v_gt(d1, d4), v_gt(d4, d2)))) )
+                        break;
+                    d4 = v_add(d4, dd_4);
+                }
+                if( d <= ndisp - VTraits<v_int16>::vlanes() )
+                {
+                    dptr[y*dstep] = FILTERED;
+                    continue;
+                }
+                if( d <= ndisp - VTraits<v_int32>::vlanes() )
+                {
+                    v_int32 sad4_l = vx_load_expand((short*)sad + d);
+                    if (v_check_any(v_and(v_gt(thresh4, sad4_l), v_or(v_gt(d1, d4), v_gt(d4, d2)))))
+                    {
+                        dptr[y*dstep] = FILTERED;
+                        continue;
+                    }
+                    d += VTraits<v_int16>::vlanes();
+                }
+                for( ; d < ndisp; d++ )
+                {
+                    if( (thresh + 1) > sad[d] && ((mind - 1) > d || d > (mind + 1)) )
+                        break;
+                }
+                if( d < ndisp )
+                {
+                    dptr[y*dstep] = FILTERED;
+                    continue;
+                }
+            }
+
+            if( 0 < mind && mind < ndisp - 1 )
+            {
+                int p = sad[mind+1], n = sad[mind-1];
+                d = p + n - 2*sad[mind] + std::abs(p - n);
+                dptr[y*dstep] = dispDescale<dType>(ndisp - mind - 1 + mindisp, p-n, d);
+            }
+            else
+                dptr[y*dstep] = dispDescale<dType>(ndisp - mind - 1 + mindisp, 0, 0);
+            costptr[y*coststep] = sad[mind];
+        }
+    }
+}
+#endif
+
+template <typename mType>
+static void
+findStereoCorrespondenceBM( const Mat& left, const Mat& right,
+                            Mat& disp, Mat& cost, const StereoBMParams& state,
+                            int _dy0, int _dy1, const BufferBM & bufX, size_t bufNum )
+{
+
+    int x, y, d;
+    int wsz = state.SADWindowSize, wsz2 = wsz/2;
+    int dy0 = MIN(_dy0, wsz2+1), dy1 = MIN(_dy1, wsz2+1);
+    int ndisp = state.numDisparities;
+    int mindisp = state.minDisparity;
+    int lofs = MAX(ndisp - 1 + mindisp, 0);
+    int rofs = -MIN(ndisp - 1 + mindisp, 0);
+    int width = left.cols, height = left.rows;
+    int width1 = width - rofs - ndisp + 1;
+    int textureThreshold = state.textureThreshold;
+    int uniquenessRatio = state.uniquenessRatio;
+    const int disp_shift = dispShiftTemplate<mType>::value;
+    mType FILTERED = (mType)((mindisp - 1) << disp_shift);
+
+    int *hsad, *hsad_sub;
+    uchar *cbuf;
+    const uchar* lptr0 = left.ptr() + lofs;
+    const uchar* rptr0 = right.ptr() + rofs;
+    const uchar *lptr, *lptr_sub, *rptr;
+    mType* dptr = disp.ptr<mType>();
+    int sstep = (int)left.step;
+    int dstep = (int)(disp.step/sizeof(dptr[0]));
+    int cstep = (height+dy0+dy1)*ndisp;
+    int costbuf = 0;
+    int coststep = cost.data ? (int)(cost.step/sizeof(costbuf)) : 0;
+    const uchar * tab = bufX.tab;
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    int v_seq[VTraits<v_int32>::max_nlanes];
+    for (int i = 0; i < VTraits<v_int32>::vlanes(); ++i)
+        v_seq[i] = i;
+    v_int32 d0_4 = vx_load(v_seq), dd_4 = vx_setall_s32(VTraits<v_int32>::vlanes());
+#endif
+
+    int *sad = bufX.sad[bufNum] + 1;
+    int *hsad0 = bufX.hsad[bufNum] + (wsz2 + 1) * ndisp;
+    int *htext = bufX.htext[bufNum] + (wsz2 + 1);
+    uchar *cbuf0 = bufX.cbuf0[bufNum] + (wsz2 + 1) * ndisp;
+
+    // initialize buffers
+    memset(sad - 1, 0, (ndisp + 2) * sizeof(sad[0]));
+    memset(hsad0 - dy0 * ndisp, 0, (height + wsz + 2) * ndisp * sizeof(hsad[0]));
+    memset(htext - dy0, 0, (height + wsz + 2) * sizeof(htext[0]));
+
+    for( x = -wsz2-1; x < wsz2; x++ )
+    {
+        hsad = hsad0 - dy0*ndisp; cbuf = cbuf0 + (x + wsz2 + 1)*cstep - dy0*ndisp;
+        lptr = lptr0 + std::min(std::max(x, -lofs), width-lofs-1) - dy0*sstep;
+        rptr = rptr0 + std::min(std::max(x, -rofs), width-rofs-ndisp) - dy0*sstep;
+        for( y = -dy0; y < height + dy1; y++, hsad += ndisp, cbuf += ndisp, lptr += sstep, rptr += sstep )
+        {
+            int lval = lptr[0];
+            d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            {
+                v_uint8 lv = vx_setall_u8((uchar)lval);
+
+                for( ; d <= ndisp - VTraits<v_uint8>::vlanes(); d += VTraits<v_uint8>::vlanes() )
+                {
+                    v_uint8 rv = vx_load(rptr + d);
+                    v_int32 hsad_0 = vx_load(hsad + d);
+                    v_int32 hsad_1 = vx_load(hsad + d + VTraits<v_int32>::vlanes());
+                    v_int32 hsad_2 = vx_load(hsad + d + 2*VTraits<v_int32>::vlanes());
+                    v_int32 hsad_3 = vx_load(hsad + d + 3*VTraits<v_int32>::vlanes());
+                    v_uint8 diff = v_absdiff(lv, rv);
+                    v_store(cbuf + d, diff);
+
+                    v_uint16 diff0, diff1;
+                    v_uint32 diff00, diff01, diff10, diff11;
+                    v_expand(diff, diff0, diff1);
+                    v_expand(diff0, diff00, diff01);
+                    v_expand(diff1, diff10, diff11);
+
+                    hsad_0 = v_add(hsad_0, v_reinterpret_as_s32(diff00));
+                    hsad_1 = v_add(hsad_1, v_reinterpret_as_s32(diff01));
+                    hsad_2 = v_add(hsad_2, v_reinterpret_as_s32(diff10));
+                    hsad_3 = v_add(hsad_3, v_reinterpret_as_s32(diff11));
+
+                    v_store(hsad + d, hsad_0);
+                    v_store(hsad + d + VTraits<v_int32>::vlanes(), hsad_1);
+                    v_store(hsad + d + 2*VTraits<v_int32>::vlanes(), hsad_2);
+                    v_store(hsad + d + 3*VTraits<v_int32>::vlanes(), hsad_3);
+                }
+            }
+#endif
+            for( ; d < ndisp; d++ )
+            {
+                int diff = std::abs(lval - rptr[d]);
+                cbuf[d] = (uchar)diff;
+                hsad[d] = (int)(hsad[d] + diff);
+            }
+            htext[y] += tab[lval];
+        }
+    }
+
+    // initialize the left and right borders of the disparity map
+    for( y = 0; y < height; y++ )
+    {
+        for( x = 0; x < lofs; x++ )
+            dptr[y*dstep + x] = FILTERED;
+        for( x = lofs + width1; x < width; x++ )
+            dptr[y*dstep + x] = FILTERED;
+    }
+    dptr += lofs;
+
+    for( x = 0; x < width1; x++, dptr++ )
+    {
+        int* costptr = cost.data ? cost.ptr<int>() + lofs + x : &costbuf;
+        int x0 = x - wsz2 - 1, x1 = x + wsz2;
+        const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
+        hsad = hsad0 - dy0*ndisp;
+        lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
+        lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
+        rptr = rptr0 + MIN(MAX(x1, -rofs), width-ndisp-rofs) - dy0*sstep;
+
+        for( y = -dy0; y < height + dy1; y++, cbuf += ndisp, cbuf_sub += ndisp,
+            hsad += ndisp, lptr += sstep, lptr_sub += sstep, rptr += sstep )
+        {
+            int lval = lptr[0];
+            d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            {
+                v_uint8 lv = vx_setall_u8((uchar)lval);
+                for( ; d <= ndisp - VTraits<v_uint8>::vlanes(); d += VTraits<v_uint8>::vlanes() )
+                {
+                    v_uint8 rv = vx_load(rptr + d);
+                    v_int32 hsad_0 = vx_load(hsad + d);
+                    v_int32 hsad_1 = vx_load(hsad + d + VTraits<v_int32>::vlanes());
+                    v_int32 hsad_2 = vx_load(hsad + d + 2*VTraits<v_int32>::vlanes());
+                    v_int32 hsad_3 = vx_load(hsad + d + 3*VTraits<v_int32>::vlanes());
+                    v_uint8 cbs = vx_load(cbuf_sub + d);
+                    v_uint8 diff = v_absdiff(lv, rv);
+                    v_store(cbuf + d, diff);
+
+                    v_uint16 diff0, diff1, cbs0, cbs1;
+                    v_int32 diff00, diff01, diff10, diff11, cbs00, cbs01, cbs10, cbs11;
+                    v_expand(diff, diff0, diff1);
+                    v_expand(cbs, cbs0, cbs1);
+                    v_expand(v_reinterpret_as_s16(diff0), diff00, diff01);
+                    v_expand(v_reinterpret_as_s16(diff1), diff10, diff11);
+                    v_expand(v_reinterpret_as_s16(cbs0), cbs00, cbs01);
+                    v_expand(v_reinterpret_as_s16(cbs1), cbs10, cbs11);
+
+                    v_int32 diff_0 = v_sub(diff00, cbs00);
+                    v_int32 diff_1 = v_sub(diff01, cbs01);
+                    v_int32 diff_2 = v_sub(diff10, cbs10);
+                    v_int32 diff_3 = v_sub(diff11, cbs11);
+                    hsad_0 = v_add(hsad_0, diff_0);
+                    hsad_1 = v_add(hsad_1, diff_1);
+                    hsad_2 = v_add(hsad_2, diff_2);
+                    hsad_3 = v_add(hsad_3, diff_3);
+
+                    v_store(hsad + d, hsad_0);
+                    v_store(hsad + d + VTraits<v_int32>::vlanes(), hsad_1);
+                    v_store(hsad + d + 2*VTraits<v_int32>::vlanes(), hsad_2);
+                    v_store(hsad + d + 3*VTraits<v_int32>::vlanes(), hsad_3);
+                }
+            }
+#endif
+            for( ; d < ndisp; d++ )
+            {
+                int diff = std::abs(lval - rptr[d]);
+                cbuf[d] = (uchar)diff;
+                hsad[d] = hsad[d] + diff - cbuf_sub[d];
+            }
+            htext[y] += tab[lval] - tab[lptr_sub[0]];
+        }
+
+        // fill borders
+        for( y = dy1; y <= wsz2; y++ )
+            htext[height+y] = htext[height+dy1-1];
+        for( y = -wsz2-1; y < -dy0; y++ )
+            htext[y] = htext[-dy0];
+
+        // initialize sums
+        for( d = 0; d < ndisp; d++ )
+            sad[d] = (int)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0));
+
+        hsad = hsad0 + (1 - dy0)*ndisp;
+        for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp )
+        {
+            d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            {
+                for( d = 0; d <= ndisp-2*VTraits<v_int32>::vlanes(); d += 2*VTraits<v_int32>::vlanes() )
+                {
+                    v_int32 s0 = vx_load(sad + d);
+                    v_int32 s1 = vx_load(sad + d + VTraits<v_int32>::vlanes());
+                    v_int32 t0 = vx_load(hsad + d);
+                    v_int32 t1 = vx_load(hsad + d + VTraits<v_int32>::vlanes());
+                    s0 = v_add(s0, t0);
+                    s1 = v_add(s1, t1);
+                    v_store(sad + d, s0);
+                    v_store(sad + d + VTraits<v_int32>::vlanes(), s1);
+                }
+            }
+#endif
+            for( ; d < ndisp; d++ )
+                sad[d] = (int)(sad[d] + hsad[d]);
+        }
+        int tsum = 0;
+        for( y = -wsz2-1; y < wsz2; y++ )
+            tsum += htext[y];
+
+        // finally, start the real processing
+        for( y = 0; y < height; y++ )
+        {
+            int minsad = INT_MAX, mind = -1;
+            hsad = hsad0 + MIN(y + wsz2, height+dy1-1)*ndisp;
+            hsad_sub = hsad0 + MAX(y - wsz2 - 1, -dy0)*ndisp;
+            d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            {
+                v_int32 minsad4 = vx_setall_s32(INT_MAX);
+                v_int32 mind4 = vx_setall_s32(0), d4 = d0_4;
+
+                for( ; d <= ndisp - 2*VTraits<v_int32>::vlanes(); d += 2*VTraits<v_int32>::vlanes() )
+                {
+                    v_int32 sad4 = v_sub(v_add(vx_load(sad + d), vx_load(hsad + d)), vx_load(hsad_sub + d));
+                    v_store(sad + d, sad4);
+                    mind4 = v_select(v_gt(minsad4, sad4), d4, mind4);
+                    minsad4 = v_min(minsad4, sad4);
+                    d4 = v_add(d4, dd_4);
+
+                    sad4 = v_sub(v_add(vx_load(sad + d + VTraits<v_int32>::vlanes()), vx_load(hsad + d + VTraits<v_int32>::vlanes())), vx_load(hsad_sub + d + VTraits<v_int32>::vlanes()));
+                    v_store(sad + d + VTraits<v_int32>::vlanes(), sad4);
+                    mind4 = v_select(v_gt(minsad4, sad4), d4, mind4);
+                    minsad4 = v_min(minsad4, sad4);
+                    d4 = v_add(d4, dd_4);
+                }
+
+                int CV_DECL_ALIGNED(CV_SIMD_WIDTH) minsad_buf[VTraits<v_int32>::max_nlanes], mind_buf[VTraits<v_int32>::max_nlanes];
+                v_store(minsad_buf, minsad4);
+                v_store(mind_buf, mind4);
+                for (int i = 0; i < VTraits<v_int32>::vlanes(); ++i)
+                    if(minsad_buf[i] < minsad || (minsad == minsad_buf[i] && mind_buf[i] < mind)) { minsad = minsad_buf[i]; mind = mind_buf[i]; }
+            }
+#endif
+            for( ; d < ndisp; d++ )
+            {
+                int currsad = sad[d] + hsad[d] - hsad_sub[d];
+                sad[d] = currsad;
+                if( currsad < minsad )
+                {
+                    minsad = currsad;
+                    mind = d;
+                }
+            }
+
+            tsum += htext[y + wsz2] - htext[y - wsz2 - 1];
+            if( tsum < textureThreshold )
+            {
+                dptr[y*dstep] = FILTERED;
+                continue;
+            }
+
+            if( uniquenessRatio > 0 )
+            {
+                int thresh = minsad + (minsad * uniquenessRatio/100);
+                for( d = 0; d < ndisp; d++ )
+                {
+                    if( (d < mind-1 || d > mind+1) && sad[d] <= thresh)
+                        break;
+                }
+                if( d < ndisp )
+                {
+                    dptr[y*dstep] = FILTERED;
+                    continue;
+                }
+            }
+
+            {
+                sad[-1] = sad[1];
+                sad[ndisp] = sad[ndisp-2];
+                int p = sad[mind+1], n = sad[mind-1];
+                d = p + n - 2*sad[mind] + std::abs(p - n);
+                dptr[y*dstep] = dispDescale<mType>(ndisp - mind - 1 + mindisp, p-n, d);
+
+                costptr[y*coststep] = sad[mind];
+            }
+        }
+    }
+}
+
+#ifdef HAVE_OPENCL
+static bool ocl_prefiltering(InputArray left0, InputArray right0, OutputArray left, OutputArray right, StereoBMParams* state)
+{
+    if (state->useNormPrefilter())
+    {
+        if(!ocl_prefilter_norm( left0, left, state->preFilterSize, state->preFilterCap))
+            return false;
+        if(!ocl_prefilter_norm( right0, right, state->preFilterSize, state->preFilterCap))
+            return false;
+    }
+    else
+    {
+        if(!ocl_prefilter_xsobel( left0, left, state->preFilterCap ))
+            return false;
+        if(!ocl_prefilter_xsobel( right0, right, state->preFilterCap))
+            return false;
+    }
+    return true;
+}
+#endif
+
+struct PrefilterInvoker : public ParallelLoopBody
+{
+    PrefilterInvoker(const Mat& left0, const Mat& right0, Mat& left, Mat& right,
+                     const BufferBM &bufX_, const StereoBMParams &state_)
+        : bufX(bufX_), state(state_)
+    {
+        imgs0[0] = &left0; imgs0[1] = &right0;
+        imgs[0] = &left; imgs[1] = &right;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        for( int i = range.start; i < range.end; i++ )
+        {
+            if (state.useNormPrefilter())
+                prefilterNorm( *imgs0[i], *imgs[i], state.preFilterSize, state.preFilterCap, bufX.prefilter[i] );
+            else
+                prefilterXSobel( *imgs0[i], *imgs[i], state.preFilterCap );
+        }
+    }
+
+    const Mat* imgs0[2];
+    Mat* imgs[2];
+    const BufferBM &bufX;
+    const StereoBMParams &state;
+};
+
+#ifdef HAVE_OPENCL
+static bool ocl_stereobm( InputArray _left, InputArray _right,
+                       OutputArray _disp, StereoBMParams* state)
+{
+    int ndisp = state->numDisparities;
+    int mindisp = state->minDisparity;
+    int wsz = state->SADWindowSize;
+    int wsz2 = wsz/2;
+
+    ocl::Device devDef = ocl::Device::getDefault();
+    int sizeX = devDef.isIntel() ? 32 : std::max(11, 27 - devDef.maxComputeUnits()),
+        sizeY = sizeX - 1,
+        N = ndisp * 2;
+
+    cv::String opt = cv::format("-D DEFINE_KERNEL_STEREOBM -D MIN_DISP=%d -D NUM_DISP=%d"
+                                " -D BLOCK_SIZE_X=%d -D BLOCK_SIZE_Y=%d -D WSZ=%d",
+                                mindisp, ndisp,
+                                sizeX, sizeY, wsz);
+    ocl::Kernel k("stereoBM", ocl::stereo::stereobm_oclsrc, opt);
+    if(k.empty())
+        return false;
+
+    UMat left = _left.getUMat(), right = _right.getUMat();
+    int cols = left.cols, rows = left.rows;
+
+    _disp.create(_left.size(), CV_16S);
+    _disp.setTo((mindisp - 1) << 4);
+    Rect roi = Rect(Point(wsz2 + mindisp + ndisp - 1, wsz2), Point(cols-wsz2-mindisp, rows-wsz2) );
+    UMat disp = (_disp.getUMat())(roi);
+
+    int globalX = (disp.cols + sizeX - 1) / sizeX,
+        globalY = (disp.rows + sizeY - 1) / sizeY;
+    size_t globalThreads[3] = {(size_t)N, (size_t)globalX, (size_t)globalY};
+    size_t localThreads[3]  = {(size_t)N, 1, 1};
+
+    int idx = 0;
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(left));
+    idx = k.set(idx, ocl::KernelArg::PtrReadOnly(right));
+    idx = k.set(idx, ocl::KernelArg::WriteOnlyNoSize(disp));
+    idx = k.set(idx, rows);
+    idx = k.set(idx, cols);
+    idx = k.set(idx, state->textureThreshold);
+    idx = k.set(idx, state->uniquenessRatio);
+    return k.run(3, globalThreads, localThreads, false);
+}
+#endif
+
+struct FindStereoCorrespInvoker : public ParallelLoopBody
+{
+    FindStereoCorrespInvoker( const Mat& _left, const Mat& _right,
+                             Mat& _disp, const StereoBMParams &_state,
+                             int _nstripes,
+                             Rect _validDisparityRect,
+                             Mat& _cost, const BufferBM & buf_ )
+        : state(_state), buf(buf_)
+    {
+        CV_Assert( _disp.type() == CV_16S || _disp.type() == CV_32S );
+        left = &_left; right = &_right;
+        disp = &_disp;
+        nstripes = _nstripes;
+        validDisparityRect = _validDisparityRect;
+        cost = &_cost;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        int cols = left->cols, rows = left->rows;
+        int _row0 = std::min(cvRound(range.start * rows / nstripes), rows);
+        int _row1 = std::min(cvRound(range.end * rows / nstripes), rows);
+
+        int dispShift = disp->type() == CV_16S ? DISPARITY_SHIFT_16S :
+                                                 DISPARITY_SHIFT_32S;
+        int FILTERED = (state.minDisparity - 1) << dispShift;
+
+        Rect roi = validDisparityRect & Rect(0, _row0, cols, _row1 - _row0);
+        if( roi.height == 0 )
+            return;
+        int row0 = roi.y;
+        int row1 = roi.y + roi.height;
+
+        Mat part;
+        if( row0 > _row0 )
+        {
+            part = disp->rowRange(_row0, row0);
+            part = Scalar::all(FILTERED);
+        }
+        if( _row1 > row1 )
+        {
+            part = disp->rowRange(row1, _row1);
+            part = Scalar::all(FILTERED);
+        }
+
+        Mat left_i = left->rowRange(row0, row1);
+        Mat right_i = right->rowRange(row0, row1);
+        Mat disp_i = disp->rowRange(row0, row1);
+        Mat cost_i = state.disp12MaxDiff >= 0 ? cost->rowRange(row0, row1) : Mat();
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+        if (state.useShorts())
+        {
+            if( disp_i.type() == CV_16S)
+                findStereoCorrespondenceBM_SIMD<short>( left_i, right_i, disp_i, cost_i, state, row0, rows - row1, buf, range.start );
+            else
+                findStereoCorrespondenceBM_SIMD<int>( left_i, right_i, disp_i, cost_i, state, row0, rows - row1, buf, range.start);
+        }
+        else
+#endif
+        {
+            if( disp_i.type() == CV_16S )
+                findStereoCorrespondenceBM<short>( left_i, right_i, disp_i, cost_i, state, row0, rows - row1, buf, range.start );
+            else
+                findStereoCorrespondenceBM<int>( left_i, right_i, disp_i, cost_i, state, row0, rows - row1, buf, range.start );
+        }
+
+        if( state.disp12MaxDiff >= 0 )
+            validateDisparity( disp_i, cost_i, state.minDisparity, state.numDisparities, state.disp12MaxDiff );
+
+        if( roi.x > 0 )
+        {
+            part = disp_i.colRange(0, roi.x);
+            part = Scalar::all(FILTERED);
+        }
+        if( roi.x + roi.width < cols )
+        {
+            part = disp_i.colRange(roi.x + roi.width, cols);
+            part = Scalar::all(FILTERED);
+        }
+    }
+
+protected:
+    const Mat *left, *right;
+    Mat* disp, *cost;
+    const StereoBMParams &state;
+
+    int nstripes;
+    Rect validDisparityRect;
+    const BufferBM & buf;
+};
+
+class StereoBMImpl CV_FINAL : public StereoBM
+{
+public:
+    StereoBMImpl()
+        : params()
+    {
+        // nothing
+    }
+
+    StereoBMImpl( int _numDisparities, int _SADWindowSize )
+        : params(_numDisparities, _SADWindowSize)
+    {
+        // nothing
+    }
+
+    void compute( InputArray leftarr, InputArray rightarr, OutputArray disparr ) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        int dtype = disparr.fixedType() ? disparr.type() : params.dispType;
+        Size leftsize = leftarr.size();
+
+        if (leftarr.size() != rightarr.size())
+            CV_Error( Error::StsUnmatchedSizes, "All the images must have the same size" );
+
+        if (leftarr.type() != CV_8UC1 || rightarr.type() != CV_8UC1)
+            CV_Error( Error::StsUnsupportedFormat, "Both input images must have CV_8UC1" );
+
+        if (dtype != CV_16SC1 && dtype != CV_32FC1)
+            CV_Error( Error::StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format" );
+
+        if( params.preFilterType != PREFILTER_NORMALIZED_RESPONSE &&
+            params.preFilterType != PREFILTER_XSOBEL )
+            CV_Error( Error::StsOutOfRange, "preFilterType must be = CV_STEREO_BM_NORMALIZED_RESPONSE" );
+
+        if( params.preFilterSize < 5 || params.preFilterSize > 255 || params.preFilterSize % 2 == 0 )
+            CV_Error( Error::StsOutOfRange, "preFilterSize must be odd and be within 5..255" );
+
+        if( params.preFilterCap < 1 || params.preFilterCap > 63 )
+            CV_Error( Error::StsOutOfRange, "preFilterCap must be within 1..63" );
+
+        if( params.SADWindowSize < 5 || params.SADWindowSize > 255 || params.SADWindowSize % 2 == 0 ||
+            params.SADWindowSize >= std::min(leftsize.width, leftsize.height) )
+            CV_Error( Error::StsOutOfRange, "SADWindowSize must be odd, be within 5..255 and be not larger than image width or height" );
+
+        if( params.numDisparities <= 0 || params.numDisparities % 16 != 0 )
+            CV_Error( Error::StsOutOfRange, "numDisparities must be positive and divisible by 16" );
+
+        if( params.textureThreshold < 0 )
+            CV_Error( Error::StsOutOfRange, "texture threshold must be non-negative" );
+
+        if( params.uniquenessRatio < 0 )
+            CV_Error( Error::StsOutOfRange, "uniqueness ratio must be non-negative" );
+
+        int disp_shift;
+        if (dtype == CV_16SC1)
+            disp_shift = DISPARITY_SHIFT_16S;
+        else
+            disp_shift = DISPARITY_SHIFT_32S;
+
+        int FILTERED = (params.minDisparity - 1) << disp_shift;
+
+#ifdef HAVE_OPENCL
+        if(ocl::isOpenCLActivated() && disparr.isUMat() && params.textureThreshold == 0)
+        {
+            UMat left, right;
+            if(ocl_prefiltering(leftarr, rightarr, left, right, &params))
+            {
+                if(ocl_stereobm(left, right, disparr, &params))
+                {
+                    disp_shift = DISPARITY_SHIFT_16S;
+                    FILTERED = (params.minDisparity - 1) << disp_shift;
+
+                    if (params.useFilterSpeckles())
+                        filterSpeckles(disparr.getMat(), FILTERED, params.speckleWindowSize, params.speckleRange, slidingSumBuf);
+                    if (dtype == CV_32F)
+                        disparr.getUMat().convertTo(disparr, CV_32FC1, 1./(1 << disp_shift), 0);
+                    CV_IMPL_ADD(CV_IMPL_OCL);
+                    return;
+                }
+            }
+        }
+#endif
+
+        Mat left0 = leftarr.getMat(), right0 = rightarr.getMat();
+        disparr.create(left0.size(), dtype);
+        Mat disp0 = disparr.getMat();
+
+        preFilteredImg0.create( left0.size(), CV_8U );
+        preFilteredImg1.create( left0.size(), CV_8U );
+        cost.create( left0.size(), CV_16S );
+
+        Mat left = preFilteredImg0, right = preFilteredImg1;
+
+        int mindisp = params.minDisparity;
+        int ndisp = params.numDisparities;
+
+        int width = left0.cols;
+        int height = left0.rows;
+        int lofs = std::max(ndisp - 1 + mindisp, 0);
+        int rofs = -std::min(ndisp - 1 + mindisp, 0);
+        int width1 = width - rofs - ndisp + 1;
+
+        if( lofs >= width || rofs >= width || width1 < 1 )
+        {
+            disp0 = Scalar::all( FILTERED * ( disp0.type() < CV_32F ? 1 : 1./(1 << disp_shift) ) );
+            return;
+        }
+
+        Mat disp = disp0;
+        if( dtype == CV_32F )
+        {
+            dispbuf.create(disp0.size(), CV_32S);
+            disp = dispbuf;
+        }
+
+        {
+            const double SAD_overhead_coeff = 10.0;
+            const double N0 = 8000000 / (params.useShorts() ? 1 : 4);  // approx tbb's min number instructions reasonable for one thread
+            const double maxStripeSize = std::min(
+                std::max(
+                    N0 / (width * ndisp),
+                    (params.SADWindowSize-1) * SAD_overhead_coeff
+                ),
+                (double)height
+            );
+            const int nstripes = cvCeil(height / maxStripeSize);
+            BufferBM localBuf(nstripes, width, height, params);
+
+            // Prefiltering
+            parallel_for_(Range(0, 2), PrefilterInvoker(left0, right0, left, right, localBuf, params), 1);
+
+
+            Rect validDisparityRect(0, 0, width, height), R1 = params.roi1, R2 = params.roi2;
+            validDisparityRect = getValidDisparityROI(!R1.empty() ? R1 : validDisparityRect,
+                                                      !R2.empty() ? R2 : validDisparityRect,
+                                                      params.minDisparity, params.numDisparities,
+                                                      params.SADWindowSize);
+
+            FindStereoCorrespInvoker invoker(left, right, disp, params, nstripes, validDisparityRect, cost, localBuf);
+            parallel_for_(Range(0, nstripes), invoker);
+
+            if (params.useFilterSpeckles())
+            {
+                slidingSumBuf.create( 1, width * height * (sizeof(Point_<short>) + sizeof(int) + sizeof(uchar)), CV_8U );
+                filterSpeckles(disp, FILTERED, params.speckleWindowSize, params.speckleRange, slidingSumBuf);
+            }
+
+        }
+
+        if (disp0.data != disp.data)
+            disp.convertTo(disp0, disp0.type(), 1./(1 << disp_shift), 0);
+    }
+
+    int getMinDisparity() const CV_OVERRIDE { return params.minDisparity; }
+    void setMinDisparity(int minDisparity) CV_OVERRIDE { params.minDisparity = minDisparity; }
+
+    int getNumDisparities() const CV_OVERRIDE { return params.numDisparities; }
+    void setNumDisparities(int numDisparities) CV_OVERRIDE { params.numDisparities = numDisparities; }
+
+    int getBlockSize() const CV_OVERRIDE { return params.SADWindowSize; }
+    void setBlockSize(int blockSize) CV_OVERRIDE { params.SADWindowSize = blockSize; }
+
+    int getSpeckleWindowSize() const CV_OVERRIDE { return params.speckleWindowSize; }
+    void setSpeckleWindowSize(int speckleWindowSize) CV_OVERRIDE { params.speckleWindowSize = speckleWindowSize; }
+
+    int getSpeckleRange() const CV_OVERRIDE { return params.speckleRange; }
+    void setSpeckleRange(int speckleRange) CV_OVERRIDE { params.speckleRange = speckleRange; }
+
+    int getDisp12MaxDiff() const CV_OVERRIDE { return params.disp12MaxDiff; }
+    void setDisp12MaxDiff(int disp12MaxDiff) CV_OVERRIDE { params.disp12MaxDiff = disp12MaxDiff; }
+
+    int getPreFilterType() const CV_OVERRIDE { return params.preFilterType; }
+    void setPreFilterType(int preFilterType) CV_OVERRIDE { params.preFilterType = preFilterType; }
+
+    int getPreFilterSize() const CV_OVERRIDE { return params.preFilterSize; }
+    void setPreFilterSize(int preFilterSize) CV_OVERRIDE { params.preFilterSize = preFilterSize; }
+
+    int getPreFilterCap() const CV_OVERRIDE { return params.preFilterCap; }
+    void setPreFilterCap(int preFilterCap) CV_OVERRIDE { params.preFilterCap = preFilterCap; }
+
+    int getTextureThreshold() const CV_OVERRIDE { return params.textureThreshold; }
+    void setTextureThreshold(int textureThreshold) CV_OVERRIDE { params.textureThreshold = textureThreshold; }
+
+    int getUniquenessRatio() const CV_OVERRIDE { return params.uniquenessRatio; }
+    void setUniquenessRatio(int uniquenessRatio) CV_OVERRIDE { params.uniquenessRatio = uniquenessRatio; }
+
+    int getSmallerBlockSize() const CV_OVERRIDE { return 0; }
+    void setSmallerBlockSize(int) CV_OVERRIDE {}
+
+    Rect getROI1() const CV_OVERRIDE { return params.roi1; }
+    void setROI1(Rect roi1) CV_OVERRIDE { params.roi1 = roi1; }
+
+    Rect getROI2() const CV_OVERRIDE { return params.roi2; }
+    void setROI2(Rect roi2) CV_OVERRIDE { params.roi2 = roi2; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name_
+        << "minDisparity" << params.minDisparity
+        << "numDisparities" << params.numDisparities
+        << "blockSize" << params.SADWindowSize
+        << "speckleWindowSize" << params.speckleWindowSize
+        << "speckleRange" << params.speckleRange
+        << "disp12MaxDiff" << params.disp12MaxDiff
+        << "preFilterType" << params.preFilterType
+        << "preFilterSize" << params.preFilterSize
+        << "preFilterCap" << params.preFilterCap
+        << "textureThreshold" << params.textureThreshold
+        << "uniquenessRatio" << params.uniquenessRatio;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert( n.isString() && String(n) == name_ );
+        params.minDisparity = (int)fn["minDisparity"];
+        params.numDisparities = (int)fn["numDisparities"];
+        params.SADWindowSize = (int)fn["blockSize"];
+        params.speckleWindowSize = (int)fn["speckleWindowSize"];
+        params.speckleRange = (int)fn["speckleRange"];
+        params.disp12MaxDiff = (int)fn["disp12MaxDiff"];
+        params.preFilterType = (int)fn["preFilterType"];
+        params.preFilterSize = (int)fn["preFilterSize"];
+        params.preFilterCap = (int)fn["preFilterCap"];
+        params.textureThreshold = (int)fn["textureThreshold"];
+        params.uniquenessRatio = (int)fn["uniquenessRatio"];
+        params.roi1 = params.roi2 = Rect();
+    }
+
+    StereoBMParams params;
+    Mat preFilteredImg0, preFilteredImg1, cost, dispbuf;
+    Mat slidingSumBuf;
+
+    static const char* name_;
+};
+
+const char* StereoBMImpl::name_ = "StereoMatcher.BM";
+
+Ptr<StereoBM> StereoBM::create(int _numDisparities, int _SADWindowSize)
+{
+    return makePtr<StereoBMImpl>(_numDisparities, _SADWindowSize);
+}
+
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/stereo/src/stereosgbm.cpp b/upstream/opencv/modules/stereo/src/stereosgbm.cpp
new file mode 100644
index 0000000..cb2d3bb
--- /dev/null
+++ b/upstream/opencv/modules/stereo/src/stereosgbm.cpp
@@ -0,0 +1,2599 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+ This is a variation of
+ "Stereo Processing by Semiglobal Matching and Mutual Information"
+ by Heiko Hirschmuller.
+
+ We match blocks rather than individual pixels, thus the algorithm is called
+ SGBM (Semi-global block matching)
+ */
+
+#include "precomp.hpp"
+#include <limits.h>
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencv2/core/utils/buffer_area.private.hpp"
+
+namespace cv {
+
+typedef uchar PixType;
+typedef short CostType;
+typedef short DispType;
+
+// NR - the number of directions. the loop on x that computes Lr assumes that NR == 8.
+// if you change NR, please, modify the loop as well.
+enum { NR = 8, NR2 = NR/2 };
+
+
+struct StereoSGBMParams
+{
+    StereoSGBMParams()
+    {
+        minDisparity = numDisparities = 0;
+        SADWindowSize = 0;
+        P1 = P2 = 0;
+        disp12MaxDiff = 0;
+        preFilterCap = 0;
+        uniquenessRatio = 0;
+        speckleWindowSize = 0;
+        speckleRange = 0;
+        mode = StereoSGBM::MODE_SGBM;
+    }
+
+    StereoSGBMParams( int _minDisparity, int _numDisparities, int _SADWindowSize,
+                      int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
+                      int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
+                      int _mode )
+    {
+        minDisparity = _minDisparity;
+        numDisparities = _numDisparities;
+        SADWindowSize = _SADWindowSize;
+        P1 = _P1;
+        P2 = _P2;
+        disp12MaxDiff = _disp12MaxDiff;
+        preFilterCap = _preFilterCap;
+        uniquenessRatio = _uniquenessRatio;
+        speckleWindowSize = _speckleWindowSize;
+        speckleRange = _speckleRange;
+        mode = _mode;
+    }
+
+    inline bool isFullDP() const
+    {
+        return mode == StereoSGBM::MODE_HH || mode == StereoSGBM::MODE_HH4;
+    }
+    inline Size calcSADWindowSize() const
+    {
+        const int dim = SADWindowSize > 0 ? SADWindowSize : 5;
+        return Size(dim, dim);
+    }
+
+    int minDisparity;
+    int numDisparities;
+    int SADWindowSize;
+    int preFilterCap;
+    int uniquenessRatio;
+    int P1;
+    int P2;
+    int speckleWindowSize;
+    int speckleRange;
+    int disp12MaxDiff;
+    int mode;
+};
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+#if CV_SIMD_WIDTH == 16
+static inline v_int16 vx_setseq_s16()
+{ return v_int16(0, 1, 2, 3, 4, 5, 6, 7); }
+#elif CV_SIMD_WIDTH == 32
+static inline v_int16 vx_setseq_s16()
+{ return v_int16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); }
+#elif CV_SIMD_WIDTH == 64
+static inline v_int16 vx_setseq_s16()
+{ return v_int16(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); }
+#else
+struct vseq_s16
+{
+    short data[VTraits<v_int16>::max_nlanes];
+    vseq_s16()
+    {
+        for (int i = 0; i < VTraits<v_int16>::vlanes(); i++)
+            data[i] = i;
+    }
+};
+static inline v_int16 vx_setseq_s16()
+{
+    static vseq_s16 vseq;
+    return vx_load(vseq.data);
+}
+#endif
+// define some additional reduce operations:
+static inline void min_pos(const v_int16& val, const v_int16& pos, short &min_val, short &min_pos)
+{
+    min_val = v_reduce_min(val);
+    v_int16 v_mask = (v_eq(vx_setall_s16(min_val), val));
+    min_pos = v_reduce_min(v_or(v_and(v_add(pos, vx_setseq_s16()), v_mask), v_and(vx_setall_s16(SHRT_MAX), v_not(v_mask))));
+}
+#endif
+
+static const int DEFAULT_RIGHT_BORDER = -1;
+
+/*
+ For each pixel row1[x], max(maxD, 0) <= minX <= x < maxX <= width - max(0, -minD),
+ and for each disparity minD<=d<maxD the function
+ computes the cost (cost[(x-minX)*(maxD - minD) + (d - minD)]), depending on the difference between
+ row1[x] and row2[x-d]. The subpixel algorithm from
+ "Depth Discontinuities by Pixel-to-Pixel Stereo" by Stan Birchfield and C. Tomasi
+ is used, hence the suffix BT.
+
+ the temporary buffer should contain width2*2 elements
+ */
+static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
+                            int minD, int maxD, CostType* cost,
+                            PixType* buffer, const PixType* tab,
+                            int xrange_min = 0, int xrange_max = DEFAULT_RIGHT_BORDER )
+{
+    int x, c, width = img1.cols, cn = img1.channels();
+    int minX1 = std::max(maxD, 0), maxX1 = width + std::min(minD, 0);
+    int D = (int)alignSize(maxD - minD, VTraits<v_int16>::vlanes()), width1 = maxX1 - minX1;
+    //This minX1 & maxX2 correction is defining which part of calculatable line must be calculated
+    //That is needs of parallel algorithm
+    xrange_min = (xrange_min < 0) ? 0: xrange_min;
+    xrange_max = (xrange_max == DEFAULT_RIGHT_BORDER) || (xrange_max > width1) ? width1 : xrange_max;
+    maxX1 = minX1 + xrange_max;
+    minX1 += xrange_min;
+    width1 = maxX1 - minX1;
+    int minX2 = std::max(minX1 - maxD, 0), maxX2 = std::min(maxX1 - minD, width);
+    int width2 = maxX2 - minX2;
+    const PixType *row1 = img1.ptr<PixType>(y), *row2 = img2.ptr<PixType>(y);
+    PixType *prow1 = buffer + width2*2, *prow2 = prow1 + width*cn*2;
+
+    for( c = 0; c < cn*2; c++ )
+    {
+        prow1[width*c] = prow1[width*c + width-1] =
+        prow2[width*c] = prow2[width*c + width-1] = tab[0];
+    }
+
+    int n1 = y > 0 ? -(int)img1.step : 0, s1 = y < img1.rows-1 ? (int)img1.step : 0;
+    int n2 = y > 0 ? -(int)img2.step : 0, s2 = y < img2.rows-1 ? (int)img2.step : 0;
+
+    int minX_cmn = std::min(minX1,minX2)-1;
+    int maxX_cmn = std::max(maxX1,maxX2)+1;
+    minX_cmn = std::max(minX_cmn, 1);
+    maxX_cmn = std::min(maxX_cmn, width - 1);
+    if( cn == 1 )
+    {
+        for( x = minX_cmn; x < maxX_cmn; x++ )
+        {
+            prow1[x] = tab[(row1[x+1] - row1[x-1])*2 + row1[x+n1+1] - row1[x+n1-1] + row1[x+s1+1] - row1[x+s1-1]];
+            prow2[width-1-x] = tab[(row2[x+1] - row2[x-1])*2 + row2[x+n2+1] - row2[x+n2-1] + row2[x+s2+1] - row2[x+s2-1]];
+
+            prow1[x+width] = row1[x];
+            prow2[width-1-x+width] = row2[x];
+        }
+    }
+    else
+    {
+        for( x = minX_cmn; x < maxX_cmn; x++ )
+        {
+            prow1[x] = tab[(row1[x*3+3] - row1[x*3-3])*2 + row1[x*3+n1+3] - row1[x*3+n1-3] + row1[x*3+s1+3] - row1[x*3+s1-3]];
+            prow1[x+width] = tab[(row1[x*3+4] - row1[x*3-2])*2 + row1[x*3+n1+4] - row1[x*3+n1-2] + row1[x*3+s1+4] - row1[x*3+s1-2]];
+            prow1[x+width*2] = tab[(row1[x*3+5] - row1[x*3-1])*2 + row1[x*3+n1+5] - row1[x*3+n1-1] + row1[x*3+s1+5] - row1[x*3+s1-1]];
+
+            prow2[width-1-x] = tab[(row2[x*3+3] - row2[x*3-3])*2 + row2[x*3+n2+3] - row2[x*3+n2-3] + row2[x*3+s2+3] - row2[x*3+s2-3]];
+            prow2[width-1-x+width] = tab[(row2[x*3+4] - row2[x*3-2])*2 + row2[x*3+n2+4] - row2[x*3+n2-2] + row2[x*3+s2+4] - row2[x*3+s2-2]];
+            prow2[width-1-x+width*2] = tab[(row2[x*3+5] - row2[x*3-1])*2 + row2[x*3+n2+5] - row2[x*3+n2-1] + row2[x*3+s2+5] - row2[x*3+s2-1]];
+
+            prow1[x+width*3] = row1[x*3];
+            prow1[x+width*4] = row1[x*3+1];
+            prow1[x+width*5] = row1[x*3+2];
+
+            prow2[width-1-x+width*3] = row2[x*3];
+            prow2[width-1-x+width*4] = row2[x*3+1];
+            prow2[width-1-x+width*5] = row2[x*3+2];
+        }
+    }
+
+    memset( cost + xrange_min*D, 0, width1*D*sizeof(cost[0]) );
+
+    buffer -= width-maxX2;
+    cost -= (minX1-xrange_min)*D + minD; // simplify the cost indices inside the loop
+
+    for( c = 0; c < cn*2; c++, prow1 += width, prow2 += width )
+    {
+        int diff_scale = c < cn ? 0 : 2;
+
+        // precompute
+        //   v0 = min(row2[x-1/2], row2[x], row2[x+1/2]) and
+        //   v1 = max(row2[x-1/2], row2[x], row2[x+1/2]) and
+        //   to process values from [minX2, maxX2) we should check memory location (width - 1 - maxX2, width - 1 - minX2]
+        //   so iterate through [width - maxX2, width - minX2)
+        for( x = width-maxX2; x < width-minX2; x++ )
+        {
+            int v = prow2[x];
+            int vl = x > 0 ? (v + prow2[x-1])/2 : v;
+            int vr = x < width-1 ? (v + prow2[x+1])/2 : v;
+            int v0 = std::min(vl, vr); v0 = std::min(v0, v);
+            int v1 = std::max(vl, vr); v1 = std::max(v1, v);
+            buffer[x] = (PixType)v0;
+            buffer[x + width2] = (PixType)v1;
+        }
+
+        for( x = minX1; x < maxX1; x++ )
+        {
+            int u = prow1[x];
+            int ul = x > 0 ? (u + prow1[x-1])/2 : u;
+            int ur = x < width-1 ? (u + prow1[x+1])/2 : u;
+            int u0 = std::min(ul, ur); u0 = std::min(u0, u);
+            int u1 = std::max(ul, ur); u1 = std::max(u1, u);
+
+            int d = minD;
+        #if (CV_SIMD || CV_SIMD_SCALABLE)
+            v_uint8 _u  = vx_setall_u8((uchar)u), _u0 = vx_setall_u8((uchar)u0);
+            v_uint8 _u1 = vx_setall_u8((uchar)u1);
+
+            for( ; d <= maxD - 2*VTraits<v_int16>::vlanes(); d += 2*VTraits<v_int16>::vlanes() )
+            {
+                v_uint8 _v  = vx_load(prow2  + width-x-1 + d);
+                v_uint8 _v0 = vx_load(buffer + width-x-1 + d);
+                v_uint8 _v1 = vx_load(buffer + width-x-1 + d + width2);
+                v_uint8 c0 = v_max(v_sub(_u, _v1), v_sub(_v0, _u));
+                v_uint8 c1 = v_max(v_sub(_v, _u1), v_sub(_u0, _v));
+                v_uint8 diff = v_min(c0, c1);
+
+                v_int16 _c0 = vx_load_aligned(cost + x*D + d);
+                v_int16 _c1 = vx_load_aligned(cost + x*D + d + VTraits<v_int16>::vlanes());
+
+                v_uint16 diff1,diff2;
+                v_expand(diff,diff1,diff2);
+                v_store_aligned(cost + x*D + d,                   v_add(_c0, v_reinterpret_as_s16(v_shr(diff1, diff_scale))));
+                v_store_aligned(cost + x*D + d + VTraits<v_int16>::vlanes(), v_add(_c1, v_reinterpret_as_s16(v_shr(diff2, diff_scale))));
+            }
+        #endif
+            for( ; d < maxD; d++ )
+            {
+                int v = prow2[width-x-1 + d];
+                int v0 = buffer[width-x-1 + d];
+                int v1 = buffer[width-x-1 + d + width2];
+                int c0 = std::max(0, u - v1); c0 = std::max(c0, v0 - u);
+                int c1 = std::max(0, v - u1); c1 = std::max(c1, u0 - v);
+
+                cost[x*D + d] = (CostType)(cost[x*D+d] + (std::min(c0, c1) >> diff_scale));
+            }
+        }
+    }
+}
+
+
+
+class BufferSGBM
+{
+private:
+    size_t width1;
+    size_t Da;
+    size_t Dlra;
+    size_t costWidth;
+    size_t costHeight;
+    size_t hsumRows;
+    bool fullDP;
+    uchar dirs;
+    uchar dirs2;
+    static const size_t TAB_OFS = 256*4;
+
+public:
+    CostType* Cbuf;
+    CostType* Sbuf;
+    CostType* hsumBuf;
+    CostType* pixDiff;
+    CostType* disp2cost;
+    DispType* disp2ptr;
+    PixType* tempBuf;
+    std::vector<CostType*> Lr;
+    std::vector<CostType*> minLr;
+    PixType * clipTab;
+
+private:
+    utils::BufferArea area;
+
+public:
+    BufferSGBM(size_t width1_,
+               size_t Da_,
+               size_t Dlra_,
+               size_t cn,
+               size_t width,
+               size_t height,
+               const StereoSGBMParams &params)
+        : width1(width1_),
+        Da(Da_),
+        Dlra(Dlra_),
+        Cbuf(NULL),
+        Sbuf(NULL),
+        hsumBuf(NULL),
+        pixDiff(NULL),
+        disp2cost(NULL),
+        disp2ptr(NULL),
+        tempBuf(NULL),
+        Lr(2, (CostType*)NULL),
+        minLr(2, (CostType*)NULL),
+        clipTab(NULL)
+    {
+        const size_t TAB_SIZE = 256 + TAB_OFS*2;
+        fullDP = params.isFullDP();
+        costWidth = width1 * Da;
+        costHeight = fullDP ? height : 1;
+        hsumRows = params.calcSADWindowSize().height + 2;
+        dirs = params.mode == StereoSGBM::MODE_HH4 ? 1 : NR;
+        dirs2 = params.mode == StereoSGBM::MODE_HH4 ? 1 : NR2;
+        // for each possible stereo match (img1(x,y) <=> img2(x-d,y))
+        // we keep pixel difference cost (C) and the summary cost over NR directions (S).
+        // we also keep all the partial costs for the previous line L_r(x,d) and also min_k L_r(x, k)
+        area.allocate(Cbuf, costWidth * costHeight, CV_SIMD_WIDTH); // summary cost over different (nDirs) directions
+        area.allocate(Sbuf, costWidth * costHeight, CV_SIMD_WIDTH);
+        area.allocate(hsumBuf, costWidth * hsumRows, CV_SIMD_WIDTH);
+        area.allocate(pixDiff, costWidth, CV_SIMD_WIDTH);
+        area.allocate(disp2cost,    width, CV_SIMD_WIDTH);
+        area.allocate(disp2ptr,     width, CV_SIMD_WIDTH);
+        area.allocate(tempBuf,      width * (4 * cn + 2), CV_SIMD_WIDTH);
+        // the number of L_r(.,.) and min_k L_r(.,.) lines in the buffer:
+        // for 8-way dynamic programming we need the current row and
+        // the previous row, i.e. 2 rows in total
+        for (size_t i = 0; i < 2; ++i)
+        {
+            // 2D: [ NR ][ w1 * NR2 ][ NR ] * [ Dlra ]
+            area.allocate(Lr[i], calcLrCount() * Dlra, CV_SIMD_WIDTH);
+            // 1D: [ NR ][ w1 * NR2 ][ NR ]
+            area.allocate(minLr[i], calcLrCount(), CV_SIMD_WIDTH);
+        }
+        area.allocate(clipTab, TAB_SIZE, CV_SIMD_WIDTH);
+        area.commit();
+
+        // init clipTab
+        const int ftzero = std::max(params.preFilterCap, 15) | 1;
+        for(int i = 0; i < (int)TAB_SIZE; i++ )
+            clipTab[i] = (PixType)(std::min(std::max(i - (int)TAB_OFS, -ftzero), ftzero) + ftzero);
+    }
+    inline const PixType * getClipTab() const
+    {
+        return clipTab + TAB_OFS;
+    }
+    inline void initCBuf(CostType val) const
+    {
+        for (size_t i = 0; i < costWidth * costHeight; ++i)
+            Cbuf[i] = val;
+    }
+    inline void clearLr(const Range & range = Range::all()) const
+    {
+            for (uchar i = 0; i < 2; ++i)
+            {
+                if (range == Range::all())
+                {
+                    memset(Lr[i],    0, calcLrCount() * Dlra * sizeof(CostType));
+                    memset(minLr[i], 0, calcLrCount()        * sizeof(CostType));
+                }
+                else
+                {
+                    memset(getLr(i, range.start), 0, range.size() * sizeof(CostType) * Dlra);
+                    memset(getMinLr(i, range.start), 0, range.size() * sizeof(CostType));
+                }
+            }
+    }
+    inline size_t calcLrCount() const
+    {
+        return width1 * dirs2 + 2 * dirs;
+    }
+    inline void swapLr()
+    {
+        std::swap(Lr[0], Lr[1]);
+        std::swap(minLr[0], minLr[1]);
+    }
+    inline CostType * getHSumBuf(int row) const
+    {
+        return hsumBuf + (row % hsumRows) * costWidth;
+    }
+    inline CostType * getCBuf(int row) const
+    {
+        CV_Assert(row >= 0);
+        return Cbuf + (!fullDP ? 0 : (row * costWidth));
+    }
+    inline CostType * getSBuf(int row) const
+    {
+        CV_Assert(row >= 0);
+        return Sbuf + (!fullDP ? 0 : (row * costWidth));
+    }
+    inline void clearSBuf(int row, const Range & range = Range::all()) const
+    {
+        if (range == Range::all())
+            memset(getSBuf(row), 0, costWidth * sizeof(CostType));
+        else
+            memset(getSBuf(row) + range.start * Da, 0, range.size() * Da * sizeof(CostType));
+    }
+
+    // shift Lr[k] and minLr[k] pointers, because we allocated them with the borders,
+    // and will occasionally use negative indices with the arrays
+    // we need to shift Lr[k] pointers by 1, to give the space for d=-1.
+    inline CostType * getLr(uchar id, int idx, uchar shift = 0) const
+    {
+        CV_Assert(id < 2);
+        const size_t fixed_offset = dirs * Dlra;
+        return Lr[id] + fixed_offset + (idx * (int)dirs2 + (int)shift) * (int)Dlra;
+    }
+    inline CostType * getMinLr(uchar id, int idx, uchar shift = 0) const
+    {
+        CV_Assert(id < 2);
+        const size_t fixed_offset = dirs;
+        return minLr[id] + fixed_offset + (idx * dirs2 + shift);
+    }
+};
+
+/*
+ computes disparity for "roi" in img1 w.r.t. img2 and write it to disp1buf.
+ that is, disp1buf(x, y)=d means that img1(x+roi.x, y+roi.y) ~ img2(x+roi.x-d, y+roi.y).
+ minD <= d < maxD.
+ disp2full is the reverse disparity map, that is:
+ disp2full(x+roi.x,y+roi.y)=d means that img2(x+roi.x, y+roi.y) ~ img1(x+roi.x+d, y+roi.y)
+
+ note that disp1buf will have the same size as the roi and
+ disp2full will have the same size as img1 (or img2).
+ On exit disp2buf is not the final disparity, it is an intermediate result that becomes
+ final after all the tiles are processed.
+
+ the disparity in disp1buf is written with sub-pixel accuracy
+ (4 fractional bits, see StereoSGBM::DISP_SCALE),
+ using quadratic interpolation, while the disparity in disp2buf
+ is written as is, without interpolation.
+
+ disp2cost also has the same size as img1 (or img2).
+ It contains the minimum current cost, used to find the best disparity, corresponding to the minimal cost.
+ */
+static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
+                                 Mat& disp1, const StereoSGBMParams& params )
+{
+    const int DISP_SHIFT = StereoMatcher::DISP_SHIFT;
+    const int DISP_SCALE = (1 << DISP_SHIFT);
+    const CostType MAX_COST = SHRT_MAX;
+
+    int minD = params.minDisparity, maxD = minD + params.numDisparities;
+    int uniquenessRatio = params.uniquenessRatio >= 0 ? params.uniquenessRatio : 10;
+    int disp12MaxDiff = params.disp12MaxDiff > 0 ? params.disp12MaxDiff : 1;
+    int P1 = params.P1 > 0 ? params.P1 : 2, P2 = std::max(params.P2 > 0 ? params.P2 : 5, P1+1);
+    int k, width = disp1.cols, height = disp1.rows;
+    int minX1 = std::max(maxD, 0), maxX1 = width + std::min(minD, 0);
+    const int D = params.numDisparities;
+    int width1 = maxX1 - minX1;
+    int Da = (int)alignSize(D,VTraits<v_int16>::vlanes());
+    int Dlra = Da + VTraits<v_int16>::vlanes();//Additional memory is necessary to store disparity values(MAX_COST) for d=-1 and d=D
+    int INVALID_DISP = minD - 1, INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
+    int SW2 = params.calcSADWindowSize().width/2, SH2 = params.calcSADWindowSize().height/2;
+    int npasses = params.isFullDP() ? 2 : 1;
+
+    CV_CheckGT(width - (params.minDisparity + params.numDisparities), params.calcSADWindowSize().width/2,
+     "Your input images are too small for your window size and max disparity, and will result in non-deterministic SGBM results");
+
+    if( minX1 >= maxX1 )
+    {
+        disp1 = Scalar::all(INVALID_DISP_SCALED);
+        return;
+    }
+
+    BufferSGBM mem(width1, Da, Dlra, img1.channels(), width, height, params);
+    mem.initCBuf((CostType)P2); // add P2 to every C(x,y). it saves a few operations in the inner loops
+
+    for( int pass = 1; pass <= npasses; pass++ )
+    {
+        int x1, y1, x2, y2, dx, dy;
+
+        if( pass == 1 )
+        {
+            y1 = 0; y2 = height; dy = 1;
+            x1 = 0; x2 = width1; dx = 1;
+        }
+        else
+        {
+            y1 = height-1; y2 = -1; dy = -1;
+            x1 = width1-1; x2 = -1; dx = -1;
+        }
+
+        uchar lrID = 0;
+        mem.clearLr();
+
+        for( int y = y1; y != y2; y += dy )
+        {
+            int x, d;
+            DispType* disp1ptr = disp1.ptr<DispType>(y);
+            CostType* const C = mem.getCBuf(y);
+            CostType* const S = mem.getSBuf(y);
+
+            if( pass == 1 ) // compute C on the first pass, and reuse it on the second pass, if any.
+            {
+                int dy1 = y == 0 ? 0 : y + SH2, dy2 = y == 0 ? SH2 : dy1;
+
+                for( k = dy1; k <= dy2; k++ )
+                {
+                    CostType* hsumAdd = mem.getHSumBuf(std::min(k, height-1));
+
+                    if( k < height )
+                    {
+                        calcPixelCostBT( img1, img2, k, minD, maxD, mem.pixDiff, mem.tempBuf, mem.getClipTab() );
+
+                        memset(hsumAdd, 0, Da*sizeof(CostType));
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                        v_int16 h_scale = vx_setall_s16((short)SW2 + 1);
+                        for( d = 0; d < Da; d += VTraits<v_int16>::vlanes() )
+                        {
+                            v_int16 v_hsumAdd = v_mul(vx_load_aligned(mem.pixDiff + d), h_scale);
+                            for( x = Da; x <= SW2*Da; x += Da )
+                                v_hsumAdd = v_add(v_hsumAdd, vx_load_aligned(mem.pixDiff + x + d));
+                            v_store_aligned(hsumAdd + d, v_hsumAdd);
+                        }
+#else
+                        for (d = 0; d < D; d++)
+                        {
+                            hsumAdd[d] = (CostType)(mem.pixDiff[d] * (SW2 + 1));
+                            for( x = Da; x <= SW2*Da; x += Da )
+                                hsumAdd[d] = (CostType)(hsumAdd[d] + mem.pixDiff[x + d]);
+                        }
+#endif
+
+                        if( y > 0 )
+                        {
+                            const CostType* hsumSub = mem.getHSumBuf(std::max(y - SH2 - 1, 0));
+                            const CostType* Cprev =  mem.getCBuf(y - 1);
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                            for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                                v_store_aligned(C + d, v_sub(v_add(vx_load_aligned(Cprev + d), vx_load_aligned(hsumAdd + d)), vx_load_aligned(hsumSub + d)));
+#else
+                            for (d = 0; d < D; d++)
+                                C[d] = (CostType)(Cprev[d] + hsumAdd[d] - hsumSub[d]);
+#endif
+
+                            for( x = Da; x < width1*Da; x += Da )
+                            {
+                                const CostType* pixAdd = mem.pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                                const CostType* pixSub = mem.pixDiff + std::max(x - (SW2+1)*Da, 0);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for( d = 0; d < Da; d += VTraits<v_int16>::vlanes() )
+                                {
+                                    v_int16 hv = v_add(v_sub(vx_load_aligned(hsumAdd + x - Da + d), vx_load_aligned(pixSub + d)), vx_load_aligned(pixAdd + d));
+                                    v_store_aligned(hsumAdd + x + d, hv);
+                                    v_store_aligned(C + x + d, v_add(v_sub(vx_load_aligned(Cprev + x + d), vx_load_aligned(hsumSub + x + d)), hv));
+                                }
+#else
+                                for( d = 0; d < D; d++ )
+                                {
+                                    int hv = hsumAdd[x + d] = (CostType)(hsumAdd[x - Da + d] + pixAdd[d] - pixSub[d]);
+                                    C[x + d] = (CostType)(Cprev[x + d] + hv - hsumSub[x + d]);
+                                }
+#endif
+                            }
+                        }
+                        else
+                        {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                            v_int16 v_scale = vx_setall_s16(k == 0 ? (short)SH2 + 1 : 1);
+                            for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                                v_store_aligned(C + d, v_add(vx_load_aligned(C + d), v_mul(vx_load_aligned(hsumAdd + d), v_scale)));
+#else
+                            int scale = k == 0 ? SH2 + 1 : 1;
+                            for (d = 0; d < D; d++)
+                                C[d] = (CostType)(C[d] + hsumAdd[d] * scale);
+#endif
+                            for( x = Da; x < width1*Da; x += Da )
+                            {
+                                const CostType* pixAdd = mem.pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                                const CostType* pixSub = mem.pixDiff + std::max(x - (SW2+1)*Da, 0);
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                                {
+                                    v_int16 hv = v_sub(v_add(vx_load_aligned(hsumAdd + x - Da + d), vx_load_aligned(pixAdd + d)), vx_load_aligned(pixSub + d));
+                                    v_store_aligned(hsumAdd + x + d, hv);
+                                    v_store_aligned(C + x + d, v_add(vx_load_aligned(C + x + d), v_mul(hv, v_scale)));
+                                }
+#else
+                                for( d = 0; d < D; d++ )
+                                {
+                                    CostType hv = (CostType)(hsumAdd[x - Da + d] + pixAdd[d] - pixSub[d]);
+                                    hsumAdd[x + d] = hv;
+                                    C[x + d] = (CostType)(C[x + d] + hv * scale);
+                                }
+#endif
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if( y > 0 )
+                        {
+                            const CostType* hsumSub = mem.getHSumBuf(std::max(y - SH2 - 1, 0));
+                            const CostType* Cprev = mem.getCBuf(y - 1);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                            for (x = 0; x < width1*Da; x += VTraits<v_int16>::vlanes())
+                                v_store_aligned(C + x, v_add(v_sub(vx_load_aligned(Cprev + x), vx_load_aligned(hsumSub + x)), vx_load_aligned(hsumAdd + x)));
+#else
+                            for (x = 0; x < width1*Da; x++)
+                                C[x] = (CostType)(Cprev[x] + hsumAdd[x] - hsumSub[x]);
+#endif
+                        }
+                        else
+                        {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                            for (x = 0; x < width1*Da; x += VTraits<v_int16>::vlanes())
+                                v_store_aligned(C + x, v_add(vx_load_aligned(C + x), vx_load_aligned(hsumAdd + x)));
+#else
+                            for (x = 0; x < width1*Da; x++)
+                                C[x] = (CostType)(C[x] + hsumAdd[x]);
+#endif
+                        }
+                    }
+
+                }
+
+                // also, clear the S buffer
+                mem.clearSBuf(y);
+            }
+
+            /*
+             [formula 13 in the paper]
+             compute L_r(p, d) = C(p, d) +
+             min(L_r(p-r, d),
+             L_r(p-r, d-1) + P1,
+             L_r(p-r, d+1) + P1,
+             min_k L_r(p-r, k) + P2) - min_k L_r(p-r, k)
+             where p = (x,y), r is one of the directions.
+             we process all the directions at once:
+             0: r=(-dx, 0)
+             1: r=(-1, -dy)
+             2: r=(0, -dy)
+             3: r=(1, -dy)   !!!Note that only directions 0 to 3 are processed
+             4: r=(-2, -dy)
+             5: r=(-1, -dy*2)
+             6: r=(1, -dy*2)
+             7: r=(2, -dy)
+             */
+
+            for( x = x1; x != x2; x += dx )
+            {
+                int delta0 = P2 + *mem.getMinLr(lrID, x - dx);
+                int delta1 = P2 + *mem.getMinLr(1 - lrID, x - 1, 1);
+                int delta2 = P2 + *mem.getMinLr(1 - lrID, x,     2);
+                int delta3 = P2 + *mem.getMinLr(1 - lrID, x + 1, 3);
+
+                CostType* Lr_p0 = mem.getLr(lrID, x - dx);
+                CostType* Lr_p1 = mem.getLr(1 - lrID, x - 1, 1);
+                CostType* Lr_p2 = mem.getLr(1 - lrID, x,     2);
+                CostType* Lr_p3 = mem.getLr(1 - lrID, x + 1, 3);
+
+                Lr_p0[-1] = Lr_p0[D] = MAX_COST;
+                Lr_p1[-1] = Lr_p1[D] = MAX_COST;
+                Lr_p2[-1] = Lr_p2[D] = MAX_COST;
+                Lr_p3[-1] = Lr_p3[D] = MAX_COST;
+
+                CostType* Lr_p = mem.getLr(lrID, x);
+                const CostType* Cp = C + x*Da;
+                CostType* Sp = S + x*Da;
+
+                CostType* minL = mem.getMinLr(lrID, x);
+                d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                v_int16 _P1 = vx_setall_s16((short)P1);
+
+                v_int16 _delta0 = vx_setall_s16((short)delta0);
+                v_int16 _delta1 = vx_setall_s16((short)delta1);
+                v_int16 _delta2 = vx_setall_s16((short)delta2);
+                v_int16 _delta3 = vx_setall_s16((short)delta3);
+                v_int16 _minL0 = vx_setall_s16((short)MAX_COST);
+                v_int16 _minL1 = vx_setall_s16((short)MAX_COST);
+                v_int16 _minL2 = vx_setall_s16((short)MAX_COST);
+                v_int16 _minL3 = vx_setall_s16((short)MAX_COST);
+
+                for( ; d <= D - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes() )
+                {
+                    v_int16 Cpd = vx_load_aligned(Cp + d);
+                    v_int16 Spd = vx_load_aligned(Sp + d);
+                    v_int16 L;
+
+                    L = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_p0 + d), v_add(vx_load(Lr_p0 + d - 1), _P1)), v_add(vx_load(Lr_p0 + d + 1), _P1)), _delta0), _delta0), Cpd);
+                    v_store_aligned(Lr_p + d, L);
+                    _minL0 = v_min(_minL0, L);
+                    Spd = v_add(Spd, L);
+
+                    L = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_p1 + d), v_add(vx_load(Lr_p1 + d - 1), _P1)), v_add(vx_load(Lr_p1 + d + 1), _P1)), _delta1), _delta1), Cpd);
+                    v_store_aligned(Lr_p + d + Dlra, L);
+                    _minL1 = v_min(_minL1, L);
+                    Spd = v_add(Spd, L);
+
+                    L = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_p2 + d), v_add(vx_load(Lr_p2 + d - 1), _P1)), v_add(vx_load(Lr_p2 + d + 1), _P1)), _delta2), _delta2), Cpd);
+                    v_store_aligned(Lr_p + d + Dlra*2, L);
+                    _minL2 = v_min(_minL2, L);
+                    Spd = v_add(Spd, L);
+
+                    L = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_p3 + d), v_add(vx_load(Lr_p3 + d - 1), _P1)), v_add(vx_load(Lr_p3 + d + 1), _P1)), _delta3), _delta3), Cpd);
+                    v_store_aligned(Lr_p + d + Dlra*3, L);
+                    _minL3 = v_min(_minL3, L);
+                    Spd = v_add(Spd, L);
+
+                    v_store_aligned(Sp + d, Spd);
+                }
+
+#if CV_SIMD_WIDTH > 32
+                minL[0] = v_reduce_min(_minL0);
+                minL[1] = v_reduce_min(_minL1);
+                minL[2] = v_reduce_min(_minL2);
+                minL[3] = v_reduce_min(_minL3);
+#else
+                // Get minimum for L0-L3
+                v_int16 t0, t1, t2, t3;
+                v_zip(_minL0, _minL2, t0, t2);
+                v_zip(_minL1, _minL3, t1, t3);
+                v_zip(v_min(t0, t2), v_min(t1, t3), t0, t1);
+                t0 = v_min(t0, t1);
+                t0 = v_min(t0, v_rotate_right<4>(t0));
+#if CV_SIMD_WIDTH == 32
+                CostType buf[VTraits<v_int16>::max_nlanes];
+                v_store_low(buf, v_min(t0, v_rotate_right<8>(t0)));
+                minL[0] = buf[0];
+                minL[1] = buf[1];
+                minL[2] = buf[2];
+                minL[3] = buf[3];
+#else
+                v_store_low(minL, t0);
+#endif
+#endif
+#else
+                minL[0] = MAX_COST;
+                minL[1] = MAX_COST;
+                minL[2] = MAX_COST;
+                minL[3] = MAX_COST;
+#endif
+                for( ; d < D; d++ )
+                {
+                    int Cpd = Cp[d], L;
+                    int Spd = Sp[d];
+
+                    L = Cpd + std::min((int)Lr_p0[d], std::min(Lr_p0[d - 1] + P1, std::min(Lr_p0[d + 1] + P1, delta0))) - delta0;
+                    Lr_p[d] = (CostType)L;
+                    minL[0] = std::min(minL[0], (CostType)L);
+                    Spd += L;
+
+                    L = Cpd + std::min((int)Lr_p1[d], std::min(Lr_p1[d - 1] + P1, std::min(Lr_p1[d + 1] + P1, delta1))) - delta1;
+                    Lr_p[d + Dlra] = (CostType)L;
+                    minL[1] = std::min(minL[1], (CostType)L);
+                    Spd += L;
+
+                    L = Cpd + std::min((int)Lr_p2[d], std::min(Lr_p2[d - 1] + P1, std::min(Lr_p2[d + 1] + P1, delta2))) - delta2;
+                    Lr_p[d + Dlra*2] = (CostType)L;
+                    minL[2] = std::min(minL[2], (CostType)L);
+                    Spd += L;
+
+                    L = Cpd + std::min((int)Lr_p3[d], std::min(Lr_p3[d - 1] + P1, std::min(Lr_p3[d + 1] + P1, delta3))) - delta3;
+                    Lr_p[d + Dlra*3] = (CostType)L;
+                    minL[3] = std::min(minL[3], (CostType)L);
+                    Spd += L;
+
+                    Sp[d] = saturate_cast<CostType>(Spd);
+                }
+            }
+
+            if( pass == npasses )
+            {
+                x = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                v_int16 v_inv_dist = vx_setall_s16((DispType)INVALID_DISP_SCALED);
+                v_int16 v_max_cost = vx_setall_s16(MAX_COST);
+                for( ; x <= width - VTraits<v_int16>::vlanes(); x += VTraits<v_int16>::vlanes() )
+                {
+                    v_store(disp1ptr + x, v_inv_dist);
+                    v_store(mem.disp2ptr + x, v_inv_dist);
+                    v_store(mem.disp2cost + x, v_max_cost);
+                }
+#endif
+                for( ; x < width; x++ )
+                {
+                    disp1ptr[x] = mem.disp2ptr[x] = (DispType)INVALID_DISP_SCALED;
+                    mem.disp2cost[x] = MAX_COST;
+                }
+
+                for( x = width1 - 1; x >= 0; x-- )
+                {
+                    CostType* Sp = S + x*Da;
+                    CostType minS = MAX_COST;
+                    short bestDisp = -1;
+
+                    if( npasses == 1 )
+                    {
+                        CostType* Lr_p0 = mem.getLr(lrID, x + 1);
+                        Lr_p0[-1] = Lr_p0[D] = MAX_COST;
+                        CostType* Lr_p = mem.getLr(lrID, x);
+
+                        const CostType* Cp = C + x*Da;
+
+                        d = 0;
+                        int delta0 = P2 + *mem.getMinLr(lrID, x + 1);
+                        int minL0 = MAX_COST;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                        v_int16 _P1 = vx_setall_s16((short)P1);
+                        v_int16 _delta0 = vx_setall_s16((short)delta0);
+
+                        v_int16 _minL0 = vx_setall_s16((short)MAX_COST);
+                        v_int16 _minS = vx_setall_s16(MAX_COST), _bestDisp = vx_setall_s16(-1);
+                        for( ; d <= D - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes() )
+                        {
+                            v_int16 Cpd = vx_load_aligned(Cp + d);
+                            v_int16 L0 = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_p0 + d), v_add(vx_load(Lr_p0 + d - 1), _P1)), v_add(vx_load(Lr_p0 + d + 1), _P1)), _delta0), _delta0), Cpd);
+
+                            v_store_aligned(Lr_p + d, L0);
+                            _minL0 = v_min(_minL0, L0);
+                            L0 = v_add(L0, vx_load_aligned(Sp + d));
+                            v_store_aligned(Sp + d, L0);
+
+                            _bestDisp = v_select(v_gt(_minS, L0), vx_setall_s16((short)d), _bestDisp);
+                            _minS = v_min(_minS, L0);
+                        }
+                        minL0 = (CostType)v_reduce_min(_minL0);
+                        min_pos(_minS, _bestDisp, minS, bestDisp);
+#endif
+                        for( ; d < D; d++ )
+                        {
+                            int L0 = Cp[d] + std::min((int)Lr_p0[d], std::min(Lr_p0[d-1] + P1, std::min(Lr_p0[d+1] + P1, delta0))) - delta0;
+
+                            Lr_p[d] = (CostType)L0;
+                            minL0 = std::min(minL0, L0);
+
+                            CostType Sval = Sp[d] = saturate_cast<CostType>(Sp[d] + L0);
+                            if( Sval < minS )
+                            {
+                                minS = Sval;
+                                bestDisp = (short)d;
+                            }
+                        }
+                        *mem.getMinLr(lrID, x) = (CostType)minL0;
+                    }
+                    else
+                    {
+                        d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                        v_int16 _minS = vx_setall_s16(MAX_COST), _bestDisp = vx_setall_s16(-1);
+                        for( ; d <= D - VTraits<v_int16>::vlanes(); d+= VTraits<v_int16>::vlanes() )
+                        {
+                            v_int16 L0 = vx_load_aligned(Sp + d);
+                            _bestDisp = v_select(v_gt(_minS, L0), vx_setall_s16((short)d), _bestDisp);
+                            _minS = v_min( L0, _minS );
+                        }
+                        min_pos(_minS, _bestDisp, minS, bestDisp);
+#endif
+                        for( ; d < D; d++ )
+                        {
+                            int Sval = Sp[d];
+                            if( Sval < minS )
+                            {
+                                minS = (CostType)Sval;
+                                bestDisp = (short)d;
+                            }
+                        }
+                    }
+
+                    for( d = 0; d < D; d++ )
+                    {
+                        if( Sp[d]*(100 - uniquenessRatio) < minS*100 && std::abs(bestDisp - d) > 1 )
+                            break;
+                    }
+                    if( d < D )
+                        continue;
+                    d = bestDisp;
+                    int _x2 = x + minX1 - d - minD;
+                    if( mem.disp2cost[_x2] > minS )
+                    {
+                        mem.disp2cost[_x2] = (CostType)minS;
+                        mem.disp2ptr[_x2] = (DispType)(d + minD);
+                    }
+
+                    if( 0 < d && d < D-1 )
+                    {
+                        // do subpixel quadratic interpolation:
+                        //   fit parabola into (x1=d-1, y1=Sp[d-1]), (x2=d, y2=Sp[d]), (x3=d+1, y3=Sp[d+1])
+                        //   then find minimum of the parabola.
+                        int denom2 = std::max(Sp[d-1] + Sp[d+1] - 2*Sp[d], 1);
+                        d = d*DISP_SCALE + ((Sp[d-1] - Sp[d+1])*DISP_SCALE + denom2)/(denom2*2);
+                    }
+                    else
+                        d *= DISP_SCALE;
+                    disp1ptr[x + minX1] = (DispType)(d + minD*DISP_SCALE);
+                }
+
+                for( x = minX1; x < maxX1; x++ )
+                {
+                    // we round the computed disparity both towards -inf and +inf and check
+                    // if either of the corresponding disparities in disp2 is consistent.
+                    // This is to give the computed disparity a chance to look valid if it is.
+                    int d1 = disp1ptr[x];
+                    if( d1 == INVALID_DISP_SCALED )
+                        continue;
+                    int _d = d1 >> DISP_SHIFT;
+                    int d_ = (d1 + DISP_SCALE-1) >> DISP_SHIFT;
+                    int _x = x - _d, x_ = x - d_;
+                    if( 0 <= _x && _x < width && mem.disp2ptr[_x] >= minD && std::abs(mem.disp2ptr[_x] - _d) > disp12MaxDiff &&
+                       0 <= x_ && x_ < width && mem.disp2ptr[x_] >= minD && std::abs(mem.disp2ptr[x_] - d_) > disp12MaxDiff )
+                        disp1ptr[x] = (DispType)INVALID_DISP_SCALED;
+                }
+            }
+
+            lrID = 1 - lrID; // now shift the cyclic buffers
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+struct CalcVerticalSums: public ParallelLoopBody
+{
+    CalcVerticalSums(const Mat& _img1, const Mat& _img2, const StereoSGBMParams& params, const BufferSGBM &mem_)
+        : img1(_img1), img2(_img2), mem(mem_)
+    {
+        minD = params.minDisparity;
+        maxD = minD + params.numDisparities;
+        SW2 = SH2 = params.calcSADWindowSize().height/2;
+        P1 = params.P1 > 0 ? params.P1 : 2;
+        P2 = std::max(params.P2 > 0 ? params.P2 : 5, P1+1);
+        height = img1.rows;
+        width = img1.cols;
+        int minX1 = std::max(maxD, 0), maxX1 = width + std::min(minD, 0);
+        D = maxD - minD;
+        Da = (int)alignSize(D, VTraits<v_int16>::vlanes());
+        Dlra = Da + VTraits<v_int16>::vlanes();//Additional memory is necessary to store disparity values(MAX_COST) for d=-1 and d=D
+        width1 = maxX1 - minX1;
+        D = params.numDisparities;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        const CostType MAX_COST = SHRT_MAX;
+        const int npasses = 2;
+        const int x1 = range.start, x2 = range.end;
+        int k;
+
+        CostType* pixDiff = 0;
+        PixType* tempBuf = 0;
+        utils::BufferArea aux_area;
+        aux_area.allocate(pixDiff, ((x2 - x1) + 2 * SW2) * Da, CV_SIMD_WIDTH);
+        aux_area.allocate(tempBuf, width * (4 * img1.channels() + 2) * sizeof(PixType), CV_SIMD_WIDTH);
+        aux_area.commit();
+
+        // Simplification of index calculation
+        if (x1 > SW2)
+            pixDiff -= (x1 - SW2) * Da;
+
+        for( int pass = 1; pass <= npasses; pass++ )
+        {
+            int y1, y2, dy;
+
+            if( pass == 1 )
+            {
+                y1 = 0; y2 = height; dy = 1;
+            }
+            else
+            {
+                y1 = height-1; y2 = -1; dy = -1;
+            }
+
+            uchar lrID = 0;
+            mem.clearLr(range);
+
+            for( int y = y1; y != y2; y += dy )
+            {
+                int x, d;
+                CostType* C = mem.getCBuf(y);
+                CostType* S = mem.getSBuf(y);
+
+                if( pass == 1 ) // compute C on the first pass, and reuse it on the second pass, if any.
+                {
+                    int dy1 = y == 0 ? 0 : y + SH2, dy2 = y == 0 ? SH2 : dy1;
+
+                    for( k = dy1; k <= dy2; k++ )
+                    {
+                        CostType* hsumAdd = mem.getHSumBuf(std::min(k, height-1));
+
+                        if( k < height )
+                        {
+                            calcPixelCostBT( img1, img2, k, minD, maxD, pixDiff, tempBuf, mem.getClipTab(), x1 - SW2, x2 + SW2);
+
+                            memset(hsumAdd + x1*Da, 0, Da*sizeof(CostType));
+                            for( x = (x1 - SW2)*Da; x <= (x1 + SW2)*Da; x += Da )
+                            {
+                                int xbord = x <= 0 ? 0 : (x > (width1 - 1)*Da ? (width1 - 1)*Da : x);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for( d = 0; d < Da; d += VTraits<v_int16>::vlanes() )
+                                    v_store_aligned(hsumAdd + x1*Da + d, v_add(vx_load_aligned(hsumAdd + x1 * this->Da + d), vx_load_aligned(pixDiff + xbord + d)));
+#else
+                                for( d = 0; d < D; d++ )
+                                    hsumAdd[x1*Da + d] = (CostType)(hsumAdd[x1*Da + d] + pixDiff[xbord + d]);
+#endif
+                            }
+
+                            if( y > 0 )
+                            {
+                                const CostType* hsumSub =  mem.getHSumBuf(std::max(y - SH2 - 1, 0));
+                                const CostType* Cprev = mem.getCBuf(y - 1);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for( d = 0; d < Da; d += VTraits<v_int16>::vlanes() )
+                                    v_store_aligned(C + x1*Da + d, v_sub(v_add(vx_load_aligned(Cprev + x1 * this->Da + d), vx_load_aligned(hsumAdd + x1 * this->Da + d)), vx_load_aligned(hsumSub + x1 * this->Da + d)));
+#else
+                                for( d = 0; d < D; d++ )
+                                    C[x1*Da + d] = (CostType)(Cprev[x1*Da + d] + hsumAdd[x1*Da + d] - hsumSub[x1*Da + d]);
+#endif
+                                for( x = (x1+1)*Da; x < x2*Da; x += Da )
+                                {
+                                    const CostType* pixAdd = pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                                    const CostType* pixSub = pixDiff + std::max(x - (SW2+1)*Da, 0);
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                    for( d = 0; d < Da; d += VTraits<v_int16>::vlanes() )
+                                    {
+                                        v_int16 hv = v_add(v_sub(vx_load_aligned(hsumAdd + x - this->Da + d), vx_load_aligned(pixSub + d)), vx_load_aligned(pixAdd + d));
+                                        v_store_aligned(hsumAdd + x + d, hv);
+                                        v_store_aligned(C + x + d, v_add(v_sub(vx_load_aligned(Cprev + x + d), vx_load_aligned(hsumSub + x + d)), hv));
+                                    }
+#else
+                                    for( d = 0; d < D; d++ )
+                                    {
+                                        int hv = hsumAdd[x + d] = (CostType)(hsumAdd[x - Da + d] + pixAdd[d] - pixSub[d]);
+                                        C[x + d] = (CostType)(Cprev[x + d] + hv - hsumSub[x + d]);
+                                    }
+#endif
+                                }
+                            }
+                            else
+                            {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                v_int16 v_scale = vx_setall_s16(k == 0 ? (short)SH2 + 1 : 1);
+                                for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                                    v_store_aligned(C + x1*Da + d, v_add(vx_load_aligned(C + x1 * this->Da + d), v_mul(vx_load_aligned(hsumAdd + x1 * this->Da + d), v_scale)));
+#else
+                                int scale = k == 0 ? SH2 + 1 : 1;
+                                for (d = 0; d < D; d++)
+                                    C[x1*Da + d] = (CostType)(C[x1*Da + d] + hsumAdd[x1*Da + d] * scale);
+#endif
+                                for( x = (x1+1)*Da; x < x2*Da; x += Da )
+                                {
+                                    const CostType* pixAdd = pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                                    const CostType* pixSub = pixDiff + std::max(x - (SW2+1)*Da, 0);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                    for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                                    {
+                                        v_int16 hv = v_sub(v_add(vx_load_aligned(hsumAdd + x - this->Da + d), vx_load_aligned(pixAdd + d)), vx_load_aligned(pixSub + d));
+                                        v_store_aligned(hsumAdd + x + d, hv);
+                                        v_store_aligned(C + x + d, v_add(vx_load_aligned(C + x + d), v_mul(hv, v_scale)));
+                                    }
+#else
+                                    for( d = 0; d < D; d++ )
+                                    {
+                                        CostType hv = (CostType)(hsumAdd[x - Da + d] + pixAdd[d] - pixSub[d]);
+                                        hsumAdd[x + d] = hv;
+                                        C[x + d] = (CostType)(C[x + d] + hv * scale);
+                                    }
+#endif
+                                }
+                            }
+                        }
+                        else
+                        {
+/*                            if (y > 0)
+                            {
+                                const CostType* hsumSub = mem.getHSumBuf(std::max(y - SH2 - 1, 0));
+                                const CostType* Cprev = mem.getCBuf(y - 1);
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for( x = x1*Da; x < x2*Da; x += VTraits<v_int16>::vlanes() )
+                                    v_store_aligned(C + x, v_add(v_sub(vx_load_aligned(Cprev + x), vx_load_aligned(hsumSub + x)), vx_load_aligned(hsumAdd + x)));
+#else
+                                for( x = x1*Da; x < x2*Da; x++ )
+                                    C[x] = (CostType)(Cprev[x] + hsumAdd[x] - hsumSub[x]);
+#endif
+                            }
+                            else*/
+                            if(y == 0)
+                            {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                                for( x = x1*Da; x < x2*Da; x += VTraits<v_int16>::vlanes() )
+                                    v_store_aligned(C + x, v_add(vx_load_aligned(C + x), vx_load_aligned(hsumAdd + x)));
+#else
+                                for( x = x1*Da; x < x2*Da; x++ )
+                                    C[x] = (CostType)(C[x] + hsumAdd[x]);
+#endif
+                            }
+                        }
+                    }
+                    mem.clearSBuf(y, range);
+                }
+
+//              [formula 13 in the paper]
+//              compute L_r(p, d) = C(p, d) +
+//              min(L_r(p-r, d),
+//              L_r(p-r, d-1) + P1,
+//              L_r(p-r, d+1) + P1,
+//              min_k L_r(p-r, k) + P2) - min_k L_r(p-r, k)
+//              where p = (x,y), r is one of the directions.
+//              we process one directions on first pass and other on second:
+//              r=(0, dy), where dy=1 on first pass and dy=-1 on second
+
+                for( x = x1; x != x2; x++ )
+                {
+                    int delta = P2 + *mem.getMinLr(1 - lrID, x);
+                    CostType* Lr_ppr = mem.getLr(1 - lrID, x);
+
+                    Lr_ppr[-1] = Lr_ppr[D] = MAX_COST;
+
+                    CostType* Lr_p = mem.getLr(lrID, x);
+                    const CostType* Cp = C + x*Da;
+                    CostType* Sp = S + x*Da;
+
+                    CostType& minL = *(mem.getMinLr(lrID, x));
+                    d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                    v_int16 _P1 = vx_setall_s16((short)P1);
+
+                    v_int16 _delta = vx_setall_s16((short)delta);
+                    v_int16 _minL = vx_setall_s16((short)MAX_COST);
+
+                    for( ; d <= D - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes() )
+                    {
+                        v_int16 Cpd = vx_load_aligned(Cp + d);
+                        v_int16 L = v_add(v_sub(v_min(v_min(v_min(vx_load_aligned(Lr_ppr + d), v_add(vx_load(Lr_ppr + d - 1), _P1)), v_add(vx_load(Lr_ppr + d + 1), _P1)), _delta), _delta), Cpd);
+                        v_store_aligned(Lr_p + d, L);
+                        _minL = v_min(_minL, L);
+                        v_store_aligned(Sp + d, v_add(vx_load_aligned(Sp + d), L));
+                    }
+                    minL = v_reduce_min(_minL);
+#else
+                    minL = MAX_COST;
+#endif
+                    for( ; d < D; d++ )
+                    {
+                        int Cpd = Cp[d], L;
+
+                        L = Cpd + std::min((int)Lr_ppr[d], std::min(Lr_ppr[d-1] + P1, std::min(Lr_ppr[d+1] + P1, delta))) - delta;
+
+                        Lr_p[d] = (CostType)L;
+                        minL = std::min(minL, (CostType)L);
+
+                        Sp[d] = saturate_cast<CostType>(Sp[d] + L);
+                    }
+                }
+                lrID = 1 - lrID; // now shift the cyclic buffers
+            }
+        }
+    }
+    const Mat& img1;
+    const Mat& img2;
+    const BufferSGBM & mem;
+    int minD;
+    int maxD;
+    int D, Da, Dlra;
+    int SH2;
+    int SW2;
+    int width;
+    int width1;
+    int height;
+    int P1;
+    int P2;
+};
+
+struct CalcHorizontalSums: public ParallelLoopBody
+{
+    CalcHorizontalSums(const Mat& _img1, const Mat& _img2, Mat& _disp1, const StereoSGBMParams& params, const BufferSGBM &mem_)
+        : img1(_img1), img2(_img2), disp1(_disp1), mem(mem_)
+    {
+        minD = params.minDisparity;
+        maxD = minD + params.numDisparities;
+        P1 = params.P1 > 0 ? params.P1 : 2;
+        P2 = std::max(params.P2 > 0 ? params.P2 : 5, P1+1);
+        uniquenessRatio = params.uniquenessRatio >= 0 ? params.uniquenessRatio : 10;
+        disp12MaxDiff = params.disp12MaxDiff > 0 ? params.disp12MaxDiff : 1;
+        height = img1.rows;
+        width = img1.cols;
+        minX1 = std::max(maxD, 0);
+        maxX1 = width + std::min(minD, 0);
+        INVALID_DISP = minD - 1;
+        INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
+        D = maxD - minD;
+        Da = (int)alignSize(D, VTraits<v_int16>::vlanes());
+        Dlra = Da + VTraits<v_int16>::vlanes();//Additional memory is necessary to store disparity values(MAX_COST) for d=-1 and d=D
+        width1 = maxX1 - minX1;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        int y1 = range.start, y2 = range.end;
+
+        const size_t LrSize = 2 * (1 + Dlra + 1);
+
+        CostType * Lr = 0;
+        CostType * disp2cost = 0;
+        DispType * disp2ptr = 0;
+        utils::BufferArea aux_area;
+        aux_area.allocate(Lr, LrSize);
+        aux_area.allocate(disp2cost, width, CV_SIMD_WIDTH);
+        aux_area.allocate(disp2ptr, width, CV_SIMD_WIDTH);
+        aux_area.commit();
+
+        CostType minLr;
+
+        for( int y = y1; y != y2; y++)
+        {
+            int x, d;
+            DispType* disp1ptr = disp1.ptr<DispType>(y);
+            CostType* C = mem.getCBuf(y);
+            CostType* S = mem.getSBuf(y);
+
+            x = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            v_int16 v_inv_dist = vx_setall_s16((DispType)INVALID_DISP_SCALED);
+            v_int16 v_max_cost = vx_setall_s16(MAX_COST);
+            for (; x <= width - VTraits<v_int16>::vlanes(); x += VTraits<v_int16>::vlanes())
+            {
+                v_store(disp1ptr + x, v_inv_dist);
+                v_store(disp2ptr + x, v_inv_dist);
+                v_store(disp2cost + x, v_max_cost);
+            }
+#endif
+            for( ; x < width; x++ )
+            {
+                disp1ptr[x] = disp2ptr[x] = (DispType)INVALID_DISP_SCALED;
+                disp2cost[x] = MAX_COST;
+            }
+
+            // clear buffers
+            aux_area.zeroFill(Lr);
+            Lr[0] = Lr[1 + D] = Lr[3 + Dlra - 1] = Lr[3 + Dlra + D] = MAX_COST;
+
+            minLr = 0;
+//          [formula 13 in the paper]
+//          compute L_r(p, d) = C(p, d) +
+//          min(L_r(p-r, d),
+//          L_r(p-r, d-1) + P1,
+//          L_r(p-r, d+1) + P1,
+//          min_k L_r(p-r, k) + P2) - min_k L_r(p-r, k)
+//          where p = (x,y), r is one of the directions.
+//          we process all the directions at once:
+//          we process one directions on first pass and other on second:
+//          r=(dx, 0), where dx=1 on first pass and dx=-1 on second
+            for( x = 0; x != width1; x++)
+            {
+                int delta = minLr + P2;
+                CostType* Lr_ppr = Lr + ((x&1)? 1 : 3 + Dlra);
+                CostType* Lr_p = Lr + ((x&1)? 3 + Dlra : 1);
+                const CostType* Cp = C + x*Da;
+                CostType* Sp = S + x*Da;
+
+                d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                v_int16 _P1 = vx_setall_s16((short)P1);
+
+                v_int16 _delta = vx_setall_s16((short)delta);
+                v_int16 _minL = vx_setall_s16((short)MAX_COST);
+
+                for( ; d <= D - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes())
+                {
+                    v_int16 Cpd = vx_load_aligned(Cp + d);
+                    v_int16 L = v_add(v_sub(v_min(v_min(v_min(vx_load(Lr_ppr + d), v_add(vx_load(Lr_ppr + d - 1), _P1)), v_add(vx_load(Lr_ppr + d + 1), _P1)), _delta), _delta), Cpd);
+                    v_store(Lr_p + d, L);
+                    _minL = v_min(_minL, L);
+                    v_store_aligned(Sp + d, v_add(vx_load_aligned(Sp + d), L));
+                }
+                minLr = v_reduce_min(_minL);
+#else
+                minLr = MAX_COST;
+#endif
+                for( ; d < D; d++ )
+                {
+                    int Cpd = Cp[d], L;
+                    L = Cpd + std::min((int)Lr_ppr[d], std::min(Lr_ppr[d-1] + P1, std::min(Lr_ppr[d+1] + P1, delta))) - delta;
+                    Lr_p[d] = (CostType)L;
+                    minLr = std::min(minLr, (CostType)L);
+                    Sp[d] = saturate_cast<CostType>(Sp[d] + L);
+                }
+            }
+
+            aux_area.zeroFill(Lr);
+            Lr[0] = Lr[1 + D] = Lr[3 + Dlra - 1] = Lr[3 + Dlra + D] = MAX_COST;
+
+            minLr = 0;
+
+            for( x = width1-1; x != -1; x--)
+            {
+                int delta = minLr + P2;
+                CostType* Lr_ppr = Lr + ((x&1)? 1 : 3 + Dlra);
+                CostType* Lr_p = Lr + ((x&1)? 3 + Dlra : 1);
+                const CostType* Cp = C + x*Da;
+                CostType* Sp = S + x*Da;
+                CostType minS = MAX_COST;
+                short bestDisp = -1;
+                minLr = MAX_COST;
+
+                d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                v_int16 _P1 = vx_setall_s16((short)P1);
+                v_int16 _delta = vx_setall_s16((short)delta);
+
+                v_int16 _minL = vx_setall_s16((short)MAX_COST);
+                v_int16 _minS = vx_setall_s16(MAX_COST), _bestDisp = vx_setall_s16(-1);
+                for( ; d <= D - VTraits<v_int16>::vlanes(); d += VTraits<v_int16>::vlanes() )
+                {
+                    v_int16 Cpd = vx_load_aligned(Cp + d);
+                    v_int16 L = v_add(v_sub(v_min(v_min(v_min(vx_load(Lr_ppr + d), v_add(vx_load(Lr_ppr + d - 1), _P1)), v_add(vx_load(Lr_ppr + d + 1), _P1)), _delta), _delta), Cpd);
+                    v_store(Lr_p + d, L);
+                    _minL = v_min(_minL, L);
+                    L = v_add(L, vx_load_aligned(Sp + d));
+                    v_store_aligned(Sp + d, L);
+
+                    _bestDisp = v_select(v_gt(_minS, L), vx_setall_s16((short)d), _bestDisp);
+                    _minS = v_min( L, _minS );
+                }
+                minLr = v_reduce_min(_minL);
+
+                min_pos(_minS, _bestDisp, minS, bestDisp);
+#endif
+                for( ; d < D; d++ )
+                {
+                    int Cpd = Cp[d], L;
+
+                    L = Cpd + std::min((int)Lr_ppr[d], std::min(Lr_ppr[d-1] + P1, std::min(Lr_ppr[d+1] + P1, delta))) - delta;
+
+                    Lr_p[d] = (CostType)L;
+                    minLr = std::min(minLr, (CostType)L);
+
+                    Sp[d] = saturate_cast<CostType>(Sp[d] + L);
+                    if( Sp[d] < minS )
+                    {
+                        minS = Sp[d];
+                        bestDisp = (short)d;
+                    }
+                }
+
+                //Some postprocessing procedures and saving
+                for( d = 0; d < D; d++ )
+                {
+                    if( Sp[d]*(100 - uniquenessRatio) < minS*100 && std::abs(bestDisp - d) > 1 )
+                        break;
+                }
+                if( d < D )
+                    continue;
+                d = bestDisp;
+                int _x2 = x + minX1 - d - minD;
+                if( disp2cost[_x2] > minS )
+                {
+                    disp2cost[_x2] = (CostType)minS;
+                    disp2ptr[_x2] = (DispType)(d + minD);
+                }
+
+                if( 0 < d && d < D-1 )
+                {
+                    // do subpixel quadratic interpolation:
+                    //   fit parabola into (x1=d-1, y1=Sp[d-1]), (x2=d, y2=Sp[d]), (x3=d+1, y3=Sp[d+1])
+                    //   then find minimum of the parabola.
+                    int denom2 = std::max(Sp[d-1] + Sp[d+1] - 2*Sp[d], 1);
+                    d = d*DISP_SCALE + ((Sp[d-1] - Sp[d+1])*DISP_SCALE + denom2)/(denom2*2);
+                }
+                else
+                    d *= DISP_SCALE;
+                disp1ptr[x + minX1] = (DispType)(d + minD*DISP_SCALE);
+            }
+            //Left-right check sanity procedure
+            for( x = minX1; x < maxX1; x++ )
+            {
+                // we round the computed disparity both towards -inf and +inf and check
+                // if either of the corresponding disparities in disp2 is consistent.
+                // This is to give the computed disparity a chance to look valid if it is.
+                int d1 = disp1ptr[x];
+                if( d1 == INVALID_DISP_SCALED )
+                    continue;
+                int _d = d1 >> DISP_SHIFT;
+                int d_ = (d1 + DISP_SCALE-1) >> DISP_SHIFT;
+                int _x = x - _d, x_ = x - d_;
+                if( 0 <= _x && _x < width && disp2ptr[_x] >= minD && std::abs(disp2ptr[_x] - _d) > disp12MaxDiff &&
+                   0 <= x_ && x_ < width && disp2ptr[x_] >= minD && std::abs(disp2ptr[x_] - d_) > disp12MaxDiff )
+                    disp1ptr[x] = (DispType)INVALID_DISP_SCALED;
+            }
+        }
+    }
+
+    static const int DISP_SHIFT = StereoMatcher::DISP_SHIFT;
+    static const int DISP_SCALE = (1 << DISP_SHIFT);
+    static const CostType MAX_COST = SHRT_MAX;
+    const Mat& img1;
+    const Mat& img2;
+    Mat& disp1;
+    const BufferSGBM & mem;
+    int minD;
+    int maxD;
+    int D, Da, Dlra;
+    int width;
+    int width1;
+    int height;
+    int P1;
+    int P2;
+    int minX1;
+    int maxX1;
+    int INVALID_DISP;
+    int INVALID_DISP_SCALED;
+    int uniquenessRatio;
+    int disp12MaxDiff;
+};
+/*
+ computes disparity for "roi" in img1 w.r.t. img2 and write it to disp1buf.
+ that is, disp1buf(x, y)=d means that img1(x+roi.x, y+roi.y) ~ img2(x+roi.x-d, y+roi.y).
+ minD <= d < maxD.
+
+ note that disp1buf will have the same size as the roi and
+ On exit disp1buf is not the final disparity, it is an intermediate result that becomes
+ final after all the tiles are processed.
+
+ the disparity in disp1buf is written with sub-pixel accuracy
+ (4 fractional bits, see StereoSGBM::DISP_SCALE),
+ using quadratic interpolation, while the disparity in disp2buf
+ is written as is, without interpolation.
+ */
+static void computeDisparitySGBM_HH4( const Mat& img1, const Mat& img2,
+                                 Mat& disp1, const StereoSGBMParams& params)
+{
+    const int DISP_SHIFT = StereoMatcher::DISP_SHIFT;
+    const int DISP_SCALE = (1 << DISP_SHIFT);
+    int minD = params.minDisparity, maxD = minD + params.numDisparities;
+    Size SADWindowSize;
+    SADWindowSize.width = SADWindowSize.height = params.SADWindowSize > 0 ? params.SADWindowSize : 5;
+    int P1 = params.P1 > 0 ? params.P1 : 2, P2 = std::max(params.P2 > 0 ? params.P2 : 5, P1+1);
+    int width = disp1.cols, height = disp1.rows;
+    int minX1 = std::max(maxD, 0), maxX1 = width + std::min(minD, 0);
+    int width1 = maxX1 - minX1;
+    int Da = (int)alignSize(params.numDisparities, VTraits<v_int16>::vlanes());
+    int Dlra = Da + VTraits<v_int16>::vlanes();//Additional memory is necessary to store disparity values(MAX_COST) for d=-1 and d=D
+    int INVALID_DISP = minD - 1;
+    int INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
+
+    if( minX1 >= maxX1 )
+    {
+        disp1 = Scalar::all(INVALID_DISP_SCALED);
+        return;
+    }
+
+    BufferSGBM mem(width1, Da, Dlra, img1.channels(), width, height, params);
+    mem.initCBuf((CostType)P2); // add P2 to every C(x,y). it saves a few operations in the inner loops
+
+    parallel_for_(Range(0,width1),CalcVerticalSums(img1, img2, params, mem),8);
+    parallel_for_(Range(0,height),CalcHorizontalSums(img1, img2, disp1, params, mem),8);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class BufferSGBM3Way
+{
+private:
+    size_t hsumCols;
+    size_t hsumRows;
+public:
+    CostType *curCostVolumeLine;
+    CostType *hsumBuf;
+    CostType *pixDiff;
+    PixType *tmpBuf;
+    CostType *horPassCostVolume;
+    CostType *vertPassCostVolume;
+    CostType *vertPassMin;
+    CostType *rightPassBuf;
+    CostType *disp2CostBuf;
+    short *disp2Buf;
+private:
+    utils::BufferArea area;
+public:
+    BufferSGBM3Way(int width1, int width, int num_ch, int Da, int SH2, int P2) :
+        curCostVolumeLine(0),
+        hsumBuf(0),
+        pixDiff(0),
+        tmpBuf(0),
+        horPassCostVolume(0),
+        vertPassCostVolume(0),
+        vertPassMin(0),
+        rightPassBuf(0),
+        disp2CostBuf(0),
+        disp2Buf(0)
+    {
+        hsumCols = width1 * Da;
+        hsumRows = SH2*2 + 2;
+        area.allocate(curCostVolumeLine, hsumCols, CV_SIMD_WIDTH);
+        area.allocate(hsumBuf, hsumCols * hsumRows, CV_SIMD_WIDTH);
+        area.allocate(pixDiff,hsumCols, CV_SIMD_WIDTH);
+        area.allocate(tmpBuf, width * (4 * num_ch + 2), CV_SIMD_WIDTH);
+        area.allocate(horPassCostVolume, (width1 + 2) * Da, CV_SIMD_WIDTH);
+        area.allocate(vertPassCostVolume, (width1 + 2) * Da, CV_SIMD_WIDTH);
+        area.allocate(vertPassMin, width1 + 2, CV_SIMD_WIDTH);
+        area.allocate(rightPassBuf, Da, CV_SIMD_WIDTH);
+        area.allocate(disp2CostBuf, width, CV_SIMD_WIDTH);
+        area.allocate(disp2Buf, width, CV_SIMD_WIDTH);
+        area.commit();
+        area.zeroFill();
+        for(size_t i = 0; i < hsumCols; i++)
+            curCostVolumeLine[i] = (CostType)P2;
+    }
+    inline void clearRightPassBuf()
+    {
+        area.zeroFill(rightPassBuf);
+    }
+    CostType *getHSumBuf(int x) const
+    {
+        return hsumBuf + (x % hsumRows) * hsumCols;
+    }
+};
+
+struct SGBM3WayMainLoop : public ParallelLoopBody
+{
+    const Mat *img1, *img2;
+    Mat* dst_disp;
+
+    int stripe_sz;
+    int stripe_overlap;
+
+    int width,height;
+    int minD, maxD, D, Da;
+    int minX1, maxX1, width1;
+
+    int SW2, SH2;
+    int P1, P2;
+    int uniquenessRatio, disp12MaxDiff;
+
+    int TAB_OFS;
+
+    utils::BufferArea aux_area;
+    PixType* clipTab;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    short idx_row[VTraits<v_int16>::max_nlanes];
+#endif
+    SGBM3WayMainLoop(const Mat& _img1, const Mat& _img2, Mat* _dst_disp, const StereoSGBMParams& params, int stripe_size, int _stripe_overlap);
+    void operator () (const Range& range) const CV_OVERRIDE;
+    template<bool x_nlanes> void impl(const Range& range) const;
+
+private:
+    void getRawMatchingCost(const BufferSGBM3Way &mem, int y, int src_start_idx) const;
+
+    template<bool x_nlanes>
+    void accumulateCostsLeftTop(const BufferSGBM3Way &mem,
+                                int x,
+                                CostType &leftMinCost) const;
+
+    template<bool x_nlanes>
+    void accumulateCostsRight(const BufferSGBM3Way &mem,
+                              int x,
+                              CostType &rightMinCost,
+                              short &optimal_disp,
+                              CostType &min_cost) const;
+};
+
+SGBM3WayMainLoop::SGBM3WayMainLoop(const Mat& _img1,
+                                   const Mat& _img2,
+                                   Mat* _dst_disp,
+                                   const StereoSGBMParams& params,
+                                   int _stripe_sz,
+                                   int _stripe_overlap)
+    : img1(&_img1),
+    img2(&_img2),
+    dst_disp(_dst_disp),
+    stripe_sz(_stripe_sz),
+    stripe_overlap(_stripe_overlap),
+    clipTab(0)
+{
+    // precompute a lookup table for the raw matching cost computation:
+    TAB_OFS = 256*4;
+    const int TAB_SIZE = 256 + TAB_OFS*2;
+    aux_area.allocate(clipTab, TAB_SIZE, CV_SIMD_WIDTH);
+    aux_area.commit();
+    const int ftzero = std::max(params.preFilterCap, 15) | 1;
+    for(int k = 0; k < TAB_SIZE; k++ )
+        clipTab[k] = (PixType)(std::min(std::max(k - TAB_OFS, -ftzero), ftzero) + ftzero);
+
+    width = img1->cols; height = img1->rows;
+    minD = params.minDisparity; maxD = minD + params.numDisparities; D = maxD - minD;
+    minX1 = std::max(maxD, 0); maxX1 = width + std::min(minD, 0); width1 = maxX1 - minX1;
+    Da = (int)alignSize(D, VTraits<v_int16>::vlanes());
+
+    SW2 = SH2 = params.SADWindowSize > 0 ? params.SADWindowSize/2 : 1;
+
+    P1 = params.P1 > 0 ? params.P1 : 2; P2 = std::max(params.P2 > 0 ? params.P2 : 5, P1+1);
+    uniquenessRatio = params.uniquenessRatio >= 0 ? params.uniquenessRatio : 10;
+    disp12MaxDiff = params.disp12MaxDiff > 0 ? params.disp12MaxDiff : 1;
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    for(short i = 0; i < VTraits<v_int16>::vlanes(); ++i)
+        idx_row[i] = i;
+#endif
+}
+
+// performing block matching and building raw cost-volume for the current row
+void SGBM3WayMainLoop::getRawMatchingCost(const BufferSGBM3Way &mem, int y, int src_start_idx) const
+{
+    CostType* C = mem.curCostVolumeLine;
+    CostType* pixDiff = mem.pixDiff;
+    PixType* tmpBuf = mem.tmpBuf;
+    int x, d;
+    int dy1 = (y == src_start_idx) ? src_start_idx : y + SH2, dy2 = (y == src_start_idx) ? src_start_idx+SH2 : dy1;
+
+    for(int k = dy1; k <= dy2; k++ )
+    {
+        CostType* hsumAdd = mem.getHSumBuf(std::min(k, height-1));
+        if( k < height )
+        {
+            calcPixelCostBT( *img1, *img2, k, minD, maxD, pixDiff, tmpBuf, clipTab + TAB_OFS );
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            v_int16 sw2_1 = vx_setall_s16((short)SW2 + 1);
+            for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+            {
+                v_int16 hsA = v_mul(vx_load_aligned(pixDiff + d), sw2_1);
+                for (x = Da; x <= SW2 * Da; x += Da)
+                    hsA = v_add(hsA, vx_load_aligned(pixDiff + x + d));
+                v_store_aligned(hsumAdd + d, hsA);
+            }
+#else
+            for (d = 0; d < D; d++)
+            {
+                CostType hsA = (CostType)(pixDiff[d] * (SW2 + 1));
+                for (x = Da; x <= SW2 * Da; x += Da)
+                    hsA += pixDiff[x + d];
+                hsumAdd[d] = hsA;
+            }
+#endif
+            if( y > src_start_idx )
+            {
+                const CostType* hsumSub = mem.getHSumBuf(std::max(y - SH2 - 1, src_start_idx));
+
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                    v_store_aligned(C + d, v_sub(v_add(vx_load_aligned(C + d), vx_load_aligned(hsumAdd + d)), vx_load_aligned(hsumSub + d)));
+#else
+                for (d = 0; d < D; d++)
+                    C[d] = (CostType)(C[d] + hsumAdd[d] - hsumSub[d]);
+#endif
+
+                for( x = Da; x < width1*Da; x += Da )
+                {
+                    const CostType* pixAdd = pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                    const CostType* pixSub = pixDiff + std::max(x - (SW2+1)*Da, 0);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                    v_int16 hv_reg;
+                    for( d = 0; d < Da; d+=VTraits<v_int16>::vlanes() )
+                    {
+                        hv_reg = v_sub(v_add(vx_load_aligned(hsumAdd + x - this->Da + d), vx_load_aligned(pixAdd + d)), vx_load_aligned(pixSub + d));
+                        v_store_aligned(hsumAdd+x+d,hv_reg);
+                        v_store_aligned(C+x+d,v_sub(v_add(vx_load_aligned(C + x + d), hv_reg), vx_load_aligned(hsumSub + x + d)));
+                    }
+#else
+                    for( d = 0; d < D; d++ )
+                    {
+                        int hv = hsumAdd[x + d] = (CostType)(hsumAdd[x - D + d] + pixAdd[d] - pixSub[d]);
+                        C[x + d] = (CostType)(C[x + d] + hv - hsumSub[x + d]);
+                    }
+#endif
+                }
+            }
+            else
+            {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                v_int16 v_scale = vx_setall_s16(k == src_start_idx ? (short)SH2 + 1 : 1);
+                for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                    v_store_aligned(C + d, v_add(vx_load_aligned(C + d), v_mul(vx_load_aligned(hsumAdd + d), v_scale)));
+#else
+                int scale = k == src_start_idx ? SH2 + 1 : 1;
+                for (d = 0; d < D; d++)
+                    C[d] = (CostType)(C[d] + hsumAdd[d] * scale);
+#endif
+                for( x = Da; x < width1*Da; x += Da )
+                {
+                    const CostType* pixAdd = pixDiff + std::min(x + SW2*Da, (width1-1)*Da);
+                    const CostType* pixSub = pixDiff + std::max(x - (SW2+1)*Da, 0);
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                    for (d = 0; d < Da; d += VTraits<v_int16>::vlanes())
+                    {
+                        v_int16 hv = v_sub(v_add(vx_load_aligned(hsumAdd + x - this->Da + d), vx_load_aligned(pixAdd + d)), vx_load_aligned(pixSub + d));
+                        v_store_aligned(hsumAdd + x + d, hv);
+                        v_store_aligned(C + x + d, v_add(vx_load_aligned(C + x + d), v_mul(hv, v_scale)));
+                    }
+#else
+                    for (d = 0; d < D; d++)
+                    {
+                        CostType hv = (CostType)(hsumAdd[x - Da + d] + pixAdd[d] - pixSub[d]);
+                        hsumAdd[x + d] = hv;
+                        C[x + d] = (CostType)(C[x + d] + hv * scale);
+                    }
+#endif
+                }
+            }
+        }
+        else
+        {
+            if( y > src_start_idx )
+            {
+                const CostType* hsumSub = mem.getHSumBuf(std::max(y - SH2 - 1, src_start_idx));
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                for( x = 0; x < width1*Da; x += VTraits<v_int16>::vlanes())
+                    v_store_aligned(C + x, v_sub(v_add(vx_load_aligned(C + x), vx_load_aligned(hsumAdd + x)), vx_load_aligned(hsumSub + x)));
+#else
+                for( x = 0; x < width1*Da; x++ )
+                    C[x] = (CostType)(C[x] + hsumAdd[x] - hsumSub[x]);
+#endif
+            }
+            else
+            {
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                for( x = 0; x < width1*Da; x += VTraits<v_int16>::vlanes())
+                    v_store_aligned(C + x, v_add(vx_load_aligned(C + x), vx_load_aligned(hsumAdd + x)));
+#else
+                for( x = 0; x < width1*Da; x++ )
+                    C[x] = (CostType)(C[x] + hsumAdd[x]);
+#endif
+            }
+        }
+    }
+}
+
+// performing SGM cost accumulation from left to right (result is stored in leftBuf) and
+// in-place cost accumulation from top to bottom (result is stored in topBuf)
+template<bool x_nlanes>
+void SGBM3WayMainLoop::accumulateCostsLeftTop(const BufferSGBM3Way &mem, int x, CostType& leftMinCost) const
+{
+    CostType *leftBuf = mem.horPassCostVolume + x;
+    CostType *leftBuf_prev = mem.horPassCostVolume + x - Da;
+    CostType *topBuf = mem.vertPassCostVolume + x;
+    CostType *costs = mem.curCostVolumeLine - Da + x;
+    CostType& topMinCost = mem.vertPassMin[x/Da];
+    int i = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    v_int16 P1_reg = vx_setall_s16(cv::saturate_cast<CostType>(P1));
+
+    v_int16 leftMinCostP2_reg   = vx_setall_s16(cv::saturate_cast<CostType>(leftMinCost+P2));
+    v_int16 leftMinCost_new_reg = vx_setall_s16(SHRT_MAX);
+    v_int16 src0_leftBuf        = vx_setall_s16(SHRT_MAX);
+    v_int16 src1_leftBuf        = vx_load_aligned(leftBuf_prev);
+
+    v_int16 topMinCostP2_reg   = vx_setall_s16(cv::saturate_cast<CostType>(topMinCost+P2));
+    v_int16 topMinCost_new_reg = vx_setall_s16(SHRT_MAX);
+    v_int16 src0_topBuf        = vx_setall_s16(SHRT_MAX);
+    v_int16 src1_topBuf        = vx_load_aligned(topBuf);
+
+    v_int16 src2;
+    v_int16 src_shifted_left,src_shifted_right;
+    v_int16 res;
+
+    for(;i<Da-VTraits<v_int16>::vlanes();i+= VTraits<v_int16>::vlanes())
+    {
+        //process leftBuf:
+        //lookahead load:
+        src2 = vx_load_aligned(leftBuf_prev+i+VTraits<v_int16>::vlanes());
+
+        //get shifted versions of the current block and add P1:
+        src_shifted_left  = v_rotate_left<1>  (src1_leftBuf,src0_leftBuf);
+        src_shifted_right = v_rotate_right<1> (src1_leftBuf,src2        );
+
+        // process and save current block:
+        res = v_add(vx_load_aligned(costs + i), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_leftBuf, leftMinCostP2_reg)), leftMinCostP2_reg));
+        leftMinCost_new_reg = v_min(leftMinCost_new_reg,res);
+        v_store_aligned(leftBuf+i, res);
+
+        //update src buffers:
+        src0_leftBuf = src1_leftBuf;
+        src1_leftBuf = src2;
+
+        //process topBuf:
+        //lookahead load:
+        src2 = vx_load_aligned(topBuf+i+VTraits<v_int16>::vlanes());
+
+        //get shifted versions of the current block and add P1:
+        src_shifted_left  = v_rotate_left<1>  (src1_topBuf,src0_topBuf);
+        src_shifted_right = v_rotate_right<1> (src1_topBuf,src2       );
+
+        // process and save current block:
+        res = v_add(vx_load_aligned(costs + i), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_topBuf, topMinCostP2_reg)), topMinCostP2_reg));
+        topMinCost_new_reg = v_min(topMinCost_new_reg,res);
+        v_store_aligned(topBuf+i, res);
+
+        //update src buffers:
+        src0_topBuf = src1_topBuf;
+        src1_topBuf = src2;
+    }
+
+    // a bit different processing for the last cycle of the loop:
+    if(x_nlanes)
+    {
+        src2 = vx_setall_s16(SHRT_MAX);
+        //process leftBuf:
+        src_shifted_left  = v_rotate_left<1>  (src1_leftBuf,src0_leftBuf);
+        src_shifted_right = v_rotate_right<1> (src1_leftBuf,src2        );
+
+        res = v_add(vx_load_aligned(costs + this->Da - VTraits<v_int16>::vlanes()), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_leftBuf, leftMinCostP2_reg)), leftMinCostP2_reg));
+        leftMinCost = v_reduce_min(v_min(leftMinCost_new_reg,res));
+        v_store_aligned(leftBuf+Da-VTraits<v_int16>::vlanes(), res);
+
+        //process topBuf:
+        src_shifted_left  = v_rotate_left<1>  (src1_topBuf,src0_topBuf);
+        src_shifted_right = v_rotate_right<1> (src1_topBuf,src2       );
+
+        res = v_add(vx_load_aligned(costs + this->Da - VTraits<v_int16>::vlanes()), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_topBuf, topMinCostP2_reg)), topMinCostP2_reg));
+        topMinCost = v_reduce_min(v_min(topMinCost_new_reg,res));
+        v_store_aligned(topBuf+Da-VTraits<v_int16>::vlanes(), res);
+    }
+    else
+    {
+        CostType leftMinCost_new = v_reduce_min(leftMinCost_new_reg);
+        CostType topMinCost_new  = v_reduce_min(topMinCost_new_reg);
+        CostType leftBuf_prev_i_minus_1 = i > 0 ? leftBuf_prev[i-1] : SHRT_MAX;
+        CostType topBuf_i_minus_1       = i > 0 ? topBuf[i-1] : SHRT_MAX;
+#else
+    {
+        CostType leftMinCost_new = SHRT_MAX;
+        CostType topMinCost_new  = SHRT_MAX;
+        CostType leftBuf_prev_i_minus_1 = SHRT_MAX;
+        CostType topBuf_i_minus_1       = SHRT_MAX;
+#endif
+        int leftMinCost_P2  = leftMinCost + P2;
+        int topMinCost_P2   = topMinCost  + P2;
+        CostType tmp;
+        for(;i<D-1;i++)
+        {
+            leftBuf[i] = cv::saturate_cast<CostType>(costs[i] + std::min(std::min(leftBuf_prev_i_minus_1+P1,leftBuf_prev[i+1]+P1),std::min((int)leftBuf_prev[i],leftMinCost_P2))-leftMinCost_P2);
+            leftBuf_prev_i_minus_1 = leftBuf_prev[i];
+            leftMinCost_new = std::min(leftMinCost_new,leftBuf[i]);
+
+            tmp = topBuf[i];
+            topBuf[i]  = cv::saturate_cast<CostType>(costs[i] + std::min(std::min(topBuf_i_minus_1+P1,topBuf[i+1]+P1),std::min((int)topBuf[i],topMinCost_P2))-topMinCost_P2);
+            topBuf_i_minus_1 = tmp;
+            topMinCost_new  = std::min(topMinCost_new,topBuf[i]);
+        }
+
+        leftBuf[D-1] = cv::saturate_cast<CostType>(costs[D-1] + std::min(leftBuf_prev_i_minus_1+P1,std::min((int)leftBuf_prev[D-1],leftMinCost_P2))-leftMinCost_P2);
+        leftMinCost = std::min(leftMinCost_new,leftBuf[D-1]);
+
+        topBuf[D-1]  = cv::saturate_cast<CostType>(costs[D-1] + std::min(topBuf_i_minus_1+P1,std::min((int)topBuf[D-1],topMinCost_P2))-topMinCost_P2);
+        topMinCost  = std::min(topMinCost_new,topBuf[D-1]);
+    }
+}
+
+// performing in-place SGM cost accumulation from right to left (the result is stored in rightBuf) and
+// summing rightBuf, topBuf, leftBuf together (the result is stored in leftBuf), as well as finding the
+// optimal disparity value with minimum accumulated cost
+template<bool x_nlanes>
+void SGBM3WayMainLoop::accumulateCostsRight(const BufferSGBM3Way &mem, int x,
+                                            CostType& rightMinCost, short& optimal_disp, CostType& min_cost) const
+{
+    CostType* costs = mem.curCostVolumeLine - Da + x;
+    CostType* rightBuf = mem.rightPassBuf;
+    CostType* topBuf = mem.vertPassCostVolume + x;
+    CostType* leftBuf = mem.horPassCostVolume + x;
+
+    int i = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+    v_int16 P1_reg = vx_setall_s16(cv::saturate_cast<CostType>(P1));
+
+    v_int16 rightMinCostP2_reg   = vx_setall_s16(cv::saturate_cast<CostType>(rightMinCost+P2));
+    v_int16 rightMinCost_new_reg = vx_setall_s16(SHRT_MAX);
+    v_int16 src0_rightBuf        = vx_setall_s16(SHRT_MAX);
+    v_int16 src1_rightBuf        = vx_load(rightBuf);
+
+    v_int16 src2;
+    v_int16 src_shifted_left,src_shifted_right;
+    v_int16 res;
+
+    v_int16 min_sum_cost_reg = vx_setall_s16(SHRT_MAX);
+    v_int16 min_sum_pos_reg  = vx_setall_s16(0);
+
+    for(;i<Da-VTraits<v_int16>::vlanes();i+=VTraits<v_int16>::vlanes())
+    {
+        //lookahead load:
+        src2 = vx_load_aligned(rightBuf+i+VTraits<v_int16>::vlanes());
+
+        //get shifted versions of the current block and add P1:
+        src_shifted_left  = v_rotate_left<1>  (src1_rightBuf,src0_rightBuf);
+        src_shifted_right = v_rotate_right<1> (src1_rightBuf,src2         );
+
+        // process and save current block:
+        res = v_add(vx_load_aligned(costs + i), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_rightBuf, rightMinCostP2_reg)), rightMinCostP2_reg));
+        rightMinCost_new_reg = v_min(rightMinCost_new_reg,res);
+        v_store_aligned(rightBuf+i, res);
+
+        // compute and save total cost:
+        res = v_add(v_add(res, vx_load_aligned(leftBuf + i)), vx_load_aligned(topBuf + i));
+        v_store_aligned(leftBuf+i, res);
+
+        // track disparity value with the minimum cost:
+        min_sum_cost_reg = v_min(min_sum_cost_reg,res);
+        min_sum_pos_reg = v_add(min_sum_pos_reg, v_and(v_eq(min_sum_cost_reg, res), v_sub(vx_setall_s16((short)i), min_sum_pos_reg)));
+
+        //update src:
+        src0_rightBuf    = src1_rightBuf;
+        src1_rightBuf    = src2;
+    }
+
+    // a bit different processing for the last cycle of the loop:
+    if(x_nlanes)
+    {
+        src2 = vx_setall_s16(SHRT_MAX);
+        src_shifted_left  = v_rotate_left<1>  (src1_rightBuf,src0_rightBuf);
+        src_shifted_right = v_rotate_right<1> (src1_rightBuf,src2         );
+
+        res = v_add(vx_load_aligned(costs + this->D - VTraits<v_int16>::vlanes()), v_sub(v_min(v_add(v_min(src_shifted_left, src_shifted_right), P1_reg), v_min(src1_rightBuf, rightMinCostP2_reg)), rightMinCostP2_reg));
+        rightMinCost = v_reduce_min(v_min(rightMinCost_new_reg,res));
+        v_store_aligned(rightBuf+D-VTraits<v_int16>::vlanes(), res);
+
+        res = v_add(v_add(res, vx_load_aligned(leftBuf + this->D - VTraits<v_int16>::vlanes())), vx_load_aligned(topBuf + this->D - VTraits<v_int16>::vlanes()));
+        v_store_aligned(leftBuf+D-VTraits<v_int16>::vlanes(), res);
+
+        min_sum_cost_reg = v_min(min_sum_cost_reg,res);
+        min_sum_pos_reg = v_add(min_sum_pos_reg, v_and(v_eq(min_sum_cost_reg, res), v_sub(vx_setall_s16((short)(this->D - VTraits<v_int16>::vlanes())), min_sum_pos_reg)));
+        min_pos(min_sum_cost_reg,min_sum_pos_reg, min_cost, optimal_disp);
+    }
+    else
+    {
+        CostType rightMinCost_new = v_reduce_min(rightMinCost_new_reg);
+        CostType rightBuf_i_minus_1 = i > 0 ? rightBuf[i] : SHRT_MAX;
+        min_pos(min_sum_cost_reg,min_sum_pos_reg, min_cost, optimal_disp);
+#else
+    {
+        CostType rightMinCost_new = SHRT_MAX;
+        CostType rightBuf_i_minus_1 = SHRT_MAX;
+        min_cost = SHRT_MAX;
+#endif
+        int rightMinCost_P2  = rightMinCost + P2;
+        CostType tmp;
+        for(;i<D-1;i++)
+        {
+            tmp = rightBuf[i];
+            rightBuf[i]  = cv::saturate_cast<CostType>(costs[i] + std::min(std::min(rightBuf_i_minus_1+P1,rightBuf[i+1]+P1),std::min((int)rightBuf[i],rightMinCost_P2))-rightMinCost_P2);
+            rightBuf_i_minus_1 = tmp;
+            rightMinCost_new  = std::min(rightMinCost_new,rightBuf[i]);
+            leftBuf[i] = cv::saturate_cast<CostType>((int)leftBuf[i]+rightBuf[i]+topBuf[i]);
+            if(leftBuf[i]<min_cost)
+            {
+                optimal_disp = (short)i;
+                min_cost = leftBuf[i];
+            }
+        }
+
+        rightBuf[D-1]  = cv::saturate_cast<CostType>(costs[D-1] + std::min(rightBuf_i_minus_1+P1,std::min((int)rightBuf[D-1],rightMinCost_P2))-rightMinCost_P2);
+        rightMinCost  = std::min(rightMinCost_new,rightBuf[D-1]);
+        leftBuf[D-1] = cv::saturate_cast<CostType>((int)leftBuf[D-1]+rightBuf[D-1]+topBuf[D-1]);
+        if(leftBuf[D-1]<min_cost)
+        {
+            optimal_disp = (short)D-1;
+            min_cost = leftBuf[D-1];
+        }
+    }
+}
+
+void SGBM3WayMainLoop::operator () (const Range& range) const
+{
+    if (D == Da) impl<true>(range);
+    else impl<false>(range);
+}
+
+template<bool x_nlanes>
+void SGBM3WayMainLoop::impl(const Range& range) const
+{
+    // force separate processing of stripes:
+    if(range.end>range.start+1)
+    {
+        for(int n=range.start;n<range.end;n++)
+            (*this)(Range(n,n+1));
+        return;
+    }
+
+    const int DISP_SCALE = (1 << StereoMatcher::DISP_SHIFT);
+    int INVALID_DISP = minD - 1, INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
+
+    // setting up the ranges:
+    int src_start_idx = std::max(std::min(range.start * stripe_sz - stripe_overlap, height),0);
+    int src_end_idx   = std::min(range.end   * stripe_sz, height);
+
+    int dst_offset;
+    if(range.start==0)
+        dst_offset=stripe_overlap;
+    else
+        dst_offset=0;
+
+    Mat cur_disp   = dst_disp[range.start];
+    cur_disp = Scalar(INVALID_DISP_SCALED);
+
+    BufferSGBM3Way mem(width1, width, img1->channels(), Da, SH2, P2);
+    CostType *horPassCostVolume = mem.horPassCostVolume;
+    // start real processing:
+    for(int y=src_start_idx;y<src_end_idx;y++)
+    {
+        getRawMatchingCost(mem, y, src_start_idx);
+
+        short* disp_row = (short*)cur_disp.ptr(dst_offset+(y-src_start_idx));
+
+        // initialize the auxiliary buffers for the pseudo left-right consistency check:
+        for(int x=0;x<width;x++)
+        {
+            mem.disp2Buf[x] = (short)INVALID_DISP_SCALED;
+            mem.disp2CostBuf[x] = SHRT_MAX;
+        }
+        CostType prev_min, min_cost;
+        int d;
+        short best_d;
+        d = best_d = 0;
+
+        // forward pass
+        prev_min=0;
+        for (int x=Da;x<(1+width1)*Da;x+=Da)
+            accumulateCostsLeftTop<x_nlanes>(mem, x, prev_min);
+
+        //backward pass
+        mem.clearRightPassBuf();
+        prev_min=0;
+        for (int x=width1*Da;x>=Da;x-=Da)
+        {
+            accumulateCostsRight<x_nlanes>(mem, x, prev_min, best_d, min_cost);
+
+            if(uniquenessRatio>0)
+            {
+                d = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+                horPassCostVolume+=x;
+                int thresh = (100*min_cost)/(100-uniquenessRatio);
+                v_int16 thresh_reg = vx_setall_s16((short)(thresh+1));
+                v_int16 d1 = vx_setall_s16((short)(best_d-1));
+                v_int16 d2 = vx_setall_s16((short)(best_d+1));
+                v_int16 eight_reg = vx_setall_s16((short)VTraits<v_int16>::vlanes());
+                v_int16 cur_d = vx_load(idx_row);
+                v_int16 mask;
+
+                for( ; d <= D - 2*VTraits<v_int16>::vlanes(); d+=2*VTraits<v_int16>::vlanes() )
+                {
+                    mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
+                    cur_d = v_add(cur_d, eight_reg);
+                    if( v_check_any(mask) )
+                        break;
+                    mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d + VTraits<v_int16>::vlanes()), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
+                    cur_d = v_add(cur_d, eight_reg);
+                    if( v_check_any(mask) )
+                        break;
+                }
+                if( d <= D - 2*VTraits<v_int16>::vlanes() )
+                {
+                    horPassCostVolume-=x;
+                    continue;
+                }
+                if( d <= D - VTraits<v_int16>::vlanes() )
+                {
+                    if( v_check_any(v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)))) )
+                    {
+                        horPassCostVolume-=x;
+                        continue;
+                    }
+                    d+=VTraits<v_int16>::vlanes();
+                }
+                horPassCostVolume-=x;
+#endif
+                for( ; d < D; d++ )
+                {
+                    if( horPassCostVolume[x+d]*(100 - uniquenessRatio) < min_cost*100 && std::abs(d - best_d) > 1 )
+                        break;
+                }
+                if( d < D )
+                    continue;
+            }
+            d = best_d;
+
+            int _x2 = x/Da - 1 + minX1 - d - minD;
+            if( _x2>=0 && _x2<width && mem.disp2CostBuf[_x2] > min_cost )
+            {
+                mem.disp2CostBuf[_x2] = min_cost;
+                mem.disp2Buf[_x2] = (short)(d + minD);
+            }
+
+            if( 0 < d && d < D-1 )
+            {
+                // do subpixel quadratic interpolation:
+                //   fit parabola into (x1=d-1, y1=Sp[d-1]), (x2=d, y2=Sp[d]), (x3=d+1, y3=Sp[d+1])
+                //   then find minimum of the parabola.
+                int denom2 = std::max(horPassCostVolume[x+d-1] + horPassCostVolume[x+d+1] - 2*horPassCostVolume[x+d], 1);
+                d = d*DISP_SCALE + ((horPassCostVolume[x+d-1] - horPassCostVolume[x+d+1])*DISP_SCALE + denom2)/(denom2*2);
+            }
+            else
+                d *= DISP_SCALE;
+
+            disp_row[(x/Da)-1 + minX1] = (DispType)(d + minD*DISP_SCALE);
+        }
+
+        for(int x = minX1; x < maxX1; x++ )
+        {
+            // pseudo LRC consistency check using only one disparity map;
+            // pixels with difference more than disp12MaxDiff are invalidated
+            int d1 = disp_row[x];
+            if( d1 == INVALID_DISP_SCALED )
+                continue;
+            int _d = d1 >> StereoMatcher::DISP_SHIFT;
+            int d_ = (d1 + DISP_SCALE-1) >> StereoMatcher::DISP_SHIFT;
+            int _x = x - _d, x_ = x - d_;
+            if( 0 <= _x && _x < width && mem.disp2Buf[_x] >= minD && std::abs(mem.disp2Buf[_x] - _d) > disp12MaxDiff &&
+                0 <= x_ && x_ < width && mem.disp2Buf[x_] >= minD && std::abs(mem.disp2Buf[x_] - d_) > disp12MaxDiff )
+                disp_row[x] = (short)INVALID_DISP_SCALED;
+        }
+    }
+}
+
+template <uchar nstripes>
+static void computeDisparity3WaySGBM(const Mat& img1, const Mat& img2, Mat& disp1, const StereoSGBMParams& params)
+{
+    // allocate separate dst_disp arrays to avoid conflicts due to stripe overlap:
+    int stripe_sz = (int)ceil(img1.rows/(double)nstripes);
+    int stripe_overlap = (params.SADWindowSize/2+1) + (int)ceil(0.1*stripe_sz);
+    Mat dst_disp[nstripes];
+    for(int i=0;i<nstripes;i++)
+        dst_disp[i].create(stripe_sz+stripe_overlap,img1.cols,CV_16S);
+
+    parallel_for_(
+        Range(0,nstripes),
+        SGBM3WayMainLoop(img1,img2,dst_disp,params,stripe_sz,stripe_overlap)
+    );
+
+    //assemble disp1 from dst_disp:
+    short* dst_row;
+    short* src_row;
+    for(int i=0;i<disp1.rows;i++)
+    {
+        dst_row = (short*)disp1.ptr(i);
+        src_row = (short*)dst_disp[i/stripe_sz].ptr(stripe_overlap+i%stripe_sz);
+        memcpy(dst_row,src_row,disp1.cols*sizeof(short));
+    }
+}
+
+class StereoSGBMImpl CV_FINAL : public StereoSGBM
+{
+public:
+    StereoSGBMImpl()
+        : params()
+    {
+        // nothing
+    }
+
+    StereoSGBMImpl( int _minDisparity, int _numDisparities, int _SADWindowSize,
+                    int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
+                    int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
+                    int _mode )
+        : params(_minDisparity, _numDisparities, _SADWindowSize,
+                 _P1, _P2, _disp12MaxDiff, _preFilterCap,
+                 _uniquenessRatio, _speckleWindowSize, _speckleRange,
+                 _mode)
+    {
+        // nothing
+    }
+
+    void compute( InputArray leftarr, InputArray rightarr, OutputArray disparr ) CV_OVERRIDE
+    {
+        CV_INSTRUMENT_REGION();
+
+        Mat left = leftarr.getMat(), right = rightarr.getMat();
+        CV_Assert( left.size() == right.size() && left.type() == right.type() &&
+                   left.depth() == CV_8U );
+
+        disparr.create( left.size(), CV_16S );
+        Mat disp = disparr.getMat();
+
+        if(params.mode==MODE_SGBM_3WAY)
+            // the number of stripes is fixed, disregarding the number of threads/processors
+            // to make the results fully reproducible
+            computeDisparity3WaySGBM<4>( left, right, disp, params );
+        else if(params.mode==MODE_HH4)
+            computeDisparitySGBM_HH4( left, right, disp, params );
+        else
+            computeDisparitySGBM( left, right, disp, params );
+
+        medianBlur(disp, disp, 3);
+
+        if( params.speckleWindowSize > 0 )
+            filterSpeckles(disp, (params.minDisparity - 1)*StereoMatcher::DISP_SCALE, params.speckleWindowSize,
+                           StereoMatcher::DISP_SCALE*params.speckleRange, buffer);
+    }
+
+    int getMinDisparity() const CV_OVERRIDE { return params.minDisparity; }
+    void setMinDisparity(int minDisparity) CV_OVERRIDE { params.minDisparity = minDisparity; }
+
+    int getNumDisparities() const CV_OVERRIDE { return params.numDisparities; }
+    void setNumDisparities(int numDisparities) CV_OVERRIDE { params.numDisparities = numDisparities; }
+
+    int getBlockSize() const CV_OVERRIDE { return params.SADWindowSize; }
+    void setBlockSize(int blockSize) CV_OVERRIDE { params.SADWindowSize = blockSize; }
+
+    int getSpeckleWindowSize() const CV_OVERRIDE { return params.speckleWindowSize; }
+    void setSpeckleWindowSize(int speckleWindowSize) CV_OVERRIDE { params.speckleWindowSize = speckleWindowSize; }
+
+    int getSpeckleRange() const CV_OVERRIDE { return params.speckleRange; }
+    void setSpeckleRange(int speckleRange) CV_OVERRIDE { params.speckleRange = speckleRange; }
+
+    int getDisp12MaxDiff() const CV_OVERRIDE { return params.disp12MaxDiff; }
+    void setDisp12MaxDiff(int disp12MaxDiff) CV_OVERRIDE { params.disp12MaxDiff = disp12MaxDiff; }
+
+    int getPreFilterCap() const CV_OVERRIDE { return params.preFilterCap; }
+    void setPreFilterCap(int preFilterCap) CV_OVERRIDE { params.preFilterCap = preFilterCap; }
+
+    int getUniquenessRatio() const CV_OVERRIDE { return params.uniquenessRatio; }
+    void setUniquenessRatio(int uniquenessRatio) CV_OVERRIDE { params.uniquenessRatio = uniquenessRatio; }
+
+    int getP1() const CV_OVERRIDE { return params.P1; }
+    void setP1(int P1) CV_OVERRIDE { params.P1 = P1; }
+
+    int getP2() const CV_OVERRIDE { return params.P2; }
+    void setP2(int P2) CV_OVERRIDE { params.P2 = P2; }
+
+    int getMode() const CV_OVERRIDE { return params.mode; }
+    void setMode(int mode) CV_OVERRIDE { params.mode = mode; }
+
+    void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name_
+        << "minDisparity" << params.minDisparity
+        << "numDisparities" << params.numDisparities
+        << "blockSize" << params.SADWindowSize
+        << "speckleWindowSize" << params.speckleWindowSize
+        << "speckleRange" << params.speckleRange
+        << "disp12MaxDiff" << params.disp12MaxDiff
+        << "preFilterCap" << params.preFilterCap
+        << "uniquenessRatio" << params.uniquenessRatio
+        << "P1" << params.P1
+        << "P2" << params.P2
+        << "mode" << params.mode;
+    }
+
+    void read(const FileNode& fn) CV_OVERRIDE
+    {
+        FileNode n = fn["name"];
+        CV_Assert( n.isString() && String(n) == name_ );
+        params.minDisparity = (int)fn["minDisparity"];
+        params.numDisparities = (int)fn["numDisparities"];
+        params.SADWindowSize = (int)fn["blockSize"];
+        params.speckleWindowSize = (int)fn["speckleWindowSize"];
+        params.speckleRange = (int)fn["speckleRange"];
+        params.disp12MaxDiff = (int)fn["disp12MaxDiff"];
+        params.preFilterCap = (int)fn["preFilterCap"];
+        params.uniquenessRatio = (int)fn["uniquenessRatio"];
+        params.P1 = (int)fn["P1"];
+        params.P2 = (int)fn["P2"];
+        params.mode = (int)fn["mode"];
+    }
+
+    StereoSGBMParams params;
+    Mat buffer;
+
+    static const char* name_;
+};
+
+const char* StereoSGBMImpl::name_ = "StereoMatcher.SGBM";
+
+
+Ptr<StereoSGBM> StereoSGBM::create(int minDisparity, int numDisparities, int SADWindowSize,
+                                 int P1, int P2, int disp12MaxDiff,
+                                 int preFilterCap, int uniquenessRatio,
+                                 int speckleWindowSize, int speckleRange,
+                                 int mode)
+{
+    return Ptr<StereoSGBM>(
+        new StereoSGBMImpl(minDisparity, numDisparities, SADWindowSize,
+                           P1, P2, disp12MaxDiff,
+                           preFilterCap, uniquenessRatio,
+                           speckleWindowSize, speckleRange,
+                           mode));
+}
+
+Rect getValidDisparityROI( Rect roi1, Rect roi2,
+                          int minDisparity,
+                          int numberOfDisparities,
+                          int SADWindowSize )
+{
+    int SW2 = SADWindowSize/2;
+    int maxD = minDisparity + numberOfDisparities - 1;
+
+    int xmin = std::max(roi1.x, roi2.x + maxD) + SW2;
+    int xmax = std::min(roi1.x + roi1.width, roi2.x + roi2.width) - SW2;
+    int ymin = std::max(roi1.y, roi2.y) + SW2;
+    int ymax = std::min(roi1.y + roi1.height, roi2.y + roi2.height) - SW2;
+
+    Rect r(xmin, ymin, xmax - xmin, ymax - ymin);
+
+    return r.width > 0 && r.height > 0 ? r : Rect();
+}
+
+typedef cv::Point_<short> Point2s;
+
+template <typename T>
+void filterSpecklesImpl(cv::Mat& img, int newVal, int maxSpeckleSize, int maxDiff, cv::Mat& _buf)
+{
+    using namespace cv;
+
+    int width = img.cols, height = img.rows, npixels = width*height;
+    // space allocation for:
+    // labels : npixels * sizeof(int)
+    // wbuf   : npixels * sizeof(Point2s)
+    // rtype  : (npixels + 1) * sizeof(uchar)
+    size_t bufSize = npixels * sizeof(int)            // for labels
+                     + npixels * sizeof(Point2s)      // for wavefront buffer (wbuf)
+                     + (npixels + 1) * sizeof(uchar); // for region type (rtype)
+    if( !_buf.isContinuous() || _buf.empty() || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
+        _buf.reserveBuffer(bufSize);
+
+    uchar* buf = _buf.ptr();
+    int i, j, dstep = (int)(img.step/sizeof(T));
+
+    // store labels and their corresponding region types
+    int* labels = (int*)buf;
+    buf += npixels*sizeof(labels[0]);
+    // store wavefront
+    Point2s* wbuf = (Point2s*)buf;
+    buf += npixels*sizeof(wbuf[0]);
+    // store region type
+    uchar* rtype = (uchar*)buf;
+    buf += (npixels + 1) * sizeof(rtype[0]);
+    int curlabel = 0;
+
+    // clear out label and rtype buffers
+    memset(labels, 0, npixels*sizeof(labels[0]));
+    memset(rtype, 0, (npixels + 1)*sizeof(rtype[0]));
+
+    for( i = 0; i < height; i++ )
+    {
+        T* ds = img.ptr<T>(i);
+        int* ls = labels + width*i;
+
+        for( j = 0; j < width; j++ )
+        {
+            if( ds[j] != newVal )   // not a bad disparity
+            {
+                if( ls[j] )     // has a label, check for bad label
+                {
+                    if( rtype[ls[j]] ) // small region, zero out disparity
+                        ds[j] = (T)newVal;
+                }
+                // no label, assign and propagate
+                else
+                {
+                    Point2s* ws = wbuf; // initialize wavefront
+                    Point2s p((short)j, (short)i);  // current pixel
+                    curlabel++; // next label
+                    int count = 0;  // current region size
+                    ls[j] = curlabel;
+
+                    // wavefront propagation
+                    while( ws >= wbuf ) // wavefront not empty
+                    {
+                        count++;
+                        // put neighbors onto wavefront
+                        T* dpp = &img.at<T>(p.y, p.x);
+                        T dp = *dpp;
+                        int* lpp = labels + width*p.y + p.x;
+
+                        if( p.y < height-1 && !lpp[+width] && dpp[+dstep] != newVal && std::abs(dp - dpp[+dstep]) <= maxDiff )
+                        {
+                            lpp[+width] = curlabel;
+                            *ws++ = Point2s(p.x, p.y+1);
+                        }
+
+                        if( p.y > 0 && !lpp[-width] && dpp[-dstep] != newVal && std::abs(dp - dpp[-dstep]) <= maxDiff )
+                        {
+                            lpp[-width] = curlabel;
+                            *ws++ = Point2s(p.x, p.y-1);
+                        }
+
+                        if( p.x < width-1 && !lpp[+1] && dpp[+1] != newVal && std::abs(dp - dpp[+1]) <= maxDiff )
+                        {
+                            lpp[+1] = curlabel;
+                            *ws++ = Point2s(p.x+1, p.y);
+                        }
+
+                        if( p.x > 0 && !lpp[-1] && dpp[-1] != newVal && std::abs(dp - dpp[-1]) <= maxDiff )
+                        {
+                            lpp[-1] = curlabel;
+                            *ws++ = Point2s(p.x-1, p.y);
+                        }
+
+                        // pop most recent and propagate
+                        // NB: could try least recent, maybe better convergence
+                        p = *--ws;
+                    }
+
+                    // assign label type
+                    if( count <= maxSpeckleSize )   // speckle region
+                    {
+                        rtype[ls[j]] = 1;   // small region label
+                        ds[j] = (T)newVal;
+                    }
+                    else
+                        rtype[ls[j]] = 0;   // large region label
+                }
+            }
+        }
+    }
+}
+
+#ifdef HAVE_IPP
+static bool ipp_filterSpeckles(Mat &img, int maxSpeckleSize, int newVal, int maxDiff, Mat &buffer)
+{
+#if IPP_VERSION_X100 >= 810
+    CV_INSTRUMENT_REGION_IPP();
+
+    IppDataType dataType = ippiGetDataType(img.depth());
+    IppiSize    size     = ippiSize(img.size());
+    int         bufferSize;
+
+    if(img.channels() != 1)
+        return false;
+
+    if(dataType != ipp8u && dataType != ipp16s)
+        return false;
+
+    if(ippiMarkSpecklesGetBufferSize(size, dataType, 1, &bufferSize) < 0)
+        return false;
+
+    if(bufferSize && (buffer.empty() || (int)(buffer.step*buffer.rows) < bufferSize))
+        buffer.create(1, (int)bufferSize, CV_8U);
+
+    switch(dataType)
+    {
+    case ipp8u:  return CV_INSTRUMENT_FUN_IPP(ippiMarkSpeckles_8u_C1IR, img.ptr<Ipp8u>(), (int)img.step, size, (Ipp8u)newVal, maxSpeckleSize, (Ipp8u)maxDiff, ippiNormL1, buffer.ptr<Ipp8u>()) >= 0;
+    case ipp16s: return CV_INSTRUMENT_FUN_IPP(ippiMarkSpeckles_16s_C1IR, img.ptr<Ipp16s>(), (int)img.step, size, (Ipp16s)newVal, maxSpeckleSize, (Ipp16s)maxDiff, ippiNormL1, buffer.ptr<Ipp8u>()) >= 0;
+    default:     return false;
+    }
+#else
+    CV_UNUSED(img); CV_UNUSED(maxSpeckleSize); CV_UNUSED(newVal); CV_UNUSED(maxDiff); CV_UNUSED(buffer);
+    return false;
+#endif
+}
+#endif
+
+void filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSize,
+                         double _maxDiff, InputOutputArray __buf )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat img = _img.getMat();
+    int type = img.type();
+    Mat temp, &_buf = __buf.needed() ? __buf.getMatRef() : temp;
+    CV_Assert( type == CV_8UC1 || type == CV_16SC1 );
+
+    int newVal = cvRound(_newval), maxDiff = cvRound(_maxDiff);
+
+    CV_IPP_RUN_FAST(ipp_filterSpeckles(img, maxSpeckleSize, newVal, maxDiff, _buf));
+
+    if (type == CV_8UC1)
+        filterSpecklesImpl<uchar>(img, newVal, maxSpeckleSize, maxDiff, _buf);
+    else
+        filterSpecklesImpl<short>(img, newVal, maxSpeckleSize, maxDiff, _buf);
+}
+
+void validateDisparity( InputOutputArray _disp, InputArray _cost, int minDisparity,
+                            int numberOfDisparities, int disp12MaxDiff )
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat disp = _disp.getMat(), cost = _cost.getMat();
+    int cols = disp.cols, rows = disp.rows;
+    int minD = minDisparity, maxD = minDisparity + numberOfDisparities;
+    int x, minX1 = std::max(maxD, 0), maxX1 = cols + std::min(minD, 0);
+    AutoBuffer<int> _disp2buf(cols*2);
+    int* disp2buf = _disp2buf.data();
+    int* disp2cost = disp2buf + cols;
+    const int DISP_SHIFT = 4, DISP_SCALE = 1 << DISP_SHIFT;
+    int INVALID_DISP = minD - 1, INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
+    int costType = cost.type();
+
+    disp12MaxDiff *= DISP_SCALE;
+
+    CV_Assert( numberOfDisparities > 0 && disp.type() == CV_16S &&
+              (costType == CV_16S || costType == CV_32S) &&
+              disp.size() == cost.size() );
+
+    for( int y = 0; y < rows; y++ )
+    {
+        short* dptr = disp.ptr<short>(y);
+
+        for( x = 0; x < cols; x++ )
+        {
+            disp2buf[x] = INVALID_DISP_SCALED;
+            disp2cost[x] = INT_MAX;
+        }
+
+        if( costType == CV_16S )
+        {
+            const short* cptr = cost.ptr<short>(y);
+
+            for( x = minX1; x < maxX1; x++ )
+            {
+                int d = dptr[x], c = cptr[x];
+
+                if( d == INVALID_DISP_SCALED )
+                    continue;
+
+                int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
+
+                if( disp2cost[x2] > c )
+                {
+                    disp2cost[x2] = c;
+                    disp2buf[x2] = d;
+                }
+            }
+        }
+        else
+        {
+            const int* cptr = cost.ptr<int>(y);
+
+            for( x = minX1; x < maxX1; x++ )
+            {
+                int d = dptr[x], c = cptr[x];
+
+                if( d == INVALID_DISP_SCALED )
+                    continue;
+
+                int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
+
+                if( disp2cost[x2] > c )
+                {
+                    disp2cost[x2] = c;
+                    disp2buf[x2] = d;
+                }
+            }
+        }
+
+        for( x = minX1; x < maxX1; x++ )
+        {
+            // we round the computed disparity both towards -inf and +inf and check
+            // if either of the corresponding disparities in disp2 is consistent.
+            // This is to give the computed disparity a chance to look valid if it is.
+            int d = dptr[x];
+            if( d == INVALID_DISP_SCALED )
+                continue;
+            int d0 = d >> DISP_SHIFT;
+            int d1 = (d + DISP_SCALE-1) >> DISP_SHIFT;
+            int x0 = x - d0, x1 = x - d1;
+            if( (0 <= x0 && x0 < cols && disp2buf[x0] > INVALID_DISP_SCALED && std::abs(disp2buf[x0] - d) > disp12MaxDiff) &&
+                (0 <= x1 && x1 < cols && disp2buf[x1] > INVALID_DISP_SCALED && std::abs(disp2buf[x1] - d) > disp12MaxDiff) )
+                dptr[x] = (short)INVALID_DISP_SCALED;
+        }
+    }
+}
+
+}
diff --git a/upstream/opencv/modules/stitching/CMakeLists.txt b/upstream/opencv/modules/stitching/CMakeLists.txt
new file mode 100644
index 0000000..d33c0e7
--- /dev/null
+++ b/upstream/opencv/modules/stitching/CMakeLists.txt
@@ -0,0 +1,17 @@
+set(the_description "Images stitching")
+
+if(HAVE_CUDA)
+  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations -Wshadow -Wstrict-aliasing)
+endif()
+
+set(STITCHING_CONTRIB_DEPS "opencv_xfeatures2d")
+if(BUILD_SHARED_LIBS AND BUILD_opencv_world AND OPENCV_WORLD_EXCLUDE_EXTRA_MODULES)
+  set(STITCHING_CONTRIB_DEPS "")
+endif()
+ocv_define_module(stitching opencv_imgproc opencv_features opencv_geometry opencv_flann
+                  OPTIONAL opencv_cudaarithm opencv_cudawarping opencv_cudafeatures2d opencv_cudalegacy opencv_cudaimgproc ${STITCHING_CONTRIB_DEPS}
+                  WRAP python)
+
+if(HAVE_CUDA AND ENABLE_CUDA_FIRST_CLASS_LANGUAGE)
+  ocv_target_link_libraries(${the_module} PUBLIC "CUDA::cudart${CUDA_LIB_EXT}")
+endif()
diff --git a/upstream/opencv/modules/stitching/doc/StitchingPipeline.jpg b/upstream/opencv/modules/stitching/doc/StitchingPipeline.jpg
new file mode 100644
index 0000000..126987e
Binary files /dev/null and b/upstream/opencv/modules/stitching/doc/StitchingPipeline.jpg differ
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching.hpp
new file mode 100644
index 0000000..0c8b7dd
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching.hpp
@@ -0,0 +1,365 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_STITCHER_HPP
+#define OPENCV_STITCHING_STITCHER_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/features.hpp"
+#include "opencv2/stitching/warpers.hpp"
+#include "opencv2/stitching/detail/matchers.hpp"
+#include "opencv2/stitching/detail/motion_estimators.hpp"
+#include "opencv2/stitching/detail/exposure_compensate.hpp"
+#include "opencv2/stitching/detail/seam_finders.hpp"
+#include "opencv2/stitching/detail/blenders.hpp"
+#include "opencv2/stitching/detail/camera.hpp"
+
+
+#if defined(Status)
+#  warning Detected X11 'Status' macro definition, it can cause build conflicts. Please, include this header before any X11 headers.
+#endif
+
+
+/**
+@defgroup stitching Images stitching
+
+This figure illustrates the stitching module pipeline implemented in the Stitcher class. Using that
+class it's possible to configure/remove some steps, i.e. adjust the stitching pipeline according to
+the particular needs. All building blocks from the pipeline are available in the detail namespace,
+one can combine and use them separately.
+
+The implemented stitching pipeline is very similar to the one proposed in @cite BL07 .
+
+![stitching pipeline](StitchingPipeline.jpg)
+
+Camera models
+-------------
+
+There are currently 2 camera models implemented in stitching pipeline.
+
+- _Homography model_ expecting perspective transformations between images
+  implemented in @ref cv::detail::BestOf2NearestMatcher cv::detail::HomographyBasedEstimator
+  cv::detail::BundleAdjusterReproj cv::detail::BundleAdjusterRay
+- _Affine model_ expecting affine transformation with 6 DOF or 4 DOF implemented in
+  @ref cv::detail::AffineBestOf2NearestMatcher cv::detail::AffineBasedEstimator
+  cv::detail::BundleAdjusterAffine cv::detail::BundleAdjusterAffinePartial cv::AffineWarper
+
+Homography model is useful for creating photo panoramas captured by camera,
+while affine-based model can be used to stitch scans and object captured by
+specialized devices. Use @ref cv::Stitcher::create to get preconfigured pipeline for one
+of those models.
+
+@note
+Certain detailed settings of @ref cv::Stitcher might not make sense. Especially
+you should not mix classes implementing affine model and classes implementing
+Homography model, as they work with different transformations.
+
+@{
+    @defgroup stitching_match Features Finding and Images Matching
+    @defgroup stitching_rotation Rotation Estimation
+    @defgroup stitching_autocalib Autocalibration
+    @defgroup stitching_warp Images Warping
+    @defgroup stitching_seam Seam Estimation
+    @defgroup stitching_exposure Exposure Compensation
+    @defgroup stitching_blend Image Blenders
+@}
+  */
+
+namespace cv {
+
+//! @addtogroup stitching
+//! @{
+
+/** @example samples/cpp/snippets/stitching.cpp
+A basic example on image stitching
+*/
+
+/** @example samples/python/snippets/stitching.py
+A basic example on image stitching in Python.
+*/
+
+/** @example samples/cpp/stitching_detailed.cpp
+A detailed example on image stitching
+*/
+
+/** @brief High level image stitcher.
+
+It's possible to use this class without being aware of the entire stitching pipeline. However, to
+be able to achieve higher stitching stability and quality of the final images at least being
+familiar with the theory is recommended.
+
+@note
+-   A basic example on image stitching can be found at
+    opencv_source_code/samples/cpp/stitching.cpp
+-   A basic example on image stitching in Python can be found at
+    opencv_source_code/samples/python/stitching.py
+-   A detailed example on image stitching can be found at
+    opencv_source_code/samples/cpp/stitching_detailed.cpp
+ */
+class CV_EXPORTS_W Stitcher
+{
+public:
+    /**
+     * When setting a resolution for stitching, this values is a placeholder
+     * for preserving the original resolution.
+     */
+    static constexpr double ORIG_RESOL = -1.0;
+
+    enum Status
+    {
+        OK = 0,
+        ERR_NEED_MORE_IMGS = 1,
+        ERR_HOMOGRAPHY_EST_FAIL = 2,
+        ERR_CAMERA_PARAMS_ADJUST_FAIL = 3
+    };
+
+    enum Mode
+    {
+        /** Mode for creating photo panoramas. Expects images under perspective
+        transformation and projects resulting pano to sphere.
+
+        @sa detail::BestOf2NearestMatcher SphericalWarper
+        */
+        PANORAMA = 0,
+        /** Mode for composing scans. Expects images under affine transformation does
+        not compensate exposure by default.
+
+        @sa detail::AffineBestOf2NearestMatcher AffineWarper
+        */
+        SCANS = 1,
+
+    };
+
+    /** @brief Creates a Stitcher configured in one of the stitching modes.
+
+    @param mode Scenario for stitcher operation. This is usually determined by source of images
+    to stitch and their transformation. Default parameters will be chosen for operation in given
+    scenario.
+    @return Stitcher class instance.
+     */
+    CV_WRAP static Ptr<Stitcher> create(Mode mode = Stitcher::PANORAMA);
+
+    CV_WRAP double registrationResol() const { return registr_resol_; }
+    CV_WRAP void setRegistrationResol(double resol_mpx) { registr_resol_ = resol_mpx; }
+
+    CV_WRAP double seamEstimationResol() const { return seam_est_resol_; }
+    CV_WRAP void setSeamEstimationResol(double resol_mpx) { seam_est_resol_ = resol_mpx; }
+
+    CV_WRAP double compositingResol() const { return compose_resol_; }
+    CV_WRAP void setCompositingResol(double resol_mpx) { compose_resol_ = resol_mpx; }
+
+    CV_WRAP double panoConfidenceThresh() const { return conf_thresh_; }
+    CV_WRAP void setPanoConfidenceThresh(double conf_thresh) { conf_thresh_ = conf_thresh; }
+
+    CV_WRAP bool waveCorrection() const { return do_wave_correct_; }
+    CV_WRAP void setWaveCorrection(bool flag) { do_wave_correct_ = flag; }
+
+    CV_WRAP InterpolationFlags interpolationFlags() const { return interp_flags_; }
+    CV_WRAP void setInterpolationFlags(InterpolationFlags interp_flags) { interp_flags_ = interp_flags; }
+
+    detail::WaveCorrectKind waveCorrectKind() const { return wave_correct_kind_; }
+    void setWaveCorrectKind(detail::WaveCorrectKind kind) { wave_correct_kind_ = kind; }
+
+    Ptr<Feature2D> featuresFinder() { return features_finder_; }
+    Ptr<Feature2D> featuresFinder() const { return features_finder_; }
+    void setFeaturesFinder(Ptr<Feature2D> features_finder)
+        { features_finder_ = features_finder; }
+
+    Ptr<detail::FeaturesMatcher> featuresMatcher() { return features_matcher_; }
+    Ptr<detail::FeaturesMatcher> featuresMatcher() const { return features_matcher_; }
+    void setFeaturesMatcher(Ptr<detail::FeaturesMatcher> features_matcher)
+        { features_matcher_ = features_matcher; }
+
+    const cv::UMat& matchingMask() const { return matching_mask_; }
+    void setMatchingMask(const cv::UMat &mask)
+    {
+        CV_Assert(mask.type() == CV_8U && mask.cols == mask.rows);
+        matching_mask_ = mask.clone();
+    }
+
+    Ptr<detail::BundleAdjusterBase> bundleAdjuster() { return bundle_adjuster_; }
+    const Ptr<detail::BundleAdjusterBase> bundleAdjuster() const { return bundle_adjuster_; }
+    void setBundleAdjuster(Ptr<detail::BundleAdjusterBase> bundle_adjuster)
+        { bundle_adjuster_ = bundle_adjuster; }
+
+    Ptr<detail::Estimator> estimator() { return estimator_; }
+    const Ptr<detail::Estimator> estimator() const { return estimator_; }
+    void setEstimator(Ptr<detail::Estimator> estimator)
+        { estimator_ = estimator; }
+
+    Ptr<WarperCreator> warper() { return warper_; }
+    const Ptr<WarperCreator> warper() const { return warper_; }
+    void setWarper(Ptr<WarperCreator> creator) { warper_ = creator; }
+
+    Ptr<detail::ExposureCompensator> exposureCompensator() { return exposure_comp_; }
+    const Ptr<detail::ExposureCompensator> exposureCompensator() const { return exposure_comp_; }
+    void setExposureCompensator(Ptr<detail::ExposureCompensator> exposure_comp)
+        { exposure_comp_ = exposure_comp; }
+
+    Ptr<detail::SeamFinder> seamFinder() { return seam_finder_; }
+    const Ptr<detail::SeamFinder> seamFinder() const { return seam_finder_; }
+    void setSeamFinder(Ptr<detail::SeamFinder> seam_finder) { seam_finder_ = seam_finder; }
+
+    Ptr<detail::Blender> blender() { return blender_; }
+    const Ptr<detail::Blender> blender() const { return blender_; }
+    void setBlender(Ptr<detail::Blender> b) { blender_ = b; }
+
+    /** @brief These functions try to match the given images and to estimate rotations of each camera.
+
+    @note Use the functions only if you're aware of the stitching pipeline, otherwise use
+    Stitcher::stitch.
+
+    @param images Input images.
+    @param masks Masks for each input image specifying where to look for keypoints (optional).
+    @return Status code.
+     */
+    CV_WRAP Status estimateTransform(InputArrayOfArrays images, InputArrayOfArrays masks = noArray());
+
+    /** @brief These function restors camera rotation and camera intrinsics of each camera
+     *  that can be got with @ref Stitcher::cameras call
+
+    @param images Input images.
+    @param cameras Estimated rotation of cameras for each of the input images.
+    @param component Indices (0-based) of images constituting the final panorama (optional).
+    @return Status code.
+     */
+    Status setTransform(InputArrayOfArrays images,
+                        const std::vector<detail::CameraParams> &cameras,
+                        const std::vector<int> &component);
+    /** @overload */
+    Status setTransform(InputArrayOfArrays images, const std::vector<detail::CameraParams> &cameras);
+
+    /** @overload */
+    CV_WRAP Status composePanorama(OutputArray pano);
+    /** @brief These functions try to compose the given images (or images stored internally from the other function
+    calls) into the final pano under the assumption that the image transformations were estimated
+    before.
+
+    @note Use the functions only if you're aware of the stitching pipeline, otherwise use
+    Stitcher::stitch.
+
+    @param images Input images.
+    @param pano Final pano.
+    @return Status code.
+     */
+    CV_WRAP Status composePanorama(InputArrayOfArrays images, OutputArray pano);
+
+    /** @overload */
+    CV_WRAP Status stitch(InputArrayOfArrays images, OutputArray pano);
+    /** @brief These functions try to stitch the given images.
+
+    @param images Input images.
+    @param masks Masks for each input image specifying where to look for keypoints (optional).
+    @param pano Final pano.
+    @return Status code.
+     */
+    CV_WRAP Status stitch(InputArrayOfArrays images, InputArrayOfArrays masks, OutputArray pano);
+
+    /** @brief Returns indices of input images used in panorama stitching
+     */
+    CV_WRAP std::vector<int> component() const { return indices_; }
+
+    /** Returns estimated camera parameters for all stitched images
+     */
+    CV_WRAP std::vector<cv::detail::CameraParams> cameras() const { return cameras_; }
+    CV_WRAP double workScale() const { return work_scale_; }
+
+    /** @brief Return the mask of the panorama.
+
+    The mask is a 8U UMat with the values: 0xFF (white) for pixels filled by the input images,
+    0 (black) for unused pixels. It can be used as the mask for inpaint.
+
+    @return The mask.
+     */
+    UMat resultMask() const { return result_mask_; }
+
+private:
+    Status matchImages();
+    Status estimateCameraParams();
+
+    double registr_resol_;
+    double seam_est_resol_;
+    double compose_resol_;
+    double conf_thresh_;
+    InterpolationFlags interp_flags_;
+    Ptr<Feature2D> features_finder_;
+    Ptr<detail::FeaturesMatcher> features_matcher_;
+    cv::UMat matching_mask_;
+    Ptr<detail::BundleAdjusterBase> bundle_adjuster_;
+    Ptr<detail::Estimator> estimator_;
+    bool do_wave_correct_;
+    detail::WaveCorrectKind wave_correct_kind_;
+    Ptr<WarperCreator> warper_;
+    Ptr<detail::ExposureCompensator> exposure_comp_;
+    Ptr<detail::SeamFinder> seam_finder_;
+    Ptr<detail::Blender> blender_;
+
+    std::vector<cv::UMat> imgs_;
+    std::vector<cv::UMat> masks_;
+    std::vector<cv::Size> full_img_sizes_;
+    std::vector<detail::ImageFeatures> features_;
+    std::vector<detail::MatchesInfo> pairwise_matches_;
+    std::vector<cv::UMat> seam_est_imgs_;
+    std::vector<int> indices_;
+    std::vector<detail::CameraParams> cameras_;
+    UMat result_mask_;
+    double work_scale_;
+    double seam_scale_;
+    double seam_work_aspect_;
+    double warped_image_scale_;
+};
+
+/**
+ * @deprecated use Stitcher::create
+ */
+CV_DEPRECATED Ptr<Stitcher> createStitcher(bool try_use_gpu = false);
+
+/**
+ * @deprecated use Stitcher::create
+ */
+CV_DEPRECATED Ptr<Stitcher> createStitcherScans(bool try_use_gpu = false);
+
+//! @} stitching
+
+} // namespace cv
+
+#endif // OPENCV_STITCHING_STITCHER_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/autocalib.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/autocalib.hpp
new file mode 100644
index 0000000..8eb6212
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/autocalib.hpp
@@ -0,0 +1,86 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_AUTOCALIB_HPP
+#define OPENCV_STITCHING_AUTOCALIB_HPP
+
+#include "opencv2/core.hpp"
+#include "matchers.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_autocalib
+//! @{
+
+/** @brief Tries to estimate focal lengths from the given homography under the assumption that the camera
+undergoes rotations around its centre only.
+
+@param H Homography.
+@param f0 Estimated focal length along X axis.
+@param f1 Estimated focal length along Y axis.
+@param f0_ok True, if f0 was estimated successfully, false otherwise.
+@param f1_ok True, if f1 was estimated successfully, false otherwise.
+
+See "Construction of Panoramic Image Mosaics with Global and Local Alignment"
+by Heung-Yeung Shum and Richard Szeliski.
+ */
+void CV_EXPORTS_W focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok);
+
+/** @brief Estimates focal lengths for each given camera.
+
+@param features Features of images.
+@param pairwise_matches Matches between all image pairs.
+@param focals Estimated focal lengths for each camera.
+ */
+void CV_EXPORTS estimateFocal(const std::vector<ImageFeatures> &features,
+                              const std::vector<MatchesInfo> &pairwise_matches,
+                              std::vector<double> &focals);
+
+bool CV_EXPORTS_W calibrateRotatingCamera(const std::vector<Mat> &Hs,CV_OUT Mat &K);
+
+//! @} stitching_autocalib
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_AUTOCALIB_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/blenders.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/blenders.hpp
new file mode 100644
index 0000000..ec35aa7
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/blenders.hpp
@@ -0,0 +1,184 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_BLENDERS_HPP
+#define OPENCV_STITCHING_BLENDERS_HPP
+
+#if defined(NO)
+#  warning Detected Apple 'NO' macro definition, it can cause build conflicts. Please, include this header before any Apple headers.
+#endif
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/cuda.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_blend
+//! @{
+
+/** @brief Base class for all blenders.
+
+Simple blender which puts one image over another
+*/
+class CV_EXPORTS_W Blender
+{
+public:
+    virtual ~Blender() {}
+
+    enum { NO, FEATHER, MULTI_BAND };
+    CV_WRAP static Ptr<Blender> createDefault(int type, bool try_gpu = false);
+
+    /** @brief Prepares the blender for blending.
+
+    @param corners Source images top-left corners
+    @param sizes Source image sizes
+     */
+    CV_WRAP virtual void prepare(const std::vector<Point> &corners, const std::vector<Size> &sizes);
+    /** @overload */
+    CV_WRAP virtual void prepare(Rect dst_roi);
+    /** @brief Processes the image.
+
+    @param img Source image
+    @param mask Source image mask
+    @param tl Source image top-left corners
+     */
+    CV_WRAP virtual void feed(InputArray img, InputArray mask, Point tl);
+    /** @brief Blends and returns the final pano.
+
+    @param dst Final pano
+    @param dst_mask Final pano mask
+     */
+    CV_WRAP virtual void blend(CV_IN_OUT InputOutputArray dst,CV_IN_OUT  InputOutputArray dst_mask);
+
+protected:
+    UMat dst_, dst_mask_;
+    Rect dst_roi_;
+};
+
+/** @brief Simple blender which mixes images at its borders.
+ */
+class CV_EXPORTS_W FeatherBlender : public Blender
+{
+public:
+    CV_WRAP FeatherBlender(float sharpness = 0.02f);
+
+    CV_WRAP float sharpness() const { return sharpness_; }
+    CV_WRAP void setSharpness(float val) { sharpness_ = val; }
+
+    CV_WRAP void prepare(Rect dst_roi) CV_OVERRIDE;
+    CV_WRAP void feed(InputArray img, InputArray mask, Point tl) CV_OVERRIDE;
+    CV_WRAP void blend(InputOutputArray dst, InputOutputArray dst_mask) CV_OVERRIDE;
+
+    //! Creates weight maps for fixed set of source images by their masks and top-left corners.
+    //! Final image can be obtained by simple weighting of the source images.
+    CV_WRAP Rect createWeightMaps(const std::vector<UMat> &masks, const std::vector<Point> &corners,
+        CV_IN_OUT std::vector<UMat> &weight_maps);
+
+private:
+    float sharpness_;
+    UMat weight_map_;
+    UMat dst_weight_map_;
+};
+
+inline FeatherBlender::FeatherBlender(float _sharpness) { setSharpness(_sharpness); }
+
+/** @brief Blender which uses multi-band blending algorithm (see @cite BA83).
+ */
+class CV_EXPORTS_W MultiBandBlender : public Blender
+{
+public:
+    CV_WRAP MultiBandBlender(int try_gpu = false, int num_bands = 5, int weight_type = CV_32F);
+
+    CV_WRAP int numBands() const { return actual_num_bands_; }
+    CV_WRAP void setNumBands(int val) { actual_num_bands_ = val; }
+
+    CV_WRAP void prepare(Rect dst_roi) CV_OVERRIDE;
+    CV_WRAP void feed(InputArray img, InputArray mask, Point tl) CV_OVERRIDE;
+    CV_WRAP void blend(CV_IN_OUT InputOutputArray dst, CV_IN_OUT InputOutputArray dst_mask) CV_OVERRIDE;
+
+private:
+    int actual_num_bands_, num_bands_;
+    std::vector<UMat> dst_pyr_laplace_;
+    std::vector<UMat> dst_band_weights_;
+    Rect dst_roi_final_;
+    bool can_use_gpu_;
+    int weight_type_; //CV_32F or CV_16S
+#if defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    std::vector<cuda::GpuMat> gpu_dst_pyr_laplace_;
+    std::vector<cuda::GpuMat> gpu_dst_band_weights_;
+    std::vector<Point> gpu_tl_points_;
+    std::vector<cuda::GpuMat> gpu_imgs_with_border_;
+    std::vector<std::vector<cuda::GpuMat> > gpu_weight_pyr_gauss_vec_;
+    std::vector<std::vector<cuda::GpuMat> > gpu_src_pyr_laplace_vec_;
+    std::vector<std::vector<cuda::GpuMat> > gpu_ups_;
+    cuda::GpuMat gpu_dst_mask_;
+    cuda::GpuMat gpu_mask_;
+    cuda::GpuMat gpu_img_;
+    cuda::GpuMat gpu_weight_map_;
+    cuda::GpuMat gpu_add_mask_;
+    int gpu_feed_idx_;
+    bool gpu_initialized_;
+#endif
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
+
+void CV_EXPORTS_W normalizeUsingWeightMap(InputArray weight, CV_IN_OUT InputOutputArray src);
+
+void CV_EXPORTS_W createWeightMap(InputArray mask, float sharpness, CV_IN_OUT InputOutputArray weight);
+
+void CV_EXPORTS_W createLaplacePyr(InputArray img, int num_levels, CV_IN_OUT std::vector<UMat>& pyr);
+void CV_EXPORTS_W createLaplacePyrGpu(InputArray img, int num_levels, CV_IN_OUT std::vector<UMat>& pyr);
+
+// Restores source image
+void CV_EXPORTS_W restoreImageFromLaplacePyr(CV_IN_OUT std::vector<UMat>& pyr);
+void CV_EXPORTS_W restoreImageFromLaplacePyrGpu(CV_IN_OUT std::vector<UMat>& pyr);
+
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_BLENDERS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/camera.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/camera.hpp
new file mode 100644
index 0000000..14ecf60
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/camera.hpp
@@ -0,0 +1,78 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_CAMERA_HPP
+#define OPENCV_STITCHING_CAMERA_HPP
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching
+//! @{
+
+/** @brief Describes camera parameters.
+
+@note Translation is assumed to be zero during the whole stitching pipeline. :
+ */
+struct CV_EXPORTS_W_SIMPLE CameraParams
+{
+    CameraParams();
+    CameraParams(const CameraParams& other);
+    CameraParams& operator =(const CameraParams& other);
+    CV_WRAP Mat K() const;
+
+    CV_PROP_RW double focal; // Focal length
+    CV_PROP_RW double aspect; // Aspect ratio
+    CV_PROP_RW double ppx; // Principal point X
+    CV_PROP_RW double ppy; // Principal point Y
+    CV_PROP_RW Mat R; // Rotation
+    CV_PROP_RW Mat t; // Translation
+};
+
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#endif // #ifndef OPENCV_STITCHING_CAMERA_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/exposure_compensate.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/exposure_compensate.hpp
new file mode 100644
index 0000000..8b169e7
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/exposure_compensate.hpp
@@ -0,0 +1,246 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
+#define OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
+
+#if defined(NO)
+#undef NO
+//#warning Detected Apple 'NO' macro definition, it can cause build conflicts. Please, include this header before any Apple headers.
+#endif
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_exposure
+//! @{
+
+/** @brief Base class for all exposure compensators.
+ */
+class CV_EXPORTS_W ExposureCompensator
+{
+public:
+    ExposureCompensator(): updateGain(true) {}
+    virtual ~ExposureCompensator() {}
+
+    enum { NO, GAIN, GAIN_BLOCKS, CHANNELS, CHANNELS_BLOCKS };
+    CV_WRAP static Ptr<ExposureCompensator> createDefault(int type);
+
+    /**
+    @param corners Source image top-left corners
+    @param images Source images
+    @param masks Image masks to update (second value in pair specifies the value which should be used
+    to detect where image is)
+        */
+    CV_WRAP void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+        const std::vector<UMat> &masks);
+    /** @overload */
+    virtual void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+        const std::vector<std::pair<UMat, uchar> > &masks) = 0;
+    /** @brief Compensate exposure in the specified image.
+
+    @param index Image index
+    @param corner Image top-left corner
+    @param image Image to process
+    @param mask Image mask
+        */
+    CV_WRAP virtual void apply(int index, Point corner, InputOutputArray image, InputArray mask) = 0;
+    CV_WRAP virtual void getMatGains(CV_OUT std::vector<Mat>& ) {CV_Error(Error::StsInternal, "");}
+    CV_WRAP virtual void setMatGains(std::vector<Mat>& ) { CV_Error(Error::StsInternal, ""); }
+    CV_WRAP void setUpdateGain(bool b) { updateGain = b; }
+    CV_WRAP bool getUpdateGain() { return updateGain; }
+protected :
+    bool updateGain;
+};
+
+/** @brief Stub exposure compensator which does nothing.
+ */
+class CV_EXPORTS_W NoExposureCompensator : public ExposureCompensator
+{
+public:
+    void feed(const std::vector<Point> &/*corners*/, const std::vector<UMat> &/*images*/,
+              const std::vector<std::pair<UMat,uchar> > &/*masks*/) CV_OVERRIDE { }
+    CV_WRAP void apply(int /*index*/, Point /*corner*/, InputOutputArray /*image*/, InputArray /*mask*/) CV_OVERRIDE { }
+    CV_WRAP void getMatGains(CV_OUT std::vector<Mat>& umv) CV_OVERRIDE { umv.clear(); return; }
+    CV_WRAP void setMatGains(std::vector<Mat>& umv) CV_OVERRIDE { umv.clear(); return; }
+};
+
+/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image
+intensities, see @cite BL07 and @cite WJ10 for details.
+ */
+class CV_EXPORTS_W GainCompensator : public ExposureCompensator
+{
+public:
+    // This Constructor only exists to make source level compatibility detector happy
+    CV_WRAP GainCompensator()
+            : GainCompensator(1) {}
+    CV_WRAP GainCompensator(int nr_feeds)
+            : nr_feeds_(nr_feeds), similarity_threshold_(1) {}
+    void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+              const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+    void singleFeed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                    const std::vector<std::pair<UMat,uchar> > &masks);
+    CV_WRAP void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE;
+    CV_WRAP void getMatGains(CV_OUT std::vector<Mat>& umv) CV_OVERRIDE ;
+    CV_WRAP void setMatGains(std::vector<Mat>& umv) CV_OVERRIDE ;
+    CV_WRAP void setNrFeeds(int nr_feeds) { nr_feeds_ = nr_feeds; }
+    CV_WRAP int getNrFeeds() { return nr_feeds_; }
+    CV_WRAP void setSimilarityThreshold(double similarity_threshold) { similarity_threshold_ = similarity_threshold; }
+    CV_WRAP double getSimilarityThreshold() const { return similarity_threshold_; }
+    void prepareSimilarityMask(const std::vector<Point> &corners, const std::vector<UMat> &images);
+    std::vector<double> gains() const;
+
+private:
+    UMat buildSimilarityMask(InputArray src_array1, InputArray src_array2);
+
+    Mat_<double> gains_;
+    int nr_feeds_;
+    double similarity_threshold_;
+    std::vector<UMat> similarities_;
+};
+
+/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image
+intensities on each channel independently.
+ */
+class CV_EXPORTS_W ChannelsCompensator : public ExposureCompensator
+{
+public:
+    CV_WRAP ChannelsCompensator(int nr_feeds=1)
+        : nr_feeds_(nr_feeds), similarity_threshold_(1) {}
+    void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+              const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+    CV_WRAP void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE;
+    CV_WRAP void getMatGains(CV_OUT std::vector<Mat>& umv) CV_OVERRIDE;
+    CV_WRAP void setMatGains(std::vector<Mat>& umv) CV_OVERRIDE;
+    CV_WRAP void setNrFeeds(int nr_feeds) { nr_feeds_ = nr_feeds; }
+    CV_WRAP int getNrFeeds() { return nr_feeds_; }
+    CV_WRAP void setSimilarityThreshold(double similarity_threshold) { similarity_threshold_ = similarity_threshold; }
+    CV_WRAP double getSimilarityThreshold() const { return similarity_threshold_; }
+    std::vector<Scalar> gains() const { return gains_; }
+
+private:
+    std::vector<Scalar> gains_;
+    int nr_feeds_;
+    double similarity_threshold_;
+};
+
+/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image blocks.
+ */
+class CV_EXPORTS_W BlocksCompensator : public ExposureCompensator
+{
+public:
+    BlocksCompensator(int bl_width=32, int bl_height=32, int nr_feeds=1)
+            : bl_width_(bl_width), bl_height_(bl_height), nr_feeds_(nr_feeds), nr_gain_filtering_iterations_(2),
+              similarity_threshold_(1) {}
+    CV_WRAP void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE;
+    CV_WRAP void getMatGains(CV_OUT std::vector<Mat>& umv) CV_OVERRIDE;
+    CV_WRAP void setMatGains(std::vector<Mat>& umv) CV_OVERRIDE;
+    CV_WRAP void setNrFeeds(int nr_feeds) { nr_feeds_ = nr_feeds; }
+    CV_WRAP int getNrFeeds() { return nr_feeds_; }
+    CV_WRAP void setSimilarityThreshold(double similarity_threshold) { similarity_threshold_ = similarity_threshold; }
+    CV_WRAP double getSimilarityThreshold() const { return similarity_threshold_; }
+    CV_WRAP void setBlockSize(int width, int height) { bl_width_ = width; bl_height_ = height; }
+    CV_WRAP void setBlockSize(Size size) { setBlockSize(size.width, size.height); }
+    CV_WRAP Size getBlockSize() const { return Size(bl_width_, bl_height_); }
+    CV_WRAP void setNrGainsFilteringIterations(int nr_iterations) { nr_gain_filtering_iterations_ = nr_iterations; }
+    CV_WRAP int getNrGainsFilteringIterations() const { return nr_gain_filtering_iterations_; }
+
+protected:
+    template<class Compensator>
+    void feedWithStrategy(const std::vector<Point> &corners, const std::vector<UMat> &images,
+              const std::vector<std::pair<UMat,uchar> > &masks);
+
+private:
+    UMat getGainMap(const GainCompensator& compensator, int bl_idx, Size bl_per_img);
+    UMat getGainMap(const ChannelsCompensator& compensator, int bl_idx, Size bl_per_img);
+
+    int bl_width_, bl_height_;
+    std::vector<UMat> gain_maps_;
+    int nr_feeds_;
+    int nr_gain_filtering_iterations_;
+    double similarity_threshold_;
+};
+
+/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image block
+intensities, see @cite UES01 for details.
+ */
+class CV_EXPORTS_W BlocksGainCompensator : public BlocksCompensator
+{
+public:
+    // This Constructor only exists to make source level compatibility detector happy
+    CV_WRAP BlocksGainCompensator(int bl_width = 32, int bl_height = 32)
+            : BlocksGainCompensator(bl_width, bl_height, 1) {}
+    CV_WRAP BlocksGainCompensator(int bl_width, int bl_height, int nr_feeds)
+            : BlocksCompensator(bl_width, bl_height, nr_feeds) {}
+
+    void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+              const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+
+    // This function only exists to make source level compatibility detector happy
+    CV_WRAP void apply(int index, Point corner, InputOutputArray image, InputArray mask) CV_OVERRIDE {
+        BlocksCompensator::apply(index, corner, image, mask); }
+    // This function only exists to make source level compatibility detector happy
+    CV_WRAP void getMatGains(CV_OUT std::vector<Mat>& umv) CV_OVERRIDE { BlocksCompensator::getMatGains(umv); }
+    // This function only exists to make source level compatibility detector happy
+    CV_WRAP void setMatGains(std::vector<Mat>& umv) CV_OVERRIDE { BlocksCompensator::setMatGains(umv); }
+};
+
+/** @brief Exposure compensator which tries to remove exposure related artifacts by adjusting image block
+on each channel.
+ */
+class CV_EXPORTS_W BlocksChannelsCompensator : public BlocksCompensator
+{
+public:
+    CV_WRAP BlocksChannelsCompensator(int bl_width=32, int bl_height=32, int nr_feeds=1)
+            : BlocksCompensator(bl_width, bl_height, nr_feeds) {}
+
+    void feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+              const std::vector<std::pair<UMat,uchar> > &masks) CV_OVERRIDE;
+};
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_EXPOSURE_COMPENSATE_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/matchers.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/matchers.hpp
new file mode 100644
index 0000000..661090b
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/matchers.hpp
@@ -0,0 +1,307 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_MATCHERS_HPP
+#define OPENCV_STITCHING_MATCHERS_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/features.hpp"
+
+#include "opencv2/opencv_modules.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_match
+//! @{
+
+/** @brief Structure containing image keypoints and descriptors. */
+struct CV_EXPORTS_W_SIMPLE ImageFeatures
+{
+    CV_PROP_RW int img_idx;
+    CV_PROP_RW Size img_size;
+    CV_PROP_RW std::vector<KeyPoint> keypoints;
+    CV_PROP_RW UMat descriptors;
+    CV_WRAP std::vector<KeyPoint> getKeypoints() { return keypoints; }
+};
+/** @brief
+
+@param featuresFinder
+@param images
+@param features
+@param masks
+*/
+CV_EXPORTS_W void computeImageFeatures(
+    const Ptr<Feature2D> &featuresFinder,
+    InputArrayOfArrays  images,
+    CV_OUT std::vector<ImageFeatures> &features,
+    InputArrayOfArrays masks = noArray());
+
+/** @brief
+
+@param featuresFinder
+@param image
+@param features
+@param mask
+*/
+CV_EXPORTS_AS(computeImageFeatures2) void computeImageFeatures(
+    const Ptr<Feature2D> &featuresFinder,
+    InputArray image,
+    CV_OUT ImageFeatures &features,
+    InputArray mask = noArray());
+
+/** @brief Structure containing information about matches between two images.
+
+It's assumed that there is a transformation between those images. Transformation may be
+homography or affine transformation based on selected matcher.
+
+@sa detail::FeaturesMatcher
+*/
+struct CV_EXPORTS_W_SIMPLE MatchesInfo
+{
+    MatchesInfo();
+    MatchesInfo(const MatchesInfo &other);
+    MatchesInfo& operator =(const MatchesInfo &other);
+
+    CV_PROP_RW int src_img_idx;
+    CV_PROP_RW int dst_img_idx;       //!< Images indices (optional)
+    CV_PROP_RW std::vector<DMatch> matches;
+    CV_PROP_RW std::vector<uchar> inliers_mask;    //!< Geometrically consistent matches mask
+    CV_PROP_RW int num_inliers;                    //!< Number of geometrically consistent matches
+    CV_PROP_RW Mat H;                              //!< Estimated transformation
+    CV_PROP_RW double confidence;                  //!< Confidence two images are from the same panorama
+    CV_WRAP std::vector<DMatch> getMatches() { return matches; }
+    CV_WRAP std::vector<uchar> getInliers() { return inliers_mask; }
+};
+
+/** @brief Feature matchers base class. */
+class CV_EXPORTS_W FeaturesMatcher
+{
+public:
+    CV_WRAP virtual ~FeaturesMatcher() {}
+
+    /** @overload
+    @param features1 First image features
+    @param features2 Second image features
+    @param matches_info Found matches
+    */
+    CV_WRAP_AS(apply) void operator ()(const ImageFeatures &features1, const ImageFeatures &features2,
+                     CV_OUT MatchesInfo& matches_info) { match(features1, features2, matches_info); }
+
+    /** @brief Performs images matching.
+
+    @param features Features of the source images
+    @param pairwise_matches Found pairwise matches
+    @param mask Mask indicating which image pairs must be matched
+
+    The function is parallelized with the TBB library.
+
+    @sa detail::MatchesInfo
+    */
+    CV_WRAP_AS(apply2) void operator ()(const std::vector<ImageFeatures> &features, CV_OUT std::vector<MatchesInfo> &pairwise_matches,
+                                        const cv::UMat &mask = cv::UMat()) { match(features, pairwise_matches, mask); }
+
+    /** @return True, if it's possible to use the same matcher instance in parallel, false otherwise
+    */
+   CV_WRAP bool isThreadSafe() const { return is_thread_safe_; }
+
+    /** @brief Frees unused memory allocated before if there is any.
+    */
+   CV_WRAP virtual void collectGarbage() {}
+
+protected:
+    FeaturesMatcher(bool is_thread_safe = false) : is_thread_safe_(is_thread_safe) {}
+
+    /** @brief This method must implement matching logic in order to make the wrappers
+    detail::FeaturesMatcher::operator()_ work.
+
+    @param features1 first image features
+    @param features2 second image features
+    @param matches_info found matches
+     */
+    virtual void match(const ImageFeatures &features1, const ImageFeatures &features2,
+                       MatchesInfo& matches_info) = 0;
+
+    /** @brief This method implements logic to match features between arbitrary number of features.
+    By default this checks every pair of inputs in the input, but the behaviour can be changed by subclasses.
+
+    @param features vector of image features
+    @param pairwise_matches found matches
+    @param mask (optional) mask indicating which image pairs should be matched
+     */
+    virtual void match(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
+                       const cv::UMat &mask = cv::UMat());
+
+    bool is_thread_safe_;
+};
+
+/** @brief Features matcher which finds two best matches for each feature and leaves the best one only if the
+ratio between descriptor distances is greater than the threshold match_conf
+
+@sa detail::FeaturesMatcher
+ */
+class CV_EXPORTS_W BestOf2NearestMatcher : public FeaturesMatcher
+{
+public:
+    /** @brief Constructs a "best of 2 nearest" matcher.
+
+    @param try_use_gpu Should try to use GPU or not
+    @param match_conf Match distances ration threshold
+    @param num_matches_thresh1 Minimum number of matches required for the 2D projective transform
+    estimation used in the inliers classification step
+    @param num_matches_thresh2 Minimum number of matches required for the 2D projective transform
+    re-estimation on inliers
+    @param matches_confidence_thresh Matching confidence threshold to take the match into account.
+    The threshold was determined experimentally and set to 3 by default.
+     */
+    CV_WRAP BestOf2NearestMatcher(bool try_use_gpu = false, float match_conf = 0.3f, int num_matches_thresh1 = 6,
+                          int num_matches_thresh2 = 6, double matches_confidence_thresh = 3.);
+
+    CV_WRAP void collectGarbage() CV_OVERRIDE;
+    CV_WRAP static Ptr<BestOf2NearestMatcher> create(bool try_use_gpu = false, float match_conf = 0.3f, int num_matches_thresh1 = 6,
+        int num_matches_thresh2 = 6, double matches_confidence_thresh = 3.);
+
+protected:
+
+    void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info) CV_OVERRIDE;
+    int num_matches_thresh1_;
+    int num_matches_thresh2_;
+    double matches_confidence_thresh_;
+    Ptr<FeaturesMatcher> impl_;
+};
+
+class CV_EXPORTS_W BestOf2NearestRangeMatcher : public BestOf2NearestMatcher
+{
+public:
+    CV_WRAP BestOf2NearestRangeMatcher(int range_width = 5, bool try_use_gpu = false, float match_conf = 0.3f,
+                            int num_matches_thresh1 = 6, int num_matches_thresh2 = 6);
+
+protected:
+    // indicate that we do not want to hide the base class match method with a different signature
+    using BestOf2NearestMatcher::match;
+    void match(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
+               const cv::UMat &mask = cv::UMat()) CV_OVERRIDE;
+
+    int range_width_;
+};
+
+/** @brief Features matcher similar to cv::detail::BestOf2NearestMatcher which
+finds two best matches for each feature and leaves the best one only if the
+ratio between descriptor distances is greater than the threshold match_conf.
+
+Unlike cv::detail::BestOf2NearestMatcher this matcher uses affine
+transformation (affine transformation estimate will be placed in matches_info).
+
+@sa cv::detail::FeaturesMatcher cv::detail::BestOf2NearestMatcher
+ */
+class CV_EXPORTS_W AffineBestOf2NearestMatcher : public BestOf2NearestMatcher
+{
+public:
+    /** @brief Constructs a "best of 2 nearest" matcher that expects affine transformation
+    between images
+
+    @param full_affine whether to use full affine transformation with 6 degress of freedom or reduced
+    transformation with 4 degrees of freedom using only rotation, translation and uniform scaling
+    @param try_use_gpu Should try to use GPU or not
+    @param match_conf Match distances ration threshold
+    @param num_matches_thresh1 Minimum number of matches required for the 2D affine transform
+    estimation used in the inliers classification step
+
+    @sa cv::estimateAffine2D cv::estimateAffinePartial2D
+     */
+    CV_WRAP AffineBestOf2NearestMatcher(bool full_affine = false, bool try_use_gpu = false,
+                                float match_conf = 0.3f, int num_matches_thresh1 = 6) :
+        BestOf2NearestMatcher(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh1),
+        full_affine_(full_affine) {}
+
+protected:
+    void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info) CV_OVERRIDE;
+
+    bool full_affine_;
+};
+
+/** @brief Features matcher that adapts LightGlueMatcher (DescriptorMatcher) to the
+stitching pipeline's FeaturesMatcher interface.
+
+This matcher uses DNN-based LightGlue for feature matching, requiring ALIKED-style
+keypoints with spatial context for positional encoding.
+
+@sa cv::detail::FeaturesMatcher cv::LightGlueMatcher
+ */
+class CV_EXPORTS_W LightGlueFeaturesMatcher : public FeaturesMatcher
+{
+public:
+    /** @brief Constructs a LightGlue features matcher.
+
+    @param lgMatcher LightGlueMatcher instance for DNN-based matching
+    @param num_matches_thresh1 Minimum number of matches required for the 2D projective transform
+    estimation used in the inliers classification step
+    @param num_matches_thresh2 Minimum number of matches required for the 2D projective transform
+    re-estimation on inliers
+    @param matches_confidence_thresh Matching confidence threshold to take the match into account.
+     */
+    CV_WRAP LightGlueFeaturesMatcher(Ptr<LightGlueMatcher> lgMatcher,
+                              int num_matches_thresh1 = 6,
+                              int num_matches_thresh2 = 6,
+                              double matches_confidence_thresh = 3.0);
+
+    /** @brief Sets the LightGlue confidence threshold for filtering matches.
+     */
+    CV_WRAP void setScoreThreshold(float thresh);
+
+protected:
+    void match(const ImageFeatures &features1, const ImageFeatures &features2,
+               MatchesInfo &matches_info) CV_OVERRIDE;
+
+    Ptr<LightGlueMatcher> lgMatcher_;
+    int num_matches_thresh1_;
+    int num_matches_thresh2_;
+    double matches_confidence_thresh_;
+    float lg_score_thresh_;
+};
+
+//! @} stitching_match
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_MATCHERS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/motion_estimators.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/motion_estimators.hpp
new file mode 100644
index 0000000..c03aa52
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/motion_estimators.hpp
@@ -0,0 +1,373 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
+#define OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
+
+#include "opencv2/core.hpp"
+#include "matchers.hpp"
+#include "util.hpp"
+#include "camera.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_rotation
+//! @{
+
+/** @brief Rotation estimator base class.
+
+It takes features of all images, pairwise matches between all images and estimates rotations of all
+cameras.
+
+@note The coordinate system origin is implementation-dependent, but you can always normalize the
+rotations in respect to the first camera, for instance. :
+ */
+class CV_EXPORTS_W Estimator
+{
+public:
+    virtual ~Estimator() {}
+
+    /** @brief Estimates camera parameters.
+
+    @param features Features of images
+    @param pairwise_matches Pairwise matches of images
+    @param cameras Estimated camera parameters
+    @return True in case of success, false otherwise
+     */
+    CV_WRAP_AS(apply) bool operator ()(const std::vector<ImageFeatures> &features,
+        const std::vector<MatchesInfo> &pairwise_matches,
+        CV_OUT CV_IN_OUT std::vector<CameraParams> &cameras)
+    {
+        return estimate(features, pairwise_matches, cameras);
+    }
+
+protected:
+    /** @brief This method must implement camera parameters estimation logic in order to make the wrapper
+    detail::Estimator::operator()_ work.
+
+    @param features Features of images
+    @param pairwise_matches Pairwise matches of images
+    @param cameras Estimated camera parameters
+    @return True in case of success, false otherwise
+     */
+    virtual bool estimate(const std::vector<ImageFeatures> &features,
+                          const std::vector<MatchesInfo> &pairwise_matches,
+                          CV_OUT std::vector<CameraParams> &cameras) = 0;
+};
+
+/** @brief Homography based rotation estimator.
+ */
+class CV_EXPORTS_W HomographyBasedEstimator : public Estimator
+{
+public:
+    CV_WRAP HomographyBasedEstimator(bool is_focals_estimated = false)
+        : is_focals_estimated_(is_focals_estimated) {}
+
+private:
+    virtual bool estimate(const std::vector<ImageFeatures> &features,
+                          const std::vector<MatchesInfo> &pairwise_matches,
+                          std::vector<CameraParams> &cameras) CV_OVERRIDE;
+
+    bool is_focals_estimated_;
+};
+
+/** @brief Affine transformation based estimator.
+
+This estimator uses pairwise transformations estimated by matcher to estimate
+final transformation for each camera.
+
+@sa cv::detail::HomographyBasedEstimator
+ */
+class CV_EXPORTS_W AffineBasedEstimator : public Estimator
+{
+public:
+    CV_WRAP AffineBasedEstimator(){}
+private:
+    virtual bool estimate(const std::vector<ImageFeatures> &features,
+                          const std::vector<MatchesInfo> &pairwise_matches,
+                          std::vector<CameraParams> &cameras) CV_OVERRIDE;
+};
+
+/** @brief Base class for all camera parameters refinement methods.
+ */
+class CV_EXPORTS_W BundleAdjusterBase : public Estimator
+{
+public:
+    CV_WRAP Mat refinementMask() const { return refinement_mask_.clone(); }
+    CV_WRAP void setRefinementMask(const Mat &mask)
+    {
+        CV_Assert(mask.type() == CV_8U && mask.size() == Size(3, 3));
+        refinement_mask_ = mask.clone();
+    }
+
+    CV_WRAP double confThresh() const { return conf_thresh_; }
+    CV_WRAP void setConfThresh(double conf_thresh) { conf_thresh_ = conf_thresh; }
+
+    CV_WRAP TermCriteria termCriteria() { return term_criteria_; }
+    CV_WRAP void setTermCriteria(const TermCriteria& term_criteria) { term_criteria_ = term_criteria; }
+
+protected:
+    /** @brief Construct a bundle adjuster base instance.
+
+    @param num_params_per_cam Number of parameters per camera
+    @param num_errs_per_measurement Number of error terms (components) per match
+     */
+    BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement)
+        : num_images_(0), total_num_matches_(0),
+          num_params_per_cam_(num_params_per_cam),
+          num_errs_per_measurement_(num_errs_per_measurement),
+          features_(0), pairwise_matches_(0), conf_thresh_(0)
+    {
+        setRefinementMask(Mat::ones(3, 3, CV_8U));
+        setConfThresh(1.);
+        setTermCriteria(TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 1000, DBL_EPSILON));
+    }
+
+    // Runs bundle adjustment
+    virtual bool estimate(const std::vector<ImageFeatures> &features,
+                          const std::vector<MatchesInfo> &pairwise_matches,
+                          std::vector<CameraParams> &cameras) CV_OVERRIDE;
+
+    /** @brief Sets initial camera parameter to refine.
+
+    @param cameras Camera parameters
+     */
+    virtual void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) = 0;
+    /** @brief Gets the refined camera parameters.
+
+    @param cameras Refined camera parameters
+     */
+    virtual void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const = 0;
+    /** @brief Calculates error vector.
+
+    @param err Error column-vector of length total_num_matches \* num_errs_per_measurement
+     */
+    virtual void calcError(Mat &err) = 0;
+    /** @brief Calculates the cost function jacobian.
+
+    @param jac Jacobian matrix of dimensions
+    (total_num_matches \* num_errs_per_measurement) x (num_images \* num_params_per_cam)
+     */
+    virtual void calcJacobian(Mat &jac) = 0;
+
+    // 3x3 8U mask, where 0 means don't refine respective parameter, != 0 means refine
+    Mat refinement_mask_;
+
+    int num_images_;
+    int total_num_matches_;
+
+    int num_params_per_cam_;
+    int num_errs_per_measurement_;
+
+    const ImageFeatures *features_;
+    const MatchesInfo *pairwise_matches_;
+
+    // Threshold to filter out poorly matched image pairs
+    double conf_thresh_;
+
+    //Levenberg-Marquardt algorithm termination criteria
+    TermCriteria term_criteria_;
+
+    // Camera parameters matrix (CV_64F)
+    Mat cam_params_;
+
+    // Connected images pairs
+    std::vector<std::pair<int,int> > edges_;
+};
+
+
+/** @brief Stub bundle adjuster that does nothing.
+ */
+class CV_EXPORTS_W NoBundleAdjuster : public BundleAdjusterBase
+{
+public:
+    CV_WRAP NoBundleAdjuster() : BundleAdjusterBase(0, 0) {}
+
+private:
+    bool estimate(const std::vector<ImageFeatures> &, const std::vector<MatchesInfo> &,
+                  std::vector<CameraParams> &) CV_OVERRIDE
+    {
+        return true;
+    }
+    void setUpInitialCameraParams(const std::vector<CameraParams> &) CV_OVERRIDE {}
+    void obtainRefinedCameraParams(std::vector<CameraParams> &) const CV_OVERRIDE {}
+    void calcError(Mat &) CV_OVERRIDE {}
+    void calcJacobian(Mat &) CV_OVERRIDE {}
+};
+
+
+/** @brief Implementation of the camera parameters refinement algorithm which minimizes sum of the reprojection
+error squares
+
+It can estimate focal length, aspect ratio, principal point.
+You can affect only on them via the refinement mask.
+ */
+class CV_EXPORTS_W BundleAdjusterReproj : public BundleAdjusterBase
+{
+public:
+    CV_WRAP BundleAdjusterReproj() : BundleAdjusterBase(7, 2) {}
+
+private:
+    void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+    void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+    void calcError(Mat &err) CV_OVERRIDE;
+    void calcJacobian(Mat &jac) CV_OVERRIDE;
+
+    Mat err1_, err2_;
+};
+
+
+/** @brief Implementation of the camera parameters refinement algorithm which minimizes sum of the distances
+between the rays passing through the camera center and a feature. :
+
+It can estimate focal length. It ignores the refinement mask for now.
+ */
+class CV_EXPORTS_W BundleAdjusterRay : public BundleAdjusterBase
+{
+public:
+    CV_WRAP BundleAdjusterRay() : BundleAdjusterBase(4, 3) {}
+
+private:
+    void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+    void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+    void calcError(Mat &err) CV_OVERRIDE;
+    void calcJacobian(Mat &jac) CV_OVERRIDE;
+
+    Mat err1_, err2_;
+};
+
+
+/** @brief Bundle adjuster that expects affine transformation
+represented in homogeneous coordinates in R for each camera param. Implements
+camera parameters refinement algorithm which minimizes sum of the reprojection
+error squares
+
+It estimates all transformation parameters. Refinement mask is ignored.
+
+@sa AffineBasedEstimator AffineBestOf2NearestMatcher BundleAdjusterAffinePartial
+ */
+class CV_EXPORTS_W BundleAdjusterAffine : public BundleAdjusterBase
+{
+public:
+    CV_WRAP BundleAdjusterAffine() : BundleAdjusterBase(6, 2) {}
+
+private:
+    void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+    void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+    void calcError(Mat &err) CV_OVERRIDE;
+    void calcJacobian(Mat &jac) CV_OVERRIDE;
+
+    Mat err1_, err2_;
+};
+
+
+/** @brief Bundle adjuster that expects affine transformation with 4 DOF
+represented in homogeneous coordinates in R for each camera param. Implements
+camera parameters refinement algorithm which minimizes sum of the reprojection
+error squares
+
+It estimates all transformation parameters. Refinement mask is ignored.
+
+@sa AffineBasedEstimator AffineBestOf2NearestMatcher BundleAdjusterAffine
+ */
+class CV_EXPORTS_W BundleAdjusterAffinePartial : public BundleAdjusterBase
+{
+public:
+    CV_WRAP BundleAdjusterAffinePartial() : BundleAdjusterBase(4, 2) {}
+
+private:
+    void setUpInitialCameraParams(const std::vector<CameraParams> &cameras) CV_OVERRIDE;
+    void obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const CV_OVERRIDE;
+    void calcError(Mat &err) CV_OVERRIDE;
+    void calcJacobian(Mat &jac) CV_OVERRIDE;
+
+    Mat err1_, err2_;
+};
+
+
+enum WaveCorrectKind
+{
+    WAVE_CORRECT_HORIZ,
+    WAVE_CORRECT_VERT,
+    WAVE_CORRECT_AUTO
+};
+
+/** @brief Tries to detect the wave correction kind depending
+on whether a panorama spans horizontally or vertically
+
+@param rmats Camera rotation matrices.
+@return The correction kind to use for this panorama
+ */
+CV_EXPORTS
+WaveCorrectKind autoDetectWaveCorrectKind(const std::vector<Mat> &rmats);
+
+/** @brief Tries to make panorama more horizontal (or vertical).
+
+@param rmats Camera rotation matrices.
+@param kind Correction kind, see detail::WaveCorrectKind.
+ */
+void CV_EXPORTS_W waveCorrect(CV_IN_OUT std::vector<Mat> &rmats, WaveCorrectKind kind);
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
+
+// Returns matches graph representation in DOT language
+String CV_EXPORTS_W matchesGraphAsString(std::vector<String> &paths, std::vector<MatchesInfo> &pairwise_matches,
+                                         float conf_threshold);
+
+CV_EXPORTS_W std::vector<int>  leaveBiggestComponent(
+        std::vector<ImageFeatures> &features,
+        std::vector<MatchesInfo> &pairwise_matches,
+        float conf_threshold);
+
+void CV_EXPORTS findMaxSpanningTree(
+        int num_images, const std::vector<MatchesInfo> &pairwise_matches,
+        Graph &span_tree, std::vector<int> &centers);
+
+//! @} stitching_rotation
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_MOTION_ESTIMATORS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/seam_finders.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/seam_finders.hpp
new file mode 100644
index 0000000..bae7aa0
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/seam_finders.hpp
@@ -0,0 +1,291 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_SEAM_FINDERS_HPP
+#define OPENCV_STITCHING_SEAM_FINDERS_HPP
+
+#include <set>
+#include "opencv2/core.hpp"
+#include "opencv2/opencv_modules.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_seam
+//! @{
+
+/** @brief Base class for a seam estimator.
+ */
+class CV_EXPORTS_W SeamFinder
+{
+public:
+    CV_WRAP  virtual ~SeamFinder() {}
+    enum { NO, VORONOI_SEAM, DP_SEAM };
+    /** @brief Estimates seams.
+
+    @param src Source images
+    @param corners Source image top-left corners
+    @param masks Source image masks to update
+     */
+    CV_WRAP virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                      CV_IN_OUT std::vector<UMat> &masks) = 0;
+    CV_WRAP static Ptr<SeamFinder> createDefault(int type);
+};
+
+/** @brief Stub seam estimator which does nothing.
+ */
+class CV_EXPORTS_W NoSeamFinder : public SeamFinder
+{
+public:
+    CV_WRAP void find(const std::vector<UMat>&, const std::vector<Point>&, CV_IN_OUT std::vector<UMat>&) CV_OVERRIDE {}
+};
+
+/** @brief Base class for all pairwise seam estimators.
+ */
+class CV_EXPORTS_W PairwiseSeamFinder : public SeamFinder
+{
+public:
+    CV_WRAP virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                      CV_IN_OUT std::vector<UMat> &masks) CV_OVERRIDE;
+
+protected:
+    void run();
+    /** @brief Resolves masks intersection of two specified images in the given ROI.
+
+    @param first First image index
+    @param second Second image index
+    @param roi Region of interest
+     */
+    virtual void findInPair(size_t first, size_t second, Rect roi) = 0;
+
+    std::vector<UMat> images_;
+    std::vector<Size> sizes_;
+    std::vector<Point> corners_;
+    std::vector<UMat> masks_;
+};
+
+/** @brief Voronoi diagram-based seam estimator.
+ */
+class CV_EXPORTS_W VoronoiSeamFinder : public PairwiseSeamFinder
+{
+public:
+    CV_WRAP virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                      CV_IN_OUT std::vector<UMat> &masks) CV_OVERRIDE;
+    virtual void find(const std::vector<Size> &size, const std::vector<Point> &corners,
+                      std::vector<UMat> &masks);
+private:
+    void findInPair(size_t first, size_t second, Rect roi) CV_OVERRIDE;
+};
+
+
+class CV_EXPORTS_W DpSeamFinder : public SeamFinder
+{
+public:
+    enum CostFunction { COLOR, COLOR_GRAD };
+
+    DpSeamFinder(CostFunction costFunc = COLOR);
+    CV_WRAP DpSeamFinder(String costFunc );
+
+    CostFunction costFunction() const { return costFunc_; }
+    void setCostFunction(CostFunction val) { costFunc_ = val; }
+    CV_WRAP void setCostFunction(String val);
+
+    virtual void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                      std::vector<UMat> &masks) CV_OVERRIDE;
+
+private:
+    enum ComponentState
+    {
+        FIRST = 1, SECOND = 2, INTERS = 4,
+        INTERS_FIRST = INTERS | FIRST,
+        INTERS_SECOND = INTERS | SECOND
+    };
+
+    class ImagePairLess
+    {
+    public:
+        ImagePairLess(const std::vector<Mat> &images, const std::vector<Point> &corners)
+            : src_(&images[0]), corners_(&corners[0]) {}
+
+        bool operator() (const std::pair<size_t, size_t> &l, const std::pair<size_t, size_t> &r) const
+        {
+            Point c1 = corners_[l.first] + Point(src_[l.first].cols / 2, src_[l.first].rows / 2);
+            Point c2 = corners_[l.second] + Point(src_[l.second].cols / 2, src_[l.second].rows / 2);
+            int d1 = (c1 - c2).dot(c1 - c2);
+
+            c1 = corners_[r.first] + Point(src_[r.first].cols / 2, src_[r.first].rows / 2);
+            c2 = corners_[r.second] + Point(src_[r.second].cols / 2, src_[r.second].rows / 2);
+            int d2 = (c1 - c2).dot(c1 - c2);
+
+            return d1 < d2;
+        }
+
+    private:
+        const Mat *src_;
+        const Point *corners_;
+    };
+
+    class ClosePoints
+    {
+    public:
+        ClosePoints(int minDist) : minDist_(minDist) {}
+
+        bool operator() (const Point &p1, const Point &p2) const
+        {
+            int dist2 = (p1.x-p2.x) * (p1.x-p2.x) + (p1.y-p2.y) * (p1.y-p2.y);
+            return dist2 < minDist_ * minDist_;
+        }
+
+    private:
+        int minDist_;
+    };
+
+    void process(
+            const Mat &image1, const Mat &image2, Point tl1, Point tl2,  Mat &mask1, Mat &mask2);
+
+    void findComponents();
+
+    void findEdges();
+
+    void resolveConflicts(
+            const Mat &image1, const Mat &image2, Point tl1, Point tl2, Mat &mask1, Mat &mask2);
+
+    void computeGradients(const Mat &image1, const Mat &image2);
+
+    bool hasOnlyOneNeighbor(int comp);
+
+    bool closeToContour(int y, int x, const Mat_<uchar> &contourMask);
+
+    bool getSeamTips(int comp1, int comp2, Point &p1, Point &p2);
+
+    void computeCosts(
+            const Mat &image1, const Mat &image2, Point tl1, Point tl2,
+            int comp, Mat_<float> &costV, Mat_<float> &costH);
+
+    bool estimateSeam(
+            const Mat &image1, const Mat &image2, Point tl1, Point tl2, int comp,
+            Point p1, Point p2, std::vector<Point> &seam, bool &isHorizontal);
+
+    void updateLabelsUsingSeam(
+            int comp1, int comp2, const std::vector<Point> &seam, bool isHorizontalSeam);
+
+    CostFunction costFunc_;
+
+    // processing images pair data
+    Point unionTl_, unionBr_;
+    Size unionSize_;
+    Mat_<uchar> mask1_, mask2_;
+    Mat_<uchar> contour1mask_, contour2mask_;
+    Mat_<float> gradx1_, grady1_;
+    Mat_<float> gradx2_, grady2_;
+
+    // components data
+    int ncomps_;
+    Mat_<int> labels_;
+    std::vector<ComponentState> states_;
+    std::vector<Point> tls_, brs_;
+    std::vector<std::vector<Point> > contours_;
+    std::set<std::pair<int, int> > edges_;
+};
+
+/** @brief Base class for all minimum graph-cut-based seam estimators.
+ */
+class CV_EXPORTS GraphCutSeamFinderBase
+{
+public:
+    enum CostType { COST_COLOR, COST_COLOR_GRAD };
+};
+
+/** @brief Minimum graph cut-based seam estimator. See details in @cite Kwatra03 .
+ */
+class CV_EXPORTS_W GraphCutSeamFinder : public GraphCutSeamFinderBase, public SeamFinder
+{
+public:
+    GraphCutSeamFinder(int cost_type = COST_COLOR_GRAD, float terminal_cost = 10000.f,
+                       float bad_region_penalty = 1000.f);
+    CV_WRAP GraphCutSeamFinder(String cost_type,float terminal_cost = 10000.f,
+        float bad_region_penalty = 1000.f);
+
+    ~GraphCutSeamFinder();
+
+    CV_WRAP void find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                      CV_IN_OUT std::vector<UMat> &masks) CV_OVERRIDE;
+
+private:
+    // To avoid GCGraph dependency
+    class Impl;
+    Ptr<PairwiseSeamFinder> impl_;
+};
+
+
+#ifdef HAVE_OPENCV_CUDALEGACY
+class CV_EXPORTS GraphCutSeamFinderGpu : public GraphCutSeamFinderBase, public PairwiseSeamFinder
+{
+public:
+    GraphCutSeamFinderGpu(int cost_type = COST_COLOR_GRAD, float terminal_cost = 10000.f,
+                          float bad_region_penalty = 1000.f)
+                          : cost_type_(cost_type), terminal_cost_(terminal_cost),
+                            bad_region_penalty_(bad_region_penalty) {}
+
+    void find(const std::vector<cv::UMat> &src, const std::vector<cv::Point> &corners,
+              std::vector<cv::UMat> &masks) CV_OVERRIDE;
+    void findInPair(size_t first, size_t second, Rect roi) CV_OVERRIDE;
+
+private:
+    void setGraphWeightsColor(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &mask1, const cv::Mat &mask2,
+                              cv::Mat &terminals, cv::Mat &leftT, cv::Mat &rightT, cv::Mat &top, cv::Mat &bottom);
+    void setGraphWeightsColorGrad(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &dx1, const cv::Mat &dx2,
+                                  const cv::Mat &dy1, const cv::Mat &dy2, const cv::Mat &mask1, const cv::Mat &mask2,
+                                  cv::Mat &terminals, cv::Mat &leftT, cv::Mat &rightT, cv::Mat &top, cv::Mat &bottom);
+    std::vector<Mat> dx_, dy_;
+    int cost_type_;
+    float terminal_cost_;
+    float bad_region_penalty_;
+};
+#endif
+
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_SEAM_FINDERS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/timelapsers.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/timelapsers.hpp
new file mode 100644
index 0000000..f6f3da8
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/timelapsers.hpp
@@ -0,0 +1,91 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#ifndef OPENCV_STITCHING_TIMELAPSERS_HPP
+#define OPENCV_STITCHING_TIMELAPSERS_HPP
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching
+//! @{
+
+//  Base Timelapser class, takes a sequence of images, applies appropriate shift, stores result in dst_.
+
+class CV_EXPORTS_W Timelapser
+{
+public:
+
+    enum {AS_IS, CROP};
+
+    virtual ~Timelapser() {}
+
+    CV_WRAP static Ptr<Timelapser> createDefault(int type);
+
+    CV_WRAP virtual void initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes);
+    CV_WRAP virtual void process(InputArray img, InputArray mask, Point tl);
+    CV_WRAP virtual const UMat& getDst() {return dst_;}
+
+protected:
+
+    virtual bool test_point(Point pt);
+
+    UMat dst_;
+    Rect dst_roi_;
+};
+
+
+class CV_EXPORTS_W TimelapserCrop : public Timelapser
+{
+public:
+    virtual void initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes) CV_OVERRIDE;
+};
+
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#endif // OPENCV_STITCHING_TIMELAPSERS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util.hpp
new file mode 100644
index 0000000..bf7a390
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util.hpp
@@ -0,0 +1,121 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_UTIL_HPP
+#define OPENCV_STITCHING_UTIL_HPP
+
+#include <list>
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching
+//! @{
+
+class CV_EXPORTS DisjointSets
+{
+public:
+    DisjointSets(int elem_count = 0) { createOneElemSets(elem_count); }
+
+    void createOneElemSets(int elem_count);
+    int findSetByElem(int elem);
+    int mergeSets(int set1, int set2);
+
+    std::vector<int> parent;
+    std::vector<int> size;
+
+private:
+    std::vector<int> rank_;
+};
+
+
+struct CV_EXPORTS GraphEdge
+{
+    GraphEdge(int from, int to, float weight);
+    bool operator <(const GraphEdge& other) const { return weight < other.weight; }
+    bool operator >(const GraphEdge& other) const { return weight > other.weight; }
+
+    int from, to;
+    float weight;
+};
+
+inline GraphEdge::GraphEdge(int _from, int _to, float _weight) : from(_from), to(_to), weight(_weight) {}
+
+
+class CV_EXPORTS Graph
+{
+public:
+    Graph(int num_vertices = 0) { create(num_vertices); }
+    void create(int num_vertices) { edges_.assign(num_vertices, std::list<GraphEdge>()); }
+    int numVertices() const { return static_cast<int>(edges_.size()); }
+    void addEdge(int from, int to, float weight);
+    template <typename B> B forEach(B body) const;
+    template <typename B> B walkBreadthFirst(int from, B body) const;
+
+private:
+    std::vector< std::list<GraphEdge> > edges_;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
+
+CV_EXPORTS_W bool overlapRoi(Point tl1, Point tl2, Size sz1, Size sz2, Rect &roi);
+CV_EXPORTS_W Rect resultRoi(const std::vector<Point> &corners, const std::vector<UMat> &images);
+CV_EXPORTS_W Rect resultRoi(const std::vector<Point> &corners, const std::vector<Size> &sizes);
+CV_EXPORTS_W Rect resultRoiIntersection(const std::vector<Point> &corners, const std::vector<Size> &sizes);
+CV_EXPORTS_W Point resultTl(const std::vector<Point> &corners);
+
+// Returns random 'count' element subset of the {0,1,...,size-1} set
+CV_EXPORTS_W void selectRandomSubset(int count, int size, std::vector<int> &subset);
+
+CV_EXPORTS_W int& stitchingLogLevel();
+
+//! @}
+
+} // namespace detail
+} // namespace cv
+
+#include "util_inl.hpp"
+
+#endif // OPENCV_STITCHING_UTIL_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util_inl.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util_inl.hpp
new file mode 100644
index 0000000..dafab8b
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/util_inl.hpp
@@ -0,0 +1,131 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_UTIL_INL_HPP
+#define OPENCV_STITCHING_UTIL_INL_HPP
+
+#include <queue>
+#include "opencv2/core.hpp"
+#include "util.hpp" // Make your IDE see declarations
+
+//! @cond IGNORED
+
+namespace cv {
+namespace detail {
+
+template <typename B>
+B Graph::forEach(B body) const
+{
+    for (int i = 0; i < numVertices(); ++i)
+    {
+        std::list<GraphEdge>::const_iterator edge = edges_[i].begin();
+        for (; edge != edges_[i].end(); ++edge)
+            body(*edge);
+    }
+    return body;
+}
+
+
+template <typename B>
+B Graph::walkBreadthFirst(int from, B body) const
+{
+    std::vector<bool> was(numVertices(), false);
+    std::queue<int> vertices;
+
+    was[from] = true;
+    vertices.push(from);
+
+    while (!vertices.empty())
+    {
+        int vertex = vertices.front();
+        vertices.pop();
+
+        std::list<GraphEdge>::const_iterator edge = edges_[vertex].begin();
+        for (; edge != edges_[vertex].end(); ++edge)
+        {
+            if (!was[edge->to])
+            {
+                body(*edge);
+                was[edge->to] = true;
+                vertices.push(edge->to);
+            }
+        }
+    }
+
+    return body;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Some auxiliary math functions
+
+static inline
+float normL2(const Point3f& a)
+{
+    return a.x * a.x + a.y * a.y + a.z * a.z;
+}
+
+
+static inline
+float normL2(const Point3f& a, const Point3f& b)
+{
+    return normL2(a - b);
+}
+
+
+static inline
+double normL2sq(const Mat &r)
+{
+    return r.dot(r);
+}
+
+
+static inline int sqr(int x) { return x * x; }
+static inline float sqr(float x) { return x * x; }
+static inline double sqr(double x) { return x * x; }
+
+} // namespace detail
+} // namespace cv
+
+//! @endcond
+
+#endif // OPENCV_STITCHING_UTIL_INL_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers.hpp
new file mode 100644
index 0000000..6837790
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers.hpp
@@ -0,0 +1,698 @@
+ /*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_WARPERS_HPP
+#define OPENCV_STITCHING_WARPERS_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/core/cuda.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/opencv_modules.hpp"
+
+namespace cv {
+namespace detail {
+
+//! @addtogroup stitching_warp
+//! @{
+
+/** @brief Rotation-only model image warper interface.
+ */
+class CV_EXPORTS RotationWarper
+{
+public:
+    virtual ~RotationWarper() {}
+
+    /** @brief Projects the image point.
+
+    @param pt Source point
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @return Projected point
+     */
+    virtual Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) = 0;
+
+    /** @brief Projects the image point backward.
+
+    @param pt Projected point
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @return Backward-projected point
+    */
+    virtual Point2f warpPointBackward(const Point2f& pt, InputArray K, InputArray R) = 0;
+
+    /** @brief Builds the projection maps according to the given camera data.
+
+    @param src_size Source image size
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @param xmap Projection map for the x axis
+    @param ymap Projection map for the y axis
+    @return Projected image minimum bounding box
+     */
+    virtual Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) = 0;
+
+    /** @brief Projects the image.
+
+    @param src Source image
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @param interp_mode Interpolation mode
+    @param border_mode Border extrapolation mode
+    @param dst Projected image
+    @return Project image top-left corner
+     */
+    virtual Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+                       CV_OUT OutputArray dst) = 0;
+
+    /** @brief Projects the image backward.
+
+    @param src Projected image
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @param interp_mode Interpolation mode
+    @param border_mode Border extrapolation mode
+    @param dst_size Backward-projected image size
+    @param dst Backward-projected image
+     */
+    virtual void warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+                              Size dst_size, CV_OUT OutputArray dst) = 0;
+
+    /**
+    @param src_size Source image bounding box
+    @param K Camera intrinsic parameters
+    @param R Camera rotation matrix
+    @return Projected image minimum bounding box
+     */
+    virtual Rect warpRoi(Size src_size, InputArray K, InputArray R) = 0;
+
+    virtual float getScale() const { return 1.f; }
+    virtual void setScale(float) {}
+};
+
+/** @brief Base class for warping logic implementation.
+ */
+struct CV_EXPORTS_W_SIMPLE ProjectorBase
+{
+    void setCameraParams(InputArray K = Mat::eye(3, 3, CV_32F),
+                         InputArray R = Mat::eye(3, 3, CV_32F),
+                         InputArray T = Mat::zeros(3, 1, CV_32F));
+
+    float scale;
+    float k[9];
+    float rinv[9];
+    float r_kinv[9];
+    float k_rinv[9];
+    float t[3];
+};
+
+/** @brief Base class for rotation-based warper using a detail::ProjectorBase_ derived class.
+ */
+template <class P>
+class CV_EXPORTS_TEMPLATE RotationWarperBase : public RotationWarper
+{
+public:
+    Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
+
+    Point2f warpPointBackward(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               OutputArray dst) CV_OVERRIDE;
+
+    void warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+                      Size dst_size, OutputArray dst) CV_OVERRIDE;
+
+    Rect warpRoi(Size src_size, InputArray K, InputArray R) CV_OVERRIDE;
+
+    float getScale() const  CV_OVERRIDE{ return projector_.scale; }
+    void setScale(float val) CV_OVERRIDE { projector_.scale = val; }
+
+protected:
+
+    // Detects ROI of the destination image. It's correct for any projection.
+    virtual void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
+
+    // Detects ROI of the destination image by walking over image border.
+    // Correctness for any projection isn't guaranteed.
+    void detectResultRoiByBorder(Size src_size, Point &dst_tl, Point &dst_br);
+
+    P projector_;
+};
+
+
+struct CV_EXPORTS PlaneProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+/** @brief Warper that maps an image onto the z = 1 plane.
+ */
+class CV_EXPORTS PlaneWarper : public RotationWarperBase<PlaneProjector>
+{
+public:
+    /** @brief Construct an instance of the plane warper class.
+
+    @param scale Projected image scale multiplier
+     */
+    PlaneWarper(float scale = 1.f) { projector_.scale = scale; }
+
+    Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R) CV_OVERRIDE;
+    Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R, InputArray T);
+
+    Point2f warpPointBackward(const Point2f& pt, InputArray K, InputArray R) CV_OVERRIDE;
+    Point2f warpPointBackward(const Point2f& pt, InputArray K, InputArray R, InputArray T);
+
+    virtual Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, CV_OUT OutputArray xmap, CV_OUT OutputArray ymap);
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, CV_OUT OutputArray xmap, CV_OUT OutputArray ymap) CV_OVERRIDE;
+
+    Point warp(InputArray src, InputArray K, InputArray R,
+               int interp_mode, int border_mode, CV_OUT OutputArray dst) CV_OVERRIDE;
+    virtual Point warp(InputArray src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
+        CV_OUT OutputArray dst);
+
+    Rect warpRoi(Size src_size, InputArray K, InputArray R) CV_OVERRIDE;
+    Rect warpRoi(Size src_size, InputArray K, InputArray R, InputArray T);
+
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
+};
+
+
+/** @brief Affine warper that uses rotations and translations
+
+ Uses affine transformation in homogeneous coordinates to represent both rotation and
+ translation in camera rotation matrix.
+ */
+class CV_EXPORTS AffineWarper : public PlaneWarper
+{
+public:
+    /** @brief Construct an instance of the affine warper class.
+
+    @param scale Projected image scale multiplier
+     */
+    AffineWarper(float scale = 1.f) : PlaneWarper(scale) {}
+
+    /** @brief Projects the image point.
+
+    @param pt Source point
+    @param K Camera intrinsic parameters
+    @param H Camera extrinsic parameters
+    @return Projected point
+     */
+    Point2f warpPoint(const Point2f &pt, InputArray K, InputArray H) CV_OVERRIDE;
+
+    /** @brief Projects the image point backward.
+
+    @param pt Projected point
+    @param K Camera intrinsic parameters
+    @param H Camera extrinsic parameters
+    @return Backward-projected point
+    */
+    Point2f warpPointBackward(const Point2f &pt, InputArray K, InputArray H) CV_OVERRIDE;
+
+    /** @brief Builds the projection maps according to the given camera data.
+
+    @param src_size Source image size
+    @param K Camera intrinsic parameters
+    @param H Camera extrinsic parameters
+    @param xmap Projection map for the x axis
+    @param ymap Projection map for the y axis
+    @return Projected image minimum bounding box
+     */
+    Rect buildMaps(Size src_size, InputArray K, InputArray H, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+
+    /** @brief Projects the image.
+
+    @param src Source image
+    @param K Camera intrinsic parameters
+    @param H Camera extrinsic parameters
+    @param interp_mode Interpolation mode
+    @param border_mode Border extrapolation mode
+    @param dst Projected image
+    @return Project image top-left corner
+     */
+    Point warp(InputArray src, InputArray K, InputArray H,
+               int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
+
+    /**
+    @param src_size Source image bounding box
+    @param K Camera intrinsic parameters
+    @param H Camera extrinsic parameters
+    @return Projected image minimum bounding box
+     */
+    Rect warpRoi(Size src_size, InputArray K, InputArray H) CV_OVERRIDE;
+
+protected:
+    /** @brief Extracts rotation and translation matrices from matrix H representing
+        affine transformation in homogeneous coordinates
+     */
+    void getRTfromHomogeneous(InputArray H, Mat &R, Mat &T);
+};
+
+
+struct CV_EXPORTS_W_SIMPLE SphericalProjector : ProjectorBase
+{
+    CV_WRAP void mapForward(float x, float y, float &u, float &v);
+    CV_WRAP void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+/** @brief Warper that maps an image onto the unit sphere located at the origin.
+
+ Projects image onto unit sphere with origin at (0, 0, 0) and radius scale, measured in pixels.
+ A 360 panorama would therefore have a resulting width of 2 * scale * PI pixels.
+ Poles are located at (0, -1, 0) and (0, 1, 0) points.
+*/
+class CV_EXPORTS SphericalWarper : public RotationWarperBase<SphericalProjector>
+{
+public:
+    /** @brief Construct an instance of the spherical warper class.
+
+    @param scale Radius of the projected sphere, in pixels. An image spanning the
+                 whole sphere will have a width of 2 * scale * PI pixels.
+     */
+    SphericalWarper(float scale) { projector_.scale = scale; }
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
+};
+
+
+struct CV_EXPORTS CylindricalProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+/** @brief Warper that maps an image onto the x\*x + z\*z = 1 cylinder.
+ */
+class CV_EXPORTS CylindricalWarper : public RotationWarperBase<CylindricalProjector>
+{
+public:
+    /** @brief Construct an instance of the cylindrical warper class.
+
+    @param scale Projected image scale multiplier
+     */
+    CylindricalWarper(float scale) { projector_.scale = scale; }
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE;
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst) CV_OVERRIDE;
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
+    {
+        RotationWarperBase<CylindricalProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
+    }
+};
+
+
+struct CV_EXPORTS FisheyeProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS FisheyeWarper : public RotationWarperBase<FisheyeProjector>
+{
+public:
+    FisheyeWarper(float scale) { projector_.scale = scale; }
+};
+
+
+struct CV_EXPORTS StereographicProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS StereographicWarper : public RotationWarperBase<StereographicProjector>
+{
+public:
+    StereographicWarper(float scale) { projector_.scale = scale; }
+};
+
+
+struct CV_EXPORTS CompressedRectilinearProjector : ProjectorBase
+{
+    float a, b;
+
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS CompressedRectilinearWarper : public RotationWarperBase<CompressedRectilinearProjector>
+{
+public:
+    CompressedRectilinearWarper(float scale, float A = 1, float B = 1)
+    {
+        projector_.a = A;
+        projector_.b = B;
+        projector_.scale = scale;
+    }
+};
+
+
+struct CV_EXPORTS CompressedRectilinearPortraitProjector : ProjectorBase
+{
+    float a, b;
+
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS CompressedRectilinearPortraitWarper : public RotationWarperBase<CompressedRectilinearPortraitProjector>
+{
+public:
+   CompressedRectilinearPortraitWarper(float scale, float A = 1, float B = 1)
+   {
+       projector_.a = A;
+       projector_.b = B;
+       projector_.scale = scale;
+   }
+};
+
+
+struct CV_EXPORTS PaniniProjector : ProjectorBase
+{
+    float a, b;
+
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS PaniniWarper : public RotationWarperBase<PaniniProjector>
+{
+public:
+   PaniniWarper(float scale, float A = 1, float B = 1)
+   {
+       projector_.a = A;
+       projector_.b = B;
+       projector_.scale = scale;
+   }
+};
+
+
+struct CV_EXPORTS PaniniPortraitProjector : ProjectorBase
+{
+    float a, b;
+
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS PaniniPortraitWarper : public RotationWarperBase<PaniniPortraitProjector>
+{
+public:
+   PaniniPortraitWarper(float scale, float A = 1, float B = 1)
+   {
+       projector_.a = A;
+       projector_.b = B;
+       projector_.scale = scale;
+   }
+
+};
+
+
+struct CV_EXPORTS MercatorProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS MercatorWarper : public RotationWarperBase<MercatorProjector>
+{
+public:
+    MercatorWarper(float scale) { projector_.scale = scale; }
+};
+
+
+struct CV_EXPORTS TransverseMercatorProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS TransverseMercatorWarper : public RotationWarperBase<TransverseMercatorProjector>
+{
+public:
+    TransverseMercatorWarper(float scale) { projector_.scale = scale; }
+};
+
+
+class CV_EXPORTS PlaneWarperGpu : public PlaneWarper
+{
+public:
+    PlaneWarperGpu(float scale = 1.f) : PlaneWarper(scale) {}
+
+// WARNING: unreachable code using Ninja
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
+    {
+        Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
+        d_xmap_.download(xmap);
+        d_ymap_.download(ymap);
+        return result;
+    }
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
+    {
+        Rect result = buildMaps(src_size, K, R, T, d_xmap_, d_ymap_);
+        d_xmap_.download(xmap);
+        d_ymap_.download(ymap);
+        return result;
+    }
+
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               OutputArray dst) CV_OVERRIDE
+    {
+        d_src_.upload(src);
+        Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
+        d_dst_.download(dst);
+        return result;
+    }
+
+    Point warp(InputArray src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
+               OutputArray dst) CV_OVERRIDE
+    {
+        d_src_.upload(src);
+        Point result = warp(d_src_, K, R, T, interp_mode, border_mode, d_dst_);
+        d_dst_.download(dst);
+        return result;
+    }
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(pop)
+#endif
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap);
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, cuda::GpuMat & xmap, cuda::GpuMat & ymap);
+
+    Point warp(const cuda::GpuMat & src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               cuda::GpuMat & dst);
+
+    Point warp(const cuda::GpuMat & src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
+               cuda::GpuMat & dst);
+
+private:
+    cuda::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
+};
+
+
+class CV_EXPORTS SphericalWarperGpu : public SphericalWarper
+{
+public:
+    SphericalWarperGpu(float scale) : SphericalWarper(scale) {}
+
+// WARNING: unreachable code using Ninja
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
+    {
+        Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
+        d_xmap_.download(xmap);
+        d_ymap_.download(ymap);
+        return result;
+    }
+
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               OutputArray dst) CV_OVERRIDE
+    {
+        d_src_.upload(src);
+        Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
+        d_dst_.download(dst);
+        return result;
+    }
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(pop)
+#endif
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap);
+
+    Point warp(const cuda::GpuMat & src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               cuda::GpuMat & dst);
+
+private:
+    cuda::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
+};
+
+
+class CV_EXPORTS CylindricalWarperGpu : public CylindricalWarper
+{
+public:
+    CylindricalWarperGpu(float scale) : CylindricalWarper(scale) {}
+
+// WARNING: unreachable code using Ninja
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(push)
+#pragma warning(disable: 4702)
+#endif
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap) CV_OVERRIDE
+    {
+        Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
+        d_xmap_.download(xmap);
+        d_ymap_.download(ymap);
+        return result;
+    }
+
+    Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               OutputArray dst) CV_OVERRIDE
+    {
+        d_src_.upload(src);
+        Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
+        d_dst_.download(dst);
+        return result;
+    }
+#if defined _MSC_VER && _MSC_VER >= 1920
+#pragma warning(pop)
+#endif
+
+    Rect buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap);
+
+    Point warp(const cuda::GpuMat & src, InputArray K, InputArray R, int interp_mode, int border_mode,
+               cuda::GpuMat & dst);
+
+private:
+    cuda::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
+};
+
+
+struct CV_EXPORTS SphericalPortraitProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+// Projects image onto unit sphere with origin at (0, 0, 0).
+// Poles are located NOT at (0, -1, 0) and (0, 1, 0) points, BUT at (1, 0, 0) and (-1, 0, 0) points.
+class CV_EXPORTS SphericalPortraitWarper : public RotationWarperBase<SphericalPortraitProjector>
+{
+public:
+    SphericalPortraitWarper(float scale) { projector_.scale = scale; }
+
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE;
+};
+
+struct CV_EXPORTS CylindricalPortraitProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS CylindricalPortraitWarper : public RotationWarperBase<CylindricalPortraitProjector>
+{
+public:
+    CylindricalPortraitWarper(float scale) { projector_.scale = scale; }
+
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
+    {
+        RotationWarperBase<CylindricalPortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
+    }
+};
+
+struct CV_EXPORTS PlanePortraitProjector : ProjectorBase
+{
+    void mapForward(float x, float y, float &u, float &v);
+    void mapBackward(float u, float v, float &x, float &y);
+};
+
+
+class CV_EXPORTS PlanePortraitWarper : public RotationWarperBase<PlanePortraitProjector>
+{
+public:
+    PlanePortraitWarper(float scale) { projector_.scale = scale; }
+
+protected:
+    void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br) CV_OVERRIDE
+    {
+        RotationWarperBase<PlanePortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
+    }
+};
+
+//! @} stitching_warp
+
+} // namespace detail
+} // namespace cv
+
+#include "warpers_inl.hpp"
+
+#endif // OPENCV_STITCHING_WARPERS_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp
new file mode 100644
index 0000000..72b5c08
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/detail/warpers_inl.hpp
@@ -0,0 +1,782 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_WARPERS_INL_HPP
+#define OPENCV_STITCHING_WARPERS_INL_HPP
+
+#include "opencv2/core.hpp"
+#include "warpers.hpp" // Make your IDE see declarations
+#include <limits>
+
+//! @cond IGNORED
+
+namespace cv {
+namespace detail {
+
+template <class P>
+Point2f RotationWarperBase<P>::warpPoint(const Point2f &pt, InputArray K, InputArray R)
+{
+    projector_.setCameraParams(K, R);
+    Point2f uv;
+    projector_.mapForward(pt.x, pt.y, uv.x, uv.y);
+    return uv;
+}
+
+template <class P>
+Point2f RotationWarperBase<P>::warpPointBackward(const Point2f& pt, InputArray K, InputArray R)
+{
+    projector_.setCameraParams(K, R);
+    Point2f xy;
+    projector_.mapBackward(pt.x, pt.y, xy.x, xy.y);
+    return xy;
+}
+
+template <class P>
+Rect RotationWarperBase<P>::buildMaps(Size src_size, InputArray K, InputArray R, OutputArray _xmap, OutputArray _ymap)
+{
+    projector_.setCameraParams(K, R);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    _xmap.create(dst_br.y - dst_tl.y + 1, dst_br.x - dst_tl.x + 1, CV_32F);
+    _ymap.create(dst_br.y - dst_tl.y + 1, dst_br.x - dst_tl.x + 1, CV_32F);
+
+    Mat xmap = _xmap.getMat(), ymap = _ymap.getMat();
+
+    float x, y;
+    for (int v = dst_tl.y; v <= dst_br.y; ++v)
+    {
+        for (int u = dst_tl.x; u <= dst_br.x; ++u)
+        {
+            projector_.mapBackward(static_cast<float>(u), static_cast<float>(v), x, y);
+            xmap.at<float>(v - dst_tl.y, u - dst_tl.x) = x;
+            ymap.at<float>(v - dst_tl.y, u - dst_tl.x) = y;
+        }
+    }
+
+    return Rect(dst_tl, dst_br);
+}
+
+
+template <class P>
+Point RotationWarperBase<P>::warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+                                  OutputArray dst)
+{
+    UMat xmap, ymap;
+    Rect dst_roi = buildMaps(src.size(), K, R, xmap, ymap);
+
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    remap(src, dst, xmap, ymap, interp_mode, border_mode);
+
+    return dst_roi.tl();
+}
+
+
+template <class P>
+void RotationWarperBase<P>::warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+                                         Size dst_size, OutputArray dst)
+{
+    projector_.setCameraParams(K, R);
+
+    Point src_tl, src_br;
+    detectResultRoi(dst_size, src_tl, src_br);
+
+    Size size = src.size();
+    CV_Assert(src_br.x - src_tl.x + 1 == size.width && src_br.y - src_tl.y + 1 == size.height);
+
+    Mat xmap(dst_size, CV_32F);
+    Mat ymap(dst_size, CV_32F);
+
+    float u, v;
+    for (int y = 0; y < dst_size.height; ++y)
+    {
+        for (int x = 0; x < dst_size.width; ++x)
+        {
+            projector_.mapForward(static_cast<float>(x), static_cast<float>(y), u, v);
+            xmap.at<float>(y, x) = u - src_tl.x;
+            ymap.at<float>(y, x) = v - src_tl.y;
+        }
+    }
+
+    dst.create(dst_size, src.type());
+    remap(src, dst, xmap, ymap, interp_mode, border_mode);
+}
+
+
+template <class P>
+Rect RotationWarperBase<P>::warpRoi(Size src_size, InputArray K, InputArray R)
+{
+    projector_.setCameraParams(K, R);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    return Rect(dst_tl, Point(dst_br.x + 1, dst_br.y + 1));
+}
+
+
+template <class P>
+void RotationWarperBase<P>::detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+{
+    float tl_uf = (std::numeric_limits<float>::max)();
+    float tl_vf = (std::numeric_limits<float>::max)();
+    float br_uf = -(std::numeric_limits<float>::max)();
+    float br_vf = -(std::numeric_limits<float>::max)();
+
+    float u, v;
+    for (int y = 0; y < src_size.height; ++y)
+    {
+        for (int x = 0; x < src_size.width; ++x)
+        {
+            projector_.mapForward(static_cast<float>(x), static_cast<float>(y), u, v);
+            tl_uf = (std::min)(tl_uf, u); tl_vf = (std::min)(tl_vf, v);
+            br_uf = (std::max)(br_uf, u); br_vf = (std::max)(br_vf, v);
+        }
+    }
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+
+template <class P>
+void RotationWarperBase<P>::detectResultRoiByBorder(Size src_size, Point &dst_tl, Point &dst_br)
+{
+    float tl_uf = (std::numeric_limits<float>::max)();
+    float tl_vf = (std::numeric_limits<float>::max)();
+    float br_uf = -(std::numeric_limits<float>::max)();
+    float br_vf = -(std::numeric_limits<float>::max)();
+
+    float u, v;
+    for (float x = 0; x < src_size.width; ++x)
+    {
+        projector_.mapForward(static_cast<float>(x), 0, u, v);
+        tl_uf = (std::min)(tl_uf, u); tl_vf = (std::min)(tl_vf, v);
+        br_uf = (std::max)(br_uf, u); br_vf = (std::max)(br_vf, v);
+
+        projector_.mapForward(static_cast<float>(x), static_cast<float>(src_size.height - 1), u, v);
+        tl_uf = (std::min)(tl_uf, u); tl_vf = (std::min)(tl_vf, v);
+        br_uf = (std::max)(br_uf, u); br_vf = (std::max)(br_vf, v);
+    }
+    for (int y = 0; y < src_size.height; ++y)
+    {
+        projector_.mapForward(0, static_cast<float>(y), u, v);
+        tl_uf = (std::min)(tl_uf, u); tl_vf = (std::min)(tl_vf, v);
+        br_uf = (std::max)(br_uf, u); br_vf = (std::max)(br_vf, v);
+
+        projector_.mapForward(static_cast<float>(src_size.width - 1), static_cast<float>(y), u, v);
+        tl_uf = (std::min)(tl_uf, u); tl_vf = (std::min)(tl_vf, v);
+        br_uf = (std::max)(br_uf, u); br_vf = (std::max)(br_vf, v);
+    }
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+
+inline
+void PlaneProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    x_ = t[0] + x_ / z_ * (1 - t[2]);
+    y_ = t[1] + y_ / z_ * (1 - t[2]);
+
+    u = scale * x_;
+    v = scale * y_;
+}
+
+
+inline
+void PlaneProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u = u / scale - t[0];
+    v = v / scale - t[1];
+
+    float z;
+    x = k_rinv[0] * u + k_rinv[1] * v + k_rinv[2] * (1 - t[2]);
+    y = k_rinv[3] * u + k_rinv[4] * v + k_rinv[5] * (1 - t[2]);
+    z = k_rinv[6] * u + k_rinv[7] * v + k_rinv[8] * (1 - t[2]);
+
+    x /= z;
+    y /= z;
+}
+
+
+inline
+void SphericalProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    u = scale * atan2f(x_, z_);
+    float w = y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_);
+    v = scale * (static_cast<float>(CV_PI) - acosf(w == w ? w : 0));
+}
+
+
+inline
+void SphericalProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float sinv = sinf(static_cast<float>(CV_PI) - v);
+    float x_ = sinv * sinf(u);
+    float y_ = cosf(static_cast<float>(CV_PI) - v);
+    float z_ = sinv * cosf(u);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+
+inline
+void CylindricalProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    u = scale * atan2f(x_, z_);
+    v = scale * y_ / sqrtf(x_ * x_ + z_ * z_);
+}
+
+
+inline
+void CylindricalProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float x_ = sinf(u);
+    float y_ = v;
+    float z_ = cosf(u);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void FisheyeProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = (float)CV_PI - acosf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    u = scale * v_ * cosf(u_);
+    v = scale * v_ * sinf(u_);
+}
+
+inline
+void FisheyeProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float u_ = atan2f(v, u);
+    float v_ = sqrtf(u*u + v*v);
+
+    float sinv = sinf((float)CV_PI - v_);
+    float x_ = sinv * sinf(u_);
+    float y_ = cosf((float)CV_PI - v_);
+    float z_ = sinv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void StereographicProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = (float)CV_PI - acosf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    float r = sinf(v_) / (1 - cosf(v_));
+
+    u = scale * r * std::cos(u_);
+    v = scale * r * std::sin(u_);
+}
+
+inline
+void StereographicProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float u_ = atan2f(v, u);
+    float r = sqrtf(u*u + v*v);
+    float v_ = 2 * atanf(1.f / r);
+
+    float sinv = sinf((float)CV_PI - v_);
+    float x_ = sinv * sinf(u_);
+    float y_ = cosf((float)CV_PI - v_);
+    float z_ = sinv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void CompressedRectilinearProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    u = scale * a * tanf(u_ / a);
+    v = scale * b * tanf(v_) / cosf(u_);
+}
+
+inline
+void CompressedRectilinearProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float aatg = a * atanf(u / a);
+    float u_ = aatg;
+    float v_ = atanf(v * cosf(aatg) / b);
+
+    float cosv = cosf(v_);
+    float x_ = cosv * sinf(u_);
+    float y_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void CompressedRectilinearPortraitProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float y_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float x_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    u = - scale * a * tanf(u_ / a);
+    v = scale * b * tanf(v_) / cosf(u_);
+}
+
+inline
+void CompressedRectilinearPortraitProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= - scale;
+    v /= scale;
+
+    float aatg = a * atanf(u / a);
+    float u_ = aatg;
+    float v_ = atanf(v * cosf( aatg ) / b);
+
+    float cosv = cosf(v_);
+    float y_ = cosv * sinf(u_);
+    float x_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void PaniniProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    float tg = a * tanf(u_ / a);
+    u = scale * tg;
+
+    float sinu = sinf(u_);
+    if ( fabs(sinu) < 1E-7 )
+        v = scale * b * tanf(v_);
+    else
+        v = scale * b * tg * tanf(v_) / sinu;
+}
+
+inline
+void PaniniProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float lamda = a * atanf(u / a);
+    float u_ = lamda;
+
+    float v_;
+    if ( fabs(lamda) > 1E-7)
+        v_ = atanf(v * sinf(lamda) / (b * a * tanf(lamda / a)));
+    else
+        v_ = atanf(v / b);
+
+    float cosv = cosf(v_);
+    float x_ = cosv * sinf(u_);
+    float y_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void PaniniPortraitProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float y_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float x_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    float tg = a * tanf(u_ / a);
+    u = - scale * tg;
+
+    float sinu = sinf( u_ );
+    if ( fabs(sinu) < 1E-7 )
+        v = scale * b * tanf(v_);
+    else
+        v = scale * b * tg * tanf(v_) / sinu;
+}
+
+inline
+void PaniniPortraitProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= - scale;
+    v /= scale;
+
+    float lamda = a * atanf(u / a);
+    float u_ = lamda;
+
+    float v_;
+    if ( fabs(lamda) > 1E-7)
+        v_ = atanf(v * sinf(lamda) / (b * a * tanf(lamda/a)));
+    else
+        v_ = atanf(v / b);
+
+    float cosv = cosf(v_);
+    float y_ = cosv * sinf(u_);
+    float x_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void MercatorProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    u = scale * u_;
+    v = scale * logf( tanf( (float)(CV_PI/4) + v_/2 ) );
+}
+
+inline
+void MercatorProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float v_ = atanf( sinhf(v) );
+    float u_ = u;
+
+    float cosv = cosf(v_);
+    float x_ = cosv * sinf(u_);
+    float y_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void TransverseMercatorProjector::mapForward(float x, float y, float &u, float &v)
+{
+    float x_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float u_ = atan2f(x_, z_);
+    float v_ = asinf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_));
+
+    float B = cosf(v_) * sinf(u_);
+
+    u = scale / 2 * logf( (1+B) / (1-B) );
+    v = scale * atan2f(tanf(v_), cosf(u_));
+}
+
+inline
+void TransverseMercatorProjector::mapBackward(float u, float v, float &x, float &y)
+{
+    u /= scale;
+    v /= scale;
+
+    float v_ = asinf( sinf(v) / coshf(u) );
+    float u_ = atan2f( sinhf(u), std::cos(v) );
+
+    float cosv = cosf(v_);
+    float x_ = cosv * sinf(u_);
+    float y_ = sinf(v_);
+    float z_ = cosv * cosf(u_);
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void SphericalPortraitProjector::mapForward(float x, float y, float &u0, float &v0)
+{
+    float x0_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y0_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_ = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float x_ = y0_;
+    float y_ = x0_;
+    float u, v;
+
+    u = scale * atan2f(x_, z_);
+    v = scale * (static_cast<float>(CV_PI) - acosf(y_ / sqrtf(x_ * x_ + y_ * y_ + z_ * z_)));
+
+    u0 = -u;//v;
+    v0 = v;//u;
+}
+
+
+inline
+void SphericalPortraitProjector::mapBackward(float u0, float v0, float &x, float &y)
+{
+    float u, v;
+    u = -u0;//v0;
+    v = v0;//u0;
+
+    u /= scale;
+    v /= scale;
+
+    float sinv = sinf(static_cast<float>(CV_PI) - v);
+    float x0_ = sinv * sinf(u);
+    float y0_ = cosf(static_cast<float>(CV_PI) - v);
+    float z_ = sinv * cosf(u);
+
+    float x_ = y0_;
+    float y_ = x0_;
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void CylindricalPortraitProjector::mapForward(float x, float y, float &u0, float &v0)
+{
+    float x0_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y0_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_  = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float x_ = y0_;
+    float y_ = x0_;
+    float u, v;
+
+    u = scale * atan2f(x_, z_);
+    v = scale * y_ / sqrtf(x_ * x_ + z_ * z_);
+
+    u0 = -u;//v;
+    v0 = v;//u;
+}
+
+
+inline
+void CylindricalPortraitProjector::mapBackward(float u0, float v0, float &x, float &y)
+{
+    float u, v;
+    u = -u0;//v0;
+    v = v0;//u0;
+
+    u /= scale;
+    v /= scale;
+
+    float x0_ = sinf(u);
+    float y0_ = v;
+    float z_  = cosf(u);
+
+    float x_ = y0_;
+    float y_ = x0_;
+
+    float z;
+    x = k_rinv[0] * x_ + k_rinv[1] * y_ + k_rinv[2] * z_;
+    y = k_rinv[3] * x_ + k_rinv[4] * y_ + k_rinv[5] * z_;
+    z = k_rinv[6] * x_ + k_rinv[7] * y_ + k_rinv[8] * z_;
+
+    if (z > 0) { x /= z; y /= z; }
+    else x = y = -1;
+}
+
+inline
+void PlanePortraitProjector::mapForward(float x, float y, float &u0, float &v0)
+{
+    float x0_ = r_kinv[0] * x + r_kinv[1] * y + r_kinv[2];
+    float y0_ = r_kinv[3] * x + r_kinv[4] * y + r_kinv[5];
+    float z_  = r_kinv[6] * x + r_kinv[7] * y + r_kinv[8];
+
+    float x_ = y0_;
+    float y_ = x0_;
+
+    x_ = t[0] + x_ / z_ * (1 - t[2]);
+    y_ = t[1] + y_ / z_ * (1 - t[2]);
+
+    float u,v;
+    u = scale * x_;
+    v = scale * y_;
+
+    u0 = -u;
+    v0 = v;
+}
+
+
+inline
+void PlanePortraitProjector::mapBackward(float u0, float v0, float &x, float &y)
+{
+    float u, v;
+    u = -u0;
+    v = v0;
+
+    u = u / scale - t[0];
+    v = v / scale - t[1];
+
+    float z;
+    x = k_rinv[0] * v + k_rinv[1] * u + k_rinv[2] * (1 - t[2]);
+    y = k_rinv[3] * v + k_rinv[4] * u + k_rinv[5] * (1 - t[2]);
+    z = k_rinv[6] * v + k_rinv[7] * u + k_rinv[8] * (1 - t[2]);
+
+    x /= z;
+    y /= z;
+}
+
+
+} // namespace detail
+} // namespace cv
+
+//! @endcond
+
+#endif // OPENCV_STITCHING_WARPERS_INL_HPP
diff --git a/upstream/opencv/modules/stitching/include/opencv2/stitching/warpers.hpp b/upstream/opencv/modules/stitching/include/opencv2/stitching/warpers.hpp
new file mode 100644
index 0000000..5928014
--- /dev/null
+++ b/upstream/opencv/modules/stitching/include/opencv2/stitching/warpers.hpp
@@ -0,0 +1,270 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_STITCHING_WARPER_CREATORS_HPP
+#define OPENCV_STITCHING_WARPER_CREATORS_HPP
+
+#include "opencv2/stitching/detail/warpers.hpp"
+#include <string>
+
+namespace cv {
+    class CV_EXPORTS_W PyRotationWarper
+    {
+        Ptr<detail::RotationWarper> rw;
+
+    public:
+        CV_WRAP PyRotationWarper(String type, float scale);
+        CV_WRAP PyRotationWarper() {}
+        ~PyRotationWarper() {}
+
+        /** @brief Projects the image point.
+
+        @param pt Source point
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @return Projected point
+        */
+        CV_WRAP Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
+
+        /** @brief Projects the image point backward.
+
+        @param pt Projected point
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @return Backward-projected point
+        */
+        CV_WRAP Point2f warpPointBackward(const Point2f &pt, InputArray K, InputArray R);
+
+        /** @brief Builds the projection maps according to the given camera data.
+
+        @param src_size Source image size
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @param xmap Projection map for the x axis
+        @param ymap Projection map for the y axis
+        @return Projected image minimum bounding box
+        */
+        CV_WRAP Rect buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap);
+
+        /** @brief Projects the image.
+
+        @param src Source image
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @param interp_mode Interpolation mode
+        @param border_mode Border extrapolation mode
+        @param dst Projected image
+        @return Project image top-left corner
+        */
+        CV_WRAP Point warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+            CV_OUT OutputArray dst);
+
+        /** @brief Projects the image backward.
+
+        @param src Projected image
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @param interp_mode Interpolation mode
+        @param border_mode Border extrapolation mode
+        @param dst_size Backward-projected image size
+        @param dst Backward-projected image
+        */
+        CV_WRAP void warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+            Size dst_size, CV_OUT OutputArray dst);
+
+        /**
+        @param src_size Source image bounding box
+        @param K Camera intrinsic parameters
+        @param R Camera rotation matrix
+        @return Projected image minimum bounding box
+        */
+        CV_WRAP Rect warpRoi(Size src_size, InputArray K, InputArray R);
+
+        CV_WRAP float getScale() const { return 1.f; }
+        CV_WRAP void setScale(float) {}
+    };
+
+//! @addtogroup stitching_warp
+//! @{
+
+/** @brief Image warper factories base class.
+ */
+
+class CV_EXPORTS_W WarperCreator
+{
+public:
+    CV_WRAP virtual ~WarperCreator() {}
+    virtual Ptr<detail::RotationWarper> create(float scale) const = 0;
+};
+
+
+/** @brief Plane warper factory class.
+  @sa detail::PlaneWarper
+ */
+class CV_EXPORTS  PlaneWarper : public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PlaneWarper>(scale); }
+};
+
+/** @brief Affine warper factory class.
+  @sa detail::AffineWarper
+ */
+class CV_EXPORTS  AffineWarper : public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::AffineWarper>(scale); }
+};
+
+/** @brief Cylindrical warper factory class.
+@sa detail::CylindricalWarper
+*/
+class CV_EXPORTS CylindricalWarper: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CylindricalWarper>(scale); }
+};
+
+/** @brief Spherical warper factory class */
+class CV_EXPORTS SphericalWarper: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::SphericalWarper>(scale); }
+};
+
+class CV_EXPORTS FisheyeWarper : public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::FisheyeWarper>(scale); }
+};
+
+class CV_EXPORTS StereographicWarper: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::StereographicWarper>(scale); }
+};
+
+class CV_EXPORTS CompressedRectilinearWarper: public WarperCreator
+{
+    float a, b;
+public:
+    CompressedRectilinearWarper(float A = 1, float B = 1)
+    {
+        a = A; b = B;
+    }
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CompressedRectilinearWarper>(scale, a, b); }
+};
+
+class CV_EXPORTS CompressedRectilinearPortraitWarper: public WarperCreator
+{
+    float a, b;
+public:
+    CompressedRectilinearPortraitWarper(float A = 1, float B = 1)
+    {
+        a = A; b = B;
+    }
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CompressedRectilinearPortraitWarper>(scale, a, b); }
+};
+
+class CV_EXPORTS PaniniWarper: public WarperCreator
+{
+    float a, b;
+public:
+    PaniniWarper(float A = 1, float B = 1)
+    {
+        a = A; b = B;
+    }
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PaniniWarper>(scale, a, b); }
+};
+
+class CV_EXPORTS PaniniPortraitWarper: public WarperCreator
+{
+    float a, b;
+public:
+    PaniniPortraitWarper(float A = 1, float B = 1)
+    {
+        a = A; b = B;
+    }
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PaniniPortraitWarper>(scale, a, b); }
+};
+
+class CV_EXPORTS MercatorWarper: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::MercatorWarper>(scale); }
+};
+
+class CV_EXPORTS TransverseMercatorWarper: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::TransverseMercatorWarper>(scale); }
+};
+
+
+
+#ifdef HAVE_OPENCV_CUDAWARPING
+class PlaneWarperGpu: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::PlaneWarperGpu>(scale); }
+};
+
+
+class CylindricalWarperGpu: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::CylindricalWarperGpu>(scale); }
+};
+
+
+class SphericalWarperGpu: public WarperCreator
+{
+public:
+    Ptr<detail::RotationWarper> create(float scale) const CV_OVERRIDE { return makePtr<detail::SphericalWarperGpu>(scale); }
+};
+#endif
+
+//! @} stitching_warp
+
+} // namespace cv
+
+#endif // OPENCV_STITCHING_WARPER_CREATORS_HPP
diff --git a/upstream/opencv/modules/stitching/src/autocalib.cpp b/upstream/opencv/modules/stitching/src/autocalib.cpp
new file mode 100644
index 0000000..40319b3
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/autocalib.cpp
@@ -0,0 +1,202 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/hal/hal.hpp"
+
+using namespace cv;
+
+namespace {
+
+static inline bool decomposeCholesky(double* A, size_t astep, int m)
+{
+    if (!hal::Cholesky64f(A, astep, m, 0, 0, 0))
+        return false;
+    return true;
+}
+
+} // namespace
+
+
+namespace cv {
+namespace detail {
+
+void focalsFromHomography(const Mat& H, double &f0, double &f1, bool &f0_ok, bool &f1_ok)
+{
+    CV_Assert(H.type() == CV_64F && H.size() == Size(3, 3));
+
+    const double* h = H.ptr<double>();
+
+    double d1, d2; // Denominators
+    double v1, v2; // Focal squares value candidates
+
+    f1_ok = true;
+    d1 = h[6] * h[7];
+    d2 = (h[7] - h[6]) * (h[7] + h[6]);
+    v1 = -(h[0] * h[1] + h[3] * h[4]) / d1;
+    v2 = (h[0] * h[0] + h[3] * h[3] - h[1] * h[1] - h[4] * h[4]) / d2;
+    if (v1 < v2)
+    {
+        std::swap(v1, v2);
+        std::swap(d1, d2);
+    }
+    if (v1 > 0 && v2 > 0) f1 = std::sqrt(std::abs(d1) > std::abs(d2) ? v1 : v2);
+    else if (v1 > 0) f1 = std::sqrt(v1);
+    else f1_ok = false;
+
+    f0_ok = true;
+    d1 = h[0] * h[3] + h[1] * h[4];
+    d2 = h[0] * h[0] + h[1] * h[1] - h[3] * h[3] - h[4] * h[4];
+    v1 = -h[2] * h[5] / d1;
+    v2 = (h[5] * h[5] - h[2] * h[2]) / d2;
+    if (v1 < v2)
+    {
+        std::swap(v1, v2);
+        std::swap(d1, d2);
+    }
+    if (v1 > 0 && v2 > 0) f0 = std::sqrt(std::abs(d1) > std::abs(d2) ? v1 : v2);
+    else if (v1 > 0) f0 = std::sqrt(v1);
+    else f0_ok = false;
+}
+
+
+void estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches,
+                       std::vector<double> &focals)
+{
+    const int num_images = static_cast<int>(features.size());
+    focals.resize(num_images);
+
+    std::vector<double> all_focals;
+
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = 0; j < num_images; ++j)
+        {
+            const MatchesInfo &m = pairwise_matches[i*num_images + j];
+            if (m.H.empty())
+                continue;
+            double f0, f1;
+            bool f0ok, f1ok;
+            focalsFromHomography(m.H, f0, f1, f0ok, f1ok);
+            if (f0ok && f1ok)
+                all_focals.push_back(std::sqrt(f0 * f1));
+        }
+    }
+
+    if (static_cast<int>(all_focals.size()) >= num_images - 1)
+    {
+        double median;
+
+        std::sort(all_focals.begin(), all_focals.end());
+        if (all_focals.size() % 2 == 1)
+            median = all_focals[all_focals.size() / 2];
+        else
+            median = (all_focals[all_focals.size() / 2 - 1] + all_focals[all_focals.size() / 2]) * 0.5;
+
+        for (int i = 0; i < num_images; ++i)
+            focals[i] = median;
+    }
+    else
+    {
+        LOGLN("Can't estimate focal length, will use naive approach");
+        double focals_sum = 0;
+        for (int i = 0; i < num_images; ++i)
+            focals_sum += features[i].img_size.width + features[i].img_size.height;
+        for (int i = 0; i < num_images; ++i)
+            focals[i] = focals_sum / num_images;
+    }
+}
+
+
+bool calibrateRotatingCamera(const std::vector<Mat> &Hs, Mat &K)
+{
+    int m = static_cast<int>(Hs.size());
+    CV_Assert(m >= 1);
+
+    std::vector<Mat> Hs_(m);
+    for (int i = 0; i < m; ++i)
+    {
+        CV_Assert(Hs[i].size() == Size(3, 3) && Hs[i].type() == CV_64F);
+        Hs_[i] = Hs[i] / std::cbrt(determinant(Hs[i]));
+    }
+
+    const int idx_map[3][3] = {{0, 1, 2}, {1, 3, 4}, {2, 4, 5}};
+    Mat_<double> A(6*m, 6);
+    A.setTo(0);
+
+    int eq_idx = 0;
+    for (int k = 0; k < m; ++k)
+    {
+        Mat_<double> H(Hs_[k]);
+        for (int i = 0; i < 3; ++i)
+        {
+            for (int j = i; j < 3; ++j, ++eq_idx)
+            {
+                for (int l = 0; l < 3; ++l)
+                {
+                    for (int s = 0; s < 3; ++s)
+                    {
+                        int idx = idx_map[l][s];
+                        A(eq_idx, idx) += H(i,l) * H(j,s);
+                    }
+                }
+                A(eq_idx, idx_map[i][j]) -= 1;
+            }
+        }
+    }
+
+    Mat_<double> wcoef;
+    SVD::solveZ(A, wcoef);
+
+    Mat_<double> W(3,3);
+    for (int i = 0; i < 3; ++i)
+        for (int j = i; j < 3; ++j)
+            W(i,j) = W(j,i) = wcoef(idx_map[i][j], 0) / wcoef(5,0);
+    if (!decomposeCholesky(W.ptr<double>(), W.step, 3))
+        return false;
+    W(0,1) = W(0,2) = W(1,2) = 0;
+    K = W.t();
+    return true;
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/blenders.cpp b/upstream/opencv/modules/stitching/src/blenders.cpp
new file mode 100644
index 0000000..534489d
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/blenders.cpp
@@ -0,0 +1,906 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_stitching.hpp"
+
+#ifdef HAVE_CUDA
+    namespace cv { namespace cuda { namespace device
+    {
+        namespace blend
+        {
+            void addSrcWeightGpu16S(const PtrStep<short> src, const PtrStep<short> src_weight,
+                                    PtrStep<short> dst, PtrStep<short> dst_weight, cv::Rect &rc);
+            void addSrcWeightGpu32F(const PtrStep<short> src, const PtrStepf src_weight,
+                                    PtrStep<short> dst, PtrStepf dst_weight, cv::Rect &rc);
+            void normalizeUsingWeightMapGpu16S(const PtrStep<short> weight, PtrStep<short> src,
+                                               const int width, const int height);
+            void normalizeUsingWeightMapGpu32F(const PtrStepf weight, PtrStep<short> src,
+                                               const int width, const int height);
+        }
+    }}}
+#endif
+
+namespace cv {
+namespace detail {
+
+static const float WEIGHT_EPS = 1e-5f;
+
+Ptr<Blender> Blender::createDefault(int type, bool try_gpu)
+{
+    if (type == NO)
+        return makePtr<Blender>();
+    if (type == FEATHER)
+        return makePtr<FeatherBlender>();
+    if (type == MULTI_BAND)
+        return makePtr<MultiBandBlender>(try_gpu);
+    CV_Error(Error::StsBadArg, "unsupported blending method");
+}
+
+
+void Blender::prepare(const std::vector<Point> &corners, const std::vector<Size> &sizes)
+{
+    prepare(resultRoi(corners, sizes));
+}
+
+
+void Blender::prepare(Rect dst_roi)
+{
+    dst_.create(dst_roi.size(), CV_16SC3);
+    dst_.setTo(Scalar::all(0));
+    dst_mask_.create(dst_roi.size(), CV_8U);
+    dst_mask_.setTo(Scalar::all(0));
+    dst_roi_ = dst_roi;
+}
+
+
+void Blender::feed(InputArray _img, InputArray _mask, Point tl)
+{
+    Mat img = _img.getMat();
+    Mat mask = _mask.getMat();
+    Mat dst = dst_.getMat(ACCESS_RW);
+    Mat dst_mask = dst_mask_.getMat(ACCESS_RW);
+
+    CV_Assert(img.type() == CV_16SC3);
+    CV_Assert(mask.type() == CV_8U);
+    int dx = tl.x - dst_roi_.x;
+    int dy = tl.y - dst_roi_.y;
+
+    for (int y = 0; y < img.rows; ++y)
+    {
+        const Point3_<short> *src_row = img.ptr<Point3_<short> >(y);
+        Point3_<short> *dst_row = dst.ptr<Point3_<short> >(dy + y);
+        const uchar *mask_row = mask.ptr<uchar>(y);
+        uchar *dst_mask_row = dst_mask.ptr<uchar>(dy + y);
+
+        for (int x = 0; x < img.cols; ++x)
+        {
+            if (mask_row[x])
+                dst_row[dx + x] = src_row[x];
+            dst_mask_row[dx + x] |= mask_row[x];
+        }
+    }
+}
+
+
+void Blender::blend(InputOutputArray dst, InputOutputArray dst_mask)
+{
+    UMat mask;
+    compare(dst_mask_, 0, mask, CMP_EQ);
+    dst_.setTo(Scalar::all(0), mask);
+    dst.assign(dst_);
+    dst_mask.assign(dst_mask_);
+    dst_.release();
+    dst_mask_.release();
+}
+
+void FeatherBlender::prepare(Rect dst_roi)
+{
+    Blender::prepare(dst_roi);
+    dst_weight_map_.create(dst_roi.size(), CV_32F);
+    dst_weight_map_.setTo(0);
+}
+
+
+void FeatherBlender::feed(InputArray _img, InputArray mask, Point tl)
+{
+    Mat img = _img.getMat();
+    Mat dst = dst_.getMat(ACCESS_RW);
+
+    CV_Assert(img.type() == CV_16SC3);
+    CV_Assert(mask.type() == CV_8U);
+
+    createWeightMap(mask, sharpness_, weight_map_);
+    Mat weight_map = weight_map_.getMat(ACCESS_READ);
+    Mat dst_weight_map = dst_weight_map_.getMat(ACCESS_RW);
+
+    int dx = tl.x - dst_roi_.x;
+    int dy = tl.y - dst_roi_.y;
+
+    for (int y = 0; y < img.rows; ++y)
+    {
+        const Point3_<short>* src_row = img.ptr<Point3_<short> >(y);
+        Point3_<short>* dst_row = dst.ptr<Point3_<short> >(dy + y);
+        const float* weight_row = weight_map.ptr<float>(y);
+        float* dst_weight_row = dst_weight_map.ptr<float>(dy + y);
+
+        for (int x = 0; x < img.cols; ++x)
+        {
+            dst_row[dx + x].x += static_cast<short>(src_row[x].x * weight_row[x]);
+            dst_row[dx + x].y += static_cast<short>(src_row[x].y * weight_row[x]);
+            dst_row[dx + x].z += static_cast<short>(src_row[x].z * weight_row[x]);
+            dst_weight_row[dx + x] += weight_row[x];
+        }
+    }
+}
+
+
+void FeatherBlender::blend(InputOutputArray dst, InputOutputArray dst_mask)
+{
+    normalizeUsingWeightMap(dst_weight_map_, dst_);
+    compare(dst_weight_map_, WEIGHT_EPS, dst_mask_, CMP_GT);
+    Blender::blend(dst, dst_mask);
+}
+
+
+Rect FeatherBlender::createWeightMaps(const std::vector<UMat> &masks, const std::vector<Point> &corners,
+                                      std::vector<UMat> &weight_maps)
+{
+    weight_maps.resize(masks.size());
+    for (size_t i = 0; i < masks.size(); ++i)
+        createWeightMap(masks[i], sharpness_, weight_maps[i]);
+
+    Rect dst_roi = resultRoi(corners, masks);
+    Mat weights_sum(dst_roi.size(), CV_32F);
+    weights_sum.setTo(0);
+
+    for (size_t i = 0; i < weight_maps.size(); ++i)
+    {
+        Rect roi(corners[i].x - dst_roi.x, corners[i].y - dst_roi.y,
+                 weight_maps[i].cols, weight_maps[i].rows);
+        add(weights_sum(roi), weight_maps[i], weights_sum(roi));
+    }
+
+    for (size_t i = 0; i < weight_maps.size(); ++i)
+    {
+        Rect roi(corners[i].x - dst_roi.x, corners[i].y - dst_roi.y,
+                 weight_maps[i].cols, weight_maps[i].rows);
+        Mat tmp = weights_sum(roi);
+        tmp.setTo(1, tmp < std::numeric_limits<float>::epsilon());
+        divide(weight_maps[i], tmp, weight_maps[i]);
+    }
+
+    return dst_roi;
+}
+
+
+MultiBandBlender::MultiBandBlender(int try_gpu, int num_bands, int weight_type)
+{
+    num_bands_ = 0;
+    setNumBands(num_bands);
+
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    can_use_gpu_ = try_gpu && cuda::getCudaEnabledDeviceCount();
+    gpu_feed_idx_ = 0;
+#else
+    CV_UNUSED(try_gpu);
+    can_use_gpu_ = false;
+#endif
+
+    CV_Assert(weight_type == CV_32F || weight_type == CV_16S);
+    weight_type_ = weight_type;
+}
+
+void MultiBandBlender::prepare(Rect dst_roi)
+{
+    dst_roi_final_ = dst_roi;
+
+    // Crop unnecessary bands
+    double max_len = static_cast<double>(std::max(dst_roi.width, dst_roi.height));
+    num_bands_ = std::min(actual_num_bands_, static_cast<int>(ceil(std::log(max_len) / std::log(2.0))));
+
+    // Add border to the final image, to ensure sizes are divided by (1 << num_bands_)
+    dst_roi.width += ((1 << num_bands_) - dst_roi.width % (1 << num_bands_)) % (1 << num_bands_);
+    dst_roi.height += ((1 << num_bands_) - dst_roi.height % (1 << num_bands_)) % (1 << num_bands_);
+
+    Blender::prepare(dst_roi);
+
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    if (can_use_gpu_)
+    {
+        gpu_initialized_ = false;
+        gpu_feed_idx_ = 0;
+
+        gpu_tl_points_.clear();
+        gpu_weight_pyr_gauss_vec_.clear();
+        gpu_src_pyr_laplace_vec_.clear();
+        gpu_ups_.clear();
+        gpu_imgs_with_border_.clear();
+
+        gpu_dst_pyr_laplace_.resize(num_bands_ + 1);
+        gpu_dst_pyr_laplace_[0].create(dst_roi.size(), CV_16SC3);
+        gpu_dst_pyr_laplace_[0].setTo(Scalar::all(0));
+
+        gpu_dst_band_weights_.resize(num_bands_ + 1);
+        gpu_dst_band_weights_[0].create(dst_roi.size(), weight_type_);
+        gpu_dst_band_weights_[0].setTo(0);
+
+        for (int i = 1; i <= num_bands_; ++i)
+        {
+            gpu_dst_pyr_laplace_[i].create((gpu_dst_pyr_laplace_[i - 1].rows + 1) / 2,
+                (gpu_dst_pyr_laplace_[i - 1].cols + 1) / 2, CV_16SC3);
+            gpu_dst_band_weights_[i].create((gpu_dst_band_weights_[i - 1].rows + 1) / 2,
+                (gpu_dst_band_weights_[i - 1].cols + 1) / 2, weight_type_);
+            gpu_dst_pyr_laplace_[i].setTo(Scalar::all(0));
+            gpu_dst_band_weights_[i].setTo(0);
+        }
+    }
+    else
+#endif
+    {
+        dst_pyr_laplace_.clear();
+        dst_band_weights_.clear();
+
+        dst_pyr_laplace_.resize(num_bands_ + 1);
+        dst_pyr_laplace_[0] = dst_;
+
+        dst_band_weights_.resize(num_bands_ + 1);
+        dst_band_weights_[0].create(dst_roi.size(), weight_type_);
+        dst_band_weights_[0].setTo(0);
+
+        for (int i = 1; i <= num_bands_; ++i)
+        {
+            dst_pyr_laplace_[i].create((dst_pyr_laplace_[i - 1].rows + 1) / 2,
+                (dst_pyr_laplace_[i - 1].cols + 1) / 2, CV_16SC3);
+            dst_band_weights_[i].create((dst_band_weights_[i - 1].rows + 1) / 2,
+                (dst_band_weights_[i - 1].cols + 1) / 2, weight_type_);
+            dst_pyr_laplace_[i].setTo(Scalar::all(0));
+            dst_band_weights_[i].setTo(0);
+        }
+    }
+}
+
+#ifdef HAVE_OPENCL
+static bool ocl_MultiBandBlender_feed(InputArray _src, InputArray _weight,
+        InputOutputArray _dst, InputOutputArray _dst_weight)
+{
+    String buildOptions = "-D DEFINE_feed";
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "src", _src);
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "weight", _weight);
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "dst", _dst);
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "dstWeight", _dst_weight);
+    ocl::Kernel k("feed", ocl::stitching::multibandblend_oclsrc, buildOptions);
+    if (k.empty())
+        return false;
+
+    UMat src = _src.getUMat();
+
+    k.args(ocl::KernelArg::ReadOnly(src),
+           ocl::KernelArg::ReadOnly(_weight.getUMat()),
+           ocl::KernelArg::ReadWrite(_dst.getUMat()),
+           ocl::KernelArg::ReadWrite(_dst_weight.getUMat())
+           );
+
+    size_t globalsize[2] = {(size_t)src.cols, (size_t)src.rows };
+    return k.run(2, globalsize, NULL, false);
+}
+#endif
+
+void MultiBandBlender::feed(InputArray _img, InputArray mask, Point tl)
+{
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    UMat img;
+
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    // If using gpu save the top left coordinate when running first time after prepare
+    if (can_use_gpu_)
+    {
+        if (!gpu_initialized_)
+        {
+            gpu_tl_points_.push_back(tl);
+        }
+        else
+        {
+            tl = gpu_tl_points_[gpu_feed_idx_];
+        }
+    }
+    // If _img is not a GpuMat get it as UMat from the InputArray object.
+    // If it is GpuMat make a dummy object with right dimensions but no data and
+    // get _img as a GpuMat
+    if (!_img.isGpuMat())
+#endif
+    {
+        img = _img.getUMat();
+    }
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    else
+    {
+        gpu_img_ = _img.getGpuMat();
+        img = UMat(gpu_img_.rows, gpu_img_.cols, gpu_img_.type());
+    }
+#endif
+
+    CV_Assert(img.type() == CV_16SC3 || img.type() == CV_8UC3);
+    CV_Assert(mask.type() == CV_8U);
+
+    // Keep source image in memory with small border
+    int gap = 3 * (1 << num_bands_);
+    Point tl_new(std::max(dst_roi_.x, tl.x - gap),
+                 std::max(dst_roi_.y, tl.y - gap));
+    Point br_new(std::min(dst_roi_.br().x, tl.x + img.cols + gap),
+                 std::min(dst_roi_.br().y, tl.y + img.rows + gap));
+
+    // Ensure coordinates of top-left, bottom-right corners are divided by (1 << num_bands_).
+    // After that scale between layers is exactly 2.
+    //
+    // We do it to avoid interpolation problems when keeping sub-images only. There is no such problem when
+    // image is bordered to have size equal to the final image size, but this is too memory hungry approach.
+    tl_new.x = dst_roi_.x + (((tl_new.x - dst_roi_.x) >> num_bands_) << num_bands_);
+    tl_new.y = dst_roi_.y + (((tl_new.y - dst_roi_.y) >> num_bands_) << num_bands_);
+    int width = br_new.x - tl_new.x;
+    int height = br_new.y - tl_new.y;
+    width += ((1 << num_bands_) - width % (1 << num_bands_)) % (1 << num_bands_);
+    height += ((1 << num_bands_) - height % (1 << num_bands_)) % (1 << num_bands_);
+    br_new.x = tl_new.x + width;
+    br_new.y = tl_new.y + height;
+    int dy = std::max(br_new.y - dst_roi_.br().y, 0);
+    int dx = std::max(br_new.x - dst_roi_.br().x, 0);
+    tl_new.x -= dx; br_new.x -= dx;
+    tl_new.y -= dy; br_new.y -= dy;
+
+    int top = tl.y - tl_new.y;
+    int left = tl.x - tl_new.x;
+    int bottom = br_new.y - tl.y - img.rows;
+    int right = br_new.x - tl.x - img.cols;
+
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    if (can_use_gpu_)
+    {
+        if (!gpu_initialized_)
+        {
+            gpu_imgs_with_border_.push_back(cuda::GpuMat());
+            gpu_weight_pyr_gauss_vec_.push_back(std::vector<cuda::GpuMat>(num_bands_+1));
+            gpu_src_pyr_laplace_vec_.push_back(std::vector<cuda::GpuMat>(num_bands_+1));
+            gpu_ups_.push_back(std::vector<cuda::GpuMat>(num_bands_));
+        }
+
+        // If _img is not GpuMat upload it to gpu else gpu_img_ was set already
+        if (!_img.isGpuMat())
+        {
+            gpu_img_.upload(img);
+        }
+
+        // Create the source image Laplacian pyramid
+        cuda::copyMakeBorder(gpu_img_, gpu_imgs_with_border_[gpu_feed_idx_], top, bottom,
+                             left, right, BORDER_REFLECT);
+        gpu_imgs_with_border_[gpu_feed_idx_].convertTo(gpu_src_pyr_laplace_vec_[gpu_feed_idx_][0], CV_16S);
+        for (int i = 0; i < num_bands_; ++i)
+            cuda::pyrDown(gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i],
+                          gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i + 1]);
+        for (int i = 0; i < num_bands_; ++i)
+        {
+            cuda::pyrUp(gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i + 1], gpu_ups_[gpu_feed_idx_][i]);
+            cuda::subtract(gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i],
+                           gpu_ups_[gpu_feed_idx_][i],
+                           gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i]);
+        }
+
+        // Create the weight map Gaussian pyramid only if not yet initialized
+        if (!gpu_initialized_)
+        {
+            if (mask.isGpuMat())
+            {
+                gpu_mask_ = mask.getGpuMat();
+            }
+            else
+            {
+                gpu_mask_.upload(mask);
+            }
+
+            if (weight_type_ == CV_32F)
+            {
+                gpu_mask_.convertTo(gpu_weight_map_, CV_32F, 1. / 255.);
+            }
+            else // weight_type_ == CV_16S
+            {
+                gpu_mask_.convertTo(gpu_weight_map_, CV_16S);
+                cuda::compare(gpu_mask_, 0, gpu_add_mask_, CMP_NE);
+                cuda::add(gpu_weight_map_, Scalar::all(1), gpu_weight_map_, gpu_add_mask_);
+            }
+            cuda::copyMakeBorder(gpu_weight_map_, gpu_weight_pyr_gauss_vec_[gpu_feed_idx_][0], top,
+                                 bottom, left, right, BORDER_CONSTANT);
+            for (int i = 0; i < num_bands_; ++i)
+                cuda::pyrDown(gpu_weight_pyr_gauss_vec_[gpu_feed_idx_][i],
+                              gpu_weight_pyr_gauss_vec_[gpu_feed_idx_][i + 1]);
+        }
+
+        int y_tl = tl_new.y - dst_roi_.y;
+        int y_br = br_new.y - dst_roi_.y;
+        int x_tl = tl_new.x - dst_roi_.x;
+        int x_br = br_new.x - dst_roi_.x;
+
+        // Add weighted layer of the source image to the final Laplacian pyramid layer
+        for (int i = 0; i <= num_bands_; ++i)
+        {
+            Rect rc(x_tl, y_tl, x_br - x_tl, y_br - y_tl);
+            cuda::GpuMat &_src_pyr_laplace = gpu_src_pyr_laplace_vec_[gpu_feed_idx_][i];
+            cuda::GpuMat _dst_pyr_laplace = gpu_dst_pyr_laplace_[i](rc);
+            cuda::GpuMat &_weight_pyr_gauss = gpu_weight_pyr_gauss_vec_[gpu_feed_idx_][i];
+            cuda::GpuMat _dst_band_weights = gpu_dst_band_weights_[i](rc);
+
+            using namespace cv::cuda::device::blend;
+            if (weight_type_ == CV_32F)
+            {
+                addSrcWeightGpu32F(_src_pyr_laplace, _weight_pyr_gauss, _dst_pyr_laplace, _dst_band_weights, rc);
+            }
+            else
+            {
+                addSrcWeightGpu16S(_src_pyr_laplace, _weight_pyr_gauss, _dst_pyr_laplace, _dst_band_weights, rc);
+            }
+            x_tl /= 2; y_tl /= 2;
+            x_br /= 2; y_br /= 2;
+        }
+        ++gpu_feed_idx_;
+        return;
+    }
+#endif
+
+    // Create the source image Laplacian pyramid
+    UMat img_with_border;
+    copyMakeBorder(_img, img_with_border, top, bottom, left, right,
+                   BORDER_REFLECT);
+    LOGLN("  Add border to the source image, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    std::vector<UMat> src_pyr_laplace;
+    createLaplacePyr(img_with_border, num_bands_, src_pyr_laplace);
+
+    LOGLN("  Create the source image Laplacian pyramid, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    // Create the weight map Gaussian pyramid
+    UMat weight_map;
+    std::vector<UMat> weight_pyr_gauss(num_bands_ + 1);
+
+    if (weight_type_ == CV_32F)
+    {
+        mask.getUMat().convertTo(weight_map, CV_32F, 1./255.);
+    }
+    else // weight_type_ == CV_16S
+    {
+        mask.getUMat().convertTo(weight_map, CV_16S);
+        UMat add_mask;
+        compare(mask, 0, add_mask, CMP_NE);
+        add(weight_map, Scalar::all(1), weight_map, add_mask);
+    }
+
+    copyMakeBorder(weight_map, weight_pyr_gauss[0], top, bottom, left, right, BORDER_CONSTANT);
+
+    for (int i = 0; i < num_bands_; ++i)
+        pyrDown(weight_pyr_gauss[i], weight_pyr_gauss[i + 1]);
+
+    LOGLN("  Create the weight map Gaussian pyramid, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    int y_tl = tl_new.y - dst_roi_.y;
+    int y_br = br_new.y - dst_roi_.y;
+    int x_tl = tl_new.x - dst_roi_.x;
+    int x_br = br_new.x - dst_roi_.x;
+
+    // Add weighted layer of the source image to the final Laplacian pyramid layer
+    for (int i = 0; i <= num_bands_; ++i)
+    {
+        Rect rc(x_tl, y_tl, x_br - x_tl, y_br - y_tl);
+#ifdef HAVE_OPENCL
+        if ( !cv::ocl::isOpenCLActivated() ||
+             !ocl_MultiBandBlender_feed(src_pyr_laplace[i], weight_pyr_gauss[i],
+                    dst_pyr_laplace_[i](rc), dst_band_weights_[i](rc)) )
+#endif
+        {
+            Mat _src_pyr_laplace = src_pyr_laplace[i].getMat(ACCESS_READ);
+            Mat _dst_pyr_laplace = dst_pyr_laplace_[i](rc).getMat(ACCESS_RW);
+            Mat _weight_pyr_gauss = weight_pyr_gauss[i].getMat(ACCESS_READ);
+            Mat _dst_band_weights = dst_band_weights_[i](rc).getMat(ACCESS_RW);
+            if (weight_type_ == CV_32F)
+            {
+                for (int y = 0; y < rc.height; ++y)
+                {
+                    const Point3_<short>* src_row = _src_pyr_laplace.ptr<Point3_<short> >(y);
+                    Point3_<short>* dst_row = _dst_pyr_laplace.ptr<Point3_<short> >(y);
+                    const float* weight_row = _weight_pyr_gauss.ptr<float>(y);
+                    float* dst_weight_row = _dst_band_weights.ptr<float>(y);
+
+                    for (int x = 0; x < rc.width; ++x)
+                    {
+                        dst_row[x].x += static_cast<short>(src_row[x].x * weight_row[x]);
+                        dst_row[x].y += static_cast<short>(src_row[x].y * weight_row[x]);
+                        dst_row[x].z += static_cast<short>(src_row[x].z * weight_row[x]);
+                        dst_weight_row[x] += weight_row[x];
+                    }
+                }
+            }
+            else // weight_type_ == CV_16S
+            {
+                for (int y = 0; y < y_br - y_tl; ++y)
+                {
+                    const Point3_<short>* src_row = _src_pyr_laplace.ptr<Point3_<short> >(y);
+                    Point3_<short>* dst_row = _dst_pyr_laplace.ptr<Point3_<short> >(y);
+                    const short* weight_row = _weight_pyr_gauss.ptr<short>(y);
+                    short* dst_weight_row = _dst_band_weights.ptr<short>(y);
+
+                    for (int x = 0; x < x_br - x_tl; ++x)
+                    {
+                        dst_row[x].x += short((src_row[x].x * weight_row[x]) >> 8);
+                        dst_row[x].y += short((src_row[x].y * weight_row[x]) >> 8);
+                        dst_row[x].z += short((src_row[x].z * weight_row[x]) >> 8);
+                        dst_weight_row[x] += weight_row[x];
+                    }
+                }
+            }
+        }
+#ifdef HAVE_OPENCL
+        else
+        {
+            CV_IMPL_ADD(CV_IMPL_OCL);
+        }
+#endif
+
+        x_tl /= 2; y_tl /= 2;
+        x_br /= 2; y_br /= 2;
+    }
+
+    LOGLN("  Add weighted layer of the source image to the final Laplacian pyramid layer, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+
+void MultiBandBlender::blend(InputOutputArray dst, InputOutputArray dst_mask)
+{
+    Rect dst_rc(0, 0, dst_roi_final_.width, dst_roi_final_.height);
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    if (can_use_gpu_)
+    {
+        if (!gpu_initialized_)
+        {
+            gpu_ups_.push_back(std::vector<cuda::GpuMat>(num_bands_+1));
+        }
+
+        for (int i = 0; i <= num_bands_; ++i)
+        {
+            cuda::GpuMat dst_i = gpu_dst_pyr_laplace_[i];
+            cuda::GpuMat weight_i = gpu_dst_band_weights_[i];
+
+            using namespace ::cv::cuda::device::blend;
+            if (weight_type_ == CV_32F)
+            {
+                normalizeUsingWeightMapGpu32F(weight_i, dst_i, weight_i.cols, weight_i.rows);
+            }
+            else
+            {
+                normalizeUsingWeightMapGpu16S(weight_i, dst_i, weight_i.cols, weight_i.rows);
+            }
+        }
+
+        // Restore image from Laplacian pyramid
+        for (size_t i = num_bands_; i > 0; --i)
+        {
+            cuda::pyrUp(gpu_dst_pyr_laplace_[i], gpu_ups_[gpu_ups_.size()-1][num_bands_-i]);
+            cuda::add(gpu_ups_[gpu_ups_.size()-1][num_bands_-i],
+                      gpu_dst_pyr_laplace_[i - 1],
+                      gpu_dst_pyr_laplace_[i - 1]);
+        }
+
+        // If dst is GpuMat do masking on gpu and return dst as a GpuMat
+        // else download the image to cpu and return it as an ordinary Mat
+        if (dst.isGpuMat())
+        {
+            cuda::GpuMat &gpu_dst = dst.getGpuMatRef();
+
+            cuda::compare(gpu_dst_band_weights_[0](dst_rc), WEIGHT_EPS, gpu_dst_mask_, CMP_GT);
+
+            cuda::compare(gpu_dst_mask_, 0, gpu_mask_, CMP_EQ);
+
+            gpu_dst_pyr_laplace_[0](dst_rc).setTo(Scalar::all(0), gpu_mask_);
+            gpu_dst_pyr_laplace_[0](dst_rc).convertTo(gpu_dst, CV_16S);
+
+        }
+        else
+        {
+            gpu_dst_pyr_laplace_[0](dst_rc).download(dst_);
+            Mat dst_band_weights_0;
+            gpu_dst_band_weights_[0].download(dst_band_weights_0);
+
+            compare(dst_band_weights_0(dst_rc), WEIGHT_EPS, dst_mask_, CMP_GT);
+            Blender::blend(dst, dst_mask);
+        }
+
+        // Set destination Mats to 0 so new image can be blended
+        for (size_t i = 0; i < (size_t)(num_bands_ + 1); ++i)
+        {
+            gpu_dst_band_weights_[i].setTo(0);
+            gpu_dst_pyr_laplace_[i].setTo(Scalar::all(0));
+        }
+        gpu_feed_idx_ = 0;
+        gpu_initialized_ = true;
+    }
+    else
+#endif
+    {
+        cv::UMat dst_band_weights_0;
+
+        for (int i = 0; i <= num_bands_; ++i)
+            normalizeUsingWeightMap(dst_band_weights_[i], dst_pyr_laplace_[i]);
+
+        restoreImageFromLaplacePyr(dst_pyr_laplace_);
+
+        dst_ = dst_pyr_laplace_[0](dst_rc);
+        dst_band_weights_0 = dst_band_weights_[0];
+
+        dst_pyr_laplace_.clear();
+        dst_band_weights_.clear();
+
+        compare(dst_band_weights_0(dst_rc), WEIGHT_EPS, dst_mask_, CMP_GT);
+
+        Blender::blend(dst, dst_mask);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
+
+#ifdef HAVE_OPENCL
+static bool ocl_normalizeUsingWeightMap(InputArray _weight, InputOutputArray _mat)
+{
+    String buildOptions = "-D DEFINE_normalizeUsingWeightMap";
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "mat", _mat);
+    ocl::buildOptionsAddMatrixDescription(buildOptions, "weight", _weight);
+    ocl::Kernel k("normalizeUsingWeightMap", ocl::stitching::multibandblend_oclsrc, buildOptions);
+    if (k.empty())
+        return false;
+
+    UMat mat = _mat.getUMat();
+
+    k.args(ocl::KernelArg::ReadWrite(mat),
+           ocl::KernelArg::ReadOnly(_weight.getUMat())
+           );
+
+    size_t globalsize[2] = {(size_t)mat.cols, (size_t)mat.rows };
+    return k.run(2, globalsize, NULL, false);
+}
+#endif
+
+void normalizeUsingWeightMap(InputArray _weight, InputOutputArray _src)
+{
+    Mat src;
+    Mat weight;
+
+#ifdef HAVE_OPENCL
+    if ( !cv::ocl::isOpenCLActivated() ||
+            !ocl_normalizeUsingWeightMap(_weight, _src) )
+#endif
+    {
+        src = _src.getMat();
+        weight = _weight.getMat();
+
+        CV_Assert(src.type() == CV_16SC3);
+
+        if (weight.type() == CV_32FC1)
+        {
+            for (int y = 0; y < src.rows; ++y)
+            {
+                Point3_<short> *row = src.ptr<Point3_<short> >(y);
+                const float *weight_row = weight.ptr<float>(y);
+
+                for (int x = 0; x < src.cols; ++x)
+                {
+                    row[x].x = static_cast<short>(row[x].x / (weight_row[x] + WEIGHT_EPS));
+                    row[x].y = static_cast<short>(row[x].y / (weight_row[x] + WEIGHT_EPS));
+                    row[x].z = static_cast<short>(row[x].z / (weight_row[x] + WEIGHT_EPS));
+                }
+            }
+        }
+        else
+        {
+            CV_Assert(weight.type() == CV_16SC1);
+
+            for (int y = 0; y < src.rows; ++y)
+            {
+                const short *weight_row = weight.ptr<short>(y);
+                Point3_<short> *row = src.ptr<Point3_<short> >(y);
+
+                for (int x = 0; x < src.cols; ++x)
+                {
+                    int w = weight_row[x] + 1;
+                    row[x].x = static_cast<short>((row[x].x << 8) / w);
+                    row[x].y = static_cast<short>((row[x].y << 8) / w);
+                    row[x].z = static_cast<short>((row[x].z << 8) / w);
+                }
+            }
+        }
+    }
+#ifdef HAVE_OPENCL
+    else
+    {
+        CV_IMPL_ADD(CV_IMPL_OCL);
+    }
+#endif
+}
+
+
+void createWeightMap(InputArray mask, float sharpness, InputOutputArray weight)
+{
+    CV_Assert(mask.type() == CV_8U);
+    distanceTransform(mask, weight, DIST_L1, 3);
+    UMat tmp;
+    multiply(weight, sharpness, tmp);
+    threshold(tmp, weight, 1.f, 1.f, THRESH_TRUNC);
+}
+
+
+void createLaplacePyr(InputArray img, int num_levels, std::vector<UMat> &pyr)
+{
+    pyr.resize(num_levels + 1);
+
+    if(img.depth() == CV_8U)
+    {
+        if(num_levels == 0)
+        {
+            img.getUMat().convertTo(pyr[0], CV_16S);
+            return;
+        }
+
+        UMat downNext;
+        UMat current = img.getUMat();
+        pyrDown(img, downNext);
+
+        for(int i = 1; i < num_levels; ++i)
+        {
+            UMat lvl_up;
+            UMat lvl_down;
+
+            pyrDown(downNext, lvl_down);
+            pyrUp(downNext, lvl_up, current.size());
+            subtract(current, lvl_up, pyr[i-1], noArray(), CV_16S);
+
+            current = downNext;
+            downNext = lvl_down;
+        }
+
+        {
+            UMat lvl_up;
+            pyrUp(downNext, lvl_up, current.size());
+            subtract(current, lvl_up, pyr[num_levels-1], noArray(), CV_16S);
+
+            downNext.convertTo(pyr[num_levels], CV_16S);
+        }
+    }
+    else
+    {
+        pyr[0] = img.getUMat();
+        for (int i = 0; i < num_levels; ++i)
+            pyrDown(pyr[i], pyr[i + 1]);
+        UMat tmp;
+        for (int i = 0; i < num_levels; ++i)
+        {
+            pyrUp(pyr[i + 1], tmp, pyr[i].size());
+            subtract(pyr[i], tmp, pyr[i]);
+        }
+    }
+}
+
+
+void createLaplacePyrGpu(InputArray img, int num_levels, std::vector<UMat> &pyr)
+{
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    pyr.resize(num_levels + 1);
+
+    std::vector<cuda::GpuMat> gpu_pyr(num_levels + 1);
+    gpu_pyr[0].upload(img);
+    for (int i = 0; i < num_levels; ++i)
+        cuda::pyrDown(gpu_pyr[i], gpu_pyr[i + 1]);
+
+    cuda::GpuMat tmp;
+    for (int i = 0; i < num_levels; ++i)
+    {
+        cuda::pyrUp(gpu_pyr[i + 1], tmp);
+        cuda::subtract(gpu_pyr[i], tmp, gpu_pyr[i]);
+        gpu_pyr[i].download(pyr[i]);
+    }
+
+    gpu_pyr[num_levels].download(pyr[num_levels]);
+#else
+    CV_UNUSED(img);
+    CV_UNUSED(num_levels);
+    CV_UNUSED(pyr);
+    CV_Error(Error::StsNotImplemented, "CUDA optimization is unavailable");
+#endif
+}
+
+
+void restoreImageFromLaplacePyr(std::vector<UMat> &pyr)
+{
+    if (pyr.empty())
+        return;
+    UMat tmp;
+    for (size_t i = pyr.size() - 1; i > 0; --i)
+    {
+        pyrUp(pyr[i], tmp, pyr[i - 1].size());
+        add(tmp, pyr[i - 1], pyr[i - 1]);
+    }
+}
+
+
+void restoreImageFromLaplacePyrGpu(std::vector<UMat> &pyr)
+{
+#if defined(HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAWARPING)
+    if (pyr.empty())
+        return;
+
+    std::vector<cuda::GpuMat> gpu_pyr(pyr.size());
+    for (size_t i = 0; i < pyr.size(); ++i)
+        gpu_pyr[i].upload(pyr[i]);
+
+    cuda::GpuMat tmp;
+    for (size_t i = pyr.size() - 1; i > 0; --i)
+    {
+        cuda::pyrUp(gpu_pyr[i], tmp);
+        cuda::add(tmp, gpu_pyr[i - 1], gpu_pyr[i - 1]);
+    }
+
+    gpu_pyr[0].download(pyr[0]);
+#else
+    CV_UNUSED(pyr);
+    CV_Error(Error::StsNotImplemented, "CUDA optimization is unavailable");
+#endif
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/camera.cpp b/upstream/opencv/modules/stitching/src/camera.cpp
new file mode 100644
index 0000000..2f7ee97
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/camera.cpp
@@ -0,0 +1,73 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace detail {
+
+CameraParams::CameraParams() : focal(1), aspect(1), ppx(0), ppy(0),
+                               R(Mat::eye(3, 3, CV_64F)), t(Mat::zeros(3, 1, CV_64F)) {}
+
+CameraParams::CameraParams(const CameraParams &other) { *this = other; }
+
+CameraParams& CameraParams::operator =(const CameraParams &other)
+{
+    focal = other.focal;
+    ppx = other.ppx;
+    ppy = other.ppy;
+    aspect = other.aspect;
+    R = other.R.clone();
+    t = other.t.clone();
+    return *this;
+}
+
+Mat CameraParams::K() const
+{
+    Mat_<double> k = Mat::eye(3, 3, CV_64F);
+    k(0,0) = focal; k(0,2) = ppx;
+    k(1,1) = focal * aspect; k(1,2) = ppy;
+    return Mat(k);
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/cuda/build_warp_maps.cu b/upstream/opencv/modules/stitching/src/cuda/build_warp_maps.cu
new file mode 100644
index 0000000..42d5572
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/cuda/build_warp_maps.cu
@@ -0,0 +1,247 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "opencv2/core/cuda/common.hpp"
+#include "opencv2/core/cuda/vec_traits.hpp"
+#include "opencv2/core/cuda/vec_math.hpp"
+#include "opencv2/core/cuda/saturate_cast.hpp"
+#include "opencv2/core/cuda/border_interpolate.hpp"
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+        // TODO use intrinsics like __sinf and so on
+
+        struct WarpParams
+        {
+            float k_rinv[9];
+            float r_kinv[9];
+            float t[3];
+            float scale;
+        };
+
+        class PlaneMapper
+        {
+        public:
+            static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y,
+                                                               const WarpParams& params)
+            {
+                const float *ck_rinv = params.k_rinv;
+                const float *ct = params.t;
+                const float cscale = params.scale;
+                float x_ = u / cscale - ct[0];
+                float y_ = v / cscale - ct[1];
+
+                float z;
+                x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * (1 - ct[2]);
+                y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * (1 - ct[2]);
+                z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * (1 - ct[2]);
+
+                x /= z;
+                y /= z;
+            }
+        };
+
+
+        class CylindricalMapper
+        {
+        public:
+            static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y,
+                                                               const WarpParams& params)
+            {
+                const float *ck_rinv = params.k_rinv;
+                const float cscale = params.scale;
+                u /= cscale;
+                float x_ = ::sinf(u);
+                float y_ = v / cscale;
+                float z_ = ::cosf(u);
+
+                float z;
+                x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
+                y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
+                z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
+
+                if (z > 0) { x /= z; y /= z; }
+                else x = y = -1;
+            }
+        };
+
+
+        class SphericalMapper
+        {
+        public:
+            static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y,
+                                                               const WarpParams& params)
+            {
+                const float *ck_rinv = params.k_rinv;
+                const float cscale = params.scale;
+                v /= cscale;
+                u /= cscale;
+
+                float sinv = ::sinf(v);
+                float x_ = sinv * ::sinf(u);
+                float y_ = -::cosf(v);
+                float z_ = sinv * ::cosf(u);
+
+                float z;
+                x = ck_rinv[0] * x_ + ck_rinv[1] * y_ + ck_rinv[2] * z_;
+                y = ck_rinv[3] * x_ + ck_rinv[4] * y_ + ck_rinv[5] * z_;
+                z = ck_rinv[6] * x_ + ck_rinv[7] * y_ + ck_rinv[8] * z_;
+
+                if (z > 0) { x /= z; y /= z; }
+                else x = y = -1;
+            }
+        };
+
+
+        template <typename Mapper>
+        __global__ void buildWarpMapsKernel(int tl_u, int tl_v, int cols, int rows,
+                                            PtrStepf map_x, PtrStepf map_y,
+                                            const WarpParams params)
+        {
+            int du = blockIdx.x * blockDim.x + threadIdx.x;
+            int dv = blockIdx.y * blockDim.y + threadIdx.y;
+            if (du < cols && dv < rows)
+            {
+                float u = tl_u + du;
+                float v = tl_v + dv;
+                float x, y;
+                Mapper::mapBackward(u, v, x, y, params);
+                map_x.ptr(dv)[du] = x;
+                map_y.ptr(dv)[du] = y;
+            }
+        }
+
+
+        void buildWarpPlaneMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                const float k_rinv[9], const float r_kinv[9], const float t[3],
+                                float scale, cudaStream_t stream)
+        {
+            WarpParams params;
+            for (int i = 0; i < 9; ++i)
+            {
+                params.k_rinv[i] = k_rinv[i];
+                params.r_kinv[i] = r_kinv[i];
+            }
+            params.t[0] = t[0];
+            params.t[1] = t[1];
+            params.t[2] = t[2];
+            params.scale = scale;
+
+            int cols = map_x.cols;
+            int rows = map_x.rows;
+
+            dim3 threads(32, 8);
+            dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+
+            buildWarpMapsKernel<PlaneMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows,
+                                                               map_x, map_y, params);
+            cudaSafeCall(cudaGetLastError());
+            if (stream == 0)
+                cudaSafeCall(cudaDeviceSynchronize());
+        }
+
+
+        void buildWarpCylindricalMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                      const float k_rinv[9], const float r_kinv[9], float scale,
+                                      cudaStream_t stream)
+        {
+            WarpParams params;
+            for (int i = 0; i < 9; ++i)
+            {
+                params.k_rinv[i] = k_rinv[i];
+                params.r_kinv[i] = r_kinv[i];
+            }
+            params.t[0] = 0.f;
+            params.t[1] = 0.f;
+            params.t[2] = 0.f;
+            params.scale = scale;
+
+            int cols = map_x.cols;
+            int rows = map_x.rows;
+
+            dim3 threads(32, 8);
+            dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+
+            buildWarpMapsKernel<CylindricalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows,
+                                                                     map_x, map_y, params);
+            cudaSafeCall(cudaGetLastError());
+            if (stream == 0)
+                cudaSafeCall(cudaDeviceSynchronize());
+        }
+
+
+        void buildWarpSphericalMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                    const float k_rinv[9], const float r_kinv[9], float scale,
+                                    cudaStream_t stream)
+        {
+            WarpParams params;
+            for (int i = 0; i < 9; ++i)
+            {
+                params.k_rinv[i] = k_rinv[i];
+                params.r_kinv[i] = r_kinv[i];
+            }
+            params.t[0] = 0.f;
+            params.t[1] = 0.f;
+            params.t[2] = 0.f;
+            params.scale = scale;
+
+            int cols = map_x.cols;
+            int rows = map_x.rows;
+
+            dim3 threads(32, 8);
+            dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+
+            buildWarpMapsKernel<SphericalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows,
+                                                                   map_x, map_y, params);
+            cudaSafeCall(cudaGetLastError());
+            if (stream == 0)
+                cudaSafeCall(cudaDeviceSynchronize());
+        }
+    } // namespace imgproc
+}}} // namespace cv { namespace cuda { namespace cudev {
+
+
+#endif /* CUDA_DISABLER */
diff --git a/upstream/opencv/modules/stitching/src/cuda/multiband_blend.cu b/upstream/opencv/modules/stitching/src/cuda/multiband_blend.cu
new file mode 100644
index 0000000..27eb920
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/cuda/multiband_blend.cu
@@ -0,0 +1,112 @@
+#if !defined CUDA_DISABLER
+
+#include "opencv2/core/cuda/common.hpp"
+#include "opencv2/core/types.hpp"
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace blend
+    {
+        __global__ void addSrcWeightKernel16S(const PtrStep<short> src, const PtrStep<short> src_weight,
+            PtrStep<short> dst, PtrStep<short> dst_weight, int rows, int cols)
+        {
+            int x = blockIdx.x * blockDim.x + threadIdx.x;
+            int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+            if (y < rows && x < cols)
+            {
+                const short3 v = ((const short3*)src.ptr(y))[x];
+                short w = src_weight.ptr(y)[x];
+                ((short3*)dst.ptr(y))[x].x += short((v.x * w) >> 8);
+                ((short3*)dst.ptr(y))[x].y += short((v.y * w) >> 8);
+                ((short3*)dst.ptr(y))[x].z += short((v.z * w) >> 8);
+                dst_weight.ptr(y)[x] += w;
+            }
+        }
+
+        void addSrcWeightGpu16S(const PtrStep<short> src, const PtrStep<short> src_weight,
+            PtrStep<short> dst, PtrStep<short> dst_weight, cv::Rect &rc)
+        {
+            dim3 threads(16, 16);
+            dim3 grid(divUp(rc.width, threads.x), divUp(rc.height, threads.y));
+            addSrcWeightKernel16S<<<grid, threads>>>(src, src_weight, dst, dst_weight, rc.height, rc.width);
+            cudaSafeCall(cudaGetLastError());
+        }
+
+        __global__ void addSrcWeightKernel32F(const PtrStep<short> src, const PtrStepf src_weight,
+            PtrStep<short> dst, PtrStepf dst_weight, int rows, int cols)
+        {
+            int x = blockIdx.x * blockDim.x + threadIdx.x;
+            int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+            if (y < rows && x < cols)
+            {
+                const short3 v = ((const short3*)src.ptr(y))[x];
+                float w = src_weight.ptr(y)[x];
+                ((short3*)dst.ptr(y))[x].x += static_cast<short>(v.x * w);
+                ((short3*)dst.ptr(y))[x].y += static_cast<short>(v.y * w);
+                ((short3*)dst.ptr(y))[x].z += static_cast<short>(v.z * w);
+                dst_weight.ptr(y)[x] += w;
+            }
+        }
+
+        void addSrcWeightGpu32F(const PtrStep<short> src, const PtrStepf src_weight,
+            PtrStep<short> dst, PtrStepf dst_weight, cv::Rect &rc)
+        {
+            dim3 threads(16, 16);
+            dim3 grid(divUp(rc.width, threads.x), divUp(rc.height, threads.y));
+            addSrcWeightKernel32F<<<grid, threads>>>(src, src_weight, dst, dst_weight, rc.height, rc.width);
+            cudaSafeCall(cudaGetLastError());
+        }
+
+        __global__ void normalizeUsingWeightKernel16S(const PtrStep<short> weight, PtrStep<short> src,
+            const int width, const int height)
+        {
+            int x = (blockIdx.x * blockDim.x) + threadIdx.x;
+            int y = (blockIdx.y * blockDim.y) + threadIdx.y;
+
+            if (x < width && y < height)
+            {
+                const short3 v = ((short3*)src.ptr(y))[x];
+                short w = weight.ptr(y)[x];
+                ((short3*)src.ptr(y))[x] = make_short3(short((v.x << 8) / w),
+                    short((v.y << 8) / w), short((v.z << 8) / w));
+            }
+        }
+
+        void normalizeUsingWeightMapGpu16S(const PtrStep<short> weight, PtrStep<short> src,
+                                           const int width, const int height)
+        {
+            dim3 threads(16, 16);
+            dim3 grid(divUp(width, threads.x), divUp(height, threads.y));
+            normalizeUsingWeightKernel16S<<<grid, threads>>> (weight, src, width, height);
+        }
+
+        __global__ void normalizeUsingWeightKernel32F(const PtrStepf weight, PtrStep<short> src,
+            const int width, const int height)
+        {
+            int x = (blockIdx.x * blockDim.x) + threadIdx.x;
+            int y = (blockIdx.y * blockDim.y) + threadIdx.y;
+
+            if (x < width && y < height)
+            {
+                const float WEIGHT_EPS = 1e-5f;
+                const short3 v = ((short3*)src.ptr(y))[x];
+                float w = weight.ptr(y)[x];
+                ((short3*)src.ptr(y))[x] = make_short3(static_cast<short>(v.x / (w + WEIGHT_EPS)),
+                    static_cast<short>(v.y / (w + WEIGHT_EPS)),
+                    static_cast<short>(v.z / (w + WEIGHT_EPS)));
+            }
+        }
+
+        void normalizeUsingWeightMapGpu32F(const PtrStepf weight, PtrStep<short> src,
+                                           const int width, const int height)
+        {
+            dim3 threads(16, 16);
+            dim3 grid(divUp(width, threads.x), divUp(height, threads.y));
+            normalizeUsingWeightKernel32F<<<grid, threads>>> (weight, src, width, height);
+        }
+    }
+}}}
+
+#endif
diff --git a/upstream/opencv/modules/stitching/src/exposure_compensate.cpp b/upstream/opencv/modules/stitching/src/exposure_compensate.cpp
new file mode 100644
index 0000000..3d693d1
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/exposure_compensate.cpp
@@ -0,0 +1,619 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#ifdef HAVE_EIGEN
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#endif
+
+namespace cv {
+namespace detail {
+
+Ptr<ExposureCompensator> ExposureCompensator::createDefault(int type)
+{
+    Ptr<ExposureCompensator> e;
+    if (type == NO)
+        e = makePtr<NoExposureCompensator>();
+    else if (type == GAIN)
+        e = makePtr<GainCompensator>();
+    else if (type == GAIN_BLOCKS)
+        e = makePtr<BlocksGainCompensator>();
+    else if (type == CHANNELS)
+        e = makePtr<ChannelsCompensator>();
+    else if (type == CHANNELS_BLOCKS)
+        e = makePtr<BlocksChannelsCompensator>();
+
+    if (e.get() != nullptr)
+        return e;
+
+    CV_Error(Error::StsBadArg, "unsupported exposure compensation method");
+}
+
+
+void ExposureCompensator::feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                               const std::vector<UMat> &masks)
+{
+    std::vector<std::pair<UMat,uchar> > level_masks;
+    for (size_t i = 0; i < masks.size(); ++i)
+        level_masks.push_back(std::make_pair(masks[i], (uchar)255));
+    feed(corners, images, level_masks);
+}
+
+
+void GainCompensator::feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                           const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    LOGLN("Exposure compensation...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    const int num_images = static_cast<int>(images.size());
+    Mat accumulated_gains;
+    prepareSimilarityMask(corners, images);
+
+    for (int n = 0; n < nr_feeds_; ++n)
+    {
+        if (n > 0)
+        {
+            // Apply previous iteration gains
+            for (int i = 0; i < num_images; ++i)
+                apply(i, corners[i], images[i], masks[i].first);
+        }
+
+        singleFeed(corners, images, masks);
+
+        if (n == 0)
+            accumulated_gains = gains_.clone();
+        else
+            multiply(accumulated_gains, gains_, accumulated_gains);
+    }
+    gains_ = accumulated_gains;
+
+    LOGLN("Exposure compensation, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+void GainCompensator::singleFeed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                                 const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    CV_Assert(corners.size() == images.size() && images.size() == masks.size());
+
+    if (images.size() == 0)
+        return;
+
+    const int num_channels = images[0].channels();
+    CV_Assert(std::all_of(images.begin(), images.end(),
+        [num_channels](const UMat& image) { return image.channels() == num_channels; }));
+    CV_Assert(num_channels == 1 || num_channels == 3);
+
+    const int num_images = static_cast<int>(images.size());
+    Mat_<int> N(num_images, num_images); N.setTo(0);
+    Mat_<double> I(num_images, num_images); I.setTo(0);
+    Mat_<uchar> skip(num_images, 1); skip.setTo(1);
+
+    Mat subimg1, subimg2;
+    Mat_<uchar> submask1, submask2, intersect;
+
+    std::vector<UMat>::iterator similarity_it = similarities_.begin();
+
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = i; j < num_images; ++j)
+        {
+            Rect roi;
+            if (overlapRoi(corners[i], corners[j], images[i].size(), images[j].size(), roi))
+            {
+                subimg1 = images[i](Rect(roi.tl() - corners[i], roi.br() - corners[i])).getMat(ACCESS_READ);
+                subimg2 = images[j](Rect(roi.tl() - corners[j], roi.br() - corners[j])).getMat(ACCESS_READ);
+
+                submask1 = masks[i].first(Rect(roi.tl() - corners[i], roi.br() - corners[i])).getMat(ACCESS_READ);
+                submask2 = masks[j].first(Rect(roi.tl() - corners[j], roi.br() - corners[j])).getMat(ACCESS_READ);
+                intersect = (submask1 == masks[i].second) & (submask2 == masks[j].second);
+
+                if (!similarities_.empty())
+                {
+                    CV_Assert(similarity_it != similarities_.end());
+                    UMat similarity = *similarity_it++;
+                    // in-place operation has an issue. don't remove the swap
+                    // detail https://github.com/opencv/opencv/issues/19184
+                    Mat_<uchar> intersect_updated;
+                    bitwise_and(intersect, similarity, intersect_updated);
+                    std::swap(intersect, intersect_updated);
+                }
+
+                int intersect_count = countNonZero(intersect);
+                N(i, j) = N(j, i) = std::max(1, intersect_count);
+
+                // Don't compute Isums if subimages do not intersect anyway
+                if (intersect_count == 0)
+                    continue;
+
+                // Don't skip images that intersect with at least one other image
+                if (i != j)
+                {
+                    skip(i, 0) = false;
+                    skip(j, 0) = false;
+                }
+
+                double Isum1 = 0, Isum2 = 0;
+                for (int y = 0; y < roi.height; ++y)
+                {
+                    if (num_channels == 3)
+                    {
+                        const Vec<uchar, 3>* r1 = subimg1.ptr<Vec<uchar, 3> >(y);
+                        const Vec<uchar, 3>* r2 = subimg2.ptr<Vec<uchar, 3> >(y);
+                        for (int x = 0; x < roi.width; ++x)
+                        {
+                            if (intersect(y, x))
+                            {
+                                Isum1 += norm(r1[x]);
+                                Isum2 += norm(r2[x]);
+                            }
+                        }
+                    }
+                    else // if (num_channels == 1)
+                    {
+                        const uchar* r1 = subimg1.ptr<uchar>(y);
+                        const uchar* r2 = subimg2.ptr<uchar>(y);
+                        for (int x = 0; x < roi.width; ++x)
+                        {
+                            if (intersect(y, x))
+                            {
+                                Isum1 += r1[x];
+                                Isum2 += r2[x];
+                            }
+                        }
+                    }
+                }
+                I(i, j) = Isum1 / N(i, j);
+                I(j, i) = Isum2 / N(i, j);
+            }
+        }
+    }
+    if (getUpdateGain() || gains_.rows != num_images)
+    {
+        double alpha = 0.01;
+        double beta = 100;
+        int num_eq = num_images - countNonZero(skip);
+        gains_.create(num_images, 1);
+        gains_.setTo(1);
+
+        // No image process, gains are all set to one, stop here
+        if (num_eq == 0)
+            return;
+
+        Mat_<double> A(num_eq, num_eq); A.setTo(0);
+        Mat_<double> b(num_eq, 1); b.setTo(0);
+        for (int i = 0, ki = 0; i < num_images; ++i)
+        {
+            if (skip(i, 0))
+                continue;
+
+            for (int j = 0, kj = 0; j < num_images; ++j)
+            {
+                if (skip(j, 0))
+                    continue;
+
+                b(ki, 0) += beta * N(i, j);
+                A(ki, ki) += beta * N(i, j);
+                if (j != i)
+                {
+                    A(ki, ki) += 2 * alpha * I(i, j) * I(i, j) * N(i, j);
+                    A(ki, kj) -= 2 * alpha * I(i, j) * I(j, i) * N(i, j);
+                }
+                ++kj;
+            }
+            ++ki;
+        }
+
+        Mat_<double> l_gains;
+
+#ifdef HAVE_EIGEN
+        Eigen::MatrixXf eigen_A, eigen_b, eigen_x;
+        cv2eigen(A, eigen_A);
+        cv2eigen(b, eigen_b);
+
+        Eigen::LLT<Eigen::MatrixXf> solver(eigen_A);
+#if ENABLE_LOG
+        if (solver.info() != Eigen::ComputationInfo::Success)
+            LOGLN("Failed to solve exposure compensation system");
+#endif
+        eigen_x = solver.solve(eigen_b);
+
+        Mat_<float> l_gains_float;
+        eigen2cv(eigen_x, l_gains_float);
+        l_gains_float.convertTo(l_gains, CV_64FC1);
+#else
+        solve(A, b, l_gains);
+#endif
+        CV_CheckTypeEQ(l_gains.type(), CV_64FC1, "");
+
+        for (int i = 0, j = 0; i < num_images; ++i)
+        {
+            // Only assign non-skipped gains. Other gains are already set to 1
+            if (!skip(i, 0))
+                gains_.at<double>(i, 0) = l_gains(j++, 0);
+        }
+    }
+}
+
+
+void GainCompensator::apply(int index, Point /*corner*/, InputOutputArray image, InputArray /*mask*/)
+{
+    CV_INSTRUMENT_REGION();
+
+    multiply(image, gains_(index, 0), image);
+}
+
+
+std::vector<double> GainCompensator::gains() const
+{
+    std::vector<double> gains_vec(gains_.rows);
+    for (int i = 0; i < gains_.rows; ++i)
+        gains_vec[i] = gains_(i, 0);
+    return gains_vec;
+}
+
+void GainCompensator::getMatGains(std::vector<Mat>& umv)
+{
+    umv.clear();
+    for (int i = 0; i < gains_.rows; ++i)
+        umv.push_back(Mat(1,1,CV_64FC1,Scalar(gains_(i, 0))));
+}
+void GainCompensator::setMatGains(std::vector<Mat>& umv)
+{
+    gains_=Mat_<double>(static_cast<int>(umv.size()),1);
+    for (int i = 0; i < static_cast<int>(umv.size()); i++)
+    {
+        int type = umv[i].type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+        CV_CheckType(type, depth == CV_64F && cn == 1, "Only double images are supported for gain");
+        CV_Assert(umv[i].rows == 1 && umv[i].cols == 1);
+        gains_(i, 0) = umv[i].at<double>(0, 0);
+    }
+}
+
+void GainCompensator::prepareSimilarityMask(
+    const std::vector<Point> &corners, const std::vector<UMat> &images)
+{
+    if (similarity_threshold_ >= 1)
+    {
+        LOGLN("  skipping similarity mask: disabled");
+        return;
+    }
+    if (!similarities_.empty())
+    {
+        LOGLN("  skipping similarity mask: already set");
+        return;
+    }
+
+    LOGLN("  calculating similarity mask");
+    const int num_images = static_cast<int>(images.size());
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = i; j < num_images; ++j)
+        {
+            Rect roi;
+            if (overlapRoi(corners[i], corners[j], images[i].size(), images[j].size(), roi))
+            {
+                UMat subimg1 = images[i](Rect(roi.tl() - corners[i], roi.br() - corners[i]));
+                UMat subimg2 = images[j](Rect(roi.tl() - corners[j], roi.br() - corners[j]));
+                UMat similarity = buildSimilarityMask(subimg1, subimg2);
+                similarities_.push_back(similarity);
+            }
+        }
+    }
+}
+
+UMat GainCompensator::buildSimilarityMask(InputArray src_array1, InputArray src_array2)
+{
+    CV_Assert(src_array1.rows() == src_array2.rows() && src_array1.cols() == src_array2.cols());
+    CV_Assert(src_array1.type() == src_array2.type());
+    CV_Assert(src_array1.type() == CV_8UC3 || src_array1.type() == CV_8UC1);
+
+    Mat src1 = src_array1.getMat();
+    Mat src2 = src_array2.getMat();
+
+    UMat umat_similarity(src1.rows, src1.cols, CV_8UC1);
+    Mat similarity = umat_similarity.getMat(ACCESS_WRITE);
+
+    if (src1.channels() == 3)
+    {
+        for (int y = 0; y < similarity.rows; ++y)
+        {
+            for (int x = 0; x < similarity.cols; ++x)
+            {
+                Vec<float, 3> vec_diff =
+                    Vec<float, 3>(*src1.ptr<Vec<uchar, 3>>(y, x))
+                    - Vec<float, 3>(*src2.ptr<Vec<uchar, 3>>(y, x));
+                double diff = norm(vec_diff * (1.f / 255.f));
+
+                *similarity.ptr<uchar>(y, x) = diff <= similarity_threshold_ ? 255 : 0;
+            }
+        }
+    }
+    else // if (src1.channels() == 1)
+    {
+        for (int y = 0; y < similarity.rows; ++y)
+        {
+            for (int x = 0; x < similarity.cols; ++x)
+            {
+                float diff = std::abs(static_cast<int>(*src1.ptr<uchar>(y, x))
+                    - static_cast<int>(*src2.ptr<uchar>(y, x))) / 255.f;
+
+                *similarity.ptr<uchar>(y, x) = diff <= similarity_threshold_ ? 255 : 0;
+            }
+        }
+    }
+    similarity.release();
+
+    Mat kernel = getStructuringElement(MORPH_RECT, Size(3,3));
+    UMat umat_erode;
+    erode(umat_similarity, umat_erode, kernel);
+    dilate(umat_erode, umat_similarity, kernel);
+
+    return umat_similarity;
+}
+
+void ChannelsCompensator::feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                               const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    std::array<std::vector<UMat>, 3> images_channels;
+
+    // Split channels of each input image
+    for (const UMat& image: images)
+    {
+        std::vector<UMat> image_channels;
+        image_channels.resize(3);
+        split(image, image_channels);
+
+        for (int i = 0; i < int(images_channels.size()); ++i)
+            images_channels[i].emplace_back(std::move(image_channels[i]));
+    }
+
+    // For each channel, feed the channel of each image in a GainCompensator
+    gains_.clear();
+    gains_.resize(images.size());
+
+    GainCompensator compensator(getNrFeeds());
+    compensator.setSimilarityThreshold(getSimilarityThreshold());
+    compensator.prepareSimilarityMask(corners, images);
+
+    for (int c = 0; c < 3; ++c)
+    {
+        const std::vector<UMat>& channels = images_channels[c];
+
+        compensator.feed(corners, channels, masks);
+
+        std::vector<double> gains = compensator.gains();
+        for (int i = 0; i < int(gains.size()); ++i)
+            gains_.at(i)[c] = gains[i];
+    }
+}
+
+void ChannelsCompensator::apply(int index, Point /*corner*/, InputOutputArray image, InputArray /*mask*/)
+{
+    CV_INSTRUMENT_REGION();
+
+    multiply(image, gains_.at(index), image);
+}
+
+void ChannelsCompensator::getMatGains(std::vector<Mat>& umv)
+{
+    umv.clear();
+    for (int i = 0; i < static_cast<int>(gains_.size()); ++i)
+    {
+        Mat m;
+        Mat(gains_[i]).copyTo(m);
+        umv.push_back(m);
+    }
+}
+
+void ChannelsCompensator::setMatGains(std::vector<Mat>& umv)
+{
+    for (int i = 0; i < static_cast<int>(umv.size()); i++)
+    {
+        Scalar s;
+        umv[i].copyTo(s);
+        gains_.push_back(s);
+    }
+}
+
+
+template<class Compensator>
+void BlocksCompensator::feedWithStrategy(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                             const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    CV_Assert(corners.size() == images.size() && images.size() == masks.size());
+
+    const int num_images = static_cast<int>(images.size());
+
+    std::vector<Size> bl_per_imgs(num_images);
+    std::vector<Point> block_corners;
+    std::vector<UMat> block_images;
+    std::vector<std::pair<UMat,uchar> > block_masks;
+
+    // Construct blocks for gain compensator
+    for (int img_idx = 0; img_idx < num_images; ++img_idx)
+    {
+        Size bl_per_img((images[img_idx].cols + bl_width_ - 1) / bl_width_,
+                        (images[img_idx].rows + bl_height_ - 1) / bl_height_);
+        int bl_width = (images[img_idx].cols + bl_per_img.width - 1) / bl_per_img.width;
+        int bl_height = (images[img_idx].rows + bl_per_img.height - 1) / bl_per_img.height;
+        bl_per_imgs[img_idx] = bl_per_img;
+        for (int by = 0; by < bl_per_img.height; ++by)
+        {
+            for (int bx = 0; bx < bl_per_img.width; ++bx)
+            {
+                Point bl_tl(bx * bl_width, by * bl_height);
+                Point bl_br(std::min(bl_tl.x + bl_width, images[img_idx].cols),
+                            std::min(bl_tl.y + bl_height, images[img_idx].rows));
+
+                block_corners.push_back(corners[img_idx] + bl_tl);
+                block_images.push_back(images[img_idx](Rect(bl_tl, bl_br)));
+                block_masks.push_back(std::make_pair(masks[img_idx].first(Rect(bl_tl, bl_br)),
+                                                masks[img_idx].second));
+            }
+        }
+    }
+
+    if (getUpdateGain() || int(gain_maps_.size()) != num_images)
+    {
+        Compensator compensator;
+        compensator.setNrFeeds(getNrFeeds());
+        compensator.setSimilarityThreshold(getSimilarityThreshold());
+        compensator.feed(block_corners, block_images, block_masks);
+
+        gain_maps_.clear();
+        gain_maps_.resize(num_images);
+
+        Mat_<float> ker(1, 3);
+        ker(0, 0) = 0.25; ker(0, 1) = 0.5; ker(0, 2) = 0.25;
+
+        int bl_idx = 0;
+        for (int img_idx = 0; img_idx < num_images; ++img_idx)
+        {
+            Size bl_per_img = bl_per_imgs[img_idx];
+            UMat gain_map = getGainMap(compensator, bl_idx, bl_per_img);
+            bl_idx += bl_per_img.width*bl_per_img.height;
+
+            for (int i=0; i<nr_gain_filtering_iterations_; ++i)
+            {
+                UMat tmp;
+                sepFilter2D(gain_map, tmp, CV_32F, ker, ker);
+                swap(gain_map, tmp);
+            }
+
+            gain_maps_[img_idx] = gain_map;
+        }
+    }
+}
+
+UMat BlocksCompensator::getGainMap(const GainCompensator& compensator, int bl_idx, Size bl_per_img)
+{
+    std::vector<double> gains = compensator.gains();
+
+    UMat u_gain_map(bl_per_img, CV_32F);
+    Mat_<float> gain_map = u_gain_map.getMat(ACCESS_WRITE);
+
+    for (int by = 0; by < bl_per_img.height; ++by)
+        for (int bx = 0; bx < bl_per_img.width; ++bx, ++bl_idx)
+            gain_map(by, bx) = static_cast<float>(gains[bl_idx]);
+
+    return u_gain_map;
+}
+
+UMat BlocksCompensator::getGainMap(const ChannelsCompensator& compensator, int bl_idx, Size bl_per_img)
+{
+    std::vector<Scalar> gains = compensator.gains();
+
+    UMat u_gain_map(bl_per_img, CV_32FC3);
+    Mat_<Vec3f> gain_map = u_gain_map.getMat(ACCESS_WRITE);
+
+    for (int by = 0; by < bl_per_img.height; ++by)
+        for (int bx = 0; bx < bl_per_img.width; ++bx, ++bl_idx)
+            for (int c = 0; c < 3; ++c)
+                gain_map(by, bx)[c] = static_cast<float>(gains[bl_idx][c]);
+
+    return u_gain_map;
+}
+
+void BlocksCompensator::apply(int index, Point /*corner*/, InputOutputArray _image, InputArray /*mask*/)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(_image.type() == CV_8UC3);
+
+    UMat u_gain_map;
+    if (gain_maps_.at(index).size() == _image.size())
+        u_gain_map = gain_maps_.at(index);
+    else
+        resize(gain_maps_.at(index), u_gain_map, _image.size(), 0, 0, INTER_LINEAR);
+
+    if (u_gain_map.channels() != 3)
+    {
+        std::vector<UMat> gains_channels;
+        gains_channels.push_back(u_gain_map);
+        gains_channels.push_back(u_gain_map);
+        gains_channels.push_back(u_gain_map);
+        merge(gains_channels, u_gain_map);
+    }
+
+    multiply(_image, u_gain_map, _image, 1, _image.type());
+}
+
+void BlocksCompensator::getMatGains(std::vector<Mat>& umv)
+{
+    umv.clear();
+    for (int i = 0; i < static_cast<int>(gain_maps_.size()); ++i)
+    {
+        Mat m;
+        gain_maps_[i].copyTo(m);
+        umv.push_back(m);
+    }
+}
+
+void BlocksCompensator::setMatGains(std::vector<Mat>& umv)
+{
+    for (int i = 0; i < static_cast<int>(umv.size()); i++)
+    {
+        UMat m;
+        umv[i].copyTo(m);
+        gain_maps_.push_back(m);
+    }
+}
+
+void BlocksGainCompensator::feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                                 const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    BlocksCompensator::feedWithStrategy<GainCompensator>(corners, images, masks);
+}
+
+void BlocksChannelsCompensator::feed(const std::vector<Point> &corners, const std::vector<UMat> &images,
+                                     const std::vector<std::pair<UMat,uchar> > &masks)
+{
+    BlocksCompensator::feedWithStrategy<ChannelsCompensator>(corners, images, masks);
+}
+
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/matchers.cpp b/upstream/opencv/modules/stitching/src/matchers.cpp
new file mode 100644
index 0000000..e7c7616
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/matchers.cpp
@@ -0,0 +1,712 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#include "opencv2/core/opencl/ocl_defs.hpp"
+
+using namespace cv;
+using namespace cv::detail;
+using namespace cv::cuda;
+
+#ifdef HAVE_OPENCV_CUDAIMGPROC
+#  include "opencv2/cudaimgproc.hpp"
+#endif
+
+namespace {
+
+struct DistIdxPair
+{
+    bool operator<(const DistIdxPair &other) const { return dist < other.dist; }
+    double dist;
+    int idx;
+};
+
+
+struct MatchPairsBody : ParallelLoopBody
+{
+    MatchPairsBody(FeaturesMatcher &_matcher, const std::vector<ImageFeatures> &_features,
+                   std::vector<MatchesInfo> &_pairwise_matches, std::vector<std::pair<int,int> > &_near_pairs)
+            : matcher(_matcher), features(_features),
+              pairwise_matches(_pairwise_matches), near_pairs(_near_pairs) {}
+
+    void operator ()(const Range &r) const CV_OVERRIDE
+    {
+        cv::RNG rng = cv::theRNG(); // save entry rng state
+        const int num_images = static_cast<int>(features.size());
+        for (int i = r.start; i < r.end; ++i)
+        {
+            cv::theRNG() = cv::RNG(rng.state + i); // force "stable" RNG seed for each processed pair
+
+            int from = near_pairs[i].first;
+            int to = near_pairs[i].second;
+            int pair_idx = from*num_images + to;
+
+            matcher(features[from], features[to], pairwise_matches[pair_idx]);
+            pairwise_matches[pair_idx].src_img_idx = from;
+            pairwise_matches[pair_idx].dst_img_idx = to;
+
+            size_t dual_pair_idx = to*num_images + from;
+
+            pairwise_matches[dual_pair_idx] = pairwise_matches[pair_idx];
+            pairwise_matches[dual_pair_idx].src_img_idx = to;
+            pairwise_matches[dual_pair_idx].dst_img_idx = from;
+
+            if (!pairwise_matches[pair_idx].H.empty())
+                pairwise_matches[dual_pair_idx].H = pairwise_matches[pair_idx].H.inv();
+
+            for (size_t j = 0; j < pairwise_matches[dual_pair_idx].matches.size(); ++j)
+                std::swap(pairwise_matches[dual_pair_idx].matches[j].queryIdx,
+                          pairwise_matches[dual_pair_idx].matches[j].trainIdx);
+            LOG(".");
+        }
+    }
+
+    FeaturesMatcher &matcher;
+    const std::vector<ImageFeatures> &features;
+    std::vector<MatchesInfo> &pairwise_matches;
+    std::vector<std::pair<int,int> > &near_pairs;
+
+private:
+    void operator =(const MatchPairsBody&);
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+typedef std::set<std::pair<int,int> > MatchesSet;
+
+// These two classes are aimed to find features matches only, not to
+// estimate homography
+
+class CpuMatcher CV_FINAL : public FeaturesMatcher
+{
+public:
+    CpuMatcher(float match_conf) : FeaturesMatcher(true), match_conf_(match_conf) {}
+    void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info) CV_OVERRIDE;
+
+private:
+    float match_conf_;
+};
+
+#ifdef HAVE_OPENCV_CUDAFEATURES2D
+class GpuMatcher CV_FINAL : public FeaturesMatcher
+{
+public:
+    GpuMatcher(float match_conf) : match_conf_(match_conf) {}
+    void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info);
+
+    void collectGarbage();
+
+private:
+    float match_conf_;
+    GpuMat descriptors1_, descriptors2_;
+    GpuMat train_idx_, distance_, all_dist_;
+    std::vector< std::vector<DMatch> > pair_matches;
+};
+#endif
+
+
+void CpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(features1.descriptors.type() == features2.descriptors.type());
+    CV_Assert(features2.descriptors.depth() == CV_8U || features2.descriptors.depth() == CV_32F);
+
+    matches_info.matches.clear();
+
+    Ptr<cv::DescriptorMatcher> matcher;
+#if 0 // TODO check this
+    if (ocl::isOpenCLActivated())
+    {
+        matcher = makePtr<BFMatcher>((int)NORM_L2);
+    }
+    else
+#endif
+    {
+        Ptr<flann::IndexParams> indexParams = makePtr<flann::KDTreeIndexParams>();
+        Ptr<flann::SearchParams> searchParams = makePtr<flann::SearchParams>();
+
+        if (features2.descriptors.depth() == CV_8U)
+        {
+            indexParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
+            searchParams->setAlgorithm(cvflann::FLANN_INDEX_LSH);
+        }
+
+        matcher = makePtr<FlannBasedMatcher>(indexParams, searchParams);
+    }
+    std::vector< std::vector<DMatch> > pair_matches;
+    MatchesSet matches;
+
+    // Find 1->2 matches
+    matcher->knnMatch(features1.descriptors, features2.descriptors, pair_matches, 2);
+    for (size_t i = 0; i < pair_matches.size(); ++i)
+    {
+        if (pair_matches[i].size() < 2)
+            continue;
+        const DMatch& m0 = pair_matches[i][0];
+        const DMatch& m1 = pair_matches[i][1];
+        if (m0.distance < (1.f - match_conf_) * m1.distance)
+        {
+            matches_info.matches.push_back(m0);
+            matches.insert(std::make_pair(m0.queryIdx, m0.trainIdx));
+        }
+    }
+    LOG("\n1->2 matches: " << matches_info.matches.size() << endl);
+
+    // Find 2->1 matches
+    pair_matches.clear();
+    matcher->knnMatch(features2.descriptors, features1.descriptors, pair_matches, 2);
+    for (size_t i = 0; i < pair_matches.size(); ++i)
+    {
+        if (pair_matches[i].size() < 2)
+            continue;
+        const DMatch& m0 = pair_matches[i][0];
+        const DMatch& m1 = pair_matches[i][1];
+        if (m0.distance < (1.f - match_conf_) * m1.distance)
+            if (matches.find(std::make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
+                matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
+    }
+    LOG("1->2 & 2->1 matches: " << matches_info.matches.size() << endl);
+}
+
+#ifdef HAVE_OPENCV_CUDAFEATURES2D
+void GpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info)
+{
+    CV_INSTRUMENT_REGION();
+
+    matches_info.matches.clear();
+
+    ensureSizeIsEnough(features1.descriptors.size(), features1.descriptors.type(), descriptors1_);
+    ensureSizeIsEnough(features2.descriptors.size(), features2.descriptors.type(), descriptors2_);
+
+    descriptors1_.upload(features1.descriptors);
+    descriptors2_.upload(features2.descriptors);
+
+    //TODO: NORM_L1 allows to avoid matcher crashes for ORB features, but is not absolutely correct for them.
+    //      The best choice for ORB features is NORM_HAMMING, but it is incorrect for SURF features.
+    //      More accurate fix in this place should be done in the future -- the type of the norm
+    //      should be either a parameter of this method, or a field of the class.
+    Ptr<cuda::DescriptorMatcher> matcher = cuda::DescriptorMatcher::createBFMatcher(NORM_L1);
+
+    MatchesSet matches;
+
+    // Find 1->2 matches
+    pair_matches.clear();
+    matcher->knnMatch(descriptors1_, descriptors2_, pair_matches, 2);
+    for (size_t i = 0; i < pair_matches.size(); ++i)
+    {
+        if (pair_matches[i].size() < 2)
+            continue;
+        const DMatch& m0 = pair_matches[i][0];
+        const DMatch& m1 = pair_matches[i][1];
+        if (m0.distance < (1.f - match_conf_) * m1.distance)
+        {
+            matches_info.matches.push_back(m0);
+            matches.insert(std::make_pair(m0.queryIdx, m0.trainIdx));
+        }
+    }
+
+    // Find 2->1 matches
+    pair_matches.clear();
+    matcher->knnMatch(descriptors2_, descriptors1_, pair_matches, 2);
+    for (size_t i = 0; i < pair_matches.size(); ++i)
+    {
+        if (pair_matches[i].size() < 2)
+            continue;
+        const DMatch& m0 = pair_matches[i][0];
+        const DMatch& m1 = pair_matches[i][1];
+        if (m0.distance < (1.f - match_conf_) * m1.distance)
+            if (matches.find(std::make_pair(m0.trainIdx, m0.queryIdx)) == matches.end())
+                matches_info.matches.push_back(DMatch(m0.trainIdx, m0.queryIdx, m0.distance));
+    }
+}
+
+void GpuMatcher::collectGarbage()
+{
+    descriptors1_.release();
+    descriptors2_.release();
+    train_idx_.release();
+    distance_.release();
+    all_dist_.release();
+    std::vector< std::vector<DMatch> >().swap(pair_matches);
+}
+#endif
+
+} // namespace
+
+
+namespace cv {
+namespace detail {
+
+void computeImageFeatures(
+    const Ptr<Feature2D> &featuresFinder,
+    InputArrayOfArrays  images,
+    std::vector<ImageFeatures> &features,
+    InputArrayOfArrays masks)
+{
+    // compute all features
+    std::vector<std::vector<KeyPoint>> keypoints;
+    std::vector<UMat> descriptors;
+    // TODO replace with 1 call to new over load of detectAndCompute
+    featuresFinder->detect(images, keypoints, masks);
+    featuresFinder->compute(images, keypoints, descriptors);
+
+    // store to ImageFeatures
+    size_t count = images.total();
+    features.resize(count);
+    CV_Assert(count == keypoints.size() && count == descriptors.size());
+    for (size_t i = 0; i < count; ++i)
+    {
+        features[i].img_size = images.size(int(i));
+        features[i].keypoints = std::move(keypoints[i]);
+        features[i].descriptors = std::move(descriptors[i]);
+    }
+}
+
+void computeImageFeatures(
+    const Ptr<Feature2D> &featuresFinder,
+    InputArray image,
+    ImageFeatures &features,
+    InputArray mask)
+{
+    features.img_size = image.size();
+    featuresFinder->detectAndCompute(image, mask, features.keypoints, features.descriptors);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+MatchesInfo::MatchesInfo() : src_img_idx(-1), dst_img_idx(-1), num_inliers(0), confidence(0) {}
+
+MatchesInfo::MatchesInfo(const MatchesInfo &other) { *this = other; }
+
+MatchesInfo& MatchesInfo::operator =(const MatchesInfo &other)
+{
+    src_img_idx = other.src_img_idx;
+    dst_img_idx = other.dst_img_idx;
+    matches = other.matches;
+    inliers_mask = other.inliers_mask;
+    num_inliers = other.num_inliers;
+    H = other.H.clone();
+    confidence = other.confidence;
+    return *this;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+void FeaturesMatcher::match(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
+                            const UMat &mask)
+{
+    const int num_images = static_cast<int>(features.size());
+
+    CV_Assert(mask.empty() || (mask.type() == CV_8U && mask.cols == num_images && mask.rows));
+    Mat_<uchar> mask_(mask.getMat(ACCESS_READ));
+    if (mask_.empty())
+        mask_ = Mat::ones(num_images, num_images, CV_8U);
+
+    std::vector<std::pair<int,int> > near_pairs;
+    for (int i = 0; i < num_images - 1; ++i)
+        for (int j = i + 1; j < num_images; ++j)
+            if (features[i].keypoints.size() > 0 && features[j].keypoints.size() > 0 && mask_(i, j))
+                near_pairs.push_back(std::make_pair(i, j));
+
+    pairwise_matches.clear(); // clear history values
+    pairwise_matches.resize(num_images * num_images);
+    MatchPairsBody body(*this, features, pairwise_matches, near_pairs);
+
+    if (is_thread_safe_)
+        parallel_for_(Range(0, static_cast<int>(near_pairs.size())), body);
+    else
+        body(Range(0, static_cast<int>(near_pairs.size())));
+    LOGLN_CHAT("");
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+BestOf2NearestMatcher::BestOf2NearestMatcher(bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2, double matches_confidence_thresh)
+{
+    CV_UNUSED(try_use_gpu);
+
+#ifdef HAVE_OPENCV_CUDAFEATURES2D
+    if (try_use_gpu && getCudaEnabledDeviceCount() > 0)
+    {
+        impl_ = makePtr<GpuMatcher>(match_conf);
+    }
+    else
+#endif
+    {
+        impl_ = makePtr<CpuMatcher>(match_conf);
+    }
+
+    is_thread_safe_ = impl_->isThreadSafe();
+    num_matches_thresh1_ = num_matches_thresh1;
+    num_matches_thresh2_ = num_matches_thresh2;
+    matches_confidence_thresh_ = matches_confidence_thresh;
+}
+
+Ptr<BestOf2NearestMatcher> BestOf2NearestMatcher::create(bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2,
+                                                         double matches_confidence_thresh)
+{
+    return makePtr<BestOf2NearestMatcher>(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2, matches_confidence_thresh);
+}
+
+
+
+void BestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2,
+                                  MatchesInfo &matches_info)
+{
+    CV_INSTRUMENT_REGION();
+
+    (*impl_)(features1, features2, matches_info);
+
+    // Check if it makes sense to find homography
+    if (matches_info.matches.size() < static_cast<size_t>(num_matches_thresh1_))
+        return;
+
+    // Construct point-point correspondences for homography estimation
+    Mat src_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
+    Mat dst_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
+    for (size_t i = 0; i < matches_info.matches.size(); ++i)
+    {
+        const DMatch& m = matches_info.matches[i];
+
+        Point2f p = features1.keypoints[m.queryIdx].pt;
+        p.x -= features1.img_size.width * 0.5f;
+        p.y -= features1.img_size.height * 0.5f;
+        src_points.at<Point2f>(0, static_cast<int>(i)) = p;
+
+        p = features2.keypoints[m.trainIdx].pt;
+        p.x -= features2.img_size.width * 0.5f;
+        p.y -= features2.img_size.height * 0.5f;
+        dst_points.at<Point2f>(0, static_cast<int>(i)) = p;
+    }
+
+    // Find pair-wise motion
+    matches_info.H = findHomography(src_points, dst_points, matches_info.inliers_mask, RANSAC);
+    if (matches_info.H.empty() || std::abs(determinant(matches_info.H)) < std::numeric_limits<double>::epsilon())
+        return;
+
+    // Find number of inliers
+    matches_info.num_inliers = 0;
+    for (size_t i = 0; i < matches_info.inliers_mask.size(); ++i)
+        if (matches_info.inliers_mask[i])
+            matches_info.num_inliers++;
+
+    // These coeffs are from paper M. Brown and D. Lowe. "Automatic Panoramic Image Stitching
+    // using Invariant Features"
+    matches_info.confidence = matches_info.num_inliers / (8 + 0.3 * matches_info.matches.size());
+
+    // Set zero confidence to remove matches between too close images, as they don't provide
+    // additional information anyway.
+    matches_info.confidence = matches_info.confidence > matches_confidence_thresh_ ? 0. : matches_info.confidence;
+
+    // Check if we should try to refine motion
+    if (matches_info.num_inliers < num_matches_thresh2_)
+        return;
+
+    // Construct point-point correspondences for inliers only
+    src_points.create(1, matches_info.num_inliers, CV_32FC2);
+    dst_points.create(1, matches_info.num_inliers, CV_32FC2);
+    int inlier_idx = 0;
+    for (size_t i = 0; i < matches_info.matches.size(); ++i)
+    {
+        if (!matches_info.inliers_mask[i])
+            continue;
+
+        const DMatch& m = matches_info.matches[i];
+
+        Point2f p = features1.keypoints[m.queryIdx].pt;
+        p.x -= features1.img_size.width * 0.5f;
+        p.y -= features1.img_size.height * 0.5f;
+        src_points.at<Point2f>(0, inlier_idx) = p;
+
+        p = features2.keypoints[m.trainIdx].pt;
+        p.x -= features2.img_size.width * 0.5f;
+        p.y -= features2.img_size.height * 0.5f;
+        dst_points.at<Point2f>(0, inlier_idx) = p;
+
+        inlier_idx++;
+    }
+
+    // Rerun motion estimation on inliers only
+    matches_info.H = findHomography(src_points, dst_points, RANSAC);
+}
+
+void BestOf2NearestMatcher::collectGarbage()
+{
+    impl_->collectGarbage();
+}
+
+
+BestOf2NearestRangeMatcher::BestOf2NearestRangeMatcher(int range_width, bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2): BestOf2NearestMatcher(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2)
+{
+    range_width_ = range_width;
+}
+
+
+void BestOf2NearestRangeMatcher::match(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches,
+                                       const UMat &mask)
+{
+    const int num_images = static_cast<int>(features.size());
+
+    CV_Assert(mask.empty() || (mask.type() == CV_8U && mask.cols == num_images && mask.rows));
+    Mat_<uchar> mask_(mask.getMat(ACCESS_READ));
+    if (mask_.empty())
+        mask_ = Mat::ones(num_images, num_images, CV_8U);
+
+    std::vector<std::pair<int,int> > near_pairs;
+    for (int i = 0; i < num_images - 1; ++i)
+        for (int j = i + 1; j < std::min(num_images, i + 1 + range_width_); ++j)
+            if (features[i].keypoints.size() > 0 && features[j].keypoints.size() > 0 && mask_(i, j))
+                near_pairs.push_back(std::make_pair(i, j));
+
+    pairwise_matches.resize(num_images * num_images);
+    MatchPairsBody body(*this, features, pairwise_matches, near_pairs);
+
+    if (is_thread_safe_)
+        parallel_for_(Range(0, static_cast<int>(near_pairs.size())), body);
+    else
+        body(Range(0, static_cast<int>(near_pairs.size())));
+    LOGLN_CHAT("");
+}
+
+
+void AffineBestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2,
+                                        MatchesInfo &matches_info)
+{
+    (*impl_)(features1, features2, matches_info);
+
+    // Check if it makes sense to find transform
+    if (matches_info.matches.size() < static_cast<size_t>(num_matches_thresh1_))
+        return;
+
+    // Construct point-point correspondences for transform estimation
+    Mat src_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
+    Mat dst_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
+    for (size_t i = 0; i < matches_info.matches.size(); ++i)
+    {
+        const cv::DMatch &m = matches_info.matches[i];
+        src_points.at<Point2f>(0, static_cast<int>(i)) = features1.keypoints[m.queryIdx].pt;
+        dst_points.at<Point2f>(0, static_cast<int>(i)) = features2.keypoints[m.trainIdx].pt;
+    }
+
+    // Find pair-wise motion
+    if (full_affine_)
+        matches_info.H = estimateAffine2D(src_points, dst_points, matches_info.inliers_mask);
+    else
+        matches_info.H = estimateAffinePartial2D(src_points, dst_points, matches_info.inliers_mask);
+
+    if (matches_info.H.empty()) {
+        // could not find transformation
+        matches_info.confidence = 0;
+        matches_info.num_inliers = 0;
+        return;
+    }
+
+    // Find number of inliers
+    matches_info.num_inliers = 0;
+    for (size_t i = 0; i < matches_info.inliers_mask.size(); ++i)
+        if (matches_info.inliers_mask[i])
+            matches_info.num_inliers++;
+
+    // These coeffs are from paper M. Brown and D. Lowe. "Automatic Panoramic
+    // Image Stitching using Invariant Features"
+    matches_info.confidence =
+        matches_info.num_inliers / (8 + 0.3 * matches_info.matches.size());
+
+    /* should we remove matches between too close images? */
+    // matches_info.confidence = matches_info.confidence > 3. ? 0. : matches_info.confidence;
+
+    // extend H to represent linear transformation in homogeneous coordinates
+    matches_info.H.push_back(Mat::zeros(1, 3, CV_64F));
+    matches_info.H.at<double>(2, 2) = 1;
+}
+
+
+LightGlueFeaturesMatcher::LightGlueFeaturesMatcher(Ptr<LightGlueMatcher> lgMatcher,
+                                                     int num_matches_thresh1,
+                                                     int num_matches_thresh2,
+                                                     double matches_confidence_thresh)
+    : FeaturesMatcher(false),  // not thread-safe: setPairInfo() mutates state
+      lgMatcher_(lgMatcher),
+      num_matches_thresh1_(num_matches_thresh1),
+      num_matches_thresh2_(num_matches_thresh2),
+      matches_confidence_thresh_(matches_confidence_thresh),
+      lg_score_thresh_(0.0f)
+{
+}
+
+void LightGlueFeaturesMatcher::setScoreThreshold(float thresh)
+{
+    lg_score_thresh_ = thresh;
+}
+
+void LightGlueFeaturesMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2,
+                                      MatchesInfo &matches_info)
+{
+    matches_info.src_img_idx = features1.img_idx;
+    matches_info.dst_img_idx = features2.img_idx;
+    matches_info.confidence = 0;
+
+    // Guard empty keypoints
+    if (features1.keypoints.empty() || features2.keypoints.empty())
+        return;
+
+    const int N = static_cast<int>(features1.keypoints.size());
+    const int M = static_cast<int>(features2.keypoints.size());
+
+    // Build Nx2 keypoint coordinate matrices
+    Mat kpts1Mat(N, 2, CV_32F);
+    Mat kpts2Mat(M, 2, CV_32F);
+    for (int i = 0; i < N; i++)
+    {
+        kpts1Mat.at<float>(i, 0) = features1.keypoints[i].pt.x;
+        kpts1Mat.at<float>(i, 1) = features1.keypoints[i].pt.y;
+    }
+    for (int i = 0; i < M; i++)
+    {
+        kpts2Mat.at<float>(i, 0) = features2.keypoints[i].pt.x;
+        kpts2Mat.at<float>(i, 1) = features2.keypoints[i].pt.y;
+    }
+
+    // Set pair context for LightGlue spatial reasoning
+    lgMatcher_->setPairInfo(kpts1Mat, kpts2Mat, features1.img_size, features2.img_size);
+
+    // Run LightGlue matching
+    Mat desc1 = features1.descriptors.getMat(ACCESS_READ);
+    Mat desc2 = features2.descriptors.getMat(ACCESS_READ);
+    std::vector<DMatch> matches;
+    lgMatcher_->match(desc1, desc2, matches);
+
+    // Filter by score threshold
+    if (lg_score_thresh_ > 0.0f)
+    {
+        float maxDist = 1.0f - lg_score_thresh_;
+        std::vector<DMatch> filtered;
+        filtered.reserve(matches.size());
+        for (const auto& m : matches)
+        {
+            if (m.distance <= maxDist)
+                filtered.push_back(m);
+        }
+        matches.swap(filtered);
+    }
+
+    // Store matches before homography estimation
+    matches_info.matches = matches;
+
+    // Guard: need at least 4 matches for findHomography
+    if (matches.size() < 4)
+        return;
+
+    // Estimate homography with centered coordinates
+    Mat src_points(1, static_cast<int>(matches.size()), CV_32FC2);
+    Mat dst_points(1, static_cast<int>(matches.size()), CV_32FC2);
+    for (size_t i = 0; i < matches.size(); ++i)
+    {
+        const DMatch& m = matches[i];
+
+        Point2f p = features1.keypoints[m.queryIdx].pt;
+        p.x -= features1.img_size.width * 0.5f;
+        p.y -= features1.img_size.height * 0.5f;
+        src_points.at<Point2f>(0, static_cast<int>(i)) = p;
+
+        p = features2.keypoints[m.trainIdx].pt;
+        p.x -= features2.img_size.width * 0.5f;
+        p.y -= features2.img_size.height * 0.5f;
+        dst_points.at<Point2f>(0, static_cast<int>(i)) = p;
+    }
+
+    matches_info.H = findHomography(src_points, dst_points, matches_info.inliers_mask, RANSAC);
+    if (matches_info.H.empty() ||
+        std::abs(determinant(matches_info.H)) < std::numeric_limits<double>::epsilon())
+        return;
+
+    // Compute inliers and confidence (Brown & Lowe formula)
+    matches_info.num_inliers = 0;
+    for (size_t i = 0; i < matches_info.inliers_mask.size(); ++i)
+        if (matches_info.inliers_mask[i])
+            matches_info.num_inliers++;
+
+    matches_info.confidence = matches_info.num_inliers /
+                              (8 + 0.3 * matches_info.matches.size());
+
+    // Zero confidence for too-close image pairs
+    if (matches_info.confidence > matches_confidence_thresh_)
+        matches_info.confidence = 0.;
+
+    // Refine homography on inliers if enough
+    if (matches_info.num_inliers >= num_matches_thresh2_)
+    {
+        src_points.create(1, matches_info.num_inliers, CV_32FC2);
+        dst_points.create(1, matches_info.num_inliers, CV_32FC2);
+        int inlier_idx = 0;
+        for (size_t i = 0; i < matches_info.matches.size(); ++i)
+        {
+            if (!matches_info.inliers_mask[i])
+                continue;
+
+            const DMatch& m = matches_info.matches[i];
+
+            Point2f p = features1.keypoints[m.queryIdx].pt;
+            p.x -= features1.img_size.width * 0.5f;
+            p.y -= features1.img_size.height * 0.5f;
+            src_points.at<Point2f>(0, inlier_idx) = p;
+
+            p = features2.keypoints[m.trainIdx].pt;
+            p.x -= features2.img_size.width * 0.5f;
+            p.y -= features2.img_size.height * 0.5f;
+            dst_points.at<Point2f>(0, inlier_idx) = p;
+
+            inlier_idx++;
+        }
+
+        matches_info.H = findHomography(src_points, dst_points, RANSAC);
+    }
+}
+
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/motion_estimators.cpp b/upstream/opencv/modules/stitching/src/motion_estimators.cpp
new file mode 100644
index 0000000..f6800b6
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/motion_estimators.cpp
@@ -0,0 +1,1202 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/cvdef.h"
+
+using namespace cv;
+using namespace cv::detail;
+
+namespace {
+
+struct IncDistance
+{
+    IncDistance(std::vector<int> &vdists) : dists(&vdists[0]) {}
+    void operator ()(const GraphEdge &edge) { dists[edge.to] = dists[edge.from] + 1; }
+    int* dists;
+};
+
+
+struct CalcRotation
+{
+    CalcRotation(int _num_images, const std::vector<MatchesInfo> &_pairwise_matches, std::vector<CameraParams> &_cameras)
+        : num_images(_num_images), pairwise_matches(&_pairwise_matches[0]), cameras(&_cameras[0]) {}
+
+    void operator ()(const GraphEdge &edge)
+    {
+        int pair_idx = edge.from * num_images + edge.to;
+
+        Mat_<double> K_from = Mat::eye(3, 3, CV_64F);
+        K_from(0,0) = cameras[edge.from].focal;
+        K_from(1,1) = cameras[edge.from].focal * cameras[edge.from].aspect;
+        K_from(0,2) = cameras[edge.from].ppx;
+        K_from(1,2) = cameras[edge.from].ppy;
+
+        Mat_<double> K_to = Mat::eye(3, 3, CV_64F);
+        K_to(0,0) = cameras[edge.to].focal;
+        K_to(1,1) = cameras[edge.to].focal * cameras[edge.to].aspect;
+        K_to(0,2) = cameras[edge.to].ppx;
+        K_to(1,2) = cameras[edge.to].ppy;
+
+        Mat R = K_from.inv() * pairwise_matches[pair_idx].H.inv() * K_to;
+        cameras[edge.to].R = cameras[edge.from].R * R;
+    }
+
+    int num_images;
+    const MatchesInfo* pairwise_matches;
+    CameraParams* cameras;
+};
+
+
+/**
+ * @brief Functor calculating final transformation by chaining linear transformations
+ */
+struct CalcAffineTransform
+{
+    CalcAffineTransform(int _num_images,
+                      const std::vector<MatchesInfo> &_pairwise_matches,
+                      std::vector<CameraParams> &_cameras)
+    : num_images(_num_images), pairwise_matches(&_pairwise_matches[0]), cameras(&_cameras[0]) {}
+
+    void operator()(const GraphEdge &edge)
+    {
+        int pair_idx = edge.from * num_images + edge.to;
+        cameras[edge.to].R = cameras[edge.from].R * pairwise_matches[pair_idx].H;
+    }
+
+    int num_images;
+    const MatchesInfo *pairwise_matches;
+    CameraParams *cameras;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+void calcDeriv(const Mat &err1, const Mat &err2, double h, Mat res)
+{
+    for (int i = 0; i < err1.rows; ++i)
+        res.at<double>(i, 0) = (err2.at<double>(i, 0) - err1.at<double>(i, 0)) / h;
+}
+
+} // namespace
+
+
+namespace cv {
+namespace detail {
+
+bool HomographyBasedEstimator::estimate(
+        const std::vector<ImageFeatures> &features,
+        const std::vector<MatchesInfo> &pairwise_matches,
+        std::vector<CameraParams> &cameras)
+{
+    LOGLN("Estimating rotations...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    const int num_images = static_cast<int>(features.size());
+
+#if 0
+    // Robustly estimate focal length from rotating cameras
+    std::vector<Mat> Hs;
+    for (int iter = 0; iter < 100; ++iter)
+    {
+        int len = 2 + rand()%(pairwise_matches.size() - 1);
+        std::vector<int> subset;
+        selectRandomSubset(len, pairwise_matches.size(), subset);
+        Hs.clear();
+        for (size_t i = 0; i < subset.size(); ++i)
+            if (!pairwise_matches[subset[i]].H.empty())
+                Hs.push_back(pairwise_matches[subset[i]].H);
+        Mat_<double> K;
+        if (Hs.size() >= 2)
+        {
+            if (calibrateRotatingCamera(Hs, K))
+                cin.get();
+        }
+    }
+#endif
+
+    if (!is_focals_estimated_)
+    {
+        // Estimate focal length and set it for all cameras
+        std::vector<double> focals;
+        estimateFocal(features, pairwise_matches, focals);
+        cameras.assign(num_images, CameraParams());
+        for (int i = 0; i < num_images; ++i)
+            cameras[i].focal = focals[i];
+    }
+    else
+    {
+        for (int i = 0; i < num_images; ++i)
+        {
+            cameras[i].ppx -= 0.5 * features[i].img_size.width;
+            cameras[i].ppy -= 0.5 * features[i].img_size.height;
+        }
+    }
+
+    // Restore global motion
+    Graph span_tree;
+    std::vector<int> span_tree_centers;
+    findMaxSpanningTree(num_images, pairwise_matches, span_tree, span_tree_centers);
+    span_tree.walkBreadthFirst(span_tree_centers[0], CalcRotation(num_images, pairwise_matches, cameras));
+
+    // As calculations were performed under assumption that p.p. is in image center
+    for (int i = 0; i < num_images; ++i)
+    {
+        cameras[i].ppx += 0.5 * features[i].img_size.width;
+        cameras[i].ppy += 0.5 * features[i].img_size.height;
+    }
+
+    LOGLN("Estimating rotations, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+    return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+bool AffineBasedEstimator::estimate(const std::vector<ImageFeatures> &features,
+                                    const std::vector<MatchesInfo> &pairwise_matches,
+                                    std::vector<CameraParams> &cameras)
+{
+    cameras.assign(features.size(), CameraParams());
+    const int num_images = static_cast<int>(features.size());
+
+    // find maximum spaning tree on pairwise matches
+    cv::detail::Graph span_tree;
+    std::vector<int> span_tree_centers;
+    // uses number of inliers as weights
+    findMaxSpanningTree(num_images, pairwise_matches, span_tree,
+                      span_tree_centers);
+
+    // compute final transform by chaining H together
+    span_tree.walkBreadthFirst(
+            span_tree_centers[0],
+            CalcAffineTransform(num_images, pairwise_matches, cameras));
+    // this estimator never fails
+    return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+bool BundleAdjusterBase::estimate(const std::vector<ImageFeatures> &features,
+                                  const std::vector<MatchesInfo> &pairwise_matches,
+                                  std::vector<CameraParams> &cameras)
+{
+    LOG_CHAT("Bundle adjustment");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    num_images_ = static_cast<int>(features.size());
+    features_ = &features[0];
+    pairwise_matches_ = &pairwise_matches[0];
+
+    setUpInitialCameraParams(cameras);
+
+    // Leave only consistent image pairs
+    edges_.clear();
+    for (int i = 0; i < num_images_ - 1; ++i)
+    {
+        for (int j = i + 1; j < num_images_; ++j)
+        {
+            const MatchesInfo& matches_info = pairwise_matches_[i * num_images_ + j];
+            if (matches_info.confidence > conf_thresh_)
+                edges_.push_back(std::make_pair(i, j));
+        }
+    }
+
+    // Compute number of correspondences
+    total_num_matches_ = 0;
+    for (size_t i = 0; i < edges_.size(); ++i)
+        total_num_matches_ += static_cast<int>(pairwise_matches[edges_[i].first * num_images_ +
+                                                                edges_[i].second].num_inliers);
+
+    int nerrs = total_num_matches_ * num_errs_per_measurement_;
+
+    auto callb = [&](InputOutputArray param, OutputArray err, OutputArray jac) -> bool
+    {
+        // workaround against losing value
+        Mat backup = cam_params_.clone();
+        param.copyTo(cam_params_);
+        if (jac.needed())
+        {
+            Mat m = jac.getMat();
+            calcJacobian(m);
+        }
+        if (err.needed())
+        {
+            Mat m = err.getMat();
+            calcError(m);
+        }
+        backup.copyTo(cam_params_);
+        return true;
+    };
+
+    LevMarq solver(cam_params_, callb,
+                   LevMarq::Settings()
+                   .setMaxIterations((unsigned int)term_criteria_.maxCount)
+                   .setStepNormTolerance(term_criteria_.epsilon)
+                   .setSmallEnergyTolerance(term_criteria_.epsilon * term_criteria_.epsilon)
+                   .setGeodesic(true),
+                   noArray(), MatrixType::AUTO, VariableType::LINEAR, nerrs);
+    solver.optimize();
+
+    LOGLN_CHAT("");
+    LOGLN_CHAT("Bundle adjustment, final RMS error: " << std::sqrt(err.dot(err) / total_num_matches_));
+    LOGLN_CHAT("Bundle adjustment, iterations done: " << iter);
+
+    // Check if all camera parameters are valid
+    bool ok = true;
+    for (int i = 0; i < cam_params_.rows; ++i)
+    {
+        if (cvIsNaN(cam_params_.at<double>(i,0)))
+        {
+            ok = false;
+            break;
+        }
+    }
+    if (!ok)
+        return false;
+
+    obtainRefinedCameraParams(cameras);
+
+    // Normalize motion to center image
+    Graph span_tree;
+    std::vector<int> span_tree_centers;
+    findMaxSpanningTree(num_images_, pairwise_matches, span_tree, span_tree_centers);
+    Mat R_inv = cameras[span_tree_centers[0]].R.inv();
+    for (int i = 0; i < num_images_; ++i)
+        cameras[i].R = R_inv * cameras[i].R;
+
+    LOGLN_CHAT("Bundle adjustment, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+    return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+void BundleAdjusterReproj::setUpInitialCameraParams(const std::vector<CameraParams> &cameras)
+{
+    cam_params_.create(num_images_ * 7, 1, CV_64F);
+    SVD svd;
+    for (int i = 0; i < num_images_; ++i)
+    {
+        cam_params_.at<double>(i * 7, 0) = cameras[i].focal;
+        cam_params_.at<double>(i * 7 + 1, 0) = cameras[i].ppx;
+        cam_params_.at<double>(i * 7 + 2, 0) = cameras[i].ppy;
+        cam_params_.at<double>(i * 7 + 3, 0) = cameras[i].aspect;
+
+        svd(cameras[i].R, SVD::FULL_UV);
+        Mat R = svd.u * svd.vt;
+        if (determinant(R) < 0)
+            R *= -1;
+
+        Mat rvec;
+        Rodrigues(R, rvec);
+        CV_Assert(rvec.type() == CV_32F);
+        cam_params_.at<double>(i * 7 + 4, 0) = rvec.at<float>(0, 0);
+        cam_params_.at<double>(i * 7 + 5, 0) = rvec.at<float>(1, 0);
+        cam_params_.at<double>(i * 7 + 6, 0) = rvec.at<float>(2, 0);
+    }
+}
+
+
+void BundleAdjusterReproj::obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const
+{
+    for (int i = 0; i < num_images_; ++i)
+    {
+        cameras[i].focal = cam_params_.at<double>(i * 7, 0);
+        cameras[i].ppx = cam_params_.at<double>(i * 7 + 1, 0);
+        cameras[i].ppy = cam_params_.at<double>(i * 7 + 2, 0);
+        cameras[i].aspect = cam_params_.at<double>(i * 7 + 3, 0);
+
+        Mat rvec(3, 1, CV_64F);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(i * 7 + 4, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(i * 7 + 5, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(i * 7 + 6, 0);
+        Rodrigues(rvec, cameras[i].R);
+
+        Mat tmp;
+        cameras[i].R.convertTo(tmp, CV_32F);
+        cameras[i].R = tmp;
+    }
+}
+
+
+void BundleAdjusterReproj::calcError(Mat &err)
+{
+    err.create(total_num_matches_ * 2, 1, CV_64F);
+
+    int match_idx = 0;
+    for (size_t edge_idx = 0; edge_idx < edges_.size(); ++edge_idx)
+    {
+        int i = edges_[edge_idx].first;
+        int j = edges_[edge_idx].second;
+        double f1 = cam_params_.at<double>(i * 7, 0);
+        double f2 = cam_params_.at<double>(j * 7, 0);
+        double ppx1 = cam_params_.at<double>(i * 7 + 1, 0);
+        double ppx2 = cam_params_.at<double>(j * 7 + 1, 0);
+        double ppy1 = cam_params_.at<double>(i * 7 + 2, 0);
+        double ppy2 = cam_params_.at<double>(j * 7 + 2, 0);
+        double a1 = cam_params_.at<double>(i * 7 + 3, 0);
+        double a2 = cam_params_.at<double>(j * 7 + 3, 0);
+
+        double R1[9];
+        Mat R1_(3, 3, CV_64F, R1);
+        Mat rvec(3, 1, CV_64F);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(i * 7 + 4, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(i * 7 + 5, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(i * 7 + 6, 0);
+        Rodrigues(rvec, R1_);
+
+        double R2[9];
+        Mat R2_(3, 3, CV_64F, R2);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(j * 7 + 4, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(j * 7 + 5, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(j * 7 + 6, 0);
+        Rodrigues(rvec, R2_);
+
+        const ImageFeatures& features1 = features_[i];
+        const ImageFeatures& features2 = features_[j];
+        const MatchesInfo& matches_info = pairwise_matches_[i * num_images_ + j];
+
+        Mat_<double> K1 = Mat::eye(3, 3, CV_64F);
+        K1(0,0) = f1; K1(0,2) = ppx1;
+        K1(1,1) = f1*a1; K1(1,2) = ppy1;
+
+        Mat_<double> K2 = Mat::eye(3, 3, CV_64F);
+        K2(0,0) = f2; K2(0,2) = ppx2;
+        K2(1,1) = f2*a2; K2(1,2) = ppy2;
+
+        Mat_<double> H = K2 * R2_.inv() * R1_ * K1.inv();
+
+        for (size_t k = 0; k < matches_info.matches.size(); ++k)
+        {
+            if (!matches_info.inliers_mask[k])
+                continue;
+
+            const DMatch& m = matches_info.matches[k];
+            Point2f p1 = features1.keypoints[m.queryIdx].pt;
+            Point2f p2 = features2.keypoints[m.trainIdx].pt;
+            double x = H(0,0)*p1.x + H(0,1)*p1.y + H(0,2);
+            double y = H(1,0)*p1.x + H(1,1)*p1.y + H(1,2);
+            double z = H(2,0)*p1.x + H(2,1)*p1.y + H(2,2);
+
+            err.at<double>(2 * match_idx, 0) = p2.x - x/z;
+            err.at<double>(2 * match_idx + 1, 0) = p2.y - y/z;
+            match_idx++;
+        }
+    }
+}
+
+
+void BundleAdjusterReproj::calcJacobian(Mat &jac)
+{
+    jac.create(total_num_matches_ * 2, num_images_ * 7, CV_64F);
+    jac.setTo(0);
+
+    double val;
+    const double step = 1e-4;
+
+    for (int i = 0; i < num_images_; ++i)
+    {
+        if (refinement_mask_.at<uchar>(0, 0))
+        {
+            val = cam_params_.at<double>(i * 7, 0);
+            cam_params_.at<double>(i * 7, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 7, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 7));
+            cam_params_.at<double>(i * 7, 0) = val;
+        }
+        if (refinement_mask_.at<uchar>(0, 2))
+        {
+            val = cam_params_.at<double>(i * 7 + 1, 0);
+            cam_params_.at<double>(i * 7 + 1, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 7 + 1, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 7 + 1));
+            cam_params_.at<double>(i * 7 + 1, 0) = val;
+        }
+        if (refinement_mask_.at<uchar>(1, 2))
+        {
+            val = cam_params_.at<double>(i * 7 + 2, 0);
+            cam_params_.at<double>(i * 7 + 2, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 7 + 2, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 7 + 2));
+            cam_params_.at<double>(i * 7 + 2, 0) = val;
+        }
+        if (refinement_mask_.at<uchar>(1, 1))
+        {
+            val = cam_params_.at<double>(i * 7 + 3, 0);
+            cam_params_.at<double>(i * 7 + 3, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 7 + 3, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 7 + 3));
+            cam_params_.at<double>(i * 7 + 3, 0) = val;
+        }
+        for (int j = 4; j < 7; ++j)
+        {
+            val = cam_params_.at<double>(i * 7 + j, 0);
+            cam_params_.at<double>(i * 7 + j, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 7 + j, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 7 + j));
+            cam_params_.at<double>(i * 7 + j, 0) = val;
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+void BundleAdjusterRay::setUpInitialCameraParams(const std::vector<CameraParams> &cameras)
+{
+    cam_params_.create(num_images_ * 4, 1, CV_64F);
+    SVD svd;
+    for (int i = 0; i < num_images_; ++i)
+    {
+        cam_params_.at<double>(i * 4, 0) = cameras[i].focal;
+
+        svd(cameras[i].R, SVD::FULL_UV);
+        Mat R = svd.u * svd.vt;
+        if (determinant(R) < 0)
+            R *= -1;
+
+        Mat rvec;
+        Rodrigues(R, rvec);
+        CV_Assert(rvec.type() == CV_32F);
+        cam_params_.at<double>(i * 4 + 1, 0) = rvec.at<float>(0, 0);
+        cam_params_.at<double>(i * 4 + 2, 0) = rvec.at<float>(1, 0);
+        cam_params_.at<double>(i * 4 + 3, 0) = rvec.at<float>(2, 0);
+    }
+}
+
+
+void BundleAdjusterRay::obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const
+{
+    for (int i = 0; i < num_images_; ++i)
+    {
+        cameras[i].focal = cam_params_.at<double>(i * 4, 0);
+
+        Mat rvec(3, 1, CV_64F);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(i * 4 + 1, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(i * 4 + 2, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(i * 4 + 3, 0);
+        Rodrigues(rvec, cameras[i].R);
+
+        Mat tmp;
+        cameras[i].R.convertTo(tmp, CV_32F);
+        cameras[i].R = tmp;
+    }
+}
+
+
+void BundleAdjusterRay::calcError(Mat &err)
+{
+    err.create(total_num_matches_ * 3, 1, CV_64F);
+
+    int match_idx = 0;
+    for (size_t edge_idx = 0; edge_idx < edges_.size(); ++edge_idx)
+    {
+        int i = edges_[edge_idx].first;
+        int j = edges_[edge_idx].second;
+        double f1 = cam_params_.at<double>(i * 4, 0);
+        double f2 = cam_params_.at<double>(j * 4, 0);
+
+        double R1[9];
+        Mat R1_(3, 3, CV_64F, R1);
+        Mat rvec(3, 1, CV_64F);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(i * 4 + 1, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(i * 4 + 2, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(i * 4 + 3, 0);
+        Rodrigues(rvec, R1_);
+
+        double R2[9];
+        Mat R2_(3, 3, CV_64F, R2);
+        rvec.at<double>(0, 0) = cam_params_.at<double>(j * 4 + 1, 0);
+        rvec.at<double>(1, 0) = cam_params_.at<double>(j * 4 + 2, 0);
+        rvec.at<double>(2, 0) = cam_params_.at<double>(j * 4 + 3, 0);
+        Rodrigues(rvec, R2_);
+
+        const ImageFeatures& features1 = features_[i];
+        const ImageFeatures& features2 = features_[j];
+        const MatchesInfo& matches_info = pairwise_matches_[i * num_images_ + j];
+
+        Mat_<double> K1 = Mat::eye(3, 3, CV_64F);
+        K1(0,0) = f1; K1(0,2) = features1.img_size.width * 0.5;
+        K1(1,1) = f1; K1(1,2) = features1.img_size.height * 0.5;
+
+        Mat_<double> K2 = Mat::eye(3, 3, CV_64F);
+        K2(0,0) = f2; K2(0,2) = features2.img_size.width * 0.5;
+        K2(1,1) = f2; K2(1,2) = features2.img_size.height * 0.5;
+
+        Mat_<double> H1 = R1_ * K1.inv();
+        Mat_<double> H2 = R2_ * K2.inv();
+
+        for (size_t k = 0; k < matches_info.matches.size(); ++k)
+        {
+            if (!matches_info.inliers_mask[k])
+                continue;
+
+            const DMatch& m = matches_info.matches[k];
+
+            Point2f p1 = features1.keypoints[m.queryIdx].pt;
+            double x1 = H1(0,0)*p1.x + H1(0,1)*p1.y + H1(0,2);
+            double y1 = H1(1,0)*p1.x + H1(1,1)*p1.y + H1(1,2);
+            double z1 = H1(2,0)*p1.x + H1(2,1)*p1.y + H1(2,2);
+            double len = std::sqrt(x1*x1 + y1*y1 + z1*z1);
+            x1 /= len; y1 /= len; z1 /= len;
+
+            Point2f p2 = features2.keypoints[m.trainIdx].pt;
+            double x2 = H2(0,0)*p2.x + H2(0,1)*p2.y + H2(0,2);
+            double y2 = H2(1,0)*p2.x + H2(1,1)*p2.y + H2(1,2);
+            double z2 = H2(2,0)*p2.x + H2(2,1)*p2.y + H2(2,2);
+            len = std::sqrt(x2*x2 + y2*y2 + z2*z2);
+            x2 /= len; y2 /= len; z2 /= len;
+
+            double mult = std::sqrt(f1 * f2);
+            err.at<double>(3 * match_idx, 0) = mult * (x1 - x2);
+            err.at<double>(3 * match_idx + 1, 0) = mult * (y1 - y2);
+            err.at<double>(3 * match_idx + 2, 0) = mult * (z1 - z2);
+
+            match_idx++;
+        }
+    }
+}
+
+
+void BundleAdjusterRay::calcJacobian(Mat &jac)
+{
+    jac.create(total_num_matches_ * 3, num_images_ * 4, CV_64F);
+
+    double val;
+    const double step = 1e-3;
+
+    for (int i = 0; i < num_images_; ++i)
+    {
+        for (int j = 0; j < 4; ++j)
+        {
+            val = cam_params_.at<double>(i * 4 + j, 0);
+            cam_params_.at<double>(i * 4 + j, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 4 + j, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 4 + j));
+            cam_params_.at<double>(i * 4 + j, 0) = val;
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+void BundleAdjusterAffine::setUpInitialCameraParams(const std::vector<CameraParams> &cameras)
+{
+    cam_params_.create(num_images_ * 6, 1, CV_64F);
+    for (size_t i = 0; i < static_cast<size_t>(num_images_); ++i)
+    {
+        CV_Assert(cameras[i].R.type() == CV_32F);
+        // cameras[i].R is
+        //     a b tx
+        //     c d ty
+        //     0 0 1. (optional)
+        // cam_params_ model for LevMarq is
+        //     (a, b, tx, c, d, ty)
+        Mat params (2, 3, CV_64F, cam_params_.ptr<double>() + i * 6);
+        cameras[i].R.rowRange(0, 2).convertTo(params, CV_64F);
+    }
+}
+
+
+void BundleAdjusterAffine::obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const
+{
+    for (int i = 0; i < num_images_; ++i)
+    {
+        // cameras[i].R will be
+        //     a b tx
+        //     c d ty
+        //     0 0 1
+        cameras[i].R = Mat::eye(3, 3, CV_32F);
+        Mat params = cam_params_.rowRange(i * 6, i * 6 + 6).reshape(1, 2);
+        params.convertTo(cameras[i].R.rowRange(0, 2), CV_32F);
+    }
+}
+
+
+void BundleAdjusterAffine::calcError(Mat &err)
+{
+    err.create(total_num_matches_ * 2, 1, CV_64F);
+
+    int match_idx = 0;
+    for (size_t edge_idx = 0; edge_idx < edges_.size(); ++edge_idx)
+    {
+        size_t i = edges_[edge_idx].first;
+        size_t j = edges_[edge_idx].second;
+
+        const ImageFeatures& features1 = features_[i];
+        const ImageFeatures& features2 = features_[j];
+        const MatchesInfo& matches_info = pairwise_matches_[i * num_images_ + j];
+
+        Mat H1 (2, 3, CV_64F, cam_params_.ptr<double>() + i * 6);
+        Mat H2 (2, 3, CV_64F, cam_params_.ptr<double>() + j * 6);
+
+        // invert H1
+        Mat H1_inv;
+        invertAffineTransform(H1, H1_inv);
+
+        // convert to representation in homogeneous coordinates
+        Mat last_row = Mat::zeros(1, 3, CV_64F);
+        last_row.at<double>(2) = 1.;
+        H1_inv.push_back(last_row);
+        H2.push_back(last_row);
+
+        Mat_<double> H = H1_inv * H2;
+
+        for (size_t k = 0; k < matches_info.matches.size(); ++k)
+        {
+            if (!matches_info.inliers_mask[k])
+                continue;
+
+            const DMatch& m = matches_info.matches[k];
+            const Point2f& p1 = features1.keypoints[m.queryIdx].pt;
+            const Point2f& p2 = features2.keypoints[m.trainIdx].pt;
+
+            double x = H(0,0)*p1.x + H(0,1)*p1.y + H(0,2);
+            double y = H(1,0)*p1.x + H(1,1)*p1.y + H(1,2);
+
+            err.at<double>(2 * match_idx + 0, 0) = p2.x - x;
+            err.at<double>(2 * match_idx + 1, 0) = p2.y - y;
+
+            ++match_idx;
+        }
+    }
+}
+
+
+void BundleAdjusterAffine::calcJacobian(Mat &jac)
+{
+    jac.create(total_num_matches_ * 2, num_images_ * 6, CV_64F);
+
+    double val;
+    const double step = 1e-4;
+
+    for (int i = 0; i < num_images_; ++i)
+    {
+        for (int j = 0; j < 6; ++j)
+        {
+            val = cam_params_.at<double>(i * 6 + j, 0);
+            cam_params_.at<double>(i * 6 + j, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 6 + j, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 6 + j));
+            cam_params_.at<double>(i * 6 + j, 0) = val;
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+void BundleAdjusterAffinePartial::setUpInitialCameraParams(const std::vector<CameraParams> &cameras)
+{
+    cam_params_.create(num_images_ * 4, 1, CV_64F);
+    for (size_t i = 0; i < static_cast<size_t>(num_images_); ++i)
+    {
+        CV_Assert(cameras[i].R.type() == CV_32F);
+        // cameras[i].R is
+        //     a -b tx
+        //     b  a ty
+        //     0  0 1. (optional)
+        // cam_params_ model for LevMarq is
+        //     (a, b, tx, ty)
+        double *params = cam_params_.ptr<double>() + i * 4;
+        params[0] = cameras[i].R.at<float>(0, 0);
+        params[1] = cameras[i].R.at<float>(1, 0);
+        params[2] = cameras[i].R.at<float>(0, 2);
+        params[3] = cameras[i].R.at<float>(1, 2);
+    }
+}
+
+
+void BundleAdjusterAffinePartial::obtainRefinedCameraParams(std::vector<CameraParams> &cameras) const
+{
+    for (size_t i = 0; i < static_cast<size_t>(num_images_); ++i)
+    {
+        // cameras[i].R will be
+        //     a -b tx
+        //     b  a ty
+        //     0  0 1
+        // cam_params_ model for LevMarq is
+        //     (a, b, tx, ty)
+        const double *params = cam_params_.ptr<double>() + i * 4;
+        double transform_buf[9] =
+        {
+            params[0], -params[1], params[2],
+            params[1],  params[0], params[3],
+            0., 0., 1.
+        };
+        Mat transform(3, 3, CV_64F, transform_buf);
+        transform.convertTo(cameras[i].R, CV_32F);
+    }
+}
+
+
+void BundleAdjusterAffinePartial::calcError(Mat &err)
+{
+    err.create(total_num_matches_ * 2, 1, CV_64F);
+
+    int match_idx = 0;
+    for (size_t edge_idx = 0; edge_idx < edges_.size(); ++edge_idx)
+    {
+        size_t i = edges_[edge_idx].first;
+        size_t j = edges_[edge_idx].second;
+
+        const ImageFeatures& features1 = features_[i];
+        const ImageFeatures& features2 = features_[j];
+        const MatchesInfo& matches_info = pairwise_matches_[i * num_images_ + j];
+
+        const double *H1_ptr = cam_params_.ptr<double>() + i * 4;
+        double H1_buf[9] =
+        {
+            H1_ptr[0], -H1_ptr[1], H1_ptr[2],
+            H1_ptr[1],  H1_ptr[0], H1_ptr[3],
+            0., 0., 1.
+        };
+        Mat H1 (3, 3, CV_64F, H1_buf);
+        const double *H2_ptr = cam_params_.ptr<double>() + j * 4;
+        double H2_buf[9] =
+        {
+            H2_ptr[0], -H2_ptr[1], H2_ptr[2],
+            H2_ptr[1],  H2_ptr[0], H2_ptr[3],
+            0., 0., 1.
+        };
+        Mat H2 (3, 3, CV_64F, H2_buf);
+
+        // invert H1
+        Mat H1_aff (H1, Range(0, 2));
+        double H1_inv_buf[6];
+        Mat H1_inv (2, 3, CV_64F, H1_inv_buf);
+        invertAffineTransform(H1_aff, H1_inv);
+        H1_inv.copyTo(H1_aff);
+
+        Mat_<double> H = H1 * H2;
+
+        for (size_t k = 0; k < matches_info.matches.size(); ++k)
+        {
+            if (!matches_info.inliers_mask[k])
+                continue;
+
+            const DMatch& m = matches_info.matches[k];
+            const Point2f& p1 = features1.keypoints[m.queryIdx].pt;
+            const Point2f& p2 = features2.keypoints[m.trainIdx].pt;
+
+            double x = H(0,0)*p1.x + H(0,1)*p1.y + H(0,2);
+            double y = H(1,0)*p1.x + H(1,1)*p1.y + H(1,2);
+
+            err.at<double>(2 * match_idx + 0, 0) = p2.x - x;
+            err.at<double>(2 * match_idx + 1, 0) = p2.y - y;
+
+            ++match_idx;
+        }
+    }
+}
+
+
+void BundleAdjusterAffinePartial::calcJacobian(Mat &jac)
+{
+    jac.create(total_num_matches_ * 2, num_images_ * 4, CV_64F);
+
+    double val;
+    const double step = 1e-4;
+
+    for (int i = 0; i < num_images_; ++i)
+    {
+        for (int j = 0; j < 4; ++j)
+        {
+            val = cam_params_.at<double>(i * 4 + j, 0);
+            cam_params_.at<double>(i * 4 + j, 0) = val - step;
+            calcError(err1_);
+            cam_params_.at<double>(i * 4 + j, 0) = val + step;
+            calcError(err2_);
+            calcDeriv(err1_, err2_, 2 * step, jac.col(i * 4 + j));
+            cam_params_.at<double>(i * 4 + j, 0) = val;
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+WaveCorrectKind autoDetectWaveCorrectKind(const std::vector<Mat> &rmats)
+{
+    std::vector<float> xs, ys;
+    xs.reserve(rmats.size());
+    ys.reserve(rmats.size());
+
+    // Project a [0, 0, 1, 1] point to the camera image frame
+    // Ignore intrinsic parameters and camera translation as they
+    // have little influence
+    // This also means we can simply use "rmat.col(2)" as the
+    // projected point homogeneous coordinate
+    for (const Mat& rmat: rmats)
+    {
+        CV_Assert(rmat.type() == CV_32F);
+        xs.push_back(rmat.at<float>(0, 2) / rmat.at<float>(2, 2));
+        ys.push_back(rmat.at<float>(1, 2) / rmat.at<float>(2, 2));
+    }
+
+    // Calculate the delta between the max and min values for
+    // both the X and Y axis
+    auto min_max_x = std::minmax_element(xs.begin(), xs.end());
+    auto min_max_y = std::minmax_element(ys.begin(), ys.end());
+    double delta_x = *min_max_x.second - *min_max_x.first;
+    double delta_y = *min_max_y.second - *min_max_y.first;
+
+    // If the Y delta is the biggest, it means the images
+    // mostly span along the vertical axis: correct this axis
+    if (delta_y > delta_x)
+    {
+        LOGLN("  using vertical wave correction");
+        return WAVE_CORRECT_VERT;
+    }
+    else
+    {
+        LOGLN("  using horizontal wave correction");
+        return WAVE_CORRECT_HORIZ;
+    }
+}
+
+void waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind)
+{
+    LOGLN("Wave correcting...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+    if (rmats.size() <= 1)
+    {
+        LOGLN("Wave correcting, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+        return;
+    }
+
+    if (kind == WAVE_CORRECT_AUTO)
+    {
+        kind = autoDetectWaveCorrectKind(rmats);
+    }
+
+    Mat moment = Mat::zeros(3, 3, CV_32F);
+    for (size_t i = 0; i < rmats.size(); ++i)
+    {
+        Mat col = rmats[i].col(0);
+        moment += col * col.t();
+    }
+
+    Mat eigen_vals, eigen_vecs;
+    eigen(moment, eigen_vals, eigen_vecs);
+
+    Mat rg1;
+    if (kind == WAVE_CORRECT_HORIZ)
+        rg1 = eigen_vecs.row(2).t();
+    else if (kind == WAVE_CORRECT_VERT)
+        rg1 = eigen_vecs.row(0).t();
+    else
+        CV_Error(cv::Error::StsBadArg, "unsupported kind of wave correction");
+
+    Mat img_k = Mat::zeros(3, 1, CV_32F);
+    for (size_t i = 0; i < rmats.size(); ++i)
+        img_k += rmats[i].col(2);
+    Mat rg0 = rg1.cross(img_k);
+    double rg0_norm = norm(rg0);
+
+    if( rg0_norm <= DBL_MIN )
+    {
+        return;
+    }
+
+    rg0 /= rg0_norm;
+
+    Mat rg2 = rg0.cross(rg1);
+
+    double conf = 0;
+    if (kind == WAVE_CORRECT_HORIZ)
+    {
+        for (size_t i = 0; i < rmats.size(); ++i)
+            conf += rg0.dot(rmats[i].col(0));
+        if (conf < 0)
+        {
+            rg0 *= -1;
+            rg1 *= -1;
+        }
+    }
+    else if (kind == WAVE_CORRECT_VERT)
+    {
+        for (size_t i = 0; i < rmats.size(); ++i)
+            conf -= rg1.dot(rmats[i].col(0));
+        if (conf < 0)
+        {
+            rg0 *= -1;
+            rg1 *= -1;
+        }
+    }
+
+    Mat R = Mat::zeros(3, 3, CV_32F);
+    Mat tmp = R.row(0);
+    Mat(rg0.t()).copyTo(tmp);
+    tmp = R.row(1);
+    Mat(rg1.t()).copyTo(tmp);
+    tmp = R.row(2);
+    Mat(rg2.t()).copyTo(tmp);
+
+    for (size_t i = 0; i < rmats.size(); ++i)
+        rmats[i] = R * rmats[i];
+
+    LOGLN("Wave correcting, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+String matchesGraphAsString(std::vector<String> &paths, std::vector<MatchesInfo> &pairwise_matches,
+                            float conf_threshold)
+{
+    std::stringstream str;
+    str << "graph matches_graph{\n";
+
+    const int num_images = static_cast<int>(paths.size());
+    std::set<std::pair<int,int> > span_tree_edges;
+    DisjointSets comps(num_images);
+
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = 0; j < num_images; ++j)
+        {
+            if (pairwise_matches[i*num_images + j].confidence < conf_threshold)
+                continue;
+            int comp1 = comps.findSetByElem(i);
+            int comp2 = comps.findSetByElem(j);
+            if (comp1 != comp2)
+            {
+                comps.mergeSets(comp1, comp2);
+                span_tree_edges.insert(std::make_pair(i, j));
+            }
+        }
+    }
+
+    for (std::set<std::pair<int,int> >::const_iterator itr = span_tree_edges.begin();
+         itr != span_tree_edges.end(); ++itr)
+    {
+        std::pair<int,int> edge = *itr;
+        if (span_tree_edges.find(edge) != span_tree_edges.end())
+        {
+            String name_src = paths[edge.first];
+            size_t prefix_len = name_src.find_last_of("/\\");
+            if (prefix_len != String::npos) prefix_len++; else prefix_len = 0;
+            name_src = name_src.substr(prefix_len, name_src.size() - prefix_len);
+
+            String name_dst = paths[edge.second];
+            prefix_len = name_dst.find_last_of("/\\");
+            if (prefix_len != String::npos) prefix_len++; else prefix_len = 0;
+            name_dst = name_dst.substr(prefix_len, name_dst.size() - prefix_len);
+
+            int pos = edge.first*num_images + edge.second;
+            str << "\"" << name_src.c_str() << "\" -- \"" << name_dst.c_str() << "\""
+                << "[label=\"Nm=" << pairwise_matches[pos].matches.size()
+                << ", Ni=" << pairwise_matches[pos].num_inliers
+                << ", C=" << pairwise_matches[pos].confidence << "\"];\n";
+        }
+    }
+
+    for (size_t i = 0; i < comps.size.size(); ++i)
+    {
+        if (comps.size[comps.findSetByElem((int)i)] == 1)
+        {
+            String name = paths[i];
+            size_t prefix_len = name.find_last_of("/\\");
+            if (prefix_len != String::npos) prefix_len++; else prefix_len = 0;
+            name = name.substr(prefix_len, name.size() - prefix_len);
+            str << "\"" << name.c_str() << "\";\n";
+        }
+    }
+
+    str << "}";
+    return str.str().c_str();
+}
+
+std::vector<int> leaveBiggestComponent(std::vector<ImageFeatures> &features,  std::vector<MatchesInfo> &pairwise_matches,
+                                      float conf_threshold)
+{
+    const int num_images = static_cast<int>(features.size());
+
+    DisjointSets comps(num_images);
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = 0; j < num_images; ++j)
+        {
+            if (pairwise_matches[i*num_images + j].confidence < conf_threshold)
+                continue;
+            int comp1 = comps.findSetByElem(i);
+            int comp2 = comps.findSetByElem(j);
+            if (comp1 != comp2)
+                comps.mergeSets(comp1, comp2);
+        }
+    }
+
+    int max_comp = static_cast<int>(std::max_element(comps.size.begin(), comps.size.end()) - comps.size.begin());
+
+    std::vector<int> indices;
+    std::vector<int> indices_removed;
+    for (int i = 0; i < num_images; ++i)
+        if (comps.findSetByElem(i) == max_comp)
+            indices.push_back(i);
+        else
+            indices_removed.push_back(i);
+
+    std::vector<ImageFeatures> features_subset;
+    std::vector<MatchesInfo> pairwise_matches_subset;
+    for (size_t i = 0; i < indices.size(); ++i)
+    {
+        features_subset.push_back(features[indices[i]]);
+        for (size_t j = 0; j < indices.size(); ++j)
+        {
+            pairwise_matches_subset.push_back(pairwise_matches[indices[i]*num_images + indices[j]]);
+            pairwise_matches_subset.back().src_img_idx = static_cast<int>(i);
+            pairwise_matches_subset.back().dst_img_idx = static_cast<int>(j);
+        }
+    }
+
+    if (static_cast<int>(features_subset.size()) == num_images)
+        return indices;
+
+    LOG("Removed some images, because can't match them or there are too similar images: (");
+    LOG(indices_removed[0] + 1);
+    for (size_t i = 1; i < indices_removed.size(); ++i)
+        LOG(", " << indices_removed[i]+1);
+    LOGLN(").");
+    LOGLN("Try to decrease the match confidence threshold and/or check if you're stitching duplicates.");
+
+    features = features_subset;
+    pairwise_matches = pairwise_matches_subset;
+
+    return indices;
+}
+
+
+void findMaxSpanningTree(int num_images, const std::vector<MatchesInfo> &pairwise_matches,
+                             Graph &span_tree, std::vector<int> &centers)
+{
+    Graph graph(num_images);
+    std::vector<GraphEdge> edges;
+
+    // Construct images graph and remember its edges
+    for (int i = 0; i < num_images; ++i)
+    {
+        for (int j = 0; j < num_images; ++j)
+        {
+            if (pairwise_matches[i * num_images + j].H.empty())
+                continue;
+            float conf = static_cast<float>(pairwise_matches[i * num_images + j].num_inliers);
+            graph.addEdge(i, j, conf);
+            edges.push_back(GraphEdge(i, j, conf));
+        }
+    }
+
+    DisjointSets comps(num_images);
+    span_tree.create(num_images);
+    std::vector<int> span_tree_powers(num_images, 0);
+
+    // Find maximum spanning tree
+    sort(edges.begin(), edges.end(), std::greater<GraphEdge>());
+    for (size_t i = 0; i < edges.size(); ++i)
+    {
+        int comp1 = comps.findSetByElem(edges[i].from);
+        int comp2 = comps.findSetByElem(edges[i].to);
+        if (comp1 != comp2)
+        {
+            comps.mergeSets(comp1, comp2);
+            span_tree.addEdge(edges[i].from, edges[i].to, edges[i].weight);
+            span_tree.addEdge(edges[i].to, edges[i].from, edges[i].weight);
+            span_tree_powers[edges[i].from]++;
+            span_tree_powers[edges[i].to]++;
+        }
+    }
+
+    // Find spanning tree leafs
+    std::vector<int> span_tree_leafs;
+    for (int i = 0; i < num_images; ++i)
+        if (span_tree_powers[i] == 1)
+            span_tree_leafs.push_back(i);
+
+    // Find maximum distance from each spanning tree vertex
+    std::vector<int> max_dists(num_images, 0);
+    std::vector<int> cur_dists;
+    for (size_t i = 0; i < span_tree_leafs.size(); ++i)
+    {
+        cur_dists.assign(num_images, 0);
+        span_tree.walkBreadthFirst(span_tree_leafs[i], IncDistance(cur_dists));
+        for (int j = 0; j < num_images; ++j)
+            max_dists[j] = std::max(max_dists[j], cur_dists[j]);
+    }
+
+    // Find min-max distance
+    int min_max_dist = max_dists[0];
+    for (int i = 1; i < num_images; ++i)
+        if (min_max_dist > max_dists[i])
+            min_max_dist = max_dists[i];
+
+    // Find spanning tree centers
+    centers.clear();
+    for (int i = 0; i < num_images; ++i)
+        if (max_dists[i] == min_max_dist)
+            centers.push_back(i);
+    CV_Assert(centers.size() > 0 && centers.size() <= 2);
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/opencl/multibandblend.cl b/upstream/opencv/modules/stitching/src/opencl/multibandblend.cl
new file mode 100644
index 0000000..8273ed1
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/opencl/multibandblend.cl
@@ -0,0 +1,298 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2014, Itseez, Inc, all rights reserved.
+
+//
+// Common preprocessors macro
+//
+
+//
+// TODO: Move this common code into "header" file
+//
+
+#ifndef NL // New Line: for preprocessor debugging
+#define NL
+#endif
+
+#define REF(x) x
+#define __CAT(x, y) x##y
+#define CAT(x, y) __CAT(x, y)
+
+//
+// All matrixes are come with this description ("name" is a name of matrix):
+// * name_CN - number of channels (1,2,3,4)
+// * name_DEPTH - numeric value of CV_MAT_DEPTH(type). See CV_8U, CV_32S, etc macro below.
+//
+// Currently we also pass these attributes (to reduce this macro block):
+// * name_T - datatype (int, float, uchar4, float4)
+// * name_T1 - datatype for one channel (int, float, uchar).
+//   It is equal to result of "T1(name_T)" macro
+// * name_TSIZE - CV_ELEM_SIZE(type).
+//   We can't use sizeof(name_T) here, because sizeof(float3) is usually equal to 8, not 6.
+// * name_T1SIZE - CV_ELEM_SIZE1(type)
+//
+
+//
+// Usage sample:
+//
+// #define workType TYPE(float, src_CN)
+// #define convertToWorkType CONVERT_TO(workType)
+// #define convertWorkTypeToDstType CONVERT(workType, dst_T)
+//
+// __kernel void kernelFn(DECLARE_MAT_ARG(src), DECLARE_MAT_ARG(dst))
+// {
+//     const int x = get_global_id(0);
+//     const int y = get_global_id(1);
+//
+//     if (x < srcWidth && y < srcHeight)
+//     {
+//         int src_byteOffset = MAT_BYTE_OFFSET(src, x, y);
+//         int dst_byteOffset = MAT_BYTE_OFFSET(dst, x, y);
+//         workType value = convertToWorkType(LOAD_MAT_AT(src, src_byteOffset));
+//
+//         ... value processing ...
+//
+//         STORE_MAT_AT(dst, dst_byteOffset, convertWorkTypeToDstType(value));
+//     }
+// }
+//
+
+#define DECLARE_MAT_ARG(name) \
+    __global uchar* restrict name ## Ptr, \
+    int name ## StepBytes, \
+    int name ## Offset, \
+    int name ## Height, \
+    int name ## Width NL
+
+#define MAT_BYTE_OFFSET(name, x, y) mad24((y)/* + name ## OffsetY*/, name ## StepBytes, ((x)/* + name ## OffsetX*/) * (int)(name ## _TSIZE) + name ## Offset)
+#define MAT_RELATIVE_BYTE_OFFSET(name, x, y) mad24(y, name ## StepBytes, (x) * (int)(name ## _TSIZE))
+
+#define __LOAD_MAT_AT(name, byteOffset) *((const __global name ## _T*)(name ## Ptr + (byteOffset)))
+#define __vload_CN__(name_cn) vload ## name_cn
+#define __vload_CN_(name_cn) __vload_CN__(name_cn)
+#define __vload_CN(name) __vload_CN_(name ## _CN)
+#define __LOAD_MAT_AT_vload(name, byteOffset) __vload_CN(name)(0, ((const __global name ## _T1*)(name ## Ptr + (byteOffset))))
+#define __LOAD_MAT_AT_1 __LOAD_MAT_AT
+#define __LOAD_MAT_AT_2 __LOAD_MAT_AT
+#define __LOAD_MAT_AT_3 __LOAD_MAT_AT_vload
+#define __LOAD_MAT_AT_4 __LOAD_MAT_AT
+#define __LOAD_MAT_AT_CN__(name_cn) __LOAD_MAT_AT_ ## name_cn
+#define __LOAD_MAT_AT_CN_(name_cn) __LOAD_MAT_AT_CN__(name_cn)
+#define __LOAD_MAT_AT_CN(name) __LOAD_MAT_AT_CN_(name ## _CN)
+#define LOAD_MAT_AT(name, byteOffset) __LOAD_MAT_AT_CN(name)(name, byteOffset)
+
+#define __STORE_MAT_AT(name, byteOffset, v) *((__global name ## _T*)(name ## Ptr + (byteOffset))) = v
+#define __vstore_CN__(name_cn) vstore ## name_cn
+#define __vstore_CN_(name_cn) __vstore_CN__(name_cn)
+#define __vstore_CN(name) __vstore_CN_(name ## _CN)
+#define __STORE_MAT_AT_vstore(name, byteOffset, v) __vstore_CN(name)(v, 0, ((__global name ## _T1*)(name ## Ptr + (byteOffset))))
+#define __STORE_MAT_AT_1 __STORE_MAT_AT
+#define __STORE_MAT_AT_2 __STORE_MAT_AT
+#define __STORE_MAT_AT_3 __STORE_MAT_AT_vstore
+#define __STORE_MAT_AT_4 __STORE_MAT_AT
+#define __STORE_MAT_AT_CN__(name_cn) __STORE_MAT_AT_ ## name_cn
+#define __STORE_MAT_AT_CN_(name_cn) __STORE_MAT_AT_CN__(name_cn)
+#define __STORE_MAT_AT_CN(name) __STORE_MAT_AT_CN_(name ## _CN)
+#define STORE_MAT_AT(name, byteOffset, v) __STORE_MAT_AT_CN(name)(name, byteOffset, v)
+
+#define T1_uchar uchar
+#define T1_uchar2 uchar
+#define T1_uchar3 uchar
+#define T1_uchar4 uchar
+#define T1_char char
+#define T1_char2 char
+#define T1_char3 char
+#define T1_char4 char
+#define T1_ushort ushort
+#define T1_ushort2 ushort
+#define T1_ushort3 ushort
+#define T1_ushort4 ushort
+#define T1_short short
+#define T1_short2 short
+#define T1_short3 short
+#define T1_short4 short
+#define T1_int int
+#define T1_int2 int
+#define T1_int3 int
+#define T1_int4 int
+#define T1_float float
+#define T1_float2 float
+#define T1_float3 float
+#define T1_float4 float
+#define T1_double double
+#define T1_double2 double
+#define T1_double3 double
+#define T1_double4 double
+#define T1(type) REF(CAT(T1_, REF(type)))
+
+#define uchar1 uchar
+#define char1 char
+#define short1 short
+#define ushort1 ushort
+#define int1 int
+#define float1 float
+#define double1 double
+#define TYPE(type, cn) REF(CAT(REF(type), REF(cn)))
+
+#define __CONVERT_MODE_uchar_uchar __NO_CONVERT
+#define __CONVERT_MODE_uchar_char __CONVERT_sat
+#define __CONVERT_MODE_uchar_ushort __CONVERT
+#define __CONVERT_MODE_uchar_short __CONVERT
+#define __CONVERT_MODE_uchar_int __CONVERT
+#define __CONVERT_MODE_uchar_float __CONVERT
+#define __CONVERT_MODE_uchar_double __CONVERT
+#define __CONVERT_MODE_char_uchar __CONVERT_sat
+#define __CONVERT_MODE_char_char __NO_CONVERT
+#define __CONVERT_MODE_char_ushort __CONVERT_sat
+#define __CONVERT_MODE_char_short __CONVERT
+#define __CONVERT_MODE_char_int __CONVERT
+#define __CONVERT_MODE_char_float __CONVERT
+#define __CONVERT_MODE_char_double __CONVERT
+#define __CONVERT_MODE_ushort_uchar __CONVERT_sat
+#define __CONVERT_MODE_ushort_char __CONVERT_sat
+#define __CONVERT_MODE_ushort_ushort __NO_CONVERT
+#define __CONVERT_MODE_ushort_short __CONVERT_sat
+#define __CONVERT_MODE_ushort_int __CONVERT
+#define __CONVERT_MODE_ushort_float __CONVERT
+#define __CONVERT_MODE_ushort_double __CONVERT
+#define __CONVERT_MODE_short_uchar __CONVERT_sat
+#define __CONVERT_MODE_short_char __CONVERT_sat
+#define __CONVERT_MODE_short_ushort __CONVERT_sat
+#define __CONVERT_MODE_short_short __NO_CONVERT
+#define __CONVERT_MODE_short_int __CONVERT
+#define __CONVERT_MODE_short_float __CONVERT
+#define __CONVERT_MODE_short_double __CONVERT
+#define __CONVERT_MODE_int_uchar __CONVERT_sat
+#define __CONVERT_MODE_int_char __CONVERT_sat
+#define __CONVERT_MODE_int_ushort __CONVERT_sat
+#define __CONVERT_MODE_int_short __CONVERT_sat
+#define __CONVERT_MODE_int_int __NO_CONVERT
+#define __CONVERT_MODE_int_float __CONVERT
+#define __CONVERT_MODE_int_double __CONVERT
+#define __CONVERT_MODE_float_uchar __CONVERT_sat_rte
+#define __CONVERT_MODE_float_char __CONVERT_sat_rte
+#define __CONVERT_MODE_float_ushort __CONVERT_sat_rte
+#define __CONVERT_MODE_float_short __CONVERT_sat_rte
+#define __CONVERT_MODE_float_int __CONVERT_rte
+#define __CONVERT_MODE_float_float __NO_CONVERT
+#define __CONVERT_MODE_float_double __CONVERT
+#define __CONVERT_MODE_double_uchar __CONVERT_sat_rte
+#define __CONVERT_MODE_double_char __CONVERT_sat_rte
+#define __CONVERT_MODE_double_ushort __CONVERT_sat_rte
+#define __CONVERT_MODE_double_short __CONVERT_sat_rte
+#define __CONVERT_MODE_double_int __CONVERT_rte
+#define __CONVERT_MODE_double_float __CONVERT
+#define __CONVERT_MODE_double_double __NO_CONVERT
+#define __CONVERT_MODE(srcType, dstType) CAT(__CONVERT_MODE_, CAT(REF(T1(srcType)), CAT(_, REF(T1(dstType)))))
+
+#define __ROUND_MODE__NO_CONVERT
+#define __ROUND_MODE__CONVERT // nothing
+#define __ROUND_MODE__CONVERT_rte _rte
+#define __ROUND_MODE__CONVERT_sat _sat
+#define __ROUND_MODE__CONVERT_sat_rte _sat_rte
+#define ROUND_MODE(srcType, dstType) CAT(__ROUND_MODE_, __CONVERT_MODE(srcType, dstType))
+
+#define __CONVERT_ROUND(dstType, roundMode) CAT(CAT(convert_, REF(dstType)), roundMode)
+#define __NO_CONVERT(dstType) // nothing
+#define __CONVERT(dstType) __CONVERT_ROUND(dstType,)
+#define __CONVERT_rte(dstType) __CONVERT_ROUND(dstType,_rte)
+#define __CONVERT_sat(dstType) __CONVERT_ROUND(dstType,_sat)
+#define __CONVERT_sat_rte(dstType) __CONVERT_ROUND(dstType,_sat_rte)
+#define CONVERT(srcType, dstType) REF(__CONVERT_MODE(srcType,dstType))(dstType)
+#define CONVERT_TO(dstType) __CONVERT_ROUND(dstType,)
+
+// OpenCV depths
+#define CV_8U   0
+#define CV_8S   1
+#define CV_16U  2
+#define CV_16S  3
+#define CV_32S  4
+#define CV_32F  5
+#define CV_64F  6
+
+//
+// End of common preprocessors macro
+//
+
+
+
+#if defined(DEFINE_feed)
+
+#define workType TYPE(weight_T1, src_CN)
+
+#if src_DEPTH == 3 && src_CN == 3
+#define convertSrcToWorkType convert_float3
+#else
+#define convertSrcToWorkType CONVERT_TO(workType)
+#endif
+
+#if dst_DEPTH == 3 && dst_CN == 3
+#define convertToDstType convert_short3
+#else
+#define convertToDstType CONVERT_TO(dst_T) // sat_rte provides incompatible results with CPU path
+#endif
+
+__kernel void feed(
+        DECLARE_MAT_ARG(src), DECLARE_MAT_ARG(weight),
+        DECLARE_MAT_ARG(dst), DECLARE_MAT_ARG(dstWeight)
+)
+{
+    const int x = get_global_id(0);
+    const int y = get_global_id(1);
+
+    if (x < srcWidth && y < srcHeight)
+    {
+        int src_byteOffset = MAT_BYTE_OFFSET(src, x, y);
+        int weight_byteOffset = MAT_BYTE_OFFSET(weight, x, y);
+        int dst_byteOffset = MAT_BYTE_OFFSET(dst, x, y);
+        int dstWeight_byteOffset = MAT_BYTE_OFFSET(dstWeight, x, y);
+
+        weight_T w = LOAD_MAT_AT(weight, weight_byteOffset);
+        workType src_value = convertSrcToWorkType(LOAD_MAT_AT(src, src_byteOffset));
+        STORE_MAT_AT(dst, dst_byteOffset, LOAD_MAT_AT(dst, dst_byteOffset) + convertToDstType(src_value * w));
+        STORE_MAT_AT(dstWeight, dstWeight_byteOffset, LOAD_MAT_AT(dstWeight, dstWeight_byteOffset) + w);
+    }
+}
+
+#endif
+
+#if defined(DEFINE_normalizeUsingWeightMap)
+
+#if mat_DEPTH == 3 && mat_CN == 3
+#define workType float3
+#define convertSrcToWorkType convert_float3
+#define convertToDstType convert_short3
+#else
+#define workType TYPE(weight_T1, mat_CN)
+#define convertSrcToWorkType CONVERT_TO(workType)
+#define convertToDstType CONVERT_TO(mat_T) // sat_rte provides incompatible results with CPU path
+#endif
+
+#if weight_DEPTH >= CV_32F
+#define WEIGHT_EPS 1e-5f
+#else
+#define WEIGHT_EPS 0
+#endif
+
+__kernel void normalizeUsingWeightMap(
+        DECLARE_MAT_ARG(mat), DECLARE_MAT_ARG(weight)
+)
+{
+    const int x = get_global_id(0);
+    const int y = get_global_id(1);
+
+    if (x < matWidth && y < matHeight)
+    {
+        int mat_byteOffset = MAT_BYTE_OFFSET(mat, x, y);
+        int weight_byteOffset = MAT_BYTE_OFFSET(weight, x, y);
+
+        weight_T w = LOAD_MAT_AT(weight, weight_byteOffset);
+        workType value = convertSrcToWorkType(LOAD_MAT_AT(mat, mat_byteOffset));
+        value = value / (w + WEIGHT_EPS);
+        STORE_MAT_AT(mat, mat_byteOffset, convertToDstType(value));
+    }
+}
+
+#endif
diff --git a/upstream/opencv/modules/stitching/src/opencl/warpers.cl b/upstream/opencv/modules/stitching/src/opencl/warpers.cl
new file mode 100644
index 0000000..a8f04a6
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/opencl/warpers.cl
@@ -0,0 +1,169 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+__kernel void buildWarpPlaneMaps(__global uchar * xmapptr, int xmap_step, int xmap_offset,
+                                 __global uchar * ymapptr, int ymap_step, int ymap_offset, int rows, int cols,
+                                 __constant float * ck_rinv, __constant float * ct,
+                                 int tl_u, int tl_v, float scale, int rowsPerWI)
+{
+    int du = get_global_id(0);
+    int dv0 = get_global_id(1) * rowsPerWI;
+
+    if (du < cols)
+    {
+        int xmap_index = mad24(dv0, xmap_step, mad24(du, (int)sizeof(float), xmap_offset));
+        int ymap_index = mad24(dv0, ymap_step, mad24(du, (int)sizeof(float), ymap_offset));
+
+        float u = tl_u + du;
+        float x_ = fma(u, scale, -ct[0]);
+        float ct1 = 1 - ct[2];
+
+        for (int dv = dv0, dv1 = min(rows, dv0 + rowsPerWI); dv < dv1; ++dv, xmap_index += xmap_step,
+            ymap_index += ymap_step)
+        {
+            __global float * xmap = (__global float *)(xmapptr + xmap_index);
+            __global float * ymap = (__global float *)(ymapptr + ymap_index);
+
+            float v = tl_v + dv;
+            float y_ = fma(v, scale, -ct[1]);
+
+            float x = fma(ck_rinv[0], x_, fma(ck_rinv[1], y_, ck_rinv[2] * ct1));
+            float y = fma(ck_rinv[3], x_, fma(ck_rinv[4], y_, ck_rinv[5] * ct1));
+            float z = fma(ck_rinv[6], x_, fma(ck_rinv[7], y_, ck_rinv[8] * ct1));
+
+            if (z != 0)
+                x /= z, y /= z;
+            else
+                x = y = -1;
+
+            xmap[0] = x;
+            ymap[0] = y;
+        }
+    }
+}
+
+__kernel void buildWarpCylindricalMaps(__global uchar * xmapptr, int xmap_step, int xmap_offset,
+                                       __global uchar * ymapptr, int ymap_step, int ymap_offset, int rows, int cols,
+                                       __constant float * ck_rinv, int tl_u, int tl_v, float scale, int rowsPerWI)
+{
+    int du = get_global_id(0);
+    int dv0 = get_global_id(1) * rowsPerWI;
+
+    if (du < cols)
+    {
+        int xmap_index = mad24(dv0, xmap_step, mad24(du, (int)sizeof(float), xmap_offset));
+        int ymap_index = mad24(dv0, ymap_step, mad24(du, (int)sizeof(float), ymap_offset));
+
+        float u = (tl_u + du) * scale;
+        float x_, z_;
+        x_ = sincos(u, &z_);
+
+        for (int dv = dv0, dv1 = min(rows, dv0 + rowsPerWI); dv < dv1; ++dv, xmap_index += xmap_step,
+            ymap_index += ymap_step)
+        {
+            __global float * xmap = (__global float *)(xmapptr + xmap_index);
+            __global float * ymap = (__global float *)(ymapptr + ymap_index);
+
+            float y_ = (tl_v + dv) * scale;
+
+            float x, y, z;
+            x = fma(ck_rinv[0], x_, fma(ck_rinv[1], y_, ck_rinv[2] * z_));
+            y = fma(ck_rinv[3], x_, fma(ck_rinv[4], y_, ck_rinv[5] * z_));
+            z = fma(ck_rinv[6], x_, fma(ck_rinv[7], y_, ck_rinv[8] * z_));
+
+            if (z > 0)
+                x /= z, y /= z;
+            else
+                x = y = -1;
+
+            xmap[0] = x;
+            ymap[0] = y;
+        }
+    }
+}
+
+__kernel void buildWarpSphericalMaps(__global uchar * xmapptr, int xmap_step, int xmap_offset,
+                                     __global uchar * ymapptr, int ymap_step, int ymap_offset, int rows, int cols,
+                                     __constant float * ck_rinv, int tl_u, int tl_v, float scale, int rowsPerWI)
+{
+    int du = get_global_id(0);
+    int dv0 = get_global_id(1) * rowsPerWI;
+
+    if (du < cols)
+    {
+        int xmap_index = mad24(dv0, xmap_step, mad24(du, (int)sizeof(float), xmap_offset));
+        int ymap_index = mad24(dv0, ymap_step, mad24(du, (int)sizeof(float), ymap_offset));
+
+        float u = (tl_u + du) * scale;
+        float cosu, sinu = sincos(u, &cosu);
+
+        for (int dv = dv0, dv1 = min(rows, dv0 + rowsPerWI); dv < dv1; ++dv, xmap_index += xmap_step,
+            ymap_index += ymap_step)
+        {
+            __global float * xmap = (__global float *)(xmapptr + xmap_index);
+            __global float * ymap = (__global float *)(ymapptr + ymap_index);
+
+            float v = (tl_v + dv) * scale;
+
+            float cosv, sinv = sincos(v, &cosv);
+            float x_ = sinv * sinu;
+            float y_ = -cosv;
+            float z_ = sinv * cosu;
+
+            float x, y, z;
+            x = fma(ck_rinv[0], x_, fma(ck_rinv[1], y_, ck_rinv[2] * z_));
+            y = fma(ck_rinv[3], x_, fma(ck_rinv[4], y_, ck_rinv[5] * z_));
+            z = fma(ck_rinv[6], x_, fma(ck_rinv[7], y_, ck_rinv[8] * z_));
+
+            if (z > 0)
+                x /= z, y /= z;
+            else
+                x = y = -1;
+
+            xmap[0] = x;
+            ymap[0] = y;
+        }
+    }
+}
diff --git a/upstream/opencv/modules/stitching/src/precomp.hpp b/upstream/opencv/modules/stitching/src/precomp.hpp
new file mode 100644
index 0000000..b097117
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/precomp.hpp
@@ -0,0 +1,95 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_STITCHING_PRECOMP_H__
+#define __OPENCV_STITCHING_PRECOMP_H__
+
+#include "opencv2/opencv_modules.hpp"
+
+#include <array>
+#include <vector>
+#include <algorithm>
+#include <utility>
+#include <set>
+#include <functional>
+#include <sstream>
+#include <iostream>
+#include <cmath>
+#include "opencv2/core.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/stitching.hpp"
+#include "opencv2/stitching/detail/autocalib.hpp"
+#include "opencv2/stitching/detail/blenders.hpp"
+#include "opencv2/stitching/detail/timelapsers.hpp"
+#include "opencv2/stitching/detail/camera.hpp"
+#include "opencv2/stitching/detail/exposure_compensate.hpp"
+#include "opencv2/stitching/detail/matchers.hpp"
+#include "opencv2/stitching/detail/motion_estimators.hpp"
+#include "opencv2/stitching/detail/seam_finders.hpp"
+#include "opencv2/stitching/detail/util.hpp"
+#include "opencv2/stitching/detail/warpers.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features.hpp"
+#include "opencv2/geometry.hpp"
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+#  include "opencv2/cudaarithm.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_CUDAWARPING
+#  include "opencv2/cudawarping.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_CUDAFEATURES2D
+#  include "opencv2/cudafeatures2d.hpp"
+#endif
+
+#ifdef HAVE_OPENCV_CUDALEGACY
+#  include "opencv2/cudalegacy.hpp"
+#endif
+
+#include "opencv2/core/private.hpp"
+
+#include "util_log.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/stitching/src/seam_finders.cpp b/upstream/opencv/modules/stitching/src/seam_finders.cpp
new file mode 100644
index 0000000..0db6360
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/seam_finders.cpp
@@ -0,0 +1,1717 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/geometry/detail/gcgraph.hpp"
+#include <map>
+
+namespace cv {
+namespace detail {
+
+Ptr<SeamFinder> SeamFinder::createDefault(int type)
+{
+    if (type == NO)
+        return makePtr<NoSeamFinder>();
+    if (type == VORONOI_SEAM)
+        return makePtr<VoronoiSeamFinder>();
+    if (type == DP_SEAM)
+        return makePtr<DpSeamFinder>();
+    CV_Error(Error::StsBadArg, "unsupported seam finder method");
+}
+
+
+void PairwiseSeamFinder::find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                              std::vector<UMat> &masks)
+{
+    LOGLN("Finding seams...");
+    if (src.size() == 0)
+        return;
+
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    images_ = src;
+    sizes_.resize(src.size());
+    for (size_t i = 0; i < src.size(); ++i)
+        sizes_[i] = src[i].size();
+    corners_ = corners;
+    masks_ = masks;
+    run();
+
+    LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+
+void PairwiseSeamFinder::run()
+{
+    for (size_t i = 0; i < sizes_.size() - 1; ++i)
+    {
+        for (size_t j = i + 1; j < sizes_.size(); ++j)
+        {
+            Rect roi;
+            if (overlapRoi(corners_[i], corners_[j], sizes_[i], sizes_[j], roi))
+                findInPair(i, j, roi);
+        }
+    }
+}
+
+void VoronoiSeamFinder::find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                             std::vector<UMat> &masks)
+{
+    PairwiseSeamFinder::find(src, corners, masks);
+}
+
+void VoronoiSeamFinder::find(const std::vector<Size> &sizes, const std::vector<Point> &corners,
+                             std::vector<UMat> &masks)
+{
+    LOGLN("Finding seams...");
+    if (sizes.size() == 0)
+        return;
+
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    sizes_ = sizes;
+    corners_ = corners;
+    masks_ = masks;
+    run();
+
+    LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+
+void VoronoiSeamFinder::findInPair(size_t first, size_t second, Rect roi)
+{
+    const int gap = 10;
+    Mat submask1(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+    Mat submask2(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+
+    Size img1 = sizes_[first], img2 = sizes_[second];
+    Mat mask1 = masks_[first].getMat(ACCESS_RW), mask2 = masks_[second].getMat(ACCESS_RW);
+    Point tl1 = corners_[first], tl2 = corners_[second];
+
+    // Cut submasks with some gap
+    for (int y = -gap; y < roi.height + gap; ++y)
+    {
+        for (int x = -gap; x < roi.width + gap; ++x)
+        {
+            int y1 = roi.y - tl1.y + y;
+            int x1 = roi.x - tl1.x + x;
+            if (y1 >= 0 && x1 >= 0 && y1 < img1.height && x1 < img1.width)
+                submask1.at<uchar>(y + gap, x + gap) = mask1.at<uchar>(y1, x1);
+            else
+                submask1.at<uchar>(y + gap, x + gap) = 0;
+
+            int y2 = roi.y - tl2.y + y;
+            int x2 = roi.x - tl2.x + x;
+            if (y2 >= 0 && x2 >= 0 && y2 < img2.height && x2 < img2.width)
+                submask2.at<uchar>(y + gap, x + gap) = mask2.at<uchar>(y2, x2);
+            else
+                submask2.at<uchar>(y + gap, x + gap) = 0;
+        }
+    }
+
+    Mat collision = (submask1 != 0) & (submask2 != 0);
+    Mat unique1 = submask1.clone(); unique1.setTo(0, collision);
+    Mat unique2 = submask2.clone(); unique2.setTo(0, collision);
+
+    Mat dist1, dist2;
+    distanceTransform(unique1 == 0, dist1, DIST_L1, 3);
+    distanceTransform(unique2 == 0, dist2, DIST_L1, 3);
+
+    Mat seam = dist1 < dist2;
+
+    for (int y = 0; y < roi.height; ++y)
+    {
+        for (int x = 0; x < roi.width; ++x)
+        {
+            if (seam.at<uchar>(y + gap, x + gap))
+                mask2.at<uchar>(roi.y - tl2.y + y, roi.x - tl2.x + x) = 0;
+            else
+                mask1.at<uchar>(roi.y - tl1.y + y, roi.x - tl1.x + x) = 0;
+        }
+    }
+}
+
+
+DpSeamFinder::DpSeamFinder(CostFunction costFunc) : costFunc_(costFunc), ncomps_(0) {}
+
+DpSeamFinder::DpSeamFinder(String costFunc)
+{
+    ncomps_ = 0;
+    if (costFunc == "COLOR")
+        costFunc_ = COLOR;
+    else if (costFunc == "COLOR_GRAD")
+        costFunc_ = COLOR_GRAD;
+    else
+        CV_Error(cv::Error::StsError, "Unknown cost function");
+}
+
+void DpSeamFinder::setCostFunction(String costFunc)
+{
+    if (costFunc == "COLOR")
+        costFunc_ = COLOR;
+    else if (costFunc == "COLOR_GRAD")
+        costFunc_ = COLOR_GRAD;
+    else
+        CV_Error(cv::Error::StsError, "Unknown cost function");
+}
+
+void DpSeamFinder::find(const std::vector<UMat> &src, const std::vector<Point> &corners, std::vector<UMat> &masks)
+{
+    LOGLN("Finding seams...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    if (src.size() == 0)
+        return;
+
+    std::vector<std::pair<size_t, size_t> > pairs;
+
+    for (size_t i = 0; i+1 < src.size(); ++i)
+        for (size_t j = i+1; j < src.size(); ++j)
+            pairs.push_back(std::make_pair(i, j));
+
+    {
+        std::vector<Mat> _src(src.size());
+        for (size_t i = 0; i < src.size(); ++i) _src[i] = src[i].getMat(ACCESS_READ);
+        sort(pairs.begin(), pairs.end(), ImagePairLess(_src, corners));
+    }
+    std::reverse(pairs.begin(), pairs.end());
+
+    for (size_t i = 0; i < pairs.size(); ++i)
+    {
+        size_t i0 = pairs[i].first, i1 = pairs[i].second;
+        Mat mask0 = masks[i0].getMat(ACCESS_RW), mask1 = masks[i1].getMat(ACCESS_RW);
+        process(src[i0].getMat(ACCESS_READ), src[i1].getMat(ACCESS_READ), corners[i0], corners[i1], mask0, mask1);
+    }
+
+    LOGLN("Finding seams, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+}
+
+
+void DpSeamFinder::process(
+        const Mat &image1, const Mat &image2, Point tl1, Point tl2,
+        Mat &mask1, Mat &mask2)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(image1.size() == mask1.size());
+    CV_Assert(image2.size() == mask2.size());
+
+    Point intersectTl(std::max(tl1.x, tl2.x), std::max(tl1.y, tl2.y));
+
+    Point intersectBr(std::min(tl1.x + image1.cols, tl2.x + image2.cols),
+                      std::min(tl1.y + image1.rows, tl2.y + image2.rows));
+
+    if (intersectTl.x >= intersectBr.x || intersectTl.y >= intersectBr.y)
+        return; // there are no conflicts
+
+    unionTl_ = Point(std::min(tl1.x, tl2.x), std::min(tl1.y, tl2.y));
+
+    unionBr_ = Point(std::max(tl1.x + image1.cols, tl2.x + image2.cols),
+                     std::max(tl1.y + image1.rows, tl2.y + image2.rows));
+
+    unionSize_ = Size(unionBr_.x - unionTl_.x, unionBr_.y - unionTl_.y);
+
+    mask1_ = Mat::zeros(unionSize_, CV_8U);
+    mask2_ = Mat::zeros(unionSize_, CV_8U);
+
+    Mat tmp = mask1_(Rect(tl1.x - unionTl_.x, tl1.y - unionTl_.y, mask1.cols, mask1.rows));
+    mask1.copyTo(tmp);
+
+    tmp = mask2_(Rect(tl2.x - unionTl_.x, tl2.y - unionTl_.y, mask2.cols, mask2.rows));
+    mask2.copyTo(tmp);
+
+    // find both images contour masks
+
+    contour1mask_ = Mat::zeros(unionSize_, CV_8U);
+    contour2mask_ = Mat::zeros(unionSize_, CV_8U);
+
+    for (int y = 0; y < unionSize_.height; ++y)
+    {
+        for (int x = 0; x < unionSize_.width; ++x)
+        {
+            if (mask1_(y, x) &&
+                ((x == 0 || !mask1_(y, x-1)) || (x == unionSize_.width-1 || !mask1_(y, x+1)) ||
+                 (y == 0 || !mask1_(y-1, x)) || (y == unionSize_.height-1 || !mask1_(y+1, x))))
+            {
+                contour1mask_(y, x) = 255;
+            }
+
+            if (mask2_(y, x) &&
+                ((x == 0 || !mask2_(y, x-1)) || (x == unionSize_.width-1 || !mask2_(y, x+1)) ||
+                 (y == 0 || !mask2_(y-1, x)) || (y == unionSize_.height-1 || !mask2_(y+1, x))))
+            {
+                contour2mask_(y, x) = 255;
+            }
+        }
+    }
+
+    findComponents();
+
+    findEdges();
+
+    resolveConflicts(image1, image2, tl1, tl2, mask1, mask2);
+}
+
+
+void DpSeamFinder::findComponents()
+{
+    // label all connected components and get information about them
+
+    ncomps_ = 0;
+    labels_.create(unionSize_);
+    states_.clear();
+    tls_.clear();
+    brs_.clear();
+    contours_.clear();
+
+    for (int y = 0; y < unionSize_.height; ++y)
+    {
+        for (int x = 0; x < unionSize_.width; ++x)
+        {
+            if (mask1_(y, x) && mask2_(y, x))
+                labels_(y, x) = std::numeric_limits<int>::max();
+            else if (mask1_(y, x))
+                labels_(y, x) = std::numeric_limits<int>::max()-1;
+            else if (mask2_(y, x))
+                labels_(y, x) = std::numeric_limits<int>::max()-2;
+            else
+                labels_(y, x) = 0;
+        }
+    }
+
+    for (int y = 0; y < unionSize_.height; ++y)
+    {
+        for (int x = 0; x < unionSize_.width; ++x)
+        {
+            if (labels_(y, x) >= std::numeric_limits<int>::max()-2)
+            {
+                if (labels_(y, x) == std::numeric_limits<int>::max())
+                    states_.push_back(INTERS);
+                else if (labels_(y, x) == std::numeric_limits<int>::max()-1)
+                    states_.push_back(FIRST);
+                else if (labels_(y, x) == std::numeric_limits<int>::max()-2)
+                    states_.push_back(SECOND);
+
+                floodFill(labels_, Point(x, y), ++ncomps_);
+                tls_.emplace_back(x,y);
+                brs_.emplace_back(x+1, y+1);
+                contours_.push_back(std::vector<Point>());
+            }
+
+            if (labels_(y, x))
+            {
+                int l = labels_(y, x);
+                int ci = l-1;
+
+                tls_[ci].x = std::min(tls_[ci].x, x);
+                tls_[ci].y = std::min(tls_[ci].y, y);
+                brs_[ci].x = std::max(brs_[ci].x, x+1);
+                brs_[ci].y = std::max(brs_[ci].y, y+1);
+
+                if ((x == 0 || labels_(y, x-1) != l) || (x == unionSize_.width-1 || labels_(y, x+1) != l) ||
+                    (y == 0 || labels_(y-1, x) != l) || (y == unionSize_.height-1 || labels_(y+1, x) != l))
+                {
+                    contours_[ci].emplace_back(x,y);
+                }
+            }
+        }
+    }
+}
+
+
+void DpSeamFinder::findEdges()
+{
+    // find edges between components
+
+    std::map<std::pair<int, int>, int> wedges; // weighted edges
+
+    for (int ci = 0; ci < ncomps_-1; ++ci)
+    {
+        for (int cj = ci+1; cj < ncomps_; ++cj)
+        {
+            wedges[std::make_pair(ci, cj)] = 0;
+            wedges[std::make_pair(cj, ci)] = 0;
+        }
+    }
+
+    for (int ci = 0; ci < ncomps_; ++ci)
+    {
+        for (size_t i = 0; i < contours_[ci].size(); ++i)
+        {
+            int x = contours_[ci][i].x;
+            int y = contours_[ci][i].y;
+            int l = ci + 1;
+
+            if (x > 0 && labels_(y, x-1) && labels_(y, x-1) != l)
+            {
+                wedges[std::make_pair(ci, labels_(y, x-1)-1)]++;
+                wedges[std::make_pair(labels_(y, x-1)-1, ci)]++;
+            }
+
+            if (y > 0 && labels_(y-1, x) && labels_(y-1, x) != l)
+            {
+                wedges[std::make_pair(ci, labels_(y-1, x)-1)]++;
+                wedges[std::make_pair(labels_(y-1, x)-1, ci)]++;
+            }
+
+            if (x < unionSize_.width-1 && labels_(y, x+1) && labels_(y, x+1) != l)
+            {
+                wedges[std::make_pair(ci, labels_(y, x+1)-1)]++;
+                wedges[std::make_pair(labels_(y, x+1)-1, ci)]++;
+            }
+
+            if (y < unionSize_.height-1 && labels_(y+1, x) && labels_(y+1, x) != l)
+            {
+                wedges[std::make_pair(ci, labels_(y+1, x)-1)]++;
+                wedges[std::make_pair(labels_(y+1, x)-1, ci)]++;
+            }
+        }
+    }
+
+    edges_.clear();
+
+    for (int ci = 0; ci < ncomps_-1; ++ci)
+    {
+        for (int cj = ci+1; cj < ncomps_; ++cj)
+        {
+            std::map<std::pair<int, int>, int>::iterator itr = wedges.find(std::make_pair(ci, cj));
+            if (itr != wedges.end() && itr->second > 0)
+                edges_.insert(itr->first);
+
+            itr = wedges.find(std::make_pair(cj, ci));
+            if (itr != wedges.end() && itr->second > 0)
+                edges_.insert(itr->first);
+        }
+    }
+}
+
+
+void DpSeamFinder::resolveConflicts(
+        const Mat &image1, const Mat &image2, Point tl1, Point tl2, Mat &mask1, Mat &mask2)
+{
+    if (costFunc_ == COLOR_GRAD)
+        computeGradients(image1, image2);
+
+    // resolve conflicts between components
+
+    bool hasConflict = true;
+    while (hasConflict)
+    {
+        int c1 = 0, c2 = 0;
+        hasConflict = false;
+
+        for (std::set<std::pair<int, int> >::iterator itr = edges_.begin(); itr != edges_.end(); ++itr)
+        {
+            c1 = itr->first;
+            c2 = itr->second;
+
+            if ((states_[c1] & INTERS) && (states_[c1] & (~INTERS)) != states_[c2])
+            {
+                hasConflict = true;
+                break;
+            }
+        }
+
+        if (hasConflict)
+        {
+            int l1 = c1+1, l2 = c2+1;
+
+            if (hasOnlyOneNeighbor(c1))
+            {
+                // if the first components has only one adjacent component
+
+                for (int y = tls_[c1].y; y < brs_[c1].y; ++y)
+                    for (int x = tls_[c1].x; x < brs_[c1].x; ++x)
+                        if (labels_(y, x) == l1)
+                            labels_(y, x) = l2;
+
+                states_[c1] = states_[c2] == FIRST ? SECOND : FIRST;
+            }
+            else
+            {
+                // if the first component has more than one adjacent component
+
+                Point p1, p2;
+                if (getSeamTips(c1, c2, p1, p2))
+                {
+                    std::vector<Point> seam;
+                    bool isHorizontalSeam;
+
+                    if (estimateSeam(image1, image2, tl1, tl2, c1, p1, p2, seam, isHorizontalSeam))
+                        updateLabelsUsingSeam(c1, c2, seam, isHorizontalSeam);
+                }
+
+                states_[c1] = states_[c2] == FIRST ? INTERS_SECOND : INTERS_FIRST;
+            }
+
+            const int c[] = {c1, c2};
+            const int l[] = {l1, l2};
+
+            for (int i = 0; i < 2; ++i)
+            {
+                // update information about the (i+1)-th component
+
+                int x0 = tls_[c[i]].x, x1 = brs_[c[i]].x;
+                int y0 = tls_[c[i]].y, y1 = brs_[c[i]].y;
+
+                tls_[c[i]] = Point(std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
+                brs_[c[i]] = Point(std::numeric_limits<int>::min(), std::numeric_limits<int>::min());
+                contours_[c[i]].clear();
+
+                for (int y = y0; y < y1; ++y)
+                {
+                    for (int x = x0; x < x1; ++x)
+                    {
+                        if (labels_(y, x) == l[i])
+                        {
+                            tls_[c[i]].x = std::min(tls_[c[i]].x, x);
+                            tls_[c[i]].y = std::min(tls_[c[i]].y, y);
+                            brs_[c[i]].x = std::max(brs_[c[i]].x, x+1);
+                            brs_[c[i]].y = std::max(brs_[c[i]].y, y+1);
+
+                            if ((x == 0 || labels_(y, x-1) != l[i]) || (x == unionSize_.width-1 || labels_(y, x+1) != l[i]) ||
+                                (y == 0 || labels_(y-1, x) != l[i]) || (y == unionSize_.height-1 || labels_(y+1, x) != l[i]))
+                            {
+                                contours_[c[i]].emplace_back(x,y);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // remove edges
+
+            edges_.erase(std::make_pair(c1, c2));
+            edges_.erase(std::make_pair(c2, c1));
+        }
+    }
+
+    // update masks
+
+    int dx1 = unionTl_.x - tl1.x, dy1 = unionTl_.y - tl1.y;
+    int dx2 = unionTl_.x - tl2.x, dy2 = unionTl_.y - tl2.y;
+
+    for (int y = 0; y < mask2.rows; ++y)
+    {
+        for (int x = 0; x < mask2.cols; ++x)
+        {
+             int l = labels_(y - dy2, x - dx2);
+             if (l > 0 && (states_[l-1] & FIRST) && mask1.at<uchar>(y - dy2 + dy1, x - dx2 + dx1))
+                mask2.at<uchar>(y, x) = 0;
+        }
+    }
+
+    for (int y = 0; y < mask1.rows; ++y)
+    {
+        for (int x = 0; x < mask1.cols; ++x)
+        {
+             int l = labels_(y - dy1, x - dx1);
+             if (l > 0 && (states_[l-1] & SECOND) && mask2.at<uchar>(y - dy1 + dy2, x - dx1 + dx2))
+                mask1.at<uchar>(y, x) = 0;
+        }
+    }
+}
+
+
+void DpSeamFinder::computeGradients(const Mat &image1, const Mat &image2)
+{
+    CV_Assert(image1.channels() == 3 || image1.channels() == 4);
+    CV_Assert(image2.channels() == 3 || image2.channels() == 4);
+    CV_Assert(costFunction() == COLOR_GRAD);
+
+    Mat gray;
+
+    if (image1.channels() == 3)
+        cvtColor(image1, gray, COLOR_BGR2GRAY);
+    else if (image1.channels() == 4)
+        cvtColor(image1, gray, COLOR_BGRA2GRAY);
+
+    Sobel(gray, gradx1_, CV_32F, 1, 0);
+    Sobel(gray, grady1_, CV_32F, 0, 1);
+
+    if (image2.channels() == 3)
+        cvtColor(image2, gray, COLOR_BGR2GRAY);
+    else if (image2.channels() == 4)
+        cvtColor(image2, gray, COLOR_BGRA2GRAY);
+
+    Sobel(gray, gradx2_, CV_32F, 1, 0);
+    Sobel(gray, grady2_, CV_32F, 0, 1);
+}
+
+
+bool DpSeamFinder::hasOnlyOneNeighbor(int comp)
+{
+    std::set<std::pair<int, int> >::iterator begin, end;
+    begin = edges_.lower_bound(std::make_pair(comp, std::numeric_limits<int>::min()));
+    end = edges_.upper_bound(std::make_pair(comp, std::numeric_limits<int>::max()));
+    return ++begin == end;
+}
+
+
+bool DpSeamFinder::closeToContour(int y, int x, const Mat_<uchar> &contourMask)
+{
+    const int rad = 2;
+
+    for (int dy = -rad; dy <= rad; ++dy)
+    {
+        if (y + dy >= 0 && y + dy < unionSize_.height)
+        {
+            for (int dx = -rad; dx <= rad; ++dx)
+            {
+                if (x + dx >= 0 && x + dx < unionSize_.width &&
+                    contourMask(y + dy, x + dx))
+                {
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+
+bool DpSeamFinder::getSeamTips(int comp1, int comp2, Point &p1, Point &p2)
+{
+    CV_Assert(states_[comp1] & INTERS);
+
+    // find special points
+
+    std::vector<Point> specialPoints;
+    int l2 = comp2+1;
+
+    for (size_t i = 0; i < contours_[comp1].size(); ++i)
+    {
+        int x = contours_[comp1][i].x;
+        int y = contours_[comp1][i].y;
+
+        if (closeToContour(y, x, contour1mask_) &&
+            closeToContour(y, x, contour2mask_) &&
+            ((x > 0 && labels_(y, x-1) == l2) ||
+             (y > 0 && labels_(y-1, x) == l2) ||
+             (x < unionSize_.width-1 && labels_(y, x+1) == l2) ||
+             (y < unionSize_.height-1 && labels_(y+1, x) == l2)))
+        {
+            specialPoints.emplace_back(x,y);
+        }
+    }
+
+    if (specialPoints.size() < 2)
+        return false;
+
+    // find clusters
+
+    std::vector<int> labels;
+    cv::partition(specialPoints, labels, ClosePoints(10));
+
+    int nlabels = *std::max_element(labels.begin(), labels.end()) + 1;
+    if (nlabels < 2)
+        return false;
+
+    std::vector<Point> sum(nlabels);
+    std::vector<std::vector<Point> > points(nlabels);
+
+    for (size_t i = 0; i < specialPoints.size(); ++i)
+    {
+        sum[labels[i]] += specialPoints[i];
+        points[labels[i]].push_back(specialPoints[i]);
+    }
+
+    // select two most distant clusters
+
+    int idx[2] = {-1,-1};
+    double maxDist = -std::numeric_limits<double>::max();
+
+    for (int i = 0; i < nlabels-1; ++i)
+    {
+        for (int j = i+1; j < nlabels; ++j)
+        {
+            double size1 = static_cast<double>(points[i].size()), size2 = static_cast<double>(points[j].size());
+            double cx1 = cvRound(sum[i].x / size1), cy1 = cvRound(sum[i].y / size1);
+            double cx2 = cvRound(sum[j].x / size2), cy2 = cvRound(sum[j].y / size2);
+
+            double dist = (cx1 - cx2) * (cx1 - cx2) + (cy1 - cy2) * (cy1 - cy2);
+            if (dist > maxDist)
+            {
+                maxDist = dist;
+                idx[0] = i;
+                idx[1] = j;
+            }
+        }
+    }
+
+    // select two points closest to the clusters' centers
+
+    Point p[2];
+
+    for (int i = 0; i < 2; ++i)
+    {
+        double size = static_cast<double>(points[idx[i]].size());
+        double cx = cvRound(sum[idx[i]].x / size);
+        double cy = cvRound(sum[idx[i]].y / size);
+
+        size_t closest = points[idx[i]].size();
+        double minDist = std::numeric_limits<double>::max();
+
+        for (size_t j = 0; j < points[idx[i]].size(); ++j)
+        {
+            double dist = (points[idx[i]][j].x - cx) * (points[idx[i]][j].x - cx) +
+                          (points[idx[i]][j].y - cy) * (points[idx[i]][j].y - cy);
+            if (dist < minDist)
+            {
+                minDist = dist;
+                closest = j;
+            }
+        }
+
+        p[i] = points[idx[i]][closest];
+    }
+
+    p1 = p[0];
+    p2 = p[1];
+    return true;
+}
+
+
+namespace
+{
+
+template <typename T>
+float diffL2Square3(const Mat &image1, int y1, int x1, const Mat &image2, int y2, int x2)
+{
+    const T *r1 = image1.ptr<T>(y1);
+    const T *r2 = image2.ptr<T>(y2);
+    return static_cast<float>(sqr(r1[3*x1] - r2[3*x2]) + sqr(r1[3*x1+1] - r2[3*x2+1]) +
+                              sqr(r1[3*x1+2] - r2[3*x2+2]));
+}
+
+
+template <typename T>
+float diffL2Square4(const Mat &image1, int y1, int x1, const Mat &image2, int y2, int x2)
+{
+    const T *r1 = image1.ptr<T>(y1);
+    const T *r2 = image2.ptr<T>(y2);
+    return static_cast<float>(sqr(r1[4*x1] - r2[4*x2]) + sqr(r1[4*x1+1] - r2[4*x2+1]) +
+                              sqr(r1[4*x1+2] - r2[4*x2+2]));
+}
+
+} // namespace
+
+
+void DpSeamFinder::computeCosts(
+        const Mat &image1, const Mat &image2, Point tl1, Point tl2,
+        int comp, Mat_<float> &costV, Mat_<float> &costH)
+{
+    CV_Assert(states_[comp] & INTERS);
+
+    // compute costs
+
+    float (*diff)(const Mat&, int, int, const Mat&, int, int) = 0;
+    if (image1.type() == CV_32FC3 && image2.type() == CV_32FC3)
+        diff = diffL2Square3<float>;
+    else if (image1.type() == CV_8UC3 && image2.type() == CV_8UC3)
+        diff = diffL2Square3<uchar>;
+    else if (image1.type() == CV_32FC4 && image2.type() == CV_32FC4)
+        diff = diffL2Square4<float>;
+    else if (image1.type() == CV_8UC4 && image2.type() == CV_8UC4)
+        diff = diffL2Square4<uchar>;
+    else
+        CV_Error(Error::StsBadArg, "both images must have CV_32FC3(4) or CV_8UC3(4) type");
+
+    int l = comp+1;
+    Rect roi(tls_[comp], brs_[comp]);
+
+    int dx1 = unionTl_.x - tl1.x, dy1 = unionTl_.y - tl1.y;
+    int dx2 = unionTl_.x - tl2.x, dy2 = unionTl_.y - tl2.y;
+
+    const float badRegionCost = normL2(Point3f(255.f, 255.f, 255.f),
+                                       Point3f(0.f, 0.f, 0.f));
+
+    costV.create(roi.height, roi.width+1);
+
+    for (int y = roi.y; y < roi.br().y; ++y)
+    {
+        for (int x = roi.x; x < roi.br().x+1; ++x)
+        {
+            if (x > 0 && x < labels_.cols &&
+                labels_(y, x) == l && labels_(y, x-1) == l
+            )
+            {
+                float costColor = (diff(image1, y + dy1, x + dx1 - 1, image2, y + dy2, x + dx2) +
+                                   diff(image1, y + dy1, x + dx1, image2, y + dy2, x + dx2 - 1)) / 2;
+                if (costFunc_ == COLOR)
+                    costV(y - roi.y, x - roi.x) = costColor;
+                else if (costFunc_ == COLOR_GRAD)
+                {
+                    float costGrad = std::abs(gradx1_(y + dy1, x + dx1)) + std::abs(gradx1_(y + dy1, x + dx1 - 1)) +
+                                     std::abs(gradx2_(y + dy2, x + dx2)) + std::abs(gradx2_(y + dy2, x + dx2 - 1)) + 1.f;
+                    costV(y - roi.y, x - roi.x) = costColor / costGrad;
+                }
+            }
+            else
+                costV(y - roi.y, x - roi.x) = badRegionCost;
+        }
+    }
+
+    costH.create(roi.height+1, roi.width);
+
+    for (int y = roi.y; y < roi.br().y+1; ++y)
+    {
+        for (int x = roi.x; x < roi.br().x; ++x)
+        {
+            if (y > 0 && y < labels_.rows &&
+                labels_(y, x) == l && labels_(y-1, x) == l
+            )
+            {
+                float costColor = (diff(image1, y + dy1 - 1, x + dx1, image2, y + dy2, x + dx2) +
+                                   diff(image1, y + dy1, x + dx1, image2, y + dy2 - 1, x + dx2)) / 2;
+                if (costFunc_ == COLOR)
+                    costH(y - roi.y, x - roi.x) = costColor;
+                else if (costFunc_ == COLOR_GRAD)
+                {
+                    float costGrad = std::abs(grady1_(y + dy1, x + dx1)) + std::abs(grady1_(y + dy1 - 1, x + dx1)) +
+                                     std::abs(grady2_(y + dy2, x + dx2)) + std::abs(grady2_(y + dy2 - 1, x + dx2)) + 1.f;
+                    costH(y - roi.y, x - roi.x) = costColor / costGrad;
+                }
+            }
+            else
+                costH(y - roi.y, x - roi.x) = badRegionCost;
+        }
+    }
+}
+
+
+bool DpSeamFinder::estimateSeam(
+        const Mat &image1, const Mat &image2, Point tl1, Point tl2, int comp,
+        Point p1, Point p2, std::vector<Point> &seam, bool &isHorizontal)
+{
+    CV_Assert(states_[comp] & INTERS);
+
+    Mat_<float> costV, costH;
+    computeCosts(image1, image2, tl1, tl2, comp, costV, costH);
+
+    Rect roi(tls_[comp], brs_[comp]);
+    Point src = p1 - roi.tl();
+    Point dst = p2 - roi.tl();
+    int l = comp+1;
+
+    // estimate seam direction
+
+    bool swapped = false;
+    isHorizontal = std::abs(dst.x - src.x) > std::abs(dst.y - src.y);
+
+    if (isHorizontal)
+    {
+        if (src.x > dst.x)
+        {
+            std::swap(src, dst);
+            swapped = true;
+        }
+    }
+    else if (src.y > dst.y)
+    {
+        swapped = true;
+        std::swap(src, dst);
+    }
+
+    // find optimal control
+
+    Mat_<uchar> control = Mat::zeros(roi.size(), CV_8U);
+    Mat_<uchar> reachable = Mat::zeros(roi.size(), CV_8U);
+    Mat_<float> cost = Mat::zeros(roi.size(), CV_32F);
+
+    reachable(src) = 1;
+    cost(src) = 0.f;
+
+    int nsteps;
+    std::pair<float, int> steps[3];
+
+    if (isHorizontal)
+    {
+        for (int x = src.x+1; x <= dst.x; ++x)
+        {
+            for (int y = 0; y < roi.height; ++y)
+            {
+                // seam follows along upper side of pixels
+
+                nsteps = 0;
+
+                if (labels_(y + roi.y, x + roi.x) == l)
+                {
+                    if (reachable(y, x-1))
+                        steps[nsteps++] = std::make_pair(cost(y, x-1) + costH(y, x-1), 1);
+                    if (y > 0 && reachable(y-1, x-1))
+                        steps[nsteps++] = std::make_pair(cost(y-1, x-1) + costH(y-1, x-1) + costV(y-1, x), 2);
+                    if (y < roi.height-1 && reachable(y+1, x-1))
+                        steps[nsteps++] = std::make_pair(cost(y+1, x-1) + costH(y+1, x-1) + costV(y, x), 3);
+                }
+
+                if (nsteps)
+                {
+                    std::pair<float, int> opt = *min_element(steps, steps + nsteps);
+                    cost(y, x) = opt.first;
+                    control(y, x) = (uchar)opt.second;
+                    reachable(y, x) = 255;
+                }
+            }
+        }
+    }
+    else
+    {
+        for (int y = src.y+1; y <= dst.y; ++y)
+        {
+            for (int x = 0; x < roi.width; ++x)
+            {
+                // seam follows along left side of pixels
+
+                nsteps = 0;
+
+                if (labels_(y + roi.y, x + roi.x) == l)
+                {
+                    if (reachable(y-1, x))
+                        steps[nsteps++] = std::make_pair(cost(y-1, x) + costV(y-1, x), 1);
+                    if (x > 0 && reachable(y-1, x-1))
+                        steps[nsteps++] = std::make_pair(cost(y-1, x-1) + costV(y-1, x-1) + costH(y, x-1), 2);
+                    if (x < roi.width-1 && reachable(y-1, x+1))
+                        steps[nsteps++] = std::make_pair(cost(y-1, x+1) + costV(y-1, x+1) + costH(y, x), 3);
+                }
+
+                if (nsteps)
+                {
+                    std::pair<float, int> opt = *min_element(steps, steps + nsteps);
+                    cost(y, x) = opt.first;
+                    control(y, x) = (uchar)opt.second;
+                    reachable(y, x) = 255;
+                }
+            }
+        }
+    }
+
+    if (!reachable(dst))
+        return false;
+
+    // restore seam
+
+    Point p = dst;
+    seam.clear();
+    seam.push_back(p + roi.tl());
+
+    if (isHorizontal)
+    {
+        for (; p.x != src.x; seam.push_back(p + roi.tl()))
+        {
+            if (control(p) == 2) p.y--;
+            else if (control(p) == 3) p.y++;
+            p.x--;
+        }
+    }
+    else
+    {
+        for (; p.y != src.y; seam.push_back(p + roi.tl()))
+        {
+            if (control(p) == 2) p.x--;
+            else if (control(p) == 3) p.x++;
+            p.y--;
+        }
+    }
+
+    if (!swapped)
+        std::reverse(seam.begin(), seam.end());
+
+    CV_Assert(seam.front() == p1);
+    CV_Assert(seam.back() == p2);
+    return true;
+}
+
+
+void DpSeamFinder::updateLabelsUsingSeam(
+        int comp1, int comp2, const std::vector<Point> &seam, bool isHorizontalSeam)
+{
+    Mat_<int> mask = Mat::zeros(brs_[comp1].y - tls_[comp1].y,
+                                brs_[comp1].x - tls_[comp1].x, CV_32S);
+
+    for (size_t i = 0; i < contours_[comp1].size(); ++i)
+        mask(contours_[comp1][i] - tls_[comp1]) = 255;
+
+    for (size_t i = 0; i < seam.size(); ++i)
+        mask(seam[i] - tls_[comp1]) = 255;
+
+    // find connected components after seam carving
+
+    int l1 = comp1+1, l2 = comp2+1;
+
+    int ncomps = 0;
+
+    for (int y = 0; y < mask.rows; ++y)
+        for (int x = 0; x < mask.cols; ++x)
+            if (!mask(y, x) && labels_(y + tls_[comp1].y, x + tls_[comp1].x) == l1)
+                floodFill(mask, Point(x, y), ++ncomps);
+
+    for (size_t i = 0; i < contours_[comp1].size(); ++i)
+    {
+        int x = contours_[comp1][i].x - tls_[comp1].x;
+        int y = contours_[comp1][i].y - tls_[comp1].y;
+
+        bool ok = false;
+        static const int dx[] = {-1, +1, 0, 0, -1, +1, -1, +1};
+        static const int dy[] = {0, 0, -1, +1, -1, -1, +1, +1};
+
+        for (int j = 0; j < 8; ++j)
+        {
+            int c = x + dx[j];
+            int r = y + dy[j];
+
+            if (c >= 0 && c < mask.cols && r >= 0 && r < mask.rows &&
+                mask(r, c) && mask(r, c) != 255)
+            {
+                ok = true;
+                mask(y, x) = mask(r, c);
+            }
+        }
+
+        if (!ok)
+            mask(y, x) = 0;
+    }
+
+    if (isHorizontalSeam)
+    {
+        for (size_t i = 0; i < seam.size(); ++i)
+        {
+            int x = seam[i].x - tls_[comp1].x;
+            int y = seam[i].y - tls_[comp1].y;
+
+            if (y < mask.rows-1 && mask(y+1, x) && mask(y+1, x) != 255)
+                mask(y, x) = mask(y+1, x);
+            else
+                mask(y, x) = 0;
+        }
+    }
+    else
+    {
+        for (size_t i = 0; i < seam.size(); ++i)
+        {
+            int x = seam[i].x - tls_[comp1].x;
+            int y = seam[i].y - tls_[comp1].y;
+
+            if (x < mask.cols-1 && mask(y, x+1) && mask(y, x+1) != 255)
+                mask(y, x) = mask(y, x+1);
+            else
+                mask(y, x) = 0;
+        }
+    }
+
+    // find new components connected with the second component and
+    // with other components except the ones we are working with
+
+    std::map<int, int> connect2;
+    std::map<int, int> connectOther;
+
+    for (int i = 1; i <= ncomps; ++i)
+    {
+        connect2.insert(std::make_pair(i, 0));
+        connectOther.insert(std::make_pair(i, 0));
+    }
+
+    for (size_t i = 0; i < contours_[comp1].size(); ++i)
+    {
+        int x = contours_[comp1][i].x;
+        int y = contours_[comp1][i].y;
+
+        if ((x > 0 && labels_(y, x-1) == l2) ||
+            (y > 0 && labels_(y-1, x) == l2) ||
+            (x < unionSize_.width-1 && labels_(y, x+1) == l2) ||
+            (y < unionSize_.height-1 && labels_(y+1, x) == l2))
+        {
+            connect2[mask(y - tls_[comp1].y, x - tls_[comp1].x)]++;
+        }
+
+        if ((x > 0 && labels_(y, x-1) != l1 && labels_(y, x-1) != l2) ||
+            (y > 0 && labels_(y-1, x) != l1 && labels_(y-1, x) != l2) ||
+            (x < unionSize_.width-1 && labels_(y, x+1) != l1 && labels_(y, x+1) != l2) ||
+            (y < unionSize_.height-1 && labels_(y+1, x) != l1 && labels_(y+1, x) != l2))
+        {
+            connectOther[mask(y - tls_[comp1].y, x - tls_[comp1].x)]++;
+        }
+    }
+
+    std::vector<int> isAdjComp(ncomps + 1, 0);
+
+    for (std::map<int, int>::iterator itr = connect2.begin(); itr != connect2.end(); ++itr)
+    {
+        double len = static_cast<double>(contours_[comp1].size());
+        int res = 0;
+        if (itr->second / len > 0.05)
+        {
+            std::map<int, int>::const_iterator sub = connectOther.find(itr->first);
+            if (sub != connectOther.end() && (sub->second / len < 0.1))
+            {
+                res = 1;
+            }
+        }
+        isAdjComp[itr->first] = res;
+    }
+
+    // update labels
+
+    for (int y = 0; y < mask.rows; ++y)
+        for (int x = 0; x < mask.cols; ++x)
+            if (mask(y, x) && isAdjComp[mask(y, x)])
+                labels_(y + tls_[comp1].y, x + tls_[comp1].x) = l2;
+}
+
+
+class GraphCutSeamFinder::Impl CV_FINAL : public PairwiseSeamFinder
+{
+public:
+    Impl(int cost_type, float terminal_cost, float bad_region_penalty)
+        : cost_type_(cost_type), terminal_cost_(terminal_cost), bad_region_penalty_(bad_region_penalty) {}
+
+    ~Impl() {}
+
+    void find(const std::vector<UMat> &src, const std::vector<Point> &corners, std::vector<UMat> &masks) CV_OVERRIDE;
+    void findInPair(size_t first, size_t second, Rect roi) CV_OVERRIDE;
+
+private:
+    void setGraphWeightsColor(const Mat &img1, const Mat &img2,
+                              const Mat &mask1, const Mat &mask2, GCGraph<float> &graph);
+    void setGraphWeightsColorGrad(const Mat &img1, const Mat &img2, const Mat &dx1, const Mat &dx2,
+                                  const Mat &dy1, const Mat &dy2, const Mat &mask1, const Mat &mask2,
+                                  GCGraph<float> &graph);
+
+    std::vector<Mat> dx_, dy_;
+    int cost_type_;
+    float terminal_cost_;
+    float bad_region_penalty_;
+};
+
+
+void GraphCutSeamFinder::Impl::find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                                    std::vector<UMat> &masks)
+{
+    // Compute gradients
+    dx_.resize(src.size());
+    dy_.resize(src.size());
+    Mat dx, dy;
+    for (size_t i = 0; i < src.size(); ++i)
+    {
+        CV_Assert(src[i].channels() == 3);
+        Sobel(src[i], dx, CV_32F, 1, 0);
+        Sobel(src[i], dy, CV_32F, 0, 1);
+        dx_[i].create(src[i].size(), CV_32F);
+        dy_[i].create(src[i].size(), CV_32F);
+        for (int y = 0; y < src[i].rows; ++y)
+        {
+            const Point3f* dx_row = dx.ptr<Point3f>(y);
+            const Point3f* dy_row = dy.ptr<Point3f>(y);
+            float* dx_row_ = dx_[i].ptr<float>(y);
+            float* dy_row_ = dy_[i].ptr<float>(y);
+            for (int x = 0; x < src[i].cols; ++x)
+            {
+                dx_row_[x] = normL2(dx_row[x]);
+                dy_row_[x] = normL2(dy_row[x]);
+            }
+        }
+    }
+    PairwiseSeamFinder::find(src, corners, masks);
+}
+
+
+void GraphCutSeamFinder::Impl::setGraphWeightsColor(const Mat &img1, const Mat &img2,
+                                                    const Mat &mask1, const Mat &mask2, GCGraph<float> &graph)
+{
+    const Size img_size = img1.size();
+
+    // Set terminal weights
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            int v = graph.addVtx();
+            graph.addTermWeights(v, mask1.at<uchar>(y, x) ? terminal_cost_ : 0.f,
+                                    mask2.at<uchar>(y, x) ? terminal_cost_ : 0.f);
+        }
+    }
+
+    // Set regular edge weights
+    const float weight_eps = 1.f;
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            int v = y * img_size.width + x;
+            if (x < img_size.width - 1)
+            {
+                float weight = normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               normL2(img1.at<Point3f>(y, x + 1), img2.at<Point3f>(y, x + 1)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y, x + 1) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y, x + 1))
+                    weight += bad_region_penalty_;
+                graph.addEdges(v, v + 1, weight, weight);
+            }
+            if (y < img_size.height - 1)
+            {
+                float weight = normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               normL2(img1.at<Point3f>(y + 1, x), img2.at<Point3f>(y + 1, x)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y + 1, x) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y + 1, x))
+                    weight += bad_region_penalty_;
+                graph.addEdges(v, v + img_size.width, weight, weight);
+            }
+        }
+    }
+}
+
+
+void GraphCutSeamFinder::Impl::setGraphWeightsColorGrad(
+        const Mat &img1, const Mat &img2, const Mat &dx1, const Mat &dx2,
+        const Mat &dy1, const Mat &dy2, const Mat &mask1, const Mat &mask2,
+        GCGraph<float> &graph)
+{
+    const Size img_size = img1.size();
+
+    // Set terminal weights
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            int v = graph.addVtx();
+            graph.addTermWeights(v, mask1.at<uchar>(y, x) ? terminal_cost_ : 0.f,
+                                    mask2.at<uchar>(y, x) ? terminal_cost_ : 0.f);
+        }
+    }
+
+    // Set regular edge weights
+    const float weight_eps = 1.f;
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            int v = y * img_size.width + x;
+            if (x < img_size.width - 1)
+            {
+                float grad = dx1.at<float>(y, x) + dx1.at<float>(y, x + 1) +
+                             dx2.at<float>(y, x) + dx2.at<float>(y, x + 1) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                                normL2(img1.at<Point3f>(y, x + 1), img2.at<Point3f>(y, x + 1))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y, x + 1) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y, x + 1))
+                    weight += bad_region_penalty_;
+                graph.addEdges(v, v + 1, weight, weight);
+            }
+            if (y < img_size.height - 1)
+            {
+                float grad = dy1.at<float>(y, x) + dy1.at<float>(y + 1, x) +
+                             dy2.at<float>(y, x) + dy2.at<float>(y + 1, x) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                                normL2(img1.at<Point3f>(y + 1, x), img2.at<Point3f>(y + 1, x))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y + 1, x) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y + 1, x))
+                    weight += bad_region_penalty_;
+                graph.addEdges(v, v + img_size.width, weight, weight);
+            }
+        }
+    }
+}
+
+
+void GraphCutSeamFinder::Impl::findInPair(size_t first, size_t second, Rect roi)
+{
+    Mat img1 = images_[first].getMat(ACCESS_READ), img2 = images_[second].getMat(ACCESS_READ);
+    Mat dx1 = dx_[first], dx2 = dx_[second];
+    Mat dy1 = dy_[first], dy2 = dy_[second];
+    Mat mask1 = masks_[first].getMat(ACCESS_RW), mask2 = masks_[second].getMat(ACCESS_RW);
+    Point tl1 = corners_[first], tl2 = corners_[second];
+
+    const int gap = 10;
+    Mat subimg1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32FC3);
+    Mat subimg2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32FC3);
+    Mat submask1(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+    Mat submask2(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+    Mat subdx1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdy1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdx2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdy2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+
+    // Cut subimages and submasks with some gap
+    for (int y = -gap; y < roi.height + gap; ++y)
+    {
+        for (int x = -gap; x < roi.width + gap; ++x)
+        {
+            int y1 = roi.y - tl1.y + y;
+            int x1 = roi.x - tl1.x + x;
+            if (y1 >= 0 && x1 >= 0 && y1 < img1.rows && x1 < img1.cols)
+            {
+                subimg1.at<Point3f>(y + gap, x + gap) = img1.at<Point3f>(y1, x1);
+                submask1.at<uchar>(y + gap, x + gap) = mask1.at<uchar>(y1, x1);
+                subdx1.at<float>(y + gap, x + gap) = dx1.at<float>(y1, x1);
+                subdy1.at<float>(y + gap, x + gap) = dy1.at<float>(y1, x1);
+            }
+            else
+            {
+                subimg1.at<Point3f>(y + gap, x + gap) = Point3f(0, 0, 0);
+                submask1.at<uchar>(y + gap, x + gap) = 0;
+                subdx1.at<float>(y + gap, x + gap) = 0.f;
+                subdy1.at<float>(y + gap, x + gap) = 0.f;
+            }
+
+            int y2 = roi.y - tl2.y + y;
+            int x2 = roi.x - tl2.x + x;
+            if (y2 >= 0 && x2 >= 0 && y2 < img2.rows && x2 < img2.cols)
+            {
+                subimg2.at<Point3f>(y + gap, x + gap) = img2.at<Point3f>(y2, x2);
+                submask2.at<uchar>(y + gap, x + gap) = mask2.at<uchar>(y2, x2);
+                subdx2.at<float>(y + gap, x + gap) = dx2.at<float>(y2, x2);
+                subdy2.at<float>(y + gap, x + gap) = dy2.at<float>(y2, x2);
+            }
+            else
+            {
+                subimg2.at<Point3f>(y + gap, x + gap) = Point3f(0, 0, 0);
+                submask2.at<uchar>(y + gap, x + gap) = 0;
+                subdx2.at<float>(y + gap, x + gap) = 0.f;
+                subdy2.at<float>(y + gap, x + gap) = 0.f;
+            }
+        }
+    }
+
+    const int vertex_count = (roi.height + 2 * gap) * (roi.width + 2 * gap);
+    const int edge_count = (roi.height - 1 + 2 * gap) * (roi.width + 2 * gap) +
+                           (roi.width - 1 + 2 * gap) * (roi.height + 2 * gap);
+    GCGraph<float> graph(vertex_count, edge_count);
+
+    switch (cost_type_)
+    {
+    case GraphCutSeamFinder::COST_COLOR:
+        setGraphWeightsColor(subimg1, subimg2, submask1, submask2, graph);
+        break;
+    case GraphCutSeamFinder::COST_COLOR_GRAD:
+        setGraphWeightsColorGrad(subimg1, subimg2, subdx1, subdx2, subdy1, subdy2,
+                                 submask1, submask2, graph);
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "unsupported pixel similarity measure");
+    }
+
+    graph.maxFlow();
+
+    for (int y = 0; y < roi.height; ++y)
+    {
+        for (int x = 0; x < roi.width; ++x)
+        {
+            if (graph.inSourceSegment((y + gap) * (roi.width + 2 * gap) + x + gap))
+            {
+                if (mask1.at<uchar>(roi.y - tl1.y + y, roi.x - tl1.x + x))
+                    mask2.at<uchar>(roi.y - tl2.y + y, roi.x - tl2.x + x) = 0;
+            }
+            else
+            {
+                if (mask2.at<uchar>(roi.y - tl2.y + y, roi.x - tl2.x + x))
+                    mask1.at<uchar>(roi.y - tl1.y + y, roi.x - tl1.x + x) = 0;
+            }
+        }
+    }
+}
+
+GraphCutSeamFinder::GraphCutSeamFinder(String cost_type, float terminal_cost, float bad_region_penalty)
+{
+    CostType t;
+    if (cost_type == "COST_COLOR")
+        t = COST_COLOR;
+    else if (cost_type == "COST_COLOR_GRAD")
+        t = COST_COLOR_GRAD;
+    else
+        CV_Error(Error::StsBadFunc, "Unknown cost type function");
+    impl_ = new Impl(t, terminal_cost, bad_region_penalty);
+}
+
+
+
+GraphCutSeamFinder::GraphCutSeamFinder(int cost_type, float terminal_cost, float bad_region_penalty)
+    : impl_(new Impl(cost_type, terminal_cost, bad_region_penalty)) {}
+
+GraphCutSeamFinder::~GraphCutSeamFinder() {}
+
+
+void GraphCutSeamFinder::find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                              std::vector<UMat> &masks)
+{
+    impl_->find(src, corners, masks);
+}
+
+
+#ifdef HAVE_OPENCV_CUDALEGACY
+void GraphCutSeamFinderGpu::find(const std::vector<UMat> &src, const std::vector<Point> &corners,
+                                 std::vector<UMat> &masks)
+{
+    // Compute gradients
+    dx_.resize(src.size());
+    dy_.resize(src.size());
+    Mat dx, dy;
+    for (size_t i = 0; i < src.size(); ++i)
+    {
+        CV_Assert(src[i].channels() == 3);
+        Sobel(src[i], dx, CV_32F, 1, 0);
+        Sobel(src[i], dy, CV_32F, 0, 1);
+        dx_[i].create(src[i].size(), CV_32F);
+        dy_[i].create(src[i].size(), CV_32F);
+        for (int y = 0; y < src[i].rows; ++y)
+        {
+            const Point3f* dx_row = dx.ptr<Point3f>(y);
+            const Point3f* dy_row = dy.ptr<Point3f>(y);
+            float* dx_row_ = dx_[i].ptr<float>(y);
+            float* dy_row_ = dy_[i].ptr<float>(y);
+            for (int x = 0; x < src[i].cols; ++x)
+            {
+                dx_row_[x] = normL2(dx_row[x]);
+                dy_row_[x] = normL2(dy_row[x]);
+            }
+        }
+    }
+    PairwiseSeamFinder::find(src, corners, masks);
+}
+
+
+void GraphCutSeamFinderGpu::findInPair(size_t first, size_t second, Rect roi)
+{
+    Mat img1 = images_[first].getMat(ACCESS_READ), img2 = images_[second].getMat(ACCESS_READ);
+    Mat dx1 = dx_[first], dx2 = dx_[second];
+    Mat dy1 = dy_[first], dy2 = dy_[second];
+    Mat mask1 = masks_[first].getMat(ACCESS_READ), mask2 = masks_[second].getMat(ACCESS_READ);
+    Point tl1 = corners_[first], tl2 = corners_[second];
+
+    const int gap = 10;
+    Mat subimg1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32FC3);
+    Mat subimg2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32FC3);
+    Mat submask1(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+    Mat submask2(roi.height + 2 * gap, roi.width + 2 * gap, CV_8U);
+    Mat subdx1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdy1(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdx2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+    Mat subdy2(roi.height + 2 * gap, roi.width + 2 * gap, CV_32F);
+
+    // Cut subimages and submasks with some gap
+    for (int y = -gap; y < roi.height + gap; ++y)
+    {
+        for (int x = -gap; x < roi.width + gap; ++x)
+        {
+            int y1 = roi.y - tl1.y + y;
+            int x1 = roi.x - tl1.x + x;
+            if (y1 >= 0 && x1 >= 0 && y1 < img1.rows && x1 < img1.cols)
+            {
+                subimg1.at<Point3f>(y + gap, x + gap) = img1.at<Point3f>(y1, x1);
+                submask1.at<uchar>(y + gap, x + gap) = mask1.at<uchar>(y1, x1);
+                subdx1.at<float>(y + gap, x + gap) = dx1.at<float>(y1, x1);
+                subdy1.at<float>(y + gap, x + gap) = dy1.at<float>(y1, x1);
+            }
+            else
+            {
+                subimg1.at<Point3f>(y + gap, x + gap) = Point3f(0, 0, 0);
+                submask1.at<uchar>(y + gap, x + gap) = 0;
+                subdx1.at<float>(y + gap, x + gap) = 0.f;
+                subdy1.at<float>(y + gap, x + gap) = 0.f;
+            }
+
+            int y2 = roi.y - tl2.y + y;
+            int x2 = roi.x - tl2.x + x;
+            if (y2 >= 0 && x2 >= 0 && y2 < img2.rows && x2 < img2.cols)
+            {
+                subimg2.at<Point3f>(y + gap, x + gap) = img2.at<Point3f>(y2, x2);
+                submask2.at<uchar>(y + gap, x + gap) = mask2.at<uchar>(y2, x2);
+                subdx2.at<float>(y + gap, x + gap) = dx2.at<float>(y2, x2);
+                subdy2.at<float>(y + gap, x + gap) = dy2.at<float>(y2, x2);
+            }
+            else
+            {
+                subimg2.at<Point3f>(y + gap, x + gap) = Point3f(0, 0, 0);
+                submask2.at<uchar>(y + gap, x + gap) = 0;
+                subdx2.at<float>(y + gap, x + gap) = 0.f;
+                subdy2.at<float>(y + gap, x + gap) = 0.f;
+            }
+        }
+    }
+
+    Mat terminals, leftT, rightT, top, bottom;
+
+    switch (cost_type_)
+    {
+    case GraphCutSeamFinder::COST_COLOR:
+        setGraphWeightsColor(subimg1, subimg2, submask1, submask2,
+                             terminals, leftT, rightT, top, bottom);
+        break;
+    case GraphCutSeamFinder::COST_COLOR_GRAD:
+        setGraphWeightsColorGrad(subimg1, subimg2, subdx1, subdx2, subdy1, subdy2,
+                                 submask1, submask2, terminals, leftT, rightT, top, bottom);
+        break;
+    default:
+        CV_Error(Error::StsBadArg, "unsupported pixel similarity measure");
+    }
+
+    cuda::GpuMat terminals_d(terminals);
+    cuda::GpuMat leftT_d(leftT);
+    cuda::GpuMat rightT_d(rightT);
+    cuda::GpuMat top_d(top);
+    cuda::GpuMat bottom_d(bottom);
+    cuda::GpuMat labels_d, buf_d;
+
+    cuda::graphcut(terminals_d, leftT_d, rightT_d, top_d, bottom_d, labels_d, buf_d);
+
+    Mat_<uchar> labels = (Mat)labels_d;
+    for (int y = 0; y < roi.height; ++y)
+    {
+        for (int x = 0; x < roi.width; ++x)
+        {
+            if (labels(y + gap, x + gap))
+            {
+                if (mask1.at<uchar>(roi.y - tl1.y + y, roi.x - tl1.x + x))
+                    mask2.at<uchar>(roi.y - tl2.y + y, roi.x - tl2.x + x) = 0;
+            }
+            else
+            {
+                if (mask2.at<uchar>(roi.y - tl2.y + y, roi.x - tl2.x + x))
+                    mask1.at<uchar>(roi.y - tl1.y + y, roi.x - tl1.x + x) = 0;
+            }
+        }
+    }
+}
+
+
+void GraphCutSeamFinderGpu::setGraphWeightsColor(const Mat &img1, const Mat &img2, const Mat &mask1, const Mat &mask2,
+                                                 Mat &terminals, Mat &leftT, Mat &rightT, Mat &top, Mat &bottom)
+{
+    const Size img_size = img1.size();
+
+    terminals.create(img_size, CV_32S);
+    leftT.create(Size(img_size.height, img_size.width), CV_32S);
+    rightT.create(Size(img_size.height, img_size.width), CV_32S);
+    top.create(img_size, CV_32S);
+    bottom.create(img_size, CV_32S);
+
+    Mat_<int> terminals_(terminals);
+    Mat_<int> leftT_(leftT);
+    Mat_<int> rightT_(rightT);
+    Mat_<int> top_(top);
+    Mat_<int> bottom_(bottom);
+
+    // Set terminal weights
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            float source = mask1.at<uchar>(y, x) ? terminal_cost_ : 0.f;
+            float sink = mask2.at<uchar>(y, x) ? terminal_cost_ : 0.f;
+            terminals_(y, x) = saturate_cast<int>((source - sink) * 255.f);
+        }
+    }
+
+    // Set regular edge weights
+    const float weight_eps = 1.f;
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            if (x > 0)
+            {
+                float weight = normL2(img1.at<Point3f>(y, x - 1), img2.at<Point3f>(y, x - 1)) +
+                               normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x - 1) || !mask1.at<uchar>(y, x) ||
+                    !mask2.at<uchar>(y, x - 1) || !mask2.at<uchar>(y, x))
+                    weight += bad_region_penalty_;
+                leftT_(x, y) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                leftT_(x, y) = 0;
+
+            if (x < img_size.width - 1)
+            {
+                float weight = normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               normL2(img1.at<Point3f>(y, x + 1), img2.at<Point3f>(y, x + 1)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y, x + 1) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y, x + 1))
+                    weight += bad_region_penalty_;
+                rightT_(x, y) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                rightT_(x, y) = 0;
+
+            if (y > 0)
+            {
+                float weight = normL2(img1.at<Point3f>(y - 1, x), img2.at<Point3f>(y - 1, x)) +
+                               normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y - 1, x) || !mask1.at<uchar>(y, x) ||
+                    !mask2.at<uchar>(y - 1, x) || !mask2.at<uchar>(y, x))
+                    weight += bad_region_penalty_;
+                top_(y, x) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                top_(y, x) = 0;
+
+            if (y < img_size.height - 1)
+            {
+                float weight = normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                               normL2(img1.at<Point3f>(y + 1, x), img2.at<Point3f>(y + 1, x)) +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y + 1, x) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y + 1, x))
+                    weight += bad_region_penalty_;
+                bottom_(y, x) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                bottom_(y, x) = 0;
+        }
+    }
+}
+
+
+void GraphCutSeamFinderGpu::setGraphWeightsColorGrad(
+        const Mat &img1, const Mat &img2, const Mat &dx1, const Mat &dx2,
+        const Mat &dy1, const Mat &dy2, const Mat &mask1, const Mat &mask2,
+        Mat &terminals, Mat &leftT, Mat &rightT, Mat &top, Mat &bottom)
+{
+    const Size img_size = img1.size();
+
+    terminals.create(img_size, CV_32S);
+    leftT.create(Size(img_size.height, img_size.width), CV_32S);
+    rightT.create(Size(img_size.height, img_size.width), CV_32S);
+    top.create(img_size, CV_32S);
+    bottom.create(img_size, CV_32S);
+
+    Mat_<int> terminals_(terminals);
+    Mat_<int> leftT_(leftT);
+    Mat_<int> rightT_(rightT);
+    Mat_<int> top_(top);
+    Mat_<int> bottom_(bottom);
+
+    // Set terminal weights
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            float source = mask1.at<uchar>(y, x) ? terminal_cost_ : 0.f;
+            float sink = mask2.at<uchar>(y, x) ? terminal_cost_ : 0.f;
+            terminals_(y, x) = saturate_cast<int>((source - sink) * 255.f);
+        }
+    }
+
+    // Set regular edge weights
+    const float weight_eps = 1.f;
+    for (int y = 0; y < img_size.height; ++y)
+    {
+        for (int x = 0; x < img_size.width; ++x)
+        {
+            if (x > 0)
+            {
+                float grad = dx1.at<float>(y, x - 1) + dx1.at<float>(y, x) +
+                             dx2.at<float>(y, x - 1) + dx2.at<float>(y, x) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y, x - 1), img2.at<Point3f>(y, x - 1)) +
+                                normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x - 1) || !mask1.at<uchar>(y, x) ||
+                    !mask2.at<uchar>(y, x - 1) || !mask2.at<uchar>(y, x))
+                    weight += bad_region_penalty_;
+                leftT_(x, y) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                leftT_(x, y) = 0;
+
+            if (x < img_size.width - 1)
+            {
+                float grad = dx1.at<float>(y, x) + dx1.at<float>(y, x + 1) +
+                             dx2.at<float>(y, x) + dx2.at<float>(y, x + 1) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                                normL2(img1.at<Point3f>(y, x + 1), img2.at<Point3f>(y, x + 1))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y, x + 1) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y, x + 1))
+                    weight += bad_region_penalty_;
+                rightT_(x, y) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                rightT_(x, y) = 0;
+
+            if (y > 0)
+            {
+                float grad = dy1.at<float>(y - 1, x) + dy1.at<float>(y, x) +
+                             dy2.at<float>(y - 1, x) + dy2.at<float>(y, x) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y - 1, x), img2.at<Point3f>(y - 1, x)) +
+                                normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y - 1, x) || !mask1.at<uchar>(y, x) ||
+                    !mask2.at<uchar>(y - 1, x) || !mask2.at<uchar>(y, x))
+                    weight += bad_region_penalty_;
+                top_(y, x) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                top_(y, x) = 0;
+
+            if (y < img_size.height - 1)
+            {
+                float grad = dy1.at<float>(y, x) + dy1.at<float>(y + 1, x) +
+                             dy2.at<float>(y, x) + dy2.at<float>(y + 1, x) + weight_eps;
+                float weight = (normL2(img1.at<Point3f>(y, x), img2.at<Point3f>(y, x)) +
+                                normL2(img1.at<Point3f>(y + 1, x), img2.at<Point3f>(y + 1, x))) / grad +
+                               weight_eps;
+                if (!mask1.at<uchar>(y, x) || !mask1.at<uchar>(y + 1, x) ||
+                    !mask2.at<uchar>(y, x) || !mask2.at<uchar>(y + 1, x))
+                    weight += bad_region_penalty_;
+                bottom_(y, x) = saturate_cast<int>(weight * 255.f);
+            }
+            else
+                bottom_(y, x) = 0;
+        }
+    }
+}
+#endif
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/stitcher.cpp b/upstream/opencv/modules/stitching/src/stitcher.cpp
new file mode 100644
index 0000000..922e29d
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/stitcher.cpp
@@ -0,0 +1,648 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv {
+
+Ptr<Stitcher> Stitcher::create(Mode mode)
+{
+    Ptr<Stitcher> stitcher = makePtr<Stitcher>();
+
+    stitcher->setRegistrationResol(0.6);
+    stitcher->setSeamEstimationResol(0.1);
+    stitcher->setCompositingResol(ORIG_RESOL);
+    stitcher->setPanoConfidenceThresh(1);
+    stitcher->setSeamFinder(makePtr<detail::GraphCutSeamFinder>(detail::GraphCutSeamFinderBase::COST_COLOR));
+    stitcher->setBlender(makePtr<detail::MultiBandBlender>(false));
+    stitcher->setFeaturesFinder(ORB::create());
+    stitcher->setInterpolationFlags(INTER_LINEAR);
+
+    stitcher->work_scale_ = 1;
+    stitcher->seam_scale_ = 1;
+    stitcher->seam_work_aspect_ = 1;
+    stitcher->warped_image_scale_ = 1;
+
+    switch (mode)
+    {
+    case PANORAMA: // PANORAMA is the default
+        // mostly already setup
+        stitcher->setEstimator(makePtr<detail::HomographyBasedEstimator>());
+        stitcher->setWaveCorrection(true);
+        stitcher->setWaveCorrectKind(detail::WAVE_CORRECT_HORIZ);
+        stitcher->setFeaturesMatcher(makePtr<detail::BestOf2NearestMatcher>(false));
+        stitcher->setBundleAdjuster(makePtr<detail::BundleAdjusterRay>());
+        stitcher->setWarper(makePtr<SphericalWarper>());
+        stitcher->setExposureCompensator(makePtr<detail::BlocksGainCompensator>());
+    break;
+
+    case SCANS:
+        stitcher->setEstimator(makePtr<detail::AffineBasedEstimator>());
+        stitcher->setWaveCorrection(false);
+        stitcher->setFeaturesMatcher(makePtr<detail::AffineBestOf2NearestMatcher>(false, false));
+        stitcher->setBundleAdjuster(makePtr<detail::BundleAdjusterAffinePartial>());
+        stitcher->setWarper(makePtr<AffineWarper>());
+        stitcher->setExposureCompensator(makePtr<detail::NoExposureCompensator>());
+    break;
+
+    default:
+        CV_Error(Error::StsBadArg, "Invalid stitching mode. Must be one of Stitcher::Mode");
+    break;
+    }
+
+    return stitcher;
+}
+
+
+Stitcher::Status Stitcher::estimateTransform(InputArrayOfArrays images, InputArrayOfArrays masks)
+{
+    CV_INSTRUMENT_REGION();
+
+    images.getUMatVector(imgs_);
+    masks.getUMatVector(masks_);
+
+    Status status;
+
+    if ((status = matchImages()) != OK)
+        return status;
+
+    if ((status = estimateCameraParams()) != OK)
+        return status;
+
+    return OK;
+}
+
+
+Stitcher::Status Stitcher::composePanorama(OutputArray pano)
+{
+    CV_INSTRUMENT_REGION();
+
+    return composePanorama(std::vector<UMat>(), pano);
+}
+
+
+Stitcher::Status Stitcher::composePanorama(InputArrayOfArrays images, OutputArray pano)
+{
+    CV_INSTRUMENT_REGION();
+
+    LOGLN("Warping images (auxiliary)... ");
+
+    std::vector<UMat> imgs;
+    images.getUMatVector(imgs);
+    if (!imgs.empty())
+    {
+        CV_Assert(imgs.size() == imgs_.size());
+
+        UMat img;
+        seam_est_imgs_.resize(imgs.size());
+
+        for (size_t i = 0; i < imgs.size(); ++i)
+        {
+            imgs_[i] = imgs[i];
+            resize(imgs[i], img, Size(), seam_scale_, seam_scale_, INTER_LINEAR_EXACT);
+            seam_est_imgs_[i] = img.clone();
+        }
+
+        std::vector<UMat> seam_est_imgs_subset;
+        std::vector<UMat> imgs_subset;
+
+        for (size_t i = 0; i < indices_.size(); ++i)
+        {
+            imgs_subset.push_back(imgs_[indices_[i]]);
+            seam_est_imgs_subset.push_back(seam_est_imgs_[indices_[i]]);
+        }
+
+        seam_est_imgs_ = seam_est_imgs_subset;
+        imgs_ = imgs_subset;
+    }
+
+    UMat pano_;
+
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    std::vector<Point> corners(imgs_.size());
+    std::vector<UMat> masks_warped(imgs_.size());
+    std::vector<UMat> images_warped(imgs_.size());
+    std::vector<Size> sizes(imgs_.size());
+    std::vector<UMat> masks(imgs_.size());
+
+    // Prepare image masks
+    for (size_t i = 0; i < imgs_.size(); ++i)
+    {
+        masks[i].create(seam_est_imgs_[i].size(), CV_8U);
+        masks[i].setTo(Scalar::all(255));
+    }
+
+    // Warp images and their masks
+    Ptr<detail::RotationWarper> w = warper_->create(float(warped_image_scale_ * seam_work_aspect_));
+    for (size_t i = 0; i < imgs_.size(); ++i)
+    {
+        Mat_<float> K;
+        cameras_[i].K().convertTo(K, CV_32F);
+        K(0,0) *= (float)seam_work_aspect_;
+        K(0,2) *= (float)seam_work_aspect_;
+        K(1,1) *= (float)seam_work_aspect_;
+        K(1,2) *= (float)seam_work_aspect_;
+
+        corners[i] = w->warp(seam_est_imgs_[i], K, cameras_[i].R, interp_flags_, BORDER_REFLECT, images_warped[i]);
+        sizes[i] = images_warped[i].size();
+
+        w->warp(masks[i], K, cameras_[i].R, INTER_NEAREST, BORDER_CONSTANT, masks_warped[i]);
+    }
+
+
+    LOGLN("Warping images, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    // Compensate exposure before finding seams
+    exposure_comp_->feed(corners, images_warped, masks_warped);
+    for (size_t i = 0; i < imgs_.size(); ++i)
+        exposure_comp_->apply(int(i), corners[i], images_warped[i], masks_warped[i]);
+
+    // Find seams
+    std::vector<UMat> images_warped_f(imgs_.size());
+    for (size_t i = 0; i < imgs_.size(); ++i)
+        images_warped[i].convertTo(images_warped_f[i], CV_32F);
+    seam_finder_->find(images_warped_f, corners, masks_warped);
+
+    // Release unused memory
+    seam_est_imgs_.clear();
+    images_warped.clear();
+    images_warped_f.clear();
+    masks.clear();
+
+    LOGLN("Compositing...");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+
+    UMat img_warped, img_warped_s;
+    UMat dilated_mask, seam_mask, mask, mask_warped;
+
+    //double compose_seam_aspect = 1;
+    double compose_work_aspect = 1;
+    bool is_blender_prepared = false;
+
+    double compose_scale = 1;
+    bool is_compose_scale_set = false;
+
+    std::vector<detail::CameraParams> cameras_scaled(cameras_);
+
+    UMat full_img, img;
+    for (size_t img_idx = 0; img_idx < imgs_.size(); ++img_idx)
+    {
+        LOGLN("Compositing image #" << indices_[img_idx] + 1);
+#if ENABLE_LOG
+        int64 compositing_t = getTickCount();
+#endif
+
+        // Read image and resize it if necessary
+        full_img = imgs_[img_idx];
+        if (!is_compose_scale_set)
+        {
+            if (compose_resol_ > 0)
+                compose_scale = std::min(1.0, std::sqrt(compose_resol_ * 1e6 / full_img.size().area()));
+            is_compose_scale_set = true;
+
+            // Compute relative scales
+            //compose_seam_aspect = compose_scale / seam_scale_;
+            compose_work_aspect = compose_scale / work_scale_;
+
+            // Update warped image scale
+            float warp_scale = static_cast<float>(warped_image_scale_ * compose_work_aspect);
+            w = warper_->create(warp_scale);
+
+            // Update corners and sizes
+            for (size_t i = 0; i < imgs_.size(); ++i)
+            {
+                // Update intrinsics
+                cameras_scaled[i].ppx *= compose_work_aspect;
+                cameras_scaled[i].ppy *= compose_work_aspect;
+                cameras_scaled[i].focal *= compose_work_aspect;
+
+                // Update corner and size
+                Size sz = full_img_sizes_[i];
+                if (std::abs(compose_scale - 1) > 1e-1)
+                {
+                    sz.width = cvRound(full_img_sizes_[i].width * compose_scale);
+                    sz.height = cvRound(full_img_sizes_[i].height * compose_scale);
+                }
+
+                Mat K;
+                cameras_scaled[i].K().convertTo(K, CV_32F);
+                Rect roi = w->warpRoi(sz, K, cameras_scaled[i].R);
+                corners[i] = roi.tl();
+                sizes[i] = roi.size();
+            }
+        }
+        if (std::abs(compose_scale - 1) > 1e-1)
+        {
+#if ENABLE_LOG
+            int64 resize_t = getTickCount();
+#endif
+            resize(full_img, img, Size(), compose_scale, compose_scale, INTER_LINEAR_EXACT);
+            LOGLN("  resize time: " << ((getTickCount() - resize_t) / getTickFrequency()) << " sec");
+        }
+        else
+            img = full_img;
+        full_img.release();
+        Size img_size = img.size();
+
+        LOGLN(" after resize time: " << ((getTickCount() - compositing_t) / getTickFrequency()) << " sec");
+
+        Mat K;
+        cameras_scaled[img_idx].K().convertTo(K, CV_32F);
+
+#if ENABLE_LOG
+        int64 pt = getTickCount();
+#endif
+        // Warp the current image
+        w->warp(img, K, cameras_[img_idx].R, interp_flags_, BORDER_REFLECT, img_warped);
+        LOGLN(" warp the current image: " << ((getTickCount() - pt) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+        pt = getTickCount();
+#endif
+
+        // Warp the current image mask
+        mask.create(img_size, CV_8U);
+        mask.setTo(Scalar::all(255));
+        w->warp(mask, K, cameras_[img_idx].R, INTER_NEAREST, BORDER_CONSTANT, mask_warped);
+        LOGLN(" warp the current image mask: " << ((getTickCount() - pt) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+        pt = getTickCount();
+#endif
+
+        // Compensate exposure
+        exposure_comp_->apply((int)img_idx, corners[img_idx], img_warped, mask_warped);
+        LOGLN(" compensate exposure: " << ((getTickCount() - pt) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+        pt = getTickCount();
+#endif
+
+        img_warped.convertTo(img_warped_s, CV_16S);
+        img_warped.release();
+        img.release();
+        mask.release();
+
+        // Make sure seam mask has proper size
+        dilate(masks_warped[img_idx], dilated_mask, Mat());
+        resize(dilated_mask, seam_mask, mask_warped.size(), 0, 0, INTER_LINEAR_EXACT);
+
+        bitwise_and(seam_mask, mask_warped, mask_warped);
+
+        LOGLN(" other: " << ((getTickCount() - pt) / getTickFrequency()) << " sec");
+#if ENABLE_LOG
+        pt = getTickCount();
+#endif
+
+        if (!is_blender_prepared)
+        {
+            blender_->prepare(corners, sizes);
+            is_blender_prepared = true;
+        }
+
+        LOGLN(" other2: " << ((getTickCount() - pt) / getTickFrequency()) << " sec");
+
+        LOGLN(" feed...");
+#if ENABLE_LOG
+        int64 feed_t = getTickCount();
+#endif
+        // Blend the current image
+        blender_->feed(img_warped_s, mask_warped, corners[img_idx]);
+        LOGLN(" feed time: " << ((getTickCount() - feed_t) / getTickFrequency()) << " sec");
+        LOGLN("Compositing ## time: " << ((getTickCount() - compositing_t) / getTickFrequency()) << " sec");
+    }
+
+#if ENABLE_LOG
+        int64 blend_t = getTickCount();
+#endif
+    UMat result;
+    blender_->blend(result, result_mask_);
+    LOGLN("blend time: " << ((getTickCount() - blend_t) / getTickFrequency()) << " sec");
+
+    LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    // Preliminary result is in CV_16SC3 format, but all values are in [0,255] range,
+    // so convert it to avoid user confusing
+    result.convertTo(pano, CV_8U);
+
+    return OK;
+}
+
+
+Stitcher::Status Stitcher::stitch(InputArrayOfArrays images, OutputArray pano)
+{
+    return stitch(images, noArray(), pano);
+}
+
+
+Stitcher::Status Stitcher::stitch(InputArrayOfArrays images, InputArrayOfArrays masks, OutputArray pano)
+{
+    CV_INSTRUMENT_REGION();
+
+    Status status = estimateTransform(images, masks);
+    if (status != OK)
+        return status;
+    return composePanorama(pano);
+}
+
+
+Stitcher::Status Stitcher::matchImages()
+{
+    if ((int)imgs_.size() < 2)
+    {
+        LOGLN("Need more images");
+        return ERR_NEED_MORE_IMGS;
+    }
+
+    work_scale_ = 1;
+    seam_work_aspect_ = 1;
+    seam_scale_ = 1;
+    bool is_work_scale_set = false;
+    bool is_seam_scale_set = false;
+    features_.resize(imgs_.size());
+    seam_est_imgs_.resize(imgs_.size());
+    full_img_sizes_.resize(imgs_.size());
+
+    LOGLN("Finding features...");
+#if ENABLE_LOG
+    int64 t = getTickCount();
+#endif
+
+    std::vector<UMat> feature_find_imgs(imgs_.size());
+    std::vector<UMat> feature_find_masks(masks_.size());
+
+    for (size_t i = 0; i < imgs_.size(); ++i)
+    {
+        full_img_sizes_[i] = imgs_[i].size();
+        if (registr_resol_ < 0)
+        {
+            feature_find_imgs[i] = imgs_[i];
+            work_scale_ = 1;
+            is_work_scale_set = true;
+        }
+        else
+        {
+            if (!is_work_scale_set)
+            {
+                work_scale_ = std::min(1.0, std::sqrt(registr_resol_ * 1e6 / full_img_sizes_[i].area()));
+                is_work_scale_set = true;
+            }
+            resize(imgs_[i], feature_find_imgs[i], Size(), work_scale_, work_scale_, INTER_LINEAR_EXACT);
+        }
+        if (!is_seam_scale_set)
+        {
+            seam_scale_ = std::min(1.0, std::sqrt(seam_est_resol_ * 1e6 / full_img_sizes_[i].area()));
+            seam_work_aspect_ = seam_scale_ / work_scale_;
+            is_seam_scale_set = true;
+        }
+
+        if (!masks_.empty())
+        {
+            resize(masks_[i], feature_find_masks[i], Size(), work_scale_, work_scale_, INTER_NEAREST);
+        }
+        features_[i].img_idx = (int)i;
+        LOGLN("Features in image #" << i+1 << ": " << features_[i].keypoints.size());
+
+        resize(imgs_[i], seam_est_imgs_[i], Size(), seam_scale_, seam_scale_, INTER_LINEAR_EXACT);
+    }
+
+    // find features possibly in parallel
+    detail::computeImageFeatures(features_finder_, feature_find_imgs, features_, feature_find_masks);
+
+    // Do it to save memory
+    feature_find_imgs.clear();
+    feature_find_masks.clear();
+
+    LOGLN("Finding features, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    LOG("Pairwise matching");
+#if ENABLE_LOG
+    t = getTickCount();
+#endif
+    (*features_matcher_)(features_, pairwise_matches_, matching_mask_);
+    features_matcher_->collectGarbage();
+    LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
+
+    // Leave only images we are sure are from the same panorama
+    indices_ = detail::leaveBiggestComponent(features_, pairwise_matches_, (float)conf_thresh_);
+    std::vector<UMat> seam_est_imgs_subset;
+    std::vector<UMat> imgs_subset;
+    std::vector<Size> full_img_sizes_subset;
+    for (size_t i = 0; i < indices_.size(); ++i)
+    {
+        imgs_subset.push_back(imgs_[indices_[i]]);
+        seam_est_imgs_subset.push_back(seam_est_imgs_[indices_[i]]);
+        full_img_sizes_subset.push_back(full_img_sizes_[indices_[i]]);
+    }
+    seam_est_imgs_ = seam_est_imgs_subset;
+    imgs_ = imgs_subset;
+    full_img_sizes_ = full_img_sizes_subset;
+
+    if ((int)imgs_.size() < 2)
+    {
+        LOGLN("Need more images");
+        return ERR_NEED_MORE_IMGS;
+    }
+
+    return OK;
+}
+
+
+Stitcher::Status Stitcher::estimateCameraParams()
+{
+    // estimate homography in global frame
+    if (!(*estimator_)(features_, pairwise_matches_, cameras_))
+        return ERR_HOMOGRAPHY_EST_FAIL;
+
+    for (size_t i = 0; i < cameras_.size(); ++i)
+    {
+        Mat R;
+        cameras_[i].R.convertTo(R, CV_32F);
+        cameras_[i].R = R;
+        //LOGLN("Initial intrinsic parameters #" << indices_[i] + 1 << ":\n " << cameras_[i].K());
+    }
+
+    bundle_adjuster_->setConfThresh(conf_thresh_);
+    if (!(*bundle_adjuster_)(features_, pairwise_matches_, cameras_))
+        return ERR_CAMERA_PARAMS_ADJUST_FAIL;
+
+    // Find median focal length and use it as final image scale
+    std::vector<double> focals;
+    for (size_t i = 0; i < cameras_.size(); ++i)
+    {
+        //LOGLN("Camera #" << indices_[i] + 1 << ":\n" << cameras_[i].K());
+        focals.push_back(cameras_[i].focal);
+    }
+
+    std::sort(focals.begin(), focals.end());
+    if (focals.size() % 2 == 1)
+        warped_image_scale_ = static_cast<float>(focals[focals.size() / 2]);
+    else
+        warped_image_scale_ = static_cast<float>(focals[focals.size() / 2 - 1] + focals[focals.size() / 2]) * 0.5f;
+
+    if (do_wave_correct_)
+    {
+        std::vector<Mat> rmats;
+        for (size_t i = 0; i < cameras_.size(); ++i)
+            rmats.push_back(cameras_[i].R.clone());
+        detail::waveCorrect(rmats, wave_correct_kind_);
+        for (size_t i = 0; i < cameras_.size(); ++i)
+            cameras_[i].R = rmats[i];
+    }
+
+    return OK;
+}
+
+Stitcher::Status Stitcher::setTransform(InputArrayOfArrays images, const std::vector<detail::CameraParams> &cameras)
+{
+    std::vector<int> component;
+    for (int i = 0; i < (int)images.total(); i++)
+        component.push_back(i);
+
+    return setTransform(images, cameras, component);
+}
+
+
+Stitcher::Status Stitcher::setTransform(
+        InputArrayOfArrays images, const std::vector<detail::CameraParams> &cameras, const std::vector<int> &component)
+{
+//    CV_Assert(images.size() == cameras.size());
+
+    images.getUMatVector(imgs_);
+    masks_.clear();
+
+    if ((int)imgs_.size() < 2)
+    {
+        LOGLN("Need more images");
+        return ERR_NEED_MORE_IMGS;
+    }
+
+    work_scale_ = 1;
+    seam_work_aspect_ = 1;
+    seam_scale_ = 1;
+    bool is_work_scale_set = false;
+    bool is_seam_scale_set = false;
+    seam_est_imgs_.resize(imgs_.size());
+    full_img_sizes_.resize(imgs_.size());
+
+
+    for (size_t i = 0; i < imgs_.size(); ++i)
+    {
+        full_img_sizes_[i] = imgs_[i].size();
+        if (registr_resol_ < 0)
+        {
+            work_scale_ = 1;
+            is_work_scale_set = true;
+        }
+        else
+        {
+            if (!is_work_scale_set)
+            {
+                work_scale_ = std::min(1.0, std::sqrt(registr_resol_ * 1e6 / full_img_sizes_[i].area()));
+                is_work_scale_set = true;
+            }
+        }
+        if (!is_seam_scale_set)
+        {
+            seam_scale_ = std::min(1.0, std::sqrt(seam_est_resol_ * 1e6 / full_img_sizes_[i].area()));
+            seam_work_aspect_ = seam_scale_ / work_scale_;
+            is_seam_scale_set = true;
+        }
+
+        resize(imgs_[i], seam_est_imgs_[i], Size(), seam_scale_, seam_scale_, INTER_LINEAR_EXACT);
+    }
+
+    features_.clear();
+    pairwise_matches_.clear();
+
+    indices_ = component;
+    std::vector<UMat> seam_est_imgs_subset;
+    std::vector<UMat> imgs_subset;
+    std::vector<Size> full_img_sizes_subset;
+    for (size_t i = 0; i < indices_.size(); ++i)
+    {
+        imgs_subset.push_back(imgs_[indices_[i]]);
+        seam_est_imgs_subset.push_back(seam_est_imgs_[indices_[i]]);
+        full_img_sizes_subset.push_back(full_img_sizes_[indices_[i]]);
+    }
+    seam_est_imgs_ = seam_est_imgs_subset;
+    imgs_ = imgs_subset;
+    full_img_sizes_ = full_img_sizes_subset;
+
+    if ((int)imgs_.size() < 2)
+    {
+        LOGLN("Need more images");
+        return ERR_NEED_MORE_IMGS;
+    }
+
+    cameras_ = cameras;
+
+    std::vector<double> focals;
+    for (size_t i = 0; i < cameras.size(); ++i)
+        focals.push_back(cameras_[i].focal);
+
+    std::sort(focals.begin(), focals.end());
+    if (focals.size() % 2 == 1)
+        warped_image_scale_ = static_cast<float>(focals[focals.size() / 2]);
+    else
+        warped_image_scale_ = static_cast<float>(focals[focals.size() / 2 - 1] + focals[focals.size() / 2]) * 0.5f;
+
+    return Status::OK;
+}
+
+
+CV_DEPRECATED Ptr<Stitcher> createStitcher(bool /*ignored*/)
+{
+    CV_INSTRUMENT_REGION();
+
+    return Stitcher::create(Stitcher::PANORAMA);
+}
+
+CV_DEPRECATED Ptr<Stitcher> createStitcherScans(bool /*ignored*/)
+{
+    CV_INSTRUMENT_REGION();
+
+    return Stitcher::create(Stitcher::SCANS);
+}
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/timelapsers.cpp b/upstream/opencv/modules/stitching/src/timelapsers.cpp
new file mode 100644
index 0000000..30febaa
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/timelapsers.cpp
@@ -0,0 +1,108 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_stitching.hpp"
+
+namespace cv {
+namespace detail {
+
+Ptr<Timelapser> Timelapser::createDefault(int type)
+{
+    if (type == AS_IS)
+        return makePtr<Timelapser>();
+    if (type == CROP)
+        return makePtr<TimelapserCrop>();
+    CV_Error(Error::StsBadArg, "unsupported timelapsing method");
+}
+
+
+void Timelapser::initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes)
+{
+    dst_roi_ = resultRoi(corners, sizes);
+    dst_.create(dst_roi_.size(), CV_16SC3);
+}
+
+void Timelapser::process(InputArray _img, InputArray /*_mask*/, Point tl)
+{
+    CV_INSTRUMENT_REGION();
+
+    dst_.setTo(Scalar::all(0));
+
+    Mat img = _img.getMat();
+    Mat dst = dst_.getMat(ACCESS_RW);
+
+    CV_Assert(img.type() == CV_16SC3);
+    int dx = tl.x - dst_roi_.x;
+    int dy = tl.y - dst_roi_.y;
+
+    for (int y = 0; y < img.rows; ++y)
+    {
+        const Point3_<short> *src_row = img.ptr<Point3_<short> >(y);
+
+        for (int x = 0; x < img.cols; ++x)
+        {
+            if (test_point(Point(tl.x + x, tl.y + y)))
+            {
+                Point3_<short> *dst_row = dst.ptr<Point3_<short> >(dy + y);
+                dst_row[dx + x] = src_row[x];
+            }
+        }
+    }
+}
+
+
+bool Timelapser::test_point(Point pt)
+{
+    return dst_roi_.contains(pt);
+}
+
+
+void TimelapserCrop::initialize(const std::vector<Point> &corners, const std::vector<Size> &sizes)
+{
+    dst_roi_ = resultRoiIntersection(corners, sizes);
+    dst_.create(dst_roi_.size(), CV_16SC3);
+}
+
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/util.cpp b/upstream/opencv/modules/stitching/src/util.cpp
new file mode 100644
index 0000000..ce36d9d
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/util.cpp
@@ -0,0 +1,188 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+namespace cv {
+namespace detail {
+
+void DisjointSets::createOneElemSets(int n)
+{
+    rank_.assign(n, 0);
+    size.assign(n, 1);
+    parent.resize(n);
+    for (int i = 0; i < n; ++i)
+        parent[i] = i;
+}
+
+
+int DisjointSets::findSetByElem(int elem)
+{
+    int set = elem;
+    while (set != parent[set])
+        set = parent[set];
+    int next;
+    while (elem != parent[elem])
+    {
+        next = parent[elem];
+        parent[elem] = set;
+        elem = next;
+    }
+    return set;
+}
+
+
+int DisjointSets::mergeSets(int set1, int set2)
+{
+    if (rank_[set1] < rank_[set2])
+    {
+        parent[set1] = set2;
+        size[set2] += size[set1];
+        return set2;
+    }
+    if (rank_[set2] < rank_[set1])
+    {
+        parent[set2] = set1;
+        size[set1] += size[set2];
+        return set1;
+    }
+    parent[set1] = set2;
+    rank_[set2]++;
+    size[set2] += size[set1];
+    return set2;
+}
+
+
+void Graph::addEdge(int from, int to, float weight)
+{
+    edges_[from].push_back(GraphEdge(from, to, weight));
+}
+
+
+bool overlapRoi(Point tl1, Point tl2, Size sz1, Size sz2, Rect &roi)
+{
+    int x_tl = std::max(tl1.x, tl2.x);
+    int y_tl = std::max(tl1.y, tl2.y);
+    int x_br = std::min(tl1.x + sz1.width, tl2.x + sz2.width);
+    int y_br = std::min(tl1.y + sz1.height, tl2.y + sz2.height);
+    if (x_tl < x_br && y_tl < y_br)
+    {
+        roi = Rect(x_tl, y_tl, x_br - x_tl, y_br - y_tl);
+        return true;
+    }
+    return false;
+}
+
+
+Rect resultRoi(const std::vector<Point> &corners, const std::vector<UMat> &images)
+{
+    std::vector<Size> sizes(images.size());
+    for (size_t i = 0; i < images.size(); ++i)
+        sizes[i] = images[i].size();
+    return resultRoi(corners, sizes);
+}
+
+
+Rect resultRoi(const std::vector<Point> &corners, const std::vector<Size> &sizes)
+{
+    CV_Assert(sizes.size() == corners.size());
+    Point tl(std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
+    Point br(std::numeric_limits<int>::min(), std::numeric_limits<int>::min());
+    for (size_t i = 0; i < corners.size(); ++i)
+    {
+        tl.x = std::min(tl.x, corners[i].x);
+        tl.y = std::min(tl.y, corners[i].y);
+        br.x = std::max(br.x, corners[i].x + sizes[i].width);
+        br.y = std::max(br.y, corners[i].y + sizes[i].height);
+    }
+    return Rect(tl, br);
+}
+
+Rect resultRoiIntersection(const std::vector<Point> &corners, const std::vector<Size> &sizes)
+{
+    CV_Assert(sizes.size() == corners.size());
+    Point tl(std::numeric_limits<int>::min(), std::numeric_limits<int>::min());
+    Point br(std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
+    for (size_t i = 0; i < corners.size(); ++i)
+    {
+        tl.x = std::max(tl.x, corners[i].x);
+        tl.y = std::max(tl.y, corners[i].y);
+        br.x = std::min(br.x, corners[i].x + sizes[i].width);
+        br.y = std::min(br.y, corners[i].y + sizes[i].height);
+    }
+    return Rect(tl, br);
+}
+
+
+Point resultTl(const std::vector<Point> &corners)
+{
+    Point tl(std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
+    for (size_t i = 0; i < corners.size(); ++i)
+    {
+        tl.x = std::min(tl.x, corners[i].x);
+        tl.y = std::min(tl.y, corners[i].y);
+    }
+    return tl;
+}
+
+
+void selectRandomSubset(int count, int size, std::vector<int> &subset)
+{
+    subset.clear();
+    for (int i = 0; i < size; ++i)
+    {
+        if (randu<int>() % (size - i) < count)
+        {
+            subset.push_back(i);
+            count--;
+        }
+    }
+}
+
+int& stitchingLogLevel()
+{
+    static int _log_level=1;
+    return _log_level;
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/util_log.hpp b/upstream/opencv/modules/stitching/src/util_log.hpp
new file mode 100644
index 0000000..edaaf38
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/util_log.hpp
@@ -0,0 +1,58 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_STITCHING_UTIL_LOG_HPP__
+#define __OPENCV_STITCHING_UTIL_LOG_HPP__
+
+#ifndef ENABLE_LOG
+#define ENABLE_LOG 0
+#endif
+
+// TODO remove LOG macros, add logging class
+#if ENABLE_LOG
+#ifdef __ANDROID__
+  #include <iostream>
+  #include <sstream>
+  #include <android/log.h>
+  #define LOG_STITCHING_MSG(msg) \
+    do { \
+        Stringstream _os; \
+        _os << msg; \
+       __android_log_print(ANDROID_LOG_DEBUG, "STITCHING", "%s", _os.str().c_str()); \
+    } while(0);
+#else
+  #include <iostream>
+  #define LOG_STITCHING_MSG(msg) for(;;) { std::cout << msg; std::cout.flush(); break; }
+#endif
+#else
+  #define LOG_STITCHING_MSG(msg)
+#endif
+
+#define LOG_(_level, _msg)                     \
+    for(;;)                                    \
+    {                                          \
+        using namespace std;                   \
+        if ((_level) >= ::cv::detail::stitchingLogLevel()) \
+        {                                      \
+            LOG_STITCHING_MSG(_msg);           \
+        }                                      \
+    break;                                 \
+    }
+
+
+#define LOG(msg) LOG_(1, msg)
+#define LOG_CHAT(msg) LOG_(0, msg)
+
+#define LOGLN(msg) LOG(msg << std::endl)
+#define LOGLN_CHAT(msg) LOG_CHAT(msg << std::endl)
+
+//#if DEBUG_LOG_CHAT
+//  #define LOG_CHAT(msg) LOG(msg)
+//  #define LOGLN_CHAT(msg) LOGLN(msg)
+//#else
+//  #define LOG_CHAT(msg) do{}while(0)
+//  #define LOGLN_CHAT(msg) do{}while(0)
+//#endif
+
+#endif // __OPENCV_STITCHING_UTIL_LOG_HPP__
diff --git a/upstream/opencv/modules/stitching/src/warpers.cpp b/upstream/opencv/modules/stitching/src/warpers.cpp
new file mode 100644
index 0000000..c492ec3
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/warpers.cpp
@@ -0,0 +1,559 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_stitching.hpp"
+#include <iostream>
+namespace cv {
+
+PyRotationWarper::PyRotationWarper(String warp_type, float scale)
+{
+    Ptr<WarperCreator> warper_creator;
+    if (warp_type == "plane")
+        warper_creator = makePtr<cv::PlaneWarper>();
+    else if (warp_type == "affine")
+        warper_creator = makePtr<cv::AffineWarper>();
+    else if (warp_type == "cylindrical")
+        warper_creator = makePtr<cv::CylindricalWarper>();
+    else if (warp_type == "spherical")
+        warper_creator = makePtr<cv::SphericalWarper>();
+    else if (warp_type == "fisheye")
+        warper_creator = makePtr<cv::FisheyeWarper>();
+    else if (warp_type == "stereographic")
+        warper_creator = makePtr<cv::StereographicWarper>();
+    else if (warp_type == "compressedPlaneA2B1")
+        warper_creator = makePtr<cv::CompressedRectilinearWarper>(2.0f, 1.0f);
+    else if (warp_type == "compressedPlaneA1.5B1")
+        warper_creator = makePtr<cv::CompressedRectilinearWarper>(1.5f, 1.0f);
+    else if (warp_type == "compressedPlanePortraitA2B1")
+        warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(2.0f, 1.0f);
+    else if (warp_type == "compressedPlanePortraitA1.5B1")
+        warper_creator = makePtr<cv::CompressedRectilinearPortraitWarper>(1.5f, 1.0f);
+    else if (warp_type == "paniniA2B1")
+        warper_creator = makePtr<cv::PaniniWarper>(2.0f, 1.0f);
+    else if (warp_type == "paniniA1.5B1")
+        warper_creator = makePtr<cv::PaniniWarper>(1.5f, 1.0f);
+    else if (warp_type == "paniniPortraitA2B1")
+        warper_creator = makePtr<cv::PaniniPortraitWarper>(2.0f, 1.0f);
+    else if (warp_type == "paniniPortraitA1.5B1")
+        warper_creator = makePtr<cv::PaniniPortraitWarper>(1.5f, 1.0f);
+    else if (warp_type == "mercator")
+        warper_creator = makePtr<cv::MercatorWarper>();
+    else if (warp_type == "transverseMercator")
+        warper_creator = makePtr<cv::TransverseMercatorWarper>();
+    if (warper_creator.get() != nullptr)
+    {
+        rw = warper_creator->create(scale);
+
+    }
+    else
+        CV_Error(Error::StsError, "unknown warper :" + warp_type);
+}
+Point2f PyRotationWarper::warpPoint(const Point2f &pt, InputArray K, InputArray R)
+{
+    return rw.get()->warpPoint(pt, K, R);
+}
+
+Point2f PyRotationWarper::warpPointBackward(const Point2f& pt, InputArray K, InputArray R)
+{
+    return rw.get()->warpPointBackward(pt, K, R);
+}
+
+Rect PyRotationWarper::buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+{
+    return rw.get()->buildMaps(src_size, K, R, xmap, ymap);
+}
+Point PyRotationWarper::warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+    OutputArray dst)
+{
+    if (rw.get() == nullptr)
+        CV_Error(Error::StsError, "Warper is null");
+    Point p = rw.get()->warp(src, K, R, interp_mode, border_mode, dst);
+    return p;
+
+}
+void PyRotationWarper::warpBackward(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode,
+    Size dst_size, OutputArray dst)
+{
+    return rw.get()->warpBackward(src, K, R, interp_mode, border_mode, dst_size, dst);
+}
+Rect PyRotationWarper::warpRoi(Size src_size, InputArray K, InputArray R)
+{
+    return rw.get()->warpRoi(src_size, K, R);
+}
+
+namespace detail {
+
+void ProjectorBase::setCameraParams(InputArray _K, InputArray _R, InputArray _T)
+{
+    Mat K = _K.getMat(), R = _R.getMat(), T = _T.getMat();
+
+    CV_Assert(K.size() == Size(3, 3) && K.type() == CV_32F);
+    CV_Assert(R.size() == Size(3, 3) && R.type() == CV_32F);
+    CV_Assert((T.size() == Size(1, 3) || T.size() == Size(3, 1)) && T.type() == CV_32F);
+
+    Mat_<float> K_(K);
+    k[0] = K_(0,0); k[1] = K_(0,1); k[2] = K_(0,2);
+    k[3] = K_(1,0); k[4] = K_(1,1); k[5] = K_(1,2);
+    k[6] = K_(2,0); k[7] = K_(2,1); k[8] = K_(2,2);
+
+    Mat_<float> Rinv = R.t();
+    rinv[0] = Rinv(0,0); rinv[1] = Rinv(0,1); rinv[2] = Rinv(0,2);
+    rinv[3] = Rinv(1,0); rinv[4] = Rinv(1,1); rinv[5] = Rinv(1,2);
+    rinv[6] = Rinv(2,0); rinv[7] = Rinv(2,1); rinv[8] = Rinv(2,2);
+
+    Mat_<float> R_Kinv = R * K.inv();
+    r_kinv[0] = R_Kinv(0,0); r_kinv[1] = R_Kinv(0,1); r_kinv[2] = R_Kinv(0,2);
+    r_kinv[3] = R_Kinv(1,0); r_kinv[4] = R_Kinv(1,1); r_kinv[5] = R_Kinv(1,2);
+    r_kinv[6] = R_Kinv(2,0); r_kinv[7] = R_Kinv(2,1); r_kinv[8] = R_Kinv(2,2);
+
+    Mat_<float> K_Rinv = K * Rinv;
+    k_rinv[0] = K_Rinv(0,0); k_rinv[1] = K_Rinv(0,1); k_rinv[2] = K_Rinv(0,2);
+    k_rinv[3] = K_Rinv(1,0); k_rinv[4] = K_Rinv(1,1); k_rinv[5] = K_Rinv(1,2);
+    k_rinv[6] = K_Rinv(2,0); k_rinv[7] = K_Rinv(2,1); k_rinv[8] = K_Rinv(2,2);
+
+    Mat_<float> T_(T.reshape(0, 3));
+    t[0] = T_(0,0); t[1] = T_(1,0); t[2] = T_(2,0);
+}
+
+
+Point2f PlaneWarper::warpPoint(const Point2f &pt, InputArray K, InputArray R, InputArray T)
+{
+    projector_.setCameraParams(K, R, T);
+    Point2f uv;
+    projector_.mapForward(pt.x, pt.y, uv.x, uv.y);
+    return uv;
+}
+
+Point2f PlaneWarper::warpPoint(const Point2f &pt, InputArray K, InputArray R)
+{
+    float tz[] = {0.f, 0.f, 0.f};
+    Mat_<float> T(3, 1, tz);
+    return warpPoint(pt, K, R, T);
+}
+Point2f PlaneWarper::warpPointBackward(const Point2f& pt, InputArray K, InputArray R, InputArray T)
+{
+    projector_.setCameraParams(K, R, T);
+    Point2f xy;
+    projector_.mapBackward(pt.x, pt.y, xy.x, xy.y);
+    return xy;
+}
+
+Point2f PlaneWarper::warpPointBackward(const Point2f& pt, InputArray K, InputArray R)
+{
+    float tz[] = { 0.f, 0.f, 0.f };
+    Mat_<float> T(3, 1, tz);
+    return warpPointBackward(pt, K, R, T);
+}
+
+Rect PlaneWarper::buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+{
+    return buildMaps(src_size, K, R, Mat::zeros(3, 1, CV_32FC1), xmap, ymap);
+}
+
+Rect PlaneWarper::buildMaps(Size src_size, InputArray K, InputArray R, InputArray T, OutputArray _xmap, OutputArray _ymap)
+{
+    projector_.setCameraParams(K, R, T);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    Size dsize(dst_br.x - dst_tl.x + 1, dst_br.y - dst_tl.y + 1);
+    _xmap.create(dsize, CV_32FC1);
+    _ymap.create(dsize, CV_32FC1);
+
+#ifdef HAVE_OPENCL
+    if (ocl::isOpenCLActivated())
+    {
+        ocl::Kernel k("buildWarpPlaneMaps", ocl::stitching::warpers_oclsrc);
+        if (!k.empty())
+        {
+            int rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
+            Mat k_rinv(1, 9, CV_32FC1, projector_.k_rinv), t(1, 3, CV_32FC1, projector_.t);
+            UMat uxmap = _xmap.getUMat(), uymap = _ymap.getUMat(),
+                    uk_rinv = k_rinv.getUMat(ACCESS_READ), ut = t.getUMat(ACCESS_READ);
+
+            k.args(ocl::KernelArg::WriteOnlyNoSize(uxmap), ocl::KernelArg::WriteOnly(uymap),
+                   ocl::KernelArg::PtrReadOnly(uk_rinv), ocl::KernelArg::PtrReadOnly(ut),
+                   dst_tl.x, dst_tl.y, 1/projector_.scale, rowsPerWI);
+
+            size_t globalsize[2] = { (size_t)dsize.width, ((size_t)dsize.height + rowsPerWI - 1) / rowsPerWI };
+            if (k.run(2, globalsize, NULL, true))
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return Rect(dst_tl, dst_br);
+            }
+        }
+    }
+#endif
+
+    Mat xmap = _xmap.getMat(), ymap = _ymap.getMat();
+
+    float x, y;
+    for (int v = dst_tl.y; v <= dst_br.y; ++v)
+    {
+        for (int u = dst_tl.x; u <= dst_br.x; ++u)
+        {
+            projector_.mapBackward(static_cast<float>(u), static_cast<float>(v), x, y);
+            xmap.at<float>(v - dst_tl.y, u - dst_tl.x) = x;
+            ymap.at<float>(v - dst_tl.y, u - dst_tl.x) = y;
+        }
+    }
+
+    return Rect(dst_tl, dst_br);
+}
+
+
+Point PlaneWarper::warp(InputArray src, InputArray K, InputArray R, InputArray T, int interp_mode, int border_mode,
+                        OutputArray dst)
+{
+    UMat uxmap, uymap;
+    Rect dst_roi = buildMaps(src.size(), K, R, T, uxmap, uymap);
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    remap(src, dst, uxmap, uymap, interp_mode, border_mode);
+
+    return dst_roi.tl();
+}
+
+Point PlaneWarper::warp(InputArray src, InputArray K, InputArray R,
+                        int interp_mode, int border_mode, OutputArray dst)
+{
+    float tz[] = {0.f, 0.f, 0.f};
+    Mat_<float> T(3, 1, tz);
+    return warp(src, K, R, T, interp_mode, border_mode, dst);
+}
+
+Rect PlaneWarper::warpRoi(Size src_size, InputArray K, InputArray R, InputArray T)
+{
+    projector_.setCameraParams(K, R, T);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    return Rect(dst_tl, Point(dst_br.x + 1, dst_br.y + 1));
+}
+
+Rect PlaneWarper::warpRoi(Size src_size, InputArray K, InputArray R)
+{
+    float tz[] = {0.f, 0.f, 0.f};
+    Mat_<float> T(3, 1, tz);
+    return warpRoi(src_size, K, R, T);
+}
+
+
+void PlaneWarper::detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+{
+    float tl_uf = std::numeric_limits<float>::max();
+    float tl_vf = std::numeric_limits<float>::max();
+    float br_uf = -std::numeric_limits<float>::max();
+    float br_vf = -std::numeric_limits<float>::max();
+
+    float u, v;
+
+    projector_.mapForward(0, 0, u, v);
+    tl_uf = std::min(tl_uf, u); tl_vf = std::min(tl_vf, v);
+    br_uf = std::max(br_uf, u); br_vf = std::max(br_vf, v);
+
+    projector_.mapForward(0, static_cast<float>(src_size.height - 1), u, v);
+    tl_uf = std::min(tl_uf, u); tl_vf = std::min(tl_vf, v);
+    br_uf = std::max(br_uf, u); br_vf = std::max(br_vf, v);
+
+    projector_.mapForward(static_cast<float>(src_size.width - 1), 0, u, v);
+    tl_uf = std::min(tl_uf, u); tl_vf = std::min(tl_vf, v);
+    br_uf = std::max(br_uf, u); br_vf = std::max(br_vf, v);
+
+    projector_.mapForward(static_cast<float>(src_size.width - 1), static_cast<float>(src_size.height - 1), u, v);
+    tl_uf = std::min(tl_uf, u); tl_vf = std::min(tl_vf, v);
+    br_uf = std::max(br_uf, u); br_vf = std::max(br_vf, v);
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+
+Point2f AffineWarper::warpPoint(const Point2f &pt, InputArray K, InputArray H)
+{
+    Mat R, T;
+    getRTfromHomogeneous(H, R, T);
+    return PlaneWarper::warpPoint(pt, K, R, T);
+}
+
+Point2f AffineWarper::warpPointBackward(const Point2f& pt, InputArray K, InputArray H)
+{
+    Mat R, T;
+    getRTfromHomogeneous(H, R, T);
+    return PlaneWarper::warpPointBackward(pt, K, R, T);
+}
+
+Rect AffineWarper::buildMaps(Size src_size, InputArray K, InputArray H, OutputArray xmap, OutputArray ymap)
+{
+    Mat R, T;
+    getRTfromHomogeneous(H, R, T);
+    return PlaneWarper::buildMaps(src_size, K, R, T, xmap, ymap);
+}
+
+
+Point AffineWarper::warp(InputArray src, InputArray K, InputArray H,
+                         int interp_mode, int border_mode, OutputArray dst)
+{
+    Mat R, T;
+    getRTfromHomogeneous(H, R, T);
+    return PlaneWarper::warp(src, K, R, T, interp_mode, border_mode, dst);
+}
+
+
+Rect AffineWarper::warpRoi(Size src_size, InputArray K, InputArray H)
+{
+    Mat R, T;
+    getRTfromHomogeneous(H, R, T);
+    return PlaneWarper::warpRoi(src_size, K, R, T);
+}
+
+
+void AffineWarper::getRTfromHomogeneous(InputArray H_, Mat &R, Mat &T)
+{
+    Mat H = H_.getMat();
+    CV_Assert(H.size() == Size(3, 3) && H.type() == CV_32F);
+
+    T = Mat::zeros(3, 1, CV_32F);
+    R = H.clone();
+
+    T.at<float>(0,0) = R.at<float>(0,2);
+    T.at<float>(1,0) = R.at<float>(1,2);
+    R.at<float>(0,2) = 0.f;
+    R.at<float>(1,2) = 0.f;
+
+    // we want to compensate transform to fit into plane warper
+    R = R.t();
+    T = (R * T) * -1;
+}
+
+
+void SphericalWarper::detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+{
+    detectResultRoiByBorder(src_size, dst_tl, dst_br);
+
+    float tl_uf = static_cast<float>(dst_tl.x);
+    float tl_vf = static_cast<float>(dst_tl.y);
+    float br_uf = static_cast<float>(dst_br.x);
+    float br_vf = static_cast<float>(dst_br.y);
+
+    float x = projector_.rinv[1];
+    float y = projector_.rinv[4];
+    float z = projector_.rinv[7];
+    if (y > 0.f)
+    {
+        float x_ = (projector_.k[0] * x + projector_.k[1] * y) / z + projector_.k[2];
+        float y_ = projector_.k[4] * y / z + projector_.k[5];
+        if (x_ > 0.f && x_ < src_size.width && y_ > 0.f && y_ < src_size.height)
+        {
+            tl_uf = std::min(tl_uf, 0.f); tl_vf = std::min(tl_vf, static_cast<float>(CV_PI * projector_.scale));
+            br_uf = std::max(br_uf, 0.f); br_vf = std::max(br_vf, static_cast<float>(CV_PI * projector_.scale));
+        }
+    }
+
+    x = projector_.rinv[1];
+    y = -projector_.rinv[4];
+    z = projector_.rinv[7];
+    if (y > 0.f)
+    {
+        float x_ = (projector_.k[0] * x + projector_.k[1] * y) / z + projector_.k[2];
+        float y_ = projector_.k[4] * y / z + projector_.k[5];
+        if (x_ > 0.f && x_ < src_size.width && y_ > 0.f && y_ < src_size.height)
+        {
+            tl_uf = std::min(tl_uf, 0.f); tl_vf = std::min(tl_vf, static_cast<float>(0));
+            br_uf = std::max(br_uf, 0.f); br_vf = std::max(br_vf, static_cast<float>(0));
+        }
+    }
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+void SphericalPortraitWarper::detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
+{
+    detectResultRoiByBorder(src_size, dst_tl, dst_br);
+
+    float tl_uf = static_cast<float>(dst_tl.x);
+    float tl_vf = static_cast<float>(dst_tl.y);
+    float br_uf = static_cast<float>(dst_br.x);
+    float br_vf = static_cast<float>(dst_br.y);
+
+    float x = projector_.rinv[0];
+    float y = projector_.rinv[3];
+    float z = projector_.rinv[6];
+    if (y > 0.f)
+    {
+        float x_ = (projector_.k[0] * x + projector_.k[1] * y) / z + projector_.k[2];
+        float y_ = projector_.k[4] * y / z + projector_.k[5];
+        if (x_ > 0.f && x_ < src_size.width && y_ > 0.f && y_ < src_size.height)
+        {
+            tl_uf = std::min(tl_uf, 0.f); tl_vf = std::min(tl_vf, static_cast<float>(CV_PI * projector_.scale));
+            br_uf = std::max(br_uf, 0.f); br_vf = std::max(br_vf, static_cast<float>(CV_PI * projector_.scale));
+        }
+    }
+
+    x = projector_.rinv[0];
+    y = -projector_.rinv[3];
+    z = projector_.rinv[6];
+    if (y > 0.f)
+    {
+        float x_ = (projector_.k[0] * x + projector_.k[1] * y) / z + projector_.k[2];
+        float y_ = projector_.k[4] * y / z + projector_.k[5];
+        if (x_ > 0.f && x_ < src_size.width && y_ > 0.f && y_ < src_size.height)
+        {
+            tl_uf = std::min(tl_uf, 0.f); tl_vf = std::min(tl_vf, static_cast<float>(0));
+            br_uf = std::max(br_uf, 0.f); br_vf = std::max(br_vf, static_cast<float>(0));
+        }
+    }
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+/////////////////////////////////////////// SphericalWarper ////////////////////////////////////////
+
+Rect SphericalWarper::buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+{
+#ifdef HAVE_OPENCL
+    if (ocl::isOpenCLActivated())
+    {
+        ocl::Kernel k("buildWarpSphericalMaps", ocl::stitching::warpers_oclsrc);
+        if (!k.empty())
+        {
+            int rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
+            projector_.setCameraParams(K, R);
+
+            Point dst_tl, dst_br;
+            detectResultRoi(src_size, dst_tl, dst_br);
+
+            Size dsize(dst_br.x - dst_tl.x + 1, dst_br.y - dst_tl.y + 1);
+            xmap.create(dsize, CV_32FC1);
+            ymap.create(dsize, CV_32FC1);
+
+            Mat k_rinv(1, 9, CV_32FC1, projector_.k_rinv);
+            UMat uxmap = xmap.getUMat(), uymap = ymap.getUMat(), uk_rinv = k_rinv.getUMat(ACCESS_READ);
+
+            k.args(ocl::KernelArg::WriteOnlyNoSize(uxmap), ocl::KernelArg::WriteOnly(uymap),
+                   ocl::KernelArg::PtrReadOnly(uk_rinv), dst_tl.x, dst_tl.y, 1/projector_.scale, rowsPerWI);
+
+            size_t globalsize[2] = { (size_t)dsize.width, ((size_t)dsize.height + rowsPerWI - 1) / rowsPerWI };
+            if (k.run(2, globalsize, NULL, true))
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return Rect(dst_tl, dst_br);
+            }
+        }
+    }
+#endif
+    return RotationWarperBase<SphericalProjector>::buildMaps(src_size, K, R, xmap, ymap);
+}
+
+Point SphericalWarper::warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst)
+{
+    UMat uxmap, uymap;
+    Rect dst_roi = buildMaps(src.size(), K, R, uxmap, uymap);
+
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    remap(src, dst, uxmap, uymap, interp_mode, border_mode);
+
+    return dst_roi.tl();
+}
+
+/////////////////////////////////////////// CylindricalWarper ////////////////////////////////////////
+
+Rect CylindricalWarper::buildMaps(Size src_size, InputArray K, InputArray R, OutputArray xmap, OutputArray ymap)
+{
+#ifdef HAVE_OPENCL
+    if (ocl::isOpenCLActivated())
+    {
+        ocl::Kernel k("buildWarpCylindricalMaps", ocl::stitching::warpers_oclsrc);
+        if (!k.empty())
+        {
+            int rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
+            projector_.setCameraParams(K, R);
+
+            Point dst_tl, dst_br;
+            detectResultRoi(src_size, dst_tl, dst_br);
+
+            Size dsize(dst_br.x - dst_tl.x + 1, dst_br.y - dst_tl.y + 1);
+            xmap.create(dsize, CV_32FC1);
+            ymap.create(dsize, CV_32FC1);
+
+            Mat k_rinv(1, 9, CV_32FC1, projector_.k_rinv);
+            UMat uxmap = xmap.getUMat(), uymap = ymap.getUMat(), uk_rinv = k_rinv.getUMat(ACCESS_READ);
+
+            k.args(ocl::KernelArg::WriteOnlyNoSize(uxmap), ocl::KernelArg::WriteOnly(uymap),
+                   ocl::KernelArg::PtrReadOnly(uk_rinv), dst_tl.x, dst_tl.y, 1/projector_.scale,
+                   rowsPerWI);
+
+            size_t globalsize[2] = { (size_t)dsize.width, ((size_t)dsize.height + rowsPerWI - 1) / rowsPerWI };
+            if (k.run(2, globalsize, NULL, true))
+            {
+                CV_IMPL_ADD(CV_IMPL_OCL);
+                return Rect(dst_tl, dst_br);
+            }
+        }
+    }
+#endif
+    return RotationWarperBase<CylindricalProjector>::buildMaps(src_size, K, R, xmap, ymap);
+}
+
+Point CylindricalWarper::warp(InputArray src, InputArray K, InputArray R, int interp_mode, int border_mode, OutputArray dst)
+{
+    UMat uxmap, uymap;
+    Rect dst_roi = buildMaps(src.size(), K, R, uxmap, uymap);
+
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    remap(src, dst, uxmap, uymap, interp_mode, border_mode);
+
+    return dst_roi.tl();
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/stitching/src/warpers_cuda.cpp b/upstream/opencv/modules/stitching/src/warpers_cuda.cpp
new file mode 100644
index 0000000..680f4f9
--- /dev/null
+++ b/upstream/opencv/modules/stitching/src/warpers_cuda.cpp
@@ -0,0 +1,292 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/private.cuda.hpp"
+
+using namespace cv;
+using namespace cv::cuda;
+
+#ifdef HAVE_CUDA
+
+namespace cv { namespace cuda { namespace device
+{
+    namespace imgproc
+    {
+        void buildWarpPlaneMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                const float k_rinv[9], const float r_kinv[9], const float t[3], float scale,
+                                cudaStream_t stream);
+
+        void buildWarpSphericalMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                    const float k_rinv[9], const float r_kinv[9], float scale,
+                                    cudaStream_t stream);
+
+        void buildWarpCylindricalMaps(int tl_u, int tl_v, PtrStepSzf map_x, PtrStepSzf map_y,
+                                      const float k_rinv[9], const float r_kinv[9], float scale,
+                                      cudaStream_t stream);
+    }
+}}}
+
+static void buildWarpPlaneMaps(Size src_size, Rect dst_roi, InputArray _K, InputArray _R, InputArray _T,
+                               float scale, OutputArray _map_x, OutputArray _map_y, Stream& stream = Stream::Null())
+{
+    CV_UNUSED(src_size);
+
+    Mat K = _K.getMat();
+    Mat R = _R.getMat();
+    Mat T = _T.getMat();
+
+    CV_Assert( K.size() == Size(3,3) && K.type() == CV_32FC1 );
+    CV_Assert( R.size() == Size(3,3) && R.type() == CV_32FC1 );
+    CV_Assert( (T.size() == Size(3,1) || T.size() == Size(1,3)) && T.type() == CV_32FC1 && T.isContinuous() );
+
+    Mat K_Rinv = K * R.t();
+    Mat R_Kinv = R * K.inv();
+    CV_Assert( K_Rinv.isContinuous() );
+    CV_Assert( R_Kinv.isContinuous() );
+
+    _map_x.create(dst_roi.size(), CV_32FC1);
+    _map_y.create(dst_roi.size(), CV_32FC1);
+
+    GpuMat map_x = _map_x.getGpuMat();
+    GpuMat map_y = _map_y.getGpuMat();
+
+    device::imgproc::buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(),
+                       T.ptr<float>(), scale, StreamAccessor::getStream(stream));
+}
+
+static void buildWarpSphericalMaps(Size src_size, Rect dst_roi, InputArray _K, InputArray _R, float scale,
+                                   OutputArray _map_x, OutputArray _map_y, Stream& stream = Stream::Null())
+{
+    CV_UNUSED(src_size);
+
+    Mat K = _K.getMat();
+    Mat R = _R.getMat();
+
+    CV_Assert( K.size() == Size(3,3) && K.type() == CV_32FC1 );
+    CV_Assert( R.size() == Size(3,3) && R.type() == CV_32FC1 );
+
+    Mat K_Rinv = K * R.t();
+    Mat R_Kinv = R * K.inv();
+    CV_Assert( K_Rinv.isContinuous() );
+    CV_Assert( R_Kinv.isContinuous() );
+
+    _map_x.create(dst_roi.size(), CV_32FC1);
+    _map_y.create(dst_roi.size(), CV_32FC1);
+
+    GpuMat map_x = _map_x.getGpuMat();
+    GpuMat map_y = _map_y.getGpuMat();
+
+    device::imgproc::buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
+}
+
+static void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, InputArray _K, InputArray _R, float scale,
+                                     OutputArray _map_x, OutputArray _map_y, Stream& stream = Stream::Null())
+{
+    CV_UNUSED(src_size);
+
+    Mat K = _K.getMat();
+    Mat R = _R.getMat();
+
+    CV_Assert( K.size() == Size(3,3) && K.type() == CV_32FC1 );
+    CV_Assert( R.size() == Size(3,3) && R.type() == CV_32FC1 );
+
+    Mat K_Rinv = K * R.t();
+    Mat R_Kinv = R * K.inv();
+    CV_Assert( K_Rinv.isContinuous() );
+    CV_Assert( R_Kinv.isContinuous() );
+
+    _map_x.create(dst_roi.size(), CV_32FC1);
+    _map_y.create(dst_roi.size(), CV_32FC1);
+
+    GpuMat map_x = _map_x.getGpuMat();
+    GpuMat map_y = _map_y.getGpuMat();
+
+    device::imgproc::buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, K_Rinv.ptr<float>(), R_Kinv.ptr<float>(), scale, StreamAccessor::getStream(stream));
+}
+
+#endif
+
+Rect cv::detail::PlaneWarperGpu::buildMaps(Size src_size, InputArray K, InputArray R,
+                                           cuda::GpuMat & xmap, cuda::GpuMat & ymap)
+{
+    return buildMaps(src_size, K, R, Mat::zeros(3, 1, CV_32F), xmap, ymap);
+}
+
+Rect cv::detail::PlaneWarperGpu::buildMaps(Size src_size, InputArray K, InputArray R, InputArray T,
+                                           cuda::GpuMat & xmap, cuda::GpuMat & ymap)
+{
+#ifndef HAVE_CUDA
+    CV_UNUSED(src_size);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(T);
+    CV_UNUSED(xmap);
+    CV_UNUSED(ymap);
+    throw_no_cuda();
+#else
+    projector_.setCameraParams(K, R, T);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    ::buildWarpPlaneMaps(src_size, Rect(dst_tl, Point(dst_br.x + 1, dst_br.y + 1)),
+                         K, R, T, projector_.scale, xmap, ymap);
+
+    return Rect(dst_tl, dst_br);
+#endif
+}
+
+Point cv::detail::PlaneWarperGpu::warp(const cuda::GpuMat & src, InputArray K, InputArray R,
+                                       int interp_mode, int border_mode,
+                                       cuda::GpuMat & dst)
+{
+    return warp(src, K, R, Mat::zeros(3, 1, CV_32F), interp_mode, border_mode, dst);
+}
+
+
+Point cv::detail::PlaneWarperGpu::warp(const cuda::GpuMat & src, InputArray K, InputArray R, InputArray T,
+                                       int interp_mode, int border_mode,
+                                       cuda::GpuMat & dst)
+{
+#ifndef HAVE_OPENCV_CUDAWARPING
+    CV_UNUSED(src);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(T);
+    CV_UNUSED(interp_mode);
+    CV_UNUSED(border_mode);
+    CV_UNUSED(dst);
+    throw_no_cuda();
+#else
+    Rect dst_roi = buildMaps(src.size(), K, R, T, d_xmap_, d_ymap_);
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    cuda::remap(src, dst, d_xmap_, d_ymap_, interp_mode, border_mode);
+    return dst_roi.tl();
+#endif
+}
+
+Rect cv::detail::SphericalWarperGpu::buildMaps(Size src_size, InputArray K, InputArray R, cuda::GpuMat & xmap, cuda::GpuMat & ymap)
+{
+#ifndef HAVE_CUDA
+    CV_UNUSED(src_size);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(xmap);
+    CV_UNUSED(ymap);
+    throw_no_cuda();
+#else
+    projector_.setCameraParams(K, R);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    ::buildWarpSphericalMaps(src_size, Rect(dst_tl, Point(dst_br.x + 1, dst_br.y + 1)),
+                             K, R, projector_.scale, xmap, ymap);
+
+    return Rect(dst_tl, dst_br);
+#endif
+}
+
+Point cv::detail::SphericalWarperGpu::warp(const cuda::GpuMat & src, InputArray K, InputArray R,
+                                           int interp_mode, int border_mode,
+                                           cuda::GpuMat & dst)
+{
+#ifndef HAVE_OPENCV_CUDAWARPING
+    CV_UNUSED(src);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(interp_mode);
+    CV_UNUSED(border_mode);
+    CV_UNUSED(dst);
+    throw_no_cuda();
+#else
+    Rect dst_roi = buildMaps(src.size(), K, R, d_xmap_, d_ymap_);
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    cuda::remap(src, dst, d_xmap_, d_ymap_, interp_mode, border_mode);
+    return dst_roi.tl();
+#endif
+}
+
+
+Rect cv::detail::CylindricalWarperGpu::buildMaps(Size src_size, InputArray K, InputArray R,
+                                                 cuda::GpuMat & xmap, cuda::GpuMat & ymap)
+{
+#ifndef HAVE_CUDA
+    CV_UNUSED(src_size);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(xmap);
+    CV_UNUSED(ymap);
+    throw_no_cuda();
+#else
+    projector_.setCameraParams(K, R);
+
+    Point dst_tl, dst_br;
+    detectResultRoi(src_size, dst_tl, dst_br);
+
+    ::buildWarpCylindricalMaps(src_size, Rect(dst_tl, Point(dst_br.x + 1, dst_br.y + 1)),
+                               K, R, projector_.scale, xmap, ymap);
+
+    return Rect(dst_tl, dst_br);
+#endif
+}
+
+Point cv::detail::CylindricalWarperGpu::warp(const cuda::GpuMat & src, InputArray K, InputArray R,
+                                             int interp_mode, int border_mode,
+                                             cuda::GpuMat & dst)
+{
+#ifndef HAVE_OPENCV_CUDAWARPING
+    CV_UNUSED(src);
+    CV_UNUSED(K);
+    CV_UNUSED(R);
+    CV_UNUSED(interp_mode);
+    CV_UNUSED(border_mode);
+    CV_UNUSED(dst);
+    throw_no_cuda();
+#else
+    Rect dst_roi = buildMaps(src.size(), K, R, d_xmap_, d_ymap_);
+    dst.create(dst_roi.height + 1, dst_roi.width + 1, src.type());
+    cuda::remap(src, dst, d_xmap_, d_ymap_, interp_mode, border_mode);
+    return dst_roi.tl();
+#endif
+}
diff --git a/upstream/opencv/modules/video/CMakeLists.txt b/upstream/opencv/modules/video/CMakeLists.txt
new file mode 100644
index 0000000..8d47712
--- /dev/null
+++ b/upstream/opencv/modules/video/CMakeLists.txt
@@ -0,0 +1,18 @@
+set(the_description "Video Analysis")
+ocv_add_dispatched_file(lkpyramid SSE2 SSE4_1 AVX2 AVX512_SKX AVX512_ICL)
+ocv_define_module(video
+    opencv_imgproc
+    OPTIONAL
+      opencv_geometry
+      opencv_features
+      opencv_dnn
+    WRAP
+      java
+      objc
+      python
+      js
+)
+
+if(HAVE_OPENMP AND DEFINED OpenMP_CXX_LIBRARIES AND OpenMP_CXX_LIBRARIES)
+  ocv_target_link_libraries(${the_module} LINK_PRIVATE "${OpenMP_CXX_LIBRARIES}")
+endif()
diff --git a/upstream/opencv/modules/video/doc/video.bib b/upstream/opencv/modules/video/doc/video.bib
new file mode 100644
index 0000000..f464865
--- /dev/null
+++ b/upstream/opencv/modules/video/doc/video.bib
@@ -0,0 +1,37 @@
+@article{AAM,
+  title={Adaptive appearance modeling for video tracking: survey and evaluation},
+  author={Salti, Samuele and Cavallaro, Andrea and Di Stefano, Luigi},
+  journal={Image Processing, IEEE Transactions on},
+  volume={21},
+  number={10},
+  pages={4334--4348},
+  year={2012},
+  publisher={IEEE}
+}
+
+@article{AMVOT,
+  title={A survey of appearance models in visual object tracking},
+  author={Li, Xi and Hu, Weiming and Shen, Chunhua and Zhang, Zhongfei and Dick, Anthony and Hengel, Anton Van Den},
+  journal={ACM Transactions on Intelligent Systems and Technology (TIST)},
+  volume={4},
+  number={4},
+  pages={58},
+  year={2013},
+  publisher={ACM}
+}
+
+@inproceedings{Kroeger2016,
+  author={Till Kroeger and Radu Timofte and Dengxin Dai and Luc Van Gool},
+  title={Fast Optical Flow using Dense Inverse Search},
+  booktitle={Proceedings of the European Conference on Computer Vision ({ECCV})},
+  year={2016}
+}
+
+@inproceedings{MIL,
+  title={Visual tracking with online multiple instance learning},
+  author={Babenko, Boris and Yang, Ming-Hsuan and Belongie, Serge},
+  booktitle={Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on},
+  pages={983--990},
+  year={2009},
+  organization={IEEE}
+}
diff --git a/upstream/opencv/modules/video/include/opencv2/video.hpp b/upstream/opencv/modules/video/include/opencv2/video.hpp
new file mode 100644
index 0000000..b1c1919
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video.hpp
@@ -0,0 +1,58 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_VIDEO_HPP
+#define OPENCV_VIDEO_HPP
+
+/**
+  @defgroup video Video Analysis
+  @{
+    @defgroup video_motion Motion Analysis
+    @defgroup video_track Object Tracking
+  @}
+*/
+
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/video/background_segm.hpp"
+
+#endif //OPENCV_VIDEO_HPP
diff --git a/upstream/opencv/modules/video/include/opencv2/video/background_segm.hpp b/upstream/opencv/modules/video/include/opencv2/video/background_segm.hpp
new file mode 100644
index 0000000..2d3ea82
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video/background_segm.hpp
@@ -0,0 +1,344 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_BACKGROUND_SEGM_HPP
+#define OPENCV_BACKGROUND_SEGM_HPP
+
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+
+//! @addtogroup video_motion
+//! @{
+
+/** @brief Base class for background/foreground segmentation. :
+
+The class is only used to define the common interface for the whole family of background/foreground
+segmentation algorithms.
+ */
+class CV_EXPORTS_W BackgroundSubtractor : public Algorithm
+{
+public:
+    /** @brief Computes a foreground mask.
+
+    @param image Next video frame.
+    @param fgmask The output foreground mask as an 8-bit binary image.
+    @param learningRate The value between 0 and 1 that indicates how fast the background model is
+    learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
+    rate. 0 means that the background model is not updated at all, 1 means that the background model
+    is completely reinitialized from the last frame.
+     */
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
+
+    /** @brief Computes a foreground mask with known foreground mask input.
+
+    @param image Next video frame. Floating point frame will be used without scaling and should be in range \f$[0,255]\f$.
+    @param fgmask The output foreground mask as an 8-bit binary image.
+    @param knownForegroundMask The mask for inputting already known foreground, allows model to ignore pixels.
+    @param learningRate The value between 0 and 1 that indicates how fast the background model is
+    learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
+    rate. 0 means that the background model is not updated at all, 1 means that the background model
+    is completely reinitialized from the last frame.
+
+    @note This method has a default virtual implementation that throws a "not impemented" error.
+    Foreground masking may not be supported by all background subtractors.
+    */
+    CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) = 0;
+
+    /** @brief Computes a background image.
+
+    @param backgroundImage The output background image.
+
+    @note Sometimes the background image can be very blurry, as it contain the average background
+    statistics.
+     */
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+};
+
+
+/** @brief Gaussian Mixture-based Background/Foreground Segmentation Algorithm.
+
+The class implements the Gaussian mixture model background subtraction described in @cite Zivkovic2004
+and @cite Zivkovic2006 .
+ */
+class CV_EXPORTS_W BackgroundSubtractorMOG2 : public BackgroundSubtractor
+{
+public:
+    /** @brief Returns the number of last frames that affect the background model
+    */
+    CV_WRAP virtual int getHistory() const = 0;
+    /** @brief Sets the number of last frames that affect the background model
+    */
+    CV_WRAP virtual void setHistory(int history) = 0;
+
+    /** @brief Returns the number of gaussian components in the background model
+    */
+    CV_WRAP virtual int getNMixtures() const = 0;
+    /** @brief Sets the number of gaussian components in the background model.
+
+    The model needs to be reinitialized to reserve memory.
+    */
+    CV_WRAP virtual void setNMixtures(int nmixtures) = 0;//needs reinitialization!
+
+    /** @brief Returns the "background ratio" parameter of the algorithm
+
+    If a foreground pixel keeps semi-constant value for about backgroundRatio\*history frames, it's
+    considered background and added to the model as a center of a new component. It corresponds to TB
+    parameter in the paper.
+     */
+    CV_WRAP virtual double getBackgroundRatio() const = 0;
+    /** @brief Sets the "background ratio" parameter of the algorithm
+    */
+    CV_WRAP virtual void setBackgroundRatio(double ratio) = 0;
+
+    /** @brief Returns the variance threshold for the pixel-model match
+
+    The main threshold on the squared Mahalanobis distance to decide if the sample is well described by
+    the background model or not. Related to Cthr from the paper.
+     */
+    CV_WRAP virtual double getVarThreshold() const = 0;
+    /** @brief Sets the variance threshold for the pixel-model match
+    */
+    CV_WRAP virtual void setVarThreshold(double varThreshold) = 0;
+
+    /** @brief Returns the variance threshold for the pixel-model match used for new mixture component generation
+
+    Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the
+    existing components (corresponds to Tg in the paper). If a pixel is not close to any component, it
+    is considered foreground or added as a new component. 3 sigma =\> Tg=3\*3=9 is default. A smaller Tg
+    value generates more components. A higher Tg value may result in a small number of components but
+    they can grow too large.
+     */
+    CV_WRAP virtual double getVarThresholdGen() const = 0;
+    /** @brief Sets the variance threshold for the pixel-model match used for new mixture component generation
+    */
+    CV_WRAP virtual void setVarThresholdGen(double varThresholdGen) = 0;
+
+    /** @brief Returns the initial variance of each gaussian component
+    */
+    CV_WRAP virtual double getVarInit() const = 0;
+    /** @brief Sets the initial variance of each gaussian component
+    */
+    CV_WRAP virtual void setVarInit(double varInit) = 0;
+
+    CV_WRAP virtual double getVarMin() const = 0;
+    CV_WRAP virtual void setVarMin(double varMin) = 0;
+
+    CV_WRAP virtual double getVarMax() const = 0;
+    CV_WRAP virtual void setVarMax(double varMax) = 0;
+
+    /** @brief Returns the complexity reduction threshold
+
+    This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05
+    is a default value for all the samples. By setting CT=0 you get an algorithm very similar to the
+    standard Stauffer&Grimson algorithm.
+     */
+    CV_WRAP virtual double getComplexityReductionThreshold() const = 0;
+    /** @brief Sets the complexity reduction threshold
+    */
+    CV_WRAP virtual void setComplexityReductionThreshold(double ct) = 0;
+
+    /** @brief Returns the shadow detection flag
+
+    If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorMOG2 for
+    details.
+     */
+    CV_WRAP virtual bool getDetectShadows() const = 0;
+    /** @brief Enables or disables shadow detection
+    */
+    CV_WRAP virtual void setDetectShadows(bool detectShadows) = 0;
+
+    /** @brief Returns the shadow value
+
+    Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0
+    in the mask always means background, 255 means foreground.
+     */
+    CV_WRAP virtual int getShadowValue() const = 0;
+    /** @brief Sets the shadow value
+    */
+    CV_WRAP virtual void setShadowValue(int value) = 0;
+
+    /** @brief Returns the shadow threshold
+
+    A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in
+    the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel
+    is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,
+    *Detecting Moving Shadows...*, IEEE PAMI,2003.
+     */
+    CV_WRAP virtual double getShadowThreshold() const = 0;
+    /** @brief Sets the shadow threshold
+    */
+    CV_WRAP virtual void setShadowThreshold(double threshold) = 0;
+
+    /** @brief Computes a foreground mask.
+
+    @param image Next video frame. Floating point frame will be used without scaling and should be in range \f$[0,255]\f$.
+    @param fgmask The output foreground mask as an 8-bit binary image.
+    @param learningRate The value between 0 and 1 that indicates how fast the background model is
+    learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
+    rate. 0 means that the background model is not updated at all, 1 means that the background model
+    is completely reinitialized from the last frame.
+     */
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0;
+
+    /** @brief Computes a foreground mask and skips known foreground in evaluation.
+
+    @param image Next video frame. Floating point frame will be used without scaling and should be in range \f$[0,255]\f$.
+    @param fgmask The output foreground mask as an 8-bit binary image.
+    @param knownForegroundMask The mask for inputting already known foreground, allows model to ignore pixels.
+    @param learningRate The value between 0 and 1 that indicates how fast the background model is
+    learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
+    rate. 0 means that the background model is not updated at all, 1 means that the background model
+    is completely reinitialized from the last frame.
+     */
+    CV_WRAP virtual void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate=-1) CV_OVERRIDE = 0;
+};
+
+/** @brief Creates MOG2 Background Subtractor
+
+@param history Length of the history.
+@param varThreshold Threshold on the squared Mahalanobis distance between the pixel and the model
+to decide whether a pixel is well described by the background model. This parameter does not
+affect the background update.
+@param detectShadows If true, the algorithm will detect shadows and mark them. It decreases the
+speed a bit, so if you do not need this feature, set the parameter to false.
+ */
+CV_EXPORTS_W Ptr<BackgroundSubtractorMOG2>
+    createBackgroundSubtractorMOG2(int history=500, double varThreshold=16,
+                                   bool detectShadows=true);
+
+/** @brief K-nearest neighbours - based Background/Foreground Segmentation Algorithm.
+
+The class implements the K-nearest neighbours background subtraction described in @cite Zivkovic2006 .
+Very efficient if number of foreground pixels is low.
+ */
+class CV_EXPORTS_W BackgroundSubtractorKNN : public BackgroundSubtractor
+{
+public:
+    /** @brief Returns the number of last frames that affect the background model
+    */
+    CV_WRAP virtual int getHistory() const = 0;
+    /** @brief Sets the number of last frames that affect the background model
+    */
+    CV_WRAP virtual void setHistory(int history) = 0;
+
+    /** @brief Returns the number of data samples in the background model
+    */
+    CV_WRAP virtual int getNSamples() const = 0;
+    /** @brief Sets the number of data samples in the background model.
+
+    The model needs to be reinitialized to reserve memory.
+    */
+    CV_WRAP virtual void setNSamples(int _nN) = 0;//needs reinitialization!
+
+    /** @brief Returns the threshold on the squared distance between the pixel and the sample
+
+    The threshold on the squared distance between the pixel and the sample to decide whether a pixel is
+    close to a data sample.
+     */
+    CV_WRAP virtual double getDist2Threshold() const = 0;
+    /** @brief Sets the threshold on the squared distance
+    */
+    CV_WRAP virtual void setDist2Threshold(double _dist2Threshold) = 0;
+
+    /** @brief Returns the number of neighbours, the k in the kNN.
+
+    K is the number of samples that need to be within dist2Threshold in order to decide that that
+    pixel is matching the kNN background model.
+     */
+    CV_WRAP virtual int getkNNSamples() const = 0;
+    /** @brief Sets the k in the kNN. How many nearest neighbours need to match.
+    */
+    CV_WRAP virtual void setkNNSamples(int _nkNN) = 0;
+
+    /** @brief Returns the shadow detection flag
+
+    If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorKNN for
+    details.
+     */
+    CV_WRAP virtual bool getDetectShadows() const = 0;
+    /** @brief Enables or disables shadow detection
+    */
+    CV_WRAP virtual void setDetectShadows(bool detectShadows) = 0;
+
+    /** @brief Returns the shadow value
+
+    Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0
+    in the mask always means background, 255 means foreground.
+     */
+    CV_WRAP virtual int getShadowValue() const = 0;
+    /** @brief Sets the shadow value
+    */
+    CV_WRAP virtual void setShadowValue(int value) = 0;
+
+    /** @brief Returns the shadow threshold
+
+    A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in
+    the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel
+    is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,
+    *Detecting Moving Shadows...*, IEEE PAMI,2003.
+     */
+    CV_WRAP virtual double getShadowThreshold() const = 0;
+    /** @brief Sets the shadow threshold
+     */
+    CV_WRAP virtual void setShadowThreshold(double threshold) = 0;
+};
+
+/** @brief Creates KNN Background Subtractor
+
+@param history Length of the history.
+@param dist2Threshold Threshold on the squared distance between the pixel and the sample to decide
+whether a pixel is close to that sample. This parameter does not affect the background update.
+@param detectShadows If true, the algorithm will detect shadows and mark them. It decreases the
+speed a bit, so if you do not need this feature, set the parameter to false.
+ */
+CV_EXPORTS_W Ptr<BackgroundSubtractorKNN>
+    createBackgroundSubtractorKNN(int history=500, double dist2Threshold=400.0,
+                                   bool detectShadows=true);
+
+//! @} video_motion
+
+} // cv
+
+#endif
diff --git a/upstream/opencv/modules/video/include/opencv2/video/detail/tracking.detail.hpp b/upstream/opencv/modules/video/include/opencv2/video/detail/tracking.detail.hpp
new file mode 100644
index 0000000..3c7823b
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video/detail/tracking.detail.hpp
@@ -0,0 +1,406 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_DETAIL_TRACKING_HPP
+#define OPENCV_VIDEO_DETAIL_TRACKING_HPP
+
+/*
+ * Partially based on:
+ * ====================================================================================================================
+ *  - [AAM] S. Salti, A. Cavallaro, L. Di Stefano, Adaptive Appearance Modeling for Video Tracking: Survey and Evaluation
+ *  - [AMVOT] X. Li, W. Hu, C. Shen, Z. Zhang, A. Dick, A. van den Hengel, A Survey of Appearance Models in Visual Object Tracking
+ *
+ * This Tracking API has been designed with PlantUML. If you modify this API please change UML files under modules/tracking/doc/uml
+ *
+ */
+
+#include "opencv2/core.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+/** @addtogroup tracking_detail
+@{
+*/
+
+/************************************ TrackerFeature Base Classes ************************************/
+
+/** @brief Abstract base class for TrackerFeature that represents the feature.
+*/
+class CV_EXPORTS TrackerFeature
+{
+public:
+    virtual ~TrackerFeature();
+
+    /** @brief Compute the features in the images collection
+    @param images The images
+    @param response The output response
+    */
+    void compute(const std::vector<Mat>& images, Mat& response);
+
+protected:
+    virtual bool computeImpl(const std::vector<Mat>& images, Mat& response) = 0;
+};
+
+/** @brief Class that manages the extraction and selection of features
+
+@cite AAM Feature Extraction and Feature Set Refinement (Feature Processing and Feature Selection).
+See table I and section III C @cite AMVOT Appearance modelling -\> Visual representation (Table II,
+section 3.1 - 3.2)
+
+TrackerFeatureSet is an aggregation of TrackerFeature
+
+@sa
+   TrackerFeature
+
+*/
+class CV_EXPORTS TrackerFeatureSet
+{
+public:
+    TrackerFeatureSet();
+
+    ~TrackerFeatureSet();
+
+    /** @brief Extract features from the images collection
+    @param images The input images
+    */
+    void extraction(const std::vector<Mat>& images);
+
+    /** @brief Add TrackerFeature in the collection. Return true if TrackerFeature is added, false otherwise
+    @param feature The TrackerFeature class
+    */
+    bool addTrackerFeature(const Ptr<TrackerFeature>& feature);
+
+    /** @brief Get the TrackerFeature collection (TrackerFeature name, TrackerFeature pointer)
+    */
+    const std::vector<Ptr<TrackerFeature>>& getTrackerFeatures() const;
+
+    /** @brief Get the responses
+    @note Be sure to call extraction before getResponses Example TrackerFeatureSet::getResponses
+    */
+    const std::vector<Mat>& getResponses() const;
+
+private:
+    void clearResponses();
+    bool blockAddTrackerFeature;
+
+    std::vector<Ptr<TrackerFeature>> features;  // list of features
+    std::vector<Mat> responses;  // list of response after compute
+};
+
+/************************************ TrackerSampler Base Classes ************************************/
+
+/** @brief Abstract base class for TrackerSamplerAlgorithm that represents the algorithm for the specific
+sampler.
+*/
+class CV_EXPORTS TrackerSamplerAlgorithm
+{
+public:
+    virtual ~TrackerSamplerAlgorithm();
+
+    /** @brief Computes the regions starting from a position in an image.
+
+    Return true if samples are computed, false otherwise
+
+    @param image The current frame
+    @param boundingBox The bounding box from which regions can be calculated
+
+    @param sample The computed samples @cite AAM Fig. 1 variable Sk
+    */
+    virtual bool sampling(const Mat& image, const Rect& boundingBox, std::vector<Mat>& sample) = 0;
+};
+
+/**
+ * \brief Class that manages the sampler in order to select regions for the update the model of the tracker
+ * [AAM] Sampling e Labeling. See table I and section III B
+ */
+
+/** @brief Class that manages the sampler in order to select regions for the update the model of the tracker
+
+@cite AAM Sampling e Labeling. See table I and section III B
+
+TrackerSampler is an aggregation of TrackerSamplerAlgorithm
+@sa
+   TrackerSamplerAlgorithm
+ */
+class CV_EXPORTS TrackerSampler
+{
+public:
+    TrackerSampler();
+
+    ~TrackerSampler();
+
+    /** @brief Computes the regions starting from a position in an image
+    @param image The current frame
+    @param boundingBox The bounding box from which regions can be calculated
+    */
+    void sampling(const Mat& image, Rect boundingBox);
+
+    /** @brief Return the collection of the TrackerSamplerAlgorithm
+    */
+    const std::vector<Ptr<TrackerSamplerAlgorithm>>& getSamplers() const;
+
+    /** @brief Return the samples from all TrackerSamplerAlgorithm, @cite AAM Fig. 1 variable Sk
+    */
+    const std::vector<Mat>& getSamples() const;
+
+    /** @brief Add TrackerSamplerAlgorithm in the collection. Return true if sampler is added, false otherwise
+    @param sampler The TrackerSamplerAlgorithm
+    */
+    bool addTrackerSamplerAlgorithm(const Ptr<TrackerSamplerAlgorithm>& sampler);
+
+private:
+    std::vector<Ptr<TrackerSamplerAlgorithm>> samplers;
+    std::vector<Mat> samples;
+    bool blockAddTrackerSampler;
+
+    void clearSamples();
+};
+
+/************************************ TrackerModel Base Classes ************************************/
+
+/** @brief Abstract base class for TrackerTargetState that represents a possible state of the target.
+
+See @cite AAM \f$\hat{x}^{i}_{k}\f$ all the states candidates.
+
+Inherits this class with your Target state, In own implementation you can add scale variation,
+width, height, orientation, etc.
+*/
+class CV_EXPORTS TrackerTargetState
+{
+public:
+    virtual ~TrackerTargetState() {}
+    /** @brief Get the position
+    * @return The position
+    */
+    Point2f getTargetPosition() const;
+
+    /** @brief Set the position
+    * @param position The position
+    */
+    void setTargetPosition(const Point2f& position);
+    /** @brief Get the width of the target
+    * @return The width of the target
+    */
+    int getTargetWidth() const;
+
+    /** @brief Set the width of the target
+    * @param width The width of the target
+    */
+    void setTargetWidth(int width);
+    /** @brief Get the height of the target
+    * @return The height of the target
+    */
+    int getTargetHeight() const;
+
+    /** @brief Set the height of the target
+    * @param height The height of the target
+    */
+    void setTargetHeight(int height);
+
+protected:
+    Point2f targetPosition;
+    int targetWidth;
+    int targetHeight;
+};
+
+/** @brief Represents the model of the target at frame \f$k\f$ (all states and scores)
+
+See @cite AAM The set of the pair \f$\langle \hat{x}^{i}_{k}, C^{i}_{k} \rangle\f$
+@sa TrackerTargetState
+*/
+typedef std::vector<std::pair<Ptr<TrackerTargetState>, float>> ConfidenceMap;
+
+/** @brief Represents the estimate states for all frames
+
+@cite AAM \f$x_{k}\f$ is the trajectory of the target up to time \f$k\f$
+
+@sa TrackerTargetState
+*/
+typedef std::vector<Ptr<TrackerTargetState>> Trajectory;
+
+/** @brief Abstract base class for TrackerStateEstimator that estimates the most likely target state.
+
+See @cite AAM State estimator
+
+See @cite AMVOT Statistical modeling (Fig. 3), Table III (generative) - IV (discriminative) - V (hybrid)
+*/
+class CV_EXPORTS TrackerStateEstimator
+{
+public:
+    virtual ~TrackerStateEstimator();
+
+    /** @brief Estimate the most likely target state, return the estimated state
+    @param confidenceMaps The overall appearance model as a list of :cConfidenceMap
+    */
+    Ptr<TrackerTargetState> estimate(const std::vector<ConfidenceMap>& confidenceMaps);
+
+    /** @brief Update the ConfidenceMap with the scores
+    @param confidenceMaps The overall appearance model as a list of :cConfidenceMap
+    */
+    void update(std::vector<ConfidenceMap>& confidenceMaps);
+
+    /** @brief Create TrackerStateEstimator by tracker state estimator type
+    @param trackeStateEstimatorType The TrackerStateEstimator name
+
+    The modes available now:
+
+    -   "BOOSTING" -- Boosting-based discriminative appearance models. See @cite AMVOT section 4.4
+
+    The modes available soon:
+
+    -   "SVM" -- SVM-based discriminative appearance models. See @cite AMVOT section 4.5
+    */
+    static Ptr<TrackerStateEstimator> create(const String& trackeStateEstimatorType);
+
+    /** @brief Get the name of the specific TrackerStateEstimator
+    */
+    String getClassName() const;
+
+protected:
+    virtual Ptr<TrackerTargetState> estimateImpl(const std::vector<ConfidenceMap>& confidenceMaps) = 0;
+    virtual void updateImpl(std::vector<ConfidenceMap>& confidenceMaps) = 0;
+    String className;
+};
+
+/** @brief Abstract class that represents the model of the target.
+
+It must be instantiated by specialized tracker
+
+See @cite AAM Ak
+
+Inherits this with your TrackerModel
+*/
+class CV_EXPORTS TrackerModel
+{
+public:
+    TrackerModel();
+
+    virtual ~TrackerModel();
+
+    /** @brief Set TrackerEstimator, return true if the tracker state estimator is added, false otherwise
+    @param trackerStateEstimator The TrackerStateEstimator
+    @note You can add only one TrackerStateEstimator
+    */
+    bool setTrackerStateEstimator(Ptr<TrackerStateEstimator> trackerStateEstimator);
+
+    /** @brief Estimate the most likely target location
+
+    @cite AAM ME, Model Estimation table I
+    @param responses Features extracted from TrackerFeatureSet
+    */
+    void modelEstimation(const std::vector<Mat>& responses);
+
+    /** @brief Update the model
+
+    @cite AAM MU, Model Update table I
+    */
+    void modelUpdate();
+
+    /** @brief Run the TrackerStateEstimator, return true if is possible to estimate a new state, false otherwise
+    */
+    bool runStateEstimator();
+
+    /** @brief Set the current TrackerTargetState in the Trajectory
+    @param lastTargetState The current TrackerTargetState
+    */
+    void setLastTargetState(const Ptr<TrackerTargetState>& lastTargetState);
+
+    /** @brief Get the last TrackerTargetState from Trajectory
+    */
+    Ptr<TrackerTargetState> getLastTargetState() const;
+
+    /** @brief Get the list of the ConfidenceMap
+    */
+    const std::vector<ConfidenceMap>& getConfidenceMaps() const;
+
+    /** @brief Get the last ConfidenceMap for the current frame
+    */
+    const ConfidenceMap& getLastConfidenceMap() const;
+
+    /** @brief Get the TrackerStateEstimator
+    */
+    Ptr<TrackerStateEstimator> getTrackerStateEstimator() const;
+
+private:
+    void clearCurrentConfidenceMap();
+
+protected:
+    std::vector<ConfidenceMap> confidenceMaps;
+    Ptr<TrackerStateEstimator> stateEstimator;
+    ConfidenceMap currentConfidenceMap;
+    Trajectory trajectory;
+    int maxCMLength;
+
+    virtual void modelEstimationImpl(const std::vector<Mat>& responses) = 0;
+    virtual void modelUpdateImpl() = 0;
+};
+
+/************************************ Specific TrackerStateEstimator Classes ************************************/
+
+// None
+
+/************************************ Specific TrackerSamplerAlgorithm Classes ************************************/
+
+/** @brief TrackerSampler based on CSC (current state centered), used by MIL algorithm TrackerMIL
+ */
+class CV_EXPORTS TrackerSamplerCSC : public TrackerSamplerAlgorithm
+{
+public:
+    ~TrackerSamplerCSC();
+
+    enum MODE
+    {
+        MODE_INIT_POS = 1,  //!< mode for init positive samples
+        MODE_INIT_NEG = 2,  //!< mode for init negative samples
+        MODE_TRACK_POS = 3,  //!< mode for update positive samples
+        MODE_TRACK_NEG = 4,  //!< mode for update negative samples
+        MODE_DETECT = 5  //!< mode for detect samples
+    };
+
+    struct CV_EXPORTS Params
+    {
+        Params();
+        float initInRad;  //!< radius for gathering positive instances during init
+        float trackInPosRad;  //!< radius for gathering positive instances during tracking
+        float searchWinSize;  //!< size of search window
+        int initMaxNegNum;  //!< # negative samples to use during init
+        int trackMaxPosNum;  //!< # positive samples to use during training
+        int trackMaxNegNum;  //!< # negative samples to use during training
+    };
+
+    /** @brief Constructor
+    @param parameters TrackerSamplerCSC parameters TrackerSamplerCSC::Params
+    */
+    TrackerSamplerCSC(const TrackerSamplerCSC::Params& parameters = TrackerSamplerCSC::Params());
+
+    /** @brief Set the sampling mode of TrackerSamplerCSC
+    @param samplingMode The sampling mode
+
+    The modes are:
+
+    -   "MODE_INIT_POS = 1" -- for the positive sampling in initialization step
+    -   "MODE_INIT_NEG = 2" -- for the negative sampling in initialization step
+    -   "MODE_TRACK_POS = 3" -- for the positive sampling in update step
+    -   "MODE_TRACK_NEG = 4" -- for the negative sampling in update step
+    -   "MODE_DETECT = 5" -- for the sampling in detection step
+    */
+    void setMode(int samplingMode);
+
+    bool sampling(const Mat& image, const Rect& boundingBox, std::vector<Mat>& sample) CV_OVERRIDE;
+
+private:
+    Params params;
+    int mode;
+    RNG rng;
+
+    std::vector<Mat> sampleImage(const Mat& img, int x, int y, int w, int h, float inrad, float outrad = 0, int maxnum = 1000000);
+};
+
+//! @}
+
+}}}  // namespace cv::detail::tracking
+
+#endif  // OPENCV_VIDEO_DETAIL_TRACKING_HPP
diff --git a/upstream/opencv/modules/video/include/opencv2/video/legacy/constants_c.h b/upstream/opencv/modules/video/include/opencv2/video/legacy/constants_c.h
new file mode 100644
index 0000000..1a98f52
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video/legacy/constants_c.h
@@ -0,0 +1,16 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_LEGACY_CONSTANTS_H
+#define OPENCV_VIDEO_LEGACY_CONSTANTS_H
+
+enum
+{
+    CV_LKFLOW_PYR_A_READY = 1,
+    CV_LKFLOW_PYR_B_READY = 2,
+    CV_LKFLOW_INITIAL_GUESSES = 4,
+    CV_LKFLOW_GET_MIN_EIGENVALS = 8
+};
+
+#endif // OPENCV_VIDEO_LEGACY_CONSTANTS_H
diff --git a/upstream/opencv/modules/video/include/opencv2/video/tracking.hpp b/upstream/opencv/modules/video/include/opencv2/video/tracking.hpp
new file mode 100644
index 0000000..bf85889
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video/tracking.hpp
@@ -0,0 +1,1115 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_TRACKING_HPP
+#define OPENCV_TRACKING_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#ifdef HAVE_OPENCV_DNN
+# include "opencv2/dnn.hpp"
+#endif
+
+namespace cv
+{
+
+//! @addtogroup video_track
+//! @{
+
+enum { OPTFLOW_USE_INITIAL_FLOW     = 4,
+       OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
+       OPTFLOW_FARNEBACK_GAUSSIAN   = 256
+     };
+
+/** @brief Finds an object center, size, and orientation.
+
+@param probImage Back projection of the object histogram. See calcBackProject.
+@param window Initial search window.
+@param criteria Stop criteria for the underlying meanShift.
+returns
+(in old interfaces) Number of iterations CAMSHIFT took to converge
+The function implements the CAMSHIFT object tracking algorithm @cite Bradski98 . First, it finds an
+object center using meanShift and then adjusts the window size and finds the optimal rotation. The
+function returns the rotated rectangle structure that includes the object position, size, and
+orientation. The next position of the search window can be obtained with RotatedRect::boundingRect()
+
+See the OpenCV sample camshiftdemo.c that tracks colored objects.
+
+@note
+-   (Python) A sample explaining the camshift tracking algorithm can be found at
+    opencv_source_code/samples/python/snippets/camshift.py
+ */
+CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window,
+                                   TermCriteria criteria );
+
+/** @example samples/cpp/snippets/camshiftdemo.cpp
+An example using the mean-shift tracking algorithm
+*/
+
+/** @brief Finds an object on a back projection image.
+
+@param probImage Back projection of the object histogram. See calcBackProject for details.
+@param window Initial search window.
+@param criteria Stop criteria for the iterative search algorithm.
+returns
+:   Number of iterations CAMSHIFT took to converge.
+The function implements the iterative object search algorithm. It takes the input back projection of
+an object and the initial position. The mass center in window of the back projection image is
+computed and the search window center shifts to the mass center. The procedure is repeated until the
+specified number of iterations criteria.maxCount is done or until the window center shifts by less
+than criteria.epsilon. The algorithm is used inside CamShift and, unlike CamShift , the search
+window size or orientation do not change during the search. You can simply pass the output of
+calcBackProject to this function. But better results can be obtained if you pre-filter the back
+projection and remove the noise. For example, you can do this by retrieving connected components
+with findContours , throwing away contours with small area ( contourArea ), and rendering the
+remaining contours with drawContours.
+
+ */
+CV_EXPORTS_W int meanShift( InputArray probImage, CV_IN_OUT Rect& window, TermCriteria criteria );
+
+/** @brief Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
+
+@param img 8-bit input image.
+@param pyramid output pyramid.
+@param winSize window size of optical flow algorithm. Must be not less than winSize argument of
+calcOpticalFlowPyrLK. It is needed to calculate required padding for pyramid levels.
+@param maxLevel 0-based maximal pyramid level number.
+@param withDerivatives set to precompute gradients for the every pyramid level. If pyramid is
+constructed without the gradients then calcOpticalFlowPyrLK will calculate them internally.
+@param pyrBorder the border mode for pyramid layers.
+@param derivBorder the border mode for gradients.
+@param tryReuseInputImage put ROI of input image into the pyramid if possible. You can pass false
+to force data copying.
+@return number of levels in constructed pyramid. Can be less than maxLevel.
+ */
+CV_EXPORTS_W int buildOpticalFlowPyramid( InputArray img, OutputArrayOfArrays pyramid,
+                                          Size winSize, int maxLevel, bool withDerivatives = true,
+                                          int pyrBorder = BORDER_REFLECT_101,
+                                          int derivBorder = BORDER_CONSTANT,
+                                          bool tryReuseInputImage = true );
+
+/** @example samples/cpp/lkdemo.cpp
+An example using the Lucas-Kanade optical flow algorithm
+*/
+
+/** @example samples/python/snippets/lk_track.py
+An example using the Lucas-Kanade optical flow algorithm in python
+*/
+
+/** @brief Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with
+pyramids.
+
+@param prevImg first 8-bit input image or pyramid constructed by buildOpticalFlowPyramid.
+@param nextImg second input image or pyramid of the same size and the same type as prevImg.
+@param prevPts vector of 2D points for which the flow needs to be found; point coordinates must be
+single-precision floating-point numbers.
+@param nextPts output vector of 2D points (with single-precision floating-point coordinates)
+containing the calculated new positions of input features in the second image; when
+OPTFLOW_USE_INITIAL_FLOW flag is passed, the vector must have the same size as in the input.
+@param status output status vector (of unsigned chars); each element of the vector is set to 1 if
+the flow for the corresponding features has been found, otherwise, it is set to 0.
+@param err output vector of errors; each element of the vector is set to an error for the
+corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't
+found then the error is not defined (use the status parameter to find such cases).
+@param winSize size of the search window at each pyramid level.
+@param maxLevel 0-based maximal pyramid level number; if set to 0, pyramids are not used (single
+level), if set to 1, two levels are used, and so on; if pyramids are passed to input then
+algorithm will use as many levels as pyramids have but no more than maxLevel.
+@param criteria parameter, specifying the termination criteria of the iterative search algorithm
+(after the specified maximum number of iterations criteria.maxCount or when the search window
+moves by less than criteria.epsilon.
+@param flags operation flags:
+ -   **OPTFLOW_USE_INITIAL_FLOW** uses initial estimations, stored in nextPts; if the flag is
+     not set, then prevPts is copied to nextPts and is considered the initial estimate.
+ -   **OPTFLOW_LK_GET_MIN_EIGENVALS** use minimum eigen values as an error measure (see
+     minEigThreshold description); if the flag is not set, then L1 distance between patches
+     around the original and a moved point, divided by number of pixels in a window, is used as a
+     error measure.
+@param minEigThreshold the algorithm calculates the minimum eigen value of a 2x2 normal matrix of
+optical flow equations (this matrix is called a spatial gradient matrix in @cite Bouguet00), divided
+by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding
+feature is filtered out and its flow is not processed, so it allows to remove bad points and get a
+performance boost.
+
+The function implements a sparse iterative version of the Lucas-Kanade optical flow in pyramids. See
+@cite Bouguet00 . The function is parallelized with the TBB library.
+
+@note Some examples:
+
+-   An example using the Lucas-Kanade optical flow algorithm can be found at
+    opencv_source_code/samples/cpp/lkdemo.cpp
+-   (Python) An example using the Lucas-Kanade optical flow algorithm can be found at
+    opencv_source_code/samples/python/lk_track.py
+-   (Python) An example using the Lucas-Kanade tracker for homography matching can be found at
+    opencv_source_code/samples/python/lk_homography.py
+ */
+CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
+                                        InputArray prevPts, InputOutputArray nextPts,
+                                        OutputArray status, OutputArray err,
+                                        Size winSize = Size(21,21), int maxLevel = 3,
+                                        TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
+                                        int flags = 0, double minEigThreshold = 1e-4 );
+
+/** @example samples/python/snippets/opt_flow.py
+An example to show optical flow in python
+*/
+
+/** @brief Computes a dense optical flow using the Gunnar Farneback's algorithm.
+
+@param prev first 8-bit single-channel input image.
+@param next second input image of the same size and the same type as prev.
+@param flow computed flow image that has the same size as prev and type CV_32FC2.
+@param pyr_scale parameter, specifying the image scale (\<1) to build pyramids for each image;
+pyr_scale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous
+one.
+@param levels number of pyramid layers including the initial image; levels=1 means that no extra
+layers are created and only the original images are used.
+@param winsize averaging window size; larger values increase the algorithm robustness to image
+noise and give more chances for fast motion detection, but yield more blurred motion field.
+@param iterations number of iterations the algorithm does at each pyramid level.
+@param poly_n size of the pixel neighborhood used to find polynomial expansion in each pixel;
+larger values mean that the image will be approximated with smoother surfaces, yielding more
+robust algorithm and more blurred motion field, typically poly_n =5 or 7.
+@param poly_sigma standard deviation of the Gaussian that is used to smooth derivatives used as a
+basis for the polynomial expansion; for poly_n=5, you can set poly_sigma=1.1, for poly_n=7, a
+good value would be poly_sigma=1.5.
+@param flags operation flags that can be a combination of the following:
+ -   **OPTFLOW_USE_INITIAL_FLOW** uses the input flow as an initial flow approximation.
+ -   **OPTFLOW_FARNEBACK_GAUSSIAN** uses the Gaussian \f$\texttt{winsize}\times\texttt{winsize}\f$
+     filter instead of a box filter of the same size for optical flow estimation; usually, this
+     option gives z more accurate flow than with a box filter, at the cost of lower speed;
+     normally, winsize for a Gaussian window should be set to a larger value to achieve the same
+     level of robustness.
+
+The function finds an optical flow for each prev pixel using the @cite Farneback2003 algorithm so that
+
+\f[\texttt{prev} (y,x)  \sim \texttt{next} ( y + \texttt{flow} (y,x)[1],  x + \texttt{flow} (y,x)[0])\f]
+
+@note Some examples:
+
+-   An example using the optical flow algorithm described by Gunnar Farneback can be found at
+    opencv_source_code/samples/cpp/fback.cpp
+-   (Python) An example using the optical flow algorithm described by Gunnar Farneback can be
+    found at opencv_source_code/samples/python/opt_flow.py
+ */
+CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next, InputOutputArray flow,
+                                            double pyr_scale, int levels, int winsize,
+                                            int iterations, int poly_n, double poly_sigma,
+                                            int flags );
+
+/** @brief Computes an optimal affine transformation between two 2D point sets.
+
+@param src First input 2D point set stored in std::vector or Mat, or an image stored in Mat.
+@param dst Second input 2D point set of the same size and the same type as A, or another image.
+@param fullAffine If true, the function finds an optimal affine transformation with no additional
+restrictions (6 degrees of freedom). Otherwise, the class of transformations to choose from is
+limited to combinations of translation, rotation, and uniform scaling (4 degrees of freedom).
+
+The function finds an optimal affine transform *[A|b]* (a 2 x 3 floating-point matrix) that
+approximates best the affine transformation between:
+
+*   Two point sets
+*   Two raster images. In this case, the function first finds some features in the src image and
+    finds the corresponding features in dst image. After that, the problem is reduced to the first
+    case.
+In case of point sets, the problem is formulated as follows: you need to find a 2x2 matrix *A* and
+2x1 vector *b* so that:
+
+\f[[A^*|b^*] = arg  \min _{[A|b]}  \sum _i  \| \texttt{dst}[i] - A { \texttt{src}[i]}^T - b  \| ^2\f]
+where src[i] and dst[i] are the i-th points in src and dst, respectively
+\f$[A|b]\f$ can be either arbitrary (when fullAffine=true ) or have a form of
+\f[\begin{bmatrix} a_{11} & a_{12} & b_1  \\ -a_{12} & a_{11} & b_2  \end{bmatrix}\f]
+when fullAffine=false.
+
+@deprecated Use cv::estimateAffine2D, cv::estimateAffinePartial2D instead. If you are using this function
+with images, extract points using cv::calcOpticalFlowPyrLK and then use the estimation functions.
+
+@sa
+estimateAffine2D, estimateAffinePartial2D, getAffineTransform, getPerspectiveTransform, findHomography
+ */
+CV_DEPRECATED CV_EXPORTS Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine );
+
+enum
+{
+    MOTION_TRANSLATION = 0,
+    MOTION_EUCLIDEAN   = 1,
+    MOTION_AFFINE      = 2,
+    MOTION_HOMOGRAPHY  = 3
+};
+
+/**
+@brief Computes the Enhanced Correlation Coefficient (ECC) value between two images
+
+The Enhanced Correlation Coefficient (ECC) is a normalized measure of similarity between two images @cite EP08.
+The result lies in the range [-1, 1], where 1 corresponds to perfect similarity (modulo affine shift and scale),
+0 indicates no correlation, and -1 indicates perfect negative correlation.
+
+For single-channel images, the ECC is defined as:
+
+\f[
+\mathrm{ECC}(I, T) = \frac{\sum_{x} (I(x) - \mu_I)(T(x) - \mu_T)}
+{\sqrt{\sum_{x} (I(x) - \mu_I)^2} \cdot \sqrt{\sum_{x} (T(x) - \mu_T)^2}}
+\f]
+
+For multi-channel images (e.g., 3-channel RGB), the formula generalizes to:
+
+\f[
+\mathrm{ECC}(I, T) =
+\frac{\sum_{x} \sum_{c=1}^{C} (I_c(x) - \mu_{I_c})(T_c(x) - \mu_{T_c})}
+{\sqrt{\sum_{x} \sum_{c=1}^{C} (I_c(x) - \mu_{I_c})^2} \cdot
+ \sqrt{\sum_{x} \sum_{c=1}^{C} (T_c(x) - \mu_{T_c})^2}}
+\f]
+
+Where:
+- \f$I_c(x), T_c(x)\f$ are the values of channel \f$c\f$ at spatial location \f$x\f$,
+- \f$\mu_{I_c}, \mu_{T_c}\f$ are the mean values of channel \f$c\f$ over the masked region (if provided),
+- \f$C\f$ is the number of channels (only 1 and 3 are currently supported),
+- The sums run over all pixels \f$x\f$ in the image domain (optionally restricted by mask).
+
+@param templateImage Input template image; must have either 1 or 3 channels and be of type CV_8U, CV_16U, CV_32F, or CV_64F.
+@param inputImage Input image to be compared with the template; must have the same type and number of channels as templateImage.
+@param inputMask Optional single-channel mask to specify the valid region of interest in inputImage and templateImage.
+
+@return The ECC similarity coefficient in the range [-1, 1].
+
+@sa findTransformECC
+*/
+CV_EXPORTS_W double computeECC(InputArray templateImage, InputArray inputImage, InputArray inputMask = noArray());
+
+/** @example samples/cpp/image_alignment.cpp
+An example using the image alignment ECC algorithm
+*/
+
+/** @brief Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08 .
+
+@param templateImage 1 or 3 channel template image; CV_8U, CV_16U, CV_32F, CV_64F type.
+@param inputImage input image which should be warped with the final warpMatrix in
+order to provide an image similar to templateImage, same type as templateImage.
+@param warpMatrix floating-point \f$2\times 3\f$ or \f$3\times 3\f$ mapping matrix (warp).
+@param motionType parameter, specifying the type of motion:
+ -   **MOTION_TRANSLATION** sets a translational motion model; warpMatrix is \f$2\times 3\f$ with
+     the first \f$2\times 2\f$ part being the unity matrix and the rest two parameters being
+     estimated.
+ -   **MOTION_EUCLIDEAN** sets a Euclidean (rigid) transformation as motion model; three
+     parameters are estimated; warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_AFFINE** sets an affine motion model (DEFAULT); six parameters are estimated;
+     warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_HOMOGRAPHY** sets a homography as a motion model; eight parameters are
+     estimated;\`warpMatrix\` is \f$3\times 3\f$.
+@param criteria parameter, specifying the termination criteria of the ECC algorithm;
+criteria.epsilon defines the threshold of the increment in the correlation coefficient between two
+iterations (a negative criteria.epsilon makes criteria.maxcount the only termination criterion).
+Default values are shown in the declaration above.
+@param inputMask An optional single channel mask to indicate valid values of inputImage.
+@param gaussFiltSize An optional value indicating size of gaussian blur filter; (DEFAULT: 5)
+
+The function estimates the optimum transformation (warpMatrix) with respect to ECC criterion
+(@cite EP08), that is
+
+\f[\texttt{warpMatrix} = \arg\max_{W} \texttt{ECC}(\texttt{templateImage}(x,y),\texttt{inputImage}(x',y'))\f]
+
+where
+
+\f[\begin{bmatrix} x' \\ y' \end{bmatrix} = W \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}\f]
+
+(the equation holds with homogeneous coordinates for homography). It returns the final enhanced
+correlation coefficient, that is the correlation coefficient between the template image and the
+final warped input image. When a \f$3\times 3\f$ matrix is given with motionType =0, 1 or 2, the third
+row is ignored.
+
+Unlike findHomography and estimateRigidTransform, the function findTransformECC implements an
+area-based alignment that builds on intensity similarities. In essence, the function updates the
+initial transformation that roughly aligns the images. If this information is missing, the identity
+warp (unity matrix) is used as an initialization. Note that if images undergo strong
+displacements/rotations, an initial transformation that roughly aligns the images is necessary
+(e.g., a simple euclidean/similarity transform that allows for the images showing the same image
+content approximately). Use inverse warping in the second image to take an image close to the first
+one, i.e. use the flag WARP_INVERSE_MAP with warpAffine or warpPerspective. See also the OpenCV
+sample image_alignment.cpp that demonstrates the use of the function. Note that the function throws
+an exception if algorithm does not converges.
+
+@sa
+computeECC, estimateAffine2D, estimateAffinePartial2D, findHomography
+ */
+CV_EXPORTS_W double findTransformECC( InputArray templateImage, InputArray inputImage,
+                                      InputOutputArray warpMatrix, int motionType,
+                                      TermCriteria criteria,
+                                      InputArray inputMask, int gaussFiltSize);
+
+/** @overload */
+CV_EXPORTS_W
+double findTransformECC(InputArray templateImage, InputArray inputImage,
+    InputOutputArray warpMatrix, int motionType = MOTION_AFFINE,
+    TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001),
+    InputArray inputMask = noArray());
+
+/** @brief Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08
+using validity masks for both the template and the input images.
+
+This function extends findTransformECC() by adding a mask for the template image.
+The Enhanced Correlation Coefficient is evaluated only over pixels that are valid in both images:
+on each iteration inputMask is warped into the template frame and combined with templateMask, and
+only the intersection of these masks contributes to the objective function.
+
+@param templateImage 1 or 3 channel template image; CV_8U, CV_16U, CV_32F, CV_64F type.
+@param inputImage input image which should be warped with the final warpMatrix in
+order to provide an image similar to templateImage, same type as templateImage.
+@param templateMask single-channel 8-bit mask for templateImage indicating valid pixels
+to be used in the alignment. Must have the same size as templateImage.
+@param inputMask single-channel 8-bit mask for inputImage indicating valid pixels
+before warping. Must have the same size as inputImage.
+@param warpMatrix floating-point \f$2\times 3\f$ or \f$3\times 3\f$ mapping matrix (warp).
+@param motionType parameter, specifying the type of motion:
+ -   **MOTION_TRANSLATION** sets a translational motion model; warpMatrix is \f$2\times 3\f$ with
+     the first \f$2\times 2\f$ part being the unity matrix and the rest two parameters being
+     estimated.
+ -   **MOTION_EUCLIDEAN** sets a Euclidean (rigid) transformation as motion model; three
+     parameters are estimated; warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_AFFINE** sets an affine motion model (DEFAULT); six parameters are estimated;
+     warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_HOMOGRAPHY** sets a homography as a motion model; eight parameters are
+     estimated; warpMatrix is \f$3\times 3\f$.
+@param criteria parameter, specifying the termination criteria of the ECC algorithm;
+criteria.epsilon defines the threshold of the increment in the correlation coefficient between two
+iterations (a negative criteria.epsilon makes criteria.maxcount the only termination criterion).
+Default values are shown in the declaration above.
+@param gaussFiltSize size of the Gaussian blur filter used for smoothing images and masks
+before computing the alignment (DEFAULT: 5).
+
+@sa
+findTransformECC, computeECC, estimateAffine2D, estimateAffinePartial2D, findHomography
+*/
+CV_EXPORTS_W double findTransformECCWithMask( InputArray templateImage,
+                                 InputArray inputImage,
+                                 InputArray templateMask,
+                                 InputArray inputMask,
+                                 InputOutputArray warpMatrix,
+                                 int motionType = MOTION_AFFINE,
+                                 TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 50, 1e-6),
+                                 int gaussFiltSize = 5 );
+
+/** @brief struct ECCParameters is used by findTransformECCMultiScale
+
+@param motionType parameter, specifying the type of motion:
+ -   **MOTION_TRANSLATION** sets a translational motion model; warpMatrix is \f$2\times 3\f$ with
+     the first \f$2\times 2\f$ part being the unity matrix and the rest two parameters being
+     estimated.
+ -   **MOTION_EUCLIDEAN** sets a Euclidean (rigid) transformation as motion model; three
+     parameters are estimated; warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_AFFINE** sets an affine motion model (DEFAULT); six parameters are estimated;
+     warpMatrix is \f$2\times 3\f$.
+ -   **MOTION_HOMOGRAPHY** sets a homography as a motion model; eight parameters are
+     estimated;\`warpMatrix\` is \f$3\times 3\f$.
+@param criteria parameter, specifying the termination criteria of the ECC algorithm;
+criteria.epsilon defines the threshold of the increment in the correlation coefficient between two
+iterations (a negative criteria.epsilon makes criteria.maxcount the only termination criterion).
+Default values are shown in the declaration above.
+@param itersPerLevel Criterion extension: distribution of iterations limit over pyramid levels.
+Can be empty, in this case, this algorithm will use criteria.maxCount on each level.
+@param gaussFiltSize An optional value indicating size of gaussian blur filter; (DEFAULT: 5)
+@param nlevels An optional value indicating amount of levels in the pyramid; (DEFAULT: 4)
+@param interpolation Type of warp interpolation. Possible values are INTER_NEAREST and INTER_LINEAR.
+Affects accuracy, especially when motionType == MOTION_TRANSLATION. (DEFAULT: INTER_LINEAR)
+ */
+struct CV_EXPORTS_W_SIMPLE ECCParameters
+{
+    CV_WRAP ECCParameters();
+    CV_PROP_RW int motionType = MOTION_AFFINE;
+    CV_PROP_RW cv::TermCriteria criteria;
+    CV_PROP_RW std::vector<int> itersPerLevel;
+    CV_PROP_RW int gaussFiltSize = 5;
+    CV_PROP_RW int nlevels = 4;
+    CV_PROP_RW int interpolation = INTER_LINEAR;
+};
+
+/** @brief Finds the geometric transform (warp) between two images in terms of the ECC criterion @cite EP08. Uses pyramids.
+
+@param reference Single channel reference image; CV_8U, CV_16U, CV_32F, CV_64F type.
+@param sample sample image which should be warped with the final warpMatrix in
+order to provide an image similar to reference, same type as reference.
+@param warpMatrix floating-point \f$2\times 3\f$ or \f$3\times 3\f$ mapping matrix (warp).
+@param eccParams List of the algorithm parameters. See ECCParameters for details.
+@param referenceMask An optional single channel mask to indicate valid values of reference.
+@param sampleMask An optional single channel mask to indicate valid values of sample.
+
+The function estimates the optimum transformation (warpMatrix) with respect to ECC criterion
+(@cite EP08), that is
+
+\f[\texttt{warpMatrix} = \arg\max_{W} \texttt{ECC}(\texttt{templateImage}(x,y),\texttt{inputImage}(x',y'))\f]
+
+where
+
+\f[\begin{bmatrix} x' \\ y' \end{bmatrix} = W \cdot \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}\f]
+
+(the equation holds with homogeneous coordinates for homography). It returns the final enhanced
+correlation coefficient, that is the correlation coefficient between the template image and the
+final warped input image. When a \f$3\times 3\f$ matrix is given with motionType =0, 1 or 2, the third
+row is ignored.
+
+Unlike findHomography and estimateRigidTransform, the function findTransformECCMultiScale implements
+an area-based alignment that builds on intensity similarities. In essence, the function updates the
+initial transformation that roughly aligns the images. If this information is missing, the identity
+warp (unity matrix) is used as an initialization. Note that if images undergo strong
+displacements/rotations, an initial transformation that roughly aligns the images is necessary
+(e.g., a simple euclidean/similarity transform that allows for the images showing the same image
+content approximately). Use inverse warping in the second image to take an image close to the first
+one, i.e. use the flag WARP_INVERSE_MAP with warpAffine or warpPerspective. See also the OpenCV
+sample image_alignment.cpp that demonstrates the use of the function. Note that the function throws
+an exception if algorithm does not converges.
+Unlike findTransformECC, the findTransformECCMultiScale uses pyramids, making function more stable
+and able to handle correctly more sophisticated cases.
+
+@sa
+computeECC, estimateAffine2D, estimateAffinePartial2D, findHomography
+*/
+
+CV_EXPORTS_W double findTransformECCMultiScale(InputArray reference,
+                        InputArray sample,
+                        InputOutputArray warpMatrix,
+                        const ECCParameters& eccParams = ECCParameters(),
+                        InputArray referenceMask = noArray(),
+                        InputArray sampleMask = noArray());
+
+/** @example samples/cpp/snippets/kalman.cpp
+An example using the standard Kalman filter
+*/
+
+
+/** @example samples/python/snippets/kalman.py
+An example using the standard Kalman filter in Python.
+ */
+
+/** @brief Kalman filter class.
+
+The class implements a standard Kalman filter <http://en.wikipedia.org/wiki/Kalman_filter>,
+@cite Welch95 . However, you can modify transitionMatrix, controlMatrix, and measurementMatrix to get
+an extended Kalman filter functionality.
+@note In C API when CvKalman\* kalmanFilter structure is not needed anymore, it should be released
+with cvReleaseKalman(&kalmanFilter)
+ */
+class CV_EXPORTS_W KalmanFilter
+{
+public:
+    CV_WRAP KalmanFilter();
+    /** @overload
+    @param dynamParams Dimensionality of the state.
+    @param measureParams Dimensionality of the measurement.
+    @param controlParams Dimensionality of the control vector.
+    @param type Type of the created matrices that should be CV_32F or CV_64F.
+    */
+    CV_WRAP KalmanFilter( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
+
+    /** @brief Re-initializes Kalman filter. The previous content is destroyed.
+
+    @param dynamParams Dimensionality of the state.
+    @param measureParams Dimensionality of the measurement.
+    @param controlParams Dimensionality of the control vector.
+    @param type Type of the created matrices that should be CV_32F or CV_64F.
+     */
+    void init( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
+
+    /** @brief Computes a predicted state.
+
+    @param control The optional input control
+     */
+    CV_WRAP const Mat& predict( const Mat& control = Mat() );
+
+    /** @brief Updates the predicted state from the measurement.
+
+    @param measurement The measured system parameters
+     */
+    CV_WRAP const Mat& correct( const Mat& measurement );
+
+    CV_PROP_RW Mat statePre;           //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
+    CV_PROP_RW Mat statePost;          //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
+    CV_PROP_RW Mat transitionMatrix;   //!< state transition matrix (A)
+    CV_PROP_RW Mat controlMatrix;      //!< control matrix (B) (not used if there is no control)
+    CV_PROP_RW Mat measurementMatrix;  //!< measurement matrix (H)
+    CV_PROP_RW Mat processNoiseCov;    //!< process noise covariance matrix (Q)
+    CV_PROP_RW Mat measurementNoiseCov;//!< measurement noise covariance matrix (R)
+    CV_PROP_RW Mat errorCovPre;        //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
+    CV_PROP_RW Mat gain;               //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
+    CV_PROP_RW Mat errorCovPost;       //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
+
+    // temporary matrices
+    Mat temp1;
+    Mat temp2;
+    Mat temp3;
+    Mat temp4;
+    Mat temp5;
+};
+
+
+/** @brief Read a .flo file
+
+ @param path Path to the file to be loaded
+
+ The function readOpticalFlow loads a flow field from a file and returns it as a single matrix.
+ Resulting Mat has a type CV_32FC2 - floating-point, 2-channel. First channel corresponds to the
+ flow in the horizontal direction (u), second - vertical (v).
+ */
+CV_EXPORTS_W Mat readOpticalFlow( const String& path );
+/** @brief Write a .flo to disk
+
+ @param path Path to the file to be written
+ @param flow Flow field to be stored
+
+ The function stores a flow field in a file, returns true on success, false otherwise.
+ The flow field must be a 2-channel, floating-point matrix (CV_32FC2). First channel corresponds
+ to the flow in the horizontal direction (u), second - vertical (v).
+ */
+CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow );
+
+/** @example samples/python/snippets/dis_opt_flow.py
+An example using the dense optical flow and DIS optical flow algorithms in python
+*/
+
+/** @example samples/cpp/snippets/dis_opticalflow.cpp
+An example using the dense optical flow and DIS optical flow algorithms
+*/
+
+/**
+   Base class for dense optical flow algorithms
+*/
+class CV_EXPORTS_W DenseOpticalFlow : public Algorithm
+{
+public:
+    /** @brief Calculates an optical flow.
+
+    @param I0 first 8-bit single-channel input image.
+    @param I1 second input image of the same size and the same type as prev.
+    @param flow computed flow image that has the same size as prev and type CV_32FC2.
+     */
+    CV_WRAP virtual void calc( InputArray I0, InputArray I1, InputOutputArray flow ) = 0;
+    /** @brief Releases all inner buffers.
+    */
+    CV_WRAP virtual void collectGarbage() = 0;
+};
+
+/** @brief Base interface for sparse optical flow algorithms.
+ */
+class CV_EXPORTS_W SparseOpticalFlow : public Algorithm
+{
+public:
+    /** @brief Calculates a sparse optical flow.
+
+    @param prevImg First input image.
+    @param nextImg Second input image of the same size and the same type as prevImg.
+    @param prevPts Vector of 2D points for which the flow needs to be found.
+    @param nextPts Output vector of 2D points containing the calculated new positions of input features in the second image.
+    @param status Output status vector. Each element of the vector is set to 1 if the
+                  flow for the corresponding features has been found. Otherwise, it is set to 0.
+    @param err Optional output vector that contains error response for each point (inverse confidence).
+     */
+    CV_WRAP virtual void calc(InputArray prevImg, InputArray nextImg,
+                      InputArray prevPts, InputOutputArray nextPts,
+                      OutputArray status,
+                      OutputArray err = cv::noArray()) = 0;
+};
+
+
+/** @brief Class computing a dense optical flow using the Gunnar Farneback's algorithm.
+ */
+class CV_EXPORTS_W FarnebackOpticalFlow : public DenseOpticalFlow
+{
+public:
+    CV_WRAP virtual int getNumLevels() const = 0;
+    CV_WRAP virtual void setNumLevels(int numLevels) = 0;
+
+    CV_WRAP virtual double getPyrScale() const = 0;
+    CV_WRAP virtual void setPyrScale(double pyrScale) = 0;
+
+    CV_WRAP virtual bool getFastPyramids() const = 0;
+    CV_WRAP virtual void setFastPyramids(bool fastPyramids) = 0;
+
+    CV_WRAP virtual int getWinSize() const = 0;
+    CV_WRAP virtual void setWinSize(int winSize) = 0;
+
+    CV_WRAP virtual int getNumIters() const = 0;
+    CV_WRAP virtual void setNumIters(int numIters) = 0;
+
+    CV_WRAP virtual int getPolyN() const = 0;
+    CV_WRAP virtual void setPolyN(int polyN) = 0;
+
+    CV_WRAP virtual double getPolySigma() const = 0;
+    CV_WRAP virtual void setPolySigma(double polySigma) = 0;
+
+    CV_WRAP virtual int getFlags() const = 0;
+    CV_WRAP virtual void setFlags(int flags) = 0;
+
+    CV_WRAP static Ptr<FarnebackOpticalFlow> create(
+            int numLevels = 5,
+            double pyrScale = 0.5,
+            bool fastPyramids = false,
+            int winSize = 13,
+            int numIters = 10,
+            int polyN = 5,
+            double polySigma = 1.1,
+            int flags = 0);
+};
+
+/** @brief Variational optical flow refinement
+
+This class implements variational refinement of the input flow field, i.e.
+it uses input flow to initialize the minimization of the following functional:
+\f$E(U) = \int_{\Omega} \delta \Psi(E_I) + \gamma \Psi(E_G) + \alpha \Psi(E_S) \f$,
+where \f$E_I,E_G,E_S\f$ are color constancy, gradient constancy and smoothness terms
+respectively. \f$\Psi(s^2)=\sqrt{s^2+\epsilon^2}\f$ is a robust penalizer to limit the
+influence of outliers. A complete formulation and a description of the minimization
+procedure can be found in @cite Brox2004
+*/
+class CV_EXPORTS_W VariationalRefinement : public DenseOpticalFlow
+{
+public:
+    /** @brief @ref calc function overload to handle separate horizontal (u) and vertical (v) flow components
+    (to avoid extra splits/merges) */
+    CV_WRAP virtual void calcUV(InputArray I0, InputArray I1, InputOutputArray flow_u, InputOutputArray flow_v) = 0;
+
+    /** @brief Number of outer (fixed-point) iterations in the minimization procedure.
+    @see setFixedPointIterations */
+    CV_WRAP virtual int getFixedPointIterations() const = 0;
+    /** @copybrief getFixedPointIterations @see getFixedPointIterations */
+    CV_WRAP virtual void setFixedPointIterations(int val) = 0;
+
+    /** @brief Number of inner successive over-relaxation (SOR) iterations
+        in the minimization procedure to solve the respective linear system.
+    @see setSorIterations */
+    CV_WRAP virtual int getSorIterations() const = 0;
+    /** @copybrief getSorIterations @see getSorIterations */
+    CV_WRAP virtual void setSorIterations(int val) = 0;
+
+    /** @brief Relaxation factor in SOR
+    @see setOmega */
+    CV_WRAP virtual float getOmega() const = 0;
+    /** @copybrief getOmega @see getOmega */
+    CV_WRAP virtual void setOmega(float val) = 0;
+
+    /** @brief Weight of the smoothness term
+    @see setAlpha */
+    CV_WRAP virtual float getAlpha() const = 0;
+    /** @copybrief getAlpha @see getAlpha */
+    CV_WRAP virtual void setAlpha(float val) = 0;
+
+    /** @brief Weight of the color constancy term
+    @see setDelta */
+    CV_WRAP virtual float getDelta() const = 0;
+    /** @copybrief getDelta @see getDelta */
+    CV_WRAP virtual void setDelta(float val) = 0;
+
+    /** @brief Weight of the gradient constancy term
+    @see setGamma */
+    CV_WRAP virtual float getGamma() const = 0;
+    /** @copybrief getGamma @see getGamma */
+    CV_WRAP virtual void setGamma(float val) = 0;
+
+    /** @brief Norm value shift for robust penalizer
+    @see setEpsilon */
+    CV_WRAP virtual float getEpsilon() const = 0;
+    /** @copybrief getEpsilon @see getEpsilon */
+    CV_WRAP virtual void setEpsilon(float val) = 0;
+
+    /** @brief Creates an instance of VariationalRefinement
+    */
+    CV_WRAP static Ptr<VariationalRefinement> create();
+};
+
+/** @brief DIS optical flow algorithm.
+
+This class implements the Dense Inverse Search (DIS) optical flow algorithm. More
+details about the algorithm can be found at @cite Kroeger2016 . Includes three presets with preselected
+parameters to provide reasonable trade-off between speed and quality. However, even the slowest preset is
+still relatively fast, use DeepFlow if you need better quality and don't care about speed.
+
+This implementation includes several additional features compared to the algorithm described in the paper,
+including spatial propagation of flow vectors (@ref getUseSpatialPropagation), as well as an option to
+utilize an initial flow approximation passed to @ref calc (which is, essentially, temporal propagation,
+if the previous frame's flow field is passed).
+*/
+class CV_EXPORTS_W DISOpticalFlow : public DenseOpticalFlow
+{
+public:
+    enum
+    {
+        PRESET_ULTRAFAST = 0,
+        PRESET_FAST = 1,
+        PRESET_MEDIUM = 2
+    };
+
+    /** @brief Finest level of the Gaussian pyramid on which the flow is computed (zero level
+        corresponds to the original image resolution). The final flow is obtained by bilinear upscaling.
+        @see setFinestScale */
+    CV_WRAP virtual int getFinestScale() const = 0;
+    /** @copybrief getFinestScale @see getFinestScale */
+    CV_WRAP virtual void setFinestScale(int val) = 0;
+
+    /** @brief Sets the coarsest scale
+    @param val Coarsest level of the Gaussian pyramid on which the flow is computed.
+    If set to -1, the auto-computed coarsest scale will be used.
+    */
+    CV_WRAP virtual void setCoarsestScale(int val) = 0;
+
+    /** @brief Gets the coarsest scale
+    */
+    CV_WRAP virtual int getCoarsestScale() const = 0;
+
+    /** @brief Size of an image patch for matching (in pixels). Normally, default 8x8 patches work well
+        enough in most cases.
+        @see setPatchSize */
+    CV_WRAP virtual int getPatchSize() const = 0;
+    /** @copybrief getPatchSize @see getPatchSize */
+    CV_WRAP virtual void setPatchSize(int val) = 0;
+
+    /** @brief Stride between neighbor patches. Must be less than patch size. Lower values correspond
+        to higher flow quality.
+        @see setPatchStride */
+    CV_WRAP virtual int getPatchStride() const = 0;
+    /** @copybrief getPatchStride @see getPatchStride */
+    CV_WRAP virtual void setPatchStride(int val) = 0;
+
+    /** @brief Maximum number of gradient descent iterations in the patch inverse search stage. Higher values
+        may improve quality in some cases.
+        @see setGradientDescentIterations */
+    CV_WRAP virtual int getGradientDescentIterations() const = 0;
+    /** @copybrief getGradientDescentIterations @see getGradientDescentIterations */
+    CV_WRAP virtual void setGradientDescentIterations(int val) = 0;
+
+    /** @brief Number of fixed point iterations of variational refinement per scale. Set to zero to
+        disable variational refinement completely. Higher values will typically result in more smooth and
+        high-quality flow.
+    @see setGradientDescentIterations */
+    CV_WRAP virtual int getVariationalRefinementIterations() const = 0;
+    /** @copybrief getGradientDescentIterations @see getGradientDescentIterations */
+    CV_WRAP virtual void setVariationalRefinementIterations(int val) = 0;
+
+    /** @brief Weight of the smoothness term
+    @see setVariationalRefinementAlpha */
+    CV_WRAP virtual float getVariationalRefinementAlpha() const = 0;
+    /** @copybrief getVariationalRefinementAlpha @see getVariationalRefinementAlpha */
+    CV_WRAP virtual void setVariationalRefinementAlpha(float val) = 0;
+
+    /** @brief Weight of the color constancy term
+    @see setVariationalRefinementDelta */
+    CV_WRAP virtual float getVariationalRefinementDelta() const = 0;
+    /** @copybrief getVariationalRefinementDelta @see getVariationalRefinementDelta */
+    CV_WRAP virtual void setVariationalRefinementDelta(float val) = 0;
+
+    /** @brief Weight of the gradient constancy term
+    @see setVariationalRefinementGamma */
+    CV_WRAP virtual float getVariationalRefinementGamma() const = 0;
+    /** @copybrief getVariationalRefinementGamma @see getVariationalRefinementGamma */
+    CV_WRAP virtual void setVariationalRefinementGamma(float val) = 0;
+
+    /** @brief Norm value shift for robust penalizer
+    @see setVariationalRefinementEpsilon */
+    CV_WRAP virtual float getVariationalRefinementEpsilon() const = 0;
+    /** @copybrief getVariationalRefinementEpsilon @see getVariationalRefinementEpsilon */
+    CV_WRAP virtual void setVariationalRefinementEpsilon(float val) = 0;
+
+
+    /** @brief Whether to use mean-normalization of patches when computing patch distance. It is turned on
+        by default as it typically provides a noticeable quality boost because of increased robustness to
+        illumination variations. Turn it off if you are certain that your sequence doesn't contain any changes
+        in illumination.
+    @see setUseMeanNormalization */
+    CV_WRAP virtual bool getUseMeanNormalization() const = 0;
+    /** @copybrief getUseMeanNormalization @see getUseMeanNormalization */
+    CV_WRAP virtual void setUseMeanNormalization(bool val) = 0;
+
+    /** @brief Whether to use spatial propagation of good optical flow vectors. This option is turned on by
+        default, as it tends to work better on average and can sometimes help recover from major errors
+        introduced by the coarse-to-fine scheme employed by the DIS optical flow algorithm. Turning this
+        option off can make the output flow field a bit smoother, however.
+    @see setUseSpatialPropagation */
+    CV_WRAP virtual bool getUseSpatialPropagation() const = 0;
+    /** @copybrief getUseSpatialPropagation @see getUseSpatialPropagation */
+    CV_WRAP virtual void setUseSpatialPropagation(bool val) = 0;
+
+    /** @brief Creates an instance of DISOpticalFlow
+
+    @param preset one of PRESET_ULTRAFAST, PRESET_FAST and PRESET_MEDIUM
+    */
+    CV_WRAP static Ptr<DISOpticalFlow> create(int preset = DISOpticalFlow::PRESET_FAST);
+};
+
+/** @brief Class used for calculating a sparse optical flow.
+
+The class can calculate an optical flow for a sparse feature set using the
+iterative Lucas-Kanade method with pyramids.
+
+@sa calcOpticalFlowPyrLK
+
+*/
+class CV_EXPORTS_W SparsePyrLKOpticalFlow : public SparseOpticalFlow
+{
+public:
+    CV_WRAP virtual Size getWinSize() const = 0;
+    CV_WRAP virtual void setWinSize(Size winSize) = 0;
+
+    CV_WRAP virtual int getMaxLevel() const = 0;
+    CV_WRAP virtual void setMaxLevel(int maxLevel) = 0;
+
+    CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
+    CV_WRAP virtual void setTermCriteria(TermCriteria& crit) = 0;
+
+    CV_WRAP virtual int getFlags() const = 0;
+    CV_WRAP virtual void setFlags(int flags) = 0;
+
+    CV_WRAP virtual double getMinEigThreshold() const = 0;
+    CV_WRAP virtual void setMinEigThreshold(double minEigThreshold) = 0;
+
+    CV_WRAP static Ptr<SparsePyrLKOpticalFlow> create(
+            Size winSize = Size(21, 21),
+            int maxLevel = 3, TermCriteria crit =
+            TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
+            int flags = 0,
+            double minEigThreshold = 1e-4);
+};
+
+
+
+
+/** @brief Base abstract class for the long-term tracker
+ */
+class CV_EXPORTS_W Tracker
+{
+protected:
+    Tracker();
+public:
+    virtual ~Tracker();
+
+    /** @brief Initialize the tracker with a known bounding box that surrounded the target
+    @param image The initial frame
+    @param boundingBox The initial bounding box
+    */
+    CV_WRAP virtual
+    void init(InputArray image, const Rect& boundingBox) = 0;
+
+    /** @brief Update the tracker, find the new most likely bounding box for the target
+    @param image The current frame
+    @param boundingBox The bounding box that represent the new target location, if true was returned, not
+    modified otherwise
+
+    @return True means that target was located and false means that tracker cannot locate target in
+    current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed
+    missing from the frame (say, out of sight)
+    */
+    CV_WRAP virtual
+    bool update(InputArray image, CV_OUT Rect& boundingBox) = 0;
+
+    /** @brief Return tracking score
+    */
+    CV_WRAP virtual float getTrackingScore() { return -1; }
+
+};
+
+
+
+/** @brief The MIL algorithm trains a classifier in an online manner to separate the object from the
+background.
+
+Multiple Instance Learning avoids the drift problem for a robust tracking. The implementation is
+based on @cite MIL .
+
+Original code can be found here <http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml>
+ */
+class CV_EXPORTS_W TrackerMIL : public Tracker
+{
+protected:
+    TrackerMIL();  // use ::create()
+public:
+    virtual ~TrackerMIL() CV_OVERRIDE;
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        //parameters for sampler
+        CV_PROP_RW float samplerInitInRadius;  //!< radius for gathering positive instances during init
+        CV_PROP_RW int samplerInitMaxNegNum;  //!< # negative samples to use during init
+        CV_PROP_RW float samplerSearchWinSize;  //!< size of search window
+        CV_PROP_RW float samplerTrackInRadius;  //!< radius for gathering positive instances during tracking
+        CV_PROP_RW int samplerTrackMaxPosNum;  //!< # positive samples to use during tracking
+        CV_PROP_RW int samplerTrackMaxNegNum;  //!< # negative samples to use during tracking
+        CV_PROP_RW int featureSetNumFeatures;  //!< # features
+    };
+
+    /** @brief Create MIL tracker instance
+     *  @param parameters MIL parameters TrackerMIL::Params
+     */
+    static CV_WRAP
+    Ptr<TrackerMIL> create(const TrackerMIL::Params &parameters = TrackerMIL::Params());
+
+    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
+};
+
+class CV_EXPORTS_W TrackerDaSiamRPN : public Tracker
+{
+protected:
+    TrackerDaSiamRPN();  // use ::create()
+public:
+    virtual ~TrackerDaSiamRPN() CV_OVERRIDE;
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        CV_PROP_RW std::string model;
+        CV_PROP_RW std::string kernel_cls1;
+        CV_PROP_RW std::string kernel_r1;
+        CV_PROP_RW int backend;
+        CV_PROP_RW int target;
+    };
+
+    /** @brief Constructor
+    @param parameters DaSiamRPN parameters TrackerDaSiamRPN::Params
+    */
+    static CV_WRAP
+    Ptr<TrackerDaSiamRPN> create(const TrackerDaSiamRPN::Params& parameters = TrackerDaSiamRPN::Params());
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Constructor
+     *  @param siam_rpn pre-loaded SiamRPN model
+     *  @param kernel_cls1 pre-loaded CLS model
+     *  @param kernel_r1 pre-loaded R1 model
+     */
+    static CV_WRAP
+    Ptr<TrackerDaSiamRPN> create(const dnn::Net& siam_rpn, const dnn::Net& kernel_cls1, const dnn::Net& kernel_r1);
+#endif
+
+    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
+};
+
+/** @brief the Nano tracker is a super lightweight dnn-based general object tracking.
+ *
+ *  Nano tracker is much faster and extremely lightweight due to special model structure, the whole model size is about 1.9 MB.
+ *  Nano tracker needs two models: one for feature extraction (backbone) and the another for localization (neckhead).
+ *  Model download link: https://github.com/HonglinChu/SiamTrackers/tree/master/NanoTrack/models/nanotrackv2
+ *  Original repo is here: https://github.com/HonglinChu/NanoTrack
+ *  Author: HongLinChu, 1628464345@qq.com
+ */
+class CV_EXPORTS_W TrackerNano : public Tracker
+{
+protected:
+    TrackerNano();  // use ::create()
+public:
+    virtual ~TrackerNano() CV_OVERRIDE;
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        CV_PROP_RW std::string backbone;
+        CV_PROP_RW std::string neckhead;
+        CV_PROP_RW int backend;
+        CV_PROP_RW int target;
+    };
+
+    /** @brief Constructor
+    @param parameters NanoTrack parameters TrackerNano::Params
+    */
+    static CV_WRAP
+    Ptr<TrackerNano> create(const TrackerNano::Params& parameters = TrackerNano::Params());
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Constructor
+     *  @param backbone pre-loaded backbone model
+     *  @param neckhead pre-loaded neckhead model
+     */
+    static CV_WRAP
+    Ptr<TrackerNano> create(const dnn::Net& backbone, const dnn::Net& neckhead);
+#endif
+
+    //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
+};
+
+/** @brief the VIT tracker is a super lightweight dnn-based general object tracking.
+ *
+ *  VIT tracker is much faster and extremely lightweight due to special model structure, the model file is about 767KB.
+ *  Model download link: https://github.com/opencv/opencv_zoo/tree/main/models/object_tracking_vittrack
+ *  Author: PengyuLiu, 1872918507@qq.com
+ */
+class CV_EXPORTS_W TrackerVit : public Tracker
+{
+protected:
+    TrackerVit();  // use ::create()
+public:
+    virtual ~TrackerVit() CV_OVERRIDE;
+
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        CV_PROP_RW std::string net;
+        CV_PROP_RW int backend;
+        CV_PROP_RW int target;
+        CV_PROP_RW Scalar meanvalue;
+        CV_PROP_RW Scalar stdvalue;
+        CV_PROP_RW float tracking_score_threshold;
+    };
+
+    /** @brief Constructor
+    @param parameters vit tracker parameters TrackerVit::Params
+    */
+    static CV_WRAP
+    Ptr<TrackerVit> create(const TrackerVit::Params& parameters = TrackerVit::Params());
+
+#ifdef HAVE_OPENCV_DNN
+    /** @brief Constructor
+     *  @param model pre-loaded DNN model
+     *  @param meanvalue mean value for image preprocessing
+     *  @param stdvalue std value for image preprocessing
+     *  @param tracking_score_threshold threshold for tracking score
+     */
+    static CV_WRAP
+    Ptr<TrackerVit> create(const dnn::Net& model, Scalar meanvalue = Scalar(0.485, 0.456, 0.406),
+                           Scalar stdvalue = Scalar(0.229, 0.224, 0.225), float tracking_score_threshold = 0.20f);
+#endif
+
+    // void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    // bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
+};
+
+//! @} video_track
+
+} // cv
+
+#endif
diff --git a/upstream/opencv/modules/video/include/opencv2/video/video.hpp b/upstream/opencv/modules/video/include/opencv2/video/video.hpp
new file mode 100644
index 0000000..8267b85
--- /dev/null
+++ b/upstream/opencv/modules/video/include/opencv2/video/video.hpp
@@ -0,0 +1,48 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/video.hpp"
diff --git a/upstream/opencv/modules/video/src/bgfg_KNN.cpp b/upstream/opencv/modules/video/src/bgfg_KNN.cpp
new file mode 100644
index 0000000..cdf4eb3
--- /dev/null
+++ b/upstream/opencv/modules/video/src/bgfg_KNN.cpp
@@ -0,0 +1,913 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+//#include <math.h>
+
+#include "precomp.hpp"
+#include "opencl_kernels_video.hpp"
+
+namespace cv
+{
+
+/*!
+ The class implements the following algorithm:
+ "Efficient Adaptive Density Estimation per Image Pixel for the Task of Background Subtraction"
+ Z.Zivkovic, F. van der Heijden
+ Pattern Recognition Letters, vol. 27, no. 7, pages 773-780, 2006
+ http://www.zoranz.net/Publications/zivkovicPRL2006.pdf
+*/
+
+// default parameters of gaussian background detection algorithm
+static const int defaultHistory2 = 500; // Learning rate; alpha = 1/defaultHistory2
+static const int defaultNsamples = 7; // number of samples saved in memory
+static const float defaultDist2Threshold = 20.0f*20.0f;//threshold on distance from the sample
+
+// additional parameters
+static const unsigned char defaultnShadowDetection2 = (unsigned char)127; // value to use in the segmentation mask for shadows, set 0 not to do shadow detection
+static const float defaultfTau = 0.5f; // Tau - shadow threshold, see the paper for explanation
+
+class BackgroundSubtractorKNNImpl CV_FINAL : public BackgroundSubtractorKNN
+{
+public:
+    //! the default constructor
+    BackgroundSubtractorKNNImpl()
+    {
+    frameSize = Size(0,0);
+    frameType = 0;
+    nframes = 0;
+    history = defaultHistory2;
+
+    //set parameters
+    // N - the number of samples stored in memory per model
+    nN = defaultNsamples;
+
+    //kNN - k nearest neighbour - number on NN for detecting background - default K=[0.1*nN]
+    nkNN=MAX(1,cvRound(0.1*nN*3+0.40));
+
+    //Tb - Threshold Tb*kernelwidth
+    fTb = defaultDist2Threshold;
+
+    // Shadow detection
+    bShadowDetection = 1;//turn on
+    nShadowDetection =  defaultnShadowDetection2;
+    fTau = defaultfTau;// Tau - shadow threshold
+    name_ = "BackgroundSubtractor.KNN";
+    nLongCounter = 0;
+    nMidCounter = 0;
+    nShortCounter = 0;
+#ifdef HAVE_OPENCL
+    opencl_ON = true;
+#endif
+    }
+    //! the full constructor that takes the length of the history,
+    // the number of gaussian mixtures, the background ratio parameter and the noise strength
+    BackgroundSubtractorKNNImpl(int _history,  float _dist2Threshold, bool _bShadowDetection=true)
+    {
+    frameSize = Size(0,0);
+    frameType = 0;
+
+    nframes = 0;
+    history = _history > 0 ? _history : defaultHistory2;
+
+    //set parameters
+    // N - the number of samples stored in memory per model
+    nN = defaultNsamples;
+    //kNN - k nearest neighbour - number on NN for detecting background - default K=[0.1*nN]
+    nkNN=MAX(1,cvRound(0.1*nN*3+0.40));
+
+    //Tb - Threshold Tb*kernelwidth
+    fTb = _dist2Threshold>0? _dist2Threshold : defaultDist2Threshold;
+
+    bShadowDetection = _bShadowDetection;
+    nShadowDetection =  defaultnShadowDetection2;
+    fTau = defaultfTau;
+    name_ = "BackgroundSubtractor.KNN";
+    nLongCounter = 0;
+    nMidCounter = 0;
+    nShortCounter = 0;
+#ifdef HAVE_OPENCL
+    opencl_ON = true;
+#endif
+    }
+    //! the destructor
+    ~BackgroundSubtractorKNNImpl() CV_OVERRIDE {}
+    //! the update operator
+    void apply(InputArray image, OutputArray fgmask, double learningRate) CV_OVERRIDE;
+
+    void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE;
+
+    //! computes a background image which are the mean of all background gaussians
+    virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE;
+
+    //! re-initialization method
+    void initialize(Size _frameSize, int _frameType)
+    {
+        frameSize = _frameSize;
+        frameType = _frameType;
+        nframes = 0;
+
+        int nchannels = CV_MAT_CN(frameType);
+        CV_Assert( nchannels <= CV_CN_MAX );
+
+        // Reserve memory for the model
+        int size=frameSize.height*frameSize.width;
+        //Reset counters
+        nShortCounter = 0;
+        nMidCounter = 0;
+        nLongCounter = 0;
+
+#ifdef HAVE_OPENCL
+        if (ocl::isOpenCLActivated() && opencl_ON)
+        {
+            create_ocl_apply_kernel();
+
+            kernel_getBg.create("getBackgroundImage2_kernel", ocl::video::bgfg_knn_oclsrc, format( "-D CN=%d -D NSAMPLES=%d", nchannels, nN));
+
+            if (kernel_apply.empty() || kernel_getBg.empty())
+                opencl_ON = false;
+        }
+        else opencl_ON = false;
+
+        if (opencl_ON)
+        {
+            u_flag.create(frameSize.height * nN * 3, frameSize.width, CV_8UC1);
+            u_flag.setTo(Scalar::all(0));
+
+            if (nchannels==3)
+                nchannels=4;
+            u_sample.create(frameSize.height * nN * 3, frameSize.width, CV_32FC(nchannels));
+            u_sample.setTo(Scalar::all(0));
+
+            u_aModelIndexShort.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_aModelIndexShort.setTo(Scalar::all(0));
+            u_aModelIndexMid.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_aModelIndexMid.setTo(Scalar::all(0));
+            u_aModelIndexLong.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_aModelIndexLong.setTo(Scalar::all(0));
+
+            u_nNextShortUpdate.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_nNextShortUpdate.setTo(Scalar::all(0));
+            u_nNextMidUpdate.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_nNextMidUpdate.setTo(Scalar::all(0));
+            u_nNextLongUpdate.create(frameSize.height, frameSize.width, CV_8UC1);
+            u_nNextLongUpdate.setTo(Scalar::all(0));
+        }
+        else
+#endif
+        {
+            // for each sample of 3 speed pixel models each pixel bg model we store ...
+            // values + flag (nchannels+1 values)
+            bgmodel.create( 1,(nN * 3) * (nchannels+1)* size,CV_8U);
+            bgmodel = Scalar::all(0);
+
+            //index through the three circular lists
+            aModelIndexShort.create(1,size,CV_8U);
+            aModelIndexMid.create(1,size,CV_8U);
+            aModelIndexLong.create(1,size,CV_8U);
+            //when to update next
+            nNextShortUpdate.create(1,size,CV_8U);
+            nNextMidUpdate.create(1,size,CV_8U);
+            nNextLongUpdate.create(1,size,CV_8U);
+
+            aModelIndexShort = Scalar::all(0);//random? //((m_nN)*rand())/(RAND_MAX+1);//0...m_nN-1
+            aModelIndexMid = Scalar::all(0);
+            aModelIndexLong = Scalar::all(0);
+            nNextShortUpdate = Scalar::all(0);
+            nNextMidUpdate = Scalar::all(0);
+            nNextLongUpdate = Scalar::all(0);
+        }
+    }
+
+    virtual String getDefaultName() const CV_OVERRIDE { return "BackgroundSubtractor_KNN"; }
+
+    virtual int getHistory() const CV_OVERRIDE { return history; }
+    virtual void setHistory(int _nframes) CV_OVERRIDE { history = _nframes; }
+
+    virtual int getNSamples() const CV_OVERRIDE { return nN; }
+    virtual void setNSamples(int _nN) CV_OVERRIDE { nN = _nN; }//needs reinitialization!
+
+    virtual int getkNNSamples() const CV_OVERRIDE { return nkNN; }
+    virtual void setkNNSamples(int _nkNN) CV_OVERRIDE { nkNN = _nkNN; }
+
+    virtual double getDist2Threshold() const CV_OVERRIDE { return fTb; }
+    virtual void setDist2Threshold(double _dist2Threshold) CV_OVERRIDE { fTb = (float)_dist2Threshold; }
+
+    virtual bool getDetectShadows() const CV_OVERRIDE { return bShadowDetection; }
+    virtual void setDetectShadows(bool detectshadows) CV_OVERRIDE
+    {
+        if (bShadowDetection == detectshadows)
+            return;
+        bShadowDetection = detectshadows;
+#ifdef HAVE_OPENCL
+        if (!kernel_apply.empty())
+        {
+            create_ocl_apply_kernel();
+            CV_Assert( !kernel_apply.empty() );
+        }
+#endif
+    }
+
+    virtual int getShadowValue() const CV_OVERRIDE { return nShadowDetection; }
+    virtual void setShadowValue(int value) CV_OVERRIDE { nShadowDetection = (uchar)value; }
+
+    virtual double getShadowThreshold() const CV_OVERRIDE { return fTau; }
+    virtual void setShadowThreshold(double value) CV_OVERRIDE { fTau = (float)value; }
+
+    virtual void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name_
+        << "history" << history
+        << "nsamples" << nN
+        << "nKNN" << nkNN
+        << "dist2Threshold" << fTb
+        << "detectShadows" << (int)bShadowDetection
+        << "shadowValue" << (int)nShadowDetection
+        << "shadowThreshold" << fTau;
+    }
+
+    virtual void read(const FileNode& fn) CV_OVERRIDE
+    {
+        CV_Assert( (String)fn["name"] == name_ );
+        history = (int)fn["history"];
+        nN = (int)fn["nsamples"];
+        nkNN = (int)fn["nKNN"];
+        fTb = (float)fn["dist2Threshold"];
+        bShadowDetection = (int)fn["detectShadows"] != 0;
+        nShadowDetection = saturate_cast<uchar>((int)fn["shadowValue"]);
+        fTau = (float)fn["shadowThreshold"];
+    }
+
+protected:
+    Size frameSize;
+    int frameType;
+    int nframes;
+    /////////////////////////
+    //very important parameters - things you will change
+    ////////////////////////
+    int history;
+    //alpha=1/history - speed of update - if the time interval you want to average over is T
+    //set alpha=1/history. It is also useful at start to make T slowly increase
+    //from 1 until the desired T
+    float fTb;
+    //Tb - threshold on the squared distance from the sample used to decide if it is well described
+    //by the background model or not. A typical value could be 2 sigma
+    //and that is Tb=2*2*10*10 =400; where we take typical pixel level sigma=10
+
+    /////////////////////////
+    //less important parameters - things you might change but be careful
+    ////////////////////////
+    int nN;//totlal number of samples
+    int nkNN;//number on NN for detecting background - default K=[0.1*nN]
+
+    //shadow detection parameters
+    bool bShadowDetection;//default 1 - do shadow detection
+    unsigned char nShadowDetection;//do shadow detection - insert this value as the detection result - 127 default value
+    float fTau;
+    // Tau - shadow threshold. The shadow is detected if the pixel is darker
+    //version of the background. Tau is a threshold on how much darker the shadow can be.
+    //Tau= 0.5 means that if pixel is more than 2 times darker then it is not shadow
+    //See: Prati,Mikic,Trivedi,Cucchiara,"Detecting Moving Shadows...",IEEE PAMI,2003.
+
+    //model data
+    int nLongCounter;//circular counter
+    int nMidCounter;
+    int nShortCounter;
+    Mat bgmodel; // model data pixel values
+    Mat aModelIndexShort;// index into the models
+    Mat aModelIndexMid;
+    Mat aModelIndexLong;
+    Mat nNextShortUpdate;//random update points per model
+    Mat nNextMidUpdate;
+    Mat nNextLongUpdate;
+
+#ifdef HAVE_OPENCL
+    mutable bool opencl_ON;
+
+    UMat u_flag;
+    UMat u_sample;
+    UMat u_aModelIndexShort;
+    UMat u_aModelIndexMid;
+    UMat u_aModelIndexLong;
+    UMat u_nNextShortUpdate;
+    UMat u_nNextMidUpdate;
+    UMat u_nNextLongUpdate;
+
+    mutable ocl::Kernel kernel_apply;
+    mutable ocl::Kernel kernel_getBg;
+#endif
+
+    String name_;
+
+#ifdef HAVE_OPENCL
+    bool ocl_getBackgroundImage(OutputArray backgroundImage) const;
+    bool ocl_apply(InputArray _image, OutputArray _fgmask, double learningRate=-1);
+    void create_ocl_apply_kernel();
+#endif
+};
+
+CV_INLINE void
+        _cvUpdatePixelBackgroundNP(int x_idx, const uchar* data, int nchannels, int m_nN,
+        uchar* m_aModel,
+        uchar* m_nNextLongUpdate,
+        uchar* m_nNextMidUpdate,
+        uchar* m_nNextShortUpdate,
+        uchar* m_aModelIndexLong,
+        uchar* m_aModelIndexMid,
+        uchar* m_aModelIndexShort,
+        int m_nLongCounter,
+        int m_nMidCounter,
+        int m_nShortCounter,
+        uchar include
+        )
+{
+    // hold the offset
+    int ndata=1+nchannels;
+    long offsetLong =  ndata * (m_aModelIndexLong[x_idx] + m_nN * 2);
+    long offsetMid =   ndata * (m_aModelIndexMid[x_idx]  + m_nN * 1);
+    long offsetShort = ndata * (m_aModelIndexShort[x_idx]);
+
+    // Long update?
+    if (m_nNextLongUpdate[x_idx] == m_nLongCounter)
+    {
+        // add the oldest pixel from Mid to the list of values (for each color)
+        memcpy(&m_aModel[offsetLong],&m_aModel[offsetMid],ndata*sizeof(unsigned char));
+        // increase the index
+        m_aModelIndexLong[x_idx] = (m_aModelIndexLong[x_idx] >= (m_nN-1)) ? 0 : (m_aModelIndexLong[x_idx] + 1);
+    };
+
+    // Mid update?
+    if (m_nNextMidUpdate[x_idx] == m_nMidCounter)
+    {
+        // add this pixel to the list of values (for each color)
+        memcpy(&m_aModel[offsetMid],&m_aModel[offsetShort],ndata*sizeof(unsigned char));
+        // increase the index
+        m_aModelIndexMid[x_idx] = (m_aModelIndexMid[x_idx] >= (m_nN-1)) ? 0 : (m_aModelIndexMid[x_idx] + 1);
+    };
+
+    // Short update?
+    if (m_nNextShortUpdate[x_idx] == m_nShortCounter)
+    {
+        // add this pixel to the list of values (for each color)
+        memcpy(&m_aModel[offsetShort],data,nchannels*sizeof(unsigned char));
+        //set the include flag
+        m_aModel[offsetShort+nchannels]=include;
+        // increase the index
+        m_aModelIndexShort[x_idx] = (m_aModelIndexShort[x_idx] >= (m_nN-1)) ? 0 : (m_aModelIndexShort[x_idx] + 1);
+    };
+}
+
+CV_INLINE int
+        _cvCheckPixelBackgroundNP(const uchar* data, int nchannels,
+        int m_nN,
+        uchar* m_aModel,
+        float m_fTb,
+        int m_nkNN,
+        float tau,
+        bool m_bShadowDetection,
+        uchar& include)
+{
+    int Pbf = 0; // the total probability that this pixel is background
+    int Pb = 0; //background model probability
+    float dData[CV_CN_MAX];
+
+    //uchar& include=data[nchannels];
+    include=0;//do we include this pixel into background model?
+
+    int ndata=nchannels+1;
+    // now increase the probability for each pixel
+    for (int n = 0; n < m_nN*3; n++)
+    {
+        uchar* mean_m = &m_aModel[n*ndata];
+
+        //calculate difference and distance
+        float dist2;
+
+        if( nchannels == 3 )
+        {
+            dData[0] = (float)mean_m[0] - data[0];
+            dData[1] = (float)mean_m[1] - data[1];
+            dData[2] = (float)mean_m[2] - data[2];
+            dist2 = dData[0]*dData[0] + dData[1]*dData[1] + dData[2]*dData[2];
+        }
+        else
+        {
+            dist2 = 0.f;
+            for( int c = 0; c < nchannels; c++ )
+            {
+                dData[c] = (float)mean_m[c] - data[c];
+                dist2 += dData[c]*dData[c];
+            }
+        }
+
+        if (dist2<m_fTb)
+        {
+            Pbf++;//all
+            //background only
+            //if(m_aModel[subPosPixel + nchannels])//indicator
+            if(mean_m[nchannels])//indicator
+            {
+                Pb++;
+                if (Pb >= m_nkNN)//Tb
+                {
+                    include=1;//include
+                    return 1;//background ->exit
+                };
+            }
+        };
+    };
+
+    //include?
+    if (Pbf>=m_nkNN)//m_nTbf)
+    {
+        include=1;
+    }
+
+    int Ps = 0; // the total probability that this pixel is background shadow
+    // Detected as moving object, perform shadow detection
+    if (m_bShadowDetection)
+    {
+        for (int n = 0; n < m_nN*3; n++)
+        {
+            //long subPosPixel = posPixel + n*ndata;
+            uchar* mean_m = &m_aModel[n*ndata];
+
+            if(mean_m[nchannels])//check only background
+            {
+                float numerator = 0.0f;
+                float denominator = 0.0f;
+                for( int c = 0; c < nchannels; c++ )
+                {
+                    numerator   += (float)data[c] * mean_m[c];
+                    denominator += (float)mean_m[c] * mean_m[c];
+                }
+
+                // no division by zero allowed
+                if( denominator == 0 )
+                    return 0;
+
+                // if tau < a < 1 then also check the color distortion
+                if( numerator <= denominator && numerator >= tau*denominator )
+                {
+                    float a = numerator / denominator;
+                    float dist2a = 0.0f;
+
+                    for( int c = 0; c < nchannels; c++ )
+                    {
+                        float dD= a*mean_m[c] - data[c];
+                        dist2a += dD*dD;
+                    }
+
+                    if (dist2a<m_fTb*a*a)
+                    {
+                        Ps++;
+                        if (Ps >= m_nkNN)//shadow
+                            return 2;
+                    };
+                };
+            };
+        };
+    }
+    return 0;
+}
+
+class KNNInvoker : public ParallelLoopBody
+{
+public:
+    KNNInvoker(const Mat& _src, Mat& _dst,
+               uchar* _bgmodel,
+               uchar* _nNextLongUpdate,
+               uchar* _nNextMidUpdate,
+               uchar* _nNextShortUpdate,
+               uchar* _aModelIndexLong,
+               uchar* _aModelIndexMid,
+               uchar* _aModelIndexShort,
+               int _nLongCounter,
+               int _nMidCounter,
+               int _nShortCounter,
+               int _nN,
+               float _fTb,
+               int _nkNN,
+               float _fTau,
+               bool _bShadowDetection,
+               uchar _nShadowDetection,
+               const Mat& _knownForegroundMask)
+            :  knownForegroundMask(_knownForegroundMask)
+    {
+        src = &_src;
+        dst = &_dst;
+        m_aModel0 = _bgmodel;
+        m_nNextLongUpdate0 = _nNextLongUpdate;
+        m_nNextMidUpdate0 = _nNextMidUpdate;
+        m_nNextShortUpdate0 = _nNextShortUpdate;
+        m_aModelIndexLong0 = _aModelIndexLong;
+        m_aModelIndexMid0 = _aModelIndexMid;
+        m_aModelIndexShort0 = _aModelIndexShort;
+        m_nLongCounter = _nLongCounter;
+        m_nMidCounter = _nMidCounter;
+        m_nShortCounter = _nShortCounter;
+        m_nN = _nN;
+        m_fTb = _fTb;
+        m_fTau = _fTau;
+        m_nkNN = _nkNN;
+        m_bShadowDetection = _bShadowDetection;
+        m_nShadowDetection = _nShadowDetection;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        int y0 = range.start, y1 = range.end;
+        int ncols = src->cols, nchannels = src->channels();
+        int ndata=nchannels+1;
+
+        for ( int y = y0; y < y1; y++ )
+        {
+            const uchar* data = src->ptr(y);
+            uchar* m_aModel = m_aModel0 + ncols*m_nN*3*ndata*y;
+            uchar* m_nNextLongUpdate = m_nNextLongUpdate0 + ncols*y;
+            uchar* m_nNextMidUpdate = m_nNextMidUpdate0 + ncols*y;
+            uchar* m_nNextShortUpdate = m_nNextShortUpdate0 + ncols*y;
+            uchar* m_aModelIndexLong = m_aModelIndexLong0 + ncols*y;
+            uchar* m_aModelIndexMid = m_aModelIndexMid0 + ncols*y;
+            uchar* m_aModelIndexShort = m_aModelIndexShort0 + ncols*y;
+            uchar* mask = dst->ptr(y);
+
+            for ( int x = 0; x < ncols; x++ )
+            {
+
+                //update model+ background subtract
+                uchar include=0;
+                int result= _cvCheckPixelBackgroundNP(data, nchannels,
+                        m_nN, m_aModel, m_fTb,m_nkNN, m_fTau,m_bShadowDetection,include);
+
+                _cvUpdatePixelBackgroundNP(x,data,nchannels,
+                        m_nN, m_aModel,
+                        m_nNextLongUpdate,
+                        m_nNextMidUpdate,
+                        m_nNextShortUpdate,
+                        m_aModelIndexLong,
+                        m_aModelIndexMid,
+                        m_aModelIndexShort,
+                        m_nLongCounter,
+                        m_nMidCounter,
+                        m_nShortCounter,
+                        include
+                        );
+                // Check that foreground mask exists
+                if (!knownForegroundMask.empty()) {
+                    // If input mask states pixel is foreground
+                    if (knownForegroundMask.at<uchar>(y, x) > 0)
+                    {
+                        mask[x] = 255; // ensure output mask marks this pixel as FG
+                        data += nchannels;
+                        m_aModel += m_nN*3*ndata;
+                        continue;
+                    }
+                }
+                switch (result)
+                {
+                    case 0:
+                        //foreground
+                        mask[x] = 255;
+                        break;
+                    case 1:
+                        //background
+                        mask[x] = 0;
+                        break;
+                    case 2:
+                        //shadow
+                        mask[x] = m_nShadowDetection;
+                        break;
+                }
+                data += nchannels;
+                m_aModel += m_nN*3*ndata;
+            }
+        }
+    }
+
+    const Mat* src;
+    Mat* dst;
+    uchar* m_aModel0;
+    uchar* m_nNextLongUpdate0;
+    uchar* m_nNextMidUpdate0;
+    uchar* m_nNextShortUpdate0;
+    uchar* m_aModelIndexLong0;
+    uchar* m_aModelIndexMid0;
+    uchar* m_aModelIndexShort0;
+    int m_nLongCounter;
+    int m_nMidCounter;
+    int m_nShortCounter;
+    int m_nN;
+    float m_fTb;
+    float m_fTau;
+    int m_nkNN;
+    bool m_bShadowDetection;
+    uchar m_nShadowDetection;
+    const Mat& knownForegroundMask;
+};
+
+#ifdef HAVE_OPENCL
+bool BackgroundSubtractorKNNImpl::ocl_apply(InputArray _image, OutputArray _fgmask, double learningRate)
+{
+    bool needToInitialize = nframes == 0 || learningRate >= 1 || _image.size() != frameSize || _image.type() != frameType;
+
+    if( needToInitialize )
+        initialize(_image.size(), _image.type());
+
+    ++nframes;
+    learningRate = learningRate >= 0 && nframes > 1 ? learningRate : 1./std::min( 2*nframes, history );
+    CV_Assert(learningRate >= 0);
+
+    _fgmask.create(_image.size(), CV_8U);
+    UMat fgmask = _fgmask.getUMat();
+
+    UMat frame = _image.getUMat();
+
+    //recalculate update rates - in case alpha is changed
+    // calculate update parameters (using alpha)
+    int Kshort,Kmid,Klong;
+    //approximate exponential learning curve
+    Kshort=(int)(log(0.7)/log(1-learningRate))+1;//Kshort
+    Kmid=(int)(log(0.4)/log(1-learningRate))-Kshort+1;//Kmid
+    Klong=(int)(log(0.1)/log(1-learningRate))-Kshort-Kmid+1;//Klong
+
+    //refresh rates
+    int nShortUpdate = (Kshort/nN)+1;
+    int nMidUpdate = (Kmid/nN)+1;
+    int nLongUpdate = (Klong/nN)+1;
+
+    int idxArg = 0;
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::ReadOnly(frame));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadOnly(u_nNextLongUpdate));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadOnly(u_nNextMidUpdate));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadOnly(u_nNextShortUpdate));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_aModelIndexLong));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_aModelIndexMid));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_aModelIndexShort));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_flag));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_sample));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::WriteOnlyNoSize(fgmask));
+
+    idxArg = kernel_apply.set(idxArg, nLongCounter);
+    idxArg = kernel_apply.set(idxArg, nMidCounter);
+    idxArg = kernel_apply.set(idxArg, nShortCounter);
+    idxArg = kernel_apply.set(idxArg, fTb);
+    idxArg = kernel_apply.set(idxArg, nkNN);
+    idxArg = kernel_apply.set(idxArg, fTau);
+    if (bShadowDetection)
+        kernel_apply.set(idxArg, nShadowDetection);
+
+    size_t globalsize[2] = {(size_t)frame.cols, (size_t)frame.rows};
+    if(!kernel_apply.run(2, globalsize, NULL, true))
+        return false;
+
+    nShortCounter++;//0,1,...,nShortUpdate-1
+    nMidCounter++;
+    nLongCounter++;
+    if (nShortCounter >= nShortUpdate)
+    {
+        nShortCounter = 0;
+        randu(u_nNextShortUpdate, Scalar::all(0),  Scalar::all(nShortUpdate));
+    }
+    if (nMidCounter >= nMidUpdate)
+    {
+        nMidCounter = 0;
+        randu(u_nNextMidUpdate, Scalar::all(0),  Scalar::all(nMidUpdate));
+    }
+    if (nLongCounter >= nLongUpdate)
+    {
+        nLongCounter = 0;
+        randu(u_nNextLongUpdate, Scalar::all(0),  Scalar::all(nLongUpdate));
+    }
+    return true;
+}
+
+bool BackgroundSubtractorKNNImpl::ocl_getBackgroundImage(OutputArray _backgroundImage) const
+{
+    _backgroundImage.create(frameSize, frameType);
+    UMat dst = _backgroundImage.getUMat();
+
+    int idxArg = 0;
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::PtrReadOnly(u_flag));
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::PtrReadOnly(u_sample));
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::WriteOnly(dst));
+
+    size_t globalsize[2] = {(size_t)dst.cols, (size_t)dst.rows};
+
+    return kernel_getBg.run(2, globalsize, NULL, false);
+}
+
+void BackgroundSubtractorKNNImpl::create_ocl_apply_kernel()
+{
+    int nchannels = CV_MAT_CN(frameType);
+    String opts = format("-D CN=%d -D NSAMPLES=%d%s", nchannels, nN, bShadowDetection ? " -D SHADOW_DETECT" : "");
+    kernel_apply.create("knn_kernel", ocl::video::bgfg_knn_oclsrc, opts);
+}
+
+#endif
+
+// Base 3 version class
+void BackgroundSubtractorKNNImpl::apply(InputArray _image, OutputArray _fgmask, double learningRate) {
+    apply(_image,  noArray(), _fgmask, learningRate);
+}
+
+void BackgroundSubtractorKNNImpl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate)
+{
+    CV_INSTRUMENT_REGION();
+
+#ifdef HAVE_OPENCL
+    if (opencl_ON)
+    {
+#ifndef __APPLE__
+        CV_OCL_RUN(_fgmask.isUMat() && OCL_PERFORMANCE_CHECK(!ocl::Device::getDefault().isIntel() || _image.channels() == 1),
+                   ocl_apply(_image, _fgmask, learningRate))
+#else
+        CV_OCL_RUN(_fgmask.isUMat() && OCL_PERFORMANCE_CHECK(!ocl::Device::getDefault().isIntel()),
+                   ocl_apply(_image, _fgmask, learningRate))
+#endif
+
+        opencl_ON = false;
+        nframes = 0;
+    }
+#endif
+
+    bool needToInitialize = nframes == 0 || learningRate >= 1 || _image.size() != frameSize || _image.type() != frameType;
+
+    if( needToInitialize )
+        initialize(_image.size(), _image.type());
+
+    Mat image = _image.getMat();
+    _fgmask.create( image.size(), CV_8U );
+    Mat fgmask = _fgmask.getMat();
+
+    Mat knownForegroundMask = _knownForegroundMask.getMat();
+
+    if(!knownForegroundMask.empty())
+    {
+    CV_Assert(knownForegroundMask.type() == CV_8UC1);
+    CV_Assert(knownForegroundMask.size() == image.size());
+    }
+
+    ++nframes;
+    learningRate = learningRate >= 0 && nframes > 1 ? learningRate : 1./std::min( 2*nframes, history );
+    CV_Assert(learningRate >= 0);
+
+    //recalculate update rates - in case alpha is changed
+    // calculate update parameters (using alpha)
+    int Kshort,Kmid,Klong;
+    //approximate exponential learning curve
+    Kshort=(int)(log(0.7)/log(1-learningRate))+1;//Kshort
+    Kmid=(int)(log(0.4)/log(1-learningRate))-Kshort+1;//Kmid
+    Klong=(int)(log(0.1)/log(1-learningRate))-Kshort-Kmid+1;//Klong
+
+    //refresh rates
+    int nShortUpdate = (Kshort/nN)+1;
+    int nMidUpdate = (Kmid/nN)+1;
+    int nLongUpdate = (Klong/nN)+1;
+
+    parallel_for_(Range(0, image.rows),
+                  KNNInvoker(image, fgmask,
+                             bgmodel.ptr(),
+                             nNextLongUpdate.ptr(),
+                             nNextMidUpdate.ptr(),
+                             nNextShortUpdate.ptr(),
+                             aModelIndexLong.ptr(),
+                             aModelIndexMid.ptr(),
+                             aModelIndexShort.ptr(),
+                             nLongCounter,
+                             nMidCounter,
+                             nShortCounter,
+                             nN,
+                             fTb,
+                             nkNN,
+                             fTau,
+                             bShadowDetection,
+                             nShadowDetection,
+                             knownForegroundMask),
+                             image.total()/(double)(1 << 16));
+
+    nShortCounter++;//0,1,...,nShortUpdate-1
+    nMidCounter++;
+    nLongCounter++;
+    if (nShortCounter >= nShortUpdate)
+    {
+        nShortCounter = 0;
+        randu(nNextShortUpdate, Scalar::all(0),  Scalar::all(nShortUpdate));
+    }
+    if (nMidCounter >= nMidUpdate)
+    {
+        nMidCounter = 0;
+        randu(nNextMidUpdate, Scalar::all(0),  Scalar::all(nMidUpdate));
+    }
+    if (nLongCounter >= nLongUpdate)
+    {
+        nLongCounter = 0;
+        randu(nNextLongUpdate, Scalar::all(0),  Scalar::all(nLongUpdate));
+    }
+}
+
+void BackgroundSubtractorKNNImpl::getBackgroundImage(OutputArray backgroundImage) const
+{
+    CV_INSTRUMENT_REGION();
+
+#ifdef HAVE_OPENCL
+    if (opencl_ON)
+    {
+        CV_OCL_RUN(opencl_ON, ocl_getBackgroundImage(backgroundImage))
+
+        opencl_ON = false;
+    }
+#endif
+
+    int nchannels = CV_MAT_CN(frameType);
+    //CV_Assert( nchannels == 3 );
+    Mat meanBackground(frameSize, CV_8UC3, Scalar::all(0));
+
+    int ndata=nchannels+1;
+    int modelstep=(ndata * nN * 3);
+
+    const uchar* pbgmodel=bgmodel.ptr(0);
+    for(int row=0; row<meanBackground.rows; row++)
+    {
+        for(int col=0; col<meanBackground.cols; col++)
+        {
+            for (int n = 0; n < nN*3; n++)
+            {
+                const uchar* mean_m = &pbgmodel[n*ndata];
+                if (mean_m[nchannels])
+                {
+                    meanBackground.at<Vec3b>(row, col) = Vec3b(mean_m);
+                    break;
+                }
+            }
+            pbgmodel=pbgmodel+modelstep;
+        }
+    }
+
+    switch(CV_MAT_CN(frameType))
+    {
+        case 1:
+        {
+            std::vector<Mat> channels;
+            split(meanBackground, channels);
+            channels[0].copyTo(backgroundImage);
+            break;
+        }
+        case 3:
+        {
+            meanBackground.copyTo(backgroundImage);
+            break;
+        }
+        default:
+            CV_Error(Error::StsUnsupportedFormat, "");
+    }
+}
+
+
+Ptr<BackgroundSubtractorKNN> createBackgroundSubtractorKNN(int _history, double _threshold2,
+                                                           bool _bShadowDetection)
+{
+    return makePtr<BackgroundSubtractorKNNImpl>(_history, (float)_threshold2, _bShadowDetection);
+}
+
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp b/upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp
new file mode 100644
index 0000000..48d8ee8
--- /dev/null
+++ b/upstream/opencv/modules/video/src/bgfg_gaussmix2.cpp
@@ -0,0 +1,996 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*//Implementation of the Gaussian mixture model background subtraction from:
+//
+//"Improved adaptive Gaussian mixture model for background subtraction"
+//Z.Zivkovic
+//International Conference Pattern Recognition, UK, August, 2004
+//http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf
+//The code is very fast and performs also shadow detection.
+//Number of Gaussian components is adapted per pixel.
+//
+// and
+//
+//"Efficient Adaptive Density Estimapion per Image Pixel for the Task of Background Subtraction"
+//Z.Zivkovic, F. van der Heijden
+//Pattern Recognition Letters, vol. 27, no. 7, pages 773-780, 2006.
+//
+//The algorithm similar to the standard Stauffer&Grimson algorithm with
+//additional selection of the number of the Gaussian components based on:
+//
+//"Recursive unsupervised learning of finite mixture models "
+//Z.Zivkovic, F.van der Heijden
+//IEEE Trans. on Pattern Analysis and Machine Intelligence, vol.26, no.5, pages 651-656, 2004
+//http://www.zoranz.net/Publications/zivkovic2004PAMI.pdf
+//
+//
+//Example usage with as cpp class
+// BackgroundSubtractorMOG2 bg_model;
+//For each new image the model is updates using:
+// bg_model(img, fgmask);
+//
+//Example usage as part of the CvBGStatModel:
+// CvBGStatModel* bg_model = cvCreateGaussianBGModel2( first_frame );
+//
+// //update for each frame
+// cvUpdateBGStatModel( tmp_frame, bg_model );//segmentation result is in bg_model->foreground
+//
+// //release at the program termination
+// cvReleaseBGStatModel( &bg_model );
+//
+//Author: Z.Zivkovic, www.zoranz.net
+//Date: 7-April-2011, Version:1.0
+///////////*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_video.hpp"
+
+namespace cv
+{
+
+/*
+ Interface of Gaussian mixture algorithm from:
+
+ "Improved adaptive Gaussian mixture model for background subtraction"
+ Z.Zivkovic
+ International Conference Pattern Recognition, UK, August, 2004
+ http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf
+
+ Advantages:
+ -fast - number of Gaussian components is constantly adapted per pixel.
+ -performs also shadow detection (see bgfg_segm_test.cpp example)
+
+*/
+
+// default parameters of gaussian background detection algorithm
+static const int defaultHistory2 = 500; // Learning rate; alpha = 1/defaultHistory2
+static const float defaultVarThreshold2 = 4.0f*4.0f;
+static const int defaultNMixtures2 = 5; // maximal number of Gaussians in mixture
+static const float defaultBackgroundRatio2 = 0.9f; // threshold sum of weights for background test
+static const float defaultVarThresholdGen2 = 3.0f*3.0f;
+static const float defaultVarInit2 = 15.0f; // initial variance for new components
+static const float defaultVarMax2 = 5*defaultVarInit2;
+static const float defaultVarMin2 = 4.0f;
+
+// additional parameters
+static const float defaultfCT2 = 0.05f; // complexity reduction prior constant 0 - no reduction of number of components
+static const unsigned char defaultnShadowDetection2 = (unsigned char)127; // value to use in the segmentation mask for shadows, set 0 not to do shadow detection
+static const float defaultfTau = 0.5f; // Tau - shadow threshold, see the paper for explanation
+
+
+class BackgroundSubtractorMOG2Impl CV_FINAL : public BackgroundSubtractorMOG2
+{
+public:
+    //! the default constructor
+    BackgroundSubtractorMOG2Impl()
+    {
+        frameSize = Size(0,0);
+        frameType = 0;
+
+        nframes = 0;
+        history = defaultHistory2;
+        varThreshold = defaultVarThreshold2;
+        bShadowDetection = 1;
+
+        nmixtures = defaultNMixtures2;
+        backgroundRatio = defaultBackgroundRatio2;
+        fVarInit = defaultVarInit2;
+        fVarMax  = defaultVarMax2;
+        fVarMin = defaultVarMin2;
+
+        varThresholdGen = defaultVarThresholdGen2;
+        fCT = defaultfCT2;
+        nShadowDetection =  defaultnShadowDetection2;
+        fTau = defaultfTau;
+#ifdef HAVE_OPENCL
+        opencl_ON = true;
+#endif
+    }
+    //! the full constructor that takes the length of the history,
+    // the number of gaussian mixtures, the background ratio parameter and the noise strength
+    BackgroundSubtractorMOG2Impl(int _history,  float _varThreshold, bool _bShadowDetection=true)
+    {
+        frameSize = Size(0,0);
+        frameType = 0;
+
+        nframes = 0;
+        history = _history > 0 ? _history : defaultHistory2;
+        varThreshold = (_varThreshold>0)? _varThreshold : defaultVarThreshold2;
+        bShadowDetection = _bShadowDetection;
+
+        nmixtures = defaultNMixtures2;
+        backgroundRatio = defaultBackgroundRatio2;
+        fVarInit = defaultVarInit2;
+        fVarMax  = defaultVarMax2;
+        fVarMin = defaultVarMin2;
+
+        varThresholdGen = defaultVarThresholdGen2;
+        fCT = defaultfCT2;
+        nShadowDetection =  defaultnShadowDetection2;
+        fTau = defaultfTau;
+        name_ = "BackgroundSubtractor.MOG2";
+#ifdef HAVE_OPENCL
+        opencl_ON = true;
+#endif
+    }
+    //! the destructor
+    ~BackgroundSubtractorMOG2Impl() CV_OVERRIDE {}
+    //! the update operator
+    void apply(InputArray image, OutputArray fgmask, double learningRate) CV_OVERRIDE;
+
+    void apply(InputArray image, InputArray knownForegroundMask, OutputArray fgmask, double learningRate) CV_OVERRIDE;
+
+    //! computes a background image which are the mean of all background gaussians
+    virtual void getBackgroundImage(OutputArray backgroundImage) const CV_OVERRIDE;
+
+    //! re-initialization method
+    void initialize(Size _frameSize, int _frameType)
+    {
+        frameSize = _frameSize;
+        frameType = _frameType;
+        nframes = 0;
+
+        int nchannels = CV_MAT_CN(frameType);
+        CV_Assert( nchannels <= CV_CN_MAX );
+        CV_Assert( nmixtures <= 255);
+
+#ifdef HAVE_OPENCL
+        if (ocl::isOpenCLActivated() && opencl_ON)
+        {
+            create_ocl_apply_kernel();
+
+            bool isFloat = CV_MAKETYPE(CV_32F,nchannels) == frameType;
+            kernel_getBg.create("getBackgroundImage2_kernel", ocl::video::bgfg_mog2_oclsrc, format( "-D CN=%d -D FL=%d -D NMIXTURES=%d", nchannels, isFloat, nmixtures));
+
+            if (kernel_apply.empty() || kernel_getBg.empty())
+                opencl_ON = false;
+        }
+        else opencl_ON = false;
+
+        if (opencl_ON)
+        {
+            u_weight.create(frameSize.height * nmixtures, frameSize.width, CV_32FC1);
+            u_weight.setTo(Scalar::all(0));
+
+            u_variance.create(frameSize.height * nmixtures, frameSize.width, CV_32FC1);
+            u_variance.setTo(Scalar::all(0));
+
+            if (nchannels==3)
+                nchannels=4;
+            u_mean.create(frameSize.height * nmixtures, frameSize.width, CV_32FC(nchannels)); //4 channels
+            u_mean.setTo(Scalar::all(0));
+
+            //make the array for keeping track of the used modes per pixel - all zeros at start
+            u_bgmodelUsedModes.create(frameSize, CV_8UC1);
+            u_bgmodelUsedModes.setTo(cv::Scalar::all(0));
+        }
+        else
+#endif
+        {
+            // for each gaussian mixture of each pixel bg model we store ...
+            // the mixture weight (w),
+            // the mean (nchannels values) and
+            // the covariance
+            bgmodel.create( 1, frameSize.height*frameSize.width*nmixtures*(2 + nchannels), CV_32F );
+            //make the array for keeping track of the used modes per pixel - all zeros at start
+            bgmodelUsedModes.create(frameSize,CV_8U);
+            bgmodelUsedModes = Scalar::all(0);
+        }
+    }
+
+    virtual String getDefaultName() const CV_OVERRIDE { return "BackgroundSubtractor_MOG2"; }
+
+    virtual int getHistory() const CV_OVERRIDE { return history; }
+    virtual void setHistory(int _nframes) CV_OVERRIDE { history = _nframes; }
+
+    virtual int getNMixtures() const CV_OVERRIDE { return nmixtures; }
+    virtual void setNMixtures(int nmix) CV_OVERRIDE { nmixtures = nmix; }
+
+    virtual double getBackgroundRatio() const CV_OVERRIDE { return backgroundRatio; }
+    virtual void setBackgroundRatio(double _backgroundRatio) CV_OVERRIDE { backgroundRatio = (float)_backgroundRatio; }
+
+    virtual double getVarThreshold() const CV_OVERRIDE { return varThreshold; }
+    virtual void setVarThreshold(double _varThreshold) CV_OVERRIDE { varThreshold = _varThreshold; }
+
+    virtual double getVarThresholdGen() const CV_OVERRIDE { return varThresholdGen; }
+    virtual void setVarThresholdGen(double _varThresholdGen) CV_OVERRIDE { varThresholdGen = (float)_varThresholdGen; }
+
+    virtual double getVarInit() const CV_OVERRIDE { return fVarInit; }
+    virtual void setVarInit(double varInit) CV_OVERRIDE { fVarInit = (float)varInit; }
+
+    virtual double getVarMin() const CV_OVERRIDE { return fVarMin; }
+    virtual void setVarMin(double varMin) CV_OVERRIDE { fVarMin = (float)varMin; }
+
+    virtual double getVarMax() const CV_OVERRIDE { return fVarMax; }
+    virtual void setVarMax(double varMax) CV_OVERRIDE { fVarMax = (float)varMax; }
+
+    virtual double getComplexityReductionThreshold() const CV_OVERRIDE { return fCT; }
+    virtual void setComplexityReductionThreshold(double ct) CV_OVERRIDE { fCT = (float)ct; }
+
+    virtual bool getDetectShadows() const CV_OVERRIDE { return bShadowDetection; }
+    virtual void setDetectShadows(bool detectshadows) CV_OVERRIDE
+    {
+        if (bShadowDetection == detectshadows)
+            return;
+        bShadowDetection = detectshadows;
+#ifdef HAVE_OPENCL
+        if (!kernel_apply.empty())
+        {
+            create_ocl_apply_kernel();
+            CV_Assert( !kernel_apply.empty() );
+        }
+#endif
+    }
+
+    virtual int getShadowValue() const CV_OVERRIDE { return nShadowDetection; }
+    virtual void setShadowValue(int value) CV_OVERRIDE { nShadowDetection = (uchar)value; }
+
+    virtual double getShadowThreshold() const CV_OVERRIDE { return fTau; }
+    virtual void setShadowThreshold(double value) CV_OVERRIDE { fTau = (float)value; }
+
+    virtual void write(FileStorage& fs) const CV_OVERRIDE
+    {
+        writeFormat(fs);
+        fs << "name" << name_
+        << "history" << history
+        << "nmixtures" << nmixtures
+        << "backgroundRatio" << backgroundRatio
+        << "varThreshold" << varThreshold
+        << "varThresholdGen" << varThresholdGen
+        << "varInit" << fVarInit
+        << "varMin" << fVarMin
+        << "varMax" << fVarMax
+        << "complexityReductionThreshold" << fCT
+        << "detectShadows" << (int)bShadowDetection
+        << "shadowValue" << (int)nShadowDetection
+        << "shadowThreshold" << fTau;
+    }
+
+    virtual void read(const FileNode& fn) CV_OVERRIDE
+    {
+        CV_Assert( (String)fn["name"] == name_ );
+        history = (int)fn["history"];
+        nmixtures = (int)fn["nmixtures"];
+        backgroundRatio = (float)fn["backgroundRatio"];
+        varThreshold = (double)fn["varThreshold"];
+        varThresholdGen = (float)fn["varThresholdGen"];
+        fVarInit = (float)fn["varInit"];
+        fVarMin = (float)fn["varMin"];
+        fVarMax = (float)fn["varMax"];
+        fCT = (float)fn["complexityReductionThreshold"];
+        bShadowDetection = (int)fn["detectShadows"] != 0;
+        nShadowDetection = saturate_cast<uchar>((int)fn["shadowValue"]);
+        fTau = (float)fn["shadowThreshold"];
+    }
+
+protected:
+    Size frameSize;
+    int frameType;
+    Mat bgmodel;
+    Mat bgmodelUsedModes;//keep track of number of modes per pixel
+
+#ifdef HAVE_OPENCL
+    //for OCL
+
+    mutable bool opencl_ON;
+
+    UMat u_weight;
+    UMat u_variance;
+    UMat u_mean;
+    UMat u_bgmodelUsedModes;
+
+    mutable ocl::Kernel kernel_apply;
+    mutable ocl::Kernel kernel_getBg;
+#endif
+
+    int nframes;
+    int history;
+    int nmixtures;
+    //! here it is the maximum allowed number of mixture components.
+    //! Actual number is determined dynamically per pixel
+    double varThreshold;
+    // threshold on the squared Mahalanobis distance to decide if it is well described
+    // by the background model or not. Related to Cthr from the paper.
+    // This does not influence the update of the background. A typical value could be 4 sigma
+    // and that is varThreshold=4*4=16; Corresponds to Tb in the paper.
+
+    /////////////////////////
+    // less important parameters - things you might change but be careful
+    ////////////////////////
+    float backgroundRatio;
+    // corresponds to fTB=1-cf from the paper
+    // TB - threshold when the component becomes significant enough to be included into
+    // the background model. It is the TB=1-cf from the paper. So I use cf=0.1 => TB=0.
+    // For alpha=0.001 it means that the mode should exist for approximately 105 frames before
+    // it is considered foreground
+    // float noiseSigma;
+    float varThresholdGen;
+    //correspondts to Tg - threshold on the squared Mahalan. dist. to decide
+    //when a sample is close to the existing components. If it is not close
+    //to any a new component will be generated. I use 3 sigma => Tg=3*3=9.
+    //Smaller Tg leads to more generated components and higher Tg might make
+    //lead to small number of components but they can grow too large
+    float fVarInit;
+    float fVarMin;
+    float fVarMax;
+    //initial variance  for the newly generated components.
+    //It will will influence the speed of adaptation. A good guess should be made.
+    //A simple way is to estimate the typical standard deviation from the images.
+    //I used here 10 as a reasonable value
+    // min and max can be used to further control the variance
+    float fCT;//CT - complexity reduction prior
+    //this is related to the number of samples needed to accept that a component
+    //actually exists. We use CT=0.05 of all the samples. By setting CT=0 you get
+    //the standard Stauffer&Grimson algorithm (maybe not exact but very similar)
+
+    //shadow detection parameters
+    bool bShadowDetection;//default 1 - do shadow detection
+    unsigned char nShadowDetection;//do shadow detection - insert this value as the detection result - 127 default value
+    float fTau;
+    // Tau - shadow threshold. The shadow is detected if the pixel is darker
+    //version of the background. Tau is a threshold on how much darker the shadow can be.
+    //Tau= 0.5 means that if pixel is more than 2 times darker then it is not shadow
+    //See: Prati,Mikic,Trivedi,Cucchiara,"Detecting Moving Shadows...",IEEE PAMI,2003.
+
+    String name_;
+
+    template <typename T, int CN>
+    void getBackgroundImage_intern(OutputArray backgroundImage) const;
+
+#ifdef HAVE_OPENCL
+    bool ocl_getBackgroundImage(OutputArray backgroundImage) const;
+    bool ocl_apply(InputArray _image, OutputArray _fgmask, double learningRate=-1);
+    void create_ocl_apply_kernel();
+#endif
+};
+
+struct GaussBGStatModel2Params
+{
+    //image info
+    int nWidth;
+    int nHeight;
+    int nND;//number of data dimensions (image channels)
+
+    bool bPostFiltering;//default 1 - do postfiltering - will make shadow detection results also give value 255
+    double  minArea; // for postfiltering
+
+    bool bInit;//default 1, faster updates at start
+
+    /////////////////////////
+    //very important parameters - things you will change
+    ////////////////////////
+    float fAlphaT;
+    //alpha - speed of update - if the time interval you want to average over is T
+    //set alpha=1/T. It is also useful at start to make T slowly increase
+    //from 1 until the desired T
+    float fTb;
+    //Tb - threshold on the squared Mahalan. dist. to decide if it is well described
+    //by the background model or not. Related to Cthr from the paper.
+    //This does not influence the update of the background. A typical value could be 4 sigma
+    //and that is Tb=4*4=16;
+
+    /////////////////////////
+    //less important parameters - things you might change but be careful
+    ////////////////////////
+    float fTg;
+    //Tg - threshold on the squared Mahalan. dist. to decide
+    //when a sample is close to the existing components. If it is not close
+    //to any a new component will be generated. I use 3 sigma => Tg=3*3=9.
+    //Smaller Tg leads to more generated components and higher Tg might make
+    //lead to small number of components but they can grow too large
+    float fTB;//1-cf from the paper
+    //TB - threshold when the component becomes significant enough to be included into
+    //the background model. It is the TB=1-cf from the paper. So I use cf=0.1 => TB=0.
+    //For alpha=0.001 it means that the mode should exist for approximately 105 frames before
+    //it is considered foreground
+    float fVarInit;
+    float fVarMax;
+    float fVarMin;
+    //initial standard deviation  for the newly generated components.
+    //It will will influence the speed of adaptation. A good guess should be made.
+    //A simple way is to estimate the typical standard deviation from the images.
+    //I used here 10 as a reasonable value
+    float fCT;//CT - complexity reduction prior
+    //this is related to the number of samples needed to accept that a component
+    //actually exists. We use CT=0.05 of all the samples. By setting CT=0 you get
+    //the standard Stauffer&Grimson algorithm (maybe not exact but very similar)
+
+    //even less important parameters
+    int nM;//max number of modes - const - 4 is usually enough
+
+    //shadow detection parameters
+    bool bShadowDetection;//default 1 - do shadow detection
+    unsigned char nShadowDetection;//do shadow detection - insert this value as the detection result
+    float fTau;
+    // Tau - shadow threshold. The shadow is detected if the pixel is darker
+    //version of the background. Tau is a threshold on how much darker the shadow can be.
+    //Tau= 0.5 means that if pixel is more than 2 times darker then it is not shadow
+    //See: Prati,Mikic,Trivedi,Cucchiara,"Detecting Moving Shadows...",IEEE PAMI,2003.
+};
+
+struct GMM
+{
+    float weight;
+    float variance;
+};
+
+// shadow detection performed per pixel
+// should work for rgb data, could be useful for gray scale and depth data as well
+// See: Prati,Mikic,Trivedi,Cucchiara,"Detecting Moving Shadows...",IEEE PAMI,2003.
+CV_INLINE bool
+detectShadowGMM(const float* data, int nchannels, int nmodes,
+                const GMM* gmm, const float* mean,
+                float Tb, float TB, float tau)
+{
+    float tWeight = 0;
+
+    // check all the components  marked as background:
+    for( int mode = 0; mode < nmodes; mode++, mean += nchannels )
+    {
+        GMM g = gmm[mode];
+
+        float numerator = 0.0f;
+        float denominator = 0.0f;
+        for( int c = 0; c < nchannels; c++ )
+        {
+            numerator   += data[c] * mean[c];
+            denominator += mean[c] * mean[c];
+        }
+
+        // no division by zero allowed
+        if( denominator == 0 )
+            return false;
+
+        // if tau < a < 1 then also check the color distortion
+        if( numerator <= denominator && numerator >= tau*denominator )
+        {
+            float a = numerator / denominator;
+            float dist2a = 0.0f;
+
+            for( int c = 0; c < nchannels; c++ )
+            {
+                float dD= a*mean[c] - data[c];
+                dist2a += dD*dD;
+            }
+
+            if (dist2a < Tb*g.variance*a*a)
+                return true;
+        };
+
+        tWeight += g.weight;
+        if( tWeight > TB )
+            return false;
+    };
+    return false;
+}
+
+//update GMM - the base update function performed per pixel
+//
+//"Efficient Adaptive Density Estimapion per Image Pixel for the Task of Background Subtraction"
+//Z.Zivkovic, F. van der Heijden
+//Pattern Recognition Letters, vol. 27, no. 7, pages 773-780, 2006.
+//
+//The algorithm similar to the standard Stauffer&Grimson algorithm with
+//additional selection of the number of the Gaussian components based on:
+//
+//"Recursive unsupervised learning of finite mixture models "
+//Z.Zivkovic, F.van der Heijden
+//IEEE Trans. on Pattern Analysis and Machine Intelligence, vol.26, no.5, pages 651-656, 2004
+//http://www.zoranz.net/Publications/zivkovic2004PAMI.pdf
+
+class MOG2Invoker : public ParallelLoopBody
+{
+public:
+    MOG2Invoker(const Mat& _src, Mat& _dst,
+                GMM* _gmm, float* _mean,
+                uchar* _modesUsed,
+                int _nmixtures, float _alphaT,
+                float _Tb, float _TB, float _Tg,
+                float _varInit, float _varMin, float _varMax,
+                float _prune, float _tau, bool _detectShadows,
+                uchar _shadowVal, const Mat& _knownForegroundMask)
+            :   knownForegroundMask(_knownForegroundMask)
+    {
+        src = &_src;
+        dst = &_dst;
+        gmm0 = _gmm;
+        mean0 = _mean;
+        modesUsed0 = _modesUsed;
+        nmixtures = _nmixtures;
+        alphaT = _alphaT;
+        Tb = _Tb;
+        TB = _TB;
+        Tg = _Tg;
+        varInit = _varInit;
+        varMin = MIN(_varMin, _varMax);
+        varMax = MAX(_varMin, _varMax);
+        prune = _prune;
+        tau = _tau;
+        detectShadows = _detectShadows;
+        shadowVal = _shadowVal;
+    }
+
+    void operator()(const Range& range) const CV_OVERRIDE
+    {
+        int y0 = range.start, y1 = range.end;
+        int ncols = src->cols, nchannels = src->channels();
+        AutoBuffer<float> buf(src->cols*nchannels);
+        float alpha1 = 1.f - alphaT;
+        float dData[CV_CN_MAX];
+
+        for( int y = y0; y < y1; y++ )
+        {
+            const float* data = buf.data();
+            if( src->depth() != CV_32F )
+                src->row(y).convertTo(Mat(1, ncols, CV_32FC(nchannels), (void*)data), CV_32F);
+            else
+                data = src->ptr<float>(y);
+
+            float* mean = mean0 + ncols*nmixtures*nchannels*y;
+            GMM* gmm = gmm0 + ncols*nmixtures*y;
+            uchar* modesUsed = modesUsed0 + ncols*y;
+            uchar* mask = dst->ptr(y);
+
+            for( int x = 0; x < ncols; x++, data += nchannels, gmm += nmixtures, mean += nmixtures*nchannels )
+            {
+
+                // Check that foreground mask exists
+                if (!knownForegroundMask.empty())
+                {
+                    // If input mask states pixel is foreground
+                    if (knownForegroundMask.at<uchar>(y, x) > 0)
+                    {
+                        mask[x] = 255; // ensure output mask marks this pixel as FG
+                        continue;
+                    }
+                }
+
+                //calculate distances to the modes (+ sort)
+                //here we need to go in descending order!!!
+                bool background = false;//return value -> true - the pixel classified as background
+
+                //internal:
+                bool fitsPDF = false;//if it remains zero a new GMM mode will be added
+                int nmodes = modesUsed[x];//current number of modes in GMM
+                float totalWeight = 0.f;
+
+                float* mean_m = mean;
+
+                //////
+                //go through all modes
+                for( int mode = 0; mode < nmodes; mode++, mean_m += nchannels )
+                {
+                    float weight = alpha1*gmm[mode].weight + prune;//need only weight if fit is found
+                    int swap_count = 0;
+                    ////
+                    //fit not found yet
+                    if( !fitsPDF )
+                    {
+                        //check if it belongs to some of the remaining modes
+                        float var = gmm[mode].variance;
+
+                        //calculate difference and distance
+                        float dist2;
+
+                        if( nchannels == 3 )
+                        {
+                            dData[0] = mean_m[0] - data[0];
+                            dData[1] = mean_m[1] - data[1];
+                            dData[2] = mean_m[2] - data[2];
+                            dist2 = dData[0]*dData[0] + dData[1]*dData[1] + dData[2]*dData[2];
+                        }
+                        else
+                        {
+                            dist2 = 0.f;
+                            for( int c = 0; c < nchannels; c++ )
+                            {
+                                dData[c] = mean_m[c] - data[c];
+                                dist2 += dData[c]*dData[c];
+                            }
+                        }
+
+                        //background? - Tb - usually larger than Tg
+                        if( totalWeight < TB && dist2 < Tb*var )
+                            background = true;
+
+                        //check fit
+                        if( dist2 < Tg*var )
+                        {
+                            /////
+                            //belongs to the mode
+                            fitsPDF = true;
+
+                            //update distribution
+
+                            //update weight
+                            weight += alphaT;
+                            float k = alphaT/weight;
+
+                            //update mean
+                            for( int c = 0; c < nchannels; c++ )
+                                mean_m[c] -= k*dData[c];
+
+                            //update variance
+                            float varnew = var + k*(dist2-var);
+                            //limit the variance
+                            varnew = MAX(varnew, varMin);
+                            varnew = MIN(varnew, varMax);
+                            gmm[mode].variance = varnew;
+
+                            //sort
+                            //all other weights are at the same place and
+                            //only the matched (iModes) is higher -> just find the new place for it
+                            for( int i = mode; i > 0; i-- )
+                            {
+                                //check one up
+                                if( weight < gmm[i-1].weight )
+                                    break;
+
+                                swap_count++;
+                                //swap one up
+                                std::swap(gmm[i], gmm[i-1]);
+                                for( int c = 0; c < nchannels; c++ )
+                                    std::swap(mean[i*nchannels + c], mean[(i-1)*nchannels + c]);
+                            }
+                            //belongs to the mode - bFitsPDF becomes 1
+                            /////
+                        }
+                    }//!bFitsPDF)
+
+                    //check prune
+                    if( weight < -prune )
+                    {
+                        weight = 0.0;
+                        nmodes--;
+                    }
+
+                    gmm[mode-swap_count].weight = weight;//update weight by the calculated value
+                    totalWeight += weight;
+                }
+                //go through all modes
+                //////
+
+                // Renormalize weights. In the special case that the pixel does
+                // not agree with any modes, set weights to zero (a new mode will be added below).
+                float invWeight = 0.f;
+                if (std::abs(totalWeight) > FLT_EPSILON) {
+                    invWeight = 1.f/totalWeight;
+                }
+
+                for( int mode = 0; mode < nmodes; mode++ )
+                {
+                    gmm[mode].weight *= invWeight;
+                }
+
+                //make new mode if needed and exit
+                if( !fitsPDF && alphaT > 0.f )
+                {
+                    // replace the weakest or add a new one
+                    int mode = nmodes == nmixtures ? nmixtures-1 : nmodes++;
+
+                    if (nmodes==1)
+                        gmm[mode].weight = 1.f;
+                    else
+                    {
+                        gmm[mode].weight = alphaT;
+
+                        // renormalize all other weights
+                        for( int i = 0; i < nmodes-1; i++ )
+                            gmm[i].weight *= alpha1;
+                    }
+
+                    // init
+                    for( int c = 0; c < nchannels; c++ )
+                        mean[mode*nchannels + c] = data[c];
+
+                    gmm[mode].variance = varInit;
+
+                    //sort
+                    //find the new place for it
+                    for( int i = nmodes - 1; i > 0; i-- )
+                    {
+                        // check one up
+                        if( alphaT < gmm[i-1].weight )
+                            break;
+
+                        // swap one up
+                        std::swap(gmm[i], gmm[i-1]);
+                        for( int c = 0; c < nchannels; c++ )
+                            std::swap(mean[i*nchannels + c], mean[(i-1)*nchannels + c]);
+                    }
+                }
+
+                //set the number of modes
+                modesUsed[x] = uchar(nmodes);
+                mask[x] = background ? 0 :
+                    detectShadows && detectShadowGMM(data, nchannels, nmodes, gmm, mean, Tb, TB, tau) ?
+                    shadowVal : 255;
+            }
+        }
+    }
+
+    const Mat* src;
+    Mat* dst;
+    GMM* gmm0;
+    float* mean0;
+    uchar* modesUsed0;
+
+    int nmixtures;
+    float alphaT, Tb, TB, Tg;
+    float varInit, varMin, varMax, prune, tau;
+
+    bool detectShadows;
+    uchar shadowVal;
+    const Mat& knownForegroundMask;
+};
+
+#ifdef HAVE_OPENCL
+
+bool BackgroundSubtractorMOG2Impl::ocl_apply(InputArray _image, OutputArray _fgmask, double learningRate)
+{
+    bool needToInitialize = nframes == 0 || learningRate >= 1 || _image.size() != frameSize || _image.type() != frameType;
+
+    if( needToInitialize )
+        initialize(_image.size(), _image.type());
+
+    ++nframes;
+    learningRate = learningRate >= 0 && nframes > 1 ? learningRate : 1./std::min( 2*nframes, history );
+    CV_Assert(learningRate >= 0);
+
+    _fgmask.create(_image.size(), CV_8U);
+    UMat fgmask = _fgmask.getUMat();
+
+    const double alpha1 = 1.0f - learningRate;
+
+    UMat frame = _image.getUMat();
+
+    float varMax = MAX(fVarMin, fVarMax);
+    float varMin = MIN(fVarMin, fVarMax);
+
+    int idxArg = 0;
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::ReadOnly(frame));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_bgmodelUsedModes));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_weight));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_mean));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::PtrReadWrite(u_variance));
+    idxArg = kernel_apply.set(idxArg, ocl::KernelArg::WriteOnlyNoSize(fgmask));
+
+    idxArg = kernel_apply.set(idxArg, (float)learningRate);        //alphaT
+    idxArg = kernel_apply.set(idxArg, (float)alpha1);
+    idxArg = kernel_apply.set(idxArg, (float)(-learningRate*fCT));   //prune
+
+    idxArg = kernel_apply.set(idxArg, (float)varThreshold); //c_Tb
+    idxArg = kernel_apply.set(idxArg, backgroundRatio);     //c_TB
+    idxArg = kernel_apply.set(idxArg, varThresholdGen);     //c_Tg
+    idxArg = kernel_apply.set(idxArg, varMin);
+    idxArg = kernel_apply.set(idxArg, varMax);
+    idxArg = kernel_apply.set(idxArg, fVarInit);
+    idxArg = kernel_apply.set(idxArg, fTau);
+    if (bShadowDetection)
+        kernel_apply.set(idxArg, nShadowDetection);
+
+    size_t globalsize[] = {(size_t)frame.cols, (size_t)frame.rows, 1};
+    return kernel_apply.run(2, globalsize, NULL, true);
+}
+
+bool BackgroundSubtractorMOG2Impl::ocl_getBackgroundImage(OutputArray _backgroundImage) const
+{
+    _backgroundImage.create(frameSize, frameType);
+    UMat dst = _backgroundImage.getUMat();
+
+    int idxArg = 0;
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::PtrReadOnly(u_bgmodelUsedModes));
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::PtrReadOnly(u_weight));
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::PtrReadOnly(u_mean));
+    idxArg = kernel_getBg.set(idxArg, ocl::KernelArg::WriteOnly(dst));
+    kernel_getBg.set(idxArg, backgroundRatio);
+
+    size_t globalsize[2] = {(size_t)u_bgmodelUsedModes.cols, (size_t)u_bgmodelUsedModes.rows};
+
+    return kernel_getBg.run(2, globalsize, NULL, false);
+}
+
+void BackgroundSubtractorMOG2Impl::create_ocl_apply_kernel()
+{
+    int nchannels = CV_MAT_CN(frameType);
+    bool isFloat = CV_MAKETYPE(CV_32F,nchannels) == frameType;
+    String opts = format("-D CN=%d -D FL=%d -D NMIXTURES=%d%s", nchannels, isFloat, nmixtures, bShadowDetection ? " -D SHADOW_DETECT" : "");
+    kernel_apply.create("mog2_kernel", ocl::video::bgfg_mog2_oclsrc, opts);
+}
+
+#endif
+
+// Base 3 version class
+void BackgroundSubtractorMOG2Impl::apply(InputArray _image, OutputArray _fgmask, double learningRate) {
+    apply(_image,  noArray(), _fgmask, learningRate);
+}
+
+void BackgroundSubtractorMOG2Impl::apply(InputArray _image, InputArray _knownForegroundMask, OutputArray _fgmask, double learningRate)
+{
+    CV_INSTRUMENT_REGION();
+
+#ifdef HAVE_OPENCL
+    if (opencl_ON)
+    {
+        CV_OCL_RUN(_fgmask.isUMat(), ocl_apply(_image, _fgmask, learningRate))
+
+        opencl_ON = false;
+        nframes = 0;
+    }
+#endif
+
+    bool needToInitialize = nframes == 0 || learningRate >= 1 || _image.size() != frameSize || _image.type() != frameType;
+
+    if( needToInitialize )
+        initialize(_image.size(), _image.type());
+
+    Mat image = _image.getMat();
+    _fgmask.create( image.size(), CV_8U );
+    Mat fgmask = _fgmask.getMat();
+
+    Mat knownForegroundMask = _knownForegroundMask.getMat();
+
+    if(!knownForegroundMask.empty())
+    {
+    CV_Assert(knownForegroundMask.type() == CV_8UC1);
+    CV_Assert(knownForegroundMask.size() == image.size());
+    }
+
+    ++nframes;
+    learningRate = learningRate >= 0 && nframes > 1 ? learningRate : 1./std::min( 2*nframes, history );
+    CV_Assert(learningRate >= 0);
+
+    parallel_for_(Range(0, image.rows),
+                  MOG2Invoker(image, fgmask,
+                              bgmodel.ptr<GMM>(),
+                              (float*)(bgmodel.ptr() + sizeof(GMM)*nmixtures*image.rows*image.cols),
+                              bgmodelUsedModes.ptr(), nmixtures, (float)learningRate,
+                              (float)varThreshold,
+                              backgroundRatio, varThresholdGen,
+                              fVarInit, fVarMin, fVarMax, float(-learningRate*fCT), fTau,
+                              bShadowDetection, nShadowDetection, knownForegroundMask),
+                              image.total()/(double)(1 << 16));
+}
+
+template <typename T, int CN>
+void BackgroundSubtractorMOG2Impl::getBackgroundImage_intern(OutputArray backgroundImage) const
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat meanBackground(frameSize, frameType, Scalar::all(0));
+    int firstGaussianIdx = 0;
+    const GMM* gmm = bgmodel.ptr<GMM>();
+    const float* mean = reinterpret_cast<const float*>(gmm + frameSize.width*frameSize.height*nmixtures);
+    Vec<float,CN> meanVal(0.f);
+    for(int row=0; row<meanBackground.rows; row++)
+    {
+        for(int col=0; col<meanBackground.cols; col++)
+        {
+            int nmodes = bgmodelUsedModes.at<uchar>(row, col);
+            float totalWeight = 0.f;
+            for(int gaussianIdx = firstGaussianIdx; gaussianIdx < firstGaussianIdx + nmodes; gaussianIdx++)
+            {
+                GMM gaussian = gmm[gaussianIdx];
+                size_t meanPosition = gaussianIdx*CN;
+                for(int chn = 0; chn < CN; chn++)
+                {
+                    meanVal(chn) += gaussian.weight * mean[meanPosition + chn];
+                }
+                totalWeight += gaussian.weight;
+
+                if(totalWeight > backgroundRatio)
+                    break;
+            }
+            float invWeight = 0.f;
+            if (std::abs(totalWeight) > FLT_EPSILON) {
+                invWeight = 1.f/totalWeight;
+            }
+
+            meanBackground.at<Vec<T,CN> >(row, col) = Vec<T,CN>(meanVal * invWeight);
+            meanVal = 0.f;
+
+            firstGaussianIdx += nmixtures;
+        }
+    }
+    meanBackground.copyTo(backgroundImage);
+}
+
+void BackgroundSubtractorMOG2Impl::getBackgroundImage(OutputArray backgroundImage) const
+{
+    CV_Assert(frameType == CV_8UC1 || frameType == CV_8UC3 || frameType == CV_32FC1 || frameType == CV_32FC3);
+
+#ifdef HAVE_OPENCL
+    if (opencl_ON)
+    {
+        CV_OCL_RUN(opencl_ON, ocl_getBackgroundImage(backgroundImage))
+
+        opencl_ON = false;
+    }
+#endif
+
+    switch(frameType)
+    {
+    case CV_8UC1:
+        getBackgroundImage_intern<uchar,1>(backgroundImage);
+        break;
+    case CV_8UC3:
+        getBackgroundImage_intern<uchar,3>(backgroundImage);
+        break;
+    case CV_32FC1:
+        getBackgroundImage_intern<float,1>(backgroundImage);
+        break;
+    case CV_32FC3:
+        getBackgroundImage_intern<float,3>(backgroundImage);
+        break;
+    }
+}
+
+Ptr<BackgroundSubtractorMOG2> createBackgroundSubtractorMOG2(int _history, double _varThreshold,
+                                                             bool _bShadowDetection)
+{
+    return makePtr<BackgroundSubtractorMOG2Impl>(_history, (float)_varThreshold, _bShadowDetection);
+}
+
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/video/src/camshift.cpp b/upstream/opencv/modules/video/src/camshift.cpp
new file mode 100644
index 0000000..dc40462
--- /dev/null
+++ b/upstream/opencv/modules/video/src/camshift.cpp
@@ -0,0 +1,220 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+
+int cv::meanShift( InputArray _probImage, Rect& window, TermCriteria criteria )
+{
+    CV_INSTRUMENT_REGION();
+
+    Size size;
+    int cn;
+    Mat mat;
+    UMat umat;
+    bool isUMat = _probImage.isUMat();
+
+    if (isUMat)
+        umat = _probImage.getUMat(), cn = umat.channels(), size = umat.size();
+    else
+        mat = _probImage.getMat(), cn = mat.channels(), size = mat.size();
+
+    Rect cur_rect = window;
+
+    CV_Assert( cn == 1 );
+
+    if( window.height <= 0 || window.width <= 0 )
+        CV_Error( Error::StsBadArg, "Input window has non-positive sizes" );
+
+    window = window & Rect(0, 0, size.width, size.height);
+
+    double eps = (criteria.type & TermCriteria::EPS) ? std::max(criteria.epsilon, 0.) : 1.;
+    eps = cvRound(eps*eps);
+    int i, niters = (criteria.type & TermCriteria::MAX_ITER) ? std::max(criteria.maxCount, 1) : 100;
+
+    for( i = 0; i < niters; i++ )
+    {
+        cur_rect = cur_rect & Rect(0, 0, size.width, size.height);
+        if( cur_rect == Rect() )
+        {
+            cur_rect.x = size.width/2;
+            cur_rect.y = size.height/2;
+        }
+        cur_rect.width = std::max(cur_rect.width, 1);
+        cur_rect.height = std::max(cur_rect.height, 1);
+
+        Moments m = isUMat ? moments(umat(cur_rect)) : moments(mat(cur_rect));
+
+        // Calculating center of mass
+        if( fabs(m.m00) < DBL_EPSILON )
+            break;
+
+        int dx = cvRound( m.m10/m.m00 - window.width*0.5 );
+        int dy = cvRound( m.m01/m.m00 - window.height*0.5 );
+
+        int nx = std::min(std::max(cur_rect.x + dx, 0), size.width - cur_rect.width);
+        int ny = std::min(std::max(cur_rect.y + dy, 0), size.height - cur_rect.height);
+
+        dx = nx - cur_rect.x;
+        dy = ny - cur_rect.y;
+        cur_rect.x = nx;
+        cur_rect.y = ny;
+
+        // Check for coverage centers mass & window
+        if( dx*dx + dy*dy < eps )
+            break;
+    }
+
+    window = cur_rect;
+    return i;
+}
+
+
+cv::RotatedRect cv::CamShift( InputArray _probImage, Rect& window,
+                              TermCriteria criteria )
+{
+    CV_INSTRUMENT_REGION();
+
+    const int TOLERANCE = 10;
+    Size size;
+    Mat mat;
+    UMat umat;
+    bool isUMat = _probImage.isUMat();
+
+    if (isUMat)
+        umat = _probImage.getUMat(), size = umat.size();
+    else
+        mat = _probImage.getMat(), size = mat.size();
+
+    meanShift( _probImage, window, criteria );
+
+    window.x -= TOLERANCE;
+    if( window.x < 0 )
+        window.x = 0;
+
+    window.y -= TOLERANCE;
+    if( window.y < 0 )
+        window.y = 0;
+
+    window.width += 2 * TOLERANCE;
+    if( window.x + window.width > size.width )
+        window.width = size.width - window.x;
+
+    window.height += 2 * TOLERANCE;
+    if( window.y + window.height > size.height )
+        window.height = size.height - window.y;
+
+    // Calculating moments in new center mass
+    Moments m = isUMat ? moments(umat(window)) : moments(mat(window));
+
+    double m00 = m.m00, m10 = m.m10, m01 = m.m01;
+    double mu11 = m.mu11, mu20 = m.mu20, mu02 = m.mu02;
+
+    if( fabs(m00) < DBL_EPSILON )
+        return RotatedRect();
+
+    double inv_m00 = 1. / m00;
+    int xc = cvRound( m10 * inv_m00 + window.x );
+    int yc = cvRound( m01 * inv_m00 + window.y );
+    double a = mu20 * inv_m00, b = mu11 * inv_m00, c = mu02 * inv_m00;
+
+    // Calculating width & height
+    double square = std::sqrt( 4 * b * b + (a - c) * (a - c) );
+
+    // Calculating orientation
+    double theta = atan2( 2 * b, a - c + square );
+
+    // Calculating width & length of figure
+    double cs = cos( theta );
+    double sn = sin( theta );
+
+    double rotate_a = cs * cs * mu20 + 2 * cs * sn * mu11 + sn * sn * mu02;
+    double rotate_c = sn * sn * mu20 - 2 * cs * sn * mu11 + cs * cs * mu02;
+    rotate_a = std::max(0.0, rotate_a);  // avoid negative result due calculation numeric errors
+    rotate_c = std::max(0.0, rotate_c);  // avoid negative result due calculation numeric errors
+    double length = std::sqrt( rotate_a * inv_m00 ) * 4;
+    double width = std::sqrt( rotate_c * inv_m00 ) * 4;
+
+    // In case, when tetta is 0 or 1.57... the Length & Width may be exchanged
+    if( length < width )
+    {
+        std::swap( length, width );
+        std::swap( cs, sn );
+        theta = CV_PI*0.5 - theta;
+    }
+
+    // Saving results
+    int _xc = cvRound( xc );
+    int _yc = cvRound( yc );
+
+    int t0 = cvRound( fabs( length * cs ));
+    int t1 = cvRound( fabs( width * sn ));
+
+    t0 = MAX( t0, t1 ) + 2;
+    window.width = MIN( t0, (size.width - _xc) * 2 );
+
+    t0 = cvRound( fabs( length * sn ));
+    t1 = cvRound( fabs( width * cs ));
+
+    t0 = MAX( t0, t1 ) + 2;
+    window.height = MIN( t0, (size.height - _yc) * 2 );
+
+    window.x = MAX( 0, _xc - window.width / 2 );
+    window.y = MAX( 0, _yc - window.height / 2 );
+
+    window.width = MIN( size.width - window.x, window.width );
+    window.height = MIN( size.height - window.y, window.height );
+
+    RotatedRect box;
+    box.size.height = (float)length;
+    box.size.width = (float)width;
+    box.angle = (float)((CV_PI*0.5+theta)*180./CV_PI);
+    while(box.angle < 0)
+        box.angle += 360;
+    while(box.angle >= 360)
+        box.angle -= 360;
+    if(box.angle >= 180)
+        box.angle -= 180;
+    box.center = Point2f( window.x + window.width*0.5f, window.y + window.height*0.5f);
+
+    return box;
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/video/src/dis_flow.cpp b/upstream/opencv/modules/video/src/dis_flow.cpp
new file mode 100644
index 0000000..c859555
--- /dev/null
+++ b/upstream/opencv/modules/video/src/dis_flow.cpp
@@ -0,0 +1,1604 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#include "opencl_kernels_video.hpp"
+
+using namespace std;
+#define EPS 0.001F
+#define INF 1E+10F
+
+namespace cv {
+
+class DISOpticalFlowImpl CV_FINAL : public DISOpticalFlow
+{
+  public:
+    DISOpticalFlowImpl();
+
+    void calc(InputArray I0, InputArray I1, InputOutputArray flow) CV_OVERRIDE;
+    void collectGarbage() CV_OVERRIDE;
+
+  protected: //!< algorithm parameters
+    int finest_scale, coarsest_scale;
+    int user_coarsest_scale;
+    int patch_size;
+    int patch_stride;
+    int grad_descent_iter;
+    int variational_refinement_iter;
+    float variational_refinement_alpha;
+    float variational_refinement_gamma;
+    float variational_refinement_delta;
+    float variational_refinement_epsilon;
+    bool use_mean_normalization;
+    bool use_spatial_propagation;
+
+  protected: //!< some auxiliary variables
+    int border_size;
+    int w, h;   //!< flow buffer width and height on the current scale
+    int ws, hs; //!< sparse flow buffer width and height on the current scale
+
+  public:
+    int getFinestScale() const CV_OVERRIDE { return finest_scale; }
+    void setFinestScale(int val) CV_OVERRIDE { finest_scale = val; }
+    int getCoarsestScale() const CV_OVERRIDE { return user_coarsest_scale; }
+    void setCoarsestScale(int val) CV_OVERRIDE { user_coarsest_scale = val; }
+    int getPatchSize() const CV_OVERRIDE { return patch_size; }
+    void setPatchSize(int val) CV_OVERRIDE { patch_size = val; }
+    int getPatchStride() const CV_OVERRIDE { return patch_stride; }
+    void setPatchStride(int val) CV_OVERRIDE { patch_stride = val; }
+    int getGradientDescentIterations() const CV_OVERRIDE { return grad_descent_iter; }
+    void setGradientDescentIterations(int val) CV_OVERRIDE { grad_descent_iter = val; }
+    int getVariationalRefinementIterations() const CV_OVERRIDE { return variational_refinement_iter; }
+    void setVariationalRefinementIterations(int val) CV_OVERRIDE { variational_refinement_iter = val; }
+    float getVariationalRefinementAlpha() const CV_OVERRIDE { return variational_refinement_alpha; }
+    void setVariationalRefinementAlpha(float val) CV_OVERRIDE { variational_refinement_alpha = val; }
+    float getVariationalRefinementDelta() const CV_OVERRIDE { return variational_refinement_delta; }
+    void setVariationalRefinementDelta(float val) CV_OVERRIDE { variational_refinement_delta = val; }
+    float getVariationalRefinementGamma() const CV_OVERRIDE { return variational_refinement_gamma; }
+    void setVariationalRefinementGamma(float val) CV_OVERRIDE { variational_refinement_gamma = val; }
+    float getVariationalRefinementEpsilon() const CV_OVERRIDE { return variational_refinement_epsilon; }
+    void setVariationalRefinementEpsilon(float val) CV_OVERRIDE { variational_refinement_epsilon = val; }
+
+    bool getUseMeanNormalization() const CV_OVERRIDE { return use_mean_normalization; }
+    void setUseMeanNormalization(bool val) CV_OVERRIDE { use_mean_normalization = val; }
+    bool getUseSpatialPropagation() const CV_OVERRIDE { return use_spatial_propagation; }
+    void setUseSpatialPropagation(bool val) CV_OVERRIDE { use_spatial_propagation = val; }
+
+  protected:                      //!< internal buffers
+    vector<Mat_<uchar> > I0s;     //!< Gaussian pyramid for the current frame
+    vector<Mat_<uchar> > I1s;     //!< Gaussian pyramid for the next frame
+    vector<Mat_<uchar> > I1s_ext; //!< I1s with borders
+
+    vector<Mat_<short> > I0xs; //!< Gaussian pyramid for the x gradient of the current frame
+    vector<Mat_<short> > I0ys; //!< Gaussian pyramid for the y gradient of the current frame
+
+    vector<Mat_<float> > Ux; //!< x component of the flow vectors
+    vector<Mat_<float> > Uy; //!< y component of the flow vectors
+
+    vector<Mat_<float> > initial_Ux; //!< x component of the initial flow field, if one was passed as an input
+    vector<Mat_<float> > initial_Uy; //!< y component of the initial flow field, if one was passed as an input
+
+    Mat_<Vec2f> U; //!< a buffer for the merged flow
+
+    Mat_<float> Sx; //!< intermediate sparse flow representation (x component)
+    Mat_<float> Sy; //!< intermediate sparse flow representation (y component)
+
+    /* Structure tensor components: */
+    Mat_<float> I0xx_buf; //!< sum of squares of x gradient values
+    Mat_<float> I0yy_buf; //!< sum of squares of y gradient values
+    Mat_<float> I0xy_buf; //!< sum of x and y gradient products
+
+    /* Extra buffers that are useful if patch mean-normalization is used: */
+    Mat_<float> I0x_buf; //!< sum of x gradient values
+    Mat_<float> I0y_buf; //!< sum of y gradient values
+
+    /* Auxiliary buffers used in structure tensor computation: */
+    Mat_<float> I0xx_buf_aux;
+    Mat_<float> I0yy_buf_aux;
+    Mat_<float> I0xy_buf_aux;
+    Mat_<float> I0x_buf_aux;
+    Mat_<float> I0y_buf_aux;
+
+    vector<Ptr<VariationalRefinement> > variational_refinement_processors;
+
+  private: //!< private methods and parallel sections
+    void prepareBuffers(Mat &I0, Mat &I1, Mat &flow, bool use_flow);
+    void precomputeStructureTensor(Mat &dst_I0xx, Mat &dst_I0yy, Mat &dst_I0xy, Mat &dst_I0x, Mat &dst_I0y, Mat &I0x,
+                                   Mat &I0y);
+    int autoSelectCoarsestScale(int img_width);
+    void autoSelectPatchSizeAndScales(int img_width);
+
+    struct PatchInverseSearch_ParBody : public ParallelLoopBody
+    {
+        DISOpticalFlowImpl *dis;
+        int nstripes, stripe_sz;
+        int hs;
+        Mat *Sx, *Sy, *Ux, *Uy, *I0, *I1, *I0x, *I0y;
+        int num_iter, pyr_level;
+
+        PatchInverseSearch_ParBody(DISOpticalFlowImpl &_dis, int _nstripes, int _hs, Mat &dst_Sx, Mat &dst_Sy,
+                                   Mat &src_Ux, Mat &src_Uy, Mat &_I0, Mat &_I1, Mat &_I0x, Mat &_I0y, int _num_iter,
+                                   int _pyr_level);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+
+    struct Densification_ParBody : public ParallelLoopBody
+    {
+        DISOpticalFlowImpl *dis;
+        int nstripes, stripe_sz;
+        int h;
+        Mat *Ux, *Uy, *Sx, *Sy, *I0, *I1;
+
+        Densification_ParBody(DISOpticalFlowImpl &_dis, int _nstripes, int _h, Mat &dst_Ux, Mat &dst_Uy, Mat &src_Sx,
+                              Mat &src_Sy, Mat &_I0, Mat &_I1);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+
+#ifdef HAVE_OPENCL
+    vector<UMat> u_I0s;     //!< Gaussian pyramid for the current frame
+    vector<UMat> u_I1s;     //!< Gaussian pyramid for the next frame
+    vector<UMat> u_I1s_ext; //!< I1s with borders
+
+    vector<UMat> u_I0xs; //!< Gaussian pyramid for the x gradient of the current frame
+    vector<UMat> u_I0ys; //!< Gaussian pyramid for the y gradient of the current frame
+
+    vector<UMat> u_U; //!< (x,y) component of the flow vectors (CV_32FC2)
+    vector<UMat> u_initial_U; //!< (x, y) components of the initial flow field, if one was passed as an input (CV_32FC2)
+
+    UMat u_S; //!< intermediate sparse flow representation (x,y components - CV_32FC2)
+
+    /* Structure tensor components: */
+    UMat u_I0xx_buf; //!< sum of squares of x gradient values
+    UMat u_I0yy_buf; //!< sum of squares of y gradient values
+    UMat u_I0xy_buf; //!< sum of x and y gradient products
+
+    /* Extra buffers that are useful if patch mean-normalization is used: */
+    UMat u_I0x_buf; //!< sum of x gradient values
+    UMat u_I0y_buf; //!< sum of y gradient values
+
+    /* Auxiliary buffers used in structure tensor computation: */
+    UMat u_I0xx_buf_aux;
+    UMat u_I0yy_buf_aux;
+    UMat u_I0xy_buf_aux;
+    UMat u_I0x_buf_aux;
+    UMat u_I0y_buf_aux;
+
+    bool ocl_precomputeStructureTensor(UMat &dst_I0xx, UMat &dst_I0yy, UMat &dst_I0xy,
+                                       UMat &dst_I0x, UMat &dst_I0y, UMat &I0x, UMat &I0y);
+    void ocl_prepareBuffers(UMat &I0, UMat &I1, InputArray flow, bool use_flow);
+    bool ocl_calc(InputArray I0, InputArray I1, InputOutputArray flow);
+    bool ocl_Densification(UMat &dst_U, UMat &src_S, UMat &_I0, UMat &_I1);
+    bool ocl_PatchInverseSearch(UMat &src_U,
+                                UMat &I0, UMat &I1, UMat &I0x, UMat &I0y, int num_iter, int pyr_level);
+#endif
+};
+
+DISOpticalFlowImpl::DISOpticalFlowImpl()
+{
+    CV_INSTRUMENT_REGION();
+
+    finest_scale = 2;
+    patch_size = 8;
+    patch_stride = 4;
+    grad_descent_iter = 16;
+    variational_refinement_iter = 5;
+    variational_refinement_alpha = 20.f;
+    variational_refinement_gamma = 10.f;
+    variational_refinement_delta = 5.f;
+    variational_refinement_epsilon = 0.01f;
+
+    border_size = 16;
+    use_mean_normalization = true;
+    use_spatial_propagation = true;
+    coarsest_scale = 10;
+    user_coarsest_scale = -1;
+
+    /* Use separate variational refinement instances for different scales to avoid repeated memory allocation: */
+    int max_possible_scales = 10;
+    ws = hs = w = h = 0;
+    for (int i = 0; i < max_possible_scales; i++)
+        variational_refinement_processors.push_back(VariationalRefinement::create());
+}
+
+void DISOpticalFlowImpl::prepareBuffers(Mat &I0, Mat &I1, Mat &flow, bool use_flow)
+{
+    CV_INSTRUMENT_REGION();
+
+    I0s.resize(coarsest_scale + 1);
+    I1s.resize(coarsest_scale + 1);
+    I1s_ext.resize(coarsest_scale + 1);
+    I0xs.resize(coarsest_scale + 1);
+    I0ys.resize(coarsest_scale + 1);
+    Ux.resize(coarsest_scale + 1);
+    Uy.resize(coarsest_scale + 1);
+
+    Mat flow_uv[2];
+    if (use_flow)
+    {
+        split(flow, flow_uv);
+        initial_Ux.resize(coarsest_scale + 1);
+        initial_Uy.resize(coarsest_scale + 1);
+    }
+
+    int fraction = 1;
+    int cur_rows = 0, cur_cols = 0;
+
+    for (int i = 0; i <= coarsest_scale; i++)
+    {
+        /* Avoid initializing the pyramid levels above the finest scale, as they won't be used anyway */
+        if (i == finest_scale)
+        {
+            cur_rows = I0.rows / fraction;
+            cur_cols = I0.cols / fraction;
+            I0s[i].create(cur_rows, cur_cols);
+            resize(I0, I0s[i], I0s[i].size(), 0.0, 0.0, INTER_AREA);
+            I1s[i].create(cur_rows, cur_cols);
+            resize(I1, I1s[i], I1s[i].size(), 0.0, 0.0, INTER_AREA);
+
+            /* These buffers are reused in each scale so we initialize them once on the finest scale: */
+            Sx.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            Sy.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            I0xx_buf.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            I0yy_buf.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            I0xy_buf.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            I0x_buf.create(cur_rows / patch_stride, cur_cols / patch_stride);
+            I0y_buf.create(cur_rows / patch_stride, cur_cols / patch_stride);
+
+            I0xx_buf_aux.create(cur_rows, cur_cols / patch_stride);
+            I0yy_buf_aux.create(cur_rows, cur_cols / patch_stride);
+            I0xy_buf_aux.create(cur_rows, cur_cols / patch_stride);
+            I0x_buf_aux.create(cur_rows, cur_cols / patch_stride);
+            I0y_buf_aux.create(cur_rows, cur_cols / patch_stride);
+
+            U.create(cur_rows, cur_cols);
+        }
+        else if (i > finest_scale)
+        {
+            cur_rows = I0s[i - 1].rows / 2;
+            cur_cols = I0s[i - 1].cols / 2;
+            I0s[i].create(cur_rows, cur_cols);
+            resize(I0s[i - 1], I0s[i], I0s[i].size(), 0.0, 0.0, INTER_AREA);
+            I1s[i].create(cur_rows, cur_cols);
+            resize(I1s[i - 1], I1s[i], I1s[i].size(), 0.0, 0.0, INTER_AREA);
+        }
+
+        if (i >= finest_scale)
+        {
+            I1s_ext[i].create(cur_rows + 2 * border_size, cur_cols + 2 * border_size);
+            copyMakeBorder(I1s[i], I1s_ext[i], border_size, border_size, border_size, border_size, BORDER_REPLICATE);
+            I0xs[i].create(cur_rows, cur_cols);
+            I0ys[i].create(cur_rows, cur_cols);
+            spatialGradient(I0s[i], I0xs[i], I0ys[i]);
+            Ux[i].create(cur_rows, cur_cols);
+            Uy[i].create(cur_rows, cur_cols);
+            variational_refinement_processors[i]->setAlpha(variational_refinement_alpha);
+            variational_refinement_processors[i]->setDelta(variational_refinement_delta);
+            variational_refinement_processors[i]->setGamma(variational_refinement_gamma);
+            variational_refinement_processors[i]->setEpsilon(variational_refinement_epsilon);
+            variational_refinement_processors[i]->setSorIterations(5);
+            variational_refinement_processors[i]->setFixedPointIterations(variational_refinement_iter);
+
+            if (use_flow)
+            {
+                resize(flow_uv[0], initial_Ux[i], Size(cur_cols, cur_rows));
+                initial_Ux[i] /= fraction;
+                resize(flow_uv[1], initial_Uy[i], Size(cur_cols, cur_rows));
+                initial_Uy[i] /= fraction;
+            }
+        }
+
+        fraction *= 2;
+    }
+}
+
+/* This function computes the structure tensor elements (local sums of I0x^2, I0x*I0y and I0y^2).
+ * A simple box filter is not used instead because we need to compute these sums on a sparse grid
+ * and store them densely in the output buffers.
+ */
+void DISOpticalFlowImpl::precomputeStructureTensor(Mat &dst_I0xx, Mat &dst_I0yy, Mat &dst_I0xy, Mat &dst_I0x,
+                                                   Mat &dst_I0y, Mat &I0x, Mat &I0y)
+{
+    CV_INSTRUMENT_REGION();
+
+    float *I0xx_ptr = dst_I0xx.ptr<float>();
+    float *I0yy_ptr = dst_I0yy.ptr<float>();
+    float *I0xy_ptr = dst_I0xy.ptr<float>();
+    float *I0x_ptr = dst_I0x.ptr<float>();
+    float *I0y_ptr = dst_I0y.ptr<float>();
+
+    float *I0xx_aux_ptr = I0xx_buf_aux.ptr<float>();
+    float *I0yy_aux_ptr = I0yy_buf_aux.ptr<float>();
+    float *I0xy_aux_ptr = I0xy_buf_aux.ptr<float>();
+    float *I0x_aux_ptr = I0x_buf_aux.ptr<float>();
+    float *I0y_aux_ptr = I0y_buf_aux.ptr<float>();
+
+    /* Separable box filter: horizontal pass */
+    for (int i = 0; i < h; i++)
+    {
+        float sum_xx = 0.0f, sum_yy = 0.0f, sum_xy = 0.0f, sum_x = 0.0f, sum_y = 0.0f;
+        short *x_row = I0x.ptr<short>(i);
+        short *y_row = I0y.ptr<short>(i);
+        for (int j = 0; j < patch_size; j++)
+        {
+            sum_xx += x_row[j] * x_row[j];
+            sum_yy += y_row[j] * y_row[j];
+            sum_xy += x_row[j] * y_row[j];
+            sum_x += x_row[j];
+            sum_y += y_row[j];
+        }
+        I0xx_aux_ptr[i * ws] = sum_xx;
+        I0yy_aux_ptr[i * ws] = sum_yy;
+        I0xy_aux_ptr[i * ws] = sum_xy;
+        I0x_aux_ptr[i * ws] = sum_x;
+        I0y_aux_ptr[i * ws] = sum_y;
+        int js = 1;
+        for (int j = patch_size; j < w; j++)
+        {
+            sum_xx += (x_row[j] * x_row[j] - x_row[j - patch_size] * x_row[j - patch_size]);
+            sum_yy += (y_row[j] * y_row[j] - y_row[j - patch_size] * y_row[j - patch_size]);
+            sum_xy += (x_row[j] * y_row[j] - x_row[j - patch_size] * y_row[j - patch_size]);
+            sum_x += (x_row[j] - x_row[j - patch_size]);
+            sum_y += (y_row[j] - y_row[j - patch_size]);
+            if ((j - patch_size + 1) % patch_stride == 0)
+            {
+                I0xx_aux_ptr[i * ws + js] = sum_xx;
+                I0yy_aux_ptr[i * ws + js] = sum_yy;
+                I0xy_aux_ptr[i * ws + js] = sum_xy;
+                I0x_aux_ptr[i * ws + js] = sum_x;
+                I0y_aux_ptr[i * ws + js] = sum_y;
+                js++;
+            }
+        }
+    }
+
+    AutoBuffer<float> sum_xx(ws), sum_yy(ws), sum_xy(ws), sum_x(ws), sum_y(ws);
+    for (int j = 0; j < ws; j++)
+    {
+        sum_xx[j] = 0.0f;
+        sum_yy[j] = 0.0f;
+        sum_xy[j] = 0.0f;
+        sum_x[j] = 0.0f;
+        sum_y[j] = 0.0f;
+    }
+
+    /* Separable box filter: vertical pass */
+    for (int i = 0; i < patch_size; i++)
+        for (int j = 0; j < ws; j++)
+        {
+            sum_xx[j] += I0xx_aux_ptr[i * ws + j];
+            sum_yy[j] += I0yy_aux_ptr[i * ws + j];
+            sum_xy[j] += I0xy_aux_ptr[i * ws + j];
+            sum_x[j] += I0x_aux_ptr[i * ws + j];
+            sum_y[j] += I0y_aux_ptr[i * ws + j];
+        }
+    for (int j = 0; j < ws; j++)
+    {
+        I0xx_ptr[j] = sum_xx[j];
+        I0yy_ptr[j] = sum_yy[j];
+        I0xy_ptr[j] = sum_xy[j];
+        I0x_ptr[j] = sum_x[j];
+        I0y_ptr[j] = sum_y[j];
+    }
+    int is = 1;
+    for (int i = patch_size; i < h; i++)
+    {
+        for (int j = 0; j < ws; j++)
+        {
+            sum_xx[j] += (I0xx_aux_ptr[i * ws + j] - I0xx_aux_ptr[(i - patch_size) * ws + j]);
+            sum_yy[j] += (I0yy_aux_ptr[i * ws + j] - I0yy_aux_ptr[(i - patch_size) * ws + j]);
+            sum_xy[j] += (I0xy_aux_ptr[i * ws + j] - I0xy_aux_ptr[(i - patch_size) * ws + j]);
+            sum_x[j] += (I0x_aux_ptr[i * ws + j] - I0x_aux_ptr[(i - patch_size) * ws + j]);
+            sum_y[j] += (I0y_aux_ptr[i * ws + j] - I0y_aux_ptr[(i - patch_size) * ws + j]);
+        }
+        if ((i - patch_size + 1) % patch_stride == 0)
+        {
+            for (int j = 0; j < ws; j++)
+            {
+                I0xx_ptr[is * ws + j] = sum_xx[j];
+                I0yy_ptr[is * ws + j] = sum_yy[j];
+                I0xy_ptr[is * ws + j] = sum_xy[j];
+                I0x_ptr[is * ws + j] = sum_x[j];
+                I0y_ptr[is * ws + j] = sum_y[j];
+            }
+            is++;
+        }
+    }
+}
+
+int DISOpticalFlowImpl::autoSelectCoarsestScale(int img_width)
+{
+    const int fratio = 5;
+    return std::max(0, (int)std::floor(log2((2.0f*(float)img_width) / ((float)fratio * (float)patch_size))));
+}
+
+void DISOpticalFlowImpl::autoSelectPatchSizeAndScales(int img_width)
+{
+    switch (finest_scale)
+    {
+    case 1:
+        patch_size = 8;
+        coarsest_scale = autoSelectCoarsestScale(img_width);
+        finest_scale = std::max(coarsest_scale-2, 0);
+        break;
+
+    case 3:
+        patch_size = 12;
+        coarsest_scale = autoSelectCoarsestScale(img_width);
+        finest_scale = std::max(coarsest_scale-4, 0);
+        break;
+
+    case 4:
+        patch_size = 12;
+        coarsest_scale = autoSelectCoarsestScale(img_width);
+        finest_scale = std::max(coarsest_scale-5, 0);
+        break;
+
+    // default case, fall-through.
+    case 2:
+    default:
+        patch_size = 8;
+        coarsest_scale = autoSelectCoarsestScale(img_width);
+        finest_scale = std::max(coarsest_scale-2, 0);
+        break;
+    }
+}
+
+DISOpticalFlowImpl::PatchInverseSearch_ParBody::PatchInverseSearch_ParBody(DISOpticalFlowImpl &_dis, int _nstripes,
+                                                                           int _hs, Mat &dst_Sx, Mat &dst_Sy,
+                                                                           Mat &src_Ux, Mat &src_Uy, Mat &_I0, Mat &_I1,
+                                                                           Mat &_I0x, Mat &_I0y, int _num_iter,
+                                                                           int _pyr_level)
+    : dis(&_dis), nstripes(_nstripes), hs(_hs), Sx(&dst_Sx), Sy(&dst_Sy), Ux(&src_Ux), Uy(&src_Uy), I0(&_I0), I1(&_I1),
+      I0x(&_I0x), I0y(&_I0y), num_iter(_num_iter), pyr_level(_pyr_level)
+{
+    stripe_sz = (int)ceil(hs / (double)nstripes);
+}
+
+/////////////////////////////////////////////* Patch processing functions */////////////////////////////////////////////
+
+/* Some auxiliary macros */
+#define HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION                                                                         \
+    v_float32x4 w00v = v_setall_f32(w00);                                                                              \
+    v_float32x4 w01v = v_setall_f32(w01);                                                                              \
+    v_float32x4 w10v = v_setall_f32(w10);                                                                              \
+    v_float32x4 w11v = v_setall_f32(w11);                                                                              \
+                                                                                                                       \
+    v_uint16x8 I0_row_8, I1_row_8, I1_row_shifted_8, I1_row_next_8, I1_row_next_shifted_8, tmp;                        \
+    v_uint32x4 I0_row_4_left, I1_row_4_left, I1_row_shifted_4_left, I1_row_next_4_left, I1_row_next_shifted_4_left;    \
+    v_uint32x4 I0_row_4_right, I1_row_4_right, I1_row_shifted_4_right, I1_row_next_4_right,                            \
+      I1_row_next_shifted_4_right;                                                                                     \
+    v_float32x4 I_diff_left, I_diff_right;                                                                             \
+                                                                                                                       \
+    /* Preload and expand the first row of I1: */                                                                      \
+    I1_row_8 = v_load_expand(I1_ptr);                                                                                  \
+    I1_row_shifted_8 = v_load_expand(I1_ptr + 1);                                                                      \
+    v_expand(I1_row_8, I1_row_4_left, I1_row_4_right);                                                                 \
+    v_expand(I1_row_shifted_8, I1_row_shifted_4_left, I1_row_shifted_4_right);                                         \
+    I1_ptr += I1_stride;
+
+#define HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION                                                                      \
+    /* Load the next row of I1: */                                                                                     \
+    I1_row_next_8 = v_load_expand(I1_ptr);                                                                             \
+    I1_row_next_shifted_8 = v_load_expand(I1_ptr + 1);                                                                 \
+    /* Separate the left and right halves: */                                                                          \
+    v_expand(I1_row_next_8, I1_row_next_4_left, I1_row_next_4_right);                                                  \
+    v_expand(I1_row_next_shifted_8, I1_row_next_shifted_4_left, I1_row_next_shifted_4_right);                          \
+                                                                                                                       \
+    /* Load current row of I0: */                                                                                      \
+    I0_row_8 = v_load_expand(I0_ptr);                                                                                  \
+    v_expand(I0_row_8, I0_row_4_left, I0_row_4_right);                                                                 \
+                                                                                                                       \
+    /* Compute diffs between I0 and bilinearly interpolated I1: */                                                     \
+    I_diff_left = v_sub(v_add(v_mul(w00v, v_cvt_f32(v_reinterpret_as_s32(I1_row_4_left))),                             \
+                  v_mul(w01v, v_cvt_f32(v_reinterpret_as_s32(I1_row_shifted_4_left))),                                 \
+                  v_mul(w10v, v_cvt_f32(v_reinterpret_as_s32(I1_row_next_4_left))),                                    \
+                  v_mul(w11v, v_cvt_f32(v_reinterpret_as_s32(I1_row_next_shifted_4_left)))),                           \
+                  v_cvt_f32(v_reinterpret_as_s32(I0_row_4_left)));                                                     \
+    I_diff_right = v_sub(v_add(v_mul(w00v, v_cvt_f32(v_reinterpret_as_s32(I1_row_4_right))),                           \
+                   v_mul(w01v, v_cvt_f32(v_reinterpret_as_s32(I1_row_shifted_4_right))),                               \
+                   v_mul(w10v, v_cvt_f32(v_reinterpret_as_s32(I1_row_next_4_right))),                                  \
+                   v_mul(w11v, v_cvt_f32(v_reinterpret_as_s32(I1_row_next_shifted_4_right)))),                         \
+                   v_cvt_f32(v_reinterpret_as_s32(I0_row_4_right)));
+
+#define HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW                                                                     \
+    I0_ptr += I0_stride;                                                                                               \
+    I1_ptr += I1_stride;                                                                                               \
+                                                                                                                       \
+    I1_row_4_left = I1_row_next_4_left;                                                                                \
+    I1_row_4_right = I1_row_next_4_right;                                                                              \
+    I1_row_shifted_4_left = I1_row_next_shifted_4_left;                                                                \
+    I1_row_shifted_4_right = I1_row_next_shifted_4_right;
+
+/* This function essentially performs one iteration of gradient descent when finding the most similar patch in I1 for a
+ * given one in I0. It assumes that I0_ptr and I1_ptr already point to the corresponding patches and w00, w01, w10, w11
+ * are precomputed bilinear interpolation weights. It returns the SSD (sum of squared differences) between these patches
+ * and computes the values (dst_dUx, dst_dUy) that are used in the flow vector update. HAL acceleration is implemented
+ * only for the default patch size (8x8). Everything is processed in floats as using fixed-point approximations harms
+ * the quality significantly.
+ */
+inline float processPatch(float &dst_dUx, float &dst_dUy, uchar *I0_ptr, uchar *I1_ptr, short *I0x_ptr, short *I0y_ptr,
+                          int I0_stride, int I1_stride, float w00, float w01, float w10, float w11, int patch_sz)
+{
+    float SSD = 0.0f;
+#if CV_SIMD128
+    if (patch_sz == 8)
+    {
+        /* Variables to accumulate the sums */
+        v_float32x4 Ux_vec = v_setall_f32(0);
+        v_float32x4 Uy_vec = v_setall_f32(0);
+        v_float32x4 SSD_vec = v_setall_f32(0);
+
+        v_int16x8 I0x_row, I0y_row;
+        v_int32x4 I0x_row_4_left, I0x_row_4_right, I0y_row_4_left, I0y_row_4_right;
+
+        HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION;
+        for (int row = 0; row < 8; row++)
+        {
+            HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION;
+            I0x_row = v_load(I0x_ptr);
+            v_expand(I0x_row, I0x_row_4_left, I0x_row_4_right);
+            I0y_row = v_load(I0y_ptr);
+            v_expand(I0y_row, I0y_row_4_left, I0y_row_4_right);
+
+            /* Update the sums: */
+            Ux_vec = v_add(Ux_vec, v_add(v_mul(I_diff_left, v_cvt_f32(I0x_row_4_left)), v_mul(I_diff_right, v_cvt_f32(I0x_row_4_right))));
+            Uy_vec = v_add(Uy_vec, v_add(v_mul(I_diff_left, v_cvt_f32(I0y_row_4_left)), v_mul(I_diff_right, v_cvt_f32(I0y_row_4_right))));
+            SSD_vec = v_add(SSD_vec, v_add(v_mul(I_diff_left, I_diff_left), v_mul(I_diff_right, I_diff_right)));
+
+            I0x_ptr += I0_stride;
+            I0y_ptr += I0_stride;
+            HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW;
+        }
+
+        /* Final reduce operations: */
+        dst_dUx = v_reduce_sum(Ux_vec);
+        dst_dUy = v_reduce_sum(Uy_vec);
+        SSD = v_reduce_sum(SSD_vec);
+    }
+    else
+#endif
+    {
+        dst_dUx = 0.0f;
+        dst_dUy = 0.0f;
+        float diff;
+        for (int i = 0; i < patch_sz; i++)
+            for (int j = 0; j < patch_sz; j++)
+            {
+                diff = w00 * I1_ptr[i * I1_stride + j] + w01 * I1_ptr[i * I1_stride + j + 1] +
+                       w10 * I1_ptr[(i + 1) * I1_stride + j] + w11 * I1_ptr[(i + 1) * I1_stride + j + 1] -
+                       I0_ptr[i * I0_stride + j];
+
+                SSD += diff * diff;
+                dst_dUx += diff * I0x_ptr[i * I0_stride + j];
+                dst_dUy += diff * I0y_ptr[i * I0_stride + j];
+            }
+    }
+    return SSD;
+}
+
+/* Same as processPatch, but with patch mean normalization, which improves robustness under changing
+ * lighting conditions
+ */
+inline float processPatchMeanNorm(float &dst_dUx, float &dst_dUy, uchar *I0_ptr, uchar *I1_ptr, short *I0x_ptr,
+                                  short *I0y_ptr, int I0_stride, int I1_stride, float w00, float w01, float w10,
+                                  float w11, int patch_sz, float x_grad_sum, float y_grad_sum)
+{
+    float sum_diff = 0.0, sum_diff_sq = 0.0;
+    float sum_I0x_mul = 0.0, sum_I0y_mul = 0.0;
+    float n = (float)patch_sz * patch_sz;
+
+#if CV_SIMD128
+    if (patch_sz == 8)
+    {
+        /* Variables to accumulate the sums */
+        v_float32x4 sum_I0x_mul_vec = v_setall_f32(0);
+        v_float32x4 sum_I0y_mul_vec = v_setall_f32(0);
+        v_float32x4 sum_diff_vec = v_setall_f32(0);
+        v_float32x4 sum_diff_sq_vec = v_setall_f32(0);
+
+        v_int16x8 I0x_row, I0y_row;
+        v_int32x4 I0x_row_4_left, I0x_row_4_right, I0y_row_4_left, I0y_row_4_right;
+
+        HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION;
+        for (int row = 0; row < 8; row++)
+        {
+            HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION;
+            I0x_row = v_load(I0x_ptr);
+            v_expand(I0x_row, I0x_row_4_left, I0x_row_4_right);
+            I0y_row = v_load(I0y_ptr);
+            v_expand(I0y_row, I0y_row_4_left, I0y_row_4_right);
+
+            /* Update the sums: */
+            sum_I0x_mul_vec = v_add(sum_I0x_mul_vec, v_add(v_mul(I_diff_left, v_cvt_f32(I0x_row_4_left)), v_mul(I_diff_right, v_cvt_f32(I0x_row_4_right))));
+            sum_I0y_mul_vec = v_add(sum_I0y_mul_vec, v_add(v_mul(I_diff_left, v_cvt_f32(I0y_row_4_left)), v_mul(I_diff_right, v_cvt_f32(I0y_row_4_right))));
+            sum_diff_sq_vec = v_add(sum_diff_sq_vec, v_add(v_mul(I_diff_left, I_diff_left), v_mul(I_diff_right, I_diff_right)));
+            sum_diff_vec = v_add(sum_diff_vec, v_add(I_diff_left, I_diff_right));
+
+            I0x_ptr += I0_stride;
+            I0y_ptr += I0_stride;
+            HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW;
+        }
+
+        /* Final reduce operations: */
+        sum_I0x_mul = v_reduce_sum(sum_I0x_mul_vec);
+        sum_I0y_mul = v_reduce_sum(sum_I0y_mul_vec);
+        sum_diff = v_reduce_sum(sum_diff_vec);
+        sum_diff_sq = v_reduce_sum(sum_diff_sq_vec);
+    }
+    else
+#endif
+    {
+        float diff;
+        for (int i = 0; i < patch_sz; i++)
+            for (int j = 0; j < patch_sz; j++)
+            {
+                diff = w00 * I1_ptr[i * I1_stride + j] + w01 * I1_ptr[i * I1_stride + j + 1] +
+                       w10 * I1_ptr[(i + 1) * I1_stride + j] + w11 * I1_ptr[(i + 1) * I1_stride + j + 1] -
+                       I0_ptr[i * I0_stride + j];
+
+                sum_diff += diff;
+                sum_diff_sq += diff * diff;
+
+                sum_I0x_mul += diff * I0x_ptr[i * I0_stride + j];
+                sum_I0y_mul += diff * I0y_ptr[i * I0_stride + j];
+            }
+    }
+    dst_dUx = sum_I0x_mul - sum_diff * x_grad_sum / n;
+    dst_dUy = sum_I0y_mul - sum_diff * y_grad_sum / n;
+    return sum_diff_sq - sum_diff * sum_diff / n;
+}
+
+/* Similar to processPatch, but compute only the sum of squared differences (SSD) between the patches */
+inline float computeSSD(uchar *I0_ptr, uchar *I1_ptr, int I0_stride, int I1_stride, float w00, float w01, float w10,
+                        float w11, int patch_sz)
+{
+    float SSD = 0.0f;
+#if CV_SIMD128
+    if (patch_sz == 8)
+    {
+        v_float32x4 SSD_vec = v_setall_f32(0);
+        HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION;
+        for (int row = 0; row < 8; row++)
+        {
+            HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION;
+            SSD_vec = v_add(SSD_vec, v_add(v_mul(I_diff_left, I_diff_left), v_mul(I_diff_right, I_diff_right)));
+            HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW;
+        }
+        SSD = v_reduce_sum(SSD_vec);
+    }
+    else
+#endif
+    {
+        float diff;
+        for (int i = 0; i < patch_sz; i++)
+            for (int j = 0; j < patch_sz; j++)
+            {
+                diff = w00 * I1_ptr[i * I1_stride + j] + w01 * I1_ptr[i * I1_stride + j + 1] +
+                       w10 * I1_ptr[(i + 1) * I1_stride + j] + w11 * I1_ptr[(i + 1) * I1_stride + j + 1] -
+                       I0_ptr[i * I0_stride + j];
+                SSD += diff * diff;
+            }
+    }
+    return SSD;
+}
+
+/* Same as computeSSD, but with patch mean normalization */
+inline float computeSSDMeanNorm(uchar *I0_ptr, uchar *I1_ptr, int I0_stride, int I1_stride, float w00, float w01,
+                                float w10, float w11, int patch_sz)
+{
+    float sum_diff = 0.0f, sum_diff_sq = 0.0f;
+    float n = (float)patch_sz * patch_sz;
+#if CV_SIMD128
+    if (patch_sz == 8)
+    {
+        v_float32x4 sum_diff_vec = v_setall_f32(0);
+        v_float32x4 sum_diff_sq_vec = v_setall_f32(0);
+        HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION;
+        for (int row = 0; row < 8; row++)
+        {
+            HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION;
+            sum_diff_sq_vec = v_add(sum_diff_sq_vec, v_add(v_mul(I_diff_left, I_diff_left), v_mul(I_diff_right, I_diff_right)));
+            sum_diff_vec = v_add(sum_diff_vec, v_add(I_diff_left, I_diff_right));
+            HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW;
+        }
+        sum_diff = v_reduce_sum(sum_diff_vec);
+        sum_diff_sq = v_reduce_sum(sum_diff_sq_vec);
+    }
+    else
+    {
+#endif
+        float diff;
+        for (int i = 0; i < patch_sz; i++)
+            for (int j = 0; j < patch_sz; j++)
+            {
+                diff = w00 * I1_ptr[i * I1_stride + j] + w01 * I1_ptr[i * I1_stride + j + 1] +
+                       w10 * I1_ptr[(i + 1) * I1_stride + j] + w11 * I1_ptr[(i + 1) * I1_stride + j + 1] -
+                       I0_ptr[i * I0_stride + j];
+
+                sum_diff += diff;
+                sum_diff_sq += diff * diff;
+            }
+#if CV_SIMD128
+    }
+#endif
+    return sum_diff_sq - sum_diff * sum_diff / n;
+}
+
+#undef HAL_INIT_BILINEAR_8x8_PATCH_EXTRACTION
+#undef HAL_PROCESS_BILINEAR_8x8_PATCH_EXTRACTION
+#undef HAL_BILINEAR_8x8_PATCH_EXTRACTION_NEXT_ROW
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void DISOpticalFlowImpl::PatchInverseSearch_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    // force separate processing of stripes if we are using spatial propagation:
+    if (dis->use_spatial_propagation && range.end > range.start + 1)
+    {
+        for (int n = range.start; n < range.end; n++)
+            (*this)(Range(n, n + 1));
+        return;
+    }
+    int psz = dis->patch_size;
+    int psz2 = psz / 2;
+    int w_ext = dis->w + 2 * dis->border_size; //!< width of I1_ext
+    int bsz = dis->border_size;
+
+    /* Input dense flow */
+    float *Ux_ptr = Ux->ptr<float>();
+    float *Uy_ptr = Uy->ptr<float>();
+
+    /* Output sparse flow */
+    float *Sx_ptr = Sx->ptr<float>();
+    float *Sy_ptr = Sy->ptr<float>();
+
+    uchar *I0_ptr = I0->ptr<uchar>();
+    uchar *I1_ptr = I1->ptr<uchar>();
+    short *I0x_ptr = I0x->ptr<short>();
+    short *I0y_ptr = I0y->ptr<short>();
+
+    /* Precomputed structure tensor */
+    float *xx_ptr = dis->I0xx_buf.ptr<float>();
+    float *yy_ptr = dis->I0yy_buf.ptr<float>();
+    float *xy_ptr = dis->I0xy_buf.ptr<float>();
+    /* And extra buffers for mean-normalization: */
+    float *x_ptr = dis->I0x_buf.ptr<float>();
+    float *y_ptr = dis->I0y_buf.ptr<float>();
+
+    bool use_temporal_candidates = false;
+    float *initial_Ux_ptr = NULL, *initial_Uy_ptr = NULL;
+    if (!dis->initial_Ux.empty())
+    {
+        initial_Ux_ptr = dis->initial_Ux[pyr_level].ptr<float>();
+        initial_Uy_ptr = dis->initial_Uy[pyr_level].ptr<float>();
+        use_temporal_candidates = true;
+    }
+
+    int i, j, dir;
+    int start_is, end_is, start_js, end_js;
+    int start_i, start_j;
+    float i_lower_limit = bsz - psz + 1.0f;
+    float i_upper_limit = bsz + dis->h - 1.0f;
+    float j_lower_limit = bsz - psz + 1.0f;
+    float j_upper_limit = bsz + dis->w - 1.0f;
+    float dUx, dUy, i_I1, j_I1, w00, w01, w10, w11, dx, dy;
+
+#define INIT_BILINEAR_WEIGHTS(Ux, Uy) \
+    i_I1 = min(max(i + Uy + bsz, i_lower_limit), i_upper_limit); \
+    j_I1 = min(max(j + Ux + bsz, j_lower_limit), j_upper_limit); \
+    { \
+        float di = i_I1 - floor(i_I1); \
+        float dj = j_I1 - floor(j_I1); \
+        w11 = di       * dj; \
+        w10 = di       * (1 - dj); \
+        w01 = (1 - di) * dj; \
+        w00 = (1 - di) * (1 - dj); \
+    }
+
+#define COMPUTE_SSD(dst, Ux, Uy)                                                                                       \
+    INIT_BILINEAR_WEIGHTS(Ux, Uy);                                                                                     \
+    if (dis->use_mean_normalization)                                                                                   \
+        dst = computeSSDMeanNorm(I0_ptr + i * dis->w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1, dis->w, w_ext, w00,  \
+                                 w01, w10, w11, psz);                                                                  \
+    else                                                                                                               \
+        dst = computeSSD(I0_ptr + i * dis->w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1, dis->w, w_ext, w00, w01,     \
+                         w10, w11, psz);
+
+    int num_inner_iter = (int)floor(dis->grad_descent_iter / (float)num_iter);
+    for (int iter = 0; iter < num_iter; iter++)
+    {
+        if (iter % 2 == 0)
+        {
+            dir = 1;
+            start_is = min(range.start * stripe_sz, hs);
+            end_is = min(range.end * stripe_sz, hs);
+            start_js = 0;
+            end_js = dis->ws;
+            start_i = start_is * dis->patch_stride;
+            start_j = 0;
+        }
+        else
+        {
+            dir = -1;
+            start_is = min(range.end * stripe_sz, hs) - 1;
+            end_is = min(range.start * stripe_sz, hs) - 1;
+            start_js = dis->ws - 1;
+            end_js = -1;
+            start_i = start_is * dis->patch_stride;
+            start_j = (dis->ws - 1) * dis->patch_stride;
+        }
+
+        i = start_i;
+        for (int is = start_is; dir * is < dir * end_is; is += dir)
+        {
+            j = start_j;
+            for (int js = start_js; dir * js < dir * end_js; js += dir)
+            {
+                if (iter == 0)
+                {
+                    /* Using result form the previous pyramid level as the very first approximation: */
+                    Sx_ptr[is * dis->ws + js] = Ux_ptr[(i + psz2) * dis->w + j + psz2];
+                    Sy_ptr[is * dis->ws + js] = Uy_ptr[(i + psz2) * dis->w + j + psz2];
+                }
+
+                float min_SSD = INF, cur_SSD;
+                if (use_temporal_candidates || dis->use_spatial_propagation)
+                {
+                    COMPUTE_SSD(min_SSD, Sx_ptr[is * dis->ws + js], Sy_ptr[is * dis->ws + js]);
+                }
+
+                if (use_temporal_candidates)
+                {
+                    /* Try temporal candidates (vectors from the initial flow field that was passed to the function) */
+                    COMPUTE_SSD(cur_SSD, initial_Ux_ptr[(i + psz2) * dis->w + j + psz2],
+                                initial_Uy_ptr[(i + psz2) * dis->w + j + psz2]);
+                    if (cur_SSD < min_SSD)
+                    {
+                        min_SSD = cur_SSD;
+                        Sx_ptr[is * dis->ws + js] = initial_Ux_ptr[(i + psz2) * dis->w + j + psz2];
+                        Sy_ptr[is * dis->ws + js] = initial_Uy_ptr[(i + psz2) * dis->w + j + psz2];
+                    }
+                }
+
+                if (dis->use_spatial_propagation)
+                {
+                    /* Try spatial candidates: */
+                    if (dir * js > dir * start_js)
+                    {
+                        COMPUTE_SSD(cur_SSD, Sx_ptr[is * dis->ws + js - dir], Sy_ptr[is * dis->ws + js - dir]);
+                        if (cur_SSD < min_SSD)
+                        {
+                            min_SSD = cur_SSD;
+                            Sx_ptr[is * dis->ws + js] = Sx_ptr[is * dis->ws + js - dir];
+                            Sy_ptr[is * dis->ws + js] = Sy_ptr[is * dis->ws + js - dir];
+                        }
+                    }
+                    /* Flow vectors won't actually propagate across different stripes, which is the reason for keeping
+                     * the number of stripes constant. It works well enough in practice and doesn't introduce any
+                     * visible seams.
+                     */
+                    if (dir * is > dir * start_is)
+                    {
+                        COMPUTE_SSD(cur_SSD, Sx_ptr[(is - dir) * dis->ws + js], Sy_ptr[(is - dir) * dis->ws + js]);
+                        if (cur_SSD < min_SSD)
+                        {
+                            min_SSD = cur_SSD;
+                            Sx_ptr[is * dis->ws + js] = Sx_ptr[(is - dir) * dis->ws + js];
+                            Sy_ptr[is * dis->ws + js] = Sy_ptr[(is - dir) * dis->ws + js];
+                        }
+                    }
+                }
+
+                /* Use the best candidate as a starting point for the gradient descent: */
+                float cur_Ux = Sx_ptr[is * dis->ws + js];
+                float cur_Uy = Sy_ptr[is * dis->ws + js];
+
+                /* Computing the inverse of the structure tensor: */
+                float detH = xx_ptr[is * dis->ws + js] * yy_ptr[is * dis->ws + js] -
+                             xy_ptr[is * dis->ws + js] * xy_ptr[is * dis->ws + js];
+                if (abs(detH) < EPS)
+                    detH = EPS;
+                float invH11 = yy_ptr[is * dis->ws + js] / detH;
+                float invH12 = -xy_ptr[is * dis->ws + js] / detH;
+                float invH22 = xx_ptr[is * dis->ws + js] / detH;
+                float prev_SSD = INF, SSD;
+                float x_grad_sum = x_ptr[is * dis->ws + js];
+                float y_grad_sum = y_ptr[is * dis->ws + js];
+
+                for (int t = 0; t < num_inner_iter; t++)
+                {
+                    INIT_BILINEAR_WEIGHTS(cur_Ux, cur_Uy);
+                    if (dis->use_mean_normalization)
+                        SSD = processPatchMeanNorm(dUx, dUy,
+                                I0_ptr  + i * dis->w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                                I0x_ptr + i * dis->w + j, I0y_ptr + i * dis->w + j,
+                                dis->w, w_ext, w00, w01, w10, w11, psz,
+                                x_grad_sum, y_grad_sum);
+                    else
+                        SSD = processPatch(dUx, dUy,
+                                I0_ptr  + i * dis->w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                                I0x_ptr + i * dis->w + j, I0y_ptr + i * dis->w + j,
+                                dis->w, w_ext, w00, w01, w10, w11, psz);
+
+                    dx = invH11 * dUx + invH12 * dUy;
+                    dy = invH12 * dUx + invH22 * dUy;
+                    cur_Ux -= dx;
+                    cur_Uy -= dy;
+
+                    /* Break when patch distance stops decreasing */
+                    if (SSD >= prev_SSD)
+                        break;
+                    prev_SSD = SSD;
+                }
+
+                /* If gradient descent converged to a flow vector that is very far from the initial approximation
+                 * (more than patch size) then we don't use it. Noticeably improves the robustness.
+                 */
+                if (norm(Vec2f(cur_Ux - Sx_ptr[is * dis->ws + js], cur_Uy - Sy_ptr[is * dis->ws + js])) <= psz)
+                {
+                    Sx_ptr[is * dis->ws + js] = cur_Ux;
+                    Sy_ptr[is * dis->ws + js] = cur_Uy;
+                }
+                j += dir * dis->patch_stride;
+            }
+            i += dir * dis->patch_stride;
+        }
+    }
+#undef INIT_BILINEAR_WEIGHTS
+#undef COMPUTE_SSD
+}
+
+DISOpticalFlowImpl::Densification_ParBody::Densification_ParBody(DISOpticalFlowImpl &_dis, int _nstripes, int _h,
+                                                                 Mat &dst_Ux, Mat &dst_Uy, Mat &src_Sx, Mat &src_Sy,
+                                                                 Mat &_I0, Mat &_I1)
+    : dis(&_dis), nstripes(_nstripes), h(_h), Ux(&dst_Ux), Uy(&dst_Uy), Sx(&src_Sx), Sy(&src_Sy), I0(&_I0), I1(&_I1)
+{
+    stripe_sz = (int)ceil(h / (double)nstripes);
+}
+
+/* This function transforms a sparse optical flow field obtained by PatchInverseSearch (which computes flow values
+ * on a sparse grid defined by patch_stride) into a dense optical flow field by weighted averaging of values from the
+ * overlapping patches.
+ */
+void DISOpticalFlowImpl::Densification_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    int start_i = min(range.start * stripe_sz, h);
+    int end_i = min(range.end * stripe_sz, h);
+
+    /* Input sparse flow */
+    float *Sx_ptr = Sx->ptr<float>();
+    float *Sy_ptr = Sy->ptr<float>();
+
+    /* Output dense flow */
+    float *Ux_ptr = Ux->ptr<float>();
+    float *Uy_ptr = Uy->ptr<float>();
+
+    uchar *I0_ptr = I0->ptr<uchar>();
+    uchar *I1_ptr = I1->ptr<uchar>();
+
+    int psz = dis->patch_size;
+    int pstr = dis->patch_stride;
+    int i_l, i_u;
+    int j_l, j_u;
+    float i_m, j_m, diff;
+
+    /* These values define the set of sparse grid locations that contain patches overlapping with the current dense flow
+     * location */
+    int start_is, end_is;
+    int start_js, end_js;
+
+/* Some helper macros for updating this set of sparse grid locations */
+#define UPDATE_SPARSE_I_COORDINATES                                                                                    \
+    if (i % pstr == 0 && i + psz <= h)                                                                                 \
+        end_is++;                                                                                                      \
+    if (i - psz >= 0 && (i - psz) % pstr == 0 && start_is < end_is)                                                    \
+        start_is++;
+
+#define UPDATE_SPARSE_J_COORDINATES                                                                                    \
+    if (j % pstr == 0 && j + psz <= dis->w)                                                                            \
+        end_js++;                                                                                                      \
+    if (j - psz >= 0 && (j - psz) % pstr == 0 && start_js < end_js)                                                    \
+        start_js++;
+
+    start_is = 0;
+    end_is = -1;
+    for (int i = 0; i < start_i; i++)
+    {
+        UPDATE_SPARSE_I_COORDINATES;
+    }
+    for (int i = start_i; i < end_i; i++)
+    {
+        UPDATE_SPARSE_I_COORDINATES;
+        start_js = 0;
+        end_js = -1;
+        for (int j = 0; j < dis->w; j++)
+        {
+            UPDATE_SPARSE_J_COORDINATES;
+            float coef, sum_coef = 0.0f;
+            float sum_Ux = 0.0f;
+            float sum_Uy = 0.0f;
+
+            /* Iterate through all the patches that overlap the current location (i,j) */
+            for (int is = start_is; is <= end_is; is++)
+                for (int js = start_js; js <= end_js; js++)
+                {
+                    j_m = min(max(j + Sx_ptr[is * dis->ws + js], 0.0f), dis->w - 1.0f - EPS);
+                    i_m = min(max(i + Sy_ptr[is * dis->ws + js], 0.0f), dis->h - 1.0f - EPS);
+                    j_l = (int)j_m;
+                    j_u = j_l + 1;
+                    i_l = (int)i_m;
+                    i_u = i_l + 1;
+                    diff = (j_m - j_l) * (i_m - i_l) * I1_ptr[i_u * dis->w + j_u] +
+                           (j_u - j_m) * (i_m - i_l) * I1_ptr[i_u * dis->w + j_l] +
+                           (j_m - j_l) * (i_u - i_m) * I1_ptr[i_l * dis->w + j_u] +
+                           (j_u - j_m) * (i_u - i_m) * I1_ptr[i_l * dis->w + j_l] - I0_ptr[i * dis->w + j];
+                    coef = 1 / max(1.0f, abs(diff));
+                    sum_Ux += coef * Sx_ptr[is * dis->ws + js];
+                    sum_Uy += coef * Sy_ptr[is * dis->ws + js];
+                    sum_coef += coef;
+                }
+            CV_DbgAssert(sum_coef != 0);
+            Ux_ptr[i * dis->w + j] = sum_Ux / sum_coef;
+            Uy_ptr[i * dis->w + j] = sum_Uy / sum_coef;
+        }
+    }
+#undef UPDATE_SPARSE_I_COORDINATES
+#undef UPDATE_SPARSE_J_COORDINATES
+}
+
+#ifdef HAVE_OPENCL
+bool DISOpticalFlowImpl::ocl_PatchInverseSearch(UMat &src_U,
+                                                UMat &I0, UMat &I1, UMat &I0x, UMat &I0y, int num_iter, int /*pyr_level*/)
+{
+    CV_INSTRUMENT_REGION();
+    CV_INSTRUMENT_REGION_OPENCL();
+
+    size_t globalSize[] = {(size_t)ws, (size_t)hs};
+    size_t localSize[]  = {16, 16};
+    int num_inner_iter = (int)floor(grad_descent_iter / (float)num_iter);
+
+    String subgroups_build_options;
+    if (ocl::Device::getDefault().isExtensionSupported("cl_khr_subgroups"))
+        subgroups_build_options = " -DCV_USE_SUBGROUPS=1";
+
+    String build_options = cv::format(
+                "-DDIS_BORDER_SIZE=%d -DDIS_PATCH_SIZE=%d -DDIS_PATCH_STRIDE=%d",
+                border_size, patch_size, patch_stride
+            ) + subgroups_build_options;
+
+#if 0 // OpenCL debug
+u_Sx = Scalar::all(0);
+u_Sy = Scalar::all(0);
+#endif
+
+    CV_Assert(num_iter == 2);
+    for (int iter = 0; iter < num_iter; iter++)
+    {
+        if (iter == 0)
+        {
+            ocl::Kernel k1("dis_patch_inverse_search_fwd_1", ocl::video::dis_flow_oclsrc, build_options);
+            size_t global_sz[] = {(size_t)hs * 8};
+            size_t local_sz[]  = {8};
+
+            k1.args(
+                ocl::KernelArg::PtrReadOnly(src_U),
+                ocl::KernelArg::PtrReadOnly(I0),
+                ocl::KernelArg::PtrReadOnly(I1),
+                (int)w, (int)h, (int)ws, (int)hs,
+                ocl::KernelArg::PtrWriteOnly(u_S)
+            );
+            if (!k1.run(1, global_sz, local_sz, false))
+                return false;
+
+            ocl::Kernel k2("dis_patch_inverse_search_fwd_2", ocl::video::dis_flow_oclsrc, build_options);
+
+            k2.args(
+                ocl::KernelArg::PtrReadOnly(src_U),
+                ocl::KernelArg::PtrReadOnly(I0),
+                ocl::KernelArg::PtrReadOnly(I1),
+                ocl::KernelArg::PtrReadOnly(I0x),
+                ocl::KernelArg::PtrReadOnly(I0y),
+                ocl::KernelArg::PtrReadOnly(u_I0xx_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0yy_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0xy_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0x_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0y_buf),
+                (int)w, (int)h, (int)ws, (int)hs,
+                (int)num_inner_iter,
+                ocl::KernelArg::PtrReadWrite(u_S)
+            );
+            if (!k2.run(2, globalSize, localSize, false))
+                return false;
+        }
+        else
+        {
+            ocl::Kernel k3("dis_patch_inverse_search_bwd_1", ocl::video::dis_flow_oclsrc, build_options);
+            size_t global_sz[] = {(size_t)hs * 8};
+            size_t local_sz[]  = {8};
+
+            k3.args(
+                ocl::KernelArg::PtrReadOnly(I0),
+                ocl::KernelArg::PtrReadOnly(I1),
+                (int)w, (int)h, (int)ws, (int)hs,
+                ocl::KernelArg::PtrReadWrite(u_S)
+            );
+            if (!k3.run(1, global_sz, local_sz, false))
+                return false;
+
+            ocl::Kernel k4("dis_patch_inverse_search_bwd_2", ocl::video::dis_flow_oclsrc, build_options);
+
+            k4.args(
+                ocl::KernelArg::PtrReadOnly(I0),
+                ocl::KernelArg::PtrReadOnly(I1),
+                ocl::KernelArg::PtrReadOnly(I0x),
+                ocl::KernelArg::PtrReadOnly(I0y),
+                ocl::KernelArg::PtrReadOnly(u_I0xx_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0yy_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0xy_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0x_buf),
+                ocl::KernelArg::PtrReadOnly(u_I0y_buf),
+                (int)w, (int)h,(int)ws, (int)hs,
+                (int)num_inner_iter,
+                ocl::KernelArg::PtrReadWrite(u_S)
+            );
+            if (!k4.run(2, globalSize, localSize, false))
+                return false;
+        }
+    }
+    return true;
+}
+
+bool DISOpticalFlowImpl::ocl_Densification(UMat &dst_U, UMat &src_S, UMat &_I0, UMat &_I1)
+{
+    CV_INSTRUMENT_REGION();
+    CV_INSTRUMENT_REGION_OPENCL();
+
+    size_t globalSize[] = {(size_t)w, (size_t)h};
+    size_t localSize[]  = {16, 16};
+
+    String build_options = cv::format(
+                "-DDIS_PATCH_SIZE=%d -DDIS_PATCH_STRIDE=%d",
+                patch_size, patch_stride
+            );
+
+    ocl::Kernel kernel("dis_densification", ocl::video::dis_flow_oclsrc, build_options);
+    kernel.args(
+        ocl::KernelArg::PtrReadOnly(src_S),
+        ocl::KernelArg::PtrReadOnly(_I0),
+        ocl::KernelArg::PtrReadOnly(_I1),
+        (int)w, (int)h, (int)ws,
+        ocl::KernelArg::PtrWriteOnly(dst_U)
+    );
+    return kernel.run(2, globalSize, localSize, false);
+}
+
+void DISOpticalFlowImpl::ocl_prepareBuffers(UMat &I0, UMat &I1, InputArray flow, bool use_flow)
+{
+    CV_INSTRUMENT_REGION();
+    // not pure OpenCV code: CV_INSTRUMENT_REGION_OPENCL();
+
+    u_I0s.resize(coarsest_scale + 1);
+    u_I1s.resize(coarsest_scale + 1);
+    u_I1s_ext.resize(coarsest_scale + 1);
+    u_I0xs.resize(coarsest_scale + 1);
+    u_I0ys.resize(coarsest_scale + 1);
+    u_U.resize(coarsest_scale + 1);
+
+    if (use_flow)
+    {
+        u_initial_U.resize(coarsest_scale + 1);
+    }
+
+    int fraction = 1;
+    int cur_rows = 0, cur_cols = 0;
+
+    for (int i = 0; i <= coarsest_scale; i++)
+    {
+        CV_TRACE_REGION("coarsest_scale_iteration");
+        /* Avoid initializing the pyramid levels above the finest scale, as they won't be used anyway */
+        if (i == finest_scale)
+        {
+            cur_rows = I0.rows / fraction;
+            cur_cols = I0.cols / fraction;
+            u_I0s[i].create(cur_rows, cur_cols, CV_8UC1);
+            resize(I0, u_I0s[i], u_I0s[i].size(), 0.0, 0.0, INTER_AREA);
+            u_I1s[i].create(cur_rows, cur_cols, CV_8UC1);
+            resize(I1, u_I1s[i], u_I1s[i].size(), 0.0, 0.0, INTER_AREA);
+
+            /* These buffers are reused in each scale so we initialize them once on the finest scale: */
+            u_S.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC2);
+            u_I0xx_buf.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC1);
+            u_I0yy_buf.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC1);
+            u_I0xy_buf.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC1);
+            u_I0x_buf.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC1);
+            u_I0y_buf.create(cur_rows / patch_stride, cur_cols / patch_stride, CV_32FC1);
+
+            u_I0xx_buf_aux.create(cur_rows, cur_cols / patch_stride, CV_32FC1);
+            u_I0yy_buf_aux.create(cur_rows, cur_cols / patch_stride, CV_32FC1);
+            u_I0xy_buf_aux.create(cur_rows, cur_cols / patch_stride, CV_32FC1);
+            u_I0x_buf_aux.create(cur_rows, cur_cols / patch_stride, CV_32FC1);
+            u_I0y_buf_aux.create(cur_rows, cur_cols / patch_stride, CV_32FC1);
+        }
+        else if (i > finest_scale)
+        {
+            cur_rows = u_I0s[i - 1].rows / 2;
+            cur_cols = u_I0s[i - 1].cols / 2;
+            u_I0s[i].create(cur_rows, cur_cols, CV_8UC1);
+            resize(u_I0s[i - 1], u_I0s[i], u_I0s[i].size(), 0.0, 0.0, INTER_AREA);
+            u_I1s[i].create(cur_rows, cur_cols, CV_8UC1);
+            resize(u_I1s[i - 1], u_I1s[i], u_I1s[i].size(), 0.0, 0.0, INTER_AREA);
+        }
+
+        if (i >= finest_scale)
+        {
+            u_I1s_ext[i].create(cur_rows + 2 * border_size, cur_cols + 2 * border_size, CV_8UC1);
+            copyMakeBorder(u_I1s[i], u_I1s_ext[i], border_size, border_size, border_size, border_size, BORDER_REPLICATE);
+            u_I0xs[i].create(cur_rows, cur_cols, CV_16SC1);
+            u_I0ys[i].create(cur_rows, cur_cols, CV_16SC1);
+            spatialGradient(u_I0s[i], u_I0xs[i], u_I0ys[i]);
+            u_U[i].create(cur_rows, cur_cols, CV_32FC2);
+            variational_refinement_processors[i]->setAlpha(variational_refinement_alpha);
+            variational_refinement_processors[i]->setDelta(variational_refinement_delta);
+            variational_refinement_processors[i]->setGamma(variational_refinement_gamma);
+            variational_refinement_processors[i]->setEpsilon(variational_refinement_epsilon);
+            variational_refinement_processors[i]->setSorIterations(5);
+            variational_refinement_processors[i]->setFixedPointIterations(variational_refinement_iter);
+
+            if (use_flow)
+            {
+                UMat resized_flow;
+                resize(flow, resized_flow, Size(cur_cols, cur_rows));
+                float scale = 1.0f / fraction;
+                resized_flow.convertTo(u_initial_U[i], CV_32FC2, scale, 0.0f);
+            }
+        }
+
+        fraction *= 2;
+    }
+}
+
+bool DISOpticalFlowImpl::ocl_precomputeStructureTensor(UMat &dst_I0xx, UMat &dst_I0yy, UMat &dst_I0xy,
+                                                       UMat &dst_I0x, UMat &dst_I0y, UMat &I0x, UMat &I0y)
+{
+    CV_INSTRUMENT_REGION();
+    CV_INSTRUMENT_REGION_OPENCL();
+
+    size_t globalSizeX[] = {(size_t)h};
+    size_t localSizeX[]  = {16};
+
+#if 0 // OpenCL debug
+    u_I0xx_buf_aux = Scalar::all(0);
+    u_I0yy_buf_aux = Scalar::all(0);
+    u_I0xy_buf_aux = Scalar::all(0);
+    u_I0x_buf_aux = Scalar::all(0);
+    u_I0y_buf_aux = Scalar::all(0);
+    dst_I0xx = Scalar::all(0);
+    dst_I0yy = Scalar::all(0);
+    dst_I0xy = Scalar::all(0);
+    dst_I0x = Scalar::all(0);
+    dst_I0y = Scalar::all(0);
+#endif
+
+    String build_options = cv::format(
+                "-DDIS_PATCH_SIZE=%d -DDIS_PATCH_STRIDE=%d",
+                patch_size, patch_stride
+            );
+
+    ocl::Kernel kernelX("dis_precomputeStructureTensor_hor", ocl::video::dis_flow_oclsrc, build_options);
+    kernelX.args(
+        ocl::KernelArg::PtrReadOnly(I0x),
+        ocl::KernelArg::PtrReadOnly(I0y),
+        (int)w, (int)h, (int)ws,
+        ocl::KernelArg::PtrWriteOnly(u_I0xx_buf_aux),
+        ocl::KernelArg::PtrWriteOnly(u_I0yy_buf_aux),
+        ocl::KernelArg::PtrWriteOnly(u_I0xy_buf_aux),
+        ocl::KernelArg::PtrWriteOnly(u_I0x_buf_aux),
+        ocl::KernelArg::PtrWriteOnly(u_I0y_buf_aux)
+    );
+    if (!kernelX.run(1, globalSizeX, localSizeX, false))
+        return false;
+
+    size_t globalSizeY[] = {(size_t)ws};
+    size_t localSizeY[]  = {16};
+
+    ocl::Kernel kernelY("dis_precomputeStructureTensor_ver", ocl::video::dis_flow_oclsrc, build_options);
+    kernelY.args(
+        ocl::KernelArg::PtrReadOnly(u_I0xx_buf_aux),
+        ocl::KernelArg::PtrReadOnly(u_I0yy_buf_aux),
+        ocl::KernelArg::PtrReadOnly(u_I0xy_buf_aux),
+        ocl::KernelArg::PtrReadOnly(u_I0x_buf_aux),
+        ocl::KernelArg::PtrReadOnly(u_I0y_buf_aux),
+        (int)w, (int)h, (int)ws,
+        ocl::KernelArg::PtrWriteOnly(dst_I0xx),
+        ocl::KernelArg::PtrWriteOnly(dst_I0yy),
+        ocl::KernelArg::PtrWriteOnly(dst_I0xy),
+        ocl::KernelArg::PtrWriteOnly(dst_I0x),
+        ocl::KernelArg::PtrWriteOnly(dst_I0y)
+    );
+    return kernelY.run(1, globalSizeY, localSizeY, false);
+}
+
+bool DISOpticalFlowImpl::ocl_calc(InputArray I0, InputArray I1, InputOutputArray flow)
+{
+    CV_INSTRUMENT_REGION();
+    // not pure OpenCV code: CV_INSTRUMENT_REGION_OPENCL();
+
+    UMat I0Mat = I0.getUMat();
+    UMat I1Mat = I1.getUMat();
+    bool use_input_flow = false;
+    if (flow.sameSize(I0) && flow.depth() == CV_32F && flow.channels() == 2)
+        use_input_flow = true;
+
+    int max_possible_scale = min((int)(log(max(I0Mat.cols, I0Mat.rows) / (4.0 * patch_size)) / log(2.0) + 0.5), /* Original code search for maximal movement of width/4 */
+                                 (int)(log(min(I0Mat.cols, I0Mat.rows) / patch_size) / log(2.0)));              /* Deepest pyramid level greater or equal than patch*/
+
+    if (user_coarsest_scale != -1)
+        coarsest_scale = min(user_coarsest_scale, max_possible_scale);
+    else
+        coarsest_scale = max_possible_scale;
+
+    if (coarsest_scale<0)
+        CV_Error(cv::Error::StsBadSize, "The input image must have either width or height >= 12");
+
+    if (coarsest_scale<finest_scale)
+    {
+        // choose the finest level based on coarsest level.
+        // Refs: https://github.com/tikroeger/OF_DIS/blob/2c9f2a674f3128d3a41c10e41cc9f3a35bb1b523/run_dense.cpp#L239
+        int original_img_width = I0.size().width;
+        autoSelectPatchSizeAndScales(original_img_width);
+    }
+
+    ocl_prepareBuffers(I0Mat, I1Mat, flow, use_input_flow);
+    u_U[coarsest_scale].setTo(0.0f);
+
+    for (int i = coarsest_scale; i >= finest_scale; i--)
+    {
+        CV_TRACE_REGION("coarsest_scale_iteration");
+        w = u_I0s[i].cols;
+        h = u_I0s[i].rows;
+        ws = 1 + (w - patch_size) / patch_stride;
+        hs = 1 + (h - patch_size) / patch_stride;
+
+        if (!ocl_precomputeStructureTensor(u_I0xx_buf, u_I0yy_buf, u_I0xy_buf,
+                                           u_I0x_buf, u_I0y_buf, u_I0xs[i], u_I0ys[i]))
+            return false;
+
+        if (!ocl_PatchInverseSearch(u_U[i], u_I0s[i], u_I1s_ext[i], u_I0xs[i], u_I0ys[i], 2, i))
+            return false;
+
+        if (!ocl_Densification(u_U[i], u_S, u_I0s[i], u_I1s[i]))
+            return false;
+
+        if (variational_refinement_iter > 0)
+        {
+            std::vector<Mat> U_channels;
+            split(u_U[i], U_channels); CV_Assert(U_channels.size() == 2);
+            variational_refinement_processors[i]->calcUV(u_I0s[i], u_I1s[i],
+                    U_channels[0], U_channels[1]);
+            merge(U_channels, u_U[i]);
+        }
+
+        if (i > finest_scale)
+        {
+            UMat resized;
+            resize(u_U[i], resized, u_U[i - 1].size());
+            multiply(resized, 2, u_U[i - 1]);
+        }
+    }
+
+    UMat resized_flow;
+    resize(u_U[finest_scale], resized_flow, I1Mat.size());
+    multiply(resized_flow, 1 << finest_scale, flow);
+
+    return true;
+}
+#endif
+
+void DISOpticalFlowImpl::calc(InputArray I0, InputArray I1, InputOutputArray flow)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!I0.empty() && I0.depth() == CV_8U && I0.channels() == 1);
+    CV_Assert(!I1.empty() && I1.depth() == CV_8U && I1.channels() == 1);
+    CV_Assert(I0.sameSize(I1));
+    CV_Assert(I0.isContinuous());
+    CV_Assert(I1.isContinuous());
+
+    CV_OCL_RUN(flow.isUMat() &&
+               (patch_size == 8) && (use_spatial_propagation == true),
+               ocl_calc(I0, I1, flow));
+
+    Mat I0Mat = I0.getMat();
+    Mat I1Mat = I1.getMat();
+    bool use_input_flow = false;
+    if (flow.sameSize(I0) && flow.depth() == CV_32F && flow.channels() == 2)
+        use_input_flow = true;
+    else
+        flow.create(I1Mat.size(), CV_32FC2);
+    Mat flowMat = flow.getMat();
+
+    int max_possible_scale = min((int)(log(max(I0Mat.cols, I0Mat.rows) / (4.0 * patch_size)) / log(2.0) + 0.5), /* Original code search for maximal movement of width/4 */
+                                 (int)(log(min(I0Mat.cols, I0Mat.rows) / patch_size) / log(2.0)));              /* Deepest pyramid level greater or equal than patch*/
+
+    if (user_coarsest_scale != -1)
+        coarsest_scale = min(user_coarsest_scale, max_possible_scale);
+    else
+        coarsest_scale = max_possible_scale;
+    if (coarsest_scale<0)
+        CV_Error(cv::Error::StsBadSize, "The input image must have either width or height >= 12");
+
+    if (coarsest_scale<finest_scale)
+    {
+        // choose the finest level based on coarsest level.
+        // Refs: https://github.com/tikroeger/OF_DIS/blob/2c9f2a674f3128d3a41c10e41cc9f3a35bb1b523/run_dense.cpp#L239
+        int original_img_width = I0.size().width;
+        autoSelectPatchSizeAndScales(original_img_width);
+    }
+
+    int num_stripes = getNumThreads();
+
+    prepareBuffers(I0Mat, I1Mat, flowMat, use_input_flow);
+    Ux[coarsest_scale].setTo(0.0f);
+    Uy[coarsest_scale].setTo(0.0f);
+
+    for (int i = coarsest_scale; i >= finest_scale; i--)
+    {
+        CV_TRACE_REGION("coarsest_scale_iteration");
+        w = I0s[i].cols;
+        h = I0s[i].rows;
+        ws = 1 + (w - patch_size) / patch_stride;
+        hs = 1 + (h - patch_size) / patch_stride;
+
+        precomputeStructureTensor(I0xx_buf, I0yy_buf, I0xy_buf, I0x_buf, I0y_buf, I0xs[i], I0ys[i]);
+        if (use_spatial_propagation)
+        {
+            /* Use a fixed number of stripes regardless the number of threads to make inverse search
+             * with spatial propagation reproducible
+             */
+            parallel_for_(Range(0, 8), PatchInverseSearch_ParBody(*this, 8, hs, Sx, Sy, Ux[i], Uy[i], I0s[i],
+                                                                  I1s_ext[i], I0xs[i], I0ys[i], 2, i));
+        }
+        else
+        {
+            parallel_for_(Range(0, num_stripes),
+                          PatchInverseSearch_ParBody(*this, num_stripes, hs, Sx, Sy, Ux[i], Uy[i], I0s[i], I1s_ext[i],
+                                                     I0xs[i], I0ys[i], 1, i));
+        }
+
+        parallel_for_(Range(0, num_stripes),
+                      Densification_ParBody(*this, num_stripes, I0s[i].rows, Ux[i], Uy[i], Sx, Sy, I0s[i], I1s[i]));
+        if (variational_refinement_iter > 0)
+            variational_refinement_processors[i]->calcUV(I0s[i], I1s[i], Ux[i], Uy[i]);
+
+        if (i > finest_scale)
+        {
+            resize(Ux[i], Ux[i - 1], Ux[i - 1].size());
+            resize(Uy[i], Uy[i - 1], Uy[i - 1].size());
+            Ux[i - 1] *= 2;
+            Uy[i - 1] *= 2;
+        }
+    }
+    Mat uxy[] = {Ux[finest_scale], Uy[finest_scale]};
+    merge(uxy, 2, U);
+    resize(U, flowMat, flowMat.size());
+    flowMat *= 1 << finest_scale;
+}
+
+void DISOpticalFlowImpl::collectGarbage()
+{
+    CV_INSTRUMENT_REGION();
+
+    I0s.clear();
+    I1s.clear();
+    I1s_ext.clear();
+    I0xs.clear();
+    I0ys.clear();
+    Ux.clear();
+    Uy.clear();
+    U.release();
+    Sx.release();
+    Sy.release();
+    I0xx_buf.release();
+    I0yy_buf.release();
+    I0xy_buf.release();
+    I0xx_buf_aux.release();
+    I0yy_buf_aux.release();
+    I0xy_buf_aux.release();
+
+#ifdef HAVE_OPENCL
+    u_I0s.clear();
+    u_I1s.clear();
+    u_I1s_ext.clear();
+    u_I0xs.clear();
+    u_I0ys.clear();
+    u_U.clear();
+    u_S.release();
+    u_I0xx_buf.release();
+    u_I0yy_buf.release();
+    u_I0xy_buf.release();
+    u_I0xx_buf_aux.release();
+    u_I0yy_buf_aux.release();
+    u_I0xy_buf_aux.release();
+#endif
+
+    for (int i = finest_scale; i <= coarsest_scale; i++)
+        variational_refinement_processors[i]->collectGarbage();
+    variational_refinement_processors.clear();
+}
+
+Ptr<DISOpticalFlow> DISOpticalFlow::create(int preset)
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<DISOpticalFlow> dis = makePtr<DISOpticalFlowImpl>();
+    dis->setPatchSize(8);
+    if (preset == DISOpticalFlow::PRESET_ULTRAFAST)
+    {
+        dis->setFinestScale(2);
+        dis->setPatchStride(4);
+        dis->setGradientDescentIterations(12);
+        dis->setVariationalRefinementIterations(0);
+    }
+    else if (preset == DISOpticalFlow::PRESET_FAST)
+    {
+        dis->setFinestScale(2);
+        dis->setPatchStride(4);
+        dis->setGradientDescentIterations(16);
+        dis->setVariationalRefinementIterations(5);
+    }
+    else if (preset == DISOpticalFlow::PRESET_MEDIUM)
+    {
+        dis->setFinestScale(1);
+        dis->setPatchStride(3);
+        dis->setGradientDescentIterations(25);
+        dis->setVariationalRefinementIterations(5);
+    }
+
+    return dis;
+}
+
+
+} // namespace
diff --git a/upstream/opencv/modules/video/src/ecc.cpp b/upstream/opencv/modules/video/src/ecc.cpp
new file mode 100644
index 0000000..a8cd173
--- /dev/null
+++ b/upstream/opencv/modules/video/src/ecc.cpp
@@ -0,0 +1,632 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+/****************************************************************************************\
+*                                       Image Alignment (ECC algorithm)                  *
+\****************************************************************************************/
+
+using namespace cv;
+
+static void image_jacobian_homo_ECC(const Mat& src1, const Mat& src2, const Mat& src3, const Mat& src4, const Mat& src5,
+                                    Mat& dst) {
+    CV_Assert(src1.size() == src2.size());
+    CV_Assert(src1.size() == src3.size());
+    CV_Assert(src1.size() == src4.size());
+
+    CV_Assert(src1.rows == dst.rows);
+    CV_Assert(dst.cols == (src1.cols * 8));
+    CV_Assert(dst.type() == CV_MAKETYPE(CV_32F, src1.channels()));
+
+    CV_Assert(src5.isContinuous());
+
+    const float* hptr = src5.ptr<float>(0);
+
+    const float h0_ = hptr[0];
+    const float h1_ = hptr[3];
+    const float h2_ = hptr[6];
+    const float h3_ = hptr[1];
+    const float h4_ = hptr[4];
+    const float h5_ = hptr[7];
+    const float h6_ = hptr[2];
+    const float h7_ = hptr[5];
+
+    const int w = src1.cols;
+
+    // create denominator for all points as a block
+    Mat den_;
+    addWeighted(src3, h2_, src4, h5_, 1.0, den_);
+
+    // create projected points
+    Mat hatX_, hatY_;
+    addWeighted(src3, h0_, src4, h3_, 0.0, hatX_);
+    hatX_ += h6_;
+
+    addWeighted(src3, h1_, src4, h4_, 0.0, hatY_);
+    hatY_ += h7_;
+
+    divide(-hatY_, den_, hatY_);
+    divide(-hatX_, den_, hatX_);
+
+    // instead of dividing each block with den,
+    // just pre-divide the block of gradients (it's more efficient)
+
+    Mat src1Divided_;
+    Mat src2Divided_;
+
+    divide(src1, den_, src1Divided_);
+    divide(src2, den_, src2Divided_);
+
+    // compute Jacobian blocks (8 blocks)
+
+    dst.colRange(0, w) = src1Divided_.mul(src3);  // 1
+
+    dst.colRange(w, 2 * w) = src2Divided_.mul(src3);  // 2
+
+    Mat temp_ = (hatX_.mul(src1Divided_) + hatY_.mul(src2Divided_));
+    dst.colRange(2 * w, 3 * w) = temp_.mul(src3);  // 3
+
+    hatX_.release();
+    hatY_.release();
+
+    dst.colRange(3 * w, 4 * w) = src1Divided_.mul(src4);  // 4
+
+    dst.colRange(4 * w, 5 * w) = src2Divided_.mul(src4);  // 5
+
+    dst.colRange(5 * w, 6 * w) = temp_.mul(src4);  // 6
+
+    src1Divided_.copyTo(dst.colRange(6 * w, 7 * w));  // 7
+
+    src2Divided_.copyTo(dst.colRange(7 * w, 8 * w));  // 8
+}
+
+static void image_jacobian_euclidean_ECC(const Mat& src1, const Mat& src2, const Mat& src3, const Mat& src4,
+                                         const Mat& src5, Mat& dst) {
+    CV_Assert(src1.size() == src2.size());
+    CV_Assert(src1.size() == src3.size());
+    CV_Assert(src1.size() == src4.size());
+
+    CV_Assert(src1.rows == dst.rows);
+    CV_Assert(dst.cols == (src1.cols * 3));
+    CV_Assert(dst.type() == CV_MAKETYPE(CV_32F, src1.channels()));
+
+    CV_Assert(src5.isContinuous());
+
+    const float* hptr = src5.ptr<float>(0);
+
+    const float h0 = hptr[0];  // cos(theta)
+    const float h1 = hptr[3];  // sin(theta)
+
+    const int w = src1.cols;
+
+    // create -sin(theta)*X -cos(theta)*Y for all points as a block -> hatX
+    Mat hatX = -(src3 * h1) - (src4 * h0);
+
+    // create cos(theta)*X -sin(theta)*Y for all points as a block -> hatY
+    Mat hatY = (src3 * h0) - (src4 * h1);
+
+    // compute Jacobian blocks (3 blocks)
+    dst.colRange(0, w) = (src1.mul(hatX)) + (src2.mul(hatY));  // 1
+
+    src1.copyTo(dst.colRange(w, 2 * w));      // 2
+    src2.copyTo(dst.colRange(2 * w, 3 * w));  // 3
+}
+
+static void image_jacobian_affine_ECC(const Mat& src1, const Mat& src2, const Mat& src3, const Mat& src4, Mat& dst) {
+    CV_Assert(src1.size() == src2.size());
+    CV_Assert(src1.size() == src3.size());
+    CV_Assert(src1.size() == src4.size());
+
+    CV_Assert(src1.rows == dst.rows);
+    CV_Assert(dst.cols == (6 * src1.cols));
+
+    CV_Assert(dst.type() == CV_MAKETYPE(CV_32F, src1.channels()));
+
+    const int w = src1.cols;
+
+    // compute Jacobian blocks (6 blocks)
+
+    dst.colRange(0, w) = src1.mul(src3);          // 1
+    dst.colRange(w, 2 * w) = src2.mul(src3);      // 2
+    dst.colRange(2 * w, 3 * w) = src1.mul(src4);  // 3
+    dst.colRange(3 * w, 4 * w) = src2.mul(src4);  // 4
+    src1.copyTo(dst.colRange(4 * w, 5 * w));      // 5
+    src2.copyTo(dst.colRange(5 * w, 6 * w));      // 6
+}
+
+static void image_jacobian_translation_ECC(const Mat& src1, const Mat& src2, Mat& dst) {
+    CV_Assert(src1.size() == src2.size());
+
+    CV_Assert(src1.rows == dst.rows);
+    CV_Assert(dst.cols == (src1.cols * 2));
+    CV_Assert(dst.type() == CV_MAKETYPE(CV_32F, src1.channels()));
+
+    const int w = src1.cols;
+
+    // compute Jacobian blocks (2 blocks)
+    src1.copyTo(dst.colRange(0, w));
+    src2.copyTo(dst.colRange(w, 2 * w));
+}
+
+static void project_onto_jacobian_ECC(const Mat& src1, const Mat& src2, Mat& dst) {
+    /* this functions is used for two types of projections. If src1.cols ==src.cols
+    it does a blockwise multiplication (like in the outer product of vectors)
+    of the blocks in matrices src1 and src2 and dst
+    has size (number_of_blcks x number_of_blocks), otherwise dst is a vector of size
+    (number_of_blocks x 1) since src2 is "multiplied"(dot) with each block of src1.
+
+    The number_of_blocks is equal to the number of parameters we are lloking for
+    (i.e. rtanslation:2, euclidean: 3, affine: 6, homography: 8)
+
+    */
+    CV_Assert(src1.rows == src2.rows);
+    CV_Assert((src1.cols % src2.cols) == 0);
+    int w;
+
+    float* dstPtr = dst.ptr<float>(0);
+
+    if (src1.cols != src2.cols) {  // dst.cols==1
+        w = src2.cols;
+        for (int i = 0; i < dst.rows; i++) {
+            dstPtr[i] = (float)src2.dot(src1.colRange(i * w, (i + 1) * w));
+        }
+    }
+
+    else {
+        CV_Assert(dst.cols == dst.rows);  // dst is square (and symmetric)
+        w = src2.cols / dst.cols;
+        Mat mat;
+        for (int i = 0; i < dst.rows; i++) {
+            mat = Mat(src1.colRange(i * w, (i + 1) * w));
+            dstPtr[i * (dst.rows + 1)] = (float)std::pow(norm(mat), 2);  // diagonal elements
+
+            for (int j = i + 1; j < dst.cols; j++) {  // j starts from i+1
+                dstPtr[i * dst.cols + j] = (float)mat.dot(src2.colRange(j * w, (j + 1) * w));
+                dstPtr[j * dst.cols + i] = dstPtr[i * dst.cols + j];  // due to symmetry
+            }
+        }
+    }
+}
+
+static void update_warping_matrix_ECC(Mat& map_matrix, const Mat& update, const int motionType) {
+    CV_Assert(map_matrix.type() == CV_32FC1);
+    CV_Assert(update.type() == CV_32FC1);
+
+    CV_Assert(motionType == MOTION_TRANSLATION || motionType == MOTION_EUCLIDEAN || motionType == MOTION_AFFINE ||
+              motionType == MOTION_HOMOGRAPHY);
+
+    if (motionType == MOTION_HOMOGRAPHY)
+        CV_Assert(map_matrix.rows == 3 && update.rows == 8);
+    else if (motionType == MOTION_AFFINE)
+        CV_Assert(map_matrix.rows == 2 && update.rows == 6);
+    else if (motionType == MOTION_EUCLIDEAN)
+        CV_Assert(map_matrix.rows == 2 && update.rows == 3);
+    else
+        CV_Assert(map_matrix.rows == 2 && update.rows == 2);
+
+    CV_Assert(update.cols == 1);
+
+    CV_Assert(map_matrix.isContinuous());
+    CV_Assert(update.isContinuous());
+
+    float* mapPtr = map_matrix.ptr<float>(0);
+    const float* updatePtr = update.ptr<float>(0);
+
+    if (motionType == MOTION_TRANSLATION) {
+        mapPtr[2] += updatePtr[0];
+        mapPtr[5] += updatePtr[1];
+    }
+    if (motionType == MOTION_AFFINE) {
+        mapPtr[0] += updatePtr[0];
+        mapPtr[3] += updatePtr[1];
+        mapPtr[1] += updatePtr[2];
+        mapPtr[4] += updatePtr[3];
+        mapPtr[2] += updatePtr[4];
+        mapPtr[5] += updatePtr[5];
+    }
+    if (motionType == MOTION_HOMOGRAPHY) {
+        mapPtr[0] += updatePtr[0];
+        mapPtr[3] += updatePtr[1];
+        mapPtr[6] += updatePtr[2];
+        mapPtr[1] += updatePtr[3];
+        mapPtr[4] += updatePtr[4];
+        mapPtr[7] += updatePtr[5];
+        mapPtr[2] += updatePtr[6];
+        mapPtr[5] += updatePtr[7];
+    }
+    if (motionType == MOTION_EUCLIDEAN) {
+        double new_theta = updatePtr[0];
+        new_theta += asin(mapPtr[3]);
+
+        mapPtr[2] += updatePtr[1];
+        mapPtr[5] += updatePtr[2];
+        mapPtr[0] = mapPtr[4] = (float)cos(new_theta);
+        mapPtr[3] = (float)sin(new_theta);
+        mapPtr[1] = -mapPtr[3];
+    }
+}
+
+/** Function that computes enhanced corelation coefficient from Georgios et.al. 2008
+ *   See https://github.com/opencv/opencv/issues/12432
+ */
+double cv::computeECC(InputArray templateImage, InputArray inputImage, InputArray inputMask) {
+    CV_Assert(!templateImage.empty());
+    CV_Assert(!inputImage.empty());
+
+    CV_Assert(templateImage.channels() == 1 || templateImage.channels() == 3);
+
+    if (!(templateImage.type() == inputImage.type()))
+        CV_Error(Error::StsUnmatchedFormats, "Both input images must have the same data type");
+
+    Scalar meanTemplate, sdTemplate;
+
+    int active_pixels = inputMask.empty() ? templateImage.size().area() : countNonZero(inputMask);
+    int type = templateImage.type();
+    meanStdDev(templateImage, meanTemplate, sdTemplate, inputMask);
+    Mat templateImage_zeromean = Mat::zeros(templateImage.size(), templateImage.type());
+    Mat templateMat = templateImage.getMat();
+    Mat inputMat = inputImage.getMat();
+
+    /*
+     * For unsigned ints, when the mean is computed and subtracted, any values less than the mean
+     * will be set to 0 (since there are no negatives values). This impacts the norm and dot product, which
+     * ultimately results in an incorrect ECC. To circumvent this problem, if unsigned ints are provided,
+     * we convert them to a signed ints with larger resolution for the subtraction step.
+     */
+    if (type == CV_8U || type == CV_16U) {
+        int newType = type == CV_8U ? CV_16S : CV_32S;
+        Mat templateMatConverted, inputMatConverted;
+        templateMat.convertTo(templateMatConverted, newType);
+        cv::swap(templateMat, templateMatConverted);
+        inputMat.convertTo(inputMatConverted, newType);
+        cv::swap(inputMat, inputMatConverted);
+    }
+    subtract(templateMat, meanTemplate, templateImage_zeromean, inputMask);
+    double templateImagenorm = std::sqrt(active_pixels * cv::norm(sdTemplate, NORM_L2SQR));
+
+    Scalar meanInput, sdInput;
+
+    Mat inputImage_zeromean = Mat::zeros(inputImage.size(), inputImage.type());
+    meanStdDev(inputImage, meanInput, sdInput, inputMask);
+    subtract(inputMat, meanInput, inputImage_zeromean, inputMask);
+    double inputImagenorm = std::sqrt(active_pixels * norm(sdInput, NORM_L2SQR));
+
+    return templateImage_zeromean.dot(inputImage_zeromean) / (templateImagenorm * inputImagenorm);
+}
+
+
+double cv::findTransformECCWithMask( InputArray templateImage,
+                                 InputArray inputImage,
+                                 InputArray templateMask,
+                                 InputArray inputMask,
+                                 InputOutputArray warpMatrix,
+                                 int motionType,
+                                 TermCriteria criteria,
+                                 int gaussFiltSize) {
+    Mat src = templateImage.getMat();  // template image
+    Mat dst = inputImage.getMat();     // input image (to be warped)
+    Mat map = warpMatrix.getMat();     // warp (transformation)
+
+    CV_Assert(!src.empty());
+    CV_Assert(!dst.empty());
+
+    CV_Assert(src.channels() == 1 || src.channels() == 3);
+    CV_Assert(src.channels() == dst.channels());
+    CV_Assert(src.depth() == dst.depth());
+    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F || src.depth() == CV_64F);
+
+    // If the user passed an un-initialized warpMatrix, initialize to identity
+    if (map.empty()) {
+        int rowCount = 2;
+        if (motionType == MOTION_HOMOGRAPHY)
+            rowCount = 3;
+
+        warpMatrix.create(rowCount, 3, CV_32FC1);
+        map = warpMatrix.getMat();
+        map = Mat::eye(rowCount, 3, CV_32F);
+    }
+
+    if (!(src.type() == dst.type()))
+        CV_Error(Error::StsUnmatchedFormats, "Both input images must have the same data type");
+
+    if (map.type() != CV_32FC1)
+        CV_Error(Error::StsUnsupportedFormat, "warpMatrix must be single-channel floating-point matrix");
+
+    CV_Assert(map.cols == 3);
+    CV_Assert(map.rows == 2 || map.rows == 3);
+
+    CV_Assert(motionType == MOTION_AFFINE || motionType == MOTION_HOMOGRAPHY || motionType == MOTION_EUCLIDEAN ||
+              motionType == MOTION_TRANSLATION);
+
+    if (motionType == MOTION_HOMOGRAPHY) {
+        CV_Assert(map.rows == 3);
+    }
+
+    CV_Assert(criteria.type & TermCriteria::COUNT || criteria.type & TermCriteria::EPS);
+    const int numberOfIterations = (criteria.type & TermCriteria::COUNT) ? criteria.maxCount : 200;
+    const double termination_eps = (criteria.type & TermCriteria::EPS) ? criteria.epsilon : -1;
+
+    int paramTemp = 6;  // default: affine
+    switch (motionType) {
+        case MOTION_TRANSLATION:
+            paramTemp = 2;
+            break;
+        case MOTION_EUCLIDEAN:
+            paramTemp = 3;
+            break;
+        case MOTION_HOMOGRAPHY:
+            paramTemp = 8;
+            break;
+    }
+
+    const int numberOfParameters = paramTemp;
+
+    const int ws = src.cols;
+    const int hs = src.rows;
+    const int wd = dst.cols;
+    const int hd = dst.rows;
+
+    Mat Xcoord = Mat(1, ws, CV_32F);
+    Mat Ycoord = Mat(hs, 1, CV_32F);
+    Mat Xgrid = Mat(hs, ws, CV_32F);
+    Mat Ygrid = Mat(hs, ws, CV_32F);
+
+    float* XcoPtr = Xcoord.ptr<float>(0);
+    float* YcoPtr = Ycoord.ptr<float>(0);
+    int j;
+    for (j = 0; j < ws; j++) XcoPtr[j] = (float)j;
+    for (j = 0; j < hs; j++) YcoPtr[j] = (float)j;
+
+    repeat(Xcoord, hs, 1, Xgrid);
+    repeat(Ycoord, 1, ws, Ygrid);
+
+    Xcoord.release();
+    Ycoord.release();
+
+    const int channels = src.channels();
+    int type = CV_MAKETYPE(CV_32F, channels);
+
+    std::vector<cv::Mat> XgridCh(channels, Xgrid);
+    cv::merge(XgridCh, Xgrid);
+
+    std::vector<cv::Mat> YgridCh(channels, Ygrid);
+    cv::merge(YgridCh, Ygrid);
+
+    Mat templateZM = Mat(hs, ws, type);     // to store the (smoothed)zero-mean version of template
+    Mat templateFloat = Mat(hs, ws, type);  // to store the (smoothed) template
+    Mat imageFloat = Mat(hd, wd, type);     // to store the (smoothed) input image
+    Mat imageWarped = Mat(hs, ws, type);    // to store the warped zero-mean input image
+    Mat imageMask = Mat(hs, ws, CV_8U);     // to store the final mask
+
+    // Gaussian filtering is optional
+    src.convertTo(templateFloat, templateFloat.type());
+    GaussianBlur(templateFloat, templateFloat, Size(gaussFiltSize, gaussFiltSize), 0, 0);
+
+    dst.convertTo(imageFloat, imageFloat.type());
+    GaussianBlur(imageFloat, imageFloat, Size(gaussFiltSize, gaussFiltSize), 0, 0);
+
+    // needed matrices for gradients and warped gradients
+    Mat gradientX = Mat::zeros(hd, wd, type);
+    Mat gradientY = Mat::zeros(hd, wd, type);
+    Mat gradientXWarped = Mat(hs, ws, type);
+    Mat gradientYWarped = Mat(hs, ws, type);
+
+    // calculate first order image derivatives
+    Matx13f dx(-0.5f, 0.0f, 0.5f);
+
+    filter2D(imageFloat, gradientX, -1, dx);
+    filter2D(imageFloat, gradientY, -1, dx.t());
+
+    // To use in mask warping
+    Mat templtMask;
+    if(templateMask.empty())
+    {
+        templtMask = Mat::ones(hs, ws, CV_8U);
+    }
+    else
+    {
+        threshold(templateMask, templtMask, 0, 1, THRESH_BINARY);
+        templtMask.convertTo(templtMask, CV_32F);
+        GaussianBlur(templtMask, templtMask, Size(gaussFiltSize, gaussFiltSize), 0, 0);
+        templtMask *= (0.5/0.95);
+        templtMask.convertTo(templtMask, CV_8U);
+    }
+
+    //to use it for mask warping
+    Mat preMask;
+    if(inputMask.empty())
+    {
+        preMask = Mat::ones(hd, wd, CV_8U);
+    }
+    else
+    {
+        Mat preMaskFloat;
+        threshold(inputMask, preMask, 0, 1, THRESH_BINARY);
+
+        preMask.convertTo(preMaskFloat, CV_32F);
+        GaussianBlur(preMaskFloat, preMaskFloat, Size(gaussFiltSize, gaussFiltSize), 0, 0);
+        // Change threshold.
+        preMaskFloat *= (0.5/0.95);
+        // Rounding conversion.
+        preMaskFloat.convertTo(preMask, CV_8U);
+
+        // If there's no template mask, we can apply image masks to gradients only once.
+        // Otherwise, we'll need to combine the template and image masks at each iteration.
+        if (templateMask.empty())
+        {
+            cv::Mat zeroMask = (preMask == 0);
+            gradientX.setTo(0, zeroMask);
+            gradientY.setTo(0, zeroMask);
+        }
+    }
+
+    // matrices needed for solving linear equation system for maximizing ECC
+    Mat jacobian = Mat(hs, ws * numberOfParameters, type);
+    Mat hessian = Mat(numberOfParameters, numberOfParameters, CV_32F);
+    Mat hessianInv = Mat(numberOfParameters, numberOfParameters, CV_32F);
+    Mat imageProjection = Mat(numberOfParameters, 1, CV_32F);
+    Mat templateProjection = Mat(numberOfParameters, 1, CV_32F);
+    Mat imageProjectionHessian = Mat(numberOfParameters, 1, CV_32F);
+    Mat errorProjection = Mat(numberOfParameters, 1, CV_32F);
+
+    Mat deltaP = Mat(numberOfParameters, 1, CV_32F);  // transformation parameter correction
+    Mat error = Mat(hs, ws, CV_32F);                  // error as 2D matrix
+
+    const int imageFlags = INTER_LINEAR + WARP_INVERSE_MAP;
+    const int maskFlags = INTER_NEAREST + WARP_INVERSE_MAP;
+
+    // iteratively update map_matrix
+    double rho = -1;
+    double last_rho = -termination_eps;
+    for (int i = 1; (i <= numberOfIterations) && (fabs(rho - last_rho) >= termination_eps); i++) {
+        // warp-back portion of the inputImage and gradients to the coordinate space of the templateImage
+        if (motionType != MOTION_HOMOGRAPHY) {
+            warpAffine(imageFloat, imageWarped, map, imageWarped.size(), imageFlags);
+            warpAffine(gradientX, gradientXWarped, map, gradientXWarped.size(), imageFlags);
+            warpAffine(gradientY, gradientYWarped, map, gradientYWarped.size(), imageFlags);
+            warpAffine(preMask, imageMask, map, imageMask.size(), maskFlags);
+        } else {
+            warpPerspective(imageFloat, imageWarped, map, imageWarped.size(), imageFlags);
+            warpPerspective(gradientX, gradientXWarped, map, gradientXWarped.size(), imageFlags);
+            warpPerspective(gradientY, gradientYWarped, map, gradientYWarped.size(), imageFlags);
+            warpPerspective(preMask, imageMask, map, imageMask.size(), maskFlags);
+        }
+
+        if (!templateMask.empty())
+        {
+            cv::bitwise_and(imageMask, templtMask, imageMask);
+
+            cv::Mat zeroMask = (imageMask == 0);
+            gradientXWarped.setTo(0, zeroMask);
+            gradientYWarped.setTo(0, zeroMask);
+        }
+
+        Scalar imgMean, imgStd, tmpMean, tmpStd;
+        meanStdDev(imageWarped, imgMean, imgStd, imageMask);
+        meanStdDev(templateFloat, tmpMean, tmpStd, imageMask);
+
+        subtract(imageWarped, imgMean, imageWarped, imageMask);  // zero-mean input
+        templateZM = Mat::zeros(templateZM.rows, templateZM.cols, templateZM.type());
+        subtract(templateFloat, tmpMean, templateZM, imageMask);  // zero-mean template
+
+        int validPixels = countNonZero(imageMask);
+        double tmpNorm = std::sqrt(validPixels * cv::norm(tmpStd, cv::NORM_L2SQR));
+        double imgNorm = std::sqrt(validPixels * cv::norm(imgStd, cv::NORM_L2SQR));
+
+        // calculate jacobian of image wrt parameters
+        switch (motionType) {
+            case MOTION_AFFINE:
+                image_jacobian_affine_ECC(gradientXWarped, gradientYWarped, Xgrid, Ygrid, jacobian);
+                break;
+            case MOTION_HOMOGRAPHY:
+                image_jacobian_homo_ECC(gradientXWarped, gradientYWarped, Xgrid, Ygrid, map, jacobian);
+                break;
+            case MOTION_TRANSLATION:
+                image_jacobian_translation_ECC(gradientXWarped, gradientYWarped, jacobian);
+                break;
+            case MOTION_EUCLIDEAN:
+                image_jacobian_euclidean_ECC(gradientXWarped, gradientYWarped, Xgrid, Ygrid, map, jacobian);
+                break;
+        }
+
+        // calculate Hessian and its inverse
+        project_onto_jacobian_ECC(jacobian, jacobian, hessian);
+
+        hessianInv = hessian.inv();
+
+        const double correlation = templateZM.dot(imageWarped);
+
+        // calculate enhanced correlation coefficient (ECC)->rho
+        last_rho = rho;
+        rho = correlation / (imgNorm * tmpNorm);
+        if (cvIsNaN(rho)) {
+            CV_Error(Error::StsNoConv, "NaN encountered.");
+        }
+
+        // project images into jacobian
+        project_onto_jacobian_ECC(jacobian, imageWarped, imageProjection);
+        project_onto_jacobian_ECC(jacobian, templateZM, templateProjection);
+
+        // calculate the parameter lambda to account for illumination variation
+        imageProjectionHessian = hessianInv * imageProjection;
+        const double lambda_n = (imgNorm * imgNorm) - imageProjection.dot(imageProjectionHessian);
+        const double lambda_d = correlation - templateProjection.dot(imageProjectionHessian);
+        if (lambda_d <= 0.0) {
+            rho = -1;
+            CV_Error(Error::StsNoConv,
+                     "The algorithm stopped before its convergence. The correlation is going to be minimized. Images "
+                     "may be uncorrelated or non-overlapped");
+        }
+        const double lambda = (lambda_n / lambda_d);
+
+        // estimate the update step delta_p
+        error = lambda * templateZM - imageWarped;
+        project_onto_jacobian_ECC(jacobian, error, errorProjection);
+        deltaP = hessianInv * errorProjection;
+
+        // update warping matrix
+        update_warping_matrix_ECC(map, deltaP, motionType);
+    }
+
+    // return final correlation coefficient
+    return rho;
+}
+
+double cv::findTransformECC(InputArray templateImage,
+                            InputArray inputImage,
+                            InputOutputArray warpMatrix,
+                            int motionType,
+                            TermCriteria criteria,
+                            InputArray inputMask,
+                            int gaussFiltSize
+                            ) {
+    return findTransformECCWithMask(templateImage, inputImage, noArray(), inputMask,
+            warpMatrix, motionType, criteria, gaussFiltSize);
+}
+
+double cv::findTransformECC(InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix,
+                            int motionType, TermCriteria criteria, InputArray inputMask) {
+    // Use default value of 5 for gaussFiltSize to maintain backward compatibility.
+    return findTransformECC(templateImage, inputImage, warpMatrix, motionType, criteria, inputMask, 5);
+}
+
+/* End of file. */
diff --git a/upstream/opencv/modules/video/src/eccms.cpp b/upstream/opencv/modules/video/src/eccms.cpp
new file mode 100644
index 0000000..97557bd
--- /dev/null
+++ b/upstream/opencv/modules/video/src/eccms.cpp
@@ -0,0 +1,888 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+
+#include "precomp.hpp"
+
+/****************************************************************************************\
+*                    Image Alignment (ECC algorithm, pyramidal version)                  *
+\****************************************************************************************/
+
+namespace cv {
+ECCParameters::ECCParameters() : criteria(TermCriteria::COUNT + TermCriteria::EPS, 50, 1e-6)
+{}
+
+typedef std::vector<cv::Mat> MatPyramid;
+
+template<int motionType> struct MotionTraits {};
+
+template<> struct MotionTraits<MOTION_TRANSLATION> {
+    enum { paramAmount = 2 };
+    static inline void tailHandlerGetCoord(float& sx,
+                                              float& sy,
+                                              float& denominator,
+                                              int col,
+                                              float numeratorX0,
+                                              float numeratorY0,
+                                              float /*denominator0*/,
+                                              float /*a00*/,
+                                              float /*a10*/,
+                                              float /*a20*/)
+    {
+        denominator = 0;
+        sx = (numeratorX0 + col);
+        sy = numeratorY0;
+    }
+    template<typename elemtype>
+    static constexpr std::array<float, paramAmount> fillJacobian(int /*col*/, int /*row*/, float/*sx*/, float/*sy*/, float fVal,
+                                                     elemtype gx, elemtype gy, float /*a00*/, float /*a10*/,
+                                                     float/*denominator*/) {
+#define GX (fVal * gx)
+#define GY (fVal * gy)
+        return std::array<float, paramAmount>{GX, GY};
+#undef GX
+#undef GY
+    }
+};
+
+template<> struct MotionTraits<MOTION_EUCLIDEAN> {
+    enum { paramAmount = 3 };
+    static inline void tailHandlerGetCoord(float& sx,
+                                              float& sy,
+                                              float& denominator,
+                                              int col,
+                                              float numeratorX0,
+                                              float numeratorY0,
+                                              float /*denominator0*/,
+                                              float a00,
+                                              float a10,
+                                              float /*a20*/)
+    {
+        denominator = 0;
+        sx = (numeratorX0 + a00 * col);
+        sy = (numeratorY0 + a10 * col);
+    }
+
+    template<typename elemtype>
+    static constexpr std::array<float, paramAmount> fillJacobian(int col, int row, float/*sx*/, float/*sy*/, float fVal,
+                                                     elemtype gx, elemtype gy, float a00, float a10,
+                                                     float/*denominator*/) {
+#define GX (fVal * gx)
+#define GY (fVal * gy)
+#define HATX (-col * a10 - row * a00)
+#define HATY (col * a00 - row * a10)
+#define GZ (GX * HATX + GY * HATY)
+        return std::array<float, paramAmount>{GZ, GX, GY};
+#undef GX
+#undef GY
+#undef HATX
+#undef HATY
+#undef GZ
+    }
+};
+
+template<> struct MotionTraits<MOTION_AFFINE> {
+    enum { paramAmount = 6};
+    static inline void tailHandlerGetCoord(float& sx,
+                                              float& sy,
+                                              float& denominator,
+                                              int col,
+                                              float numeratorX0,
+                                              float numeratorY0,
+                                              float /*denominator0*/,
+                                              float a00,
+                                              float a10,
+                                              float /*a20*/)
+    {
+        denominator = 0;
+        sx = (numeratorX0 + a00 * col);
+        sy = (numeratorY0 + a10 * col);
+    }
+
+    template<typename elemtype>
+    static constexpr std::array<float, paramAmount> fillJacobian(int col, int row, float/*sx*/, float/*sy*/, float fVal,
+                                                     elemtype gx, elemtype gy, float /*a00*/, float /*a10*/,
+                                                     float/*denominator*/) {
+#define GX (fVal * gx)
+#define GY (fVal * gy)
+        return std::array<float, paramAmount>{GX * col, GY * col, GX * row, GY * row, GX, GY};
+#undef GX
+#undef GY
+    }
+};
+
+template<> struct MotionTraits<MOTION_HOMOGRAPHY> {
+    enum { paramAmount = 8};
+    static inline void tailHandlerGetCoord(float& sx,
+                                              float& sy,
+                                              float& denominator,
+                                              int col,
+                                              float numeratorX0,
+                                              float numeratorY0,
+                                              float denominator0,
+                                              float a00,
+                                              float a10,
+                                              float a20)
+    {
+        denominator = 1.f / (col * a20 + denominator0);
+        sx = (numeratorX0 + a00 * col) * denominator;
+        sy = (numeratorY0 + a10 * col) * denominator;
+    }
+
+    template<typename elemtype>
+    static constexpr std::array<float, paramAmount> fillJacobian(int col, int row, float sx, float sy, float fVal,
+                                                     elemtype gx, elemtype gy, float/*a00*/, float/*a10*/,
+                                                     float denominator) {
+#define GX (fVal * float(gx) * denominator)
+#define GY (fVal * float(gy) * denominator)
+#define GZ (-(GX * sx + GY * sy))
+        return std::array<float, paramAmount>{GX * col, GY * col, GZ * col, GX * row, GY * row, GZ * row, GX, GY};
+#undef GX
+#undef GY
+#undef GZ
+    }
+};
+
+inline void reinterpret(Mat& mat, int newdepth) {
+    mat.flags = (mat.flags & ~CV_MAT_DEPTH_MASK) | newdepth;
+}
+
+template<int N, class F>
+class constexprForClass
+{
+public:
+    static inline void execute(F&& fVal) {
+        constexprForClass<N-1, F>::execute(std::forward<F>(fVal));
+        fVal(N-1);
+    }
+};
+
+template<class F>
+class constexprForClass<0, F>
+{
+public:
+    static inline void execute(F&&) {}
+};
+
+template<int N, class F>
+void constexprFor(F&& fVal) {
+    constexprForClass<N, F>::execute(std::forward<F>(fVal));
+}
+template<int R, int C, class F>
+class constexprForUpperTriangleClassOneRow
+{
+public:
+    static inline void execute(F&& fVal) {
+        constexprForUpperTriangleClassOneRow<R, C-1, F>::execute(std::forward<F>(fVal));
+        fVal(R, R + C - 1);
+    }
+};
+
+template<int R, class F>
+class constexprForUpperTriangleClassOneRow<R, 0, F>
+{
+public:
+    static inline void execute(F&&) {}
+};
+
+template<int R, int D, class F>
+class constexprForUpperTriangleClass
+{
+public:
+    static inline void execute(F&& fVal) {
+        constexprForUpperTriangleClass<R-1, D, F>::execute(std::forward<F>(fVal));
+        constexprForUpperTriangleClassOneRow<R-1, D-R+1, F>::execute(std::forward<F>(fVal));
+    }
+};
+
+template<int D, class F>
+class constexprForUpperTriangleClass<0, D, F>
+{
+public:
+    static inline void execute(F&&) {}
+};
+
+template<int M, class F>
+void constexprForUpperTriangle(F&& fVal) {
+    constexprForUpperTriangleClass<M,M,F>::execute(std::forward<F>(fVal));
+}
+
+template<int MotionType>
+constexpr int hessianRowStart(int row) {
+    return row == 0 ? 0 : (MotionTraits<MotionType>::paramAmount - row + 1 + hessianRowStart<MotionType>(row - 1));
+}
+
+template<int motionType, typename elemtype>
+static double imageHessianProjECC(const Mat& map,
+                           const Mat& sampleWithGrad,
+                           const Mat& ref,
+                           double& sampSum,
+                           double& sampSqSum,
+                           double& refSum,
+                           double& refSqSum,
+                           int& nz,
+                           Mat& hessian,
+                           Mat& sampleProj,
+                           Mat& refProj,
+                           int deltaY,
+                           int interpolation) {
+    static_assert(std::is_same<float, elemtype>::value, "imageHessianProjECC: f16 is not supported yet");
+#define HESSIAN_PARAMS (MotionTraits<motionType>::paramAmount)
+
+    CV_Assert(map.type() == CV_64F);
+    CV_Assert(interpolation == INTER_NEAREST || interpolation == INTER_LINEAR);
+    CV_Assert(hessian.type() == CV_64F && sampleProj.type() == CV_64F && refProj.type() == CV_64F);
+    if (sampleProj.size() != Size(1, HESSIAN_PARAMS) || refProj.size() != Size(1, HESSIAN_PARAMS)) {
+        CV_Error(Error::BadImageSize, format("imageHessianProjECC: Wrong sample projection/reference projection size. 1x%d expected", HESSIAN_PARAMS));
+    }
+    if (hessian.size() != Size(HESSIAN_PARAMS, HESSIAN_PARAMS)) {
+        CV_Error(Error::BadImageSize, format("imageHessianProjECC: Wrong hessian size. %dx%d expected", HESSIAN_PARAMS, HESSIAN_PARAMS));
+    }
+    if (!map.isContinuous()) {
+        CV_Error(Error::BadStep, "imageHessianProjECC: Map should be continuous");
+    }
+    if (std::is_same<float, elemtype>::value) {
+        CV_Assert(sampleWithGrad.type() == CV_32FC4 && ref.type() == CV_32FC2);
+    }
+
+    int hr = ref.rows;
+    int wr = ref.cols;
+    int hs = sampleWithGrad.rows;
+    int ws = sampleWithGrad.cols;
+    unsigned int ycond = hs - (INTER_LINEAR ? 1 : 0);
+    unsigned int xcond = ws - (INTER_LINEAR ? 1 : 0);
+
+    hessian = Mat::zeros(hessian.size(), hessian.type());
+    sampleProj = Mat::zeros(sampleProj.size(), sampleProj.type());
+    refProj = Mat::zeros(refProj.size(), refProj.type());
+
+    const int MAX_STRIPES = 128;
+    int stripesAmount = std::min(MAX_STRIPES, hr / deltaY);
+    std::vector<Matx<double, MotionTraits<motionType>::paramAmount, MotionTraits<motionType>::paramAmount> > hessPs(stripesAmount);
+    std::vector<Vec<double, MotionTraits<motionType>::paramAmount> > iprojs(stripesAmount);
+    std::vector<Vec<double, MotionTraits<motionType>::paramAmount> > tprojs(stripesAmount);
+    std::vector<Vec<double, MotionTraits<motionType>::paramAmount> > projSubs(stripesAmount);
+    std::vector<double> correlations(stripesAmount, 0.);
+
+    std::vector<double> sampSums(stripesAmount, 0);
+    std::vector<double> sampSqSums(stripesAmount, 0);
+    std::vector<double> refSums(stripesAmount, 0);
+    std::vector<double> refSqSums(stripesAmount, 0);
+    std::vector<int> nzs(stripesAmount, 0);
+    std::vector<double> sampMaskedSums(stripesAmount, 0);
+    std::vector<double> refMaskedSums(stripesAmount, 0);
+
+    double a00 = map.at<double>(0, 0);
+    double a01 = map.at<double>(0, 1);
+    double a02 = map.at<double>(0, 2);
+    double a10 = map.at<double>(1, 0);
+    double a11 = map.at<double>(1, 1);
+    double a12 = map.at<double>(1, 2);
+    double a20 = 0;
+    double a21 = 0;
+    double a22 = 0;
+    if (motionType == MOTION_HOMOGRAPHY) {
+        a20 = map.at<double>(2, 0);
+        a21 = map.at<double>(2, 1);
+        a22 = map.at<double>(2, 2);
+    }
+
+    const elemtype* samplePtr0 = sampleWithGrad.ptr<elemtype>(0);
+
+    parallel_for_(Range(0, stripesAmount), [&](const Range& range) {
+        int stripeIdx = range.start;
+        int ystart = (hr * stripeIdx) / stripesAmount;
+        ystart = roundUp(ystart, deltaY);
+        int yend = (hr * (range.end)) / stripesAmount;
+        // we don't store intermediate jacobian; instead, we iteratively update Hessian, sampleProj and refProj
+        for (int y = ystart; y < yend; y += deltaY) {
+            const elemtype* refPtr = ref.ptr<elemtype>(y);
+
+            std::array<float, (HESSIAN_PARAMS * HESSIAN_PARAMS + HESSIAN_PARAMS) / 2> hessPcache{};
+            std::array<float, HESSIAN_PARAMS> iprojCache{};
+            std::array<float, HESSIAN_PARAMS> tprojCache{};
+            std::array<float, HESSIAN_PARAMS> projSubCache{};
+
+            const float numeratorX0 = y * (float)a01 + (float)a02;
+            const float numeratorY0 = y * (float)a11 + (float)a12;
+            const float denominator0 = y * (float)a21 + (float)a22;
+            int x = 0;
+            for (; x < wr; x++) { //Tail handler
+                float sx, sy, denominator;
+                MotionTraits<motionType>::tailHandlerGetCoord(sx, sy, denominator, x, numeratorX0, numeratorY0,
+                                                denominator0, (float)a00, (float)a10, (float)a20);
+                const unsigned int x0 = (interpolation == INTER_LINEAR) ? static_cast<int>(std::floor(sx)) : saturate_cast<unsigned>(sx);
+                const unsigned int y0 = (interpolation == INTER_LINEAR) ? static_cast<int>(std::floor(sy)) : saturate_cast<unsigned>(sy);
+                if(interpolation == INTER_LINEAR && (static_cast<int>(x0 < xcond) & static_cast<int>(y0 < ycond)) == 0)
+                    continue;
+                if (interpolation == INTER_NEAREST && (static_cast<int>(x0 < xcond) & static_cast<int>(y0 < ycond)) == 0)
+                    continue;
+                float sampleVal = 0;
+                float gx = 0;
+                float gy = 0;
+                float fVal = 0;
+                if(interpolation == INTER_LINEAR) {
+                    const int x1 = x0 + 1;
+                    const int y1 = y0 + 1;
+
+                    const float dx = sx - x0;
+                    const float dy = sy - y0;
+
+                    const float p00_val = samplePtr0[4 * y0 * ws + 4 * x0];
+                    const float p01_val = samplePtr0[4 * y0 * ws + 4 * x1];
+                    const float p10_val = samplePtr0[4 * y1 * ws + 4 * x0];
+                    const float p11_val = samplePtr0[4 * y1 * ws + 4 * x1];
+                    const float p0_val = p00_val * (1.0f - dx) + p01_val * dx;
+                    const float p1_val = p10_val * (1.0f - dx) + p11_val * dx;
+
+                    const float p00_gx = samplePtr0[4 * y0 * ws + 4 * x0 + 1];
+                    const float p01_gx = samplePtr0[4 * y0 * ws + 4 * x1 + 1];
+                    const float p10_gx = samplePtr0[4 * y1 * ws + 4 * x0 + 1];
+                    const float p11_gx = samplePtr0[4 * y1 * ws + 4 * x1 + 1];
+                    const float p0_gx = p00_gx * (1.0f - dx) + p01_gx * dx;
+                    const float p1_gx = p10_gx * (1.0f - dx) + p11_gx * dx;
+
+                    const float p00_gy = samplePtr0[4 * y0 * ws + 4 * x0 + 2];
+                    const float p01_gy = samplePtr0[4 * y0 * ws + 4 * x1 + 2];
+                    const float p10_gy = samplePtr0[4 * y1 * ws + 4 * x0 + 2];
+                    const float p11_gy = samplePtr0[4 * y1 * ws + 4 * x1 + 2];
+                    const float p0_gy = p00_gy * (1.0f - dx) + p01_gy * dx;
+                    const float p1_gy = p10_gy * (1.0f - dx) + p11_gy * dx;
+
+                    const float p00_mask = samplePtr0[4 * y0 * ws + 4 * x0 + 2] == 0.f ? 0.f : 1.f;
+                    const float p01_mask = samplePtr0[4 * y0 * ws + 4 * x1 + 2] == 0.f ? 0.f : 1.f;
+                    const float p10_mask = samplePtr0[4 * y1 * ws + 4 * x0 + 2] == 0.f ? 0.f : 1.f;
+                    const float p11_mask = samplePtr0[4 * y1 * ws + 4 * x1 + 2] == 0.f ? 0.f : 1.f;
+
+                    sampleVal = p0_val * (1.0f - dy) + p1_val * dy;
+                    gx = p0_gx * (1.0f - dy) + p1_gx * dy;
+                    gy = p0_gy * (1.0f - dy) + p1_gy * dy;
+                    fVal = p00_mask * p01_mask * p10_mask * p11_mask;
+                }
+                else { // if(interpolation == INTER_NEAREST)
+                    const elemtype* samplePtr = samplePtr0 + y0 * (ws * 4) + x0 * 4;
+                    sampleVal = samplePtr[0];
+                    gx = samplePtr[1];
+                    gy = samplePtr[2];
+                    fVal = float(samplePtr[3]) == 0.f ? 0.f : 1.f;
+                }
+
+                float refVal = refPtr[2 * x];
+                fVal *= float(refPtr[2 * x + 1]) == 0.f ? 0.f : 1.f;
+                sampleVal *= fVal;
+                refVal *= fVal;
+                sampSums[stripeIdx] += sampleVal;
+                sampSqSums[stripeIdx] += sampleVal * sampleVal;
+                refSums[stripeIdx] += refVal;
+                refSqSums[stripeIdx] += refVal * refVal;
+                nzs[stripeIdx] += (int)fVal;
+                sampMaskedSums[stripeIdx] += sampleVal;
+                refMaskedSums[stripeIdx] += refVal;
+                std::array<float, HESSIAN_PARAMS> jac = MotionTraits<motionType>::fillJacobian(x, y, sx, sy,
+                                                                                        fVal, gx,
+                                                                                        gy, (float)a00,
+                                                                                        (float)a10, denominator);
+                constexprForUpperTriangle<HESSIAN_PARAMS>([&](int row_i, int col_i) {
+                    hessPcache[hessianRowStart<motionType>(row_i) + (col_i - row_i)] += jac[row_i] * jac[col_i];
+                });
+                constexprFor<HESSIAN_PARAMS>([&](int elem) {
+                    iprojCache[elem] += jac[elem] * sampleVal;
+                    tprojCache[elem] += jac[elem] * refVal;
+                    projSubCache[elem] += jac[elem] * fVal;
+                });
+                correlations[stripeIdx] += sampleVal * refVal;
+            }
+
+            constexprForUpperTriangle<HESSIAN_PARAMS>([&](int row, int col) {
+                hessPs[stripeIdx](row, col) += hessPcache[hessianRowStart<motionType>(row) + (col - row)];
+            });
+            constexprFor<HESSIAN_PARAMS>([&](int elem) {
+                iprojs[stripeIdx][elem] += iprojCache[elem];
+                tprojs[stripeIdx][elem] += tprojCache[elem];
+                projSubs[stripeIdx][elem] += projSubCache[elem];
+            });
+        }
+    });
+    double sampMaskedSum = 0;
+    double refMaskedSum = 0;
+    double correlation = 0;
+    sampSum = sampSqSum = refSum = refSqSum = nz = 0;
+
+    for (int stripeIdx = 0; stripeIdx < stripesAmount; stripeIdx++) {
+        correlation += correlations[stripeIdx];
+        sampSum += sampSums[stripeIdx];
+        sampSqSum += sampSqSums[stripeIdx];
+        refSum += refSums[stripeIdx];
+        refSqSum += refSqSums[stripeIdx];
+        sampMaskedSum += sampMaskedSums[stripeIdx];
+        refMaskedSum += refMaskedSums[stripeIdx];
+        nz += nzs[stripeIdx];
+    }
+    double scale = nz == 0 ? 0. : 1. / nz;
+    double sampMean = sampSum * scale;
+    double refMean = refSum * scale;
+    correlation += nz * sampMean * refMean - sampMaskedSum * refMean - refMaskedSum * sampMean;
+    double* hessPtr = hessian.ptr<double>(0);
+    double* sampleProjPtr = sampleProj.ptr<double>(0);
+    double* refProjPtr = refProj.ptr<double>(0);
+    for (int stripeIdx = 0; stripeIdx < stripesAmount; stripeIdx++) {
+        for (int hessNum = 0; hessNum < HESSIAN_PARAMS * HESSIAN_PARAMS; hessNum++) {
+            hessPtr[hessNum] += hessPs[stripeIdx].val[hessNum];
+        }
+        for (int projNum = 0; projNum < HESSIAN_PARAMS; projNum++) {
+            sampleProjPtr[projNum] += iprojs[stripeIdx][projNum] - projSubs[stripeIdx][projNum] * sampMean;
+            refProjPtr[projNum] += tprojs[stripeIdx][projNum] - projSubs[stripeIdx][projNum] * refMean;
+        }
+    }
+    constexprForUpperTriangle<HESSIAN_PARAMS>([&](int row, int col) {
+        hessPtr[col * HESSIAN_PARAMS + row] = hessPtr[row * HESSIAN_PARAMS + col];
+    });
+    return correlation;
+#undef HESSIAN_PARAMS
+}
+
+static void updateWarpingMatrixECC(Mat& map_matrix, const Mat& update, const int motionType) {
+    CV_Assert(map_matrix.type() == CV_64FC1);
+    CV_Assert(update.type() == CV_64FC1);
+
+    CV_Assert(motionType == MOTION_TRANSLATION || motionType == MOTION_EUCLIDEAN || motionType == MOTION_AFFINE ||
+              motionType == MOTION_HOMOGRAPHY);
+
+    if (motionType == MOTION_HOMOGRAPHY)
+        CV_Assert(map_matrix.rows == 3 && update.rows == 8);
+    else if (motionType == MOTION_AFFINE)
+        CV_Assert(map_matrix.rows == 2 && update.rows == 6);
+    else if (motionType == MOTION_EUCLIDEAN)
+        CV_Assert(map_matrix.rows == 2 && update.rows == 3);
+    else
+        CV_Assert(map_matrix.rows == 2 && update.rows == 2);
+
+    CV_Assert(update.cols == 1);
+
+    CV_Assert(map_matrix.isContinuous());
+    CV_Assert(update.isContinuous());
+
+    double* mapPtr = map_matrix.ptr<double>(0);
+    const double* updatePtr = update.ptr<double>(0);
+
+    if (motionType == MOTION_TRANSLATION) {
+        mapPtr[2] += updatePtr[0];
+        mapPtr[5] += updatePtr[1];
+    }
+    if (motionType == MOTION_AFFINE) {
+        mapPtr[0] += updatePtr[0];
+        mapPtr[3] += updatePtr[1];
+        mapPtr[1] += updatePtr[2];
+        mapPtr[4] += updatePtr[3];
+        mapPtr[2] += updatePtr[4];
+        mapPtr[5] += updatePtr[5];
+    }
+    if (motionType == MOTION_HOMOGRAPHY) {
+        mapPtr[0] += updatePtr[0];
+        mapPtr[3] += updatePtr[1];
+        mapPtr[6] += updatePtr[2];
+        mapPtr[1] += updatePtr[3];
+        mapPtr[4] += updatePtr[4];
+        mapPtr[7] += updatePtr[5];
+        mapPtr[2] += updatePtr[6];
+        mapPtr[5] += updatePtr[7];
+    }
+    if (motionType == MOTION_EUCLIDEAN) {
+        double new_theta = updatePtr[0];
+        new_theta += asin(mapPtr[3]);
+
+        mapPtr[2] += updatePtr[1];
+        mapPtr[5] += updatePtr[2];
+        mapPtr[0] = mapPtr[4] = cos(new_theta);
+        mapPtr[3] = sin(new_theta);
+        mapPtr[1] = -mapPtr[3];
+    }
+}
+
+static void optimizeECC(Mat& sampleWithGrad,
+                 const Mat& reference,
+                 Mat& map,
+                 int motionType,
+                 double* rho,
+                 double* lastRho,
+                 int deltaY,
+                 int nparams,
+                 int interpolation) {
+    CV_Assert(interpolation == INTER_NEAREST || interpolation == INTER_LINEAR);
+
+    // warp-back portion of the inputImage and gradients to the coordinate space of the referenceFloat
+    double correlation = 0;
+
+    // matrices needed for solving linear equation system for maximizing ECC
+    Mat hessian = Mat(nparams, nparams, CV_64F);
+    Mat hessianInv = Mat(nparams, nparams, CV_64F);
+    Mat sampleProjection = Mat(nparams, 1, CV_64F);
+    Mat referenceProjection = Mat(nparams, 1, CV_64F);
+    Mat sampleProjectionHessian = Mat(nparams, 1, CV_64F);
+    Mat errorProjection = Mat(nparams, 1, CV_64F);
+    Mat deltaP = Mat(nparams, 1, CV_64F);
+
+    double sampSum;
+    double sampSqSum;
+    double referenceSum;
+    double referenceSqSum;
+    int nz;
+
+    {  // if(imageWithGrad.type() == CV_32FC4)
+        if (motionType == MOTION_TRANSLATION) {
+            correlation = imageHessianProjECC<MOTION_TRANSLATION, float>(map,
+                                                                       sampleWithGrad,
+                                                                       reference,
+                                                                       sampSum,
+                                                                       sampSqSum,
+                                                                       referenceSum,
+                                                                       referenceSqSum,
+                                                                       nz,
+                                                                       hessian,
+                                                                       sampleProjection,
+                                                                       referenceProjection,
+                                                                       deltaY,
+                                                                       interpolation);
+        } else if (motionType == MOTION_EUCLIDEAN) {
+            correlation = imageHessianProjECC<MOTION_EUCLIDEAN, float>(map,
+                                                                       sampleWithGrad,
+                                                                       reference,
+                                                                       sampSum,
+                                                                       sampSqSum,
+                                                                       referenceSum,
+                                                                       referenceSqSum,
+                                                                       nz,
+                                                                       hessian,
+                                                                       sampleProjection,
+                                                                       referenceProjection,
+                                                                       deltaY,
+                                                                       interpolation);
+        } else if (motionType == MOTION_AFFINE) {
+            correlation = imageHessianProjECC<MOTION_AFFINE, float>(map,
+                                                                       sampleWithGrad,
+                                                                       reference,
+                                                                       sampSum,
+                                                                       sampSqSum,
+                                                                       referenceSum,
+                                                                       referenceSqSum,
+                                                                       nz,
+                                                                       hessian,
+                                                                       sampleProjection,
+                                                                       referenceProjection,
+                                                                       deltaY,
+                                                                       interpolation);
+        } else {
+            correlation = imageHessianProjECC<MOTION_HOMOGRAPHY, float>(map,
+                                                                        sampleWithGrad,
+                                                                        reference,
+                                                                        sampSum,
+                                                                        sampSqSum,
+                                                                        referenceSum,
+                                                                        referenceSqSum,
+                                                                        nz,
+                                                                        hessian,
+                                                                        sampleProjection,
+                                                                        referenceProjection,
+                                                                        deltaY,
+                                                                        interpolation);
+        }
+    }
+    double scale = nz == 0 ? 0. : 1. / nz;
+    double sampMean = sampSum * scale;
+    double refMean = referenceSum * scale;
+    double sampStd = std::sqrt(std::max(sampSqSum * scale - sampMean * sampMean, 0.));
+    double refStd = std::sqrt(std::max(referenceSqSum * scale - refMean * refMean, 0.));
+
+    // inverse of Hessian
+    hessianInv = hessian.inv();
+    // calculate enhanced correlation coefficient (ECC)->rho
+    *lastRho = *rho;
+    double refNorm = std::sqrt(nz * refStd * refStd);
+    double sampNorm = std::sqrt(nz * sampStd * sampStd);
+
+    *rho = correlation / (sampNorm * refNorm);
+    if ((bool)cvIsNaN(*rho)) {
+        CV_Error(Error::StsNoConv, "NaN encountered.");
+    }
+
+    // calculate the parameter lambda to account for illumination variation
+    sampleProjectionHessian = hessianInv * sampleProjection;
+    const double lambdaN = (sampNorm * sampNorm) - sampleProjection.dot(sampleProjectionHessian);
+    const double lambdaD = correlation - referenceProjection.dot(sampleProjectionHessian);
+
+    if (lambdaD <= 0.0) {
+        CV_Error(Error::StsNoConv, "The algorithm stopped before its convergence. The correlation is going to be minimized. "
+            "Images may be uncorrelated or non-overlapped");
+    }
+    const double lambda = (lambdaN / lambdaD);
+
+    // estimate the update step delta_p
+    errorProjection = lambda * referenceProjection - sampleProjection;
+    gemm(hessianInv, errorProjection, 1., noArray(), 0., deltaP);
+
+    // update warping matrix
+    updateWarpingMatrixECC(map, deltaP, motionType);
+}
+
+static Mat prepareGradients(const Mat& sample) {
+    CV_Assert(sample.type() == CV_32FC2 || sample.type() == CV_16FC2);
+
+    const int ws = sample.cols;
+    const int hs = sample.rows;
+
+    Mat sampleWithGrad;
+    int ntasks = std::min(4, hs);
+
+    {
+        sampleWithGrad = Mat(hs, ws, CV_32FC4);
+        float* dstPtr = sampleWithGrad.ptr<float>();
+        parallel_for_(Range(0, ntasks), [&](const Range& range) {
+            int rowstart = range.start * hs / ntasks;
+            int rowend = range.end * hs / ntasks;
+            for (int row = rowstart; row < rowend; row++) {
+                const float* sampleCurLine = sample.ptr<float>(row);
+                const float* samplePrevLine = sample.ptr<float>(std::max(row - 1, 0));
+                const float* sampleNextLine = sample.ptr<float>(std::min(row + 1, hs - 1));
+                float gradDivY = (row > 0 && row + 1 < hs) ? 0.5f : 0.25f;
+                int col = 0;
+                for (; col < ws; col++) {
+                    int prevCol = std::max(col - 1, 0);
+                    int nextCol = std::min(col + 1, ws - 1);
+                    float gradDivX = (col > 0 && col + 1 < ws) ? 0.5f : 0.25f;
+                    dstPtr[row * ws * 4 + col * 4] = sampleCurLine[2 * col];
+                    dstPtr[row * ws * 4 + col * 4 + 1] =
+                        gradDivX * (sampleCurLine[2 * nextCol] - sampleCurLine[2 * prevCol]);
+                    dstPtr[row * ws * 4 + col * 4 + 2] = gradDivY * (sampleNextLine[2 * col] - samplePrevLine[2 * col]);
+                    dstPtr[row * ws * 4 + col * 4 + 3] = sampleCurLine[2 * col + 1];
+                }
+            }
+        }, ntasks);
+    }
+    return sampleWithGrad;
+}
+
+static void buildPyramidECC(InputArray inputImage,
+                  MatPyramid& imgPyramid,
+                  InputArray& mask,
+                  MatPyramid& maskPyramid,
+                  int nlevels) {
+    imgPyramid.resize(nlevels);
+    inputImage.getMat().convertTo(imgPyramid[0], CV_8UC1);
+    maskPyramid.resize(nlevels);
+    if (!mask.empty()) {
+        mask.getMat().convertTo(maskPyramid[0], CV_8UC1);
+    }
+    for (int pyrLevel = 0; pyrLevel < nlevels - 1; ++pyrLevel) {
+        Size size = Size((imgPyramid[pyrLevel].cols + 1) / 2, (imgPyramid[pyrLevel].rows + 1) / 2);
+        pyrDown(imgPyramid[pyrLevel], imgPyramid[pyrLevel + 1], size);
+        if (!mask.empty()) {
+            pyrDown(maskPyramid[pyrLevel], maskPyramid[pyrLevel + 1], size);
+            threshold(maskPyramid[pyrLevel + 1], maskPyramid[pyrLevel + 1], 254, 0xff, THRESH_BINARY);
+        }
+    }
+}
+
+static Mat spliceWithMask(const Mat& image, const Mat& mask) {
+    CV_Assert(image.type() == CV_32F && (mask.empty() || mask.type() == CV_8U));
+    if (!mask.empty() && image.size() != mask.size()) {
+        CV_Error(Error::BadImageSize, "spliceWithMask: Mask and image have to be of same size.");
+    }
+    const int hs = image.rows;
+    const int ws = image.cols;
+
+    Mat result;
+    int ntasks = std::min(4, hs);
+    {
+        union conv_ {
+            uint32_t valU;
+            float val;
+            conv_() : valU(0xffffffff) {}
+        } conv;
+        result = Mat(hs, ws, CV_32FC2);
+        parallel_for_(Range(0, ntasks), [&](const Range& range) {
+            int rowstart = range.start * hs / ntasks;
+            int rowend = range.end * hs / ntasks;
+            for (int row = rowstart; row < rowend; row++) {
+                float* dstPtr = result.ptr<float>(row);
+                const float* srcPtr = image.ptr<float>(row);
+                const uint8_t* maskPtr = !mask.empty() ? mask.ptr<uint8_t>(row) : nullptr;
+                int col = 0;
+                for (; col < ws; col++) {
+                    dstPtr[col * 2] = srcPtr[col];
+                    dstPtr[col * 2 + 1] = (!maskPtr || maskPtr[col]) ? conv.val : 0;
+                }
+            }
+        }, ntasks);
+    }
+    return result;
+}
+
+static void scaleWarpMatrix(Mat& warpMatrix, float scale) {
+    if (warpMatrix.rows == 3) {
+        Mat invertScaleMat = Mat(3, 3, CV_64F, 0.f);
+        invertScaleMat.at<double>(0, 0) = 1.f / scale;
+        invertScaleMat.at<double>(1, 1) = 1.f / scale;
+        invertScaleMat.at<double>(2, 2) = 1.f;
+        Mat scaleMatrix = invertScaleMat.clone();
+        scaleMatrix.at<double>(0, 0) = scale;
+        scaleMatrix.at<double>(1, 1) = scale;
+        gemm(warpMatrix, invertScaleMat, 1., noArray(), 0., warpMatrix);
+        gemm(scaleMatrix, warpMatrix, 1., noArray(), 0., warpMatrix);
+        // Normalization, internal algorithms assumes, that a22 = 1.0f
+        for (int mel = 0; mel < 8; mel++) {
+            (reinterpret_cast<double*>(warpMatrix.data))[mel] /=
+                (reinterpret_cast<double*>(warpMatrix.data))[8];
+        }
+        (reinterpret_cast<double*>(warpMatrix.data))[8] = 1.f;
+    } else {
+        warpMatrix.at<double>(0, 2) *= scale;
+        warpMatrix.at<double>(1, 2) *= scale;
+    }
+}
+
+static void checkParams(const MatPyramid& referencePyramid,
+                 const MatPyramid& samplePyramid,
+                 Mat& map,
+                 std::vector<int>& itersPerLevel,
+                 const ECCParameters& eccParams) {
+    if (itersPerLevel.empty()) {
+        itersPerLevel.resize(eccParams.nlevels, eccParams.criteria.maxCount);
+    }
+    CV_Assert(eccParams.interpolation == INTER_NEAREST || eccParams.interpolation == INTER_LINEAR);
+    CV_Assert(static_cast<int>(itersPerLevel.size()) == eccParams.nlevels);
+    for (const auto& lvl : referencePyramid) {
+        CV_Assert(!lvl.empty() && lvl.type() == referencePyramid[0].type());
+    }
+    CV_Assert(!samplePyramid.empty());
+    for (const auto& lvl : samplePyramid) {
+        CV_Assert(!lvl.empty() && lvl.type() == samplePyramid[0].type());
+    }
+    CV_Assert(samplePyramid.size() == referencePyramid.size() && samplePyramid.size() == itersPerLevel.size());
+    CV_Assert(referencePyramid.back().rows > 1 && referencePyramid.back().cols > 1 &&
+              samplePyramid.back().rows > 1 && samplePyramid.back().cols > 1);
+    // If the user passed an un-initialized warpMatrix, initialize to identity
+    if (referencePyramid[0].type() != CV_32FC2 && referencePyramid[0].type() != CV_16FC2) {
+        CV_Error(Error::StsError, "Reference pyramid have to be prepared via prepareReferencePyramid function");
+    }
+    // accept only 1-channel images
+    CV_Assert(samplePyramid[0].type() == CV_32FC2 || samplePyramid[0].type() != CV_16FC2);
+    CV_Assert(map.type() == CV_64FC1);
+    if (map.cols != 3 || (map.rows != 2 && map.rows != 3)) {
+        CV_Error(Error::BadImageSize, "warpMatrix has incorrect size");
+    }
+
+    if (eccParams.motionType != MOTION_TRANSLATION && eccParams.motionType != MOTION_EUCLIDEAN &&
+        eccParams.motionType != MOTION_AFFINE && eccParams.motionType != MOTION_HOMOGRAPHY) {
+        CV_Error(Error::StsError, "Incorrect motion type");
+    }
+
+    if (eccParams.motionType == MOTION_HOMOGRAPHY && map.rows != 3) {
+        CV_Error(Error::BadImageSize, "warpMatrix has incorrect size");
+    }
+
+    if (!((bool)(eccParams.criteria.type & TermCriteria::COUNT) || (bool)(eccParams.criteria.type & TermCriteria::EPS))) {
+        CV_Error(Error::StsError, "Incorrect stop eccParams.criteria");
+    }
+}
+
+static MatPyramid prepareECCPyramid(InputArray image,
+                             InputArray imageMask,  // Can be empty
+                             int gaussFiltSize,
+                             int nlevels) {
+    MatPyramid imagePyramid, maskPyramid;
+    buildPyramidECC(image, imagePyramid, imageMask, maskPyramid, nlevels);
+    for (int lvl = 0; lvl < nlevels; lvl++) {
+        Mat imgFloat;
+        imagePyramid[lvl].convertTo(imgFloat, CV_32F, 1. / 255.);
+        if (gaussFiltSize != 0) {
+            GaussianBlur(imgFloat, imgFloat, Size(gaussFiltSize, gaussFiltSize), 0, 0);
+        }
+        imagePyramid[lvl] = spliceWithMask(
+            imgFloat,
+            (static_cast<int>(maskPyramid.size()) > lvl && !maskPyramid[lvl].empty()) ? maskPyramid[lvl] : Mat());
+    }
+    return imagePyramid;
+}
+
+double findTransformECCMultiScale(InputArray reference,
+                        InputArray sample,
+                        InputOutputArray warpMatrixA,
+                        const ECCParameters& eccParams,
+                        InputArray referenceMask,
+                        InputArray sampleMask) {
+    MatPyramid referencePyramid = prepareECCPyramid(reference, referenceMask, eccParams.gaussFiltSize, eccParams.nlevels);
+    MatPyramid samplePyramid = prepareECCPyramid(sample, sampleMask, eccParams.gaussFiltSize, eccParams.nlevels);
+    Mat& warpMatrix = warpMatrixA.getMatRef();
+    std::vector<int> itersPerLevelCopy = eccParams.itersPerLevel;
+    // If the user passed an un-initialized warpMatrix, initialize to identity
+    if (warpMatrix.empty())
+    {
+        int rowCount = eccParams.motionType == MOTION_HOMOGRAPHY ? 3 : 2;
+        warpMatrix = Mat::eye(rowCount, 3, CV_64FC1);
+    }
+    int warpMatrixType = warpMatrix.type();
+    if (warpMatrixType != CV_64FC1)
+    {
+        warpMatrix.convertTo(warpMatrix, CV_64FC1);
+    }
+
+    checkParams(referencePyramid,
+                samplePyramid,
+                warpMatrix,
+                itersPerLevelCopy,
+                eccParams);
+
+    int nparams = 0;
+    switch (eccParams.motionType) {
+        case MOTION_TRANSLATION:
+            nparams = MotionTraits<MOTION_TRANSLATION>::paramAmount;
+            break;
+        case MOTION_EUCLIDEAN:
+            nparams = MotionTraits<MOTION_EUCLIDEAN>::paramAmount;
+            break;
+        case MOTION_AFFINE:
+            nparams = MotionTraits<MOTION_AFFINE>::paramAmount;
+            break;
+        case MOTION_HOMOGRAPHY:
+            nparams = MotionTraits<MOTION_HOMOGRAPHY>::paramAmount;
+            break;
+        default:
+            CV_Error(Error::StsBadArg, "Incorrect motion type");
+    }
+
+    const std::vector<int> numberOfIterations = ((eccParams.criteria.type & TermCriteria::COUNT) != 0)
+                                                    ? itersPerLevelCopy
+                                                    : std::vector<int>(eccParams.nlevels, 200);
+    const double terminationEPS = (bool)(eccParams.criteria.type & TermCriteria::EPS) ? eccParams.criteria.epsilon : -1;
+
+    // Scale warp matrix multiple times to lower pyramid level
+    for (int pyrLevel = 0; pyrLevel < eccParams.nlevels - 1; pyrLevel++) {
+        scaleWarpMatrix(warpMatrix, 0.5);
+    }
+    double rho = -1;
+    for (int pyrLevel = eccParams.nlevels - 1; pyrLevel >= 0; --pyrLevel) {
+        const int hr = referencePyramid[pyrLevel].rows;
+
+        Mat sampleWithGrad = prepareGradients(samplePyramid[pyrLevel]);
+
+        const int LOW_SIZE = 200;
+        int deltaY = hr < LOW_SIZE ? 1 : 2;
+
+        // iteratively update mapMatrix
+        double lastRho = -terminationEPS;
+        for (int i = 1; (i <= numberOfIterations[pyrLevel]) && (fabs(rho - lastRho) >= terminationEPS); i++) {
+            optimizeECC(sampleWithGrad, referencePyramid[pyrLevel], warpMatrix, eccParams.motionType, &rho, &lastRho, deltaY, nparams, eccParams.interpolation);
+        }
+        if (pyrLevel > 0) {
+            scaleWarpMatrix(warpMatrix, 2);
+        }
+    }
+    if(warpMatrixType != CV_64FC1)
+    {
+        warpMatrix.convertTo(warpMatrix, warpMatrixType);
+    }
+    // return final correlation coefficient
+    return rho;
+}
+};
+/* End of file. */
\ No newline at end of file
diff --git a/upstream/opencv/modules/video/src/hal_replacement.hpp b/upstream/opencv/modules/video/src/hal_replacement.hpp
new file mode 100644
index 0000000..396fa9a
--- /dev/null
+++ b/upstream/opencv/modules/video/src/hal_replacement.hpp
@@ -0,0 +1,126 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_HAL_REPLACEMENT_HPP
+#define OPENCV_VIDEO_HAL_REPLACEMENT_HPP
+
+#include "opencv2/core/hal/interface.h"
+
+#if defined(__clang__)  // clang or MSVC clang
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//! @addtogroup video_hal_interface
+//! @note Define your functions to override default implementations:
+//! @code
+//! #undef cv_hal_LK_optical_flow_level
+//! #define cv_hal_LK_optical_flow_level my_hal_LK_optical_flow_level
+//! @endcode
+//! @{
+
+/**
+@brief Lucas-Kanade optical flow for single pyramid layer. See calcOpticalFlowPyrLK.
+@note OpenCV builds pyramid levels with `win_size` padding. Out-of-bound access to source
+image data is legal within `+-win_size` range.
+@param prev_data previous frame image data
+@param prev_data_step previous frame image data step
+@param prev_deriv_data previous frame Schaar derivatives
+@param prev_deriv_step previous frame Schaar derivatives step
+@param next_data next frame image data
+@param next_step next frame image step
+@param width input images width
+@param height input images height
+@param cn source image channels
+@param prev_points 2d points coordinates (x,y) on the previous frame
+@param next_points points coordinates (x,y) on the next frame
+@param point_count - amount of input points
+@param status optical flow status for each point. Optional output, expected if not nullptr is provided
+@param err optical flow estimation error for each point. Optional output, expected if not nullptr is provided
+@param win_width optical flow window width
+@param win_height optical flow window heigh
+@param termination_count maximum algorithm iterations. 0 means unlimited
+@param termination_epsilon maximal allowed algorithm error
+@param get_min_eigen_vals return minimal egen values as point errors in err buffer
+@param min_eigen_vals_threshold eigen values threshold
+**/
+inline int hal_ni_LKOpticalFlowLevel(const uchar *prev_data, size_t prev_data_step,
+                       const short* prev_deriv_data, size_t prev_deriv_step,
+                       const uchar* next_data, size_t next_step,
+                       int width, int height, int cn,
+                       const float *prev_points, float *next_points, size_t point_count,
+                       uchar *status, float *err,
+                       const int win_width, const int win_height,
+                       int termination_count, double termination_epsilon,
+                       bool get_min_eigen_vals,
+                       float min_eigen_vals_threshold)
+{
+    return CV_HAL_ERROR_NOT_IMPLEMENTED;
+}
+
+//! @cond IGNORED
+#define cv_hal_LKOpticalFlowLevel hal_ni_LKOpticalFlowLevel
+//! @endcond
+
+/**
+@brief Computes Schaar derivatives with inteleaved layout xyxy...
+@note OpenCV builds pyramid levels with `win_size` padding. Out-of-bound access to source
+image data is legal within `+-win_size` range.
+@param src_data source image data
+@param src_step source image step
+@param dst_data destination buffer data
+@param dst_step destination buffer step
+@param width image width
+@param height image height
+@param cn source image channels
+**/
+inline int hal_ni_ScharrDeriv(const uchar* src_data, size_t src_step,
+                              short* dst_data, size_t dst_step,
+                              int width, int height, int cn)
+{
+    return CV_HAL_ERROR_NOT_IMPLEMENTED;
+}
+
+//! @cond IGNORED
+#define cv_hal_ScharrDeriv hal_ni_ScharrDeriv
+//! @endcond
+
+//! @}
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#include "custom_hal.hpp"
+
+//! @cond IGNORED
+#define CALL_HAL_RET(name, fun, retval, ...) \
+    int res = __CV_EXPAND(fun(__VA_ARGS__, &retval)); \
+    if (res == CV_HAL_ERROR_OK) \
+        return retval; \
+    else if (res != CV_HAL_ERROR_NOT_IMPLEMENTED) \
+        CV_Error_(cv::Error::StsInternal, \
+            ("HAL implementation " CVAUX_STR(name) " ==> " CVAUX_STR(fun) " returned %d (0x%08x)", res, res));
+
+
+#define CALL_HAL(name, fun, ...) \
+    int res = __CV_EXPAND(fun(__VA_ARGS__)); \
+    if (res == CV_HAL_ERROR_OK) \
+        return; \
+    else if (res != CV_HAL_ERROR_NOT_IMPLEMENTED) \
+        CV_Error_(cv::Error::StsInternal, \
+            ("HAL implementation " CVAUX_STR(name) " ==> " CVAUX_STR(fun) " returned %d (0x%08x)", res, res));
+//! @endcond
+
+#endif
diff --git a/upstream/opencv/modules/video/src/kalman.cpp b/upstream/opencv/modules/video/src/kalman.cpp
new file mode 100644
index 0000000..10e7ffb
--- /dev/null
+++ b/upstream/opencv/modules/video/src/kalman.cpp
@@ -0,0 +1,134 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+
+namespace cv
+{
+
+KalmanFilter::KalmanFilter() {}
+KalmanFilter::KalmanFilter(int dynamParams, int measureParams, int controlParams, int type)
+{
+    init(dynamParams, measureParams, controlParams, type);
+}
+
+void KalmanFilter::init(int DP, int MP, int CP, int type)
+{
+    CV_Assert( DP > 0 && MP > 0 );
+    CV_Assert( type == CV_32F || type == CV_64F );
+    CP = std::max(CP, 0);
+
+    statePre = Mat::zeros(DP, 1, type);
+    statePost = Mat::zeros(DP, 1, type);
+    transitionMatrix = Mat::eye(DP, DP, type);
+
+    processNoiseCov = Mat::eye(DP, DP, type);
+    measurementMatrix = Mat::zeros(MP, DP, type);
+    measurementNoiseCov = Mat::eye(MP, MP, type);
+
+    errorCovPre = Mat::zeros(DP, DP, type);
+    errorCovPost = Mat::zeros(DP, DP, type);
+    gain = Mat::zeros(DP, MP, type);
+
+    if( CP > 0 )
+        controlMatrix = Mat::zeros(DP, CP, type);
+    else
+        controlMatrix.release();
+
+    temp1.create(DP, DP, type);
+    temp2.create(MP, DP, type);
+    temp3.create(MP, MP, type);
+    temp4.create(MP, DP, type);
+    temp5.create(MP, 1, type);
+}
+
+const Mat& KalmanFilter::predict(const Mat& control)
+{
+    CV_INSTRUMENT_REGION();
+
+    // update the state: x'(k) = A*x(k)
+    statePre = transitionMatrix*statePost;
+
+    if( !control.empty() )
+        // x'(k) = x'(k) + B*u(k)
+        statePre += controlMatrix*control;
+
+    // update error covariance matrices: temp1 = A*P(k)
+    temp1 = transitionMatrix*errorCovPost;
+
+    // P'(k) = temp1*At + Q
+    gemm(temp1, transitionMatrix, 1, processNoiseCov, 1, errorCovPre, GEMM_2_T);
+
+    // handle the case when there will be no measurement before the next predict.
+    statePre.copyTo(statePost);
+    errorCovPre.copyTo(errorCovPost);
+
+    return statePre;
+}
+
+const Mat& KalmanFilter::correct(const Mat& measurement)
+{
+    CV_INSTRUMENT_REGION();
+
+    // temp2 = H*P'(k)
+    temp2 = measurementMatrix * errorCovPre;
+
+    // temp3 = temp2*Ht + R
+    gemm(temp2, measurementMatrix, 1, measurementNoiseCov, 1, temp3, GEMM_2_T);
+
+    // temp4 = inv(temp3)*temp2 = Kt(k)
+    solve(temp3, temp2, temp4, DECOMP_SVD);
+
+    // K(k)
+    gain = temp4.t();
+
+    // temp5 = z(k) - H*x'(k)
+    temp5 = measurement - measurementMatrix*statePre;
+
+    // x(k) = x'(k) + K(k)*temp5
+    statePost = statePre + gain*temp5;
+
+    // P(k) = P'(k) - K(k)*temp2
+    errorCovPost = errorCovPre - gain*temp2;
+
+    return statePost;
+}
+
+}
diff --git a/upstream/opencv/modules/video/src/lkpyramid.cpp b/upstream/opencv/modules/video/src/lkpyramid.cpp
new file mode 100644
index 0000000..84c766f
--- /dev/null
+++ b/upstream/opencv/modules/video/src/lkpyramid.cpp
@@ -0,0 +1,1328 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Copyright (C) 2026, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+#include <float.h>
+#include <stdio.h>
+#include "lkpyramid.hpp"
+#include "opencl_kernels_video.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+#ifdef HAVE_OPENCV_GEOMETRY
+#include "opencv2/geometry.hpp"
+#endif
+
+#include "hal_replacement.hpp"
+
+#define  CV_DESCALE(x,n)     (((x) + (1 << ((n)-1))) >> (n))
+
+namespace
+{
+static void calcScharrDeriv(const cv::Mat& src, cv::Mat& dst)
+{
+    using namespace cv;
+    using cv::detail::deriv_type;
+    int rows = src.rows, cols = src.cols, cn = src.channels(), depth = src.depth();
+    CV_Assert(depth == CV_8U);
+    dst.create(rows, cols, CV_MAKETYPE(DataType<deriv_type>::depth, cn*2));
+
+    CALL_HAL(ScharrDeriv, cv_hal_ScharrDeriv, src.data, src.step, (short*)dst.data, dst.step, cols, rows, cn);
+
+    parallel_for_(Range(0, rows), cv::detail::ScharrDerivInvoker(src, dst), cv::getNumThreads());
+}
+
+}//namespace
+
+void cv::detail::ScharrDerivInvoker::operator()(const Range& range) const
+{
+    ScharrDerivInvoker_impl(src, const_cast<Mat&>(dst), range);
+}
+
+cv::detail::LKTrackerInvoker::LKTrackerInvoker(
+                      const Mat& _prevImg, const Mat& _prevDeriv, const Mat& _nextImg,
+                      const Point2f* _prevPts, Point2f* _nextPts,
+                      uchar* _status, float* _err,
+                      Size _winSize, TermCriteria _criteria,
+                      int _level, int _maxLevel, int _flags, float _minEigThreshold )
+{
+    prevImg = &_prevImg;
+    prevDeriv = &_prevDeriv;
+    nextImg = &_nextImg;
+    prevPts = _prevPts;
+    nextPts = _nextPts;
+    status = _status;
+    err = _err;
+    winSize = _winSize;
+    criteria = _criteria;
+    level = _level;
+    maxLevel = _maxLevel;
+    flags = _flags;
+    minEigThreshold = _minEigThreshold;
+}
+
+#if defined __arm__ && !CV_NEON
+typedef int64 acctype;
+typedef int itemtype;
+#else
+typedef float acctype;
+typedef float itemtype;
+#endif
+
+void cv::detail::LKTrackerInvoker::operator()(const Range& range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    const int W_BITS = 14, W_BITS1 = 14;
+    const float FLT_SCALE = 1.f/(1 << 20);
+
+    Point2f halfWin((winSize.width-1)*0.5f, (winSize.height-1)*0.5f);
+    const Mat& I = *prevImg;
+    const Mat& J = *nextImg;
+    const Mat& derivI = *prevDeriv;
+
+    cv::AutoBuffer<Point2f> prevPtsScaledData(range.end - range.start);
+    Point2f* prevPtsScaled = prevPtsScaledData.data();
+
+    int j, cn = I.channels(), cn2 = cn*2;
+    cv::AutoBuffer<deriv_type> _buf(winSize.area()*(cn + cn2));
+    int derivDepth = DataType<deriv_type>::depth;
+
+    Mat IWinBuf(winSize, CV_MAKETYPE(derivDepth, cn), _buf.data());
+    Mat derivIWinBuf(winSize, CV_MAKETYPE(derivDepth, cn2), _buf.data() + winSize.area()*cn);
+
+    for( int ptidx = range.start; ptidx < range.end; ptidx++ )
+    {
+        Point2f prevPt = prevPts[ptidx]*(float)(1./(1 << level));
+        Point2f nextPt;
+        if( level == maxLevel )
+        {
+            if( flags & OPTFLOW_USE_INITIAL_FLOW )
+                nextPt = nextPts[ptidx]*(float)(1./(1 << level));
+            else
+                nextPt = prevPt;
+        }
+        else
+            nextPt = nextPts[ptidx]*2.f;
+        nextPts[ptidx] = nextPt;
+        prevPtsScaled[ptidx-range.start] = prevPt;
+    }
+
+    CALL_HAL(LKOpticalFlowLevel, cv_hal_LKOpticalFlowLevel,
+        I.data, I.step, (const short*)derivI.data, derivI.step, J.data, J.step,
+        I.cols, I.rows, I.channels(),
+        (float*)prevPtsScaled, (float*)(nextPts+range.start), range.end-range.start,
+        (level == 0) ? status+range.start: nullptr,
+        err != nullptr ? err+range.start: nullptr,
+        winSize.width, winSize.height, criteria.maxCount, criteria.epsilon,
+        (flags & OPTFLOW_LK_GET_MIN_EIGENVALS) != 0,
+        (float)minEigThreshold
+    );
+
+    for( int ptidx = range.start; ptidx < range.end; ptidx++ )
+    {
+        Point2f prevPt = prevPtsScaled[ptidx-range.start];
+        Point2i iprevPt, inextPt;
+        prevPt -= halfWin;
+        iprevPt.x = cvFloor(prevPt.x);
+        iprevPt.y = cvFloor(prevPt.y);
+
+        if( iprevPt.x < -winSize.width || iprevPt.x >= derivI.cols ||
+            iprevPt.y < -winSize.height || iprevPt.y >= derivI.rows )
+        {
+            if( level == 0 )
+            {
+                status[ptidx] = false;
+                if( err )
+                    err[ptidx] = 0;
+            }
+            continue;
+        }
+
+        float a = prevPt.x - iprevPt.x;
+        float b = prevPt.y - iprevPt.y;
+        int iw00 = cvRound((1.f - a)*(1.f - b)*(1 << W_BITS));
+        int iw01 = cvRound(a*(1.f - b)*(1 << W_BITS));
+        int iw10 = cvRound((1.f - a)*b*(1 << W_BITS));
+        int iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+
+        int dstep = (int)(derivI.step/derivI.elemSize1());
+        int stepI = (int)(I.step/I.elemSize1());
+        int stepJ = (int)(J.step/J.elemSize1());
+        acctype iA11 = 0, iA12 = 0, iA22 = 0;
+        float A11, A12, A22;
+
+#if CV_SIMD128 && !CV_NEON
+        v_int16x8 qw0((short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01));
+        v_int16x8 qw1((short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11));
+        v_int32x4 qdelta_d = v_setall_s32(1 << (W_BITS1-1));
+        v_int32x4 qdelta = v_setall_s32(1 << (W_BITS1-5-1));
+        v_float32x4 qA11 = v_setzero_f32(), qA12 = v_setzero_f32(), qA22 = v_setzero_f32();
+#endif
+
+#if CV_NEON
+
+        float CV_DECL_ALIGNED(16) nA11[] = { 0, 0, 0, 0 }, nA12[] = { 0, 0, 0, 0 }, nA22[] = { 0, 0, 0, 0 };
+        const int shifter1 = -(W_BITS - 5); //negative so it shifts right
+        const int shifter2 = -(W_BITS);
+
+        const int16x4_t d26 = vdup_n_s16((int16_t)iw00);
+        const int16x4_t d27 = vdup_n_s16((int16_t)iw01);
+        const int16x4_t d28 = vdup_n_s16((int16_t)iw10);
+        const int16x4_t d29 = vdup_n_s16((int16_t)iw11);
+        const int32x4_t q11 = vdupq_n_s32((int32_t)shifter1);
+        const int32x4_t q12 = vdupq_n_s32((int32_t)shifter2);
+
+#endif
+
+        // extract the patch from the first image, compute covariation matrix of derivatives
+        int x, y;
+        for( y = 0; y < winSize.height; y++ )
+        {
+            const uchar* src = I.ptr() + (y + iprevPt.y)*stepI + iprevPt.x*cn;
+            const deriv_type* dsrc = derivI.ptr<deriv_type>() + (y + iprevPt.y)*dstep + iprevPt.x*cn2;
+
+            deriv_type* Iptr = IWinBuf.ptr<deriv_type>(y);
+            deriv_type* dIptr = derivIWinBuf.ptr<deriv_type>(y);
+
+            x = 0;
+
+#if CV_SIMD128 && !CV_NEON
+            for( ; x <= winSize.width*cn - 8; x += 8, dsrc += 8*2, dIptr += 8*2 )
+            {
+                v_int32x4 t0, t1;
+                v_int16x8 v00, v01, v10, v11, t00, t01, t10, t11;
+
+                v00 = v_reinterpret_as_s16(v_load_expand(src + x));
+                v01 = v_reinterpret_as_s16(v_load_expand(src + x + cn));
+                v10 = v_reinterpret_as_s16(v_load_expand(src + x + stepI));
+                v11 = v_reinterpret_as_s16(v_load_expand(src + x + stepI + cn));
+
+                v_zip(v00, v01, t00, t01);
+                v_zip(v10, v11, t10, t11);
+
+                t0 = v_add(v_dotprod(t00, qw0, qdelta), v_dotprod(t10, qw1));
+                t1 = v_add(v_dotprod(t01, qw0, qdelta), v_dotprod(t11, qw1));
+                t0 = v_shr<W_BITS1 - 5>(t0);
+                t1 = v_shr<W_BITS1 - 5>(t1);
+                v_store(Iptr + x, v_pack(t0, t1));
+
+                v00 = v_reinterpret_as_s16(v_load(dsrc));
+                v01 = v_reinterpret_as_s16(v_load(dsrc + cn2));
+                v10 = v_reinterpret_as_s16(v_load(dsrc + dstep));
+                v11 = v_reinterpret_as_s16(v_load(dsrc + dstep + cn2));
+
+                v_zip(v00, v01, t00, t01);
+                v_zip(v10, v11, t10, t11);
+
+                t0 = v_add(v_dotprod(t00, qw0, qdelta_d), v_dotprod(t10, qw1));
+                t1 = v_add(v_dotprod(t01, qw0, qdelta_d), v_dotprod(t11, qw1));
+                t0 = v_shr<W_BITS1>(t0);
+                t1 = v_shr<W_BITS1>(t1);
+                v00 = v_pack(t0, t1); // Ix0 Iy0 Ix1 Iy1 ...
+                v_store(dIptr, v00);
+
+                v00 = v_reinterpret_as_s16(v_interleave_pairs(v_reinterpret_as_s32(v_interleave_pairs(v00))));
+                v_expand(v00, t1, t0);
+
+                v_float32x4 fy = v_cvt_f32(t0);
+                v_float32x4 fx = v_cvt_f32(t1);
+
+                qA22 = v_muladd(fy, fy, qA22);
+                qA12 = v_muladd(fx, fy, qA12);
+                qA11 = v_muladd(fx, fx, qA11);
+
+                v00 = v_reinterpret_as_s16(v_load(dsrc + 4*2));
+                v01 = v_reinterpret_as_s16(v_load(dsrc + 4*2 + cn2));
+                v10 = v_reinterpret_as_s16(v_load(dsrc + 4*2 + dstep));
+                v11 = v_reinterpret_as_s16(v_load(dsrc + 4*2 + dstep + cn2));
+
+                v_zip(v00, v01, t00, t01);
+                v_zip(v10, v11, t10, t11);
+
+                t0 = v_add(v_dotprod(t00, qw0, qdelta_d), v_dotprod(t10, qw1));
+                t1 = v_add(v_dotprod(t01, qw0, qdelta_d), v_dotprod(t11, qw1));
+                t0 = v_shr<W_BITS1>(t0);
+                t1 = v_shr<W_BITS1>(t1);
+                v00 = v_pack(t0, t1); // Ix0 Iy0 Ix1 Iy1 ...
+                v_store(dIptr + 4*2, v00);
+
+                v00 = v_reinterpret_as_s16(v_interleave_pairs(v_reinterpret_as_s32(v_interleave_pairs(v00))));
+                v_expand(v00, t1, t0);
+
+                fy = v_cvt_f32(t0);
+                fx = v_cvt_f32(t1);
+
+                qA22 = v_muladd(fy, fy, qA22);
+                qA12 = v_muladd(fx, fy, qA12);
+                qA11 = v_muladd(fx, fx, qA11);
+            }
+#endif
+
+#if CV_NEON
+            for( ; x <= winSize.width*cn - 4; x += 4, dsrc += 4*2, dIptr += 4*2 )
+            {
+
+                uint8x8_t d0 = vld1_u8(&src[x]);
+                uint8x8_t d2 = vld1_u8(&src[x+cn]);
+                uint16x8_t q0 = vmovl_u8(d0);
+                uint16x8_t q1 = vmovl_u8(d2);
+
+                int32x4_t q5 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q0)), d26);
+                int32x4_t q6 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q1)), d27);
+
+                uint8x8_t d4 = vld1_u8(&src[x + stepI]);
+                uint8x8_t d6 = vld1_u8(&src[x + stepI + cn]);
+                uint16x8_t q2 = vmovl_u8(d4);
+                uint16x8_t q3 = vmovl_u8(d6);
+
+                int32x4_t q7 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q2)), d28);
+                int32x4_t q8 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q3)), d29);
+
+                q5 = vaddq_s32(q5, q6);
+                q7 = vaddq_s32(q7, q8);
+                q5 = vaddq_s32(q5, q7);
+
+                int16x4x2_t d0d1 = vld2_s16(dsrc);
+                int16x4x2_t d2d3 = vld2_s16(&dsrc[cn2]);
+
+                q5 = vqrshlq_s32(q5, q11);
+
+                int32x4_t q4 = vmull_s16(d0d1.val[0], d26);
+                q6 = vmull_s16(d0d1.val[1], d26);
+
+                int16x4_t nd0 = vmovn_s32(q5);
+
+                q7 = vmull_s16(d2d3.val[0], d27);
+                q8 = vmull_s16(d2d3.val[1], d27);
+
+                vst1_s16(&Iptr[x], nd0);
+
+                int16x4x2_t d4d5 = vld2_s16(&dsrc[dstep]);
+                int16x4x2_t d6d7 = vld2_s16(&dsrc[dstep+cn2]);
+
+                q4 = vaddq_s32(q4, q7);
+                q6 = vaddq_s32(q6, q8);
+
+                q7 = vmull_s16(d4d5.val[0], d28);
+                int32x4_t q14 = vmull_s16(d4d5.val[1], d28);
+                q8 = vmull_s16(d6d7.val[0], d29);
+                int32x4_t q15 = vmull_s16(d6d7.val[1], d29);
+
+                q7 = vaddq_s32(q7, q8);
+                q14 = vaddq_s32(q14, q15);
+
+                q4 = vaddq_s32(q4, q7);
+                q6 = vaddq_s32(q6, q14);
+
+                float32x4_t nq0 = vld1q_f32(nA11);
+                float32x4_t nq1 = vld1q_f32(nA12);
+                float32x4_t nq2 = vld1q_f32(nA22);
+
+                q4 = vqrshlq_s32(q4, q12);
+                q6 = vqrshlq_s32(q6, q12);
+
+                q7 = vmulq_s32(q4, q4);
+                q8 = vmulq_s32(q4, q6);
+                q15 = vmulq_s32(q6, q6);
+
+                nq0 = vaddq_f32(nq0, vcvtq_f32_s32(q7));
+                nq1 = vaddq_f32(nq1, vcvtq_f32_s32(q8));
+                nq2 = vaddq_f32(nq2, vcvtq_f32_s32(q15));
+
+                vst1q_f32(nA11, nq0);
+                vst1q_f32(nA12, nq1);
+                vst1q_f32(nA22, nq2);
+
+                int16x4_t d8 = vmovn_s32(q4);
+                int16x4_t d12 = vmovn_s32(q6);
+
+                int16x4x2_t d8d12;
+                d8d12.val[0] = d8; d8d12.val[1] = d12;
+                vst2_s16(dIptr, d8d12);
+            }
+#endif
+
+            for( ; x < winSize.width*cn; x++, dsrc += 2, dIptr += 2 )
+            {
+                int ival = CV_DESCALE(src[x]*iw00 + src[x+cn]*iw01 +
+                                      src[x+stepI]*iw10 + src[x+stepI+cn]*iw11, W_BITS1-5);
+                int ixval = CV_DESCALE(dsrc[0]*iw00 + dsrc[cn2]*iw01 +
+                                       dsrc[dstep]*iw10 + dsrc[dstep+cn2]*iw11, W_BITS1);
+                int iyval = CV_DESCALE(dsrc[1]*iw00 + dsrc[cn2+1]*iw01 + dsrc[dstep+1]*iw10 +
+                                       dsrc[dstep+cn2+1]*iw11, W_BITS1);
+
+                Iptr[x] = (short)ival;
+                dIptr[0] = (short)ixval;
+                dIptr[1] = (short)iyval;
+
+                iA11 += (itemtype)(ixval*ixval);
+                iA12 += (itemtype)(ixval*iyval);
+                iA22 += (itemtype)(iyval*iyval);
+            }
+        }
+
+#if CV_SIMD128 && !CV_NEON
+        iA11 += v_reduce_sum(qA11);
+        iA12 += v_reduce_sum(qA12);
+        iA22 += v_reduce_sum(qA22);
+#endif
+
+#if CV_NEON
+        iA11 += nA11[0] + nA11[1] + nA11[2] + nA11[3];
+        iA12 += nA12[0] + nA12[1] + nA12[2] + nA12[3];
+        iA22 += nA22[0] + nA22[1] + nA22[2] + nA22[3];
+#endif
+
+        A11 = iA11*FLT_SCALE;
+        A12 = iA12*FLT_SCALE;
+        A22 = iA22*FLT_SCALE;
+
+        float D = A11*A22 - A12*A12;
+        float minEig = (A22 + A11 - std::sqrt((A11-A22)*(A11-A22) +
+                        4.f*A12*A12))/(2*winSize.width*winSize.height);
+
+        if( err && (flags & OPTFLOW_LK_GET_MIN_EIGENVALS) != 0 )
+            err[ptidx] = (float)minEig;
+
+        if( minEig < minEigThreshold || D < FLT_EPSILON )
+        {
+            if(level == 0)
+                status[ptidx] = false;
+            continue;
+        }
+
+        D = 1.f/D;
+
+        Point2f nextPt = nextPts[ptidx] - halfWin;
+        Point2f prevDelta;
+
+        for( j = 0; j < criteria.maxCount; j++ )
+        {
+            inextPt.x = cvFloor(nextPt.x);
+            inextPt.y = cvFloor(nextPt.y);
+
+            if( inextPt.x < -winSize.width || inextPt.x >= J.cols ||
+               inextPt.y < -winSize.height || inextPt.y >= J.rows )
+            {
+                if( level == 0 )
+                    status[ptidx] = false;
+                break;
+            }
+
+            a = nextPt.x - inextPt.x;
+            b = nextPt.y - inextPt.y;
+            iw00 = cvRound((1.f - a)*(1.f - b)*(1 << W_BITS));
+            iw01 = cvRound(a*(1.f - b)*(1 << W_BITS));
+            iw10 = cvRound((1.f - a)*b*(1 << W_BITS));
+            iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+            acctype ib1 = 0, ib2 = 0;
+            float b1, b2;
+#if CV_SIMD128 && !CV_NEON
+            qw0 = v_int16x8((short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01), (short)(iw00), (short)(iw01));
+            qw1 = v_int16x8((short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11), (short)(iw10), (short)(iw11));
+            v_float32x4 qb0 = v_setzero_f32(), qb1 = v_setzero_f32();
+#endif
+
+#if CV_NEON
+            float CV_DECL_ALIGNED(16) nB1[] = { 0,0,0,0 }, nB2[] = { 0,0,0,0 };
+
+            const int16x4_t d26_2 = vdup_n_s16((int16_t)iw00);
+            const int16x4_t d27_2 = vdup_n_s16((int16_t)iw01);
+            const int16x4_t d28_2 = vdup_n_s16((int16_t)iw10);
+            const int16x4_t d29_2 = vdup_n_s16((int16_t)iw11);
+
+#endif
+
+            for( y = 0; y < winSize.height; y++ )
+            {
+                const uchar* Jptr = J.ptr() + (y + inextPt.y)*stepJ + inextPt.x*cn;
+                const deriv_type* Iptr = IWinBuf.ptr<deriv_type>(y);
+                const deriv_type* dIptr = derivIWinBuf.ptr<deriv_type>(y);
+
+                x = 0;
+
+#if CV_SIMD128 && !CV_NEON
+                for( ; x <= winSize.width*cn - 8; x += 8, dIptr += 8*2 )
+                {
+                    v_int16x8 diff0 = v_reinterpret_as_s16(v_load(Iptr + x)), diff1, diff2;
+                    v_int16x8 v00 = v_reinterpret_as_s16(v_load_expand(Jptr + x));
+                    v_int16x8 v01 = v_reinterpret_as_s16(v_load_expand(Jptr + x + cn));
+                    v_int16x8 v10 = v_reinterpret_as_s16(v_load_expand(Jptr + x + stepJ));
+                    v_int16x8 v11 = v_reinterpret_as_s16(v_load_expand(Jptr + x + stepJ + cn));
+
+                    v_int32x4 t0, t1;
+                    v_int16x8 t00, t01, t10, t11;
+                    v_zip(v00, v01, t00, t01);
+                    v_zip(v10, v11, t10, t11);
+
+                    t0 = v_add(v_dotprod(t00, qw0, qdelta), v_dotprod(t10, qw1));
+                    t1 = v_add(v_dotprod(t01, qw0, qdelta), v_dotprod(t11, qw1));
+                    t0 = v_shr<W_BITS1 - 5>(t0);
+                    t1 = v_shr<W_BITS1 - 5>(t1);
+                    diff0 = v_sub(v_pack(t0, t1), diff0);
+                    v_zip(diff0, diff0, diff2, diff1); // It0 It0 It1 It1 ...
+                    v00 = v_reinterpret_as_s16(v_load(dIptr)); // Ix0 Iy0 Ix1 Iy1 ...
+                    v01 = v_reinterpret_as_s16(v_load(dIptr + 8));
+                    v_zip(v00, v01, v10, v11);
+                    v_zip(diff2, diff1, v00, v01);
+                    qb0 = v_add(qb0, v_cvt_f32(v_dotprod(v00, v10)));
+                    qb1 = v_add(qb1, v_cvt_f32(v_dotprod(v01, v11)));
+                }
+#endif
+
+#if CV_NEON
+                for( ; x <= winSize.width*cn - 8; x += 8, dIptr += 8*2 )
+                {
+
+                    uint8x8_t d0 = vld1_u8(&Jptr[x]);
+                    uint8x8_t d2 = vld1_u8(&Jptr[x+cn]);
+                    uint8x8_t d4 = vld1_u8(&Jptr[x+stepJ]);
+                    uint8x8_t d6 = vld1_u8(&Jptr[x+stepJ+cn]);
+
+                    uint16x8_t q0 = vmovl_u8(d0);
+                    uint16x8_t q1 = vmovl_u8(d2);
+                    uint16x8_t q2 = vmovl_u8(d4);
+                    uint16x8_t q3 = vmovl_u8(d6);
+
+                    int32x4_t nq4 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q0)), d26_2);
+                    int32x4_t nq5 = vmull_s16(vget_high_s16(vreinterpretq_s16_u16(q0)), d26_2);
+
+                    int32x4_t nq6 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q1)), d27_2);
+                    int32x4_t nq7 = vmull_s16(vget_high_s16(vreinterpretq_s16_u16(q1)), d27_2);
+
+                    int32x4_t nq8 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q2)), d28_2);
+                    int32x4_t nq9 = vmull_s16(vget_high_s16(vreinterpretq_s16_u16(q2)), d28_2);
+
+                    int32x4_t nq10 = vmull_s16(vget_low_s16(vreinterpretq_s16_u16(q3)), d29_2);
+                    int32x4_t nq11 = vmull_s16(vget_high_s16(vreinterpretq_s16_u16(q3)), d29_2);
+
+                    nq4 = vaddq_s32(nq4, nq6);
+                    nq5 = vaddq_s32(nq5, nq7);
+                    nq8 = vaddq_s32(nq8, nq10);
+                    nq9 = vaddq_s32(nq9, nq11);
+
+                    int16x8_t q6 = vld1q_s16(&Iptr[x]);
+
+                    nq4 = vaddq_s32(nq4, nq8);
+                    nq5 = vaddq_s32(nq5, nq9);
+
+                    nq8 = vmovl_s16(vget_high_s16(q6));
+                    nq6 = vmovl_s16(vget_low_s16(q6));
+
+                    nq4 = vqrshlq_s32(nq4, q11);
+                    nq5 = vqrshlq_s32(nq5, q11);
+
+                    int16x8x2_t q0q1 = vld2q_s16(dIptr);
+                    float32x4_t nB1v = vld1q_f32(nB1);
+                    float32x4_t nB2v = vld1q_f32(nB2);
+
+                    nq4 = vsubq_s32(nq4, nq6);
+                    nq5 = vsubq_s32(nq5, nq8);
+
+                    int32x4_t nq2 = vmovl_s16(vget_low_s16(q0q1.val[0]));
+                    int32x4_t nq3 = vmovl_s16(vget_high_s16(q0q1.val[0]));
+
+                    nq7 = vmovl_s16(vget_low_s16(q0q1.val[1]));
+                    nq8 = vmovl_s16(vget_high_s16(q0q1.val[1]));
+
+                    nq9 = vmulq_s32(nq4, nq2);
+                    nq10 = vmulq_s32(nq5, nq3);
+
+                    nq4 = vmulq_s32(nq4, nq7);
+                    nq5 = vmulq_s32(nq5, nq8);
+
+                    nq9 = vaddq_s32(nq9, nq10);
+                    nq4 = vaddq_s32(nq4, nq5);
+
+                    nB1v = vaddq_f32(nB1v, vcvtq_f32_s32(nq9));
+                    nB2v = vaddq_f32(nB2v, vcvtq_f32_s32(nq4));
+
+                    vst1q_f32(nB1, nB1v);
+                    vst1q_f32(nB2, nB2v);
+                }
+#endif
+
+                for( ; x < winSize.width*cn; x++, dIptr += 2 )
+                {
+                    int diff = CV_DESCALE(Jptr[x]*iw00 + Jptr[x+cn]*iw01 +
+                                          Jptr[x+stepJ]*iw10 + Jptr[x+stepJ+cn]*iw11,
+                                          W_BITS1-5) - Iptr[x];
+                    ib1 += (itemtype)(diff*dIptr[0]);
+                    ib2 += (itemtype)(diff*dIptr[1]);
+                }
+            }
+
+#if CV_SIMD128 && !CV_NEON
+            v_float32x4 qf0, qf1;
+            v_recombine(v_interleave_pairs(v_add(qb0, qb1)), v_setzero_f32(), qf0, qf1);
+            ib1 += v_reduce_sum(qf0);
+            ib2 += v_reduce_sum(qf1);
+#endif
+
+#if CV_NEON
+
+            ib1 += (float)(nB1[0] + nB1[1] + nB1[2] + nB1[3]);
+            ib2 += (float)(nB2[0] + nB2[1] + nB2[2] + nB2[3]);
+#endif
+
+            b1 = ib1*FLT_SCALE;
+            b2 = ib2*FLT_SCALE;
+
+            Point2f delta( (float)((A12*b2 - A22*b1) * D),
+                          (float)((A12*b1 - A11*b2) * D));
+            //delta = -delta;
+
+            nextPt += delta;
+            nextPts[ptidx] = nextPt + halfWin;
+
+            if( delta.ddot(delta) <= criteria.epsilon )
+                break;
+
+            if( j > 0 && std::abs(delta.x + prevDelta.x) < 0.01 &&
+               std::abs(delta.y + prevDelta.y) < 0.01 )
+            {
+                nextPts[ptidx] -= delta*0.5f;
+                break;
+            }
+            prevDelta = delta;
+        }
+
+        if( status[ptidx] && err && level == 0 && (flags & OPTFLOW_LK_GET_MIN_EIGENVALS) == 0 )
+        {
+            Point2f nextPoint = nextPts[ptidx] - halfWin;
+            Point inextPoint;
+
+            inextPoint.x = cvFloor(nextPoint.x);
+            inextPoint.y = cvFloor(nextPoint.y);
+
+            if( inextPoint.x < -winSize.width || inextPoint.x >= J.cols ||
+                inextPoint.y < -winSize.height || inextPoint.y >= J.rows )
+            {
+                status[ptidx] = false;
+                continue;
+            }
+
+            float aa = nextPoint.x - inextPoint.x;
+            float bb = nextPoint.y - inextPoint.y;
+            iw00 = cvRound((1.f - aa)*(1.f - bb)*(1 << W_BITS));
+            iw01 = cvRound(aa*(1.f - bb)*(1 << W_BITS));
+            iw10 = cvRound((1.f - aa)*bb*(1 << W_BITS));
+            iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+            float errval = 0.f;
+
+            for( y = 0; y < winSize.height; y++ )
+            {
+                const uchar* Jptr = J.ptr() + (y + inextPoint.y)*stepJ + inextPoint.x*cn;
+                const deriv_type* Iptr = IWinBuf.ptr<deriv_type>(y);
+
+                for( x = 0; x < winSize.width*cn; x++ )
+                {
+                    int diff = CV_DESCALE(Jptr[x]*iw00 + Jptr[x+cn]*iw01 +
+                                          Jptr[x+stepJ]*iw10 + Jptr[x+stepJ+cn]*iw11,
+                                          W_BITS1-5) - Iptr[x];
+                    errval += std::abs((float)diff);
+                }
+            }
+            err[ptidx] = errval * 1.f/(32*winSize.width*cn*winSize.height);
+        }
+    }
+}
+
+int cv::buildOpticalFlowPyramid(InputArray _img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives,
+                                int pyrBorder, int derivBorder, bool tryReuseInputImage)
+{
+    CV_INSTRUMENT_REGION();
+
+    Mat img = _img.getMat();
+    CV_Assert(img.depth() == CV_8U && winSize.width > 2 && winSize.height > 2 );
+    int pyrstep = withDerivatives ? 2 : 1;
+
+    pyramid.create(1, (maxLevel + 1) * pyrstep, 0 /*type*/, -1, true);
+
+    int derivType = CV_MAKETYPE(DataType<cv::detail::deriv_type>::depth, img.channels() * 2);
+
+    //level 0
+    bool lvl0IsSet = false;
+    if(tryReuseInputImage && img.isSubmatrix() && (pyrBorder & BORDER_ISOLATED) == 0)
+    {
+        Size wholeSize;
+        Point ofs;
+        img.locateROI(wholeSize, ofs);
+        if (ofs.x >= winSize.width && ofs.y >= winSize.height
+              && ofs.x + img.cols + winSize.width <= wholeSize.width
+              && ofs.y + img.rows + winSize.height <= wholeSize.height)
+        {
+            pyramid.getMatRef(0) = img;
+            lvl0IsSet = true;
+        }
+    }
+
+    if(!lvl0IsSet)
+    {
+        Mat& temp = pyramid.getMatRef(0);
+
+        if(!temp.empty())
+            temp.adjustROI(winSize.height, winSize.height, winSize.width, winSize.width);
+        if(temp.type() != img.type() || temp.cols != winSize.width*2 + img.cols || temp.rows != winSize.height * 2 + img.rows)
+            temp.create(img.rows + winSize.height*2, img.cols + winSize.width*2, img.type());
+
+        if(pyrBorder == BORDER_TRANSPARENT)
+            img.copyTo(temp(Rect(winSize.width, winSize.height, img.cols, img.rows)));
+        else
+            copyMakeBorder(img, temp, winSize.height, winSize.height, winSize.width, winSize.width, pyrBorder);
+        temp.adjustROI(-winSize.height, -winSize.height, -winSize.width, -winSize.width);
+    }
+
+    Size sz = img.size();
+    Mat prevLevel = pyramid.getMatRef(0);
+    Mat thisLevel = prevLevel;
+
+    for(int level = 0; level <= maxLevel; ++level)
+    {
+        if (level != 0)
+        {
+            Mat& temp = pyramid.getMatRef(level * pyrstep);
+
+            if(!temp.empty())
+                temp.adjustROI(winSize.height, winSize.height, winSize.width, winSize.width);
+            if(temp.type() != img.type() || temp.cols != winSize.width*2 + sz.width || temp.rows != winSize.height * 2 + sz.height)
+                temp.create(sz.height + winSize.height*2, sz.width + winSize.width*2, img.type());
+
+            thisLevel = temp(Rect(winSize.width, winSize.height, sz.width, sz.height));
+            pyrDown(prevLevel, thisLevel, sz);
+
+            if(pyrBorder != BORDER_TRANSPARENT)
+                copyMakeBorder(thisLevel, temp, winSize.height, winSize.height, winSize.width, winSize.width, pyrBorder|BORDER_ISOLATED);
+            temp.adjustROI(-winSize.height, -winSize.height, -winSize.width, -winSize.width);
+        }
+
+        if(withDerivatives)
+        {
+            Mat& deriv = pyramid.getMatRef(level * pyrstep + 1);
+
+            if(!deriv.empty())
+                deriv.adjustROI(winSize.height, winSize.height, winSize.width, winSize.width);
+            if(deriv.type() != derivType || deriv.cols != winSize.width*2 + sz.width || deriv.rows != winSize.height * 2 + sz.height)
+                deriv.create(sz.height + winSize.height*2, sz.width + winSize.width*2, derivType);
+
+            Mat derivI = deriv(Rect(winSize.width, winSize.height, sz.width, sz.height));
+            calcScharrDeriv(thisLevel, derivI);
+
+            if(derivBorder != BORDER_TRANSPARENT)
+                copyMakeBorder(derivI, deriv, winSize.height, winSize.height, winSize.width, winSize.width, derivBorder|BORDER_ISOLATED);
+            deriv.adjustROI(-winSize.height, -winSize.height, -winSize.width, -winSize.width);
+        }
+
+        sz = Size((sz.width+1)/2, (sz.height+1)/2);
+        if( sz.width <= winSize.width || sz.height <= winSize.height )
+        {
+            pyramid.create(1, (level + 1) * pyrstep, 0 /*type*/, -1, true);//check this
+            return level;
+        }
+
+        prevLevel = thisLevel;
+    }
+
+    return maxLevel;
+}
+
+namespace cv
+{
+namespace
+{
+    class SparsePyrLKOpticalFlowImpl : public SparsePyrLKOpticalFlow
+    {
+        struct dim3
+        {
+            unsigned int x, y, z;
+            dim3() : x(0), y(0), z(0) { }
+        };
+    public:
+        SparsePyrLKOpticalFlowImpl(Size winSize_ = Size(21,21),
+                         int maxLevel_ = 3,
+                         TermCriteria criteria_ = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
+                         int flags_ = 0,
+                         double minEigThreshold_ = 1e-4) :
+          winSize(winSize_), maxLevel(maxLevel_), criteria(criteria_), flags(flags_), minEigThreshold(minEigThreshold_)
+#ifdef HAVE_OPENCL
+          , iters(criteria_.maxCount), derivLambda(criteria_.epsilon), useInitialFlow(0 != (flags_ & OPTFLOW_LK_GET_MIN_EIGENVALS))
+#endif
+        {
+        }
+
+        virtual Size getWinSize() const CV_OVERRIDE { return winSize;}
+        virtual void setWinSize(Size winSize_) CV_OVERRIDE { winSize = winSize_;}
+
+        virtual int getMaxLevel() const CV_OVERRIDE { return maxLevel;}
+        virtual void setMaxLevel(int maxLevel_) CV_OVERRIDE { maxLevel = maxLevel_;}
+
+        virtual TermCriteria getTermCriteria() const CV_OVERRIDE { return criteria;}
+        virtual void setTermCriteria(TermCriteria& crit_) CV_OVERRIDE { criteria=crit_;}
+
+        virtual int getFlags() const CV_OVERRIDE { return flags; }
+        virtual void setFlags(int flags_) CV_OVERRIDE { flags=flags_;}
+
+        virtual double getMinEigThreshold() const CV_OVERRIDE { return minEigThreshold;}
+        virtual void setMinEigThreshold(double minEigThreshold_) CV_OVERRIDE { minEigThreshold=minEigThreshold_;}
+
+        virtual void calc(InputArray prevImg, InputArray nextImg,
+                          InputArray prevPts, InputOutputArray nextPts,
+                          OutputArray status,
+                          OutputArray err = cv::noArray()) CV_OVERRIDE;
+
+        virtual String getDefaultName() const CV_OVERRIDE { return "SparseOpticalFlow.SparsePyrLKOpticalFlow"; }
+
+    private:
+#ifdef HAVE_OPENCL
+        bool checkParam()
+        {
+            iters = std::min(std::max(iters, 0), 100);
+
+            derivLambda = std::min(std::max(derivLambda, 0.0), 1.0);
+            if (derivLambda < 0)
+                return false;
+            if (maxLevel < 0 || winSize.width <= 2 || winSize.height <= 2)
+                return false;
+            if (winSize.width < 8 || winSize.height < 8 ||
+                winSize.width > 24 || winSize.height > 24)
+                return false;
+            calcPatchSize();
+            if (patch.x <= 0 || patch.x >= 6 || patch.y <= 0 || patch.y >= 6)
+                return false;
+            return true;
+        }
+
+        bool sparse(const UMat &prevImg, const UMat &nextImg, const UMat &prevPts, UMat &nextPts, UMat &status, UMat &err)
+        {
+            if (!checkParam())
+                return false;
+
+            UMat temp1 = (useInitialFlow ? nextPts : prevPts).reshape(1);
+            UMat temp2 = nextPts.reshape(1);
+            multiply(1.0f / (1 << maxLevel) /2.0f, temp1, temp2);
+
+            status.setTo(Scalar::all(1));
+
+            // build the image pyramids.
+            std::vector<UMat> prevPyr; prevPyr.resize(maxLevel + 1);
+            std::vector<UMat> nextPyr; nextPyr.resize(maxLevel + 1);
+
+            // allocate buffers with aligned pitch to be able to use cl_khr_image2d_from_buffer extension
+            // This is the required pitch alignment in pixels
+            int pitchAlign = (int)ocl::Device::getDefault().imagePitchAlignment();
+            if (pitchAlign>0)
+            {
+                prevPyr[0] = UMat(prevImg.rows,(prevImg.cols+pitchAlign-1)&(-pitchAlign),CV_32FC1).colRange(0,prevImg.cols);
+                nextPyr[0] = UMat(nextImg.rows,(nextImg.cols+pitchAlign-1)&(-pitchAlign),CV_32FC1).colRange(0,nextImg.cols);
+                for (int level = 1; level <= maxLevel; ++level)
+                {
+                    int cols,rows;
+                    // allocate buffers with aligned pitch to be able to use image on buffer extension
+                    cols = (prevPyr[level - 1].cols+1)/2;
+                    rows = (prevPyr[level - 1].rows+1)/2;
+                    prevPyr[level] = UMat(rows,(cols+pitchAlign-1)&(-pitchAlign),prevPyr[level-1].type()).colRange(0,cols);
+                    cols = (nextPyr[level - 1].cols+1)/2;
+                    rows = (nextPyr[level - 1].rows+1)/2;
+                    nextPyr[level] = UMat(rows,(cols+pitchAlign-1)&(-pitchAlign),nextPyr[level-1].type()).colRange(0,cols);
+                }
+            }
+
+            prevImg.convertTo(prevPyr[0], CV_32F);
+            nextImg.convertTo(nextPyr[0], CV_32F);
+
+            for (int level = 1; level <= maxLevel; ++level)
+            {
+                pyrDown(prevPyr[level - 1], prevPyr[level]);
+                pyrDown(nextPyr[level - 1], nextPyr[level]);
+            }
+
+            // dI/dx ~ Ix, dI/dy ~ Iy
+            for (int level = maxLevel; level >= 0; level--)
+            {
+                if (!lkSparse_run(prevPyr[level], nextPyr[level], prevPts,
+                                  nextPts, status, err,
+                                  static_cast<int>(prevPts.total()),
+                                  level))
+                    return false;
+            }
+            return true;
+        }
+#endif
+
+        Size winSize;
+        int maxLevel;
+        TermCriteria criteria;
+        int flags;
+        double minEigThreshold;
+#ifdef HAVE_OPENCL
+        int iters;
+        double derivLambda;
+        bool useInitialFlow;
+        dim3 patch;
+        void calcPatchSize()
+        {
+            dim3 block;
+
+            if (winSize.width > 32 && winSize.width > 2 * winSize.height)
+            {
+                block.x = 32;
+                block.y = 8;
+            }
+            else
+            {
+                block.x = 16;
+                block.y = 16;
+            }
+
+            patch.x = (winSize.width  + block.x - 1) / block.x;
+            patch.y = (winSize.height + block.y - 1) / block.y;
+
+            block.z = patch.z = 1;
+        }
+
+        bool lkSparse_run(UMat &I, UMat &J, const UMat &prevPts, UMat &nextPts, UMat &status, UMat& err,
+            int ptcount, int level)
+        {
+            size_t localThreads[3]  = { 8, 8};
+            size_t globalThreads[3] = { 8 * (size_t)ptcount, 8};
+            char calcErr = (0 == level) ? 1 : 0;
+
+            int wsx = 1, wsy = 1;
+            if(winSize.width < 16)
+                wsx = 0;
+            if(winSize.height < 16)
+                wsy = 0;
+            cv::String build_options;
+            if (isDeviceCPU())
+                build_options = " -D CPU";
+            else
+                build_options = cv::format("-D WSX=%d -D WSY=%d",
+                                           wsx, wsy);
+
+            ocl::Kernel kernel;
+            if (!kernel.create("lkSparse", cv::ocl::video::pyrlk_oclsrc, build_options))
+                return false;
+
+            CV_Assert(I.depth() == CV_32F && J.depth() == CV_32F);
+            ocl::Image2D imageI(I, false, ocl::Image2D::canCreateAlias(I));
+            ocl::Image2D imageJ(J, false, ocl::Image2D::canCreateAlias(J));
+
+            int idxArg = 0;
+            idxArg = kernel.set(idxArg, imageI); //image2d_t I
+            idxArg = kernel.set(idxArg, imageJ); //image2d_t J
+            idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(prevPts)); // __global const float2* prevPts
+            idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadWrite(nextPts)); // __global const float2* nextPts
+            idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadWrite(status)); // __global uchar* status
+            idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadWrite(err)); // __global float* err
+            idxArg = kernel.set(idxArg, (int)level); // const int level
+            idxArg = kernel.set(idxArg, (int)I.rows); // const int rows
+            idxArg = kernel.set(idxArg, (int)I.cols); // const int cols
+            idxArg = kernel.set(idxArg, (int)patch.x); // int PATCH_X
+            idxArg = kernel.set(idxArg, (int)patch.y); // int PATCH_Y
+            idxArg = kernel.set(idxArg, (int)winSize.width); // int c_winSize_x
+            idxArg = kernel.set(idxArg, (int)winSize.height); // int c_winSize_y
+            idxArg = kernel.set(idxArg, (int)iters); // int c_iters
+            idxArg = kernel.set(idxArg, (char)calcErr); //char calcErr
+            return kernel.run(2, globalThreads, localThreads, true); // sync=true because ocl::Image2D lifetime is not handled well for temp UMat
+        }
+    private:
+        inline static bool isDeviceCPU()
+        {
+            return (cv::ocl::Device::TYPE_CPU == cv::ocl::Device::getDefault().type());
+        }
+
+
+    bool ocl_calcOpticalFlowPyrLK(InputArray _prevImg, InputArray _nextImg,
+                                         InputArray _prevPts, InputOutputArray _nextPts,
+                                         OutputArray _status, OutputArray _err)
+    {
+        if (0 != (OPTFLOW_LK_GET_MIN_EIGENVALS & flags))
+            return false;
+        if (!cv::ocl::Device::getDefault().imageSupport())
+            return false;
+        if (_nextImg.size() != _prevImg.size())
+            return false;
+        int typePrev = _prevImg.type();
+        int typeNext = _nextImg.type();
+        if ((1 != CV_MAT_CN(typePrev)) || (1 != CV_MAT_CN(typeNext)))
+            return false;
+        if ((0 != CV_MAT_DEPTH(typePrev)) || (0 != CV_MAT_DEPTH(typeNext)))
+            return false;
+
+        if (_prevPts.empty() || _prevPts.type() != CV_32FC2 || (!_prevPts.isContinuous()))
+            return false;
+        if ((1 != _prevPts.size().height) && (1 != _prevPts.size().width))
+            return false;
+        size_t npoints = _prevPts.total();
+        if (useInitialFlow)
+        {
+            if (_nextPts.empty() || _nextPts.type() != CV_32FC2 || (!_prevPts.isContinuous()))
+                return false;
+            if ((1 != _nextPts.size().height) && (1 != _nextPts.size().width))
+                return false;
+            if (_nextPts.total() != npoints)
+                return false;
+        }
+        else
+        {
+            _nextPts.create(_prevPts.size(), _prevPts.type());
+        }
+
+        if (!checkParam())
+            return false;
+
+        UMat umatErr;
+        if (_err.needed())
+        {
+            _err.create((int)npoints, 1, CV_32FC1);
+            umatErr = _err.getUMat();
+        }
+        else
+            umatErr.create((int)npoints, 1, CV_32FC1);
+
+        _status.create((int)npoints, 1, CV_8UC1);
+        UMat umatNextPts = _nextPts.getUMat();
+        UMat umatStatus = _status.getUMat();
+        UMat umatPrevPts;
+        _prevPts.getMat().copyTo(umatPrevPts);
+        return sparse(_prevImg.getUMat(), _nextImg.getUMat(), umatPrevPts, umatNextPts, umatStatus, umatErr);
+    }
+#endif
+
+};
+
+
+
+void SparsePyrLKOpticalFlowImpl::calc( InputArray _prevImg, InputArray _nextImg,
+                           InputArray _prevPts, InputOutputArray _nextPts,
+                           OutputArray _status, OutputArray _err)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_OCL_RUN(ocl::isOpenCLActivated() &&
+               (_prevImg.isUMat() || _nextImg.isUMat()) &&
+               ocl::Image2D::isFormatSupported(CV_32F, 1, false),
+               ocl_calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err))
+
+    Mat prevPtsMat = _prevPts.getMat();
+    const int derivDepth = DataType<cv::detail::deriv_type>::depth;
+
+    CV_Assert( maxLevel >= 0 && winSize.width > 2 && winSize.height > 2 );
+
+    int level=0, i, npoints;
+    CV_Assert( (npoints = prevPtsMat.checkVector(2, CV_32F, true)) >= 0 );
+
+    if( npoints == 0 )
+    {
+        _nextPts.release();
+        _status.release();
+        _err.release();
+        return;
+    }
+
+    if( !(flags & OPTFLOW_USE_INITIAL_FLOW) )
+        _nextPts.create(prevPtsMat.size(), prevPtsMat.type(), -1, true);
+
+    Mat nextPtsMat = _nextPts.getMat();
+    CV_Assert( nextPtsMat.checkVector(2, CV_32F, true) == npoints );
+
+    const Point2f* prevPts = prevPtsMat.ptr<Point2f>();
+    Point2f* nextPts = nextPtsMat.ptr<Point2f>();
+
+    _status.create((int)npoints, 1, CV_8U, -1, true);
+    Mat statusMat = _status.getMat(), errMat;
+    CV_Assert( statusMat.isContinuous() );
+    uchar* status = statusMat.ptr();
+    float* err = 0;
+
+    for( i = 0; i < npoints; i++ )
+        status[i] = true;
+
+    if( _err.needed() )
+    {
+        _err.create((int)npoints, 1, CV_32F, -1, true);
+        errMat = _err.getMat();
+        CV_Assert( errMat.isContinuous() );
+        err = errMat.ptr<float>();
+    }
+
+    std::vector<Mat> prevPyr, nextPyr;
+    int levels1 = -1;
+    int lvlStep1 = 1;
+    int levels2 = -1;
+    int lvlStep2 = 1;
+
+    if(_prevImg.kind() == _InputArray::STD_VECTOR_MAT)
+    {
+        _prevImg.getMatVector(prevPyr);
+
+        levels1 = int(prevPyr.size()) - 1;
+        CV_Assert(levels1 >= 0);
+
+        if (levels1 % 2 == 1 && prevPyr[0].channels() * 2 == prevPyr[1].channels() && prevPyr[1].depth() == derivDepth)
+        {
+            lvlStep1 = 2;
+            levels1 /= 2;
+        }
+
+        // ensure that pyramid has required padding
+        if(levels1 > 0)
+        {
+            Size fullSize;
+            Point ofs;
+            prevPyr[lvlStep1].locateROI(fullSize, ofs);
+            CV_Assert(ofs.x >= winSize.width && ofs.y >= winSize.height
+                && ofs.x + prevPyr[lvlStep1].cols + winSize.width <= fullSize.width
+                && ofs.y + prevPyr[lvlStep1].rows + winSize.height <= fullSize.height);
+        }
+
+        if(levels1 < maxLevel)
+            maxLevel = levels1;
+    }
+
+    if(_nextImg.kind() == _InputArray::STD_VECTOR_MAT)
+    {
+        _nextImg.getMatVector(nextPyr);
+
+        levels2 = int(nextPyr.size()) - 1;
+        CV_Assert(levels2 >= 0);
+
+        if (levels2 % 2 == 1 && nextPyr[0].channels() * 2 == nextPyr[1].channels() && nextPyr[1].depth() == derivDepth)
+        {
+            lvlStep2 = 2;
+            levels2 /= 2;
+        }
+
+        // ensure that pyramid has required padding
+        if(levels2 > 0)
+        {
+            Size fullSize;
+            Point ofs;
+            nextPyr[lvlStep2].locateROI(fullSize, ofs);
+            CV_Assert(ofs.x >= winSize.width && ofs.y >= winSize.height
+                && ofs.x + nextPyr[lvlStep2].cols + winSize.width <= fullSize.width
+                && ofs.y + nextPyr[lvlStep2].rows + winSize.height <= fullSize.height);
+        }
+
+        if(levels2 < maxLevel)
+            maxLevel = levels2;
+    }
+
+    if (levels1 < 0)
+        maxLevel = buildOpticalFlowPyramid(_prevImg, prevPyr, winSize, maxLevel, false);
+
+    if (levels2 < 0)
+        maxLevel = buildOpticalFlowPyramid(_nextImg, nextPyr, winSize, maxLevel, false);
+
+    if( (criteria.type & TermCriteria::COUNT) == 0 )
+        criteria.maxCount = 30;
+    else
+        criteria.maxCount = std::min(std::max(criteria.maxCount, 0), 100);
+    if( (criteria.type & TermCriteria::EPS) == 0 )
+        criteria.epsilon = 0.01;
+    else
+        criteria.epsilon = std::min(std::max(criteria.epsilon, 0.), 10.);
+    criteria.epsilon *= criteria.epsilon;
+
+    // dI/dx ~ Ix, dI/dy ~ Iy
+    Mat derivIBuf;
+    if(lvlStep1 == 1)
+        derivIBuf.create(prevPyr[0].rows + winSize.height*2, prevPyr[0].cols + winSize.width*2, CV_MAKETYPE(derivDepth, prevPyr[0].channels() * 2));
+
+    for( level = maxLevel; level >= 0; level-- )
+    {
+        Mat derivI;
+        if(lvlStep1 == 1)
+        {
+            Size imgSize = prevPyr[level * lvlStep1].size();
+            Mat _derivI( imgSize.height + winSize.height*2,
+                imgSize.width + winSize.width*2, derivIBuf.type(), derivIBuf.ptr() );
+            derivI = _derivI(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
+            calcScharrDeriv(prevPyr[level * lvlStep1], derivI);
+            copyMakeBorder(derivI, _derivI, winSize.height, winSize.height, winSize.width, winSize.width, BORDER_CONSTANT|BORDER_ISOLATED);
+        }
+        else
+            derivI = prevPyr[level * lvlStep1 + 1];
+
+        CV_Assert(prevPyr[level * lvlStep1].size() == nextPyr[level * lvlStep2].size());
+        CV_Assert(prevPyr[level * lvlStep1].type() == nextPyr[level * lvlStep2].type());
+
+        typedef cv::detail::LKTrackerInvoker LKTrackerInvoker;
+        parallel_for_(Range(0, npoints), LKTrackerInvoker(prevPyr[level * lvlStep1], derivI,
+                                                          nextPyr[level * lvlStep2], prevPts, nextPts,
+                                                          status, err,
+                                                          winSize, criteria, level, maxLevel,
+                                                          flags, (float)minEigThreshold));
+    }
+}
+
+} // namespace
+} // namespace cv
+cv::Ptr<cv::SparsePyrLKOpticalFlow> cv::SparsePyrLKOpticalFlow::create(Size winSize, int maxLevel, TermCriteria crit, int flags, double minEigThreshold){
+    return makePtr<SparsePyrLKOpticalFlowImpl>(winSize,maxLevel,crit,flags,minEigThreshold);
+}
+void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
+                               InputArray _prevPts, InputOutputArray _nextPts,
+                               OutputArray _status, OutputArray _err,
+                               Size winSize, int maxLevel,
+                               TermCriteria criteria,
+                               int flags, double minEigThreshold )
+{
+    Ptr<cv::SparsePyrLKOpticalFlow> optflow = cv::SparsePyrLKOpticalFlow::create(winSize,maxLevel,criteria,flags,minEigThreshold);
+    optflow->calc(_prevImg,_nextImg,_prevPts,_nextPts,_status,_err);
+}
+
+cv::Mat cv::estimateRigidTransform( InputArray src1, InputArray src2, bool fullAffine )
+{
+    CV_INSTRUMENT_REGION();
+#ifndef HAVE_OPENCV_GEOMETRY
+    CV_UNUSED(src1); CV_UNUSED(src2); CV_UNUSED(fullAffine);
+    CV_Error(Error::StsError, "estimateRigidTransform requires geometry module");
+#else
+    Mat A = src1.getMat(), B = src2.getMat();
+
+    const int COUNT = 15;
+    const int WIDTH = 160, HEIGHT = 120;
+
+    std::vector<Point2f> pA, pB;
+    std::vector<uchar> status;
+
+    double scale = 1.;
+    int i, j, k;
+
+    if( A.size() != B.size() )
+        CV_Error( Error::StsUnmatchedSizes, "Both input images must have the same size" );
+
+    if( A.type() != B.type() )
+        CV_Error( Error::StsUnmatchedFormats, "Both input images must have the same data type" );
+
+    int count = A.checkVector(2);
+
+    if( count > 0 )
+    {
+        // inputs are points
+        A.reshape(2, count).convertTo(pA, CV_32F);
+        B.reshape(2, count).convertTo(pB, CV_32F);
+    }
+    else if( A.depth() == CV_8U )
+    {
+        // inputs are images
+        int cn = A.channels();
+        CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+        Size sz0 = A.size();
+        Size sz1(WIDTH, HEIGHT);
+
+        scale = std::max(1., std::max( (double)sz1.width/sz0.width, (double)sz1.height/sz0.height ));
+
+        sz1.width = cvRound( sz0.width * scale );
+        sz1.height = cvRound( sz0.height * scale );
+
+        bool equalSizes = sz1.width == sz0.width && sz1.height == sz0.height;
+
+        if( !equalSizes || cn != 1 )
+        {
+            Mat sA, sB;
+
+            if( cn != 1 )
+            {
+                Mat gray;
+                cvtColor(A, gray, COLOR_BGR2GRAY);
+                resize(gray, sA, sz1, 0., 0., INTER_AREA);
+                cvtColor(B, gray, COLOR_BGR2GRAY);
+                resize(gray, sB, sz1, 0., 0., INTER_AREA);
+            }
+            else
+            {
+                resize(A, sA, sz1, 0., 0., INTER_AREA);
+                resize(B, sB, sz1, 0., 0., INTER_AREA);
+            }
+
+            A = sA;
+            B = sB;
+        }
+
+        int count_y = COUNT;
+        int count_x = cvRound((double)COUNT*sz1.width/sz1.height);
+        count = count_x * count_y;
+
+        pA.resize(count);
+        pB.resize(count);
+        status.resize(count);
+
+        for( i = 0, k = 0; i < count_y; i++ )
+            for( j = 0; j < count_x; j++, k++ )
+            {
+                pA[k].x = (j+0.5f)*sz1.width/count_x;
+                pA[k].y = (i+0.5f)*sz1.height/count_y;
+            }
+
+        // find the corresponding points in B
+        calcOpticalFlowPyrLK(A, B, pA, pB, status, noArray(), Size(21, 21), 3,
+                             TermCriteria(TermCriteria::MAX_ITER,40,0.1));
+
+        // repack the remained points
+        for( i = 0, k = 0; i < count; i++ )
+            if( status[i] )
+            {
+                if( i > k )
+                {
+                    pA[k] = pA[i];
+                    pB[k] = pB[i];
+                }
+                k++;
+            }
+        count = k;
+        pA.resize(count);
+        pB.resize(count);
+    }
+    else
+        CV_Error( Error::StsUnsupportedFormat, "Both input images must have either 8uC1 or 8uC3 type" );
+
+    if (fullAffine)
+    {
+        return estimateAffine2D(pA, pB);
+    }
+    else
+    {
+        return estimateAffinePartial2D(pA, pB);
+    }
+#endif
+}
diff --git a/upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp b/upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp
new file mode 100644
index 0000000..2775d9a
--- /dev/null
+++ b/upstream/opencv/modules/video/src/lkpyramid.dispatch.cpp
@@ -0,0 +1,22 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+// Copyright (C) 2026, Advanced Micro Devices, Inc., all rights reserved.
+
+#include "precomp.hpp"
+#include "lkpyramid.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+
+#include "lkpyramid.simd.hpp"
+#include "lkpyramid.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL based on CMakeLists.txt
+
+namespace cv {
+namespace detail {
+
+void ScharrDerivInvoker_impl(const Mat& src, Mat& dst, const Range& range)
+{
+    CV_CPU_DISPATCH(ScharrDerivInvoker_SIMD, (src, dst, range), CV_CPU_DISPATCH_MODES_ALL);
+}
+
+} // namespace detail
+} // namespace cv
diff --git a/upstream/opencv/modules/video/src/lkpyramid.hpp b/upstream/opencv/modules/video/src/lkpyramid.hpp
new file mode 100644
index 0000000..18ff61c
--- /dev/null
+++ b/upstream/opencv/modules/video/src/lkpyramid.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+namespace cv
+{
+namespace detail
+{
+
+    typedef short deriv_type;
+
+    void ScharrDerivInvoker_impl(const Mat& src, Mat& dst, const Range& range);
+
+    struct ScharrDerivInvoker : ParallelLoopBody
+    {
+        ScharrDerivInvoker(const Mat& _src, const Mat& _dst)
+            : src(_src), dst(_dst)
+        { }
+
+        void operator()(const Range& range) const CV_OVERRIDE;
+
+        const Mat& src;
+        const Mat& dst;
+    };
+
+    struct LKTrackerInvoker : ParallelLoopBody
+    {
+        LKTrackerInvoker( const Mat& _prevImg, const Mat& _prevDeriv, const Mat& _nextImg,
+                          const Point2f* _prevPts, Point2f* _nextPts,
+                          uchar* _status, float* _err,
+                          Size _winSize, TermCriteria _criteria,
+                          int _level, int _maxLevel, int _flags, float _minEigThreshold );
+
+        void operator()(const Range& range) const CV_OVERRIDE;
+
+        const Mat* prevImg;
+        const Mat* nextImg;
+        const Mat* prevDeriv;
+        const Point2f* prevPts;
+        Point2f* nextPts;
+        uchar* status;
+        float* err;
+        Size winSize;
+        TermCriteria criteria;
+        int level;
+        int maxLevel;
+        int flags;
+        float minEigThreshold;
+    };
+
+}// namespace detail
+}// namespace cv
diff --git a/upstream/opencv/modules/video/src/lkpyramid.simd.hpp b/upstream/opencv/modules/video/src/lkpyramid.simd.hpp
new file mode 100644
index 0000000..4408b8a
--- /dev/null
+++ b/upstream/opencv/modules/video/src/lkpyramid.simd.hpp
@@ -0,0 +1,118 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+// Copyright (C) 2026, Advanced Micro Devices, Inc., all rights reserved.
+#include "precomp.hpp"
+#include "lkpyramid.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+
+namespace cv {
+namespace detail {
+
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+// SIMD-optimized implementation
+void ScharrDerivInvoker_SIMD(const Mat& src, Mat& dst, const Range& range);
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+
+} // namespace detail
+} // namespace cv
+
+#ifndef CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+namespace cv {
+namespace detail {
+
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+void ScharrDerivInvoker_SIMD(const Mat& src, Mat& dst, const Range& range)
+{
+    typedef short deriv_type;
+    int rows = src.rows, cols = src.cols, cn = src.channels(), colsn = cols*cn;
+
+    int x, y, delta = (int)alignSize((cols + 2)*cn, 16);
+    AutoBuffer<deriv_type> _tempBuf(delta*2 + 64);
+    deriv_type *trow0 = alignPtr(_tempBuf.data() + cn, 16), *trow1 = alignPtr(trow0 + delta, 16);
+
+#if (CV_SIMD)
+    const int vlanes = VTraits<v_int16>::vlanes();
+    v_int16 c3 = vx_setall_s16(3), c10 = vx_setall_s16(10);
+#endif
+
+    for( y = range.start; y < range.end; y++ )
+    {
+        const uchar* srow0 = src.ptr<uchar>(y > 0 ? y-1 : rows > 1 ? 1 : 0);
+        const uchar* srow1 = src.ptr<uchar>(y);
+        const uchar* srow2 = src.ptr<uchar>(y < rows-1 ? y+1 : rows > 1 ? rows-2 : 0);
+        deriv_type* drow = (deriv_type *)dst.ptr<deriv_type>(y);
+
+        // do vertical convolution
+        x = 0;
+#if (CV_SIMD)
+        {
+            for( ; x <= colsn - vlanes; x += vlanes )
+            {
+                v_int16 s0 = v_reinterpret_as_s16(vx_load_expand(srow0 + x));
+                v_int16 s1 = v_reinterpret_as_s16(vx_load_expand(srow1 + x));
+                v_int16 s2 = v_reinterpret_as_s16(vx_load_expand(srow2 + x));
+
+                v_int16 t1 = v_sub(s2, s0);
+                v_int16 t0 = v_add(v_mul_wrap(v_add(s0, s2), c3), v_mul_wrap(s1, c10));
+
+                v_store(trow0 + x, t0);
+                v_store(trow1 + x, t1);
+            }
+        }
+#endif
+
+        for( ; x < colsn; x++ )
+        {
+            int t0 = (srow0[x] + srow2[x])*3 + srow1[x]*10;
+            int t1 = srow2[x] - srow0[x];
+            trow0[x] = (deriv_type)t0;
+            trow1[x] = (deriv_type)t1;
+        }
+
+        // make border
+        int x0 = (cols > 1 ? 1 : 0)*cn, x1 = (cols > 1 ? cols-2 : 0)*cn;
+        for( int k = 0; k < cn; k++ )
+        {
+            trow0[-cn + k] = trow0[x0 + k]; trow0[colsn + k] = trow0[x1 + k];
+            trow1[-cn + k] = trow1[x0 + k]; trow1[colsn + k] = trow1[x1 + k];
+        }
+
+        // do horizontal convolution, interleave the results and store them to dst
+        x = 0;
+#if (CV_SIMD)
+        {
+            for( ; x <= colsn - vlanes; x += vlanes )
+            {
+                v_int16 s0 = vx_load(trow0 + x - cn);
+                v_int16 s1 = vx_load(trow0 + x + cn);
+                v_int16 s2 = vx_load(trow1 + x - cn);
+                v_int16 s3 = vx_load(trow1 + x);
+                v_int16 s4 = vx_load(trow1 + x + cn);
+
+                v_int16 t0 = v_sub(s1, s0);
+                v_int16 t1 = v_add(v_mul_wrap(v_add(s2, s4), c3), v_mul_wrap(s3, c10));
+
+                v_store_interleave((drow + x*2), t0, t1);
+            }
+        }
+#endif
+        for( ; x < colsn; x++ )
+        {
+            deriv_type t0 = (deriv_type)(trow0[x+cn] - trow0[x-cn]);
+            deriv_type t1 = (deriv_type)((trow1[x+cn] + trow1[x-cn])*3 + trow1[x]*10);
+            drow[x*2] = t0; drow[x*2+1] = t1;
+        }
+    }
+}
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+
+} // namespace detail
+} // namespace cv
+
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
diff --git a/upstream/opencv/modules/video/src/opencl/bgfg_knn.cl b/upstream/opencv/modules/video/src/opencl/bgfg_knn.cl
new file mode 100644
index 0000000..0205dba
--- /dev/null
+++ b/upstream/opencv/modules/video/src/opencl/bgfg_knn.cl
@@ -0,0 +1,248 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2018 Ya-Chiu Wu, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Ya-Chiu Wu, yacwu@cs.nctu.edu.tw
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if CN==1
+
+#define T_MEAN float
+#define F_ZERO (0.0f)
+
+#define frameToMean(a, b) (b) = *(a);
+#define meanToFrame(a, b) *b = convert_uchar_sat(a);
+
+#else
+
+#define T_MEAN float4
+#define F_ZERO (0.0f, 0.0f, 0.0f, 0.0f)
+
+#define meanToFrame(a, b)\
+    b[0] = convert_uchar_sat(a.x); \
+    b[1] = convert_uchar_sat(a.y); \
+    b[2] = convert_uchar_sat(a.z);
+
+#define frameToMean(a, b)\
+    b.x = a[0]; \
+    b.y = a[1]; \
+    b.z = a[2]; \
+    b.w = 0.0f;
+
+#endif
+
+__kernel void knn_kernel(__global const uchar* frame, int frame_step, int frame_offset, int frame_row, int frame_col,
+                         __global const uchar* nNextLongUpdate,
+                         __global const uchar* nNextMidUpdate,
+                         __global const uchar* nNextShortUpdate,
+                         __global uchar* aModelIndexLong,
+                         __global uchar* aModelIndexMid,
+                         __global uchar* aModelIndexShort,
+                         __global uchar* flag,
+                         __global uchar* sample,
+                         __global uchar* fgmask, int fgmask_step, int fgmask_offset,
+                         int nLongCounter, int nMidCounter, int nShortCounter,
+                         float c_Tb, int c_nkNN, float c_tau
+#ifdef SHADOW_DETECT
+                         , uchar c_shadowVal
+#endif
+                         )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if( x < frame_col && y < frame_row)
+    {
+        __global const uchar* _frame = (frame + mad24(y, frame_step, mad24(x, CN, frame_offset)));
+        T_MEAN pix;
+        frameToMean(_frame, pix);
+
+        uchar foreground = 255; // 0 - the pixel classified as background
+
+        int Pbf = 0;
+        int Pb = 0;
+        uchar include = 0;
+
+        int pt_idx =  mad24(y, frame_col, x);
+        int idx_step = frame_row * frame_col;
+
+        __global T_MEAN* _sample = (__global T_MEAN*)(sample);
+
+        for (uchar n = 0; n < (NSAMPLES) * 3 ; ++n)
+        {
+            int n_idx = mad24(n, idx_step, pt_idx);
+
+            T_MEAN c_mean = _sample[n_idx];
+
+            uchar c_flag = flag[n_idx];
+
+            T_MEAN diff = c_mean - pix;
+            float dist2 = dot(diff, diff);
+
+            if (dist2 < c_Tb)
+            {
+                Pbf++;
+                if (c_flag)
+                {
+                    Pb++;
+                    if (Pb >= c_nkNN)
+                    {
+                        include = 1;
+                        foreground = 0;
+                        break;
+                    }
+                }
+            }
+        }
+        if (Pbf >= c_nkNN)
+        {
+            include = 1;
+        }
+
+#ifdef SHADOW_DETECT
+        if (foreground)
+        {
+            int Ps = 0;
+            for (uchar n = 0; n < (NSAMPLES) * 3 ; ++n)
+            {
+                int n_idx = mad24(n, idx_step, pt_idx);
+                uchar c_flag = flag[n_idx];
+
+                if (c_flag)
+                {
+                    T_MEAN c_mean = _sample[n_idx];
+
+                    float numerator = dot(pix, c_mean);
+                    float denominator = dot(c_mean, c_mean);
+
+                    if (denominator == 0)
+                        break;
+
+                    if (numerator <= denominator && numerator >= c_tau * denominator)
+                    {
+                        float a = numerator / denominator;
+
+                        T_MEAN dD = mad(a, c_mean, -pix);
+
+                        if (dot(dD, dD) < c_Tb * a * a)
+                        {
+                            Ps++;
+                            if (Ps >= c_nkNN)
+                            {
+                                foreground = c_shadowVal;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+#endif
+        __global uchar* _fgmask = fgmask + mad24(y, fgmask_step, x + fgmask_offset);
+        *_fgmask = (uchar)foreground;
+
+        __global const uchar* _nNextLongUpdate = nNextLongUpdate + pt_idx;
+        __global const uchar* _nNextMidUpdate = nNextMidUpdate + pt_idx;
+        __global const uchar* _nNextShortUpdate = nNextShortUpdate + pt_idx;
+        __global uchar* _aModelIndexLong = aModelIndexLong + pt_idx;
+        __global uchar* _aModelIndexMid = aModelIndexMid + pt_idx;
+        __global uchar* _aModelIndexShort = aModelIndexShort + pt_idx;
+
+        uchar nextLongUpdate = _nNextLongUpdate[0];
+        uchar nextMidUpdate = _nNextMidUpdate[0];
+        uchar nextShortUpdate = _nNextShortUpdate[0];
+        uchar modelIndexLong = _aModelIndexLong[0];
+        uchar modelIndexMid = _aModelIndexMid[0];
+        uchar modelIndexShort = _aModelIndexShort[0];
+        int offsetLong = mad24(mad24(2, (NSAMPLES), modelIndexLong), idx_step, pt_idx);
+        int offsetMid = mad24((NSAMPLES)+modelIndexMid, idx_step, pt_idx);
+        int offsetShort = mad24(modelIndexShort, idx_step, pt_idx);
+        if (nextLongUpdate == nLongCounter)
+        {
+            _sample[offsetLong] = _sample[offsetMid];
+            flag[offsetLong] = flag[offsetMid];
+            _aModelIndexLong[0] = (modelIndexLong >= ((NSAMPLES)-1)) ? 0 : (modelIndexLong + 1);
+        }
+
+        if (nextMidUpdate == nMidCounter)
+        {
+            _sample[offsetMid] = _sample[offsetShort];
+            flag[offsetMid] = flag[offsetShort];
+            _aModelIndexMid[0] = (modelIndexMid >= ((NSAMPLES)-1)) ? 0 : (modelIndexMid + 1);
+        }
+
+        if (nextShortUpdate == nShortCounter)
+        {
+            _sample[offsetShort] = pix;
+            flag[offsetShort] = include;
+            _aModelIndexShort[0] = (modelIndexShort >= ((NSAMPLES)-1)) ? 0 : (modelIndexShort + 1);
+        }
+    }
+}
+
+__kernel void getBackgroundImage2_kernel(__global const uchar* flag,
+                                         __global const uchar* sample,
+                                         __global uchar* dst, int dst_step, int dst_offset, int dst_row, int dst_col)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x < dst_col && y < dst_row)
+    {
+        int pt_idx =  mad24(y, dst_col, x);
+
+        T_MEAN meanVal = (T_MEAN)F_ZERO;
+
+        __global T_MEAN* _sample = (__global T_MEAN*)(sample);
+        int idx_step = dst_row * dst_col;
+        for (uchar n = 0; n < (NSAMPLES) * 3 ; ++n)
+        {
+            int n_idx = mad24(n, idx_step, pt_idx);
+            uchar c_flag = flag[n_idx];
+            if(c_flag)
+            {
+                meanVal = _sample[n_idx];
+                break;
+            }
+        }
+        __global uchar* _dst = dst + mad24(y, dst_step, mad24(x, CN, dst_offset));
+        meanToFrame(meanVal, _dst);
+    }
+}
diff --git a/upstream/opencv/modules/video/src/opencl/bgfg_mog2.cl b/upstream/opencv/modules/video/src/opencl/bgfg_mog2.cl
new file mode 100644
index 0000000..2bdcc2e
--- /dev/null
+++ b/upstream/opencv/modules/video/src/opencl/bgfg_mog2.cl
@@ -0,0 +1,282 @@
+#if CN==1
+
+#define T_MEAN float
+#define F_ZERO (0.0f)
+#define cnMode 1
+
+#define frameToMean(a, b) (b) = *(a);
+#if FL==0
+#define meanToFrame(a, b) *b = convert_uchar_sat(a);
+#else
+#define meanToFrame(a, b) *b = (float)a;
+#endif
+
+#else
+
+#define T_MEAN float4
+#define F_ZERO (0.0f, 0.0f, 0.0f, 0.0f)
+#define cnMode 4
+
+#if FL == 0
+#define meanToFrame(a, b)\
+    b[0] = convert_uchar_sat(a.x); \
+    b[1] = convert_uchar_sat(a.y); \
+    b[2] = convert_uchar_sat(a.z);
+#else
+#define meanToFrame(a, b)\
+    b[0] = a.x; \
+    b[1] = a.y; \
+    b[2] = a.z;
+#endif
+
+#define frameToMean(a, b)\
+    b.x = a[0]; \
+    b.y = a[1]; \
+    b.z = a[2]; \
+    b.w = 0.0f;
+
+#endif
+
+__kernel void mog2_kernel(__global const uchar* frame, int frame_step, int frame_offset, int frame_row, int frame_col,  //uchar || uchar3
+                          __global uchar* modesUsed,                                                                    //uchar
+                          __global uchar* weight,                                                                       //float
+                          __global uchar* mean,                                                                         //T_MEAN=float || float4
+                          __global uchar* variance,                                                                     //float
+                          __global uchar* fgmask, int fgmask_step, int fgmask_offset,                                   //uchar
+                          float alphaT, float alpha1, float prune,
+                          float c_Tb, float c_TB, float c_Tg, float c_varMin,                                           //constants
+                          float c_varMax, float c_varInit, float c_tau
+#ifdef SHADOW_DETECT
+                          , uchar c_shadowVal
+#endif
+                          )
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if( x < frame_col && y < frame_row)
+    {
+        #if FL==0
+        __global const uchar* _frame = (frame + mad24(y, frame_step, mad24(x, CN, frame_offset)));
+        #else
+        __global const float* _frame = ((__global const float*)( frame + mad24(y, frame_step, frame_offset)) + mad24(x, CN, 0));
+        #endif
+        T_MEAN pix;
+        frameToMean(_frame, pix);
+
+        uchar foreground = 255; // 0 - the pixel classified as background
+
+        bool fitsPDF = false; //if it remains zero a new GMM mode will be added
+
+        int pt_idx =  mad24(y, frame_col, x);
+        int idx_step = frame_row * frame_col;
+
+        __global uchar* _modesUsed = modesUsed + pt_idx;
+        uchar nmodes = _modesUsed[0];
+
+        float totalWeight = 0.0f;
+
+        __global float* _weight = (__global float*)(weight);
+        __global float* _variance = (__global float*)(variance);
+        __global T_MEAN* _mean = (__global T_MEAN*)(mean);
+
+        uchar mode = 0;
+        for (; mode < nmodes; ++mode)
+        {
+            int mode_idx = mad24(mode, idx_step, pt_idx);
+            float c_weight = mad(alpha1, _weight[mode_idx], prune);
+
+            float c_var = _variance[mode_idx];
+
+            T_MEAN c_mean = _mean[mode_idx];
+
+            T_MEAN diff = c_mean - pix;
+            float dist2 = dot(diff, diff);
+
+            if (totalWeight < c_TB && dist2 < c_Tb * c_var)
+                foreground = 0;
+
+            if (dist2 < c_Tg * c_var)
+            {
+                fitsPDF = true;
+                c_weight += alphaT;
+
+                float k = alphaT / c_weight;
+                T_MEAN mean_new = mad((T_MEAN)-k, diff, c_mean);
+                float variance_new  = clamp(mad(k, (dist2 - c_var), c_var), c_varMin, c_varMax);
+
+                for (int i = mode; i > 0; --i)
+                {
+                    int prev_idx = mode_idx - idx_step;
+                    if (c_weight < _weight[prev_idx])
+                        break;
+
+                    _weight[mode_idx]   = _weight[prev_idx];
+                    _variance[mode_idx] = _variance[prev_idx];
+                    _mean[mode_idx]     = _mean[prev_idx];
+
+                    mode_idx = prev_idx;
+                }
+
+                _mean[mode_idx]     = mean_new;
+                _variance[mode_idx] = variance_new;
+                _weight[mode_idx]   = c_weight; //update weight by the calculated value
+
+                totalWeight += c_weight;
+
+                mode ++;
+
+                break;
+            }
+            if (c_weight < -prune)
+                c_weight = 0.0f;
+
+            _weight[mode_idx] = c_weight; //update weight by the calculated value
+            totalWeight += c_weight;
+        }
+
+        for (; mode < nmodes; ++mode)
+        {
+            int mode_idx = mad24(mode, idx_step, pt_idx);
+            float c_weight = mad(alpha1, _weight[mode_idx], prune);
+
+            if (c_weight < -prune)
+            {
+                c_weight = 0.0f;
+                nmodes = mode;
+                break;
+            }
+            _weight[mode_idx] = c_weight; //update weight by the calculated value
+            totalWeight += c_weight;
+        }
+
+        if (0.f < totalWeight)
+        {
+            totalWeight = 1.f / totalWeight;
+            for (int mode = 0; mode < nmodes; ++mode)
+                _weight[mad24(mode, idx_step, pt_idx)] *= totalWeight;
+        }
+
+        if (!fitsPDF)
+        {
+            uchar mode = nmodes == (NMIXTURES) ? (NMIXTURES) - 1 : nmodes++;
+            int mode_idx = mad24(mode, idx_step, pt_idx);
+
+            if (nmodes == 1)
+                _weight[mode_idx] = 1.f;
+            else
+            {
+                _weight[mode_idx] = alphaT;
+
+                for (int i = pt_idx; i < mode_idx; i += idx_step)
+                    _weight[i] *= alpha1;
+            }
+
+            for (int i = nmodes - 1; i > 0; --i)
+            {
+                int prev_idx = mode_idx - idx_step;
+                if (alphaT < _weight[prev_idx])
+                    break;
+
+                _weight[mode_idx]   = _weight[prev_idx];
+                _variance[mode_idx] = _variance[prev_idx];
+                _mean[mode_idx]     = _mean[prev_idx];
+
+                mode_idx = prev_idx;
+            }
+
+            _mean[mode_idx] = pix;
+            _variance[mode_idx] = c_varInit;
+        }
+
+        _modesUsed[0] = nmodes;
+#ifdef SHADOW_DETECT
+        if (foreground)
+        {
+            float tWeight = 0.0f;
+
+            for (uchar mode = 0; mode < nmodes; ++mode)
+            {
+                int mode_idx = mad24(mode, idx_step, pt_idx);
+                T_MEAN c_mean = _mean[mode_idx];
+
+                float numerator = dot(pix, c_mean);
+                float denominator = dot(c_mean, c_mean);
+
+                if (denominator == 0)
+                    break;
+
+                if (numerator <= denominator && numerator >= c_tau * denominator)
+                {
+                    float a = numerator / denominator;
+
+                    T_MEAN dD = mad(a, c_mean, -pix);
+
+                    if (dot(dD, dD) < c_Tb * _variance[mode_idx] * a * a)
+                    {
+                        foreground = c_shadowVal;
+                        break;
+                    }
+                }
+
+                tWeight += _weight[mode_idx];
+                if (tWeight > c_TB)
+                    break;
+            }
+        }
+#endif
+        __global uchar* _fgmask = fgmask + mad24(y, fgmask_step, x + fgmask_offset);
+        *_fgmask = (uchar)foreground;
+    }
+}
+
+__kernel void getBackgroundImage2_kernel(__global const uchar* modesUsed,
+                                         __global const uchar* weight,
+                                         __global const uchar* mean,
+                                         __global uchar* dst, int dst_step, int dst_offset, int dst_row, int dst_col,
+                                         float c_TB)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    if(x < dst_col && y < dst_row)
+    {
+        int pt_idx =  mad24(y, dst_col, x);
+
+        __global const uchar* _modesUsed = modesUsed + pt_idx;
+        uchar nmodes = _modesUsed[0];
+
+        T_MEAN meanVal = (T_MEAN)F_ZERO;
+
+        float totalWeight = 0.0f;
+        __global const float* _weight = (__global const float*)weight;
+        __global const T_MEAN* _mean = (__global const T_MEAN*)(mean);
+        int idx_step = dst_row * dst_col;
+        for (uchar mode = 0; mode < nmodes; ++mode)
+        {
+            int mode_idx = mad24(mode, idx_step, pt_idx);
+            float c_weight = _weight[mode_idx];
+            T_MEAN c_mean = _mean[mode_idx];
+
+            meanVal = mad(c_weight, c_mean, meanVal);
+
+            totalWeight += c_weight;
+
+            if (totalWeight > c_TB)
+                break;
+        }
+
+        if (0.f < totalWeight)
+            meanVal = meanVal / totalWeight;
+        else
+            meanVal = (T_MEAN)(0.f);
+
+        #if FL==0
+        __global uchar* _dst = dst + mad24(y, dst_step, mad24(x, CN, dst_offset));
+        meanToFrame(meanVal, _dst);
+        #else
+        __global float* _dst = ((__global float*)( dst + mad24(y, dst_step, dst_offset)) + mad24(x, CN, 0));
+        meanToFrame(meanVal, _dst);
+        #endif
+    }
+}
diff --git a/upstream/opencv/modules/video/src/opencl/dis_flow.cl b/upstream/opencv/modules/video/src/opencl/dis_flow.cl
new file mode 100644
index 0000000..472a1f6
--- /dev/null
+++ b/upstream/opencv/modules/video/src/opencl/dis_flow.cl
@@ -0,0 +1,540 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+//#define CV_USE_SUBGROUPS
+
+#define EPS 0.001f
+#define INF 1E+10F
+
+//#define DIS_BORDER_SIZE xxx
+//#define DIS_PATCH_SIZE xxx
+//#define DIS_PATCH_STRIDE xxx
+
+#define DIS_PATCH_SIZE_HALF (DIS_PATCH_SIZE / 2)
+
+#ifndef DIS_BORDER_SIZE
+
+__kernel void dis_precomputeStructureTensor_hor(__global const short *I0x,
+                                                __global const short *I0y,
+                                                int w, int h, int ws,
+                                                __global float *I0xx_aux_ptr,
+                                                __global float *I0yy_aux_ptr,
+                                                __global float *I0xy_aux_ptr,
+                                                __global float *I0x_aux_ptr,
+                                                __global float *I0y_aux_ptr)
+{
+
+    int i = get_global_id(0);
+
+    if (i >= h) return;
+
+    const __global short *x_row = I0x + i * w;
+    const __global short *y_row = I0y + i * w;
+
+    float sum_xx = 0.0f, sum_yy = 0.0f, sum_xy = 0.0f, sum_x = 0.0f, sum_y = 0.0f;
+    float8 x_vec = convert_float8(vload8(0, x_row));
+    float8 y_vec = convert_float8(vload8(0, y_row));
+    sum_xx = dot(x_vec.lo, x_vec.lo) + dot(x_vec.hi, x_vec.hi);
+    sum_yy = dot(y_vec.lo, y_vec.lo) + dot(y_vec.hi, y_vec.hi);
+    sum_xy = dot(x_vec.lo, y_vec.lo) + dot(x_vec.hi, y_vec.hi);
+    sum_x = dot(x_vec.lo, 1.0f) + dot(x_vec.hi, 1.0f);
+    sum_y = dot(y_vec.lo, 1.0f) + dot(y_vec.hi, 1.0f);
+
+    I0xx_aux_ptr[i * ws] = sum_xx;
+    I0yy_aux_ptr[i * ws] = sum_yy;
+    I0xy_aux_ptr[i * ws] = sum_xy;
+    I0x_aux_ptr[i * ws] = sum_x;
+    I0y_aux_ptr[i * ws] = sum_y;
+
+    int js = 1;
+    for (int j = DIS_PATCH_SIZE; j < w; j++)
+    {
+        short x_val1 = x_row[j];
+        short x_val2 = x_row[j - DIS_PATCH_SIZE];
+        short y_val1 = y_row[j];
+        short y_val2 = y_row[j - DIS_PATCH_SIZE];
+        sum_xx += (x_val1 * x_val1 - x_val2 * x_val2);
+        sum_yy += (y_val1 * y_val1 - y_val2 * y_val2);
+        sum_xy += (x_val1 * y_val1 - x_val2 * y_val2);
+        sum_x += (x_val1 - x_val2);
+        sum_y += (y_val1 - y_val2);
+        if ((j - DIS_PATCH_SIZE + 1) % DIS_PATCH_STRIDE == 0)
+        {
+            int index = i * ws + js;
+            I0xx_aux_ptr[index] = sum_xx;
+            I0yy_aux_ptr[index] = sum_yy;
+            I0xy_aux_ptr[index] = sum_xy;
+            I0x_aux_ptr[index] = sum_x;
+            I0y_aux_ptr[index] = sum_y;
+            js++;
+        }
+    }
+}
+
+__kernel void dis_precomputeStructureTensor_ver(__global const float *I0xx_aux_ptr,
+                                                __global const float *I0yy_aux_ptr,
+                                                __global const float *I0xy_aux_ptr,
+                                                __global const float *I0x_aux_ptr,
+                                                __global const float *I0y_aux_ptr,
+                                                int w, int h, int ws,
+                                                __global float *I0xx_ptr,
+                                                __global float *I0yy_ptr,
+                                                __global float *I0xy_ptr,
+                                                __global float *I0x_ptr,
+                                                __global float *I0y_ptr)
+{
+    int j = get_global_id(0);
+
+    if (j >= ws) return;
+
+    float sum_xx, sum_yy, sum_xy, sum_x, sum_y;
+    sum_xx = sum_yy = sum_xy = sum_x = sum_y = 0.0f;
+
+    for (int i = 0; i < DIS_PATCH_SIZE; i++)
+    {
+        sum_xx += I0xx_aux_ptr[i * ws + j];
+        sum_yy += I0yy_aux_ptr[i * ws + j];
+        sum_xy += I0xy_aux_ptr[i * ws + j];
+        sum_x  += I0x_aux_ptr[i * ws + j];
+        sum_y  += I0y_aux_ptr[i * ws + j];
+    }
+    I0xx_ptr[j] = sum_xx;
+    I0yy_ptr[j] = sum_yy;
+    I0xy_ptr[j] = sum_xy;
+    I0x_ptr[j] = sum_x;
+    I0y_ptr[j] = sum_y;
+
+    int is = 1;
+    for (int i = DIS_PATCH_SIZE; i < h; i++)
+    {
+        sum_xx += (I0xx_aux_ptr[i * ws + j] - I0xx_aux_ptr[(i - DIS_PATCH_SIZE) * ws + j]);
+        sum_yy += (I0yy_aux_ptr[i * ws + j] - I0yy_aux_ptr[(i - DIS_PATCH_SIZE) * ws + j]);
+        sum_xy += (I0xy_aux_ptr[i * ws + j] - I0xy_aux_ptr[(i - DIS_PATCH_SIZE) * ws + j]);
+        sum_x  += (I0x_aux_ptr[i * ws + j] - I0x_aux_ptr[(i - DIS_PATCH_SIZE) * ws + j]);
+        sum_y  += (I0y_aux_ptr[i * ws + j] - I0y_aux_ptr[(i - DIS_PATCH_SIZE) * ws + j]);
+
+        if ((i - DIS_PATCH_SIZE + 1) % DIS_PATCH_STRIDE == 0)
+        {
+            I0xx_ptr[is * ws + j] = sum_xx;
+            I0yy_ptr[is * ws + j] = sum_yy;
+            I0xy_ptr[is * ws + j] = sum_xy;
+            I0x_ptr[is * ws + j] = sum_x;
+            I0y_ptr[is * ws + j] = sum_y;
+            is++;
+        }
+    }
+}
+
+__kernel void dis_densification(__global const float2 *S_ptr,
+                                __global const uchar *i0, __global const uchar *i1,
+                                int w, int h, int ws,
+                                __global float2 *U_ptr)
+{
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    int i, j;
+
+    if (x >= w || y >= h) return;
+
+    int start_is, end_is;
+    int start_js, end_js;
+
+    end_is = min(y / DIS_PATCH_STRIDE, (h - DIS_PATCH_SIZE) / DIS_PATCH_STRIDE);
+    start_is = max(0, y - DIS_PATCH_SIZE + DIS_PATCH_STRIDE) / DIS_PATCH_STRIDE;
+    start_is = min(start_is, end_is);
+
+    end_js = min(x / DIS_PATCH_STRIDE, (w - DIS_PATCH_SIZE) / DIS_PATCH_STRIDE);
+    start_js = max(0, x - DIS_PATCH_SIZE + DIS_PATCH_STRIDE) / DIS_PATCH_STRIDE;
+    start_js = min(start_js, end_js);
+
+    float sum_coef = 0.0f;
+    float2 sum_U = (float2)(0.0f, 0.0f);
+
+    int i_l, i_u;
+    int j_l, j_u;
+    float i_m, j_m, diff;
+
+    i = y;
+    j = x;
+
+    /* Iterate through all the patches that overlap the current location (i,j) */
+    for (int is = start_is; is <= end_is; is++)
+        for (int js = start_js; js <= end_js; js++)
+        {
+            float2 s_val = S_ptr[is * ws + js];
+            uchar2 i1_vec1, i1_vec2;
+
+            j_m = min(max(j + s_val.x, 0.0f), w - 1.0f - EPS);
+            i_m = min(max(i + s_val.y, 0.0f), h - 1.0f - EPS);
+            j_l = (int)j_m;
+            j_u = j_l + 1;
+            i_l = (int)i_m;
+            i_u = i_l + 1;
+            i1_vec1 = vload2(0, i1 + i_u * w + j_l);
+            i1_vec2 = vload2(0, i1 + i_l * w + j_l);
+            diff = (j_m - j_l) * (i_m - i_l) * i1_vec1.y +
+                   (j_u - j_m) * (i_m - i_l) * i1_vec1.x +
+                   (j_m - j_l) * (i_u - i_m) * i1_vec2.y +
+                   (j_u - j_m) * (i_u - i_m) * i1_vec2.x - i0[i * w + j];
+            float coef = 1.0f / max(1.0f, fabs(diff));
+            sum_U += coef * s_val;
+            sum_coef += coef;
+        }
+
+    float inv_sum_coef = 1.0 / sum_coef;
+    U_ptr[i * w + j] = sum_U * inv_sum_coef;
+}
+
+#else // DIS_BORDER_SIZE
+
+#define INIT_BILINEAR_WEIGHTS(Ux, Uy) \
+    i_I1 = clamp(i + Uy + DIS_BORDER_SIZE, i_lower_limit, i_upper_limit); \
+    j_I1 = clamp(j + Ux + DIS_BORDER_SIZE, j_lower_limit, j_upper_limit); \
+    { \
+        float di = i_I1 - floor(i_I1); \
+        float dj = j_I1 - floor(j_I1); \
+        w11 = di       * dj; \
+        w10 = di       * (1 - dj); \
+        w01 = (1 - di) * dj; \
+        w00 = (1 - di) * (1 - dj); \
+    }
+
+float computeSSDMeanNorm(const __global uchar *I0_ptr, const __global uchar *I1_ptr,
+                         int I0_stride, int I1_stride,
+                         float w00, float w01, float w10, float w11, int i
+#ifndef CV_USE_SUBGROUPS
+                         , __local float2 *smem /*[8]*/
+#endif
+)
+{
+    float sum_diff = 0.0f, sum_diff_sq = 0.0f;
+    int n = DIS_PATCH_SIZE * DIS_PATCH_SIZE;
+
+    uchar8 I1_vec1, I1_vec2, I0_vec;
+    uchar I1_val1, I1_val2;
+
+    I0_vec  = vload8(0, I0_ptr + i * I0_stride);
+    I1_vec1 = vload8(0, I1_ptr + i * I1_stride);
+    I1_vec2 = vload8(0, I1_ptr + (i + 1) * I1_stride);
+    I1_val1 = I1_ptr[i * I1_stride + 8];
+    I1_val2 = I1_ptr[(i + 1) * I1_stride + 8];
+
+    float8 vec = w00 * convert_float8(I1_vec1) + w01 * convert_float8((uchar8)(I1_vec1.s123, I1_vec1.s4567, I1_val1)) +
+                 w10 * convert_float8(I1_vec2) + w11 * convert_float8((uchar8)(I1_vec2.s123, I1_vec2.s4567, I1_val2)) -
+                 convert_float8(I0_vec);
+
+    sum_diff = (dot(vec.lo, 1.0) + dot(vec.hi, 1.0));
+    sum_diff_sq = (dot(vec.lo, vec.lo) + dot(vec.hi, vec.hi));
+
+#ifdef CV_USE_SUBGROUPS
+    sum_diff = sub_group_reduce_add(sum_diff);
+    sum_diff_sq = sub_group_reduce_add(sum_diff_sq);
+#else
+    barrier(CLK_LOCAL_MEM_FENCE);
+    smem[i] = (float2)(sum_diff, sum_diff_sq);
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (i < 4)
+        smem[i] += smem[i + 4];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (i < 2)
+        smem[i] += smem[i + 2];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (i == 0)
+        smem[0] += smem[1];
+    barrier(CLK_LOCAL_MEM_FENCE);
+    float2 reduce_add_result = smem[0];
+    sum_diff = reduce_add_result.x;
+    sum_diff_sq = reduce_add_result.y;
+#endif
+
+    return sum_diff_sq - sum_diff * sum_diff / n;
+}
+
+__attribute__((reqd_work_group_size(8, 1, 1)))
+__kernel void dis_patch_inverse_search_fwd_1(__global const float2 *U_ptr,
+                                             __global const uchar *I0_ptr, __global const uchar *I1_ptr,
+                                             int w, int h, int ws, int hs,
+                                             __global float2 *S_ptr)
+{
+    int id = get_global_id(0);
+    int is = get_group_id(0);
+
+    int i = is * DIS_PATCH_STRIDE;
+    int j = 0;
+    int w_ext = w + 2 * DIS_BORDER_SIZE;
+
+    float i_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    float i_upper_limit = DIS_BORDER_SIZE + h - 1.0f;
+    float j_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    float j_upper_limit = DIS_BORDER_SIZE + w - 1.0f;
+
+    float2 prev_U = U_ptr[(i + DIS_PATCH_SIZE_HALF) * w + j + DIS_PATCH_SIZE_HALF];
+    S_ptr[is * ws] = prev_U;
+    j += DIS_PATCH_STRIDE;
+
+#ifdef CV_USE_SUBGROUPS
+    int sid = get_sub_group_local_id();
+#define EXTRA_ARGS_computeSSDMeanNorm sid
+#else
+    __local float2 smem[8];
+    int sid = get_local_id(0);
+#define EXTRA_ARGS_computeSSDMeanNorm sid, smem
+#endif
+    for (int js = 1; js < ws; js++, j += DIS_PATCH_STRIDE)
+    {
+        float2 U = U_ptr[(i + DIS_PATCH_SIZE_HALF) * w + j + DIS_PATCH_SIZE_HALF];
+
+        float i_I1, j_I1, w00, w01, w10, w11;
+
+        INIT_BILINEAR_WEIGHTS(U.x, U.y);
+        float min_SSD = computeSSDMeanNorm(
+                I0_ptr + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                w, w_ext, w00, w01, w10, w11, EXTRA_ARGS_computeSSDMeanNorm);
+
+        INIT_BILINEAR_WEIGHTS(prev_U.x, prev_U.y);
+        float cur_SSD = computeSSDMeanNorm(
+                I0_ptr + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                w, w_ext, w00, w01, w10, w11, EXTRA_ARGS_computeSSDMeanNorm);
+
+        prev_U = (cur_SSD < min_SSD) ? prev_U : U;
+        S_ptr[is * ws + js] = prev_U;
+    }
+
+#undef EXTRA_ARGS_computeSSDMeanNorm
+}
+#endif // DIS_BORDER_SIZE
+
+float4 processPatchMeanNorm(const __global uchar *I0_ptr, const __global uchar *I1_ptr,
+                            const __global short *I0x_ptr, const __global short *I0y_ptr,
+                            int I0_stride, int I1_stride, float w00, float w01, float w10,
+                            float w11, float x_grad_sum, float y_grad_sum)
+{
+    const float inv_n = 1.0f / (float)(DIS_PATCH_SIZE * DIS_PATCH_SIZE);
+
+    float sum_diff = 0.0, sum_diff_sq = 0.0;
+    float sum_I0x_mul = 0.0, sum_I0y_mul = 0.0;
+
+    uchar8 I1_vec1;
+    uchar8 I1_vec2 = vload8(0, I1_ptr);
+    uchar I1_val1;
+    uchar I1_val2 = I1_ptr[DIS_PATCH_SIZE];
+
+    for (int i = 0; i < 8; i++)
+    {
+        uchar8 I0_vec = vload8(0, I0_ptr + i * I0_stride);
+
+        I1_vec1 = I1_vec2;
+        I1_vec2 = vload8(0, I1_ptr + (i + 1) * I1_stride);
+        I1_val1 = I1_val2;
+        I1_val2 = I1_ptr[(i + 1) * I1_stride + DIS_PATCH_SIZE];
+
+        float8 vec = w00 * convert_float8(I1_vec1) + w01 * convert_float8((uchar8)(I1_vec1.s123, I1_vec1.s4567, I1_val1)) +
+                     w10 * convert_float8(I1_vec2) + w11 * convert_float8((uchar8)(I1_vec2.s123, I1_vec2.s4567, I1_val2)) -
+                     convert_float8(I0_vec);
+
+        sum_diff += (dot(vec.lo, 1.0) + dot(vec.hi, 1.0));
+        sum_diff_sq += (dot(vec.lo, vec.lo) + dot(vec.hi, vec.hi));
+
+        short8 I0x_vec = vload8(0, I0x_ptr + i * I0_stride);
+        short8 I0y_vec = vload8(0, I0y_ptr + i * I0_stride);
+
+        sum_I0x_mul += dot(vec.lo, convert_float4(I0x_vec.lo));
+        sum_I0x_mul += dot(vec.hi, convert_float4(I0x_vec.hi));
+        sum_I0y_mul += dot(vec.lo, convert_float4(I0y_vec.lo));
+        sum_I0y_mul += dot(vec.hi, convert_float4(I0y_vec.hi));
+    }
+
+    float dst_dUx = sum_I0x_mul - sum_diff * x_grad_sum * inv_n;
+    float dst_dUy = sum_I0y_mul - sum_diff * y_grad_sum * inv_n;
+    float SSD = sum_diff_sq - sum_diff * sum_diff * inv_n;
+
+    return (float4)(SSD, dst_dUx, dst_dUy, 0);
+}
+
+#ifdef DIS_BORDER_SIZE
+__kernel void dis_patch_inverse_search_fwd_2(__global const float2 *U_ptr,
+                                             __global const uchar *I0_ptr, __global const uchar *I1_ptr,
+                                             __global const short *I0x_ptr, __global const short *I0y_ptr,
+                                             __global const float *xx_ptr, __global const float *yy_ptr,
+                                             __global const float *xy_ptr,
+                                             __global const float *x_ptr, __global const float *y_ptr,
+                                             int w, int h, int ws, int hs, int num_inner_iter,
+                                             __global float2 *S_ptr)
+{
+    int js = get_global_id(0);
+    int is = get_global_id(1);
+    int i = is * DIS_PATCH_STRIDE;
+    int j = js * DIS_PATCH_STRIDE;
+    const int psz = DIS_PATCH_SIZE;
+    int w_ext = w + 2 * DIS_BORDER_SIZE;
+    int index = is * ws + js;
+
+    if (js >= ws || is >= hs) return;
+
+    float2 U0 = S_ptr[index];
+    float2 cur_U = U0;
+    float cur_xx = xx_ptr[index];
+    float cur_yy = yy_ptr[index];
+    float cur_xy = xy_ptr[index];
+    float detH = cur_xx * cur_yy - cur_xy * cur_xy;
+
+    float inv_detH = (fabs(detH) < EPS) ? 1.0 / EPS : 1.0 / detH;
+    float invH11 = cur_yy * inv_detH;
+    float invH12 = -cur_xy * inv_detH;
+    float invH22 = cur_xx * inv_detH;
+
+    float prev_SSD = INF;
+    float x_grad_sum = x_ptr[index];
+    float y_grad_sum = y_ptr[index];
+
+    const float i_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float i_upper_limit = DIS_BORDER_SIZE + h - 1.0f;
+    const float j_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float j_upper_limit = DIS_BORDER_SIZE + w - 1.0f;
+
+    for (int t = 0; t < num_inner_iter; t++)
+    {
+        float i_I1, j_I1, w00, w01, w10, w11;
+        INIT_BILINEAR_WEIGHTS(cur_U.x, cur_U.y);
+        float4 res = processPatchMeanNorm(
+                I0_ptr  + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                I0x_ptr + i * w + j, I0y_ptr + i * w + j,
+                w, w_ext, w00, w01, w10, w11,
+                x_grad_sum, y_grad_sum);
+
+        float SSD = res.x;
+        float dUx = res.y;
+        float dUy = res.z;
+        float dx = invH11 * dUx + invH12 * dUy;
+        float dy = invH12 * dUx + invH22 * dUy;
+
+        cur_U -= (float2)(dx, dy);
+
+        if (SSD >= prev_SSD)
+            break;
+        prev_SSD = SSD;
+    }
+
+    float2 vec = cur_U - U0;
+    S_ptr[index] = (dot(vec, vec) <= (float)(DIS_PATCH_SIZE * DIS_PATCH_SIZE)) ? cur_U : U0;
+}
+
+__attribute__((reqd_work_group_size(8, 1, 1)))
+__kernel void dis_patch_inverse_search_bwd_1(__global const uchar *I0_ptr, __global const uchar *I1_ptr,
+                                             int w, int h, int ws, int hs,
+                                             __global float2 *S_ptr)
+{
+    int id = get_global_id(0);
+    int is = get_group_id(0);
+
+    is = (hs - 1 - is);
+    int i = is * DIS_PATCH_STRIDE;
+    int j = (ws - 2) * DIS_PATCH_STRIDE;
+    const int w_ext = w + 2 * DIS_BORDER_SIZE;
+
+    const float i_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float i_upper_limit = DIS_BORDER_SIZE + h - 1.0f;
+    const float j_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float j_upper_limit = DIS_BORDER_SIZE + w - 1.0f;
+
+#ifdef CV_USE_SUBGROUPS
+    int sid = get_sub_group_local_id();
+#define EXTRA_ARGS_computeSSDMeanNorm sid
+#else
+    __local float2 smem[8];
+    int sid = get_local_id(0);
+#define EXTRA_ARGS_computeSSDMeanNorm sid, smem
+#endif
+
+    for (int js = (ws - 2); js > -1; js--, j -= DIS_PATCH_STRIDE)
+    {
+        float2 U0 = S_ptr[is * ws + js];
+        float2 U1 = S_ptr[is * ws + js + 1];
+
+        float i_I1, j_I1, w00, w01, w10, w11;
+
+        INIT_BILINEAR_WEIGHTS(U0.x, U0.y);
+        float min_SSD = computeSSDMeanNorm(
+                I0_ptr + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                w, w_ext, w00, w01, w10, w11, EXTRA_ARGS_computeSSDMeanNorm);
+
+        INIT_BILINEAR_WEIGHTS(U1.x, U1.y);
+        float cur_SSD = computeSSDMeanNorm(
+                I0_ptr + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                w, w_ext, w00, w01, w10, w11, EXTRA_ARGS_computeSSDMeanNorm);
+
+        S_ptr[is * ws + js] = (cur_SSD < min_SSD) ? U1 : U0;
+    }
+
+#undef EXTRA_ARGS_computeSSDMeanNorm
+}
+
+__kernel void dis_patch_inverse_search_bwd_2(__global const uchar *I0_ptr, __global const uchar *I1_ptr,
+                                             __global const short *I0x_ptr, __global const short *I0y_ptr,
+                                             __global const float *xx_ptr, __global const float *yy_ptr,
+                                             __global const float *xy_ptr,
+                                             __global const float *x_ptr, __global const float *y_ptr,
+                                             int w, int h, int ws, int hs, int num_inner_iter,
+                                             __global float2 *S_ptr)
+{
+    int js = get_global_id(0);
+    int is = get_global_id(1);
+    if (js >= ws || is >= hs) return;
+
+    js = (ws - 1 - js);
+    is = (hs - 1 - is);
+
+    int j = js * DIS_PATCH_STRIDE;
+    int i = is * DIS_PATCH_STRIDE;
+    int w_ext = w + 2 * DIS_BORDER_SIZE;
+    int index = is * ws + js;
+
+    float2 U0 = S_ptr[index];
+    float2 cur_U = U0;
+    float cur_xx = xx_ptr[index];
+    float cur_yy = yy_ptr[index];
+    float cur_xy = xy_ptr[index];
+    float detH = cur_xx * cur_yy - cur_xy * cur_xy;
+
+    float inv_detH = (fabs(detH) < EPS) ? 1.0 / EPS : 1.0 / detH;
+    float invH11 = cur_yy * inv_detH;
+    float invH12 = -cur_xy * inv_detH;
+    float invH22 = cur_xx * inv_detH;
+
+    float prev_SSD = INF;
+    float x_grad_sum = x_ptr[index];
+    float y_grad_sum = y_ptr[index];
+
+    const float i_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float i_upper_limit = DIS_BORDER_SIZE + h - 1.0f;
+    const float j_lower_limit = DIS_BORDER_SIZE - DIS_PATCH_SIZE + 1.0f;
+    const float j_upper_limit = DIS_BORDER_SIZE + w - 1.0f;
+
+    for (int t = 0; t < num_inner_iter; t++)
+    {
+        float i_I1, j_I1, w00, w01, w10, w11;
+        INIT_BILINEAR_WEIGHTS(cur_U.x, cur_U.y);
+        float4 res = processPatchMeanNorm(
+                I0_ptr  + i * w + j, I1_ptr + (int)i_I1 * w_ext + (int)j_I1,
+                I0x_ptr + i * w + j, I0y_ptr + i * w + j,
+                w, w_ext, w00, w01, w10, w11,
+                x_grad_sum, y_grad_sum);
+
+        float SSD = res.x;
+        float dUx = res.y;
+        float dUy = res.z;
+        float dx = invH11 * dUx + invH12 * dUy;
+        float dy = invH12 * dUx + invH22 * dUy;
+
+        cur_U -= (float2)(dx, dy);
+
+        if (SSD >= prev_SSD)
+            break;
+        prev_SSD = SSD;
+    }
+
+    float2 vec = cur_U - U0;
+    S_ptr[index] = ((dot(vec, vec)) <= (float)(DIS_PATCH_SIZE * DIS_PATCH_SIZE)) ? cur_U : U0;
+}
+#endif // DIS_BORDER_SIZE
diff --git a/upstream/opencv/modules/video/src/opencl/optical_flow_farneback.cl b/upstream/opencv/modules/video/src/opencl/optical_flow_farneback.cl
new file mode 100644
index 0000000..7785839
--- /dev/null
+++ b/upstream/opencv/modules/video/src/opencl/optical_flow_farneback.cl
@@ -0,0 +1,429 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Sen Liu, swjtuls1987@126.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+
+#define tx  (int)get_local_id(0)
+#define ty  get_local_id(1)
+#define bx  get_group_id(0)
+#define bdx (int)get_local_size(0)
+
+#define BORDER_SIZE 5
+#define MAX_KSIZE_HALF 100
+
+#ifndef polyN
+#define polyN 5
+#endif
+
+#if USE_DOUBLE
+#ifdef cl_amd_fp64
+#pragma OPENCL EXTENSION cl_amd_fp64:enable
+#elif defined (cl_khr_fp64)
+#pragma OPENCL EXTENSION cl_khr_fp64:enable
+#endif
+#define TYPE double
+#define VECTYPE double4
+#else
+#define TYPE float
+#define VECTYPE float4
+#endif
+
+__kernel void polynomialExpansion(__global __const float * src, int srcStep,
+                                  __global float * dst, int dstStep,
+                                  const int rows, const  int cols,
+                                  __global __const float * c_g,
+                                  __global __const float * c_xg,
+                                  __global __const float * c_xxg,
+                                  __local float * smem,
+                                  const VECTYPE ig)
+{
+    const int y = get_global_id(1);
+    const int x = bx * (bdx - 2*polyN) + tx - polyN;
+
+    int xWarped;
+    __local float *row = smem + tx;
+
+    if (y < rows && y >= 0)
+    {
+        xWarped = min(max(x, 0), cols - 1);
+
+        row[0] = src[mad24(y, srcStep, xWarped)] * c_g[0];
+        row[bdx] = 0.f;
+        row[2*bdx] = 0.f;
+
+#pragma unroll
+        for (int k = 1; k <= polyN; ++k)
+        {
+            float t0 = src[mad24(max(y - k, 0), srcStep, xWarped)];
+            float t1 = src[mad24(min(y + k, rows - 1), srcStep, xWarped)];
+
+            row[0] += c_g[k] * (t0 + t1);
+            row[bdx] += c_xg[k] * (t1 - t0);
+            row[2*bdx] += c_xxg[k] * (t0 + t1);
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (y < rows && y >= 0 && tx >= polyN && tx + polyN < bdx && x < cols)
+    {
+        TYPE b1 = c_g[0] * row[0];
+        TYPE b3 = c_g[0] * row[bdx];
+        TYPE b5 = c_g[0] * row[2*bdx];
+        TYPE b2 = 0, b4 = 0, b6 = 0;
+
+#pragma unroll
+        for (int k = 1; k <= polyN; ++k)
+        {
+            b1 += (row[k] + row[-k]) * c_g[k];
+            b4 += (row[k] + row[-k]) * c_xxg[k];
+            b2 += (row[k] - row[-k]) * c_xg[k];
+            b3 += (row[k + bdx] + row[-k + bdx]) * c_g[k];
+            b6 += (row[k + bdx] - row[-k + bdx]) * c_xg[k];
+            b5 += (row[k + 2*bdx] + row[-k + 2*bdx]) * c_g[k];
+        }
+
+        dst[mad24(y, dstStep, xWarped)] = (float)(b3*ig.s0);
+        dst[mad24(rows + y, dstStep, xWarped)] = (float)(b2*ig.s0);
+        dst[mad24(2*rows + y, dstStep, xWarped)] = (float)(b1*ig.s1 + b5*ig.s2);
+        dst[mad24(3*rows + y, dstStep, xWarped)] = (float)(b1*ig.s1 + b4*ig.s2);
+        dst[mad24(4*rows + y, dstStep, xWarped)] = (float)(b6*ig.s3);
+    }
+}
+
+inline int idx_row_low(const int y, const int last_row)
+{
+    return abs(y) % (last_row + 1);
+}
+
+inline int idx_row_high(const int y, const int last_row)
+{
+    return abs(last_row - abs(last_row - y)) % (last_row + 1);
+}
+
+inline int idx_col_low(const int x, const int last_col)
+{
+    return abs(x) % (last_col + 1);
+}
+
+inline int idx_col_high(const int x, const int last_col)
+{
+    return abs(last_col - abs(last_col - x)) % (last_col + 1);
+}
+
+inline int idx_col(const int x, const int last_col)
+{
+    return idx_col_low(idx_col_high(x, last_col), last_col);
+}
+
+__kernel void gaussianBlur(__global const float * src, int srcStep,
+                           __global float * dst, int dstStep, const int rows, const  int cols,
+                           __global const float * c_gKer, const int ksizeHalf,
+                           __local float * smem)
+{
+    const int y = get_global_id(1);
+    const int x = get_global_id(0);
+
+    __local float *row = smem + ty * (bdx + 2*ksizeHalf);
+
+    if (y < rows)
+    {
+        // Vertical pass
+        for (int i = tx; i < bdx + 2*ksizeHalf; i += bdx)
+        {
+            int xExt = (int)(bx * bdx) + i - ksizeHalf;
+            xExt = idx_col(xExt, cols - 1);
+            row[i] = src[mad24(y, srcStep, xExt)] * c_gKer[0];
+            for (int j = 1; j <= ksizeHalf; ++j)
+                row[i] += (src[mad24(idx_row_low(y - j, rows - 1), srcStep, xExt)]
+                           + src[mad24(idx_row_high(y + j, rows - 1), srcStep, xExt)]) * c_gKer[j];
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (y < rows && y >= 0 && x < cols && x >= 0)
+    {
+        // Horizontal pass
+        row += tx + ksizeHalf;
+        float res = row[0] * c_gKer[0];
+        for (int i = 1; i <= ksizeHalf; ++i)
+            res += (row[-i] + row[i]) * c_gKer[i];
+
+        dst[mad24(y, dstStep, x)] = res;
+    }
+}
+
+__kernel void gaussianBlur5(__global const float * src, int srcStep,
+                            __global float * dst, int dstStep,
+                            const int rows, const  int cols,
+                            __global const float * c_gKer, const int ksizeHalf,
+                            __local float * smem)
+{
+    const int y = get_global_id(1);
+    const int x = get_global_id(0);
+
+    const int smw = bdx + 2*ksizeHalf; // shared memory "cols"
+    __local volatile float *row = smem + 5 * ty * smw;
+
+    if (y < rows)
+    {
+        // Vertical pass
+        for (int i = tx; i < bdx + 2*ksizeHalf; i += bdx)
+        {
+            int xExt = (int)(bx * bdx) + i - ksizeHalf;
+            xExt = idx_col(xExt, cols - 1);
+
+#pragma unroll
+            for (int k = 0; k < 5; ++k)
+                row[k*smw + i] = src[mad24(k*rows + y, srcStep, xExt)] * c_gKer[0];
+
+            for (int j = 1; j <= ksizeHalf; ++j)
+#pragma unroll
+                for (int k = 0; k < 5; ++k)
+                    row[k*smw + i] +=
+                        (src[mad24(k*rows + idx_row_low(y - j, rows - 1), srcStep, xExt)] +
+                         src[mad24(k*rows + idx_row_high(y + j, rows - 1), srcStep, xExt)]) * c_gKer[j];
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (y < rows && y >= 0 && x < cols && x >= 0)
+    {
+        // Horizontal pass
+
+        row += tx + ksizeHalf;
+        float res[5];
+
+#pragma unroll
+        for (int k = 0; k < 5; ++k)
+            res[k] = row[k*smw] * c_gKer[0];
+
+        for (int i = 1; i <= ksizeHalf; ++i)
+#pragma unroll
+            for (int k = 0; k < 5; ++k)
+                res[k] += (row[k*smw - i] + row[k*smw + i]) * c_gKer[i];
+
+#pragma unroll
+        for (int k = 0; k < 5; ++k)
+            dst[mad24(k*rows + y, dstStep, x)] = res[k];
+    }
+}
+__constant float c_border[BORDER_SIZE + 1] = { 0.14f, 0.14f, 0.4472f, 0.4472f, 0.4472f, 1.f };
+
+__kernel void updateMatrices(__global const float * flowx, int xStep,
+                             __global const float * flowy, int yStep,
+                             const int rows, const int cols,
+                             __global const float * R0, int R0Step,
+                             __global const float * R1, int R1Step,
+                             __global float * M, int mStep)
+{
+    const int y = get_global_id(1);
+    const int x = get_global_id(0);
+
+    if (y < rows && y >= 0 && x < cols && x >= 0)
+    {
+        float dx = flowx[mad24(y, xStep, x)];
+        float dy = flowy[mad24(y, yStep, x)];
+        float fx = x + dx;
+        float fy = y + dy;
+
+        int x1 = convert_int(floor(fx));
+        int y1 = convert_int(floor(fy));
+        fx -= x1;
+        fy -= y1;
+
+        float r2, r3, r4, r5, r6;
+
+        if (x1 >= 0 && y1 >= 0 && x1 < cols - 1 && y1 < rows - 1)
+        {
+            float a00 = (1.f - fx) * (1.f - fy);
+            float a01 = fx * (1.f - fy);
+            float a10 = (1.f - fx) * fy;
+            float a11 = fx * fy;
+
+            r2 = a00 * R1[mad24(y1, R1Step, x1)] +
+                 a01 * R1[mad24(y1, R1Step, x1 + 1)] +
+                 a10 * R1[mad24(y1 + 1, R1Step, x1)] +
+                 a11 * R1[mad24(y1 + 1, R1Step, x1 + 1)];
+
+            r3 = a00 * R1[mad24(rows + y1, R1Step, x1)] +
+                 a01 * R1[mad24(rows + y1, R1Step, x1 + 1)] +
+                 a10 * R1[mad24(rows + y1 + 1, R1Step, x1)] +
+                 a11 * R1[mad24(rows + y1 + 1, R1Step, x1 + 1)];
+
+            r4 = a00 * R1[mad24(2*rows + y1, R1Step, x1)] +
+                 a01 * R1[mad24(2*rows + y1, R1Step, x1 + 1)] +
+                 a10 * R1[mad24(2*rows + y1 + 1, R1Step, x1)] +
+                 a11 * R1[mad24(2*rows + y1 + 1, R1Step, x1 + 1)];
+
+            r5 = a00 * R1[mad24(3*rows + y1, R1Step, x1)] +
+                 a01 * R1[mad24(3*rows + y1, R1Step, x1 + 1)] +
+                 a10 * R1[mad24(3*rows + y1 + 1, R1Step, x1)] +
+                 a11 * R1[mad24(3*rows + y1 + 1, R1Step, x1 + 1)];
+
+            r6 = a00 * R1[mad24(4*rows + y1, R1Step, x1)] +
+                 a01 * R1[mad24(4*rows + y1, R1Step, x1 + 1)] +
+                 a10 * R1[mad24(4*rows + y1 + 1, R1Step, x1)] +
+                 a11 * R1[mad24(4*rows + y1 + 1, R1Step, x1 + 1)];
+
+            r4 = (R0[mad24(2*rows + y, R0Step, x)] + r4) * 0.5f;
+            r5 = (R0[mad24(3*rows + y, R0Step, x)] + r5) * 0.5f;
+            r6 = (R0[mad24(4*rows + y, R0Step, x)] + r6) * 0.25f;
+        }
+        else
+        {
+            r2 = r3 = 0.f;
+            r4 = R0[mad24(2*rows + y, R0Step, x)];
+            r5 = R0[mad24(3*rows + y, R0Step, x)];
+            r6 = R0[mad24(4*rows + y, R0Step, x)] * 0.5f;
+        }
+
+        r2 = (R0[mad24(y, R0Step, x)] - r2) * 0.5f;
+        r3 = (R0[mad24(rows + y, R0Step, x)] - r3) * 0.5f;
+
+        r2 += r4*dy + r6*dx;
+        r3 += r6*dy + r5*dx;
+
+        float scale =
+            c_border[min(x, BORDER_SIZE)] *
+            c_border[min(y, BORDER_SIZE)] *
+            c_border[min(cols - x - 1, BORDER_SIZE)] *
+            c_border[min(rows - y - 1, BORDER_SIZE)];
+
+        r2 *= scale;
+        r3 *= scale;
+        r4 *= scale;
+        r5 *= scale;
+        r6 *= scale;
+
+        M[mad24(y, mStep, x)] = r4*r4 + r6*r6;
+        M[mad24(rows + y, mStep, x)] = (r4 + r5)*r6;
+        M[mad24(2*rows + y, mStep, x)] = r5*r5 + r6*r6;
+        M[mad24(3*rows + y, mStep, x)] = r4*r2 + r6*r3;
+        M[mad24(4*rows + y, mStep, x)] = r6*r2 + r5*r3;
+    }
+}
+
+__kernel void boxFilter5(__global const float * src, int srcStep,
+                         __global float * dst, int dstStep,
+                         const int rows, const  int cols,
+                         const int ksizeHalf,
+                         __local float * smem)
+{
+    const int y = get_global_id(1);
+    const int x = get_global_id(0);
+
+    const float boxAreaInv = 1.f / ((1 + 2*ksizeHalf) * (1 + 2*ksizeHalf));
+    const int smw = bdx + 2*ksizeHalf; // shared memory "width"
+    __local float *row = smem + 5 * ty * smw;
+
+    if (y < rows)
+    {
+        // Vertical pass
+        for (int i = tx; i < bdx + 2*ksizeHalf; i += bdx)
+        {
+            int xExt = (int)(bx * bdx) + i - ksizeHalf;
+            xExt = min(max(xExt, 0), cols - 1);
+
+#pragma unroll
+            for (int k = 0; k < 5; ++k)
+                row[k*smw + i] = src[mad24(k*rows + y, srcStep, xExt)];
+
+            for (int j = 1; j <= ksizeHalf; ++j)
+#pragma unroll
+                for (int k = 0; k < 5; ++k)
+                    row[k*smw + i] +=
+                        src[mad24(k*rows + max(y - j, 0), srcStep, xExt)] +
+                        src[mad24(k*rows + min(y + j, rows - 1), srcStep, xExt)];
+        }
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (y < rows && y >= 0 && x < cols && x >= 0)
+    {
+        // Horizontal pass
+
+        row += tx + ksizeHalf;
+        float res[5];
+
+#pragma unroll
+        for (int k = 0; k < 5; ++k)
+            res[k] = row[k*smw];
+
+        for (int i = 1; i <= ksizeHalf; ++i)
+#pragma unroll
+            for (int k = 0; k < 5; ++k)
+                res[k] += row[k*smw - i] + row[k*smw + i];
+
+#pragma unroll
+        for (int k = 0; k < 5; ++k)
+            dst[mad24(k*rows + y, dstStep, x)] = res[k] * boxAreaInv;
+    }
+}
+
+__kernel void updateFlow(__global const float * M, int mStep,
+                         __global float * flowx, int xStep,
+                         __global float * flowy, int yStep,
+                         const int rows, const int cols)
+{
+    const int y = get_global_id(1);
+    const int x = get_global_id(0);
+
+    if (y < rows && y >= 0 && x < cols && x >= 0)
+    {
+        float g11 = M[mad24(y, mStep, x)];
+        float g12 = M[mad24(rows + y, mStep, x)];
+        float g22 = M[mad24(2*rows + y, mStep, x)];
+        float h1 =  M[mad24(3*rows + y, mStep, x)];
+        float h2 =  M[mad24(4*rows + y, mStep, x)];
+
+        float detInv = 1.f / (g11*g22 - g12*g12 + 1e-3f);
+
+        flowx[mad24(y, xStep, x)] = (g11*h2 - g12*h1) * detInv;
+        flowy[mad24(y, yStep, x)] = (g22*h1 - g12*h2) * detInv;
+    }
+}
diff --git a/upstream/opencv/modules/video/src/opencl/pyrlk.cl b/upstream/opencv/modules/video/src/opencl/pyrlk.cl
new file mode 100644
index 0000000..539e582
--- /dev/null
+++ b/upstream/opencv/modules/video/src/opencl/pyrlk.cl
@@ -0,0 +1,558 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Dachuan Zhao, dachuan@multicorewareinc.com
+//    Yao Wang, bitwangyaoyao@gmail.com
+//    Xiaopeng Fu, fuxiaopeng2222@163.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#define GRIDSIZE    3
+#define LSx 8
+#define LSy 8
+// define local memory sizes
+#define LM_W (LSx*GRIDSIZE+2)
+#define LM_H (LSy*GRIDSIZE+2)
+#define BUFFER  (LSx*LSy)
+#define BUFFER2 BUFFER>>1
+
+#ifdef CPU
+
+inline void reduce3(float val1, float val2, float val3,  __local float* smem1,  __local float* smem2,  __local float* smem3, int tid)
+{
+    smem1[tid] = val1;
+    smem2[tid] = val2;
+    smem3[tid] = val3;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for(int i = BUFFER2; i > 0; i >>= 1)
+    {
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+            smem2[tid] += smem2[tid + i];
+            smem3[tid] += smem3[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+}
+
+inline void reduce2(float val1, float val2, __local float* smem1, __local float* smem2, int tid)
+{
+    smem1[tid] = val1;
+    smem2[tid] = val2;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for(int i = BUFFER2; i > 0; i >>= 1)
+    {
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+            smem2[tid] += smem2[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+}
+
+inline void reduce1(float val1, __local float* smem1, int tid)
+{
+    smem1[tid] = val1;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for(int i = BUFFER2; i > 0; i >>= 1)
+    {
+        if(tid < i)
+        {
+            smem1[tid] += smem1[tid + i];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+}
+#else
+inline void reduce3(float val1, float val2, float val3,
+             __local float* smem1, __local float* smem2, __local float* smem3, int tid)
+{
+    smem1[tid] = val1;
+    smem2[tid] = val2;
+    smem3[tid] = val3;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (tid < 32)
+    {
+        smem1[tid] += smem1[tid + 32];
+        smem2[tid] += smem2[tid + 32];
+        smem3[tid] += smem3[tid + 32];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
+        smem1[tid] += smem1[tid + 16];
+        smem2[tid] += smem2[tid + 16];
+        smem3[tid] += smem3[tid + 16];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+        smem1[tid] += smem1[tid + 8];
+        smem2[tid] += smem2[tid + 8];
+        smem3[tid] += smem3[tid + 8];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+        smem1[tid] += smem1[tid + 4];
+        smem2[tid] += smem2[tid + 4];
+        smem3[tid] += smem3[tid + 4];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid == 0)
+    {
+        smem1[0] = (smem1[0] + smem1[1]) + (smem1[2] + smem1[3]);
+        smem2[0] = (smem2[0] + smem2[1]) + (smem2[2] + smem2[3]);
+        smem3[0] = (smem3[0] + smem3[1]) + (smem3[2] + smem3[3]);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+}
+
+inline void reduce2(float val1, float val2, __local float* smem1, __local float* smem2, int tid)
+{
+    smem1[tid] = val1;
+    smem2[tid] = val2;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (tid < 32)
+    {
+        smem1[tid] += smem1[tid + 32];
+        smem2[tid] += smem2[tid + 32];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
+        smem1[tid] += smem1[tid + 16];
+        smem2[tid] += smem2[tid + 16];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+        smem1[tid] += smem1[tid + 8];
+        smem2[tid] += smem2[tid + 8];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+        smem1[tid] += smem1[tid + 4];
+        smem2[tid] += smem2[tid + 4];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid == 0)
+    {
+        smem1[0] = (smem1[0] + smem1[1]) + (smem1[2] + smem1[3]);
+        smem2[0] = (smem2[0] + smem2[1]) + (smem2[2] + smem2[3]);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+}
+
+inline void reduce1(float val1, __local float* smem1, int tid)
+{
+    smem1[tid] = val1;
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    if (tid < 32)
+    {
+        smem1[tid] += smem1[tid + 32];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 16)
+    {
+        smem1[tid] += smem1[tid + 16];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 8)
+    {
+        smem1[tid] += smem1[tid + 8];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid < 4)
+    {
+        smem1[tid] += smem1[tid + 4];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if (tid == 0)
+    {
+        smem1[0] = (smem1[0] + smem1[1]) + (smem1[2] + smem1[3]);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+}
+#endif
+
+#define SCALE (1.0f / (1 << 20))
+#define	THRESHOLD	0.01f
+
+// Image read mode
+__constant sampler_t sampler    = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_LINEAR;
+
+// macro to get pixel value from local memory
+
+#define VAL(_y,_x,_yy,_xx)    (IPatchLocal[mad24(((_y) + (_yy)), LM_W, ((_x) + (_xx)))])
+inline void SetPatch(local float* IPatchLocal, int TileY, int TileX,
+              float* Pch, float* Dx, float* Dy,
+              float* A11, float* A12, float* A22, float w)
+{
+    int xid=get_local_id(0);
+    int yid=get_local_id(1);
+    int xBase = mad24(TileX, LSx, (xid + 1));
+    int yBase = mad24(TileY, LSy, (yid + 1));
+
+    *Pch = VAL(yBase,xBase,0,0);
+
+    *Dx = mad((VAL(yBase,xBase,-1,1) + VAL(yBase,xBase,+1,1) - VAL(yBase,xBase,-1,-1) - VAL(yBase,xBase,+1,-1)), 3.0f, (VAL(yBase,xBase,0,1) - VAL(yBase,xBase,0,-1)) * 10.0f) * w;
+    *Dy = mad((VAL(yBase,xBase,1,-1) + VAL(yBase,xBase,1,+1) - VAL(yBase,xBase,-1,-1) - VAL(yBase,xBase,-1,+1)), 3.0f, (VAL(yBase,xBase,1,0) - VAL(yBase,xBase,-1,0)) * 10.0f) * w;
+
+    *A11 = mad(*Dx, *Dx, *A11);
+    *A12 = mad(*Dx, *Dy, *A12);
+    *A22 = mad(*Dy, *Dy, *A22);
+}
+#undef VAL
+
+inline void GetPatch(image2d_t J, float x, float y,
+              float* Pch, float* Dx, float* Dy,
+              float* b1, float* b2)
+{
+    float diff = read_imagef(J, sampler, (float2)(x,y)).x-*Pch;
+    *b1 = mad(diff, *Dx, *b1);
+    *b2 = mad(diff, *Dy, *b2);
+}
+
+inline void GetError(image2d_t J, const float x, const float y, const float* Pch, float* errval, float w)
+{
+    float diff = ((((read_imagef(J, sampler, (float2)(x,y)).x * 16384) + 256) / 512) - (((*Pch * 16384) + 256) /512)) * w;
+    *errval += fabs(diff);
+}
+
+
+//macro to read pixel value into local memory.
+#define READI(_y,_x) IPatchLocal[mad24(mad24((_y), LSy, yid), LM_W, mad24((_x), LSx, xid))] = read_imagef(I, sampler, (float2)(mad((float)(_x), (float)LSx, Point.x + xid - 0.5f), mad((float)(_y), (float)LSy, Point.y + yid - 0.5f))).x;
+void ReadPatchIToLocalMem(image2d_t I, float2 Point, local float* IPatchLocal)
+{
+    int xid=get_local_id(0);
+    int yid=get_local_id(1);
+    //read (3*LSx)*(3*LSy) window. each macro call read LSx*LSy pixels block
+    READI(0,0);READI(0,1);READI(0,2);
+    READI(1,0);READI(1,1);READI(1,2);
+    READI(2,0);READI(2,1);READI(2,2);
+    if(xid<2)
+    {// read last 2 columns border. each macro call reads 2*LSy pixels block
+        READI(0,3);
+        READI(1,3);
+        READI(2,3);
+    }
+
+    if(yid<2)
+    {// read last 2 row. each macro call reads LSx*2 pixels block
+        READI(3,0);READI(3,1);READI(3,2);
+    }
+
+    if(yid<2 && xid<2)
+    {// read right bottom 2x2 corner. one macro call reads 2*2 pixels block
+        READI(3,3);
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+}
+#undef READI
+
+__attribute__((reqd_work_group_size(LSx, LSy, 1)))
+__kernel void lkSparse(image2d_t I, image2d_t J,
+                       __global const float2* prevPts, __global float2* nextPts, __global uchar* status, __global float* err,
+                       const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr)
+{
+    __local float smem1[BUFFER];
+    __local float smem2[BUFFER];
+    __local float smem3[BUFFER];
+
+    int xid=get_local_id(0);
+    int yid=get_local_id(1);
+    int gid=get_group_id(0);
+    int xsize=get_local_size(0);
+    int ysize=get_local_size(1);
+    int k;
+
+#ifdef CPU
+    float wx0 = 1.0f;
+    float wy0 = 1.0f;
+    int xBase = mad24(xsize, 2, xid);
+    int yBase = mad24(ysize, 2, yid);
+    float wx1 = (xBase < c_winSize_x) ? 1 : 0;
+    float wy1 = (yBase < c_winSize_y) ? 1 : 0;
+#else
+#if WSX == 1
+    float wx0 = 1.0f;
+    int xBase = mad24(xsize, 2, xid);
+    float wx1 = (xBase < c_winSize_x) ? 1 : 0;
+#else
+    int xBase = mad24(xsize, 1, xid);
+    float wx0 = (xBase < c_winSize_x) ? 1 : 0;
+    float wx1 = 0.0f;
+#endif
+#if WSY == 1
+    float wy0 = 1.0f;
+    int yBase = mad24(ysize, 2, yid);
+    float wy1 = (yBase < c_winSize_y) ? 1 : 0;
+#else
+    int yBase = mad24(ysize, 1, yid);
+    float wy0 = (yBase < c_winSize_y) ? 1 : 0;
+    float wy1 = 0.0f;
+#endif
+#endif
+
+    float2 c_halfWin = (float2)((c_winSize_x - 1)>>1, (c_winSize_y - 1)>>1);
+
+    const int tid = mad24(yid, xsize, xid);
+
+    float2 prevPt = prevPts[gid] / (float2)(1 << level);
+
+    if (prevPt.x < 0 || prevPt.x >= cols || prevPt.y < 0 || prevPt.y >= rows)
+    {
+        if (tid == 0 && level == 0)
+        {
+            status[gid] = 0;
+        }
+
+        return;
+    }
+    prevPt -= c_halfWin;
+
+    // extract the patch from the first image, compute covariation matrix of derivatives
+
+    float A11 = 0;
+    float A12 = 0;
+    float A22 = 0;
+
+    float I_patch[GRIDSIZE][GRIDSIZE];
+    float dIdx_patch[GRIDSIZE][GRIDSIZE];
+    float dIdy_patch[GRIDSIZE][GRIDSIZE];
+
+    // local memory to read image with border to calc sobels
+    local float IPatchLocal[LM_W*LM_H];
+    ReadPatchIToLocalMem(I,prevPt,IPatchLocal);
+
+    {
+        SetPatch(IPatchLocal, 0, 0,
+                 &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
+                 &A11, &A12, &A22,1);
+
+
+        SetPatch(IPatchLocal, 0, 1,
+                 &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
+                 &A11, &A12, &A22,wx0);
+
+        SetPatch(IPatchLocal, 0, 2,
+                    &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
+                    &A11, &A12, &A22,wx1);
+    }
+    {
+        SetPatch(IPatchLocal, 1, 0,
+                 &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
+                 &A11, &A12, &A22,wy0);
+
+
+        SetPatch(IPatchLocal, 1,1,
+                 &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
+                 &A11, &A12, &A22,wx0*wy0);
+
+        SetPatch(IPatchLocal, 1,2,
+                    &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
+                    &A11, &A12, &A22,wx1*wy0);
+    }
+    {
+        SetPatch(IPatchLocal, 2,0,
+                 &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
+                 &A11, &A12, &A22,wy1);
+
+
+        SetPatch(IPatchLocal, 2,1,
+                 &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
+                 &A11, &A12, &A22,wx0*wy1);
+
+        SetPatch(IPatchLocal, 2,2,
+                    &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
+                    &A11, &A12, &A22,wx1*wy1);
+    }
+
+
+    reduce3(A11, A12, A22, smem1, smem2, smem3, tid);
+
+    A11 = smem1[0];
+    A12 = smem2[0];
+    A22 = smem3[0];
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    float D = mad(A11, A22, - A12 * A12);
+
+    if (D < 1.192092896e-07f)
+    {
+        if (tid == 0 && level == 0)
+            status[gid] = 0;
+
+        return;
+    }
+
+    A11 /= D;
+    A12 /= D;
+    A22 /= D;
+
+    prevPt = mad(nextPts[gid], 2.0f, - c_halfWin);
+
+    float2 offset0 = (float2)(xid + 0.5f, yid + 0.5f);
+    float2 offset1 = (float2)(xsize, ysize);
+    float2 loc0 = prevPt + offset0;
+    float2 loc1 = loc0 + offset1;
+    float2 loc2 = loc1 + offset1;
+
+    for (k = 0; k < c_iters; ++k)
+    {
+        if (prevPt.x < -c_halfWin.x || prevPt.x >= cols || prevPt.y < -c_halfWin.y || prevPt.y >= rows)
+        {
+            if (tid == 0 && level == 0)
+                status[gid] = 0;
+            break;
+        }
+        float b1 = 0;
+        float b2 = 0;
+
+        {
+            GetPatch(J, loc0.x, loc0.y,
+                     &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0],
+                     &b1, &b2);
+
+
+            GetPatch(J, loc1.x, loc0.y,
+                     &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1],
+                     &b1, &b2);
+
+            GetPatch(J, loc2.x, loc0.y,
+                        &I_patch[0][2], &dIdx_patch[0][2], &dIdy_patch[0][2],
+                        &b1, &b2);
+        }
+        {
+            GetPatch(J, loc0.x, loc1.y,
+                     &I_patch[1][0], &dIdx_patch[1][0], &dIdy_patch[1][0],
+                     &b1, &b2);
+
+
+            GetPatch(J, loc1.x, loc1.y,
+                     &I_patch[1][1], &dIdx_patch[1][1], &dIdy_patch[1][1],
+                     &b1, &b2);
+
+            GetPatch(J, loc2.x, loc1.y,
+                        &I_patch[1][2], &dIdx_patch[1][2], &dIdy_patch[1][2],
+                        &b1, &b2);
+        }
+        {
+            GetPatch(J, loc0.x, loc2.y,
+                     &I_patch[2][0], &dIdx_patch[2][0], &dIdy_patch[2][0],
+                     &b1, &b2);
+
+
+            GetPatch(J, loc1.x, loc2.y,
+                     &I_patch[2][1], &dIdx_patch[2][1], &dIdy_patch[2][1],
+                     &b1, &b2);
+
+            GetPatch(J, loc2.x, loc2.y,
+                        &I_patch[2][2], &dIdx_patch[2][2], &dIdy_patch[2][2],
+                        &b1, &b2);
+        }
+
+        reduce2(b1, b2, smem1, smem2, tid);
+
+        b1 = smem1[0];
+        b2 = smem2[0];
+        barrier(CLK_LOCAL_MEM_FENCE);
+
+        float2 delta;
+        delta.x = mad(A12, b2, - A22 * b1) * 32.0f;
+        delta.y = mad(A12, b1, - A11 * b2) * 32.0f;
+
+        prevPt += delta;
+        loc0 += delta;
+        loc1 += delta;
+        loc2 += delta;
+
+        if (fabs(delta.x) < THRESHOLD && fabs(delta.y) < THRESHOLD)
+            break;
+    }
+
+    D = 0.0f;
+    if (calcErr)
+    {
+        {
+            GetError(J, loc0.x, loc0.y, &I_patch[0][0], &D, 1);
+            GetError(J, loc1.x, loc0.y, &I_patch[0][1], &D, wx0);
+        }
+        {
+            GetError(J, loc0.x, loc1.y, &I_patch[1][0], &D, wy0);
+            GetError(J, loc1.x, loc1.y, &I_patch[1][1], &D, wx0*wy0);
+        }
+        if(xBase < c_winSize_x)
+        {
+            GetError(J, loc2.x, loc0.y, &I_patch[0][2], &D, wx1);
+            GetError(J, loc2.x, loc1.y, &I_patch[1][2], &D, wx1*wy0);
+        }
+        if(yBase < c_winSize_y)
+        {
+            GetError(J, loc0.x, loc2.y, &I_patch[2][0], &D, wy1);
+            GetError(J, loc1.x, loc2.y, &I_patch[2][1], &D, wx0*wy1);
+            if(xBase < c_winSize_x)
+                GetError(J, loc2.x, loc2.y, &I_patch[2][2], &D, wx1*wy1);
+        }
+
+        reduce1(D, smem1, tid);
+    }
+
+    if (tid == 0)
+    {
+        prevPt += c_halfWin;
+
+        nextPts[gid] = prevPt;
+
+        if (calcErr)
+            err[gid] = smem1[0] / (float)(32 * c_winSize_x * c_winSize_y);
+    }
+}
diff --git a/upstream/opencv/modules/video/src/optflowgf.cpp b/upstream/opencv/modules/video/src/optflowgf.cpp
new file mode 100644
index 0000000..7d654f7
--- /dev/null
+++ b/upstream/opencv/modules/video/src/optflowgf.cpp
@@ -0,0 +1,1211 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencl_kernels_video.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+
+#if defined __APPLE__ || defined __ANDROID__
+#define SMALL_LOCALSIZE
+#endif
+
+//
+// 2D dense optical flow algorithm from the following paper:
+// Gunnar Farneback. "Two-Frame Motion Estimation Based on Polynomial Expansion".
+// Proceedings of the 13th Scandinavian Conference on Image Analysis, Gothenburg, Sweden
+//
+
+namespace cv
+{
+
+static void
+FarnebackPrepareGaussian(int n, double sigma, float *g, float *xg, float *xxg,
+                         double &ig11, double &ig03, double &ig33, double &ig55)
+{
+    if( sigma < FLT_EPSILON )
+        sigma = n*0.3;
+
+    double s = 0.;
+    for (int x = -n; x <= n; x++)
+    {
+        g[x] = (float)std::exp(-x*x/(2*sigma*sigma));
+        s += g[x];
+    }
+
+    s = 1./s;
+    for (int x = -n; x <= n; x++)
+    {
+        g[x] = (float)(g[x]*s);
+        xg[x] = (float)(x*g[x]);
+        xxg[x] = (float)(x*x*g[x]);
+    }
+
+    Mat_<double> G(6, 6);
+    G.setTo(0);
+
+    for (int y = -n; y <= n; y++)
+    {
+        for (int x = -n; x <= n; x++)
+        {
+            G(0,0) += g[y]*g[x];
+            G(1,1) += g[y]*g[x]*x*x;
+            G(3,3) += g[y]*g[x]*x*x*x*x;
+            G(5,5) += g[y]*g[x]*x*x*y*y;
+        }
+    }
+
+    //G[0][0] = 1.;
+    G(2,2) = G(0,3) = G(0,4) = G(3,0) = G(4,0) = G(1,1);
+    G(4,4) = G(3,3);
+    G(3,4) = G(4,3) = G(5,5);
+
+    // invG:
+    // [ x        e  e    ]
+    // [    y             ]
+    // [       y          ]
+    // [ e        z       ]
+    // [ e           z    ]
+    // [                u ]
+    Mat_<double> invG = G.inv(DECOMP_CHOLESKY);
+
+    ig11 = invG(1,1);
+    ig03 = invG(0,3);
+    ig33 = invG(3,3);
+    ig55 = invG(5,5);
+}
+
+static void
+FarnebackPolyExp( const Mat& src, Mat& dst, int n, double sigma )
+{
+    int k, x, y;
+
+    CV_Assert( src.type() == CV_32FC1 );
+    int width = src.cols;
+    int height = src.rows;
+    AutoBuffer<float> kbuf(n*6 + 3), _row((width + n*2)*3);
+    float* g = kbuf.data() + n;
+    float* xg = g + n*2 + 1;
+    float* xxg = xg + n*2 + 1;
+    float *row = _row.data() + n*3;
+    double ig11, ig03, ig33, ig55;
+
+    FarnebackPrepareGaussian(n, sigma, g, xg, xxg, ig11, ig03, ig33, ig55);
+
+    dst.create( height, width, CV_32FC(5));
+
+    for( y = 0; y < height; y++ )
+    {
+        float g0 = g[0], g1, g2;
+        const float *srow0 = src.ptr<float>(y), *srow1 = 0;
+        float *drow = dst.ptr<float>(y);
+
+        // vertical part of convolution
+        for( x = 0; x < width; x++ )
+        {
+            row[x*3] = srow0[x]*g0;
+            row[x*3+1] = row[x*3+2] = 0.f;
+        }
+
+        for( k = 1; k <= n; k++ )
+        {
+            g0 = g[k]; g1 = xg[k]; g2 = xxg[k];
+            srow0 = src.ptr<float>(std::max(y-k,0));
+            srow1 = src.ptr<float>(std::min(y+k,height-1));
+
+            for( x = 0; x < width; x++ )
+            {
+                float p = srow0[x] + srow1[x];
+                float t0 = row[x*3] + g0*p;
+                float t1 = row[x*3+1] + g1*(srow1[x] - srow0[x]);
+                float t2 = row[x*3+2] + g2*p;
+
+                row[x*3] = t0;
+                row[x*3+1] = t1;
+                row[x*3+2] = t2;
+            }
+        }
+
+        // horizontal part of convolution
+        for( x = 0; x < n*3; x++ )
+        {
+            row[-1-x] = row[2-x];
+            row[width*3+x] = row[width*3+x-3];
+        }
+
+        for( x = 0; x < width; x++ )
+        {
+            g0 = g[0];
+            // r1 ~ 1, r2 ~ x, r3 ~ y, r4 ~ x^2, r5 ~ y^2, r6 ~ xy
+            double b1 = row[x*3]*g0, b2 = 0, b3 = row[x*3+1]*g0,
+                b4 = 0, b5 = row[x*3+2]*g0, b6 = 0;
+
+            for( k = 1; k <= n; k++ )
+            {
+                double tg = row[(x+k)*3] + row[(x-k)*3];
+                g0 = g[k];
+                b1 += tg*g0;
+                b4 += tg*xxg[k];
+                b2 += (row[(x+k)*3] - row[(x-k)*3])*xg[k];
+                b3 += (row[(x+k)*3+1] + row[(x-k)*3+1])*g0;
+                b6 += (row[(x+k)*3+1] - row[(x-k)*3+1])*xg[k];
+                b5 += (row[(x+k)*3+2] + row[(x-k)*3+2])*g0;
+            }
+
+            // do not store r1
+            drow[x*5+1] = (float)(b2*ig11);
+            drow[x*5] = (float)(b3*ig11);
+            drow[x*5+3] = (float)(b1*ig03 + b4*ig33);
+            drow[x*5+2] = (float)(b1*ig03 + b5*ig33);
+            drow[x*5+4] = (float)(b6*ig55);
+        }
+    }
+
+    row -= n*3;
+}
+
+
+/*static void
+FarnebackPolyExpPyr( const Mat& src0, Vector<Mat>& pyr, int maxlevel, int n, double sigma )
+{
+    Vector<Mat> imgpyr;
+    buildPyramid( src0, imgpyr, maxlevel );
+
+    for( int i = 0; i <= maxlevel; i++ )
+        FarnebackPolyExp( imgpyr[i], pyr[i], n, sigma );
+}*/
+
+
+static void
+FarnebackUpdateMatrices( const Mat& _R0, const Mat& _R1, const Mat& _flow, Mat& matM, int _y0, int _y1 )
+{
+    const int BORDER = 5;
+    static const float border[BORDER] = {0.14f, 0.14f, 0.4472f, 0.4472f, 0.4472f};
+
+    int x, y, width = _flow.cols, height = _flow.rows;
+    const float* R1 = _R1.ptr<float>();
+    size_t step1 = _R1.step/sizeof(R1[0]);
+
+    matM.create(height, width, CV_32FC(5));
+
+    for( y = _y0; y < _y1; y++ )
+    {
+        const float* flow = _flow.ptr<float>(y);
+        const float* R0 = _R0.ptr<float>(y);
+        float* M = matM.ptr<float>(y);
+
+        for( x = 0; x < width; x++ )
+        {
+            float dx = flow[x*2], dy = flow[x*2+1];
+            float fx = x + dx, fy = y + dy;
+
+#if 1
+            int x1 = cvFloor(fx), y1 = cvFloor(fy);
+            float r2, r3, r4, r5, r6;
+
+            fx -= x1; fy -= y1;
+
+            if( (unsigned)x1 < (unsigned)(width-1) &&
+                (unsigned)y1 < (unsigned)(height-1) )
+            {
+                const float* ptr = R1 + y1*step1 + x1*5;
+                float a00 = (1.f-fx)*(1.f-fy), a01 = fx*(1.f-fy),
+                      a10 = (1.f-fx)*fy, a11 = fx*fy;
+
+                r2 = a00*ptr[0] + a01*ptr[5] + a10*ptr[step1] + a11*ptr[step1+5];
+                r3 = a00*ptr[1] + a01*ptr[6] + a10*ptr[step1+1] + a11*ptr[step1+6];
+                r4 = a00*ptr[2] + a01*ptr[7] + a10*ptr[step1+2] + a11*ptr[step1+7];
+                r5 = a00*ptr[3] + a01*ptr[8] + a10*ptr[step1+3] + a11*ptr[step1+8];
+                r6 = a00*ptr[4] + a01*ptr[9] + a10*ptr[step1+4] + a11*ptr[step1+9];
+
+                r4 = (R0[x*5+2] + r4)*0.5f;
+                r5 = (R0[x*5+3] + r5)*0.5f;
+                r6 = (R0[x*5+4] + r6)*0.25f;
+            }
+#else
+            int x1 = cvRound(fx), y1 = cvRound(fy);
+            float r2, r3, r4, r5, r6;
+
+            if( (unsigned)x1 < (unsigned)width &&
+                (unsigned)y1 < (unsigned)height )
+            {
+                const float* ptr = R1 + y1*step1 + x1*5;
+                r2 = ptr[0];
+                r3 = ptr[1];
+                r4 = (R0[x*5+2] + ptr[2])*0.5f;
+                r5 = (R0[x*5+3] + ptr[3])*0.5f;
+                r6 = (R0[x*5+4] + ptr[4])*0.25f;
+            }
+#endif
+            else
+            {
+                r2 = r3 = 0.f;
+                r4 = R0[x*5+2];
+                r5 = R0[x*5+3];
+                r6 = R0[x*5+4]*0.5f;
+            }
+
+            r2 = (R0[x*5] - r2)*0.5f;
+            r3 = (R0[x*5+1] - r3)*0.5f;
+
+            r2 += r4*dy + r6*dx;
+            r3 += r6*dy + r5*dx;
+
+            if( (unsigned)(x - BORDER) >= (unsigned)(width - BORDER*2) ||
+                (unsigned)(y - BORDER) >= (unsigned)(height - BORDER*2))
+            {
+                float scale = (x < BORDER ? border[x] : 1.f)*
+                    (x >= width - BORDER ? border[width - x - 1] : 1.f)*
+                    (y < BORDER ? border[y] : 1.f)*
+                    (y >= height - BORDER ? border[height - y - 1] : 1.f);
+
+                r2 *= scale; r3 *= scale; r4 *= scale;
+                r5 *= scale; r6 *= scale;
+            }
+
+            M[x*5]   = r4*r4 + r6*r6; // G(1,1)
+            M[x*5+1] = (r4 + r5)*r6;  // G(1,2)=G(2,1)
+            M[x*5+2] = r5*r5 + r6*r6; // G(2,2)
+            M[x*5+3] = r4*r2 + r6*r3; // h(1)
+            M[x*5+4] = r6*r2 + r5*r3; // h(2)
+        }
+    }
+}
+
+
+static void
+FarnebackUpdateFlow_Blur( const Mat& _R0, const Mat& _R1,
+                          Mat& _flow, Mat& matM, int block_size,
+                          bool update_matrices )
+{
+    int x, y, width = _flow.cols, height = _flow.rows;
+    int m = block_size/2;
+    int y0 = 0, y1;
+    int min_update_stripe = std::max((1 << 10)/width, block_size);
+    double scale = 1./(block_size*block_size);
+
+    AutoBuffer<double> _vsum((width+m*2+2)*5);
+    double* vsum = _vsum.data() + (m+1)*5;
+
+    // init vsum
+    const float* srow0 = matM.ptr<float>();
+    for( x = 0; x < width*5; x++ )
+        vsum[x] = srow0[x]*(m+2);
+
+    for( y = 1; y < m; y++ )
+    {
+        srow0 = matM.ptr<float>(std::min(y,height-1));
+        for( x = 0; x < width*5; x++ )
+            vsum[x] += srow0[x];
+    }
+
+    // compute blur(G)*flow=blur(h)
+    for( y = 0; y < height; y++ )
+    {
+        double g11, g12, g22, h1, h2;
+        float* flow = _flow.ptr<float>(y);
+
+        srow0 = matM.ptr<float>(std::max(y-m-1,0));
+        const float* srow1 = matM.ptr<float>(std::min(y+m,height-1));
+
+        // vertical blur
+        for( x = 0; x < width*5; x++ )
+            vsum[x] += srow1[x] - srow0[x];
+
+        // update borders
+        for( x = 0; x < (m+1)*5; x++ )
+        {
+            vsum[-1-x] = vsum[4-x];
+            vsum[width*5+x] = vsum[width*5+x-5];
+        }
+
+        // init g** and h*
+        g11 = vsum[0]*(m+2);
+        g12 = vsum[1]*(m+2);
+        g22 = vsum[2]*(m+2);
+        h1 = vsum[3]*(m+2);
+        h2 = vsum[4]*(m+2);
+
+        for( x = 1; x < m; x++ )
+        {
+            g11 += vsum[x*5];
+            g12 += vsum[x*5+1];
+            g22 += vsum[x*5+2];
+            h1 += vsum[x*5+3];
+            h2 += vsum[x*5+4];
+        }
+
+        // horizontal blur
+        for( x = 0; x < width; x++ )
+        {
+            g11 += vsum[(x+m)*5] - vsum[(x-m)*5 - 5];
+            g12 += vsum[(x+m)*5 + 1] - vsum[(x-m)*5 - 4];
+            g22 += vsum[(x+m)*5 + 2] - vsum[(x-m)*5 - 3];
+            h1 += vsum[(x+m)*5 + 3] - vsum[(x-m)*5 - 2];
+            h2 += vsum[(x+m)*5 + 4] - vsum[(x-m)*5 - 1];
+
+            double g11_ = g11*scale;
+            double g12_ = g12*scale;
+            double g22_ = g22*scale;
+            double h1_ = h1*scale;
+            double h2_ = h2*scale;
+
+            double idet = 1./(g11_*g22_ - g12_*g12_+1e-3);
+
+            flow[x*2] = (float)((g11_*h2_-g12_*h1_)*idet);
+            flow[x*2+1] = (float)((g22_*h1_-g12_*h2_)*idet);
+        }
+
+        y1 = y == height - 1 ? height : y - block_size;
+        if( update_matrices && (y1 == height || y1 >= y0 + min_update_stripe) )
+        {
+            FarnebackUpdateMatrices( _R0, _R1, _flow, matM, y0, y1 );
+            y0 = y1;
+        }
+    }
+}
+
+
+static void
+FarnebackUpdateFlow_GaussianBlur( const Mat& _R0, const Mat& _R1,
+                                  Mat& _flow, Mat& matM, int block_size,
+                                  bool update_matrices )
+{
+    int x, y, i, width = _flow.cols, height = _flow.rows;
+    int m = block_size/2;
+    int y0 = 0, y1;
+    int min_update_stripe = std::max((1 << 10)/width, block_size);
+    double sigma = m*0.3, s = 1;
+
+    AutoBuffer<float> _vsum((width+m*2+2)*5 + 16), _hsum(width*5 + 16);
+    AutoBuffer<float> _kernel((m+1)*5 + 16);
+    AutoBuffer<const float*> _srow(m*2+1);
+    float *vsum = alignPtr(_vsum.data() + (m+1)*5, 16), *hsum = alignPtr(_hsum.data(), 16);
+    float* kernel = _kernel.data();
+    const float** srow = _srow.data();
+    kernel[0] = (float)s;
+
+    for( i = 1; i <= m; i++ )
+    {
+        float t = (float)std::exp(-i*i/(2*sigma*sigma) );
+        kernel[i] = t;
+        s += t*2;
+    }
+
+    s = 1./s;
+    for( i = 0; i <= m; i++ )
+        kernel[i] = (float)(kernel[i]*s);
+
+#if CV_SIMD128
+    float* simd_kernel = alignPtr(kernel + m+1, 16);
+    {
+        for( i = 0; i <= m; i++ )
+            v_store(simd_kernel + i*4, v_setall_f32(kernel[i]));
+    }
+#endif
+
+    // compute blur(G)*flow=blur(h)
+    for( y = 0; y < height; y++ )
+    {
+        double g11, g12, g22, h1, h2;
+        float* flow = _flow.ptr<float>(y);
+
+        // vertical blur
+        for( i = 0; i <= m; i++ )
+        {
+            srow[m-i] = matM.ptr<float>(std::max(y-i,0));
+            srow[m+i] = matM.ptr<float>(std::min(y+i,height-1));
+        }
+
+        x = 0;
+#if CV_SIMD128
+        {
+            for( ; x <= width*5 - 16; x += 16 )
+            {
+                const float *sptr0 = srow[m], *sptr1;
+                v_float32x4 g4 = v_load(simd_kernel);
+                v_float32x4 s0, s1, s2, s3;
+                s0 = v_mul(v_load(sptr0 + x), g4);
+                s1 = v_mul(v_load(sptr0 + x + 4), g4);
+                s2 = v_mul(v_load(sptr0 + x + 8), g4);
+                s3 = v_mul(v_load(sptr0 + x + 12), g4);
+
+                for( i = 1; i <= m; i++ )
+                {
+                    v_float32x4 x0, x1;
+                    sptr0 = srow[m+i], sptr1 = srow[m-i];
+                    g4 = v_load(simd_kernel + i*4);
+                    x0 = v_add(v_load(sptr0 + x), v_load(sptr1 + x));
+                    x1 = v_add(v_load(sptr0 + x + 4), v_load(sptr1 + x + 4));
+                    s0 = v_muladd(x0, g4, s0);
+                    s1 = v_muladd(x1, g4, s1);
+                    x0 = v_add(v_load(sptr0 + x + 8), v_load(sptr1 + x + 8));
+                    x1 = v_add(v_load(sptr0 + x + 12), v_load(sptr1 + x + 12));
+                    s2 = v_muladd(x0, g4, s2);
+                    s3 = v_muladd(x1, g4, s3);
+                }
+
+                v_store(vsum + x, s0);
+                v_store(vsum + x + 4, s1);
+                v_store(vsum + x + 8, s2);
+                v_store(vsum + x + 12, s3);
+            }
+
+            for( ; x <= width*5 - 4; x += 4 )
+            {
+                const float *sptr0 = srow[m], *sptr1;
+                v_float32x4 g4 = v_load(simd_kernel);
+                v_float32x4 s0 = v_mul(v_load(sptr0 + x), g4);
+
+                for( i = 1; i <= m; i++ )
+                {
+                    sptr0 = srow[m+i], sptr1 = srow[m-i];
+                    g4 = v_load(simd_kernel + i*4);
+                    v_float32x4 x0 = v_add(v_load(sptr0 + x), v_load(sptr1 + x));
+                    s0 = v_muladd(x0, g4, s0);
+                }
+                v_store(vsum + x, s0);
+            }
+        }
+#endif
+        for( ; x < width*5; x++ )
+        {
+            float s0 = srow[m][x]*kernel[0];
+            for( i = 1; i <= m; i++ )
+                s0 += (srow[m+i][x] + srow[m-i][x])*kernel[i];
+            vsum[x] = s0;
+        }
+
+        // update borders
+        for( x = 0; x < m*5; x++ )
+        {
+            vsum[-1-x] = vsum[4-x];
+            vsum[width*5+x] = vsum[width*5+x-5];
+        }
+
+        // horizontal blur
+        x = 0;
+#if CV_SIMD128
+        {
+            for( ; x <= width*5 - 8; x += 8 )
+            {
+                v_float32x4 g4 = v_load(simd_kernel);
+                v_float32x4 s0 = v_mul(v_load(vsum + x), g4);
+                v_float32x4 s1 = v_mul(v_load(vsum + x + 4), g4);
+
+                for( i = 1; i <= m; i++ )
+                {
+                    g4 = v_load(simd_kernel + i*4);
+                    v_float32x4 x0 = v_add(v_load(vsum + x - i * 5), v_load(vsum + x + i * 5));
+                    v_float32x4 x1 = v_add(v_load(vsum + x - i * 5 + 4), v_load(vsum + x + i * 5 + 4));
+                    s0 = v_muladd(x0, g4, s0);
+                    s1 = v_muladd(x1, g4, s1);
+                }
+
+                v_store(hsum + x, s0);
+                v_store(hsum + x + 4, s1);
+            }
+        }
+#endif
+        for( ; x < width*5; x++ )
+        {
+            float sum = vsum[x]*kernel[0];
+            for( i = 1; i <= m; i++ )
+                sum += kernel[i]*(vsum[x - i*5] + vsum[x + i*5]);
+            hsum[x] = sum;
+        }
+
+        for( x = 0; x < width; x++ )
+        {
+            g11 = hsum[x*5];
+            g12 = hsum[x*5+1];
+            g22 = hsum[x*5+2];
+            h1 = hsum[x*5+3];
+            h2 = hsum[x*5+4];
+
+            double idet = 1./(g11*g22 - g12*g12 + 1e-3);
+
+            flow[x*2] = (float)((g11*h2-g12*h1)*idet);
+            flow[x*2+1] = (float)((g22*h1-g12*h2)*idet);
+        }
+
+        y1 = y == height - 1 ? height : y - block_size;
+        if( update_matrices && (y1 == height || y1 >= y0 + min_update_stripe) )
+        {
+            FarnebackUpdateMatrices( _R0, _R1, _flow, matM, y0, y1 );
+            y0 = y1;
+        }
+    }
+}
+
+}
+
+namespace cv
+{
+namespace
+{
+class FarnebackOpticalFlowImpl : public FarnebackOpticalFlow
+{
+public:
+    FarnebackOpticalFlowImpl(int numLevels=5, double pyrScale=0.5, bool fastPyramids=false, int winSize=13,
+                             int numIters=10, int polyN=5, double polySigma=1.1, int flags=0) :
+        numLevels_(numLevels), pyrScale_(pyrScale), fastPyramids_(fastPyramids), winSize_(winSize),
+        numIters_(numIters), polyN_(polyN), polySigma_(polySigma), flags_(flags)
+    {
+    }
+
+    virtual int getNumLevels() const CV_OVERRIDE { return numLevels_; }
+    virtual void setNumLevels(int numLevels) CV_OVERRIDE { numLevels_ = numLevels; }
+
+    virtual double getPyrScale() const CV_OVERRIDE { return pyrScale_; }
+    virtual void setPyrScale(double pyrScale) CV_OVERRIDE { pyrScale_ = pyrScale; }
+
+    virtual bool getFastPyramids() const CV_OVERRIDE { return fastPyramids_; }
+    virtual void setFastPyramids(bool fastPyramids) CV_OVERRIDE { fastPyramids_ = fastPyramids; }
+
+    virtual int getWinSize() const CV_OVERRIDE { return winSize_; }
+    virtual void setWinSize(int winSize) CV_OVERRIDE { winSize_ = winSize; }
+
+    virtual int getNumIters() const CV_OVERRIDE { return numIters_; }
+    virtual void setNumIters(int numIters) CV_OVERRIDE { numIters_ = numIters; }
+
+    virtual int getPolyN() const CV_OVERRIDE { return polyN_; }
+    virtual void setPolyN(int polyN) CV_OVERRIDE { polyN_ = polyN; }
+
+    virtual double getPolySigma() const CV_OVERRIDE { return polySigma_; }
+    virtual void setPolySigma(double polySigma) CV_OVERRIDE { polySigma_ = polySigma; }
+
+    virtual int getFlags() const CV_OVERRIDE { return flags_; }
+    virtual void setFlags(int flags) CV_OVERRIDE { flags_ = flags; }
+
+    virtual void calc(InputArray I0, InputArray I1, InputOutputArray flow) CV_OVERRIDE;
+
+    virtual String getDefaultName() const CV_OVERRIDE { return "DenseOpticalFlow.FarnebackOpticalFlow"; }
+
+private:
+    int numLevels_;
+    double pyrScale_;
+    bool fastPyramids_;
+    int winSize_;
+    int numIters_;
+    int polyN_;
+    double polySigma_;
+    int flags_;
+
+#ifdef HAVE_OPENCL
+    bool operator ()(const UMat &frame0, const UMat &frame1, UMat &flowx, UMat &flowy)
+    {
+        CV_Assert(frame0.channels() == 1 && frame1.channels() == 1);
+        CV_Assert(frame0.size() == frame1.size());
+        CV_Assert(polyN_ == 5 || polyN_ == 7);
+        CV_Assert(!fastPyramids_ || std::abs(pyrScale_ - 0.5) < 1e-6);
+
+        const int min_size = 32;
+
+        Size size = frame0.size();
+        UMat prevFlowX, prevFlowY, curFlowX, curFlowY;
+
+        UMat flowx0 = flowx;
+        UMat flowy0 = flowy;
+
+        // Crop unnecessary levels
+        double scale = 1;
+        int numLevelsCropped = 0;
+        for (; numLevelsCropped < numLevels_; numLevelsCropped++)
+        {
+            scale *= pyrScale_;
+            if (size.width*scale < min_size || size.height*scale < min_size)
+                break;
+        }
+
+        frame0.convertTo(frames_[0], CV_32F);
+        frame1.convertTo(frames_[1], CV_32F);
+
+        if (fastPyramids_)
+        {
+            // Build Gaussian pyramids using pyrDown()
+            pyramid0_.resize(numLevelsCropped + 1);
+            pyramid1_.resize(numLevelsCropped + 1);
+            pyramid0_[0] = frames_[0];
+            pyramid1_[0] = frames_[1];
+            for (int i = 1; i <= numLevelsCropped; ++i)
+            {
+                pyrDown(pyramid0_[i - 1], pyramid0_[i]);
+                pyrDown(pyramid1_[i - 1], pyramid1_[i]);
+            }
+        }
+
+        setPolynomialExpansionConsts(polyN_, polySigma_);
+
+        for (int k = numLevelsCropped; k >= 0; k--)
+        {
+            scale = 1;
+            for (int i = 0; i < k; i++)
+                scale *= pyrScale_;
+
+            double sigma = (1./scale - 1) * 0.5;
+            int smoothSize = cvRound(sigma*5) | 1;
+            smoothSize = std::max(smoothSize, 3);
+
+            int width = cvRound(size.width*scale);
+            int height = cvRound(size.height*scale);
+
+            if (fastPyramids_)
+            {
+                width = pyramid0_[k].cols;
+                height = pyramid0_[k].rows;
+            }
+
+            if (k > 0)
+            {
+                curFlowX.create(height, width, CV_32F);
+                curFlowY.create(height, width, CV_32F);
+            }
+            else
+            {
+                curFlowX = flowx0;
+                curFlowY = flowy0;
+            }
+
+            if (prevFlowX.empty())
+            {
+                if (flags_ & cv::OPTFLOW_USE_INITIAL_FLOW)
+                {
+                    resize(flowx0, curFlowX, Size(width, height), 0, 0, INTER_LINEAR);
+                    resize(flowy0, curFlowY, Size(width, height), 0, 0, INTER_LINEAR);
+                    multiply(scale, curFlowX, curFlowX);
+                    multiply(scale, curFlowY, curFlowY);
+                }
+                else
+                {
+                    curFlowX.setTo(0);
+                    curFlowY.setTo(0);
+                }
+            }
+            else
+            {
+                resize(prevFlowX, curFlowX, Size(width, height), 0, 0, INTER_LINEAR);
+                resize(prevFlowY, curFlowY, Size(width, height), 0, 0, INTER_LINEAR);
+                multiply(1./pyrScale_, curFlowX, curFlowX);
+                multiply(1./pyrScale_, curFlowY, curFlowY);
+            }
+
+            UMat M = allocMatFromBuf(5*height, width, CV_32F, M_);
+            UMat bufM = allocMatFromBuf(5*height, width, CV_32F, bufM_);
+            UMat R[2] =
+            {
+                allocMatFromBuf(5*height, width, CV_32F, R_[0]),
+                allocMatFromBuf(5*height, width, CV_32F, R_[1])
+            };
+
+            if (fastPyramids_)
+            {
+                if (!polynomialExpansionOcl(pyramid0_[k], R[0]))
+                    return false;
+                if (!polynomialExpansionOcl(pyramid1_[k], R[1]))
+                    return false;
+            }
+            else
+            {
+                UMat blurredFrame[2] =
+                {
+                    allocMatFromBuf(size.height, size.width, CV_32F, blurredFrame_[0]),
+                    allocMatFromBuf(size.height, size.width, CV_32F, blurredFrame_[1])
+                };
+                UMat pyrLevel[2] =
+                {
+                    allocMatFromBuf(height, width, CV_32F, pyrLevel_[0]),
+                    allocMatFromBuf(height, width, CV_32F, pyrLevel_[1])
+                };
+
+                setGaussianBlurKernel(smoothSize, sigma);
+
+                for (int i = 0; i < 2; i++)
+                {
+                    if (!gaussianBlurOcl(frames_[i], smoothSize/2, blurredFrame[i]))
+                        return false;
+                    resize(blurredFrame[i], pyrLevel[i], Size(width, height), INTER_LINEAR);
+                    if (!polynomialExpansionOcl(pyrLevel[i], R[i]))
+                        return false;
+                }
+            }
+
+            if (!updateMatricesOcl(curFlowX, curFlowY, R[0], R[1], M))
+                return false;
+
+            if (flags_ & OPTFLOW_FARNEBACK_GAUSSIAN)
+                setGaussianBlurKernel(winSize_, winSize_/2*0.3f);
+            for (int i = 0; i < numIters_; i++)
+            {
+                if (flags_ & OPTFLOW_FARNEBACK_GAUSSIAN)
+                {
+                    if (!updateFlow_gaussianBlur(R[0], R[1], curFlowX, curFlowY, M, bufM, winSize_, i < numIters_-1))
+                        return false;
+                }
+                else
+                {
+                    if (!updateFlow_boxFilter(R[0], R[1], curFlowX, curFlowY, M, bufM, winSize_, i < numIters_-1))
+                        return false;
+                }
+            }
+
+            prevFlowX = curFlowX;
+            prevFlowY = curFlowY;
+        }
+
+        flowx = curFlowX;
+        flowy = curFlowY;
+        return true;
+    }
+    virtual void collectGarbage() CV_OVERRIDE {
+        releaseMemory();
+    }
+    void releaseMemory()
+    {
+        frames_[0].release();
+        frames_[1].release();
+        pyrLevel_[0].release();
+        pyrLevel_[1].release();
+        M_.release();
+        bufM_.release();
+        R_[0].release();
+        R_[1].release();
+        blurredFrame_[0].release();
+        blurredFrame_[1].release();
+        pyramid0_.clear();
+        pyramid1_.clear();
+    }
+private:
+    UMat m_g;
+    UMat m_xg;
+    UMat m_xxg;
+
+    double m_igd[4];
+    float  m_ig[4];
+    void setPolynomialExpansionConsts(int n, double sigma)
+    {
+        std::vector<float> buf(n*6 + 3);
+        float* g = &buf[0] + n;
+        float* xg = g + n*2 + 1;
+        float* xxg = xg + n*2 + 1;
+
+        FarnebackPrepareGaussian(n, sigma, g, xg, xxg, m_igd[0], m_igd[1], m_igd[2], m_igd[3]);
+
+        cv::Mat t_g(1, n + 1, CV_32FC1, g);     t_g.copyTo(m_g);
+        cv::Mat t_xg(1, n + 1, CV_32FC1, xg);   t_xg.copyTo(m_xg);
+        cv::Mat t_xxg(1, n + 1, CV_32FC1, xxg); t_xxg.copyTo(m_xxg);
+
+        m_ig[0] = static_cast<float>(m_igd[0]);
+        m_ig[1] = static_cast<float>(m_igd[1]);
+        m_ig[2] = static_cast<float>(m_igd[2]);
+        m_ig[3] = static_cast<float>(m_igd[3]);
+    }
+private:
+    UMat m_gKer;
+    inline void setGaussianBlurKernel(int smoothSize, double sigma)
+    {
+        Mat g = getGaussianKernel(smoothSize, sigma, CV_32F);
+        Mat gKer(1, smoothSize/2 + 1, CV_32FC1, g.ptr<float>(smoothSize/2));
+        gKer.copyTo(m_gKer);
+    }
+private:
+    UMat frames_[2];
+    UMat pyrLevel_[2], M_, bufM_, R_[2], blurredFrame_[2];
+    std::vector<UMat> pyramid0_, pyramid1_;
+
+    static UMat allocMatFromBuf(int rows, int cols, int type, UMat &mat)
+    {
+        if (!mat.empty() && mat.type() == type && mat.rows >= rows && mat.cols >= cols)
+            return mat(Rect(0, 0, cols, rows));
+        return mat = UMat(rows, cols, type);
+    }
+private:
+#define DIVUP(total, grain) (((total) + (grain) - 1) / (grain))
+
+    bool gaussianBlurOcl(const UMat &src, int ksizeHalf, UMat &dst)
+    {
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 128, 1};
+#else
+        size_t localsize[2] = { 256, 1};
+#endif
+        size_t globalsize[2] = { (size_t)src.cols, (size_t)src.rows};
+        int smem_size = (int)((localsize[0] + 2*ksizeHalf) * sizeof(float));
+        ocl::Kernel kernel;
+        if (!kernel.create("gaussianBlur", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
+            return false;
+
+        CV_Assert(dst.size() == src.size());
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
+        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
+        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
+        idxArg = kernel.set(idxArg, dst.rows);
+        idxArg = kernel.set(idxArg, dst.cols);
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_gKer));
+        idxArg = kernel.set(idxArg, (int)ksizeHalf);
+        kernel.set(idxArg, (void *)NULL, smem_size);
+        return kernel.run(2, globalsize, localsize, false);
+    }
+    bool gaussianBlur5Ocl(const UMat &src, int ksizeHalf, UMat &dst)
+    {
+        int height = src.rows / 5;
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 128, 1};
+#else
+        size_t localsize[2] = { 256, 1};
+#endif
+        size_t globalsize[2] = { (size_t)src.cols, (size_t)height};
+        int smem_size = (int)((localsize[0] + 2*ksizeHalf) * 5 * sizeof(float));
+        ocl::Kernel kernel;
+        if (!kernel.create("gaussianBlur5", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
+            return false;
+
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
+        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
+        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
+        idxArg = kernel.set(idxArg, height);
+        idxArg = kernel.set(idxArg, src.cols);
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_gKer));
+        idxArg = kernel.set(idxArg, (int)ksizeHalf);
+        kernel.set(idxArg, (void *)NULL, smem_size);
+        return kernel.run(2, globalsize, localsize, false);
+    }
+    bool polynomialExpansionOcl(const UMat &src, UMat &dst)
+    {
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 128, 1};
+#else
+        size_t localsize[2] = { 256, 1};
+#endif
+        size_t globalsize[2] = { DIVUP((size_t)src.cols, localsize[0] - 2*polyN_) * localsize[0], (size_t)src.rows};
+
+#if 0
+        const cv::ocl::Device &device = cv::ocl::Device::getDefault();
+        bool useDouble = (0 != device.doubleFPConfig());
+
+        cv::String build_options = cv::format("-D polyN=%d -D USE_DOUBLE=%d", polyN_, useDouble ? 1 : 0);
+#else
+        cv::String build_options = cv::format("-D polyN=%d", polyN_);
+#endif
+        ocl::Kernel kernel;
+        if (!kernel.create("polynomialExpansion", cv::ocl::video::optical_flow_farneback_oclsrc, build_options))
+            return false;
+
+        int smem_size = (int)(3 * localsize[0] * sizeof(float));
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
+        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
+        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
+        idxArg = kernel.set(idxArg, src.rows);
+        idxArg = kernel.set(idxArg, src.cols);
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_g));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_xg));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_xxg));
+        idxArg = kernel.set(idxArg, (void *)NULL, smem_size);
+        kernel.set(idxArg, (void *)m_ig, 4 * sizeof(float));
+        return kernel.run(2, globalsize, localsize, false);
+    }
+    bool boxFilter5Ocl(const UMat &src, int ksizeHalf, UMat &dst)
+    {
+        int height = src.rows / 5;
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 128, 1};
+#else
+        size_t localsize[2] = { 256, 1};
+#endif
+        size_t globalsize[2] = { (size_t)src.cols, (size_t)height};
+
+        ocl::Kernel kernel;
+        if (!kernel.create("boxFilter5", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
+            return false;
+
+        int smem_size = (int)((localsize[0] + 2*ksizeHalf) * 5 * sizeof(float));
+
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
+        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
+        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
+        idxArg = kernel.set(idxArg, height);
+        idxArg = kernel.set(idxArg, src.cols);
+        idxArg = kernel.set(idxArg, (int)ksizeHalf);
+        kernel.set(idxArg, (void *)NULL, smem_size);
+        return kernel.run(2, globalsize, localsize, false);
+    }
+
+    bool updateFlowOcl(const UMat &M, UMat &flowx, UMat &flowy)
+    {
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 32, 4};
+#else
+        size_t localsize[2] = { 32, 8};
+#endif
+        size_t globalsize[2] = { (size_t)flowx.cols, (size_t)flowx.rows};
+
+        ocl::Kernel kernel;
+        if (!kernel.create("updateFlow", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
+            return false;
+
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(M));
+        idxArg = kernel.set(idxArg, (int)(M.step / M.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(flowx));
+        idxArg = kernel.set(idxArg, (int)(flowx.step / flowx.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(flowy));
+        idxArg = kernel.set(idxArg, (int)(flowy.step / flowy.elemSize()));
+        idxArg = kernel.set(idxArg, (int)flowy.rows);
+        kernel.set(idxArg, (int)flowy.cols);
+        return kernel.run(2, globalsize, localsize, false);
+    }
+    bool updateMatricesOcl(const UMat &flowx, const UMat &flowy, const UMat &R0, const UMat &R1, UMat &M)
+    {
+#ifdef SMALL_LOCALSIZE
+        size_t localsize[2] = { 32, 4};
+#else
+        size_t localsize[2] = { 32, 8};
+#endif
+        size_t globalsize[2] = { (size_t)flowx.cols, (size_t)flowx.rows};
+
+        ocl::Kernel kernel;
+        if (!kernel.create("updateMatrices", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
+            return false;
+
+        int idxArg = 0;
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(flowx));
+        idxArg = kernel.set(idxArg, (int)(flowx.step / flowx.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(flowy));
+        idxArg = kernel.set(idxArg, (int)(flowy.step / flowy.elemSize()));
+        idxArg = kernel.set(idxArg, (int)flowx.rows);
+        idxArg = kernel.set(idxArg, (int)flowx.cols);
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(R0));
+        idxArg = kernel.set(idxArg, (int)(R0.step / R0.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(R1));
+        idxArg = kernel.set(idxArg, (int)(R1.step / R1.elemSize()));
+        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(M));
+        kernel.set(idxArg, (int)(M.step / M.elemSize()));
+        return kernel.run(2, globalsize, localsize, false);
+    }
+
+    bool updateFlow_boxFilter(
+        const UMat& R0, const UMat& R1, UMat& flowx, UMat &flowy,
+        UMat& M, UMat &bufM, int blockSize, bool updateMatrices)
+    {
+        if (!boxFilter5Ocl(M, blockSize/2, bufM))
+            return false;
+        swap(M, bufM);
+        if (!updateFlowOcl(M, flowx, flowy))
+            return false;
+        if (updateMatrices)
+            if (!updateMatricesOcl(flowx, flowy, R0, R1, M))
+                return false;
+        return true;
+    }
+    bool updateFlow_gaussianBlur(
+        const UMat& R0, const UMat& R1, UMat& flowx, UMat& flowy,
+        UMat& M, UMat &bufM, int blockSize, bool updateMatrices)
+    {
+        if (!gaussianBlur5Ocl(M, blockSize/2, bufM))
+            return false;
+        swap(M, bufM);
+        if (!updateFlowOcl(M, flowx, flowy))
+            return false;
+        if (updateMatrices)
+            if (!updateMatricesOcl(flowx, flowy, R0, R1, M))
+                return false;
+        return true;
+    }
+    bool calc_ocl( InputArray _prev0, InputArray _next0,
+                   InputOutputArray _flow0)
+    {
+        if ((5 != polyN_) && (7 != polyN_))
+            return false;
+        if (_next0.size() != _prev0.size())
+            return false;
+        int typePrev = _prev0.type();
+        int typeNext = _next0.type();
+        if ((1 != CV_MAT_CN(typePrev)) || (1 != CV_MAT_CN(typeNext)))
+            return false;
+
+        std::vector<UMat> flowar;
+
+        // If flag is set, check for integrity; if not set, allocate memory space
+        if (flags_ & OPTFLOW_USE_INITIAL_FLOW)
+        {
+            if (_flow0.empty() || _flow0.size() != _prev0.size() || _flow0.channels() != 2 ||
+                _flow0.depth() != CV_32F)
+                return false;
+            split(_flow0, flowar);
+        }
+        else
+        {
+            flowar.push_back(UMat(_prev0.size(), CV_32FC1));
+            flowar.push_back(UMat(_prev0.size(), CV_32FC1));
+        }
+        if(!this->operator()(_prev0.getUMat(), _next0.getUMat(), flowar[0], flowar[1])){
+            return false;
+        }
+        merge(flowar, _flow0);
+        return true;
+    }
+#else // HAVE_OPENCL
+    virtual void collectGarbage() CV_OVERRIDE {}
+#endif
+};
+
+void FarnebackOpticalFlowImpl::calc(InputArray _prev0, InputArray _next0,
+                                    InputOutputArray _flow0)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_OCL_RUN(_flow0.isUMat() &&
+               ocl::Image2D::isFormatSupported(CV_32F, 1, false),
+               calc_ocl(_prev0,_next0,_flow0))
+    Mat prev0 = _prev0.getMat(), next0 = _next0.getMat();
+    const int min_size = 32;
+    const Mat* img[2] = { &prev0, &next0 };
+
+    int i, k;
+    double scale;
+    Mat prevFlow, flow, fimg;
+    int levels = numLevels_;
+
+    CV_Assert( prev0.size() == next0.size() && prev0.channels() == next0.channels() &&
+               prev0.channels() == 1 && pyrScale_ < 1 );
+
+    // If flag is set, check for integrity; if not set, allocate memory space
+    if( flags_ & OPTFLOW_USE_INITIAL_FLOW )
+        CV_Assert( _flow0.size() == prev0.size() && _flow0.channels() == 2 &&
+                   _flow0.depth() == CV_32F );
+    else
+        _flow0.create( prev0.size(), CV_32FC2 );
+
+    Mat flow0 = _flow0.getMat();
+
+    for( k = 0, scale = 1; k < levels; k++ )
+    {
+        scale *= pyrScale_;
+        if( prev0.cols*scale < min_size || prev0.rows*scale < min_size )
+            break;
+    }
+
+    levels = k;
+
+    for( k = levels; k >= 0; k-- )
+    {
+        for( i = 0, scale = 1; i < k; i++ )
+            scale *= pyrScale_;
+
+        double sigma = (1./scale-1)*0.5;
+        int smooth_sz = cvRound(sigma*5)|1;
+        smooth_sz = std::max(smooth_sz, 3);
+
+        int width = cvRound(prev0.cols*scale);
+        int height = cvRound(prev0.rows*scale);
+
+        if( k > 0 )
+            flow.create( height, width, CV_32FC2 );
+        else
+            flow = flow0;
+
+        if( prevFlow.empty() )
+        {
+            if( flags_ & OPTFLOW_USE_INITIAL_FLOW )
+            {
+                resize( flow0, flow, Size(width, height), 0, 0, INTER_AREA );
+                flow *= scale;
+            }
+            else
+                flow = Mat::zeros( height, width, CV_32FC2 );
+        }
+        else
+        {
+            resize( prevFlow, flow, Size(width, height), 0, 0, INTER_LINEAR );
+            flow *= 1./pyrScale_;
+        }
+
+        Mat R[2], I, M;
+        for( i = 0; i < 2; i++ )
+        {
+            img[i]->convertTo(fimg, CV_32F);
+            GaussianBlur(fimg, fimg, Size(smooth_sz, smooth_sz), sigma, sigma);
+            resize( fimg, I, Size(width, height), INTER_LINEAR );
+            FarnebackPolyExp( I, R[i], polyN_, polySigma_ );
+        }
+
+        FarnebackUpdateMatrices( R[0], R[1], flow, M, 0, flow.rows );
+
+        for( i = 0; i < numIters_; i++ )
+        {
+            if( flags_ & OPTFLOW_FARNEBACK_GAUSSIAN )
+                FarnebackUpdateFlow_GaussianBlur( R[0], R[1], flow, M, winSize_, i < numIters_ - 1 );
+            else
+                FarnebackUpdateFlow_Blur( R[0], R[1], flow, M, winSize_, i < numIters_ - 1 );
+        }
+
+        prevFlow = flow;
+    }
+}
+} // namespace
+} // namespace cv
+
+void cv::calcOpticalFlowFarneback( InputArray _prev0, InputArray _next0,
+                               InputOutputArray _flow0, double pyr_scale, int levels, int winsize,
+                               int iterations, int poly_n, double poly_sigma, int flags )
+{
+    CV_INSTRUMENT_REGION();
+
+    Ptr<cv::FarnebackOpticalFlow> optflow;
+    optflow = makePtr<FarnebackOpticalFlowImpl>(levels,pyr_scale,false,winsize,iterations,poly_n,poly_sigma,flags);
+    optflow->calc(_prev0,_next0,_flow0);
+}
+
+
+cv::Ptr<cv::FarnebackOpticalFlow> cv::FarnebackOpticalFlow::create(int numLevels, double pyrScale, bool fastPyramids, int winSize,
+                                                               int numIters, int polyN, double polySigma, int flags)
+{
+    return makePtr<FarnebackOpticalFlowImpl>(numLevels, pyrScale, fastPyramids, winSize,
+                                             numIters, polyN, polySigma, flags);
+}
diff --git a/upstream/opencv/modules/video/src/optical_flow_io.cpp b/upstream/opencv/modules/video/src/optical_flow_io.cpp
new file mode 100644
index 0000000..ff34f25
--- /dev/null
+++ b/upstream/opencv/modules/video/src/optical_flow_io.cpp
@@ -0,0 +1,129 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+#include "precomp.hpp"
+#include<iostream>
+#include<fstream>
+
+namespace cv {
+
+const float FLOW_TAG_FLOAT = 202021.25f;
+const char *FLOW_TAG_STRING = "PIEH";
+CV_EXPORTS_W Mat readOpticalFlow( const String& path )
+{
+    Mat_<Point2f> flow;
+    std::ifstream file(path.c_str(), std::ios_base::binary);
+    if ( !file.good() )
+        return Mat(); // no file - return empty matrix
+
+    float tag;
+    file.read((char*) &tag, sizeof(float));
+    if ( tag != FLOW_TAG_FLOAT )
+        return Mat();
+
+    int width, height;
+
+    file.read((char*) &width, 4);
+    file.read((char*) &height, 4);
+
+    flow.create(height, width);
+
+    for ( int i = 0; i < flow.rows; ++i )
+    {
+        for ( int j = 0; j < flow.cols; ++j )
+        {
+            Point2f u;
+            file.read((char*) &u.x, sizeof(float));
+            file.read((char*) &u.y, sizeof(float));
+            if ( !file.good() )
+            {
+                flow.release();
+                return Mat();
+            }
+
+            flow(i, j) = u;
+        }
+    }
+    file.close();
+    return Mat(flow);
+}
+
+CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow )
+{
+    const int nChannels = 2;
+
+    Mat input = flow.getMat();
+    if ( input.channels() != nChannels || input.depth() != CV_32F || path.length() == 0 )
+        return false;
+
+    std::ofstream file(path.c_str(), std::ofstream::binary);
+    if ( !file.good() )
+        return false;
+
+    int nRows, nCols;
+
+    nRows = (int) input.size().height;
+    nCols = (int) input.size().width;
+
+    const int headerSize = 12;
+    char header[headerSize];
+    memcpy(header, FLOW_TAG_STRING, 4);
+    // size of ints is known - has been asserted in the current function
+    memcpy(header + 4, reinterpret_cast<const char*>(&nCols), sizeof(nCols));
+    memcpy(header + 8, reinterpret_cast<const char*>(&nRows), sizeof(nRows));
+    file.write(header, headerSize);
+    if ( !file.good() )
+        return false;
+
+    int row;
+    char* p;
+    for ( row = 0; row < nRows; row++ )
+    {
+        p = input.ptr<char>(row);
+        file.write(p, nCols * nChannels * sizeof(float));
+        if ( !file.good() )
+            return false;
+    }
+    file.close();
+    return true;
+}
+
+}
diff --git a/upstream/opencv/modules/video/src/precomp.hpp b/upstream/opencv/modules/video/src/precomp.hpp
new file mode 100644
index 0000000..27cd0ad
--- /dev/null
+++ b/upstream/opencv/modules/video/src/precomp.hpp
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/video.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/ocl.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/geometry.hpp"
+
+#endif
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp
new file mode 100644
index 0000000..b68994d
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature.cpp
@@ -0,0 +1,25 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerFeature::~TrackerFeature()
+{
+    // nothing
+}
+
+void TrackerFeature::compute(const std::vector<Mat>& images, Mat& response)
+{
+    if (images.empty())
+        return;
+
+    computeImpl(images, response);
+}
+
+}}}  // namespace cv::detail::tracking
\ No newline at end of file
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_haar.impl.hpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_haar.impl.hpp
new file mode 100644
index 0000000..30a3eb3
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_haar.impl.hpp
@@ -0,0 +1,121 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+#include "tracking_feature.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+inline namespace internal {
+
+class TrackerFeatureHAAR : public TrackerFeature
+{
+public:
+    struct Params
+    {
+        Params();
+        int numFeatures;  //!< # of rects
+        Size rectSize;  //!< rect size
+        bool isIntegral;  //!< true if input images are integral, false otherwise
+    };
+
+    TrackerFeatureHAAR(const TrackerFeatureHAAR::Params& parameters = TrackerFeatureHAAR::Params());
+
+    virtual ~TrackerFeatureHAAR() CV_OVERRIDE {}
+
+protected:
+    bool computeImpl(const std::vector<Mat>& images, Mat& response) CV_OVERRIDE;
+
+private:
+    Params params;
+    Ptr<CvHaarEvaluator> featureEvaluator;
+};
+
+/**
+ * Parameters
+ */
+
+TrackerFeatureHAAR::Params::Params()
+{
+    numFeatures = 250;
+    rectSize = Size(100, 100);
+    isIntegral = false;
+}
+
+TrackerFeatureHAAR::TrackerFeatureHAAR(const TrackerFeatureHAAR::Params& parameters)
+    : params(parameters)
+{
+    CvHaarFeatureParams haarParams;
+    haarParams.numFeatures = params.numFeatures;
+    haarParams.isIntegral = params.isIntegral;
+    featureEvaluator = makePtr<CvHaarEvaluator>();
+    featureEvaluator->init(&haarParams, 1, params.rectSize);
+}
+
+class Parallel_compute : public cv::ParallelLoopBody
+{
+private:
+    Ptr<CvHaarEvaluator> featureEvaluator;
+    std::vector<Mat> images;
+    Mat response;
+    //std::vector<CvHaarEvaluator::FeatureHaar> features;
+public:
+    Parallel_compute(Ptr<CvHaarEvaluator>& fe, const std::vector<Mat>& img, Mat& resp)
+        : featureEvaluator(fe)
+        , images(img)
+        , response(resp)
+    {
+
+        //features = featureEvaluator->getFeatures();
+    }
+
+    virtual void operator()(const cv::Range& r) const CV_OVERRIDE
+    {
+        for (int jf = r.start; jf != r.end; ++jf)
+        {
+            int cols = images[jf].cols;
+            int rows = images[jf].rows;
+            for (int j = 0; j < featureEvaluator->getNumFeatures(); j++)
+            {
+                float res = 0;
+                featureEvaluator->getFeatures()[j].eval(images[jf], Rect(0, 0, cols, rows), &res);
+                (Mat_<float>(response))(j, jf) = res;
+            }
+        }
+    }
+};
+
+bool TrackerFeatureHAAR::computeImpl(const std::vector<Mat>& images, Mat& response)
+{
+    if (images.empty())
+    {
+        return false;
+    }
+
+    int numFeatures = featureEvaluator->getNumFeatures();
+
+    response = Mat_<float>(Size((int)images.size(), numFeatures));
+
+    std::vector<CvHaarEvaluator::FeatureHaar> f = featureEvaluator->getFeatures();
+    //for each sample compute #n_feature -> put each feature (n Rect) in response
+    parallel_for_(Range(0, (int)images.size()), Parallel_compute(featureEvaluator, images, response));
+
+    /*for ( size_t i = 0; i < images.size(); i++ )
+  {
+    int c = images[i].cols;
+    int r = images[i].rows;
+    for ( int j = 0; j < numFeatures; j++ )
+    {
+      float res = 0;
+      featureEvaluator->getFeatures( j ).eval( images[i], Rect( 0, 0, c, r ), &res );
+      ( Mat_<float>( response ) )( j, i ) = res;
+    }
+  }*/
+
+    return true;
+}
+
+}}}}  // namespace cv::detail::tracking::internal
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp
new file mode 100644
index 0000000..96eb998
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_feature_set.cpp
@@ -0,0 +1,60 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerFeatureSet::TrackerFeatureSet()
+{
+    blockAddTrackerFeature = false;
+}
+
+TrackerFeatureSet::~TrackerFeatureSet()
+{
+    // nothing
+}
+
+void TrackerFeatureSet::extraction(const std::vector<Mat>& images)
+{
+    blockAddTrackerFeature = true;
+
+    clearResponses();
+    responses.resize(features.size());
+
+    for (size_t i = 0; i < features.size(); i++)
+    {
+        CV_DbgAssert(features[i]);
+        features[i]->compute(images, responses[i]);
+    }
+}
+
+bool TrackerFeatureSet::addTrackerFeature(const Ptr<TrackerFeature>& feature)
+{
+    CV_Assert(!blockAddTrackerFeature);
+    CV_Assert(feature);
+
+    features.push_back(feature);
+    return true;
+}
+
+const std::vector<Ptr<TrackerFeature>>& TrackerFeatureSet::getTrackerFeatures() const
+{
+    return features;
+}
+
+const std::vector<Mat>& TrackerFeatureSet::getResponses() const
+{
+    return responses;
+}
+
+void TrackerFeatureSet::clearResponses()
+{
+    responses.clear();
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp
new file mode 100644
index 0000000..cff826d
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.cpp
@@ -0,0 +1,85 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "tracker_mil_model.hpp"
+
+/**
+ * TrackerMILModel
+ */
+
+namespace cv {
+inline namespace tracking {
+namespace impl {
+
+TrackerMILModel::TrackerMILModel(const Rect& boundingBox)
+{
+    currentSample.clear();
+    mode = MODE_POSITIVE;
+    width = boundingBox.width;
+    height = boundingBox.height;
+
+    Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState> initState = Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState>(
+            new TrackerStateEstimatorMILBoosting::TrackerMILTargetState(Point2f((float)boundingBox.x, (float)boundingBox.y), boundingBox.width, boundingBox.height,
+                    true, Mat()));
+    trajectory.push_back(initState);
+}
+
+void TrackerMILModel::responseToConfidenceMap(const std::vector<Mat>& responses, ConfidenceMap& confidenceMap)
+{
+    if (currentSample.empty())
+    {
+        CV_Error(cv::Error::StsError, "The samples in Model estimation are empty");
+    }
+
+    for (size_t i = 0; i < responses.size(); i++)
+    {
+        //for each column (one sample) there are #num_feature
+        //get informations from currentSample
+        for (int j = 0; j < responses.at(i).cols; j++)
+        {
+
+            Size currentSize;
+            Point currentOfs;
+            currentSample.at(j).locateROI(currentSize, currentOfs);
+            bool foreground = false;
+            if (mode == MODE_POSITIVE || mode == MODE_ESTIMATON)
+            {
+                foreground = true;
+            }
+            else if (mode == MODE_NEGATIVE)
+            {
+                foreground = false;
+            }
+
+            //get the column of the HAAR responses
+            Mat singleResponse = responses.at(i).col(j);
+
+            //create the state
+            Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState> currentState = Ptr<TrackerStateEstimatorMILBoosting::TrackerMILTargetState>(
+                    new TrackerStateEstimatorMILBoosting::TrackerMILTargetState(currentOfs, width, height, foreground, singleResponse));
+
+            confidenceMap.push_back(std::make_pair(currentState, 0.0f));
+        }
+    }
+}
+
+void TrackerMILModel::modelEstimationImpl(const std::vector<Mat>& responses)
+{
+    responseToConfidenceMap(responses, currentConfidenceMap);
+}
+
+void TrackerMILModel::modelUpdateImpl()
+{
+}
+
+void TrackerMILModel::setMode(int trainingMode, const std::vector<Mat>& samples)
+{
+    currentSample.clear();
+    currentSample = samples;
+
+    mode = trainingMode;
+}
+
+}}}  // namespace cv::tracking::impl
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.hpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.hpp
new file mode 100644
index 0000000..027ddd0
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_model.hpp
@@ -0,0 +1,67 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef __OPENCV_TRACKER_MIL_MODEL_HPP__
+#define __OPENCV_TRACKER_MIL_MODEL_HPP__
+
+#include "opencv2/video/detail/tracking.detail.hpp"
+#include "tracker_mil_state.hpp"
+
+namespace cv {
+inline namespace tracking {
+namespace impl {
+
+using namespace cv::detail::tracking;
+
+/**
+ * \brief Implementation of TrackerModel for MIL algorithm
+ */
+class TrackerMILModel : public detail::TrackerModel
+{
+public:
+    enum
+    {
+        MODE_POSITIVE = 1,  // mode for positive features
+        MODE_NEGATIVE = 2,  // mode for negative features
+        MODE_ESTIMATON = 3  // mode for estimation step
+    };
+
+    /**
+   * \brief Constructor
+   * \param boundingBox The first boundingBox
+   */
+    TrackerMILModel(const Rect& boundingBox);
+
+    /**
+   * \brief Destructor
+   */
+    ~TrackerMILModel() {}
+
+    /**
+   * \brief Set the mode
+   */
+    void setMode(int trainingMode, const std::vector<Mat>& samples);
+
+    /**
+   * \brief Create the ConfidenceMap from a list of responses
+   * \param responses The list of the responses
+   * \param confidenceMap The output
+   */
+    void responseToConfidenceMap(const std::vector<Mat>& responses, ConfidenceMap& confidenceMap);
+
+protected:
+    void modelEstimationImpl(const std::vector<Mat>& responses) CV_OVERRIDE;
+    void modelUpdateImpl() CV_OVERRIDE;
+
+private:
+    int mode;
+    std::vector<Mat> currentSample;
+
+    int width;  //initial width of the boundingBox
+    int height;  //initial height of the boundingBox
+};
+
+}}}  // namespace cv::tracking::impl
+
+#endif
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp
new file mode 100644
index 0000000..b3de09c
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.cpp
@@ -0,0 +1,159 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+#include "tracker_mil_state.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+/**
+ * TrackerStateEstimatorMILBoosting::TrackerMILTargetState
+ */
+TrackerStateEstimatorMILBoosting::TrackerMILTargetState::TrackerMILTargetState(const Point2f& position, int width, int height, bool foreground,
+        const Mat& features)
+{
+    setTargetPosition(position);
+    setTargetWidth(width);
+    setTargetHeight(height);
+    setTargetFg(foreground);
+    setFeatures(features);
+}
+
+void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setTargetFg(bool foreground)
+{
+    isTarget = foreground;
+}
+
+void TrackerStateEstimatorMILBoosting::TrackerMILTargetState::setFeatures(const Mat& features)
+{
+    targetFeatures = features;
+}
+
+bool TrackerStateEstimatorMILBoosting::TrackerMILTargetState::isTargetFg() const
+{
+    return isTarget;
+}
+
+Mat TrackerStateEstimatorMILBoosting::TrackerMILTargetState::getFeatures() const
+{
+    return targetFeatures;
+}
+
+TrackerStateEstimatorMILBoosting::TrackerStateEstimatorMILBoosting(int nFeatures)
+{
+    className = "BOOSTING";
+    trained = false;
+    numFeatures = nFeatures;
+}
+
+TrackerStateEstimatorMILBoosting::~TrackerStateEstimatorMILBoosting()
+{
+}
+
+void TrackerStateEstimatorMILBoosting::setCurrentConfidenceMap(ConfidenceMap& confidenceMap)
+{
+    currentConfidenceMap.clear();
+    currentConfidenceMap = confidenceMap;
+}
+
+uint TrackerStateEstimatorMILBoosting::max_idx(const std::vector<float>& v)
+{
+    const float* findPtr = &(*std::max_element(v.begin(), v.end()));
+    const float* beginPtr = &(*v.begin());
+    return (uint)(findPtr - beginPtr);
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimatorMILBoosting::estimateImpl(const std::vector<ConfidenceMap>& /*confidenceMaps*/)
+{
+    //run ClfMilBoost classify in order to compute next location
+    if (currentConfidenceMap.empty())
+        return Ptr<TrackerTargetState>();
+
+    Mat positiveStates;
+    Mat negativeStates;
+
+    prepareData(currentConfidenceMap, positiveStates, negativeStates);
+
+    std::vector<float> prob = boostMILModel.classify(positiveStates);
+
+    int bestind = max_idx(prob);
+    //float resp = prob[bestind];
+
+    return currentConfidenceMap.at(bestind).first;
+}
+
+void TrackerStateEstimatorMILBoosting::prepareData(const ConfidenceMap& confidenceMap, Mat& positive, Mat& negative)
+{
+
+    int posCounter = 0;
+    int negCounter = 0;
+
+    for (size_t i = 0; i < confidenceMap.size(); i++)
+    {
+        Ptr<TrackerMILTargetState> currentTargetState = confidenceMap.at(i).first.staticCast<TrackerMILTargetState>();
+        CV_DbgAssert(currentTargetState);
+        if (currentTargetState->isTargetFg())
+            posCounter++;
+        else
+            negCounter++;
+    }
+
+    positive.create(posCounter, numFeatures, CV_32FC1);
+    negative.create(negCounter, numFeatures, CV_32FC1);
+
+    //TODO change with mat fast access
+    //initialize trainData (positive and negative)
+
+    int pc = 0;
+    int nc = 0;
+    for (size_t i = 0; i < confidenceMap.size(); i++)
+    {
+        Ptr<TrackerMILTargetState> currentTargetState = confidenceMap.at(i).first.staticCast<TrackerMILTargetState>();
+        Mat stateFeatures = currentTargetState->getFeatures();
+
+        if (currentTargetState->isTargetFg())
+        {
+            for (int j = 0; j < stateFeatures.rows; j++)
+            {
+                //fill the positive trainData with the value of the feature j for sample i
+                positive.at<float>(pc, j) = stateFeatures.at<float>(j, 0);
+            }
+            pc++;
+        }
+        else
+        {
+            for (int j = 0; j < stateFeatures.rows; j++)
+            {
+                //fill the negative trainData with the value of the feature j for sample i
+                negative.at<float>(nc, j) = stateFeatures.at<float>(j, 0);
+            }
+            nc++;
+        }
+    }
+}
+
+void TrackerStateEstimatorMILBoosting::updateImpl(std::vector<ConfidenceMap>& confidenceMaps)
+{
+
+    if (!trained)
+    {
+        //this is the first time that the classifier is built
+        //init MIL
+        boostMILModel.init();
+        trained = true;
+    }
+
+    ConfidenceMap lastConfidenceMap = confidenceMaps.back();
+    Mat positiveStates;
+    Mat negativeStates;
+
+    prepareData(lastConfidenceMap, positiveStates, negativeStates);
+    //update MIL
+    boostMILModel.update(positiveStates, negativeStates);
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.hpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.hpp
new file mode 100644
index 0000000..f4eeee9
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_mil_state.hpp
@@ -0,0 +1,87 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_DETAIL_TRACKING_MIL_STATE_HPP
+#define OPENCV_VIDEO_DETAIL_TRACKING_MIL_STATE_HPP
+
+#include "opencv2/video/detail/tracking.detail.hpp"
+#include "tracking_online_mil.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+/** @brief TrackerStateEstimator based on Boosting
+*/
+class CV_EXPORTS TrackerStateEstimatorMILBoosting : public TrackerStateEstimator
+{
+public:
+    /**
+    * Implementation of the target state for TrackerStateEstimatorMILBoosting
+    */
+    class TrackerMILTargetState : public TrackerTargetState
+    {
+
+    public:
+        /**
+        * \brief Constructor
+        * \param position Top left corner of the bounding box
+        * \param width Width of the bounding box
+        * \param height Height of the bounding box
+        * \param foreground label for target or background
+        * \param features features extracted
+        */
+        TrackerMILTargetState(const Point2f& position, int width, int height, bool foreground, const Mat& features);
+
+        ~TrackerMILTargetState() {}
+
+        /** @brief Set label: true for target foreground, false for background
+        @param foreground Label for background/foreground
+        */
+        void setTargetFg(bool foreground);
+        /** @brief Set the features extracted from TrackerFeatureSet
+        @param features The features extracted
+        */
+        void setFeatures(const Mat& features);
+        /** @brief Get the label. Return true for target foreground, false for background
+        */
+        bool isTargetFg() const;
+        /** @brief Get the features extracted
+        */
+        Mat getFeatures() const;
+
+    private:
+        bool isTarget;
+        Mat targetFeatures;
+    };
+
+    /** @brief Constructor
+    @param nFeatures Number of features for each sample
+    */
+    TrackerStateEstimatorMILBoosting(int nFeatures = 250);
+    ~TrackerStateEstimatorMILBoosting();
+
+    /** @brief Set the current confidenceMap
+    @param confidenceMap The current :cConfidenceMap
+    */
+    void setCurrentConfidenceMap(ConfidenceMap& confidenceMap);
+
+protected:
+    Ptr<TrackerTargetState> estimateImpl(const std::vector<ConfidenceMap>& confidenceMaps) CV_OVERRIDE;
+    void updateImpl(std::vector<ConfidenceMap>& confidenceMaps) CV_OVERRIDE;
+
+private:
+    uint max_idx(const std::vector<float>& v);
+    void prepareData(const ConfidenceMap& confidenceMap, Mat& positive, Mat& negative);
+
+    ClfMilBoost boostMILModel;
+    bool trained;
+    int numFeatures;
+
+    ConfidenceMap currentConfidenceMap;
+};
+
+}}}  // namespace cv::detail::tracking
+
+#endif
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp
new file mode 100644
index 0000000..a8d3a99
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_model.cpp
@@ -0,0 +1,132 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerModel::TrackerModel()
+{
+    stateEstimator = Ptr<TrackerStateEstimator>();
+    maxCMLength = 10;
+}
+
+TrackerModel::~TrackerModel()
+{
+    // nothing
+}
+
+bool TrackerModel::setTrackerStateEstimator(Ptr<TrackerStateEstimator> trackerStateEstimator)
+{
+    if (stateEstimator.get())
+    {
+        return false;
+    }
+
+    stateEstimator = trackerStateEstimator;
+    return true;
+}
+
+Ptr<TrackerStateEstimator> TrackerModel::getTrackerStateEstimator() const
+{
+    return stateEstimator;
+}
+
+void TrackerModel::modelEstimation(const std::vector<Mat>& responses)
+{
+    modelEstimationImpl(responses);
+}
+
+void TrackerModel::clearCurrentConfidenceMap()
+{
+    currentConfidenceMap.clear();
+}
+
+void TrackerModel::modelUpdate()
+{
+    modelUpdateImpl();
+
+    if (maxCMLength != -1 && (int)confidenceMaps.size() >= maxCMLength - 1)
+    {
+        int l = maxCMLength / 2;
+        confidenceMaps.erase(confidenceMaps.begin(), confidenceMaps.begin() + l);
+    }
+    if (maxCMLength != -1 && (int)trajectory.size() >= maxCMLength - 1)
+    {
+        int l = maxCMLength / 2;
+        trajectory.erase(trajectory.begin(), trajectory.begin() + l);
+    }
+    confidenceMaps.push_back(currentConfidenceMap);
+    stateEstimator->update(confidenceMaps);
+
+    clearCurrentConfidenceMap();
+}
+
+bool TrackerModel::runStateEstimator()
+{
+    if (!stateEstimator)
+    {
+        CV_Error(cv::Error::StsError, "Tracker state estimator is not setted");
+    }
+    Ptr<TrackerTargetState> targetState = stateEstimator->estimate(confidenceMaps);
+    if (!targetState)
+        return false;
+
+    setLastTargetState(targetState);
+    return true;
+}
+
+void TrackerModel::setLastTargetState(const Ptr<TrackerTargetState>& lastTargetState)
+{
+    trajectory.push_back(lastTargetState);
+}
+
+Ptr<TrackerTargetState> TrackerModel::getLastTargetState() const
+{
+    return trajectory.back();
+}
+
+const std::vector<ConfidenceMap>& TrackerModel::getConfidenceMaps() const
+{
+    return confidenceMaps;
+}
+
+const ConfidenceMap& TrackerModel::getLastConfidenceMap() const
+{
+    return confidenceMaps.back();
+}
+
+Point2f TrackerTargetState::getTargetPosition() const
+{
+    return targetPosition;
+}
+
+void TrackerTargetState::setTargetPosition(const Point2f& position)
+{
+    targetPosition = position;
+}
+
+int TrackerTargetState::getTargetWidth() const
+{
+    return targetWidth;
+}
+
+void TrackerTargetState::setTargetWidth(int width)
+{
+    targetWidth = width;
+}
+int TrackerTargetState::getTargetHeight() const
+{
+    return targetHeight;
+}
+
+void TrackerTargetState::setTargetHeight(int height)
+{
+    targetHeight = height;
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp
new file mode 100644
index 0000000..4e73ea3
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler.cpp
@@ -0,0 +1,68 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerSampler::TrackerSampler()
+{
+    blockAddTrackerSampler = false;
+}
+
+TrackerSampler::~TrackerSampler()
+{
+    // nothing
+}
+
+void TrackerSampler::sampling(const Mat& image, Rect boundingBox)
+{
+    clearSamples();
+
+    for (size_t i = 0; i < samplers.size(); i++)
+    {
+        CV_DbgAssert(samplers[i]);
+        std::vector<Mat> current_samples;
+        samplers[i]->sampling(image, boundingBox, current_samples);
+
+        //push in samples all current_samples
+        for (size_t j = 0; j < current_samples.size(); j++)
+        {
+            std::vector<Mat>::iterator it = samples.end();
+            samples.insert(it, current_samples.at(j));
+        }
+    }
+
+    blockAddTrackerSampler = true;
+}
+
+bool TrackerSampler::addTrackerSamplerAlgorithm(const Ptr<TrackerSamplerAlgorithm>& sampler)
+{
+    CV_Assert(!blockAddTrackerSampler);
+    CV_Assert(sampler);
+
+    samplers.push_back(sampler);
+    return true;
+}
+
+const std::vector<Ptr<TrackerSamplerAlgorithm>>& TrackerSampler::getSamplers() const
+{
+    return samplers;
+}
+
+const std::vector<Mat>& TrackerSampler::getSamples() const
+{
+    return samples;
+}
+
+void TrackerSampler::clearSamples()
+{
+    samples.clear();
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp
new file mode 100644
index 0000000..ba5ae41
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_sampler_algorithm.cpp
@@ -0,0 +1,124 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerSamplerAlgorithm::~TrackerSamplerAlgorithm()
+{
+    // nothing
+}
+
+TrackerSamplerCSC::Params::Params()
+{
+    initInRad = 3;
+    initMaxNegNum = 65;
+    searchWinSize = 25;
+    trackInPosRad = 4;
+    trackMaxNegNum = 65;
+    trackMaxPosNum = 100000;
+}
+
+TrackerSamplerCSC::TrackerSamplerCSC(const TrackerSamplerCSC::Params& parameters)
+    : params(parameters)
+{
+    mode = MODE_INIT_POS;
+    rng = theRNG();
+}
+
+TrackerSamplerCSC::~TrackerSamplerCSC()
+{
+    // nothing
+}
+
+bool TrackerSamplerCSC::sampling(const Mat& image, const Rect& boundingBox, std::vector<Mat>& sample)
+{
+    CV_Assert(!image.empty());
+
+    float inrad = 0;
+    float outrad = 0;
+    int maxnum = 0;
+
+    switch (mode)
+    {
+    case MODE_INIT_POS:
+        inrad = params.initInRad;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad);
+        break;
+    case MODE_INIT_NEG:
+        inrad = 2.0f * params.searchWinSize;
+        outrad = 1.5f * params.initInRad;
+        maxnum = params.initMaxNegNum;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum);
+        break;
+    case MODE_TRACK_POS:
+        inrad = params.trackInPosRad;
+        outrad = 0;
+        maxnum = params.trackMaxPosNum;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum);
+        break;
+    case MODE_TRACK_NEG:
+        inrad = 1.5f * params.searchWinSize;
+        outrad = params.trackInPosRad + 5;
+        maxnum = params.trackMaxNegNum;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad, outrad, maxnum);
+        break;
+    case MODE_DETECT:
+        inrad = params.searchWinSize;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad);
+        break;
+    default:
+        inrad = params.initInRad;
+        sample = sampleImage(image, boundingBox.x, boundingBox.y, boundingBox.width, boundingBox.height, inrad);
+        break;
+    }
+    return false;
+}
+
+void TrackerSamplerCSC::setMode(int samplingMode)
+{
+    mode = samplingMode;
+}
+
+std::vector<Mat> TrackerSamplerCSC::sampleImage(const Mat& img, int x, int y, int w, int h, float inrad, float outrad, int maxnum)
+{
+    int rowsz = img.rows - h - 1;
+    int colsz = img.cols - w - 1;
+    float inradsq = inrad * inrad;
+    float outradsq = outrad * outrad;
+    int dist;
+
+    uint minrow = max(0, (int)y - (int)inrad);
+    uint maxrow = min((int)rowsz - 1, (int)y + (int)inrad);
+    uint mincol = max(0, (int)x - (int)inrad);
+    uint maxcol = min((int)colsz - 1, (int)x + (int)inrad);
+
+    //fprintf(stderr,"inrad=%f minrow=%d maxrow=%d mincol=%d maxcol=%d\n",inrad,minrow,maxrow,mincol,maxcol);
+
+    std::vector<Mat> samples;
+    samples.resize((maxrow - minrow + 1) * (maxcol - mincol + 1));
+    int i = 0;
+
+    float prob = ((float)(maxnum)) / samples.size();
+
+    for (int r = minrow; r <= int(maxrow); r++)
+        for (int c = mincol; c <= int(maxcol); c++)
+        {
+            dist = (y - r) * (y - r) + (x - c) * (x - c);
+            if (float(rng.uniform(0.f, 1.f)) < prob && dist < inradsq && dist >= outradsq)
+            {
+                samples[i] = img(Rect(c, r, w, h));
+                i++;
+            }
+        }
+
+    samples.resize(min(i, maxnum));
+    return samples;
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp
new file mode 100644
index 0000000..ea48a73
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracker_state_estimator.cpp
@@ -0,0 +1,37 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+TrackerStateEstimator::~TrackerStateEstimator()
+{
+}
+
+Ptr<TrackerTargetState> TrackerStateEstimator::estimate(const std::vector<ConfidenceMap>& confidenceMaps)
+{
+    if (confidenceMaps.empty())
+        return Ptr<TrackerTargetState>();
+
+    return estimateImpl(confidenceMaps);
+}
+
+void TrackerStateEstimator::update(std::vector<ConfidenceMap>& confidenceMaps)
+{
+    if (confidenceMaps.empty())
+        return;
+
+    return updateImpl(confidenceMaps);
+}
+
+String TrackerStateEstimator::getClassName() const
+{
+    return className;
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp
new file mode 100644
index 0000000..0d9a88c
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.cpp
@@ -0,0 +1,582 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "opencv2/video/detail/tracking.detail.hpp"
+#include "tracking_feature.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+/*
+ * TODO This implementation is based on apps/traincascade/
+ * TODO Changed CvHaarEvaluator based on ADABOOSTING implementation (Grabner et al.)
+ */
+
+CvParams::CvParams()
+{
+    // nothing
+}
+
+//---------------------------- FeatureParams --------------------------------------
+
+CvFeatureParams::CvFeatureParams()
+    : maxCatCount(0)
+    , featSize(1)
+    , numFeatures(1)
+{
+    // nothing
+}
+
+//------------------------------------- FeatureEvaluator ---------------------------------------
+
+void CvFeatureEvaluator::init(const CvFeatureParams* _featureParams, int _maxSampleCount, Size _winSize)
+{
+    CV_Assert(_featureParams);
+    CV_Assert(_maxSampleCount > 0);
+    featureParams = (CvFeatureParams*)_featureParams;
+    winSize = _winSize;
+    numFeatures = _featureParams->numFeatures;
+    cls.create((int)_maxSampleCount, 1, CV_32FC1);
+    generateFeatures();
+}
+
+void CvFeatureEvaluator::setImage(const Mat& img, uchar clsLabel, int idx)
+{
+    winSize.width = img.cols;
+    winSize.height = img.rows;
+    //CV_Assert( img.cols == winSize.width );
+    //CV_Assert( img.rows == winSize.height );
+    CV_Assert(idx < cls.rows);
+    cls.ptr<float>(idx)[0] = clsLabel;
+}
+
+CvHaarFeatureParams::CvHaarFeatureParams()
+{
+    isIntegral = false;
+}
+
+//--------------------- HaarFeatureEvaluator ----------------
+
+void CvHaarEvaluator::init(const CvFeatureParams* _featureParams, int /*_maxSampleCount*/, Size _winSize)
+{
+    CV_Assert(_featureParams);
+    int cols = (_winSize.width + 1) * (_winSize.height + 1);
+    sum.create((int)1, cols, CV_32SC1);
+    isIntegral = ((CvHaarFeatureParams*)_featureParams)->isIntegral;
+    CvFeatureEvaluator::init(_featureParams, 1, _winSize);
+}
+
+void CvHaarEvaluator::setImage(const Mat& img, uchar /*clsLabel*/, int /*idx*/)
+{
+    CV_DbgAssert(!sum.empty());
+
+    winSize.width = img.cols;
+    winSize.height = img.rows;
+
+    CvFeatureEvaluator::setImage(img, 1, 0);
+    if (!isIntegral)
+    {
+        std::vector<Mat_<float>> ii_imgs;
+        compute_integral(img, ii_imgs);
+        _ii_img = ii_imgs[0];
+    }
+    else
+    {
+        _ii_img = img;
+    }
+}
+
+void CvHaarEvaluator::generateFeatures()
+{
+    generateFeatures(featureParams->numFeatures);
+}
+
+void CvHaarEvaluator::generateFeatures(int nFeatures)
+{
+    for (int i = 0; i < nFeatures; i++)
+    {
+        CvHaarEvaluator::FeatureHaar feature(Size(winSize.width, winSize.height));
+        features.push_back(feature);
+    }
+}
+
+#define INITSIGMA(numAreas) (static_cast<float>(sqrt(256.0f * 256.0f / 12.0f * (numAreas))));
+
+CvHaarEvaluator::FeatureHaar::FeatureHaar(Size patchSize)
+{
+    try
+    {
+        generateRandomFeature(patchSize);
+    }
+    catch (...)
+    {
+        // FIXIT
+        throw;
+    }
+}
+
+void CvHaarEvaluator::FeatureHaar::generateRandomFeature(Size patchSize)
+{
+    cv::Point2i position;
+    Size baseDim;
+    Size sizeFactor;
+    int area;
+
+    CV_Assert(!patchSize.empty());
+
+    //Size minSize = Size( 3, 3 );
+    int minArea = 9;
+
+    bool valid = false;
+    while (!valid)
+    {
+        //choose position and scale
+        position.y = rand() % (patchSize.height);
+        position.x = rand() % (patchSize.width);
+
+        baseDim.width = (int)((1 - sqrt(1 - (float)rand() * (float)(1.0 / RAND_MAX))) * patchSize.width);
+        baseDim.height = (int)((1 - sqrt(1 - (float)rand() * (float)(1.0 / RAND_MAX))) * patchSize.height);
+
+        //select types
+        //float probType[11] = {0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0950f};
+        float probType[11] = { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+        float prob = (float)rand() * (float)(1.0 / RAND_MAX);
+
+        if (prob < probType[0])
+        {
+            //check if feature is valid
+            sizeFactor.height = 2;
+            sizeFactor.width = 1;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 1;
+            m_numAreas = 2;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1])
+        {
+            //check if feature is valid
+            sizeFactor.height = 1;
+            sizeFactor.width = 2;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 2;
+            m_numAreas = 2;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2])
+        {
+            //check if feature is valid
+            sizeFactor.height = 4;
+            sizeFactor.width = 1;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 3;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -2;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = 2 * baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y + 3 * baseDim.height;
+            m_areas[2].x = position.x;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3])
+        {
+            //check if feature is valid
+            sizeFactor.height = 1;
+            sizeFactor.width = 4;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 3;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -2;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = 2 * baseDim.width;
+            m_areas[2].y = position.y;
+            m_areas[2].x = position.x + 3 * baseDim.width;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4])
+        {
+            //check if feature is valid
+            sizeFactor.height = 2;
+            sizeFactor.width = 2;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 5;
+            m_numAreas = 4;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -1;
+            m_weights[2] = -1;
+            m_weights[3] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y + baseDim.height;
+            m_areas[2].x = position.x;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_areas[3].y = position.y + baseDim.height;
+            m_areas[3].x = position.x + baseDim.width;
+            m_areas[3].height = baseDim.height;
+            m_areas[3].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5])
+        {
+            //check if feature is valid
+            sizeFactor.height = 3;
+            sizeFactor.width = 3;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 6;
+            m_numAreas = 2;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -9;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = 3 * baseDim.height;
+            m_areas[0].width = 3 * baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_initMean = -8 * 128;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6])
+        {
+            //check if feature is valid
+            sizeFactor.height = 3;
+            sizeFactor.width = 1;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 7;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -2;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y + baseDim.height * 2;
+            m_areas[2].x = position.x;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7])
+        {
+            //check if feature is valid
+            sizeFactor.height = 1;
+            sizeFactor.width = 3;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+
+            if (area < minArea)
+                continue;
+
+            m_type = 8;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -2;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y;
+            m_areas[2].x = position.x + 2 * baseDim.width;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8])
+        {
+            //check if feature is valid
+            sizeFactor.height = 3;
+            sizeFactor.width = 3;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 9;
+            m_numAreas = 2;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -2;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = 3 * baseDim.height;
+            m_areas[0].width = 3 * baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_initMean = 0;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob
+                < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9])
+        {
+            //check if feature is valid
+            sizeFactor.height = 3;
+            sizeFactor.width = 1;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 10;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -1;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x;
+            m_areas[1].y = position.y + baseDim.height;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y + baseDim.height * 2;
+            m_areas[2].x = position.x;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 128;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else if (prob
+                < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9]
+                        + probType[10])
+        {
+            //check if feature is valid
+            sizeFactor.height = 1;
+            sizeFactor.width = 3;
+            if (position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width)
+                continue;
+            area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
+            if (area < minArea)
+                continue;
+
+            m_type = 11;
+            m_numAreas = 3;
+            m_weights.resize(m_numAreas);
+            m_weights[0] = 1;
+            m_weights[1] = -1;
+            m_weights[2] = 1;
+            m_areas.resize(m_numAreas);
+            m_areas[0].x = position.x;
+            m_areas[0].y = position.y;
+            m_areas[0].height = baseDim.height;
+            m_areas[0].width = baseDim.width;
+            m_areas[1].x = position.x + baseDim.width;
+            m_areas[1].y = position.y;
+            m_areas[1].height = baseDim.height;
+            m_areas[1].width = baseDim.width;
+            m_areas[2].y = position.y;
+            m_areas[2].x = position.x + 2 * baseDim.width;
+            m_areas[2].height = baseDim.height;
+            m_areas[2].width = baseDim.width;
+            m_initMean = 128;
+            m_initSigma = INITSIGMA(m_numAreas);
+            valid = true;
+        }
+        else
+            CV_Error(Error::StsAssert, "");
+    }
+
+    m_initSize = patchSize;
+    m_curSize = m_initSize;
+    m_scaleFactorWidth = m_scaleFactorHeight = 1.0f;
+    m_scaleAreas.resize(m_numAreas);
+    m_scaleWeights.resize(m_numAreas);
+    for (int curArea = 0; curArea < m_numAreas; curArea++)
+    {
+        m_scaleAreas[curArea] = m_areas[curArea];
+        m_scaleWeights[curArea] = (float)m_weights[curArea] / (float)(m_areas[curArea].width * m_areas[curArea].height);
+    }
+}
+
+bool CvHaarEvaluator::FeatureHaar::eval(const Mat& image, Rect /*ROI*/, float* result) const
+{
+
+    *result = 0.0f;
+
+    for (int curArea = 0; curArea < m_numAreas; curArea++)
+    {
+        *result += (float)getSum(image, Rect(m_areas[curArea].x, m_areas[curArea].y, m_areas[curArea].width, m_areas[curArea].height))
+                * m_scaleWeights[curArea];
+    }
+
+    /*
+   if( image->getUseVariance() )
+   {
+   float variance = (float) image->getVariance( ROI );
+   *result /= variance;
+   }
+   */
+
+    return true;
+}
+
+float CvHaarEvaluator::FeatureHaar::getSum(const Mat& image, Rect imageROI) const
+{
+    // left upper Origin
+    int OriginX = imageROI.x;
+    int OriginY = imageROI.y;
+
+    // Check and fix width and height
+    int Width = imageROI.width;
+    int Height = imageROI.height;
+
+    if (OriginX + Width >= image.cols - 1)
+        Width = (image.cols - 1) - OriginX;
+    if (OriginY + Height >= image.rows - 1)
+        Height = (image.rows - 1) - OriginY;
+
+    float value = 0;
+    int depth = image.depth();
+
+    if (depth == CV_8U || depth == CV_32S)
+        value = static_cast<float>(image.at<int>(OriginY + Height, OriginX + Width) + image.at<int>(OriginY, OriginX) - image.at<int>(OriginY, OriginX + Width)
+                - image.at<int>(OriginY + Height, OriginX));
+    else if (depth == CV_64F)
+        value = static_cast<float>(image.at<double>(OriginY + Height, OriginX + Width) + image.at<double>(OriginY, OriginX)
+                - image.at<double>(OriginY, OriginX + Width) - image.at<double>(OriginY + Height, OriginX));
+    else if (depth == CV_32F)
+        value = static_cast<float>(image.at<float>(OriginY + Height, OriginX + Width) + image.at<float>(OriginY, OriginX) - image.at<float>(OriginY, OriginX + Width)
+                - image.at<float>(OriginY + Height, OriginX));
+
+    return value;
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.hpp b/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.hpp
new file mode 100644
index 0000000..659b467
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracking_feature.hpp
@@ -0,0 +1,168 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_DETAIL_TRACKING_FEATURE_HPP
+#define OPENCV_VIDEO_DETAIL_TRACKING_FEATURE_HPP
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+
+/*
+ * TODO This implementation is based on apps/traincascade/
+ * TODO Changed CvHaarEvaluator based on ADABOOSTING implementation (Grabner et al.)
+ */
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+//! @addtogroup tracking_detail
+//! @{
+
+inline namespace feature {
+
+class CvParams
+{
+public:
+    CvParams();
+    virtual ~CvParams()
+    {
+    }
+};
+
+class CvFeatureParams : public CvParams
+{
+public:
+    enum FeatureType
+    {
+        HAAR = 0,
+        LBP = 1,
+        HOG = 2
+    };
+
+    CvFeatureParams();
+    static Ptr<CvFeatureParams> create(CvFeatureParams::FeatureType featureType);
+    int maxCatCount;  // 0 in case of numerical features
+    int featSize;  // 1 in case of simple features (HAAR, LBP) and N_BINS(9)*N_CELLS(4) in case of Dalal's HOG features
+    int numFeatures;
+};
+
+class CvFeatureEvaluator
+{
+public:
+    virtual ~CvFeatureEvaluator()
+    {
+    }
+    virtual void init(const CvFeatureParams* _featureParams, int _maxSampleCount, Size _winSize);
+    virtual void setImage(const Mat& img, uchar clsLabel, int idx);
+    static Ptr<CvFeatureEvaluator> create(CvFeatureParams::FeatureType type);
+
+    int getNumFeatures() const
+    {
+        return numFeatures;
+    }
+    int getMaxCatCount() const
+    {
+        return featureParams->maxCatCount;
+    }
+    int getFeatureSize() const
+    {
+        return featureParams->featSize;
+    }
+    const Mat& getCls() const
+    {
+        return cls;
+    }
+    float getCls(int si) const
+    {
+        return cls.at<float>(si, 0);
+    }
+
+protected:
+    virtual void generateFeatures() = 0;
+
+    int npos, nneg;
+    int numFeatures;
+    Size winSize;
+    CvFeatureParams* featureParams;
+    Mat cls;
+};
+
+class CvHaarFeatureParams : public CvFeatureParams
+{
+public:
+    CvHaarFeatureParams();
+    bool isIntegral;
+};
+
+class CvHaarEvaluator : public CvFeatureEvaluator
+{
+public:
+    class FeatureHaar
+    {
+
+    public:
+        FeatureHaar(Size patchSize);
+        bool eval(const Mat& image, Rect ROI, float* result) const;
+        inline int getNumAreas() const { return m_numAreas; }
+        inline const std::vector<float>& getWeights() const { return m_weights; }
+        inline const std::vector<Rect>& getAreas() const { return m_areas; }
+
+    private:
+        int m_type;
+        int m_numAreas;
+        std::vector<float> m_weights;
+        float m_initMean;
+        float m_initSigma;
+        void generateRandomFeature(Size imageSize);
+        float getSum(const Mat& image, Rect imgROI) const;
+        std::vector<Rect> m_areas;  // areas within the patch over which to compute the feature
+        cv::Size m_initSize;  // size of the patch used during training
+        cv::Size m_curSize;  // size of the patches currently under investigation
+        float m_scaleFactorHeight;  // scaling factor in vertical direction
+        float m_scaleFactorWidth;  // scaling factor in horizontal direction
+        std::vector<Rect> m_scaleAreas;  // areas after scaling
+        std::vector<float> m_scaleWeights;  // weights after scaling
+    };
+
+    virtual void init(const CvFeatureParams* _featureParams, int _maxSampleCount, Size _winSize) CV_OVERRIDE;
+    virtual void setImage(const Mat& img, uchar clsLabel = 0, int idx = 1) CV_OVERRIDE;
+    inline const std::vector<CvHaarEvaluator::FeatureHaar>& getFeatures() const { return features; }
+    inline CvHaarEvaluator::FeatureHaar& getFeatures(int idx)
+    {
+        return features[idx];
+    }
+    inline void setWinSize(Size patchSize) { winSize = patchSize; }
+    inline Size getWinSize() const { return winSize; }
+    virtual void generateFeatures() CV_OVERRIDE;
+
+    /**
+    * \brief Overload the original generateFeatures in order to limit the number of the features
+    * @param numFeatures Number of the features
+    */
+    virtual void generateFeatures(int numFeatures);
+
+protected:
+    bool isIntegral;
+
+    /* TODO Added from MIL implementation */
+    Mat _ii_img;
+    void compute_integral(const cv::Mat& img, std::vector<cv::Mat_<float>>& ii_imgs)
+    {
+        Mat ii_img;
+        integral(img, ii_img, CV_32F);
+        split(ii_img, ii_imgs);
+    }
+
+    std::vector<FeatureHaar> features;
+    Mat sum; /* sum images (each row represents image) */
+};
+
+}  // namespace feature
+
+//! @}
+
+}}}  // namespace cv::detail::tracking
+
+#endif
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp b/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp
new file mode 100644
index 0000000..ebfb310
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.cpp
@@ -0,0 +1,356 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../../precomp.hpp"
+#include "tracking_online_mil.hpp"
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+#define sign(s) ((s > 0) ? 1 : ((s < 0) ? -1 : 0))
+
+template <class T>
+class SortableElementRev
+{
+public:
+    T _val;
+    int _ind;
+    SortableElementRev()
+        : _val(), _ind(0)
+    {
+    }
+    SortableElementRev(T val, int ind)
+    {
+        _val = val;
+        _ind = ind;
+    }
+    bool operator<(SortableElementRev<T>& b)
+    {
+        return (_val < b._val);
+    }
+};
+
+static bool CompareSortableElementRev(const SortableElementRev<float>& i, const SortableElementRev<float>& j)
+{
+    return i._val < j._val;
+}
+
+template <class T>
+void sort_order_des(std::vector<T>& v, std::vector<int>& order)
+{
+    uint n = (uint)v.size();
+    std::vector<SortableElementRev<T>> v2;
+    v2.resize(n);
+    order.clear();
+    order.resize(n);
+    for (uint i = 0; i < n; i++)
+    {
+        v2[i]._ind = i;
+        v2[i]._val = v[i];
+    }
+    //std::sort( v2.begin(), v2.end() );
+    std::sort(v2.begin(), v2.end(), CompareSortableElementRev);
+    for (uint i = 0; i < n; i++)
+    {
+        order[i] = v2[i]._ind;
+        v[i] = v2[i]._val;
+    }
+}
+
+//implementations for strong classifier
+
+ClfMilBoost::Params::Params()
+{
+    _numSel = 50;
+    _numFeat = 250;
+    _lRate = 0.85f;
+}
+
+ClfMilBoost::ClfMilBoost()
+    : _numsamples(0)
+    , _counter(0)
+{
+    _myParams = ClfMilBoost::Params();
+    _numsamples = 0;
+}
+
+ClfMilBoost::~ClfMilBoost()
+{
+    _selectors.clear();
+    for (size_t i = 0; i < _weakclf.size(); i++)
+        delete _weakclf.at(i);
+}
+
+void ClfMilBoost::init(const ClfMilBoost::Params& parameters)
+{
+    _myParams = parameters;
+    _numsamples = 0;
+
+    //_ftrs = Ftr::generate( _myParams->_ftrParams, _myParams->_numFeat );
+    // if( params->_storeFtrHistory )
+    //  Ftr::toViz( _ftrs, "haarftrs" );
+    _weakclf.resize(_myParams._numFeat);
+    for (int k = 0; k < _myParams._numFeat; k++)
+    {
+        _weakclf[k] = new ClfOnlineStump(k);
+        _weakclf[k]->_lRate = _myParams._lRate;
+    }
+    _counter = 0;
+}
+
+void ClfMilBoost::update(const Mat& posx, const Mat& negx)
+{
+    int numneg = negx.rows;
+    int numpos = posx.rows;
+
+    // compute ftrs
+    //if( !posx.ftrsComputed() )
+    //  Ftr::compute( posx, _ftrs );
+    //if( !negx.ftrsComputed() )
+    //  Ftr::compute( negx, _ftrs );
+
+    // initialize H
+    static std::vector<float> Hpos, Hneg;
+    Hpos.clear();
+    Hneg.clear();
+    Hpos.resize(posx.rows, 0.0f), Hneg.resize(negx.rows, 0.0f);
+
+    _selectors.clear();
+    std::vector<float> posw(posx.rows), negw(negx.rows);
+    std::vector<std::vector<float>> pospred(_weakclf.size()), negpred(_weakclf.size());
+
+    // train all weak classifiers without weights
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+    for (int m = 0; m < _myParams._numFeat; m++)
+    {
+        _weakclf[m]->update(posx, negx);
+        pospred[m] = _weakclf[m]->classifySetF(posx);
+        negpred[m] = _weakclf[m]->classifySetF(negx);
+    }
+
+    // pick the best features
+    for (int s = 0; s < _myParams._numSel; s++)
+    {
+
+        // compute errors/likl for all weak clfs
+        std::vector<float> poslikl(_weakclf.size(), 1.0f), neglikl(_weakclf.size()), likl(_weakclf.size());
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int w = 0; w < (int)_weakclf.size(); w++)
+        {
+            float lll = 1.0f;
+            for (int j = 0; j < numpos; j++)
+                lll *= (1 - sigmoid(Hpos[j] + pospred[w][j]));
+            poslikl[w] = (float)-log(1 - lll + 1e-5);
+
+            lll = 0.0f;
+            for (int j = 0; j < numneg; j++)
+                lll += (float)-log(1e-5f + 1 - sigmoid(Hneg[j] + negpred[w][j]));
+            neglikl[w] = lll;
+
+            likl[w] = poslikl[w] / numpos + neglikl[w] / numneg;
+        }
+
+        // pick best weak clf
+        std::vector<int> order;
+        sort_order_des(likl, order);
+
+        // find best weakclf that isn't already included
+        for (uint k = 0; k < order.size(); k++)
+            if (std::count(_selectors.begin(), _selectors.end(), order[k]) == 0)
+            {
+                _selectors.push_back(order[k]);
+                break;
+            }
+
+            // update H = H + h_m
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int k = 0; k < posx.rows; k++)
+            Hpos[k] += pospred[_selectors[s]][k];
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int k = 0; k < negx.rows; k++)
+            Hneg[k] += negpred[_selectors[s]][k];
+    }
+
+    //if( _myParams->_storeFtrHistory )
+    //for ( uint j = 0; j < _selectors.size(); j++ )
+    // _ftrHist( _selectors[j], _counter ) = 1.0f / ( j + 1 );
+
+    _counter++;
+    /* */
+    return;
+}
+
+std::vector<float> ClfMilBoost::classify(const Mat& x, bool logR)
+{
+    int numsamples = x.rows;
+    std::vector<float> res(numsamples);
+    std::vector<float> tr;
+
+    for (uint w = 0; w < _selectors.size(); w++)
+    {
+        tr = _weakclf[_selectors[w]]->classifySetF(x);
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int j = 0; j < numsamples; j++)
+        {
+            res[j] += tr[j];
+        }
+    }
+
+    // return probabilities or log odds ratio
+    if (!logR)
+    {
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+        for (int j = 0; j < (int)res.size(); j++)
+        {
+            res[j] = sigmoid(res[j]);
+        }
+    }
+
+    return res;
+}
+
+//implementations for weak classifier
+
+ClfOnlineStump::ClfOnlineStump()
+    : _mu0(0), _mu1(0), _sig0(0), _sig1(0)
+    , _q(0)
+    , _s(0)
+    , _log_n1(0), _log_n0(0)
+    , _e1(0), _e0(0)
+    , _lRate(0)
+{
+    _trained = false;
+    _ind = -1;
+    init();
+}
+
+ClfOnlineStump::ClfOnlineStump(int ind)
+    : _mu0(0), _mu1(0), _sig0(0), _sig1(0)
+    , _q(0)
+    , _s(0)
+    , _log_n1(0), _log_n0(0)
+    , _e1(0), _e0(0)
+    , _lRate(0)
+{
+    _trained = false;
+    _ind = ind;
+    init();
+}
+void ClfOnlineStump::init()
+{
+    _mu0 = 0;
+    _mu1 = 0;
+    _sig0 = 1;
+    _sig1 = 1;
+    _lRate = 0.85f;
+    _trained = false;
+}
+
+void ClfOnlineStump::update(const Mat& posx, const Mat& negx, const Mat_<float>& /*posw*/, const Mat_<float>& /*negw*/)
+{
+    //std::cout << " ClfOnlineStump::update" << _ind << std::endl;
+    float posmu = 0.0, negmu = 0.0;
+    if (posx.cols > 0)
+        posmu = float(mean(posx.col(_ind))[0]);
+    if (negx.cols > 0)
+        negmu = float(mean(negx.col(_ind))[0]);
+
+    if (_trained)
+    {
+        if (posx.cols > 0)
+        {
+            _mu1 = (_lRate * _mu1 + (1 - _lRate) * posmu);
+            cv::Mat diff = posx.col(_ind) - _mu1;
+            _sig1 = _lRate * _sig1 + (1 - _lRate) * float(mean(diff.mul(diff))[0]);
+        }
+        if (negx.cols > 0)
+        {
+            _mu0 = (_lRate * _mu0 + (1 - _lRate) * negmu);
+            cv::Mat diff = negx.col(_ind) - _mu0;
+            _sig0 = _lRate * _sig0 + (1 - _lRate) * float(mean(diff.mul(diff))[0]);
+        }
+
+        _q = (_mu1 - _mu0) / 2;
+        _s = sign(_mu1 - _mu0);
+        _log_n0 = std::log(float(1.0f / std::pow(_sig0, 0.5f)));
+        _log_n1 = std::log(float(1.0f / std::pow(_sig1, 0.5f)));
+        //_e1 = -1.0f/(2.0f*_sig1+1e-99f);
+        //_e0 = -1.0f/(2.0f*_sig0+1e-99f);
+        _e1 = -1.0f / (2.0f * _sig1 + std::numeric_limits<float>::min());
+        _e0 = -1.0f / (2.0f * _sig0 + std::numeric_limits<float>::min());
+    }
+    else
+    {
+        _trained = true;
+        if (posx.cols > 0)
+        {
+            _mu1 = posmu;
+            cv::Scalar scal_mean, scal_std_dev;
+            cv::meanStdDev(posx.col(_ind), scal_mean, scal_std_dev);
+            _sig1 = float(scal_std_dev[0]) * float(scal_std_dev[0]) + 1e-9f;
+        }
+
+        if (negx.cols > 0)
+        {
+            _mu0 = negmu;
+            cv::Scalar scal_mean, scal_std_dev;
+            cv::meanStdDev(negx.col(_ind), scal_mean, scal_std_dev);
+            _sig0 = float(scal_std_dev[0]) * float(scal_std_dev[0]) + 1e-9f;
+        }
+
+        _q = (_mu1 - _mu0) / 2;
+        _s = sign(_mu1 - _mu0);
+        _log_n0 = std::log(float(1.0f / std::pow(_sig0, 0.5f)));
+        _log_n1 = std::log(float(1.0f / std::pow(_sig1, 0.5f)));
+        //_e1 = -1.0f/(2.0f*_sig1+1e-99f);
+        //_e0 = -1.0f/(2.0f*_sig0+1e-99f);
+        _e1 = -1.0f / (2.0f * _sig1 + std::numeric_limits<float>::min());
+        _e0 = -1.0f / (2.0f * _sig0 + std::numeric_limits<float>::min());
+    }
+}
+
+bool ClfOnlineStump::classify(const Mat& x, int i)
+{
+    float xx = x.at<float>(i, _ind);
+    double log_p0 = (xx - _mu0) * (xx - _mu0) * _e0 + _log_n0;
+    double log_p1 = (xx - _mu1) * (xx - _mu1) * _e1 + _log_n1;
+    return log_p1 > log_p0;
+}
+
+float ClfOnlineStump::classifyF(const Mat& x, int i)
+{
+    float xx = x.at<float>(i, _ind);
+    double log_p0 = (xx - _mu0) * (xx - _mu0) * _e0 + _log_n0;
+    double log_p1 = (xx - _mu1) * (xx - _mu1) * _e1 + _log_n1;
+    return float(log_p1 - log_p0);
+}
+
+inline std::vector<float> ClfOnlineStump::classifySetF(const Mat& x)
+{
+    std::vector<float> res(x.rows);
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+    for (int k = 0; k < (int)res.size(); k++)
+    {
+        res[k] = classifyF(x, k);
+    }
+    return res;
+}
+
+}}}  // namespace cv::detail::tracking
diff --git a/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.hpp b/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.hpp
new file mode 100644
index 0000000..b08a628
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/detail/tracking_online_mil.hpp
@@ -0,0 +1,79 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_VIDEO_DETAIL_TRACKING_ONLINE_MIL_HPP
+#define OPENCV_VIDEO_DETAIL_TRACKING_ONLINE_MIL_HPP
+
+#include <limits>
+
+namespace cv {
+namespace detail {
+inline namespace tracking {
+
+//! @addtogroup tracking_detail
+//! @{
+
+//TODO based on the original implementation
+//http://vision.ucsd.edu/~bbabenko/project_miltrack.shtml
+
+class ClfOnlineStump;
+
+class CV_EXPORTS ClfMilBoost
+{
+public:
+    struct CV_EXPORTS Params
+    {
+        Params();
+        int _numSel;
+        int _numFeat;
+        float _lRate;
+    };
+
+    ClfMilBoost();
+    ~ClfMilBoost();
+    void init(const ClfMilBoost::Params& parameters = ClfMilBoost::Params());
+    void update(const Mat& posx, const Mat& negx);
+    std::vector<float> classify(const Mat& x, bool logR = true);
+
+    inline float sigmoid(float x)
+    {
+        return 1.0f / (1.0f + exp(-x));
+    }
+
+private:
+    uint _numsamples;
+    ClfMilBoost::Params _myParams;
+    std::vector<int> _selectors;
+    std::vector<ClfOnlineStump*> _weakclf;
+    uint _counter;
+};
+
+class ClfOnlineStump
+{
+public:
+    float _mu0, _mu1, _sig0, _sig1;
+    float _q;
+    int _s;
+    float _log_n1, _log_n0;
+    float _e1, _e0;
+    float _lRate;
+
+    ClfOnlineStump();
+    ClfOnlineStump(int ind);
+    void init();
+    void update(const Mat& posx, const Mat& negx, const cv::Mat_<float>& posw = cv::Mat_<float>(), const cv::Mat_<float>& negw = cv::Mat_<float>());
+    bool classify(const Mat& x, int i);
+    float classifyF(const Mat& x, int i);
+    std::vector<float> classifySetF(const Mat& x);
+
+private:
+    bool _trained;
+    int _ind;
+};
+
+//! @}
+
+}}}  // namespace cv::detail::tracking
+
+#endif
diff --git a/upstream/opencv/modules/video/src/tracking/tracker.cpp b/upstream/opencv/modules/video/src/tracking/tracker.cpp
new file mode 100644
index 0000000..ef2f416
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/tracker.cpp
@@ -0,0 +1,19 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../precomp.hpp"
+
+namespace cv {
+
+Tracker::Tracker()
+{
+    // nothing
+}
+
+Tracker::~Tracker()
+{
+    // nothing
+}
+
+}  // namespace cv
diff --git a/upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp b/upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp
new file mode 100644
index 0000000..dfb8a41
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/tracker_dasiamrpn.cpp
@@ -0,0 +1,453 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../precomp.hpp"
+
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+namespace cv {
+
+TrackerDaSiamRPN::TrackerDaSiamRPN()
+{
+    // nothing
+}
+
+TrackerDaSiamRPN::~TrackerDaSiamRPN()
+{
+    // nothing
+}
+
+TrackerDaSiamRPN::Params::Params()
+{
+    model = "dasiamrpn_model.onnx";
+    kernel_cls1 = "dasiamrpn_kernel_cls1.onnx";
+    kernel_r1 = "dasiamrpn_kernel_r1.onnx";
+#ifdef HAVE_OPENCV_DNN
+    backend = dnn::DNN_BACKEND_DEFAULT;
+    target = dnn::DNN_TARGET_CPU;
+#else
+    backend = -1;  // invalid value
+    target = -1;  // invalid value
+#endif
+}
+
+#ifdef HAVE_OPENCV_DNN
+
+template <typename T> static
+T sizeCal(const T& w, const T& h)
+{
+    T pad = (w + h) * T(0.5);
+    T sz2 = (w + pad) * (h + pad);
+    return sqrt(sz2);
+}
+
+template <>
+Mat sizeCal(const Mat& w, const Mat& h)
+{
+    Mat pad = (w + h) * 0.5;
+    Mat sz2 = (w + pad).mul((h + pad));
+
+    cv::sqrt(sz2, sz2);
+    return sz2;
+}
+
+class TrackerDaSiamRPNImpl : public TrackerDaSiamRPN
+{
+public:
+    TrackerDaSiamRPNImpl(const TrackerDaSiamRPN::Params& parameters)
+    {
+        siamRPN = dnn::readNet(parameters.model);
+        siamKernelCL1 = dnn::readNet(parameters.kernel_cls1);
+        siamKernelR1 = dnn::readNet(parameters.kernel_r1);
+
+        CV_Assert(!siamRPN.empty());
+        CV_Assert(!siamKernelCL1.empty());
+        CV_Assert(!siamKernelR1.empty());
+
+        siamRPN.setPreferableBackend(parameters.backend);
+        siamRPN.setPreferableTarget(parameters.target);
+        siamKernelR1.setPreferableBackend(parameters.backend);
+        siamKernelR1.setPreferableTarget(parameters.target);
+        siamKernelCL1.setPreferableBackend(parameters.backend);
+        siamKernelCL1.setPreferableTarget(parameters.target);
+    }
+
+    TrackerDaSiamRPNImpl(const dnn::Net& siam_rpn, const dnn::Net& kernel_cls1, const dnn::Net& kernel_r1)
+    {
+        CV_Assert(!siam_rpn.empty());
+        CV_Assert(!kernel_cls1.empty());
+        CV_Assert(!kernel_r1.empty());
+
+        siamRPN = siam_rpn;
+        siamKernelCL1 = kernel_cls1;
+        siamKernelR1 = kernel_r1;
+    }
+
+    void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    bool update(InputArray image, Rect& boundingBox) CV_OVERRIDE;
+    float getTrackingScore() CV_OVERRIDE;
+
+protected:
+    dnn::Net siamRPN, siamKernelR1, siamKernelCL1;
+    Rect boundingBox_;
+    Mat image_;
+    struct trackerConfig
+    {
+        float windowInfluence = 0.43f;
+        float lr = 0.4f;
+        int scale = 8;
+        bool swapRB = false;
+        int totalStride = 8;
+        float penaltyK = 0.055f;
+        int exemplarSize = 127;
+        int instanceSize = 271;
+        float contextAmount = 0.5f;
+        std::vector<float> ratios = { 0.33f, 0.5f, 1.0f, 2.0f, 3.0f };
+        int anchorNum = int(ratios.size());
+        Mat anchors;
+        Mat windows;
+        Scalar avgChans;
+        Size imgSize = { 0, 0 };
+        Rect2f targetBox = { 0, 0, 0, 0 };
+        int scoreSize = (instanceSize - exemplarSize) / totalStride + 1;
+        float tracking_score;
+
+        void update_scoreSize()
+        {
+            scoreSize = int((instanceSize - exemplarSize) / totalStride + 1);
+        }
+    };
+    trackerConfig trackState;
+
+    void softmax(const Mat& src, Mat& dst);
+    void elementMax(Mat& src);
+    Mat generateHanningWindow();
+    Mat generateAnchors();
+    Mat getSubwindow(Mat& img, const Rect2f& targetBox, float originalSize, Scalar avgChans);
+    void trackerInit(Mat img);
+    void trackerEval(Mat img);
+};
+
+void TrackerDaSiamRPNImpl::init(InputArray image, const Rect& boundingBox)
+{
+    image_ = image.getMat().clone();
+
+    trackState.update_scoreSize();
+    trackState.targetBox = Rect2f(
+        float(boundingBox.x) + float(boundingBox.width) * 0.5f,  // FIXIT don't use center in Rect structures, it is confusing
+        float(boundingBox.y) + float(boundingBox.height) * 0.5f,
+        float(boundingBox.width),
+        float(boundingBox.height)
+    );
+    trackerInit(image_);
+}
+
+void TrackerDaSiamRPNImpl::trackerInit(Mat img)
+{
+    Rect2f targetBox = trackState.targetBox;
+    Mat anchors = generateAnchors();
+    trackState.anchors = anchors;
+
+    Mat windows = generateHanningWindow();
+
+    trackState.windows = windows;
+    trackState.imgSize = img.size();
+
+    trackState.avgChans = mean(img);
+    float wc = targetBox.width + trackState.contextAmount * (targetBox.width + targetBox.height);
+    float hc = targetBox.height + trackState.contextAmount * (targetBox.width + targetBox.height);
+    float sz = (float)cvRound(sqrt(wc * hc));
+
+    Mat zCrop = getSubwindow(img, targetBox, sz, trackState.avgChans);
+    Mat blob;
+
+    dnn::blobFromImage(zCrop, blob, 1.0, Size(trackState.exemplarSize, trackState.exemplarSize), Scalar(), trackState.swapRB, false, CV_32F);
+    siamRPN.setInput(blob);
+    Mat out1;
+    siamRPN.forward(out1, "onnx_node_output_0!63");
+
+    siamKernelCL1.setInput(out1);
+    siamKernelR1.setInput(out1);
+
+    Mat cls1 = siamKernelCL1.forward();
+    Mat r1 = siamKernelR1.forward();
+    std::vector<int> r1_shape = { 20, 256, 4, 4 }, cls1_shape = { 10, 256, 4, 4 };
+
+    siamRPN.setParam("onnx_node_output_0!65", 0, r1.reshape(0, r1_shape));
+    siamRPN.setParam("onnx_node_output_0!68", 0, cls1.reshape(0, cls1_shape));
+}
+
+bool TrackerDaSiamRPNImpl::update(InputArray image, Rect& boundingBox)
+{
+    image_ = image.getMat().clone();
+    trackerEval(image_);
+    boundingBox = {
+        int(trackState.targetBox.x - int(trackState.targetBox.width / 2)),
+        int(trackState.targetBox.y - int(trackState.targetBox.height / 2)),
+        int(trackState.targetBox.width),
+        int(trackState.targetBox.height)
+    };
+    return true;
+}
+
+void TrackerDaSiamRPNImpl::trackerEval(Mat img)
+{
+    Rect2f targetBox = trackState.targetBox;
+
+    float wc = targetBox.height + trackState.contextAmount * (targetBox.width + targetBox.height);
+    float hc = targetBox.width + trackState.contextAmount * (targetBox.width + targetBox.height);
+
+    float sz = sqrt(wc * hc);
+    float scaleZ = trackState.exemplarSize / sz;
+
+    float searchSize = float((trackState.instanceSize - trackState.exemplarSize) / 2);
+    float pad = searchSize / scaleZ;
+    float sx = sz + 2 * pad;
+
+    Mat xCrop = getSubwindow(img, targetBox, (float)cvRound(sx), trackState.avgChans);
+
+    Mat blob;
+    std::vector<Mat> outs;
+    std::vector<String> outNames;
+    Mat delta, score;
+    Mat sc, rc, penalty, pscore;
+
+    dnn::blobFromImage(xCrop, blob, 1.0, Size(trackState.instanceSize, trackState.instanceSize), Scalar(), trackState.swapRB, false, CV_32F);
+
+    siamRPN.setInput(blob);
+
+    outNames = siamRPN.getUnconnectedOutLayersNames();
+    siamRPN.forward(outs, outNames);
+
+    delta = outs[0];
+    score = outs[1];
+
+    score = score.reshape(0, { 2, trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
+    delta = delta.reshape(0, { 4, trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
+
+    softmax(score, score);
+
+    targetBox.width *= scaleZ;
+    targetBox.height *= scaleZ;
+
+    score = score.row(1);
+    score = score.reshape(0, { 5, 19, 19 });
+
+    // Post processing
+    delta.row(0) = delta.row(0).mul(trackState.anchors.row(2)) + trackState.anchors.row(0);
+    delta.row(1) = delta.row(1).mul(trackState.anchors.row(3)) + trackState.anchors.row(1);
+    exp(delta.row(2), delta.row(2));
+    delta.row(2) = delta.row(2).mul(trackState.anchors.row(2));
+    exp(delta.row(3), delta.row(3));
+    delta.row(3) = delta.row(3).mul(trackState.anchors.row(3));
+
+    sc = sizeCal(delta.row(2), delta.row(3)) / sizeCal(targetBox.width, targetBox.height);
+    elementMax(sc);
+
+    rc = delta.row(2).mul(1 / delta.row(3));
+    rc = (targetBox.width / targetBox.height) / rc;
+    elementMax(rc);
+
+    // Calculating the penalty
+    exp(((rc.mul(sc) - 1.) * trackState.penaltyK * (-1.0)), penalty);
+    penalty = penalty.reshape(0, { trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
+
+    pscore = penalty.mul(score);
+    pscore = pscore * (1.0 - trackState.windowInfluence) + trackState.windows * trackState.windowInfluence;
+
+    int bestID[2] = { 0, 0 };
+    // Find the index of best score.
+    minMaxIdx(pscore.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 }), 0, 0, 0, bestID);
+    delta = delta.reshape(0, { 4, trackState.anchorNum * trackState.scoreSize * trackState.scoreSize });
+    penalty = penalty.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 });
+    score = score.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 });
+
+    int index[2] = { 0, bestID[0] };
+    Rect2f resBox = { 0, 0, 0, 0 };
+
+    resBox.x = delta.at<float>(index) / scaleZ;
+    index[0] = 1;
+    resBox.y = delta.at<float>(index) / scaleZ;
+    index[0] = 2;
+    resBox.width = delta.at<float>(index) / scaleZ;
+    index[0] = 3;
+    resBox.height = delta.at<float>(index) / scaleZ;
+
+    float lr = penalty.at<float>(bestID) * score.at<float>(bestID) * trackState.lr;
+
+    resBox.x = resBox.x + targetBox.x;
+    resBox.y = resBox.y + targetBox.y;
+    targetBox.width /= scaleZ;
+    targetBox.height /= scaleZ;
+
+    resBox.width = targetBox.width * (1 - lr) + resBox.width * lr;
+    resBox.height = targetBox.height * (1 - lr) + resBox.height * lr;
+
+    resBox.x = float(fmax(0., fmin(float(trackState.imgSize.width), resBox.x)));
+    resBox.y = float(fmax(0., fmin(float(trackState.imgSize.height), resBox.y)));
+    resBox.width = float(fmax(10., fmin(float(trackState.imgSize.width), resBox.width)));
+    resBox.height = float(fmax(10., fmin(float(trackState.imgSize.height), resBox.height)));
+
+    trackState.targetBox = resBox;
+    trackState.tracking_score = score.at<float>(bestID);
+}
+
+float TrackerDaSiamRPNImpl::getTrackingScore()
+{
+    return trackState.tracking_score;
+}
+
+void TrackerDaSiamRPNImpl::softmax(const Mat& src, Mat& dst)
+{
+    Mat maxVal;
+    cv::max(src.row(1), src.row(0), maxVal);
+
+    src.row(1) -= maxVal;
+    src.row(0) -= maxVal;
+
+    exp(src, dst);
+
+    Mat sumVal = dst.row(0) + dst.row(1);
+    dst.row(0) = dst.row(0) / sumVal;
+    dst.row(1) = dst.row(1) / sumVal;
+}
+
+void TrackerDaSiamRPNImpl::elementMax(Mat& src)
+{
+    int* p = src.size.p;
+    int index[4] = { 0, 0, 0, 0 };
+    for (int n = 0; n < *p; n++)
+    {
+        for (int k = 0; k < *(p + 1); k++)
+        {
+            for (int i = 0; i < *(p + 2); i++)
+            {
+                for (int j = 0; j < *(p + 3); j++)
+                {
+                    index[0] = n, index[1] = k, index[2] = i, index[3] = j;
+                    float& v = src.at<float>(index);
+                    v = fmax(v, 1.0f / v);
+                }
+            }
+        }
+    }
+}
+
+Mat TrackerDaSiamRPNImpl::generateHanningWindow()
+{
+    Mat baseWindows, HanningWindows;
+
+    createHanningWindow(baseWindows, Size(trackState.scoreSize, trackState.scoreSize), CV_32F);
+    baseWindows = baseWindows.reshape(0, { 1, trackState.scoreSize, trackState.scoreSize });
+    HanningWindows = baseWindows.clone();
+    for (int i = 1; i < trackState.anchorNum; i++)
+    {
+        HanningWindows.push_back(baseWindows);
+    }
+
+    return HanningWindows;
+}
+
+Mat TrackerDaSiamRPNImpl::generateAnchors()
+{
+    int totalStride = trackState.totalStride, scales = trackState.scale, scoreSize = trackState.scoreSize;
+    std::vector<float> ratios = trackState.ratios;
+    std::vector<Rect2f> baseAnchors;
+    int anchorNum = int(ratios.size());
+    int size = totalStride * totalStride;
+
+    float ori = -(float(scoreSize / 2)) * float(totalStride);
+
+    for (auto i = 0; i < anchorNum; i++)
+    {
+        int ws = int(sqrt(size / ratios[i]));
+        int hs = int(ws * ratios[i]);
+
+        float wws = float(ws) * scales;
+        float hhs = float(hs) * scales;
+        Rect2f anchor = { 0, 0, wws, hhs };
+        baseAnchors.push_back(anchor);
+    }
+
+    int anchorIndex[4] = { 0, 0, 0, 0 };
+    const int sizes[4] = { 4, (int)ratios.size(), scoreSize, scoreSize };
+    Mat anchors(4, sizes, CV_32F);
+
+    for (auto i = 0; i < scoreSize; i++)
+    {
+        for (auto j = 0; j < scoreSize; j++)
+        {
+            for (auto k = 0; k < anchorNum; k++)
+            {
+                anchorIndex[0] = 1, anchorIndex[1] = k, anchorIndex[2] = i, anchorIndex[3] = j;
+                anchors.at<float>(anchorIndex) = ori + totalStride * i;
+
+                anchorIndex[0] = 0;
+                anchors.at<float>(anchorIndex) = ori + totalStride * j;
+
+                anchorIndex[0] = 2;
+                anchors.at<float>(anchorIndex) = baseAnchors[k].width;
+
+                anchorIndex[0] = 3;
+                anchors.at<float>(anchorIndex) = baseAnchors[k].height;
+            }
+        }
+    }
+
+    return anchors;
+}
+
+Mat TrackerDaSiamRPNImpl::getSubwindow(Mat& img, const Rect2f& targetBox, float originalSize, Scalar avgChans)
+{
+    Mat zCrop, dst;
+    Size imgSize = img.size();
+    float c = (originalSize + 1) / 2;
+    float xMin = (float)cvRound(targetBox.x - c);
+    float xMax = xMin + originalSize - 1;
+    float yMin = (float)cvRound(targetBox.y - c);
+    float yMax = yMin + originalSize - 1;
+
+    int leftPad = (int)(fmax(0., -xMin));
+    int topPad = (int)(fmax(0., -yMin));
+    int rightPad = (int)(fmax(0., xMax - imgSize.width + 1));
+    int bottomPad = (int)(fmax(0., yMax - imgSize.height + 1));
+
+    xMin = xMin + leftPad;
+    xMax = xMax + leftPad;
+    yMax = yMax + topPad;
+    yMin = yMin + topPad;
+
+    if (topPad == 0 && bottomPad == 0 && leftPad == 0 && rightPad == 0)
+    {
+        img(Rect(int(xMin), int(yMin), int(xMax - xMin + 1), int(yMax - yMin + 1))).copyTo(zCrop);
+    }
+    else
+    {
+        copyMakeBorder(img, dst, topPad, bottomPad, leftPad, rightPad, BORDER_CONSTANT, avgChans);
+        dst(Rect(int(xMin), int(yMin), int(xMax - xMin + 1), int(yMax - yMin + 1))).copyTo(zCrop);
+    }
+
+    return zCrop;
+}
+
+Ptr<TrackerDaSiamRPN> TrackerDaSiamRPN::create(const TrackerDaSiamRPN::Params& parameters)
+{
+    return makePtr<TrackerDaSiamRPNImpl>(parameters);
+}
+
+Ptr<TrackerDaSiamRPN> TrackerDaSiamRPN::create(const dnn::Net& siam_rpn, const dnn::Net& kernel_cls1, const dnn::Net& kernel_r1)
+{
+    return makePtr<TrackerDaSiamRPNImpl>(siam_rpn, kernel_cls1, kernel_r1);
+}
+
+#else  // OPENCV_HAVE_DNN
+Ptr<TrackerDaSiamRPN> TrackerDaSiamRPN::create(const TrackerDaSiamRPN::Params& parameters)
+{
+    (void)(parameters);
+    CV_Error(cv::Error::StsNotImplemented, "to use DaSiamRPN, the tracking module needs to be built with opencv_dnn !");
+}
+#endif  // OPENCV_HAVE_DNN
+}
diff --git a/upstream/opencv/modules/video/src/tracking/tracker_mil.cpp b/upstream/opencv/modules/video/src/tracking/tracker_mil.cpp
new file mode 100644
index 0000000..ffe1be8
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/tracker_mil.cpp
@@ -0,0 +1,227 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+#include "../precomp.hpp"
+#include "detail/tracker_mil_model.hpp"
+
+#include "detail/tracker_feature_haar.impl.hpp"
+
+namespace cv {
+inline namespace tracking {
+namespace impl {
+
+using cv::detail::tracking::internal::TrackerFeatureHAAR;
+
+
+class TrackerMILImpl CV_FINAL : public TrackerMIL
+{
+public:
+    TrackerMILImpl(const TrackerMIL::Params& parameters);
+
+    virtual void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    virtual bool update(InputArray image, Rect& boundingBox) CV_OVERRIDE;
+
+    void compute_integral(const Mat& img, Mat& ii_img);
+
+    TrackerMIL::Params params;
+
+    Ptr<TrackerMILModel> model;
+    Ptr<TrackerSampler> sampler;
+    Ptr<TrackerFeatureSet> featureSet;
+};
+
+TrackerMILImpl::TrackerMILImpl(const TrackerMIL::Params& parameters)
+    : params(parameters)
+{
+    // nothing
+}
+
+void TrackerMILImpl::compute_integral(const Mat& img, Mat& ii_img)
+{
+    Mat ii;
+    std::vector<Mat> ii_imgs;
+    integral(img, ii, CV_32F);  // FIXIT split first
+    split(ii, ii_imgs);
+    ii_img = ii_imgs[0];
+}
+
+void TrackerMILImpl::init(InputArray image, const Rect& boundingBox)
+{
+    sampler = makePtr<TrackerSampler>();
+    featureSet = makePtr<TrackerFeatureSet>();
+
+    Mat intImage;
+    compute_integral(image.getMat(), intImage);
+    TrackerSamplerCSC::Params CSCparameters;
+    CSCparameters.initInRad = params.samplerInitInRadius;
+    CSCparameters.searchWinSize = params.samplerSearchWinSize;
+    CSCparameters.initMaxNegNum = params.samplerInitMaxNegNum;
+    CSCparameters.trackInPosRad = params.samplerTrackInRadius;
+    CSCparameters.trackMaxPosNum = params.samplerTrackMaxPosNum;
+    CSCparameters.trackMaxNegNum = params.samplerTrackMaxNegNum;
+
+    Ptr<TrackerSamplerAlgorithm> CSCSampler = makePtr<TrackerSamplerCSC>(CSCparameters);
+    CV_Assert(sampler->addTrackerSamplerAlgorithm(CSCSampler));
+
+    //or add CSC sampler with default parameters
+    //sampler->addTrackerSamplerAlgorithm( "CSC" );
+
+    //Positive sampling
+    CSCSampler.staticCast<TrackerSamplerCSC>()->setMode(TrackerSamplerCSC::MODE_INIT_POS);
+    sampler->sampling(intImage, boundingBox);
+    std::vector<Mat> posSamples = sampler->getSamples();
+
+    //Negative sampling
+    CSCSampler.staticCast<TrackerSamplerCSC>()->setMode(TrackerSamplerCSC::MODE_INIT_NEG);
+    sampler->sampling(intImage, boundingBox);
+    std::vector<Mat> negSamples = sampler->getSamples();
+
+    CV_Assert(!posSamples.empty());
+    CV_Assert(!negSamples.empty());
+
+    //compute HAAR features
+    TrackerFeatureHAAR::Params HAARparameters;
+    HAARparameters.numFeatures = params.featureSetNumFeatures;
+    HAARparameters.rectSize = Size((int)boundingBox.width, (int)boundingBox.height);
+    HAARparameters.isIntegral = true;
+    Ptr<TrackerFeature> trackerFeature = makePtr<TrackerFeatureHAAR>(HAARparameters);
+    featureSet->addTrackerFeature(trackerFeature);
+
+    featureSet->extraction(posSamples);
+    const std::vector<Mat> posResponse = featureSet->getResponses();
+
+    featureSet->extraction(negSamples);
+    const std::vector<Mat> negResponse = featureSet->getResponses();
+
+    model = makePtr<TrackerMILModel>(boundingBox);
+    Ptr<TrackerStateEstimatorMILBoosting> stateEstimator = makePtr<TrackerStateEstimatorMILBoosting>(params.featureSetNumFeatures);
+    model->setTrackerStateEstimator(stateEstimator);
+
+    //Run model estimation and update
+    model.staticCast<TrackerMILModel>()->setMode(TrackerMILModel::MODE_POSITIVE, posSamples);
+    model->modelEstimation(posResponse);
+    model.staticCast<TrackerMILModel>()->setMode(TrackerMILModel::MODE_NEGATIVE, negSamples);
+    model->modelEstimation(negResponse);
+    model->modelUpdate();
+}
+
+bool TrackerMILImpl::update(InputArray image, Rect& boundingBox)
+{
+    Mat intImage;
+    compute_integral(image.getMat(), intImage);
+
+    //get the last location [AAM] X(k-1)
+    Ptr<TrackerTargetState> lastLocation = model->getLastTargetState();
+    Rect lastBoundingBox((int)lastLocation->getTargetPosition().x, (int)lastLocation->getTargetPosition().y, lastLocation->getTargetWidth(),
+            lastLocation->getTargetHeight());
+
+    //sampling new frame based on last location
+    auto& samplers = sampler->getSamplers();
+    CV_Assert(!samplers.empty());
+    CV_Assert(samplers[0]);
+    samplers[0].staticCast<TrackerSamplerCSC>()->setMode(TrackerSamplerCSC::MODE_DETECT);
+    sampler->sampling(intImage, lastBoundingBox);
+    std::vector<Mat> detectSamples = sampler->getSamples();
+    if (detectSamples.empty())
+        return false;
+
+    /*//TODO debug samples
+   Mat f;
+   image.copyTo(f);
+
+   for( size_t i = 0; i < detectSamples.size(); i=i+10 )
+   {
+   Size sz;
+   Point off;
+   detectSamples.at(i).locateROI(sz, off);
+   rectangle(f, Rect(off.x,off.y,detectSamples.at(i).cols,detectSamples.at(i).rows), Scalar(255,0,0), 1);
+   }*/
+
+    //extract features from new samples
+    featureSet->extraction(detectSamples);
+    std::vector<Mat> response = featureSet->getResponses();
+
+    //predict new location
+    ConfidenceMap cmap;
+    model.staticCast<TrackerMILModel>()->setMode(TrackerMILModel::MODE_ESTIMATON, detectSamples);
+    model.staticCast<TrackerMILModel>()->responseToConfidenceMap(response, cmap);
+    model->getTrackerStateEstimator().staticCast<TrackerStateEstimatorMILBoosting>()->setCurrentConfidenceMap(cmap);
+
+    if (!model->runStateEstimator())
+    {
+        return false;
+    }
+
+    Ptr<TrackerTargetState> currentState = model->getLastTargetState();
+    boundingBox = Rect((int)currentState->getTargetPosition().x, (int)currentState->getTargetPosition().y, currentState->getTargetWidth(),
+            currentState->getTargetHeight());
+
+    /*//TODO debug
+   rectangle(f, lastBoundingBox, Scalar(0,255,0), 1);
+   rectangle(f, boundingBox, Scalar(0,0,255), 1);
+   imshow("f", f);
+   //waitKey( 0 );*/
+
+    //sampling new frame based on new location
+    //Positive sampling
+    samplers[0].staticCast<TrackerSamplerCSC>()->setMode(TrackerSamplerCSC::MODE_INIT_POS);
+    sampler->sampling(intImage, boundingBox);
+    std::vector<Mat> posSamples = sampler->getSamples();
+
+    //Negative sampling
+    samplers[0].staticCast<TrackerSamplerCSC>()->setMode(TrackerSamplerCSC::MODE_INIT_NEG);
+    sampler->sampling(intImage, boundingBox);
+    std::vector<Mat> negSamples = sampler->getSamples();
+
+    if (posSamples.empty() || negSamples.empty())
+        return false;
+
+    //extract features
+    featureSet->extraction(posSamples);
+    std::vector<Mat> posResponse = featureSet->getResponses();
+
+    featureSet->extraction(negSamples);
+    std::vector<Mat> negResponse = featureSet->getResponses();
+
+    //model estimate
+    model.staticCast<TrackerMILModel>()->setMode(TrackerMILModel::MODE_POSITIVE, posSamples);
+    model->modelEstimation(posResponse);
+    model.staticCast<TrackerMILModel>()->setMode(TrackerMILModel::MODE_NEGATIVE, negSamples);
+    model->modelEstimation(negResponse);
+
+    //model update
+    model->modelUpdate();
+
+    return true;
+}
+
+}}  // namespace tracking::impl
+
+TrackerMIL::Params::Params()
+{
+    samplerInitInRadius = 3;
+    samplerSearchWinSize = 25;
+    samplerInitMaxNegNum = 65;
+    samplerTrackInRadius = 4;
+    samplerTrackMaxPosNum = 100000;
+    samplerTrackMaxNegNum = 65;
+    featureSetNumFeatures = 250;
+}
+
+TrackerMIL::TrackerMIL()
+{
+    // nothing
+}
+
+TrackerMIL::~TrackerMIL()
+{
+    // nothing
+}
+
+Ptr<TrackerMIL> TrackerMIL::create(const TrackerMIL::Params& parameters)
+{
+    return makePtr<tracking::impl::TrackerMILImpl>(parameters);
+}
+
+}  // namespace cv
diff --git a/upstream/opencv/modules/video/src/tracking/tracker_nano.cpp b/upstream/opencv/modules/video/src/tracking/tracker_nano.cpp
new file mode 100644
index 0000000..643a3ed
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/tracker_nano.cpp
@@ -0,0 +1,374 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// This file is modified from the https://github.com/HonglinChu/NanoTrack/blob/master/ncnn_macos_nanotrack/nanotrack.cpp
+// Author, HongLinChu, 1628464345@qq.com
+// Adapt to OpenCV, ZihaoMu: zihaomu@outlook.com
+
+// Link to original inference code: https://github.com/HonglinChu/NanoTrack
+// Link to original training repo: https://github.com/HonglinChu/SiamTrackers/tree/master/NanoTrack
+
+#include "../precomp.hpp"
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+namespace cv {
+
+TrackerNano::TrackerNano()
+{
+    // nothing
+}
+
+TrackerNano::~TrackerNano()
+{
+    // nothing
+}
+
+TrackerNano::Params::Params()
+{
+    backbone = "backbone.onnx";
+    neckhead = "neckhead.onnx";
+#ifdef HAVE_OPENCV_DNN
+    backend = dnn::DNN_BACKEND_DEFAULT;
+    target = dnn::DNN_TARGET_CPU;
+#else
+    backend = -1;  // invalid value
+    target = -1;  // invalid value
+#endif
+}
+
+#ifdef HAVE_OPENCV_DNN
+static void softmax(const Mat& src, Mat& dst)
+{
+    Mat maxVal;
+    cv::max(src.row(1), src.row(0), maxVal);
+
+    src.row(1) -= maxVal;
+    src.row(0) -= maxVal;
+
+    exp(src, dst);
+
+    Mat sumVal = dst.row(0) + dst.row(1);
+    dst.row(0) = dst.row(0) / sumVal;
+    dst.row(1) = dst.row(1) / sumVal;
+}
+
+static float sizeCal(float w, float h)
+{
+    float pad = (w + h) * 0.5f;
+    float sz2 = (w + pad) * (h + pad);
+    return sqrt(sz2);
+}
+
+static Mat sizeCal(const Mat& w, const Mat& h)
+{
+    Mat pad = (w + h) * 0.5;
+    Mat sz2 = (w + pad).mul((h + pad));
+
+    cv::sqrt(sz2, sz2);
+    return sz2;
+}
+
+// Similar python code: r = np.maximum(r, 1. / r) # r is matrix
+static void elementReciprocalMax(Mat& srcDst)
+{
+    size_t totalV = srcDst.total();
+    float* ptr = srcDst.ptr<float>(0);
+    for (size_t i = 0; i < totalV; i++)
+    {
+        float val = *(ptr + i);
+        *(ptr + i) = std::max(val, 1.0f/val);
+    }
+}
+
+class TrackerNanoImpl : public TrackerNano
+{
+public:
+    TrackerNanoImpl(const TrackerNano::Params& parameters)
+    {
+        dnn::EngineType engine = dnn::ENGINE_AUTO;
+        if (parameters.backend != 0 || parameters.target != 0){
+            engine = dnn::ENGINE_CLASSIC;
+        }
+        backbone = dnn::readNet(parameters.backbone, "", "", engine);
+        neckhead = dnn::readNet(parameters.neckhead, "", "", engine);
+
+        CV_Assert(!backbone.empty());
+        CV_Assert(!neckhead.empty());
+
+        backbone.setPreferableBackend(parameters.backend);
+        backbone.setPreferableTarget(parameters.target);
+        neckhead.setPreferableBackend(parameters.backend);
+        neckhead.setPreferableTarget(parameters.target);
+    }
+
+    TrackerNanoImpl(const dnn::Net& _backbone, const dnn::Net& _neckhead)
+    {
+        CV_Assert(!_backbone.empty());
+        CV_Assert(!_neckhead.empty());
+
+        backbone = _backbone;
+        neckhead = _neckhead;
+    }
+
+    void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    bool update(InputArray image, Rect& boundingBox) CV_OVERRIDE;
+    float getTrackingScore() CV_OVERRIDE;
+
+    // Save the target bounding box for each frame.
+    std::vector<float> targetSz = {0, 0};  // H and W of bounding box
+    std::vector<float> targetPos = {0, 0}; // center point of bounding box (x, y)
+    float tracking_score;
+
+    struct trackerConfig
+    {
+        float windowInfluence = 0.455f;
+        float lr = 0.37f;
+        float contextAmount = 0.5;
+        bool swapRB = true;
+        int totalStride = 16;
+        float penaltyK = 0.055f;
+    };
+
+protected:
+    const int exemplarSize = 127;
+    const int instanceSize = 255;
+
+    trackerConfig trackState;
+    int scoreSize;
+    Size imgSize = {0, 0};
+    Mat hanningWindow;
+    Mat grid2searchX, grid2searchY;
+
+    dnn::Net backbone, neckhead;
+    Mat image;
+
+    void getSubwindow(Mat& dstCrop, Mat& srcImg, int originalSz, int resizeSz);
+    void generateGrids();
+};
+
+void TrackerNanoImpl::generateGrids()
+{
+    int sz = scoreSize;
+    const int sz2 = sz / 2;
+
+    std::vector<float> x1Vec(sz, 0);
+
+    for (int i = 0; i < sz; i++)
+    {
+        x1Vec[i] = (float)(i - sz2);
+    }
+
+    Mat x1M(1, sz, CV_32FC1, x1Vec.data());
+
+    cv::repeat(x1M, sz, 1, grid2searchX);
+    cv::repeat(x1M.t(), 1, sz, grid2searchY);
+
+    grid2searchX *= trackState.totalStride;
+    grid2searchY *= trackState.totalStride;
+
+    grid2searchX += instanceSize/2;
+    grid2searchY += instanceSize/2;
+}
+
+void TrackerNanoImpl::init(InputArray image_, const Rect &boundingBox_)
+{
+    scoreSize = (instanceSize - exemplarSize) / trackState.totalStride + 8;
+    trackState = trackerConfig();
+    image = image_.getMat().clone();
+
+    // convert Rect2d from left-up to center.
+    targetPos[0] = float(boundingBox_.x) + float(boundingBox_.width) * 0.5f;
+    targetPos[1] = float(boundingBox_.y) + float(boundingBox_.height) * 0.5f;
+
+    targetSz[0] = float(boundingBox_.width);
+    targetSz[1] = float(boundingBox_.height);
+
+    imgSize = image.size();
+
+    // Extent the bounding box.
+    float sumSz = targetSz[0] + targetSz[1];
+    float wExtent = targetSz[0] + trackState.contextAmount * (sumSz);
+    float hExtent = targetSz[1] + trackState.contextAmount * (sumSz);
+    int sz = int(cv::sqrt(wExtent * hExtent));
+
+    Mat crop;
+    getSubwindow(crop, image, sz, exemplarSize);
+    Mat blob = dnn::blobFromImage(crop, 1.0, Size(), Scalar(), trackState.swapRB);
+
+    backbone.setInput(blob);
+    Mat out = backbone.forward(); // Feature extraction.
+    neckhead.setInput(out, "input1");
+
+    createHanningWindow(hanningWindow, Size(scoreSize, scoreSize), CV_32F);
+    generateGrids();
+}
+
+void TrackerNanoImpl::getSubwindow(Mat& dstCrop, Mat& srcImg, int originalSz, int resizeSz)
+{
+    Scalar avgChans = mean(srcImg);
+    Size imgSz = srcImg.size();
+    int c = (originalSz + 1) / 2;
+
+    int context_xmin = (int)(targetPos[0]) - c;
+    int context_xmax = context_xmin + originalSz - 1;
+    int context_ymin = (int)(targetPos[1]) - c;
+    int context_ymax = context_ymin + originalSz - 1;
+
+    int left_pad = std::max(0, -context_xmin);
+    int top_pad = std::max(0, -context_ymin);
+    int right_pad = std::max(0, context_xmax - imgSz.width + 1);
+    int bottom_pad = std::max(0, context_ymax - imgSz.height + 1);
+
+    context_xmin += left_pad;
+    context_xmax += left_pad;
+    context_ymin += top_pad;
+    context_ymax += top_pad;
+
+    Mat cropImg;
+    if (left_pad == 0 && top_pad == 0 && right_pad == 0 && bottom_pad == 0)
+    {
+        // Crop image without padding.
+        cropImg = srcImg(cv::Rect(context_xmin, context_ymin,
+                                  context_xmax - context_xmin + 1, context_ymax - context_ymin + 1));
+    }
+    else // Crop image with padding, and the padding value is avgChans
+    {
+        cv::Mat tmpMat;
+        cv::copyMakeBorder(srcImg, tmpMat, top_pad, bottom_pad, left_pad, right_pad, cv::BORDER_CONSTANT, avgChans);
+        cropImg = tmpMat(cv::Rect(context_xmin, context_ymin, context_xmax - context_xmin + 1, context_ymax - context_ymin + 1));
+    }
+    resize(cropImg, dstCrop, Size(resizeSz, resizeSz));
+}
+
+bool TrackerNanoImpl::update(InputArray image_, Rect &boundingBoxRes)
+{
+    image = image_.getMat().clone();
+    int targetSzSum = (int)(targetSz[0] + targetSz[1]);
+
+    float wc = targetSz[0] + trackState.contextAmount * targetSzSum;
+    float hc = targetSz[1] + trackState.contextAmount * targetSzSum;
+    float sz = cv::sqrt(wc * hc);
+    float scale_z = exemplarSize / sz;
+    float sx = sz * (instanceSize / exemplarSize);
+    targetSz[0] *= scale_z;
+    targetSz[1] *= scale_z;
+
+    Mat crop;
+    getSubwindow(crop, image, int(sx), instanceSize);
+
+    Mat blob = dnn::blobFromImage(crop, 1.0, Size(), Scalar(), trackState.swapRB);
+    backbone.setInput(blob);
+    Mat xf = backbone.forward();
+    neckhead.setInput(xf, "input2");
+    std::vector<String> outputName = {"output1", "output2"};
+    std::vector<Mat> outs;
+    neckhead.forward(outs, outputName);
+
+    CV_Assert(outs.size() == 2);
+
+    Mat clsScore = outs[0]; // 1x2x16x16
+    Mat bboxPred = outs[1]; // 1x4x16x16
+
+    clsScore = clsScore.reshape(0, {2, scoreSize, scoreSize});
+    bboxPred = bboxPred.reshape(0, {4, scoreSize, scoreSize});
+
+    Mat scoreSoftmax; // 2x16x16
+    softmax(clsScore, scoreSoftmax);
+
+    Mat score = scoreSoftmax.row(1);
+    score = score.reshape(0, {scoreSize, scoreSize});
+
+    Mat predX1 = grid2searchX - bboxPred.row(0).reshape(0, {scoreSize, scoreSize});
+    Mat predY1 = grid2searchY - bboxPred.row(1).reshape(0, {scoreSize, scoreSize});
+    Mat predX2 = grid2searchX + bboxPred.row(2).reshape(0, {scoreSize, scoreSize});
+    Mat predY2 = grid2searchY + bboxPred.row(3).reshape(0, {scoreSize, scoreSize});
+
+    // size penalty
+    // scale penalty
+    Mat sc = sizeCal(predX2 - predX1, predY2 - predY1)/sizeCal(targetPos[0], targetPos[1]);
+    elementReciprocalMax(sc);
+
+    // ratio penalty
+    float ratioVal = targetSz[0] / targetSz[1];
+
+    Mat ratioM(scoreSize, scoreSize, CV_32FC1, Scalar::all(ratioVal));
+    Mat rc = ratioM / ((predX2 - predX1) / (predY2 - predY1));
+    elementReciprocalMax(rc);
+
+    Mat penalty;
+    exp(((rc.mul(sc) - 1) * trackState.penaltyK * (-1)), penalty);
+    Mat pscore = penalty.mul(score);
+
+    // Window penalty
+    pscore = pscore * (1.0 - trackState.windowInfluence) + hanningWindow * trackState.windowInfluence;
+
+    // get Max
+    int bestID[2] = { 0, 0 };
+    minMaxIdx(pscore, 0, 0, 0, bestID);
+
+    tracking_score = pscore.at<float>(bestID);
+
+    float x1Val = predX1.at<float>(bestID);
+    float x2Val = predX2.at<float>(bestID);
+    float y1Val = predY1.at<float>(bestID);
+    float y2Val = predY2.at<float>(bestID);
+
+    float predXs = (x1Val + x2Val)/2;
+    float predYs = (y1Val + y2Val)/2;
+    float predW = (x2Val - x1Val)/scale_z;
+    float predH = (y2Val - y1Val)/scale_z;
+
+    float diffXs = (predXs - instanceSize / 2) / scale_z;
+    float diffYs = (predYs - instanceSize / 2) / scale_z;
+
+    targetSz[0] /= scale_z;
+    targetSz[1] /= scale_z;
+
+    float lr = penalty.at<float>(bestID) * score.at<float>(bestID) * trackState.lr;
+
+    float resX = targetPos[0] + diffXs;
+    float resY = targetPos[1] + diffYs;
+    float resW = predW * lr + (1 - lr) * targetSz[0];
+    float resH = predH * lr + (1 - lr) * targetSz[1];
+
+    resX = std::max(0.f, std::min((float)imgSize.width, resX));
+    resY = std::max(0.f, std::min((float)imgSize.height, resY));
+    resW = std::max(10.f, std::min((float)imgSize.width, resW));
+    resH = std::max(10.f, std::min((float)imgSize.height, resH));
+
+    targetPos[0] = resX;
+    targetPos[1] = resY;
+    targetSz[0] = resW;
+    targetSz[1] = resH;
+
+    // convert center to Rect.
+    boundingBoxRes = { int(resX - resW/2), int(resY - resH/2), int(resW), int(resH)};
+    return true;
+}
+
+float TrackerNanoImpl::getTrackingScore()
+{
+    return tracking_score;
+}
+
+Ptr<TrackerNano> TrackerNano::create(const TrackerNano::Params& parameters)
+{
+    return makePtr<TrackerNanoImpl>(parameters);
+}
+
+Ptr<TrackerNano> TrackerNano::create(const dnn::Net& backbone, const dnn::Net& neckhead)
+{
+    return makePtr<TrackerNanoImpl>(backbone, neckhead);
+}
+
+#else  // OPENCV_HAVE_DNN
+Ptr<TrackerNano> TrackerNano::create(const TrackerNano::Params& parameters)
+{
+    CV_UNUSED(parameters);
+    CV_Error(cv::Error::StsNotImplemented, "to use NanoTrack, the tracking module needs to be built with opencv_dnn !");
+}
+#endif  // OPENCV_HAVE_DNN
+}
diff --git a/upstream/opencv/modules/video/src/tracking/tracker_vit.cpp b/upstream/opencv/modules/video/src/tracking/tracker_vit.cpp
new file mode 100644
index 0000000..53797e3
--- /dev/null
+++ b/upstream/opencv/modules/video/src/tracking/tracker_vit.cpp
@@ -0,0 +1,242 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Author, PengyuLiu, 1872918507@qq.com
+
+#include "../precomp.hpp"
+#ifdef HAVE_OPENCV_DNN
+#include "opencv2/dnn.hpp"
+#endif
+
+namespace cv {
+
+TrackerVit::TrackerVit()
+{
+    // nothing
+}
+
+TrackerVit::~TrackerVit()
+{
+    // nothing
+}
+
+TrackerVit::Params::Params()
+{
+    net = "vitTracker.onnx";
+    meanvalue = Scalar{0.485, 0.456, 0.406}; // normalized mean (already divided by 255)
+    stdvalue = Scalar{0.229, 0.224, 0.225};  // normalized std (already divided by 255)
+#ifdef HAVE_OPENCV_DNN
+    backend = dnn::DNN_BACKEND_DEFAULT;
+    target = dnn::DNN_TARGET_CPU;
+#else
+    backend = -1;  // invalid value
+    target = -1;  // invalid value
+#endif
+    tracking_score_threshold = 0.20f; // safe threshold to filter out black frames
+}
+
+#ifdef HAVE_OPENCV_DNN
+
+class TrackerVitImpl : public TrackerVit
+{
+public:
+    TrackerVitImpl(const TrackerVit::Params& parameters)
+    {
+        dnn::EngineType engine = dnn::ENGINE_AUTO;
+        if (parameters.backend != 0 || parameters.target != 0){
+            engine = dnn::ENGINE_CLASSIC;
+        }
+        net = dnn::readNet(parameters.net, "", "", engine);
+        CV_Assert(!net.empty());
+
+        net.setPreferableBackend(parameters.backend);
+        net.setPreferableTarget(parameters.target);
+
+        i2bp.mean = parameters.meanvalue * 255.0;
+        i2bp.scalefactor = (1.0 / parameters.stdvalue) * (1 / 255.0);
+        tracking_score_threshold = parameters.tracking_score_threshold;
+    }
+
+    TrackerVitImpl(const dnn::Net& model, Scalar meanvalue, Scalar stdvalue, float _tracking_score_threshold)
+    {
+        CV_Assert(!model.empty());
+
+        net = model;
+        i2bp.mean = meanvalue * 255.0;
+        i2bp.scalefactor = (1.0 / stdvalue) * (1 / 255.0);
+        tracking_score_threshold = _tracking_score_threshold;
+    }
+
+    void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
+    bool update(InputArray image, Rect& boundingBox) CV_OVERRIDE;
+    float getTrackingScore() CV_OVERRIDE;
+
+    Rect rect_last;
+    float tracking_score;
+
+    float tracking_score_threshold;
+    dnn::Image2BlobParams i2bp;
+
+
+protected:
+    void preprocess(const Mat& src, Mat& dst, Size size);
+
+    const Size searchSize{256, 256};
+    const Size templateSize{128, 128};
+
+    Mat hanningWindow;
+
+    dnn::Net net;
+};
+
+static int crop_image(const Mat& src, Mat& dst, Rect box, int factor)
+{
+    int x = box.x, y = box.y, w = box.width, h = box.height;
+    int crop_sz = cvCeil(sqrt(w * h) * factor);
+
+    int x1 = x + (w - crop_sz) / 2;
+    int x2 = x1 + crop_sz;
+    int y1 = y + (h - crop_sz) / 2;
+    int y2 = y1 + crop_sz;
+
+    int x1_pad = std::max(0, -x1);
+    int y1_pad = std::max(0, -y1);
+    int x2_pad = std::max(x2 - src.size[1] + 1, 0);
+    int y2_pad = std::max(y2 - src.size[0] + 1, 0);
+
+    Rect roi(x1 + x1_pad, y1 + y1_pad, x2 - x2_pad - x1 - x1_pad, y2 - y2_pad - y1 - y1_pad);
+    Mat im_crop = src(roi);
+    copyMakeBorder(im_crop, dst, y1_pad, y2_pad, x1_pad, x2_pad, BORDER_CONSTANT);
+
+    return crop_sz;
+}
+
+void TrackerVitImpl::preprocess(const Mat& src, Mat& dst, Size size)
+{
+    Mat img;
+    resize(src, img, size);
+
+    dst = dnn::blobFromImageWithParams(img, i2bp);
+}
+
+static Mat hann1d(int sz, bool centered = true) {
+    Mat hanningWindow(sz, 1, CV_32FC1);
+    float* data = hanningWindow.ptr<float>(0);
+
+    if(centered) {
+        for(int i = 0; i < sz; i++) {
+            float val = 0.5f * (1.f - std::cos(static_cast<float>(2 * M_PI / (sz + 1)) * (i + 1)));
+            data[i] = val;
+        }
+    }
+    else {
+        int half_sz = sz / 2;
+        for(int i = 0; i <= half_sz; i++) {
+            float val = 0.5f * (1.f + std::cos(static_cast<float>(2 * M_PI / (sz + 2)) * i));
+            data[i] = val;
+            data[sz - 1 - i] = val;
+        }
+    }
+
+    return hanningWindow;
+}
+
+static Mat hann2d(Size size, bool centered = true) {
+    int rows = size.height;
+    int cols = size.width;
+
+    Mat hanningWindowRows = hann1d(rows, centered);
+    Mat hanningWindowCols = hann1d(cols, centered);
+
+    Mat hanningWindow = hanningWindowRows * hanningWindowCols.t();
+
+    return hanningWindow;
+}
+
+static void updateLastRect(float cx, float cy, float w, float h, int crop_size, Rect &rect_last)
+{
+    int x0 = rect_last.x + (rect_last.width - crop_size) / 2;
+    int y0 = rect_last.y + (rect_last.height - crop_size) / 2;
+
+    float x1 = cx - w / 2, y1 = cy - h / 2;
+    rect_last.x = cvFloor(x1 * crop_size + x0);
+    rect_last.y = cvFloor(y1 * crop_size + y0);
+    rect_last.width = cvFloor(w * crop_size);
+    rect_last.height = cvFloor(h * crop_size);
+}
+
+void TrackerVitImpl::init(InputArray image_, const Rect &boundingBox_)
+{
+    Mat image = image_.getMat();
+    Mat crop;
+    crop_image(image, crop, boundingBox_, 2);
+    Mat blob;
+    preprocess(crop, blob, templateSize);
+    net.setInput(blob, "template");
+    Size size(16, 16);
+    hanningWindow = hann2d(size, true);
+    rect_last = boundingBox_;
+}
+
+bool TrackerVitImpl::update(InputArray image_, Rect &boundingBoxRes)
+{
+    Mat image = image_.getMat();
+    Mat crop;
+    int crop_size = crop_image(image, crop, rect_last, 4); // crop: [crop_size, crop_size]
+    Mat blob;
+    preprocess(crop, blob, searchSize);
+    net.setInput(blob, "search");
+    std::vector<String> outputName = {"output1", "output2", "output3"};
+    std::vector<Mat> outs;
+    net.forward(outs, outputName);
+    CV_Assert(outs.size() == 3);
+
+    Mat conf_map = outs[0].reshape(0, {16, 16});
+    Mat size_map = outs[1].reshape(0, {2, 16, 16});
+    Mat offset_map = outs[2].reshape(0, {2, 16, 16});
+
+    multiply(conf_map, hanningWindow, conf_map);
+
+    double maxVal;
+    Point maxLoc;
+    minMaxLoc(conf_map, nullptr, &maxVal, nullptr, &maxLoc);
+    tracking_score = static_cast<float>(maxVal);
+
+    if (tracking_score >= tracking_score_threshold) {
+        float cx = (maxLoc.x + offset_map.at<float>(0, maxLoc.y, maxLoc.x)) / 16;
+        float cy = (maxLoc.y + offset_map.at<float>(1, maxLoc.y, maxLoc.x)) / 16;
+        float w = size_map.at<float>(0, maxLoc.y, maxLoc.x);
+        float h = size_map.at<float>(1, maxLoc.y, maxLoc.x);
+
+        updateLastRect(cx, cy, w, h, crop_size, rect_last);
+        boundingBoxRes = rect_last;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+float TrackerVitImpl::getTrackingScore()
+{
+    return tracking_score;
+}
+
+Ptr<TrackerVit> TrackerVit::create(const TrackerVit::Params& parameters)
+{
+    return makePtr<TrackerVitImpl>(parameters);
+}
+
+Ptr<TrackerVit> TrackerVit::create(const dnn::Net& model, Scalar meanvalue, Scalar stdvalue, float tracking_score_threshold)
+{
+    return makePtr<TrackerVitImpl>(model, meanvalue, stdvalue, tracking_score_threshold);
+}
+
+#else  // OPENCV_HAVE_DNN
+Ptr<TrackerVit> TrackerVit::create(const TrackerVit::Params& parameters)
+{
+    CV_UNUSED(parameters);
+    CV_Error(Error::StsNotImplemented, "to use vittrack, the tracking module needs to be built with opencv_dnn !");
+}
+#endif  // OPENCV_HAVE_DNN
+}
diff --git a/upstream/opencv/modules/video/src/variational_refinement.cpp b/upstream/opencv/modules/video/src/variational_refinement.cpp
new file mode 100644
index 0000000..b1891c6
--- /dev/null
+++ b/upstream/opencv/modules/video/src/variational_refinement.cpp
@@ -0,0 +1,1241 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+#include "opencv2/core/hal/intrin.hpp"
+
+using namespace std;
+
+namespace cv
+{
+
+class VariationalRefinementImpl CV_FINAL : public VariationalRefinement
+{
+  public:
+    VariationalRefinementImpl();
+
+    void calc(InputArray I0, InputArray I1, InputOutputArray flow) CV_OVERRIDE;
+    void calcUV(InputArray I0, InputArray I1, InputOutputArray flow_u, InputOutputArray flow_v) CV_OVERRIDE;
+    void collectGarbage() CV_OVERRIDE;
+
+  protected: //!< algorithm parameters
+    int fixedPointIterations, sorIterations;
+    float omega;
+    float alpha, delta, gamma;
+    float zeta, epsilon;
+
+  public:
+    int getFixedPointIterations() const CV_OVERRIDE { return fixedPointIterations; }
+    void setFixedPointIterations(int val) CV_OVERRIDE { fixedPointIterations = val; }
+    int getSorIterations() const CV_OVERRIDE { return sorIterations; }
+    void setSorIterations(int val) CV_OVERRIDE { sorIterations = val; }
+    float getOmega() const CV_OVERRIDE { return omega; }
+    void setOmega(float val) CV_OVERRIDE { omega = val; }
+    float getAlpha() const CV_OVERRIDE { return alpha; }
+    void setAlpha(float val) CV_OVERRIDE { alpha = val; }
+    float getDelta() const CV_OVERRIDE { return delta; }
+    void setDelta(float val) CV_OVERRIDE { delta = val; }
+    float getGamma() const CV_OVERRIDE { return gamma; }
+    void setGamma(float val) CV_OVERRIDE { gamma = val; }
+    float getEpsilon() const CV_OVERRIDE { return epsilon; }
+    void setEpsilon(float val) CV_OVERRIDE { epsilon = val; }
+
+  protected: //!< internal buffers
+    /* This struct defines a special data layout for Mat_<float>. Original buffer is split into two: one for "red"
+     * elements (sum of indices is even) and one for "black" (sum of indices is odd) in a checkerboard pattern. It
+     * allows for more efficient processing in SOR iterations, more natural SIMD vectorization and parallelization
+     * (Red-Black SOR). Additionally, it simplifies border handling by adding repeated borders to both red and
+     * black buffers.
+     */
+    struct RedBlackBuffer
+    {
+        Mat_<float> red;   //!< (i+j)%2==0
+        Mat_<float> black; //!< (i+j)%2==1
+
+        /* Width of even and odd rows may be different */
+        int red_even_len, red_odd_len;
+        int black_even_len, black_odd_len;
+
+        RedBlackBuffer();
+        void create(Size s);
+        void release();
+    };
+
+    Mat_<float> Ix, Iy, Iz, Ixx, Ixy, Iyy, Ixz, Iyz;                            //!< image derivative buffers
+    RedBlackBuffer Ix_rb, Iy_rb, Iz_rb, Ixx_rb, Ixy_rb, Iyy_rb, Ixz_rb, Iyz_rb; //!< corresponding red-black buffers
+
+    RedBlackBuffer A11, A12, A22, b1, b2; //!< main linear system coefficients
+    RedBlackBuffer weights;               //!< smoothness term weights in the current fixed point iteration
+
+    Mat_<float> mapX, mapY; //!< auxiliary buffers for remapping
+
+    RedBlackBuffer tempW_u, tempW_v; //!< flow buffers that are modified in each fixed point iteration
+    RedBlackBuffer dW_u, dW_v;       //!< optical flow increment
+    RedBlackBuffer W_u_rb, W_v_rb;   //!< red-black-buffer version of the input flow
+
+  private: //!< private methods and parallel sections
+    void splitCheckerboard(RedBlackBuffer &dst, Mat &src);
+    void mergeCheckerboard(Mat &dst, RedBlackBuffer &src);
+    void updateRepeatedBorders(RedBlackBuffer &dst);
+    void warpImage(Mat &dst, Mat &src, Mat &flow_u, Mat &flow_v);
+    void prepareBuffers(Mat &I0, Mat &I1, Mat &W_u, Mat &W_v);
+
+    /* Parallelizing arbitrary operations with 3 input/output arguments */
+    typedef void (VariationalRefinementImpl::*Op)(void *op1, void *op2, void *op3);
+    struct ParallelOp_ParBody : public ParallelLoopBody
+    {
+        VariationalRefinementImpl *var;
+        vector<Op> ops;
+        vector<void *> op1s;
+        vector<void *> op2s;
+        vector<void *> op3s;
+
+        ParallelOp_ParBody(VariationalRefinementImpl &_var, vector<Op> _ops, vector<void *> &_op1s,
+                           vector<void *> &_op2s, vector<void *> &_op3s);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+    void gradHorizAndSplitOp(void *src, void *dst, void *dst_split)
+    {
+        CV_INSTRUMENT_REGION();
+
+        Sobel(*(Mat *)src, *(Mat *)dst, -1, 1, 0, 1, 1, 0.00, BORDER_REPLICATE);
+        splitCheckerboard(*(RedBlackBuffer *)dst_split, *(Mat *)dst);
+    }
+    void gradVertAndSplitOp(void *src, void *dst, void *dst_split)
+    {
+        CV_INSTRUMENT_REGION();
+
+        Sobel(*(Mat *)src, *(Mat *)dst, -1, 0, 1, 1, 1, 0.00, BORDER_REPLICATE);
+        splitCheckerboard(*(RedBlackBuffer *)dst_split, *(Mat *)dst);
+    }
+    void averageOp(void *src1, void *src2, void *dst)
+    {
+        CV_INSTRUMENT_REGION();
+
+        addWeighted(*(Mat *)src1, 0.5, *(Mat *)src2, 0.5, 0.0, *(Mat *)dst, CV_32F);
+    }
+    void subtractOp(void *src1, void *src2, void *dst)
+    {
+        CV_INSTRUMENT_REGION();
+
+        subtract(*(Mat *)src1, *(Mat *)src2, *(Mat *)dst, noArray(), CV_32F);
+    }
+
+    struct ComputeDataTerm_ParBody : public ParallelLoopBody
+    {
+        VariationalRefinementImpl *var;
+        int nstripes, stripe_sz;
+        int h;
+        RedBlackBuffer *dW_u, *dW_v;
+        bool red_pass;
+
+        ComputeDataTerm_ParBody(VariationalRefinementImpl &_var, int _nstripes, int _h, RedBlackBuffer &_dW_u,
+                                RedBlackBuffer &_dW_v, bool _red_pass);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+
+    struct ComputeSmoothnessTermHorPass_ParBody : public ParallelLoopBody
+    {
+        VariationalRefinementImpl *var;
+        int nstripes, stripe_sz;
+        int h;
+        RedBlackBuffer *W_u, *W_v, *curW_u, *curW_v;
+        bool red_pass;
+
+        ComputeSmoothnessTermHorPass_ParBody(VariationalRefinementImpl &_var, int _nstripes, int _h,
+                                             RedBlackBuffer &_W_u, RedBlackBuffer &_W_v, RedBlackBuffer &_tempW_u,
+                                             RedBlackBuffer &_tempW_v, bool _red_pass);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+
+    struct ComputeSmoothnessTermVertPass_ParBody : public ParallelLoopBody
+    {
+        VariationalRefinementImpl *var;
+        int nstripes, stripe_sz;
+        int h;
+        RedBlackBuffer *W_u, *W_v;
+        bool red_pass;
+
+        ComputeSmoothnessTermVertPass_ParBody(VariationalRefinementImpl &_var, int _nstripes, int _h,
+                                              RedBlackBuffer &W_u, RedBlackBuffer &_W_v, bool _red_pass);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+
+    struct RedBlackSOR_ParBody : public ParallelLoopBody
+    {
+        VariationalRefinementImpl *var;
+        int nstripes, stripe_sz;
+        int h;
+        RedBlackBuffer *dW_u, *dW_v;
+        bool red_pass;
+
+        RedBlackSOR_ParBody(VariationalRefinementImpl &_var, int _nstripes, int _h, RedBlackBuffer &_dW_u,
+                            RedBlackBuffer &_dW_v, bool _red_pass);
+        void operator()(const Range &range) const CV_OVERRIDE;
+    };
+};
+
+VariationalRefinementImpl::VariationalRefinementImpl()
+{
+    CV_INSTRUMENT_REGION();
+
+    fixedPointIterations = 5;
+    sorIterations = 5;
+    alpha = 20.0f;
+    delta = 5.0f;
+    gamma = 10.0f;
+    omega = 1.6f;
+    zeta = 0.1f;
+    epsilon = 0.001f;
+}
+
+/* This function converts an input Mat into the RedBlackBuffer format, which involves
+ * splitting the input buffer into two and adding repeated borders. Assumes that enough
+ * memory in dst is already allocated.
+ */
+void VariationalRefinementImpl::splitCheckerboard(RedBlackBuffer &dst, Mat &src)
+{
+    CV_INSTRUMENT_REGION();
+
+    int buf_j, j;
+    int buf_w = (int)ceil(src.cols / 2.0) + 2; //!< max width of red/black buffers with borders
+
+    /* Rows of red and black buffers can have different actual width, some extra repeated values are
+     * added for padding in such cases.
+     */
+    for (int i = 0; i < src.rows; i++)
+    {
+        float *src_buf = src.ptr<float>(i);
+        float *r_buf = dst.red.ptr<float>(i + 1);
+        float *b_buf = dst.black.ptr<float>(i + 1);
+        r_buf[0] = b_buf[0] = src_buf[0];
+        buf_j = 1;
+        if (i % 2 == 0)
+        {
+            for (j = 0; j < src.cols - 1; j += 2)
+            {
+                r_buf[buf_j] = src_buf[j];
+                b_buf[buf_j] = src_buf[j + 1];
+                buf_j++;
+            }
+            if (j < src.cols)
+                r_buf[buf_j] = b_buf[buf_j] = src_buf[j];
+            else
+                j--;
+        }
+        else
+        {
+            for (j = 0; j < src.cols - 1; j += 2)
+            {
+                b_buf[buf_j] = src_buf[j];
+                r_buf[buf_j] = src_buf[j + 1];
+                buf_j++;
+            }
+            if (j < src.cols)
+                r_buf[buf_j] = b_buf[buf_j] = src_buf[j];
+            else
+                j--;
+        }
+        r_buf[buf_w - 1] = b_buf[buf_w - 1] = src_buf[j];
+    }
+
+    /* Fill top and bottom borders: */
+    {
+        float *r_buf_border = dst.red.ptr<float>(dst.red.rows - 1);
+        float *b_buf_border = dst.black.ptr<float>(dst.black.rows - 1);
+        float *r_buf = dst.red.ptr<float>(dst.red.rows - 2);
+        float *b_buf = dst.black.ptr<float>(dst.black.rows - 2);
+        memcpy(r_buf_border, b_buf, buf_w * sizeof(float));
+        memcpy(b_buf_border, r_buf, buf_w * sizeof(float));
+    }
+    {
+        float *r_buf_border = dst.red.ptr<float>(0);
+        float *b_buf_border = dst.black.ptr<float>(0);
+        float *r_buf = dst.red.ptr<float>(1);
+        float *b_buf = dst.black.ptr<float>(1);
+        memcpy(r_buf_border, b_buf, buf_w * sizeof(float));
+        memcpy(b_buf_border, r_buf, buf_w * sizeof(float));
+    }
+}
+
+/* The inverse of splitCheckerboard, i.e. converting the RedBlackBuffer back into Mat.
+ * Assumes that enough memory in dst is already allocated.
+ */
+void VariationalRefinementImpl::mergeCheckerboard(Mat &dst, RedBlackBuffer &src)
+{
+    CV_INSTRUMENT_REGION();
+
+    int buf_j, j;
+    for (int i = 0; i < dst.rows; i++)
+    {
+        float *src_r_buf = src.red.ptr<float>(i + 1);
+        float *src_b_buf = src.black.ptr<float>(i + 1);
+        float *dst_buf = dst.ptr<float>(i);
+        buf_j = 1;
+
+        if (i % 2 == 0)
+        {
+            for (j = 0; j < dst.cols - 1; j += 2)
+            {
+                dst_buf[j] = src_r_buf[buf_j];
+                dst_buf[j + 1] = src_b_buf[buf_j];
+                buf_j++;
+            }
+            if (j < dst.cols)
+                dst_buf[j] = src_r_buf[buf_j];
+        }
+        else
+        {
+            for (j = 0; j < dst.cols - 1; j += 2)
+            {
+                dst_buf[j] = src_b_buf[buf_j];
+                dst_buf[j + 1] = src_r_buf[buf_j];
+                buf_j++;
+            }
+            if (j < dst.cols)
+                dst_buf[j] = src_b_buf[buf_j];
+        }
+    }
+}
+
+/* An auxiliary function that updates the borders. Used to enforce that border values repeat
+ * the ones adjacent to the border.
+ */
+void VariationalRefinementImpl::updateRepeatedBorders(RedBlackBuffer &dst)
+{
+    CV_INSTRUMENT_REGION();
+
+    int buf_w = dst.red.cols;
+    for (int i = 0; i < dst.red.rows - 2; i++)
+    {
+        float *r_buf = dst.red.ptr<float>(i + 1);
+        float *b_buf = dst.black.ptr<float>(i + 1);
+
+        if (i % 2 == 0)
+        {
+            b_buf[0] = r_buf[1];
+            if (dst.red_even_len > dst.black_even_len)
+                b_buf[dst.black_even_len + 1] = r_buf[dst.red_even_len];
+            else
+                r_buf[dst.red_even_len + 1] = b_buf[dst.black_even_len];
+        }
+        else
+        {
+            r_buf[0] = b_buf[1];
+            if (dst.red_odd_len < dst.black_odd_len)
+                r_buf[dst.red_odd_len + 1] = b_buf[dst.black_odd_len];
+            else
+                b_buf[dst.black_odd_len + 1] = r_buf[dst.red_odd_len];
+        }
+    }
+    {
+        float *r_buf_border = dst.red.ptr<float>(dst.red.rows - 1);
+        float *b_buf_border = dst.black.ptr<float>(dst.black.rows - 1);
+        float *r_buf = dst.red.ptr<float>(dst.red.rows - 2);
+        float *b_buf = dst.black.ptr<float>(dst.black.rows - 2);
+        memcpy(r_buf_border, b_buf, buf_w * sizeof(float));
+        memcpy(b_buf_border, r_buf, buf_w * sizeof(float));
+    }
+    {
+        float *r_buf_border = dst.red.ptr<float>(0);
+        float *b_buf_border = dst.black.ptr<float>(0);
+        float *r_buf = dst.red.ptr<float>(1);
+        float *b_buf = dst.black.ptr<float>(1);
+        memcpy(r_buf_border, b_buf, buf_w * sizeof(float));
+        memcpy(b_buf_border, r_buf, buf_w * sizeof(float));
+    }
+}
+
+VariationalRefinementImpl::RedBlackBuffer::RedBlackBuffer()
+{
+    CV_INSTRUMENT_REGION();
+
+    release();
+}
+void VariationalRefinementImpl::RedBlackBuffer::create(Size s)
+{
+    CV_INSTRUMENT_REGION();
+
+    /* Allocate enough memory to include borders */
+    int w = (int)ceil(s.width / 2.0) + 2;
+    red.create(s.height + 2, w);
+    black.create(s.height + 2, w);
+
+    if (s.width % 2 == 0)
+        red_even_len = red_odd_len = black_even_len = black_odd_len = w - 2;
+    else
+    {
+        red_even_len = black_odd_len = w - 2;
+        red_odd_len = black_even_len = w - 3;
+    }
+}
+
+void VariationalRefinementImpl::RedBlackBuffer::release()
+{
+    CV_INSTRUMENT_REGION();
+
+    red.release();
+    black.release();
+    red_even_len = red_odd_len = black_even_len = black_odd_len = 0;
+}
+
+VariationalRefinementImpl::ParallelOp_ParBody::ParallelOp_ParBody(VariationalRefinementImpl &_var, vector<Op> _ops,
+                                                                  vector<void *> &_op1s, vector<void *> &_op2s,
+                                                                  vector<void *> &_op3s)
+    : var(&_var), ops(_ops), op1s(_op1s), op2s(_op2s), op3s(_op3s)
+{
+}
+
+void VariationalRefinementImpl::ParallelOp_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    for (int i = range.start; i < range.end; i++)
+        (var->*ops[i])(op1s[i], op2s[i], op3s[i]);
+}
+
+void VariationalRefinementImpl::warpImage(Mat &dst, Mat &src, Mat &flow_u, Mat &flow_v)
+{
+    CV_INSTRUMENT_REGION();
+
+    for (int i = 0; i < flow_u.rows; i++)
+    {
+        float *pFlowU = flow_u.ptr<float>(i);
+        float *pFlowV = flow_v.ptr<float>(i);
+        float *pMapX = mapX.ptr<float>(i);
+        float *pMapY = mapY.ptr<float>(i);
+        for (int j = 0; j < flow_u.cols; j++)
+        {
+            pMapX[j] = j + pFlowU[j];
+            pMapY[j] = i + pFlowV[j];
+        }
+    }
+    remap(src, dst, mapX, mapY, INTER_LINEAR, BORDER_REPLICATE);
+}
+
+void VariationalRefinementImpl::prepareBuffers(Mat &I0, Mat &I1, Mat &W_u, Mat &W_v)
+{
+    CV_INSTRUMENT_REGION();
+
+    Size s = I0.size();
+    A11.create(s);
+    A12.create(s);
+    A22.create(s);
+    b1.create(s);
+    b2.create(s);
+    weights.create(s);
+    weights.red.setTo(0.0f);
+    weights.black.setTo(0.0f);
+    tempW_u.create(s);
+    tempW_v.create(s);
+    dW_u.create(s);
+    dW_v.create(s);
+    W_u_rb.create(s);
+    W_v_rb.create(s);
+
+    Ix.create(s);
+    Iy.create(s);
+    Iz.create(s);
+    Ixx.create(s);
+    Ixy.create(s);
+    Iyy.create(s);
+    Ixz.create(s);
+    Iyz.create(s);
+
+    Ix_rb.create(s);
+    Iy_rb.create(s);
+    Iz_rb.create(s);
+    Ixx_rb.create(s);
+    Ixy_rb.create(s);
+    Iyy_rb.create(s);
+    Ixz_rb.create(s);
+    Iyz_rb.create(s);
+
+    mapX.create(s);
+    mapY.create(s);
+
+    /* Floating point warps work significantly better than fixed-point */
+    Mat I1flt, warpedI;
+    I1.convertTo(I1flt, CV_32F);
+    warpImage(warpedI, I1flt, W_u, W_v);
+
+    /* Computing an average of the current and warped next frames (to compute the derivatives on) and
+     * temporal derivative Iz
+     */
+    Mat averagedI;
+    {
+        vector<void *> op1s;
+        op1s.push_back((void *)&I0);
+        op1s.push_back((void *)&warpedI);
+        vector<void *> op2s;
+        op2s.push_back((void *)&warpedI);
+        op2s.push_back((void *)&I0);
+        vector<void *> op3s;
+        op3s.push_back((void *)&averagedI);
+        op3s.push_back((void *)&Iz);
+        vector<Op> ops;
+        ops.push_back(&VariationalRefinementImpl::averageOp);
+        ops.push_back(&VariationalRefinementImpl::subtractOp);
+        parallel_for_(Range(0, 2), ParallelOp_ParBody(*this, ops, op1s, op2s, op3s));
+    }
+    splitCheckerboard(Iz_rb, Iz);
+
+    /* Computing first-order derivatives */
+    {
+        vector<void *> op1s;
+        op1s.push_back((void *)&averagedI);
+        op1s.push_back((void *)&averagedI);
+        op1s.push_back((void *)&Iz);
+        op1s.push_back((void *)&Iz);
+        vector<void *> op2s;
+        op2s.push_back((void *)&Ix);
+        op2s.push_back((void *)&Iy);
+        op2s.push_back((void *)&Ixz);
+        op2s.push_back((void *)&Iyz);
+        vector<void *> op3s;
+        op3s.push_back((void *)&Ix_rb);
+        op3s.push_back((void *)&Iy_rb);
+        op3s.push_back((void *)&Ixz_rb);
+        op3s.push_back((void *)&Iyz_rb);
+        vector<Op> ops;
+        ops.push_back(&VariationalRefinementImpl::gradHorizAndSplitOp);
+        ops.push_back(&VariationalRefinementImpl::gradVertAndSplitOp);
+        ops.push_back(&VariationalRefinementImpl::gradHorizAndSplitOp);
+        ops.push_back(&VariationalRefinementImpl::gradVertAndSplitOp);
+        parallel_for_(Range(0, 4), ParallelOp_ParBody(*this, ops, op1s, op2s, op3s));
+    }
+
+    /* Computing second-order derivatives */
+    {
+        vector<void *> op1s;
+        op1s.push_back((void *)&Ix);
+        op1s.push_back((void *)&Ix);
+        op1s.push_back((void *)&Iy);
+        vector<void *> op2s;
+        op2s.push_back((void *)&Ixx);
+        op2s.push_back((void *)&Ixy);
+        op2s.push_back((void *)&Iyy);
+        vector<void *> op3s;
+        op3s.push_back((void *)&Ixx_rb);
+        op3s.push_back((void *)&Ixy_rb);
+        op3s.push_back((void *)&Iyy_rb);
+        vector<Op> ops;
+        ops.push_back(&VariationalRefinementImpl::gradHorizAndSplitOp);
+        ops.push_back(&VariationalRefinementImpl::gradVertAndSplitOp);
+        ops.push_back(&VariationalRefinementImpl::gradVertAndSplitOp);
+        parallel_for_(Range(0, 3), ParallelOp_ParBody(*this, ops, op1s, op2s, op3s));
+    }
+}
+
+VariationalRefinementImpl::ComputeDataTerm_ParBody::ComputeDataTerm_ParBody(VariationalRefinementImpl &_var,
+                                                                            int _nstripes, int _h,
+                                                                            RedBlackBuffer &_dW_u,
+                                                                            RedBlackBuffer &_dW_v, bool _red_pass)
+    : var(&_var), nstripes(_nstripes), h(_h), dW_u(&_dW_u), dW_v(&_dW_v), red_pass(_red_pass)
+{
+    stripe_sz = (int)ceil(h / (double)nstripes);
+}
+
+/* This function computes parts of the main linear system coefficients A11,A12,A22,b1,b1
+ * that correspond to the data term, which includes color and gradient constancy assumptions.
+ */
+void VariationalRefinementImpl::ComputeDataTerm_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    int start_i = min(range.start * stripe_sz, h);
+    int end_i = min(range.end * stripe_sz, h);
+
+    float zeta_squared = var->zeta * var->zeta;
+    float epsilon_squared = var->epsilon * var->epsilon;
+    float gamma2 = var->gamma / 2;
+    float delta2 = var->delta / 2;
+
+    float *pIx, *pIy, *pIz;
+    float *pIxx, *pIxy, *pIyy, *pIxz, *pIyz;
+    float *pdU, *pdV;
+    float *pa11, *pa12, *pa22, *pb1, *pb2;
+
+    float derivNorm, derivNorm2;
+    float Ik1z, Ik1zx, Ik1zy;
+    float weight;
+    int len;
+    for (int i = start_i; i < end_i; i++)
+    {
+#define INIT_ROW_POINTERS(color)                                                                                       \
+    pIx = var->Ix_rb.color.ptr<float>(i + 1) + 1;                                                                      \
+    pIy = var->Iy_rb.color.ptr<float>(i + 1) + 1;                                                                      \
+    pIz = var->Iz_rb.color.ptr<float>(i + 1) + 1;                                                                      \
+    pIxx = var->Ixx_rb.color.ptr<float>(i + 1) + 1;                                                                    \
+    pIxy = var->Ixy_rb.color.ptr<float>(i + 1) + 1;                                                                    \
+    pIyy = var->Iyy_rb.color.ptr<float>(i + 1) + 1;                                                                    \
+    pIxz = var->Ixz_rb.color.ptr<float>(i + 1) + 1;                                                                    \
+    pIyz = var->Iyz_rb.color.ptr<float>(i + 1) + 1;                                                                    \
+    pa11 = var->A11.color.ptr<float>(i + 1) + 1;                                                                       \
+    pa12 = var->A12.color.ptr<float>(i + 1) + 1;                                                                       \
+    pa22 = var->A22.color.ptr<float>(i + 1) + 1;                                                                       \
+    pb1 = var->b1.color.ptr<float>(i + 1) + 1;                                                                         \
+    pb2 = var->b2.color.ptr<float>(i + 1) + 1;                                                                         \
+    pdU = dW_u->color.ptr<float>(i + 1) + 1;                                                                           \
+    pdV = dW_v->color.ptr<float>(i + 1) + 1;                                                                           \
+    if (i % 2 == 0)                                                                                                    \
+        len = var->Ix_rb.color##_even_len;                                                                             \
+    else                                                                                                               \
+        len = var->Ix_rb.color##_odd_len;
+
+        if (red_pass)
+        {
+            INIT_ROW_POINTERS(red);
+        }
+        else
+        {
+            INIT_ROW_POINTERS(black);
+        }
+#undef INIT_ROW_POINTERS
+
+        int j = 0;
+#if CV_SIMD128
+        v_float32x4 zeta_vec = v_setall_f32(zeta_squared);
+        v_float32x4 eps_vec = v_setall_f32(epsilon_squared);
+        v_float32x4 delta_vec = v_setall_f32(delta2);
+        v_float32x4 gamma_vec = v_setall_f32(gamma2);
+        v_float32x4 zero_vec = v_setall_f32(0.0f);
+        v_float32x4 pIx_vec, pIy_vec, pIz_vec, pdU_vec, pdV_vec;
+        v_float32x4 pIxx_vec, pIxy_vec, pIyy_vec, pIxz_vec, pIyz_vec;
+        v_float32x4 derivNorm_vec, derivNorm2_vec, weight_vec;
+        v_float32x4 Ik1z_vec, Ik1zx_vec, Ik1zy_vec;
+        v_float32x4 pa11_vec, pa12_vec, pa22_vec, pb1_vec, pb2_vec;
+
+        for (; j < len - 3; j += 4)
+        {
+            pIx_vec = v_load(pIx + j);
+            pIy_vec = v_load(pIy + j);
+            pIz_vec = v_load(pIz + j);
+            pdU_vec = v_load(pdU + j);
+            pdV_vec = v_load(pdV + j);
+
+            derivNorm_vec = v_add(v_add(v_mul(pIx_vec, pIx_vec), v_mul(pIy_vec, pIy_vec)), zeta_vec);
+            Ik1z_vec = v_add(v_add(pIz_vec, v_mul(pIx_vec, pdU_vec)), v_mul(pIy_vec, pdV_vec));
+            weight_vec = v_div(v_div(delta_vec, v_sqrt(v_add(v_div(v_mul(Ik1z_vec, Ik1z_vec), derivNorm_vec), eps_vec))), derivNorm_vec);
+
+            pa11_vec = v_add(v_mul(weight_vec, v_mul(pIx_vec, pIx_vec)), zeta_vec);
+            pa12_vec = v_mul(weight_vec, v_mul(pIx_vec, pIy_vec));
+            pa22_vec = v_add(v_mul(weight_vec, v_mul(pIy_vec, pIy_vec)), zeta_vec);
+            pb1_vec = v_sub(zero_vec, v_mul(weight_vec, v_mul(pIz_vec, pIx_vec)));
+            pb2_vec = v_sub(zero_vec, v_mul(weight_vec, v_mul(pIz_vec, pIy_vec)));
+
+            pIxx_vec = v_load(pIxx + j);
+            pIxy_vec = v_load(pIxy + j);
+            pIyy_vec = v_load(pIyy + j);
+            pIxz_vec = v_load(pIxz + j);
+            pIyz_vec = v_load(pIyz + j);
+
+            derivNorm_vec = v_add(v_add(v_mul(pIxx_vec, pIxx_vec), v_mul(pIxy_vec, pIxy_vec)), zeta_vec);
+            derivNorm2_vec = v_add(v_add(v_mul(pIyy_vec, pIyy_vec), v_mul(pIxy_vec, pIxy_vec)), zeta_vec);
+            Ik1zx_vec = v_add(v_add(pIxz_vec, v_mul(pIxx_vec, pdU_vec)), v_mul(pIxy_vec, pdV_vec));
+            Ik1zy_vec = v_add(v_add(pIyz_vec, v_mul(pIxy_vec, pdU_vec)), v_mul(pIyy_vec, pdV_vec));
+            weight_vec = v_div(gamma_vec, v_sqrt(v_add(v_add(v_div(v_mul(Ik1zx_vec, Ik1zx_vec), derivNorm_vec), v_div(v_mul(Ik1zy_vec, Ik1zy_vec), derivNorm2_vec)), eps_vec)));
+
+            pa11_vec = v_add(pa11_vec, v_mul(weight_vec, v_add(v_div(v_mul(pIxx_vec, pIxx_vec), derivNorm_vec), v_div(v_mul(pIxy_vec, pIxy_vec), derivNorm2_vec))));
+            pa12_vec = v_add(pa12_vec, v_mul(weight_vec, v_add(v_div(v_mul(pIxx_vec, pIxy_vec), derivNorm_vec), v_div(v_mul(pIxy_vec, pIyy_vec), derivNorm2_vec))));
+            pa22_vec = v_add(pa22_vec, v_mul(weight_vec, v_add(v_div(v_mul(pIxy_vec, pIxy_vec), derivNorm_vec), v_div(v_mul(pIyy_vec, pIyy_vec), derivNorm2_vec))));
+            pb1_vec = v_sub(pb1_vec, v_mul(weight_vec, v_add(v_div(v_mul(pIxx_vec, pIxz_vec), derivNorm_vec), v_div(v_mul(pIxy_vec, pIyz_vec), derivNorm2_vec))));
+            pb2_vec = v_sub(pb2_vec, v_mul(weight_vec, v_add(v_div(v_mul(pIxy_vec, pIxz_vec), derivNorm_vec), v_div(v_mul(pIyy_vec, pIyz_vec), derivNorm2_vec))));
+
+            v_store(pa11 + j, pa11_vec);
+            v_store(pa12 + j, pa12_vec);
+            v_store(pa22 + j, pa22_vec);
+            v_store(pb1 + j, pb1_vec);
+            v_store(pb2 + j, pb2_vec);
+        }
+#endif
+        for (; j < len; j++)
+        {
+            /* Step 1: Compute color constancy terms */
+            /* Normalization factor:*/
+            derivNorm = pIx[j] * pIx[j] + pIy[j] * pIy[j] + zeta_squared;
+            /* Color constancy penalty (computed by Taylor expansion):*/
+            Ik1z = pIz[j] + pIx[j] * pdU[j] + pIy[j] * pdV[j];
+            /* Weight of the color constancy term in the current fixed-point iteration divided by derivNorm: */
+            weight = (delta2 / sqrt(Ik1z * Ik1z / derivNorm + epsilon_squared)) / derivNorm;
+            /* Add respective color constancy terms to the linear system coefficients: */
+            pa11[j] = weight * (pIx[j] * pIx[j]) + zeta_squared;
+            pa12[j] = weight * (pIx[j] * pIy[j]);
+            pa22[j] = weight * (pIy[j] * pIy[j]) + zeta_squared;
+            pb1[j] = -weight * (pIz[j] * pIx[j]);
+            pb2[j] = -weight * (pIz[j] * pIy[j]);
+
+            /* Step 2: Compute gradient constancy terms */
+            /* Normalization factor for x gradient: */
+            derivNorm = pIxx[j] * pIxx[j] + pIxy[j] * pIxy[j] + zeta_squared;
+            /* Normalization factor for y gradient: */
+            derivNorm2 = pIyy[j] * pIyy[j] + pIxy[j] * pIxy[j] + zeta_squared;
+            /* Gradient constancy penalties (computed by Taylor expansion): */
+            Ik1zx = pIxz[j] + pIxx[j] * pdU[j] + pIxy[j] * pdV[j];
+            Ik1zy = pIyz[j] + pIxy[j] * pdU[j] + pIyy[j] * pdV[j];
+            /* Weight of the gradient constancy term in the current fixed-point iteration: */
+            weight = gamma2 / sqrt(Ik1zx * Ik1zx / derivNorm + Ik1zy * Ik1zy / derivNorm2 + epsilon_squared);
+            /* Add respective gradient constancy components to the linear system coefficients: */
+            pa11[j] += weight * (pIxx[j] * pIxx[j] / derivNorm + pIxy[j] * pIxy[j] / derivNorm2);
+            pa12[j] += weight * (pIxx[j] * pIxy[j] / derivNorm + pIxy[j] * pIyy[j] / derivNorm2);
+            pa22[j] += weight * (pIxy[j] * pIxy[j] / derivNorm + pIyy[j] * pIyy[j] / derivNorm2);
+            pb1[j] += -weight * (pIxx[j] * pIxz[j] / derivNorm + pIxy[j] * pIyz[j] / derivNorm2);
+            pb2[j] += -weight * (pIxy[j] * pIxz[j] / derivNorm + pIyy[j] * pIyz[j] / derivNorm2);
+        }
+    }
+}
+
+VariationalRefinementImpl::ComputeSmoothnessTermHorPass_ParBody::ComputeSmoothnessTermHorPass_ParBody(
+  VariationalRefinementImpl &_var, int _nstripes, int _h, RedBlackBuffer &_W_u, RedBlackBuffer &_W_v,
+  RedBlackBuffer &_tempW_u, RedBlackBuffer &_tempW_v, bool _red_pass)
+    : var(&_var), nstripes(_nstripes), h(_h), W_u(&_W_u), W_v(&_W_v), curW_u(&_tempW_u), curW_v(&_tempW_v),
+      red_pass(_red_pass)
+{
+    stripe_sz = (int)ceil(h / (double)nstripes);
+}
+
+/* This function updates the linear system coefficients A11,A22,b1,b1 according to the
+ * flow smoothness term and computes corresponding weights for the current fixed point iteration.
+ * A11,A22,b1,b1 are updated only partially (horizontal pass). Doing both horizontal and vertical
+ * passes in one loop complicates parallelization (different threads write to the same elements).
+ */
+void VariationalRefinementImpl::ComputeSmoothnessTermHorPass_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    int start_i = min(range.start * stripe_sz, h);
+    int end_i = min(range.end * stripe_sz, h);
+
+    float epsilon_squared = var->epsilon * var->epsilon;
+    float alpha2 = var->alpha / 2;
+    float *pWeight;
+    float *pA_u, *pA_u_next, *pA_v, *pA_v_next;
+    float *pB_u, *pB_u_next, *pB_v, *pB_v_next;
+    float *cW_u, *cW_u_next, *cW_u_next_row;
+    float *cW_v, *cW_v_next, *cW_v_next_row;
+    float *pW_u, *pW_u_next;
+    float *pW_v, *pW_v_next;
+    float ux, uy, vx, vy;
+    int len;
+    bool touches_right_border = true;
+
+#define INIT_ROW_POINTERS(cur_color, next_color, next_offs_even, next_offs_odd, bool_default)                          \
+    pWeight = var->weights.cur_color.ptr<float>(i + 1) + 1;                                                            \
+    pA_u = var->A11.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pB_u = var->b1.cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    cW_u = curW_u->cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    pW_u = W_u->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+    pA_v = var->A22.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pB_v = var->b2.cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    cW_v = curW_v->cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    pW_v = W_v->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+                                                                                                                       \
+    cW_u_next_row = curW_u->next_color.ptr<float>(i + 2) + 1;                                                          \
+    cW_v_next_row = curW_v->next_color.ptr<float>(i + 2) + 1;                                                          \
+                                                                                                                       \
+    if (i % 2 == 0)                                                                                                    \
+    {                                                                                                                  \
+        pA_u_next = var->A11.next_color.ptr<float>(i + 1) + next_offs_even;                                            \
+        pB_u_next = var->b1.next_color.ptr<float>(i + 1) + next_offs_even;                                             \
+        cW_u_next = curW_u->next_color.ptr<float>(i + 1) + next_offs_even;                                             \
+        pW_u_next = W_u->next_color.ptr<float>(i + 1) + next_offs_even;                                                \
+        pA_v_next = var->A22.next_color.ptr<float>(i + 1) + next_offs_even;                                            \
+        pB_v_next = var->b2.next_color.ptr<float>(i + 1) + next_offs_even;                                             \
+        cW_v_next = curW_v->next_color.ptr<float>(i + 1) + next_offs_even;                                             \
+        pW_v_next = W_v->next_color.ptr<float>(i + 1) + next_offs_even;                                                \
+        len = var->A11.cur_color##_even_len;                                                                           \
+        if (var->A11.cur_color##_even_len != var->A11.cur_color##_odd_len)                                             \
+            touches_right_border = bool_default;                                                                       \
+        else                                                                                                           \
+            touches_right_border = !bool_default;                                                                      \
+    }                                                                                                                  \
+    else                                                                                                               \
+    {                                                                                                                  \
+        pA_u_next = var->A11.next_color.ptr<float>(i + 1) + next_offs_odd;                                             \
+        pB_u_next = var->b1.next_color.ptr<float>(i + 1) + next_offs_odd;                                              \
+        cW_u_next = curW_u->next_color.ptr<float>(i + 1) + next_offs_odd;                                              \
+        pW_u_next = W_u->next_color.ptr<float>(i + 1) + next_offs_odd;                                                 \
+        pA_v_next = var->A22.next_color.ptr<float>(i + 1) + next_offs_odd;                                             \
+        pB_v_next = var->b2.next_color.ptr<float>(i + 1) + next_offs_odd;                                              \
+        cW_v_next = curW_v->next_color.ptr<float>(i + 1) + next_offs_odd;                                              \
+        pW_v_next = W_v->next_color.ptr<float>(i + 1) + next_offs_odd;                                                 \
+        len = var->A11.cur_color##_odd_len;                                                                            \
+        if (var->A11.cur_color##_even_len != var->A11.cur_color##_odd_len)                                             \
+            touches_right_border = !bool_default;                                                                      \
+        else                                                                                                           \
+            touches_right_border = bool_default;                                                                       \
+    }
+
+    for (int i = start_i; i < end_i; i++)
+    {
+        if (red_pass)
+        {
+            INIT_ROW_POINTERS(red, black, 1, 2, true);
+        }
+        else
+        {
+            INIT_ROW_POINTERS(black, red, 2, 1, false);
+        }
+#undef INIT_ROW_POINTERS
+
+#define COMPUTE                                                                                                        \
+    /* Gradients for the flow on the current fixed-point iteration: */                                                 \
+    ux = cW_u_next[j] - cW_u[j];                                                                                       \
+    vx = cW_v_next[j] - cW_v[j];                                                                                       \
+    uy = cW_u_next_row[j] - cW_u[j];                                                                                   \
+    vy = cW_v_next_row[j] - cW_v[j];                                                                                   \
+    /* Weight of the smoothness term in the current fixed-point iteration: */                                          \
+    pWeight[j] = alpha2 / sqrt(ux * ux + vx * vx + uy * uy + vy * vy + epsilon_squared);                               \
+    /* Gradients for initial raw flow multiplied by weight:*/                                                          \
+    ux = pWeight[j] * (pW_u_next[j] - pW_u[j]);                                                                        \
+    vx = pWeight[j] * (pW_v_next[j] - pW_v[j]);
+
+#define UPDATE                                                                                                         \
+    pB_u[j] += ux;                                                                                                     \
+    pA_u[j] += pWeight[j];                                                                                             \
+    pB_v[j] += vx;                                                                                                     \
+    pA_v[j] += pWeight[j];                                                                                             \
+    pB_u_next[j] -= ux;                                                                                                \
+    pA_u_next[j] += pWeight[j];                                                                                        \
+    pB_v_next[j] -= vx;                                                                                                \
+    pA_v_next[j] += pWeight[j];
+
+        int j = 0;
+#if CV_SIMD128
+        v_float32x4 alpha2_vec = v_setall_f32(alpha2);
+        v_float32x4 eps_vec = v_setall_f32(epsilon_squared);
+        v_float32x4 cW_u_vec, cW_v_vec;
+        v_float32x4 pWeight_vec, ux_vec, vx_vec, uy_vec, vy_vec;
+
+        for (; j < len - 4; j += 4)
+        {
+            cW_u_vec = v_load(cW_u + j);
+            cW_v_vec = v_load(cW_v + j);
+
+            ux_vec = v_sub(v_load(cW_u_next + j), cW_u_vec);
+            vx_vec = v_sub(v_load(cW_v_next + j), cW_v_vec);
+            uy_vec = v_sub(v_load(cW_u_next_row + j), cW_u_vec);
+            vy_vec = v_sub(v_load(cW_v_next_row + j), cW_v_vec);
+            pWeight_vec =
+              v_div(alpha2_vec, v_sqrt(v_add(v_add(v_add(v_add(v_mul(ux_vec, ux_vec), v_mul(vx_vec, vx_vec)), v_mul(uy_vec, uy_vec)), v_mul(vy_vec, vy_vec)), eps_vec)));
+            v_store(pWeight + j, pWeight_vec);
+
+            ux_vec = v_mul(pWeight_vec, v_sub(v_load(pW_u_next + j), v_load(pW_u + j)));
+            vx_vec = v_mul(pWeight_vec, v_sub(v_load(pW_v_next + j), v_load(pW_v + j)));
+
+            v_store(pA_u + j, v_add(v_load(pA_u + j), pWeight_vec));
+            v_store(pA_v + j, v_add(v_load(pA_v + j), pWeight_vec));
+            v_store(pB_u + j, v_add(v_load(pB_u + j), ux_vec));
+            v_store(pB_v + j, v_add(v_load(pB_v + j), vx_vec));
+
+            v_store(pA_u_next + j, v_add(v_load(pA_u_next + j), pWeight_vec));
+            v_store(pA_v_next + j, v_add(v_load(pA_v_next + j), pWeight_vec));
+            v_store(pB_u_next + j, v_sub(v_load(pB_u_next + j), ux_vec));
+            v_store(pB_v_next + j, v_sub(v_load(pB_v_next + j), vx_vec));
+        }
+#endif
+        for (; j < len - 1; j++)
+        {
+            COMPUTE;
+            UPDATE;
+        }
+
+        /* Omit the update on the rightmost elements */
+        if (touches_right_border)
+        {
+            COMPUTE;
+        }
+        else
+        {
+            COMPUTE;
+            UPDATE;
+        }
+    }
+#undef COMPUTE
+#undef UPDATE
+}
+
+VariationalRefinementImpl::ComputeSmoothnessTermVertPass_ParBody::ComputeSmoothnessTermVertPass_ParBody(
+  VariationalRefinementImpl &_var, int _nstripes, int _h, RedBlackBuffer &_W_u, RedBlackBuffer &_W_v, bool _red_pass)
+    : var(&_var), nstripes(_nstripes), W_u(&_W_u), W_v(&_W_v), red_pass(_red_pass)
+{
+    /* Omit the last row in the vertical pass */
+    h = _h - 1;
+    stripe_sz = (int)ceil(h / (double)nstripes);
+}
+
+/* This function adds the last remaining terms to the linear system coefficients A11,A22,b1,b1. */
+void VariationalRefinementImpl::ComputeSmoothnessTermVertPass_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    int start_i = min(range.start * stripe_sz, h);
+    int end_i = min(range.end * stripe_sz, h);
+
+    float *pWeight;
+    float *pA_u, *pA_u_next_row, *pA_v, *pA_v_next_row;
+    float *pB_u, *pB_u_next_row, *pB_v, *pB_v_next_row;
+    float *pW_u, *pW_u_next_row, *pW_v, *pW_v_next_row;
+    float vy, uy;
+    int len;
+
+    for (int i = start_i; i < end_i; i++)
+    {
+#define INIT_ROW_POINTERS(cur_color, next_color)                                                                       \
+    pWeight = var->weights.cur_color.ptr<float>(i + 1) + 1;                                                            \
+    pA_u = var->A11.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pB_u = var->b1.cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    pW_u = W_u->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+    pA_v = var->A22.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pB_v = var->b2.cur_color.ptr<float>(i + 1) + 1;                                                                    \
+    pW_v = W_v->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+                                                                                                                       \
+    pA_u_next_row = var->A11.next_color.ptr<float>(i + 2) + 1;                                                         \
+    pB_u_next_row = var->b1.next_color.ptr<float>(i + 2) + 1;                                                          \
+    pW_u_next_row = W_u->next_color.ptr<float>(i + 2) + 1;                                                             \
+    pA_v_next_row = var->A22.next_color.ptr<float>(i + 2) + 1;                                                         \
+    pB_v_next_row = var->b2.next_color.ptr<float>(i + 2) + 1;                                                          \
+    pW_v_next_row = W_v->next_color.ptr<float>(i + 2) + 1;                                                             \
+                                                                                                                       \
+    if (i % 2 == 0)                                                                                                    \
+        len = var->A11.cur_color##_even_len;                                                                           \
+    else                                                                                                               \
+        len = var->A11.cur_color##_odd_len;
+
+        if (red_pass)
+        {
+            INIT_ROW_POINTERS(red, black);
+        }
+        else
+        {
+            INIT_ROW_POINTERS(black, red);
+        }
+#undef INIT_ROW_POINTERS
+
+        int j = 0;
+#if CV_SIMD128
+        v_float32x4 pWeight_vec, uy_vec, vy_vec;
+        for (; j < len - 3; j += 4)
+        {
+            pWeight_vec = v_load(pWeight + j);
+            uy_vec = v_mul(pWeight_vec, v_sub(v_load(pW_u_next_row + j), v_load(pW_u + j)));
+            vy_vec = v_mul(pWeight_vec, v_sub(v_load(pW_v_next_row + j), v_load(pW_v + j)));
+
+            v_store(pA_u + j, v_add(v_load(pA_u + j), pWeight_vec));
+            v_store(pA_v + j, v_add(v_load(pA_v + j), pWeight_vec));
+            v_store(pB_u + j, v_add(v_load(pB_u + j), uy_vec));
+            v_store(pB_v + j, v_add(v_load(pB_v + j), vy_vec));
+
+            v_store(pA_u_next_row + j, v_add(v_load(pA_u_next_row + j), pWeight_vec));
+            v_store(pA_v_next_row + j, v_add(v_load(pA_v_next_row + j), pWeight_vec));
+            v_store(pB_u_next_row + j, v_sub(v_load(pB_u_next_row + j), uy_vec));
+            v_store(pB_v_next_row + j, v_sub(v_load(pB_v_next_row + j), vy_vec));
+        }
+#endif
+        for (; j < len; j++)
+        {
+            uy = pWeight[j] * (pW_u_next_row[j] - pW_u[j]);
+            vy = pWeight[j] * (pW_v_next_row[j] - pW_v[j]);
+            pB_u[j] += uy;
+            pA_u[j] += pWeight[j];
+            pB_v[j] += vy;
+            pA_v[j] += pWeight[j];
+            pB_u_next_row[j] -= uy;
+            pA_u_next_row[j] += pWeight[j];
+            pB_v_next_row[j] -= vy;
+            pA_v_next_row[j] += pWeight[j];
+        }
+    }
+}
+
+VariationalRefinementImpl::RedBlackSOR_ParBody::RedBlackSOR_ParBody(VariationalRefinementImpl &_var, int _nstripes,
+                                                                    int _h, RedBlackBuffer &_dW_u,
+                                                                    RedBlackBuffer &_dW_v, bool _red_pass)
+    : var(&_var), nstripes(_nstripes), h(_h), dW_u(&_dW_u), dW_v(&_dW_v), red_pass(_red_pass)
+{
+    stripe_sz = (int)ceil(h / (double)nstripes);
+}
+
+/* This function implements the Red-Black SOR (successive-over relaxation) method for solving the main
+ * linear system in the current fixed-point iteration.
+ */
+void VariationalRefinementImpl::RedBlackSOR_ParBody::operator()(const Range &range) const
+{
+    CV_INSTRUMENT_REGION();
+
+    int start = min(range.start * stripe_sz, h);
+    int end = min(range.end * stripe_sz, h);
+
+    float *pa11, *pa12, *pa22, *pb1, *pb2, *pW, *pdu, *pdv;
+    float *pW_next, *pdu_next, *pdv_next;
+    float *pW_prev_row, *pdu_prev_row, *pdv_prev_row;
+    float *pdu_next_row, *pdv_next_row;
+
+    float sigmaU, sigmaV;
+    int j, len;
+    for (int i = start; i < end; i++)
+    {
+#define INIT_ROW_POINTERS(cur_color, next_color, next_offs_even, next_offs_odd)                                        \
+    pW = var->weights.cur_color.ptr<float>(i + 1) + 1;                                                                 \
+    pa11 = var->A11.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pa12 = var->A12.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pa22 = var->A22.cur_color.ptr<float>(i + 1) + 1;                                                                   \
+    pb1 = var->b1.cur_color.ptr<float>(i + 1) + 1;                                                                     \
+    pb2 = var->b2.cur_color.ptr<float>(i + 1) + 1;                                                                     \
+    pdu = dW_u->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+    pdv = dW_v->cur_color.ptr<float>(i + 1) + 1;                                                                       \
+                                                                                                                       \
+    pdu_next_row = dW_u->next_color.ptr<float>(i + 2) + 1;                                                             \
+    pdv_next_row = dW_v->next_color.ptr<float>(i + 2) + 1;                                                             \
+                                                                                                                       \
+    pW_prev_row = var->weights.next_color.ptr<float>(i) + 1;                                                           \
+    pdu_prev_row = dW_u->next_color.ptr<float>(i) + 1;                                                                 \
+    pdv_prev_row = dW_v->next_color.ptr<float>(i) + 1;                                                                 \
+                                                                                                                       \
+    if (i % 2 == 0)                                                                                                    \
+    {                                                                                                                  \
+        pW_next = var->weights.next_color.ptr<float>(i + 1) + next_offs_even;                                          \
+        pdu_next = dW_u->next_color.ptr<float>(i + 1) + next_offs_even;                                                \
+        pdv_next = dW_v->next_color.ptr<float>(i + 1) + next_offs_even;                                                \
+        len = var->A11.cur_color##_even_len;                                                                           \
+    }                                                                                                                  \
+    else                                                                                                               \
+    {                                                                                                                  \
+        pW_next = var->weights.next_color.ptr<float>(i + 1) + next_offs_odd;                                           \
+        pdu_next = dW_u->next_color.ptr<float>(i + 1) + next_offs_odd;                                                 \
+        pdv_next = dW_v->next_color.ptr<float>(i + 1) + next_offs_odd;                                                 \
+        len = var->A11.cur_color##_odd_len;                                                                            \
+    }
+        if (red_pass)
+        {
+            INIT_ROW_POINTERS(red, black, 1, 2);
+        }
+        else
+        {
+            INIT_ROW_POINTERS(black, red, 2, 1);
+        }
+#undef INIT_ROW_POINTERS
+
+        j = 0;
+#if CV_SIMD128
+        v_float32x4 pW_prev_vec = v_setall_f32(pW_next[-1]);
+        v_float32x4 pdu_prev_vec = v_setall_f32(pdu_next[-1]);
+        v_float32x4 pdv_prev_vec = v_setall_f32(pdv_next[-1]);
+        v_float32x4 omega_vec = v_setall_f32(var->omega);
+        v_float32x4 pW_vec, pW_next_vec, pW_prev_row_vec;
+        v_float32x4 pdu_next_vec, pdu_prev_row_vec, pdu_next_row_vec;
+        v_float32x4 pdv_next_vec, pdv_prev_row_vec, pdv_next_row_vec;
+        v_float32x4 pW_shifted_vec, pdu_shifted_vec, pdv_shifted_vec;
+        v_float32x4 pa12_vec, sigmaU_vec, sigmaV_vec, pdu_vec, pdv_vec;
+        for (; j < len - 3; j += 4)
+        {
+            pW_vec = v_load(pW + j);
+            pW_next_vec = v_load(pW_next + j);
+            pW_prev_row_vec = v_load(pW_prev_row + j);
+            pdu_next_vec = v_load(pdu_next + j);
+            pdu_prev_row_vec = v_load(pdu_prev_row + j);
+            pdu_next_row_vec = v_load(pdu_next_row + j);
+            pdv_next_vec = v_load(pdv_next + j);
+            pdv_prev_row_vec = v_load(pdv_prev_row + j);
+            pdv_next_row_vec = v_load(pdv_next_row + j);
+            pa12_vec = v_load(pa12 + j);
+            pW_shifted_vec = v_reinterpret_as_f32(
+              v_extract<3>(v_reinterpret_as_s32(pW_prev_vec), v_reinterpret_as_s32(pW_next_vec)));
+            pdu_shifted_vec = v_reinterpret_as_f32(
+              v_extract<3>(v_reinterpret_as_s32(pdu_prev_vec), v_reinterpret_as_s32(pdu_next_vec)));
+            pdv_shifted_vec = v_reinterpret_as_f32(
+              v_extract<3>(v_reinterpret_as_s32(pdv_prev_vec), v_reinterpret_as_s32(pdv_next_vec)));
+
+            sigmaU_vec = v_add(v_add(v_add(v_mul(pW_shifted_vec, pdu_shifted_vec), v_mul(pW_vec, pdu_next_vec)), v_mul(pW_prev_row_vec, pdu_prev_row_vec)), v_mul(pW_vec, pdu_next_row_vec));
+            sigmaV_vec = v_add(v_add(v_add(v_mul(pW_shifted_vec, pdv_shifted_vec), v_mul(pW_vec, pdv_next_vec)), v_mul(pW_prev_row_vec, pdv_prev_row_vec)), v_mul(pW_vec, pdv_next_row_vec));
+
+            pdu_vec = v_load(pdu + j);
+            pdv_vec = v_load(pdv + j);
+            pdu_vec = v_add(pdu_vec, v_mul(omega_vec, v_sub(v_div(v_sub(v_add(sigmaU_vec, v_load(pb1 + j)), v_mul(pdv_vec, pa12_vec)), v_load(pa11 + j)), pdu_vec)));
+            pdv_vec = v_add(pdv_vec, v_mul(omega_vec, v_sub(v_div(v_sub(v_add(sigmaV_vec, v_load(pb2 + j)), v_mul(pdu_vec, pa12_vec)), v_load(pa22 + j)), pdv_vec)));
+            v_store(pdu + j, pdu_vec);
+            v_store(pdv + j, pdv_vec);
+
+            pW_prev_vec = pW_next_vec;
+            pdu_prev_vec = pdu_next_vec;
+            pdv_prev_vec = pdv_next_vec;
+        }
+#endif
+        for (; j < len; j++)
+        {
+            sigmaU = pW_next[j - 1] * pdu_next[j - 1] + pW[j] * pdu_next[j] + pW_prev_row[j] * pdu_prev_row[j] +
+                     pW[j] * pdu_next_row[j];
+            sigmaV = pW_next[j - 1] * pdv_next[j - 1] + pW[j] * pdv_next[j] + pW_prev_row[j] * pdv_prev_row[j] +
+                     pW[j] * pdv_next_row[j];
+            pdu[j] += var->omega * ((sigmaU + pb1[j] - pdv[j] * pa12[j]) / pa11[j] - pdu[j]);
+            pdv[j] += var->omega * ((sigmaV + pb2[j] - pdu[j] * pa12[j]) / pa22[j] - pdv[j]);
+        }
+    }
+}
+
+void VariationalRefinementImpl::calc(InputArray I0, InputArray I1, InputOutputArray flow)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!I0.empty() && I0.channels() == 1);
+    CV_Assert(!I1.empty() && I1.channels() == 1);
+    CV_Assert(I0.sameSize(I1));
+    CV_Assert((I0.depth() == CV_8U && I1.depth() == CV_8U) || (I0.depth() == CV_32F && I1.depth() == CV_32F));
+    CV_Assert(!flow.empty() && flow.depth() == CV_32F && flow.channels() == 2);
+    CV_Assert(I0.sameSize(flow));
+
+    Mat uv[2];
+    Mat &flowMat = flow.getMatRef();
+    split(flowMat, uv);
+    calcUV(I0, I1, uv[0], uv[1]);
+    merge(uv, 2, flowMat);
+}
+
+void VariationalRefinementImpl::calcUV(InputArray I0, InputArray I1, InputOutputArray flow_u, InputOutputArray flow_v)
+{
+    CV_INSTRUMENT_REGION();
+
+    CV_Assert(!I0.empty() && I0.channels() == 1);
+    CV_Assert(!I1.empty() && I1.channels() == 1);
+    CV_Assert(I0.sameSize(I1));
+    CV_Assert((I0.depth() == CV_8U && I1.depth() == CV_8U) || (I0.depth() == CV_32F && I1.depth() == CV_32F));
+    CV_Assert(!flow_u.empty() && flow_u.depth() == CV_32F && flow_u.channels() == 1);
+    CV_Assert(!flow_v.empty() && flow_v.depth() == CV_32F && flow_v.channels() == 1);
+    CV_Assert(I0.sameSize(flow_u));
+    CV_Assert(flow_u.sameSize(flow_v));
+
+    int num_stripes = getNumThreads();
+    Mat I0Mat = I0.getMat();
+    Mat I1Mat = I1.getMat();
+    Mat &W_u = flow_u.getMatRef();
+    Mat &W_v = flow_v.getMatRef();
+    prepareBuffers(I0Mat, I1Mat, W_u, W_v);
+
+    splitCheckerboard(W_u_rb, W_u);
+    splitCheckerboard(W_v_rb, W_v);
+    W_u_rb.red.copyTo(tempW_u.red);
+    W_u_rb.black.copyTo(tempW_u.black);
+    W_v_rb.red.copyTo(tempW_v.red);
+    W_v_rb.black.copyTo(tempW_v.black);
+    dW_u.red.setTo(0.0f);
+    dW_u.black.setTo(0.0f);
+    dW_v.red.setTo(0.0f);
+    dW_v.black.setTo(0.0f);
+
+    for (int i = 0; i < fixedPointIterations; i++)
+    {
+        CV_TRACE_REGION("fixedPoint_iteration");
+
+        parallel_for_(Range(0, num_stripes), ComputeDataTerm_ParBody(*this, num_stripes, I0Mat.rows, dW_u, dW_v, true));
+        parallel_for_(Range(0, num_stripes), ComputeDataTerm_ParBody(*this, num_stripes, I0Mat.rows, dW_u, dW_v, false));
+
+        parallel_for_(Range(0, num_stripes), ComputeSmoothnessTermHorPass_ParBody(
+                                               *this, num_stripes, I0Mat.rows, W_u_rb, W_v_rb, tempW_u, tempW_v, true));
+        parallel_for_(Range(0, num_stripes), ComputeSmoothnessTermHorPass_ParBody(
+                                               *this, num_stripes, I0Mat.rows, W_u_rb, W_v_rb, tempW_u, tempW_v, false));
+
+        parallel_for_(Range(0, num_stripes),
+                      ComputeSmoothnessTermVertPass_ParBody(*this, num_stripes, I0Mat.rows, W_u_rb, W_v_rb, true));
+        parallel_for_(Range(0, num_stripes),
+                      ComputeSmoothnessTermVertPass_ParBody(*this, num_stripes, I0Mat.rows, W_u_rb, W_v_rb, false));
+
+        for (int j = 0; j < sorIterations; j++)
+        {
+            CV_TRACE_REGION("SOR_iteration");
+            parallel_for_(Range(0, num_stripes), RedBlackSOR_ParBody(*this, num_stripes, I0Mat.rows, dW_u, dW_v, true));
+            parallel_for_(Range(0, num_stripes), RedBlackSOR_ParBody(*this, num_stripes, I0Mat.rows, dW_u, dW_v, false));
+        }
+
+        tempW_u.red = W_u_rb.red + dW_u.red;
+        tempW_u.black = W_u_rb.black + dW_u.black;
+        updateRepeatedBorders(tempW_u);
+        tempW_v.red = W_v_rb.red + dW_v.red;
+        tempW_v.black = W_v_rb.black + dW_v.black;
+        updateRepeatedBorders(tempW_v);
+    }
+    mergeCheckerboard(W_u, tempW_u);
+    mergeCheckerboard(W_v, tempW_v);
+}
+void VariationalRefinementImpl::collectGarbage()
+{
+    CV_INSTRUMENT_REGION();
+
+    Ix.release();
+    Iy.release();
+    Iz.release();
+    Ixx.release();
+    Ixy.release();
+    Iyy.release();
+    Ixz.release();
+    Iyz.release();
+
+    Ix_rb.release();
+    Iy_rb.release();
+    Iz_rb.release();
+    Ixx_rb.release();
+    Ixy_rb.release();
+    Iyy_rb.release();
+    Ixz_rb.release();
+    Iyz_rb.release();
+
+    A11.release();
+    A12.release();
+    A22.release();
+    b1.release();
+    b2.release();
+    weights.release();
+
+    mapX.release();
+    mapY.release();
+
+    tempW_u.release();
+    tempW_v.release();
+    dW_u.release();
+    dW_v.release();
+    W_u_rb.release();
+    W_v_rb.release();
+}
+
+Ptr<VariationalRefinement> VariationalRefinement::create()
+{ return makePtr<VariationalRefinementImpl>(); }
+
+}
diff --git a/third_party/opencv-5.0.0/modules/videoio/CMakeLists.txt b/upstream/opencv/modules/videoio/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/CMakeLists.txt
rename to upstream/opencv/modules/videoio/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_android_camera.cmake b/upstream/opencv/modules/videoio/cmake/detect_android_camera.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_android_camera.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_android_camera.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_android_mediandk.cmake b/upstream/opencv/modules/videoio/cmake/detect_android_mediandk.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_android_mediandk.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_android_mediandk.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_aravis.cmake b/upstream/opencv/modules/videoio/cmake/detect_aravis.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_aravis.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_aravis.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_avfoundation.cmake b/upstream/opencv/modules/videoio/cmake/detect_avfoundation.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_avfoundation.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_avfoundation.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_dc1394.cmake b/upstream/opencv/modules/videoio/cmake/detect_dc1394.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_dc1394.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_dc1394.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_dshow.cmake b/upstream/opencv/modules/videoio/cmake/detect_dshow.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_dshow.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_dshow.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_ffmpeg.cmake b/upstream/opencv/modules/videoio/cmake/detect_ffmpeg.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_ffmpeg.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_ffmpeg.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_gphoto.cmake b/upstream/opencv/modules/videoio/cmake/detect_gphoto.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_gphoto.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_gphoto.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_gstreamer.cmake b/upstream/opencv/modules/videoio/cmake/detect_gstreamer.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_gstreamer.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_gstreamer.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_ios.cmake b/upstream/opencv/modules/videoio/cmake/detect_ios.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_ios.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_ios.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_msdk.cmake b/upstream/opencv/modules/videoio/cmake/detect_msdk.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_msdk.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_msdk.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_msmf.cmake b/upstream/opencv/modules/videoio/cmake/detect_msmf.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_msmf.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_msmf.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_obsensor.cmake b/upstream/opencv/modules/videoio/cmake/detect_obsensor.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_obsensor.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_obsensor.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_openni2.cmake b/upstream/opencv/modules/videoio/cmake/detect_openni2.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_openni2.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_openni2.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_pvapi.cmake b/upstream/opencv/modules/videoio/cmake/detect_pvapi.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_pvapi.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_pvapi.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_realsense.cmake b/upstream/opencv/modules/videoio/cmake/detect_realsense.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_realsense.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_realsense.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_ueye.cmake b/upstream/opencv/modules/videoio/cmake/detect_ueye.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_ueye.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_ueye.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_v4l.cmake b/upstream/opencv/modules/videoio/cmake/detect_v4l.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_v4l.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_v4l.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_ximea.cmake b/upstream/opencv/modules/videoio/cmake/detect_ximea.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_ximea.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_ximea.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/detect_xine.cmake b/upstream/opencv/modules/videoio/cmake/detect_xine.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/detect_xine.cmake
rename to upstream/opencv/modules/videoio/cmake/detect_xine.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/init.cmake b/upstream/opencv/modules/videoio/cmake/init.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/init.cmake
rename to upstream/opencv/modules/videoio/cmake/init.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/cmake/plugin.cmake b/upstream/opencv/modules/videoio/cmake/plugin.cmake
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/cmake/plugin.cmake
rename to upstream/opencv/modules/videoio/cmake/plugin.cmake
diff --git a/third_party/opencv-5.0.0/modules/videoio/doc/pics/videoio_overview.svg b/upstream/opencv/modules/videoio/doc/pics/videoio_overview.svg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/doc/pics/videoio_overview.svg
rename to upstream/opencv/modules/videoio/doc/pics/videoio_overview.svg
diff --git a/third_party/opencv-5.0.0/modules/videoio/doc/videoio_overview.markdown b/upstream/opencv/modules/videoio/doc/videoio_overview.markdown
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/doc/videoio_overview.markdown
rename to upstream/opencv/modules/videoio/doc/videoio_overview.markdown
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/cap_ios.h b/upstream/opencv/modules/videoio/include/opencv2/videoio/cap_ios.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/cap_ios.h
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/cap_ios.h
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/cap_winrt.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/cap_winrt.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/cap_winrt.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/cap_winrt.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/container_avi.private.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/container_avi.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/container_avi.private.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/container_avi.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/doc/hwaccel.doc.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/registry.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/registry.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/registry.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/registry.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/utils.private.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/utils.private.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/utils.private.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/utils.private.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/videoio.hpp b/upstream/opencv/modules/videoio/include/opencv2/videoio/videoio.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/include/opencv2/videoio/videoio.hpp
rename to upstream/opencv/modules/videoio/include/opencv2/videoio/videoio.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/build_plugins.sh b/upstream/opencv/modules/videoio/misc/build_plugins.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/build_plugins.sh
rename to upstream/opencv/modules/videoio/misc/build_plugins.sh
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/gen_dict.json b/upstream/opencv/modules/videoio/misc/gen_dict.json
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/gen_dict.json
rename to upstream/opencv/modules/videoio/misc/gen_dict.json
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/CMakeLists.txt b/upstream/opencv/modules/videoio/misc/plugin_ffmpeg/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/CMakeLists.txt
rename to upstream/opencv/modules/videoio/misc/plugin_ffmpeg/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ffmpeg b/upstream/opencv/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ffmpeg
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ffmpeg
rename to upstream/opencv/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ffmpeg
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ubuntu b/upstream/opencv/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ubuntu
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ubuntu
rename to upstream/opencv/modules/videoio/misc/plugin_ffmpeg/Dockerfile-ubuntu
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/build-standalone.sh b/upstream/opencv/modules/videoio/misc/plugin_ffmpeg/build-standalone.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/build-standalone.sh
rename to upstream/opencv/modules/videoio/misc/plugin_ffmpeg/build-standalone.sh
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/build-ubuntu.sh b/upstream/opencv/modules/videoio/misc/plugin_ffmpeg/build-ubuntu.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_ffmpeg/build-ubuntu.sh
rename to upstream/opencv/modules/videoio/misc/plugin_ffmpeg/build-ubuntu.sh
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/CMakeLists.txt b/upstream/opencv/modules/videoio/misc/plugin_gstreamer/CMakeLists.txt
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/CMakeLists.txt
rename to upstream/opencv/modules/videoio/misc/plugin_gstreamer/CMakeLists.txt
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/Dockerfile b/upstream/opencv/modules/videoio/misc/plugin_gstreamer/Dockerfile
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/Dockerfile
rename to upstream/opencv/modules/videoio/misc/plugin_gstreamer/Dockerfile
diff --git a/third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/build.sh b/upstream/opencv/modules/videoio/misc/plugin_gstreamer/build.sh
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/misc/plugin_gstreamer/build.sh
rename to upstream/opencv/modules/videoio/misc/plugin_gstreamer/build.sh
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/backend.hpp b/upstream/opencv/modules/videoio/src/backend.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/backend.hpp
rename to upstream/opencv/modules/videoio/src/backend.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/backend_plugin.cpp b/upstream/opencv/modules/videoio/src/backend_plugin.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/backend_plugin.cpp
rename to upstream/opencv/modules/videoio/src/backend_plugin.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/backend_plugin_legacy.impl.hpp b/upstream/opencv/modules/videoio/src/backend_plugin_legacy.impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/backend_plugin_legacy.impl.hpp
rename to upstream/opencv/modules/videoio/src/backend_plugin_legacy.impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/backend_static.cpp b/upstream/opencv/modules/videoio/src/backend_static.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/backend_static.cpp
rename to upstream/opencv/modules/videoio/src/backend_static.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap.cpp b/upstream/opencv/modules/videoio/src/cap.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap.cpp
rename to upstream/opencv/modules/videoio/src/cap.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_android_camera.cpp b/upstream/opencv/modules/videoio/src/cap_android_camera.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_android_camera.cpp
rename to upstream/opencv/modules/videoio/src/cap_android_camera.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_android_mediandk.cpp b/upstream/opencv/modules/videoio/src/cap_android_mediandk.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_android_mediandk.cpp
rename to upstream/opencv/modules/videoio/src/cap_android_mediandk.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_aravis.cpp b/upstream/opencv/modules/videoio/src/cap_aravis.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_aravis.cpp
rename to upstream/opencv/modules/videoio/src/cap_aravis.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_avfoundation.mm b/upstream/opencv/modules/videoio/src/cap_avfoundation.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_avfoundation.mm
rename to upstream/opencv/modules/videoio/src/cap_avfoundation.mm
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_avfoundation_mac.mm b/upstream/opencv/modules/videoio/src/cap_avfoundation_mac.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_avfoundation_mac.mm
rename to upstream/opencv/modules/videoio/src/cap_avfoundation_mac.mm
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_dc1394_v2.cpp b/upstream/opencv/modules/videoio/src/cap_dc1394_v2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_dc1394_v2.cpp
rename to upstream/opencv/modules/videoio/src/cap_dc1394_v2.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_dshow.cpp b/upstream/opencv/modules/videoio/src/cap_dshow.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_dshow.cpp
rename to upstream/opencv/modules/videoio/src/cap_dshow.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_dshow.hpp b/upstream/opencv/modules/videoio/src/cap_dshow.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_dshow.hpp
rename to upstream/opencv/modules/videoio/src/cap_dshow.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg.cpp b/upstream/opencv/modules/videoio/src/cap_ffmpeg.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg.cpp
rename to upstream/opencv/modules/videoio/src/cap_ffmpeg.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_hw.hpp b/upstream/opencv/modules/videoio/src/cap_ffmpeg_hw.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_hw.hpp
rename to upstream/opencv/modules/videoio/src/cap_ffmpeg_hw.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_impl.hpp b/upstream/opencv/modules/videoio/src/cap_ffmpeg_impl.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_impl.hpp
rename to upstream/opencv/modules/videoio/src/cap_ffmpeg_impl.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_legacy_api.hpp b/upstream/opencv/modules/videoio/src/cap_ffmpeg_legacy_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ffmpeg_legacy_api.hpp
rename to upstream/opencv/modules/videoio/src/cap_ffmpeg_legacy_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_gphoto2.cpp b/upstream/opencv/modules/videoio/src/cap_gphoto2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_gphoto2.cpp
rename to upstream/opencv/modules/videoio/src/cap_gphoto2.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_gstreamer.cpp b/upstream/opencv/modules/videoio/src/cap_gstreamer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_gstreamer.cpp
rename to upstream/opencv/modules/videoio/src/cap_gstreamer.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_images.cpp b/upstream/opencv/modules/videoio/src/cap_images.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_images.cpp
rename to upstream/opencv/modules/videoio/src/cap_images.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_interface.hpp b/upstream/opencv/modules/videoio/src/cap_interface.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_interface.hpp
rename to upstream/opencv/modules/videoio/src/cap_interface.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ios_abstract_camera.mm b/upstream/opencv/modules/videoio/src/cap_ios_abstract_camera.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ios_abstract_camera.mm
rename to upstream/opencv/modules/videoio/src/cap_ios_abstract_camera.mm
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ios_photo_camera.mm b/upstream/opencv/modules/videoio/src/cap_ios_photo_camera.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ios_photo_camera.mm
rename to upstream/opencv/modules/videoio/src/cap_ios_photo_camera.mm
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ios_video_camera.mm b/upstream/opencv/modules/videoio/src/cap_ios_video_camera.mm
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ios_video_camera.mm
rename to upstream/opencv/modules/videoio/src/cap_ios_video_camera.mm
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_librealsense.cpp b/upstream/opencv/modules/videoio/src/cap_librealsense.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_librealsense.cpp
rename to upstream/opencv/modules/videoio/src/cap_librealsense.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_librealsense.hpp b/upstream/opencv/modules/videoio/src/cap_librealsense.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_librealsense.hpp
rename to upstream/opencv/modules/videoio/src/cap_librealsense.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_common.cpp b/upstream/opencv/modules/videoio/src/cap_mfx_common.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_common.cpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_common.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_common.hpp b/upstream/opencv/modules/videoio/src/cap_mfx_common.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_common.hpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_common.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_plugin.cpp b/upstream/opencv/modules/videoio/src/cap_mfx_plugin.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_plugin.cpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_plugin.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_reader.cpp b/upstream/opencv/modules/videoio/src/cap_mfx_reader.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_reader.cpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_reader.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_reader.hpp b/upstream/opencv/modules/videoio/src/cap_mfx_reader.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_reader.hpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_reader.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_writer.cpp b/upstream/opencv/modules/videoio/src/cap_mfx_writer.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_writer.cpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_writer.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_writer.hpp b/upstream/opencv/modules/videoio/src/cap_mfx_writer.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mfx_writer.hpp
rename to upstream/opencv/modules/videoio/src/cap_mfx_writer.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mjpeg_decoder.cpp b/upstream/opencv/modules/videoio/src/cap_mjpeg_decoder.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mjpeg_decoder.cpp
rename to upstream/opencv/modules/videoio/src/cap_mjpeg_decoder.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_mjpeg_encoder.cpp b/upstream/opencv/modules/videoio/src/cap_mjpeg_encoder.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_mjpeg_encoder.cpp
rename to upstream/opencv/modules/videoio/src/cap_mjpeg_encoder.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_msmf.cpp b/upstream/opencv/modules/videoio/src/cap_msmf.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_msmf.cpp
rename to upstream/opencv/modules/videoio/src/cap_msmf.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_msmf.hpp b/upstream/opencv/modules/videoio/src/cap_msmf.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_msmf.hpp
rename to upstream/opencv/modules/videoio/src/cap_msmf.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_interface.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_capture.cpp b/upstream/opencv/modules/videoio/src/cap_obsensor_capture.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_capture.cpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor_capture.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_capture.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor_capture.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_capture.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor_capture.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_liborbbec.cpp b/upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_liborbbec.cpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_liborbbec.hpp b/upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_obsensor_liborbbec.hpp
rename to upstream/opencv/modules/videoio/src/cap_obsensor_liborbbec.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_openni2.cpp b/upstream/opencv/modules/videoio/src/cap_openni2.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_openni2.cpp
rename to upstream/opencv/modules/videoio/src/cap_openni2.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_pvapi.cpp b/upstream/opencv/modules/videoio/src/cap_pvapi.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_pvapi.cpp
rename to upstream/opencv/modules/videoio/src/cap_pvapi.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ueye.cpp b/upstream/opencv/modules/videoio/src/cap_ueye.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ueye.cpp
rename to upstream/opencv/modules/videoio/src/cap_ueye.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_v4l.cpp b/upstream/opencv/modules/videoio/src/cap_v4l.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_v4l.cpp
rename to upstream/opencv/modules/videoio/src/cap_v4l.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp b/upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/CaptureFrameGrabber.hpp b/upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/CaptureFrameGrabber.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/CaptureFrameGrabber.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MFIncludes.hpp b/upstream/opencv/modules/videoio/src/cap_winrt/MFIncludes.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MFIncludes.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/MFIncludes.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaSink.hpp b/upstream/opencv/modules/videoio/src/cap_winrt/MediaSink.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaSink.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/MediaSink.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaStreamSink.cpp b/upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaStreamSink.cpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaStreamSink.hpp b/upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt/MediaStreamSink.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt/MediaStreamSink.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_bridge.cpp b/upstream/opencv/modules/videoio/src/cap_winrt_bridge.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_bridge.cpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_bridge.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_bridge.hpp b/upstream/opencv/modules/videoio/src/cap_winrt_bridge.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_bridge.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_bridge.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_capture.cpp b/upstream/opencv/modules/videoio/src/cap_winrt_capture.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_capture.cpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_capture.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_capture.hpp b/upstream/opencv/modules/videoio/src/cap_winrt_capture.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_capture.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_capture.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_video.cpp b/upstream/opencv/modules/videoio/src/cap_winrt_video.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_video.cpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_video.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_video.hpp b/upstream/opencv/modules/videoio/src/cap_winrt_video.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_winrt_video.hpp
rename to upstream/opencv/modules/videoio/src/cap_winrt_video.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_ximea.cpp b/upstream/opencv/modules/videoio/src/cap_ximea.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_ximea.cpp
rename to upstream/opencv/modules/videoio/src/cap_ximea.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/cap_xine.cpp b/upstream/opencv/modules/videoio/src/cap_xine.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/cap_xine.cpp
rename to upstream/opencv/modules/videoio/src/cap_xine.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/container_avi.cpp b/upstream/opencv/modules/videoio/src/container_avi.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/container_avi.cpp
rename to upstream/opencv/modules/videoio/src/container_avi.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/ffmpeg_codecs.hpp b/upstream/opencv/modules/videoio/src/ffmpeg_codecs.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/ffmpeg_codecs.hpp
rename to upstream/opencv/modules/videoio/src/ffmpeg_codecs.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/plugin_api.hpp b/upstream/opencv/modules/videoio/src/plugin_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/plugin_api.hpp
rename to upstream/opencv/modules/videoio/src/plugin_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/plugin_capture_api.hpp b/upstream/opencv/modules/videoio/src/plugin_capture_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/plugin_capture_api.hpp
rename to upstream/opencv/modules/videoio/src/plugin_capture_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/plugin_writer_api.hpp b/upstream/opencv/modules/videoio/src/plugin_writer_api.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/plugin_writer_api.hpp
rename to upstream/opencv/modules/videoio/src/plugin_writer_api.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/precomp.hpp b/upstream/opencv/modules/videoio/src/precomp.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/precomp.hpp
rename to upstream/opencv/modules/videoio/src/precomp.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/videoio_registry.cpp b/upstream/opencv/modules/videoio/src/videoio_registry.cpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/videoio_registry.cpp
rename to upstream/opencv/modules/videoio/src/videoio_registry.cpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/videoio_registry.hpp b/upstream/opencv/modules/videoio/src/videoio_registry.hpp
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/videoio_registry.hpp
rename to upstream/opencv/modules/videoio/src/videoio_registry.hpp
diff --git a/third_party/opencv-5.0.0/modules/videoio/src/wrl.h b/upstream/opencv/modules/videoio/src/wrl.h
similarity index 100%
rename from third_party/opencv-5.0.0/modules/videoio/src/wrl.h
rename to upstream/opencv/modules/videoio/src/wrl.h
diff --git a/upstream/sources.lock.toml b/upstream/sources.lock.toml
new file mode 100644
index 0000000..0782fc5
--- /dev/null
+++ b/upstream/sources.lock.toml
@@ -0,0 +1,8 @@
+[opencv]
+version = "5.0.0"
+tag = "5.0.0"
+repo = "https://github.com/opencv/opencv"
+url = "https://github.com/opencv/opencv/archive/refs/tags/5.0.0.tar.gz"
+sha256 = "b0528f5a1d379d59d4701cb28c36e22214cc51cf64594e5b56f2d3e6c0233095"
+path = "upstream/opencv"
+patches = []